diff --git a/.gitignore b/.gitignore index 6704566..adb2c19 100644 --- a/.gitignore +++ b/.gitignore @@ -80,7 +80,6 @@ typings/ # Nuxt.js build / generate output .nuxt -dist # Gatsby files .cache/ diff --git a/README.md b/README.md index 8175fe5..f6013dd 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,7 @@ This library implements following features: ## Demo -see `./demo` folder - -Regenerate demo using `browserify -r ./lib/kalman-filter.js:KalmanFilter -r ./script/demo/generate-noisy-observation.js:generateNoisyObservation -r ./script/demo/calculate-observation-covariance.js:calculateObservationCovariance > demo/kalman-filter.js` +See a demo in the web browser [here](http://piercus.github.io/kalman-filter) ## Installation diff --git a/demo/bikes.html b/demo/bikes.html index 898804f..c98fcca 100644 --- a/demo/bikes.html +++ b/demo/bikes.html @@ -3,85 +3,7 @@ Kalman Filter Demo on Bike Image - + @@ -97,53 +19,59 @@

Correction

+
+ + + + + - - - - - + + + + + + +
- - - - - - - + + - diff --git a/demo/dist/demo.js b/demo/dist/demo.js new file mode 100644 index 0000000..0a1b584 --- /dev/null +++ b/demo/dist/demo.js @@ -0,0 +1,1619 @@ +require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i> | ObservationCallback} stateProjection, +* @property {Array.Array.> | ObservationCallback} covariance +*/ + +/** +* @callback DynamicCallback +* @param {Object} opts +* @param {Number} opts.index +* @param {State} opts.predicted +* @param {Observation} opts.observation +*/ + +/** +* @typedef {Object} DynamicConfig +* @property {Number} dimension +* @property {Array.Array.> | DynamicCallback} transition, +* @property {Array.Array.> | DynamicCallback} covariance +*/ + +const defaultLogger = { + info: (...args) => console.log(...args), + debug: () => {}, + warn: (...args) => console.log(...args), + error: (...args) => console.log(...args) +}; + +/** +* @class +* @property {DynamicConfig} dynamic the system's dynamic model +* @property {ObservationConfig} observation the system's observation model +*@property logger a Winston-like logger +*/ +class CoreKalmanFilter { + /** + * @param {DynamicConfig} dynamic + * @param {ObservationConfig} observation the system's observation model + */ + + constructor({dynamic, observation, logger = defaultLogger}) { + this.dynamic = dynamic; + this.observation = observation; + this.logger = logger; + } + + getValue(fn, options) { + return (typeof (fn) === 'function' ? fn(options) : fn); + } + + getInitState() { + const {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init; + const initState = new State({ + mean: meanInit, + covariance: covarianceInit, + index: indexInit}); + return initState; + } + + /** + This will return the predicted covariance of a given previousCorrected State, this will help us to build the asymptoticState. + * @param {State} previousCorrected + * @returns{Array.>} + */ + + getPredictedCovariance({previousCorrected} = {}) { + previousCorrected = previousCorrected || this.getInitState(); + + const getValueOptions = {previousCorrected, index: previousCorrected.index}; + const d = this.getValue(this.dynamic.transition, getValueOptions); + const dTransposed = transpose(d); + const covarianceInter = matMul(d, previousCorrected.covariance); + const covariancePrevious = matMul(covarianceInter, dTransposed); + const dynCov = this.getValue(this.dynamic.covariance, getValueOptions); + + const covariance = add( + dynCov, + covariancePrevious + ); + return covariance; + } + + /** + This will return the new prediction, relatively to the dynamic model chosen + * @param {State} previousCorrected State relative to our dynamic model + * @returns{State} predicted State + */ + + predict({previousCorrected} = {}) { + previousCorrected = previousCorrected || this.getInitState(); + + State.check(previousCorrected, {dimension: this.dynamic.dimension}); + + const getValueOptions = {previousCorrected, index: previousCorrected.index}; + const d = this.getValue(this.dynamic.transition, getValueOptions); + + const mean = matMul(d, previousCorrected.mean); + + const covariance = this.getPredictedCovariance({previousCorrected}); + let index; + if (typeof (previousCorrected.index) === 'number') { + index = previousCorrected.index + 1; + } + else { + index = null; + } + + const predicted = new State({mean, covariance, index}); + this.logger.debug('Prediction done', predicted); + return predicted; + } + /** + This will return the new correction, taking into account the prediction made + and the observation of the sensor + * @param {State} predicted the previous State + * @returns{Array} kalmanGain + */ + + getGain({predicted, stateProjection}) { + const getValueOptions = {predicted, index: predicted.index}; + stateProjection = stateProjection || this.getValue(this.observation.stateProjection, getValueOptions); + const obsCovariance = this.getValue(this.observation.covariance, getValueOptions); + const stateProjTransposed = transpose(stateProjection); + const noiselessInnovation = matMul( + matMul(stateProjection, predicted.covariance), + stateProjTransposed + ); + const innovationCovariance = add(noiselessInnovation, obsCovariance); + const optimalKalmanGain = matMul( + matMul(predicted.covariance, stateProjTransposed), + invert(innovationCovariance) + ); + return optimalKalmanGain; + } + + /** + This will return the corrected covariance of a given predicted State, this will help us to build the asymptoticState. + * @param {State} predicted the previous State + * @returns{Array.>} + */ + + getCorrectedCovariance({predicted}) { + const getValueOptions = {predicted, index: predicted.index}; + const identity = getIdentity(predicted.covariance.length); + const stateProj = this.getValue(this.observation.stateProjection, getValueOptions); + const optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj}); + return matMul( + sub(identity, matMul(optimalKalmanGain, stateProj)), + predicted.covariance + ); + } + + /** + This will return the new correction, taking into account the prediction made + and the observation of the sensor + * @param {State} predicted the previous State + * @param {Array} observation the observation of the sensor + * @returns{State} corrected State of the Kalman Filter + */ + + correct({predicted, observation}) { + State.check(predicted, {dimension: this.dynamic.dimension}); + if (!observation) { + throw (new Error('no measure available')); + } + + const getValueOptions = {predicted, index: predicted.index}; + const stateProj = this.getValue(this.observation.stateProjection, getValueOptions); + + const optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj}); + const innovation = sub( + observation, + matMul(stateProj, predicted.mean) + ); + const mean = add( + predicted.mean, + matMul(optimalKalmanGain, innovation) + ); + if(isNaN(mean[0][0])){ + throw(new Error('Mean is NaN after correction')) + } + + const covariance = this.getCorrectedCovariance({predicted}); + const corrected = new State({mean, covariance, index: predicted.index}); + this.logger.debug('Correction done', corrected); + return corrected; + } +} + +module.exports = CoreKalmanFilter; + +},{"../lib/linalgebra/add.js":14,"../lib/linalgebra/identity.js":18,"../lib/linalgebra/invert.js":19,"../lib/linalgebra/mat-mul.js":20,"../lib/linalgebra/sub.js":22,"../lib/linalgebra/transpose.js":25,"./state.js":33}],10:[function(require,module,exports){ +const identity = require('../linalgebra/identity.js'); + +/** +*Creates a dynamic model, following constant acceleration model with respect with the dimensions provided in the observation parameters +* @param {DynamicConfig} dynamic +* @param {ObservationConfig} observation +* @returns {DynamicConfig} +*/ + +module.exports = function (dynamic, observation) { + const timeStep = dynamic.timeStep || 1; + const observedProjection = observation.observedProjection; + const stateProjection = observation.stateProjection; + const observationDimension = observation.dimension; + let dimension; + + if (stateProjection && Number.isInteger(stateProjection[0].length / 3)) { + dimension = observation.stateProjection[0].length; + } else if (observedProjection) { + dimension = observedProjection[0].length * 3; + } else if (observationDimension) { + dimension = observationDimension * 3; + } else { + throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter')); + } + + const baseDimension = dimension / 3; + // We construct the transition and covariance matrices + const transition = identity(dimension); + for (let i = 0; i < baseDimension; i++) { + transition[i][i + baseDimension] = timeStep; + transition[i][i + (2 * baseDimension)] = 0.5 * (timeStep ** 2); + transition[i + baseDimension][i + (2 * baseDimension)] = timeStep; + } + + const arrayCovariance = new Array(baseDimension).fill(1) + .concat(new Array(baseDimension).fill(timeStep * timeStep)) + .concat(new Array(baseDimension).fill(timeStep ** 4)); + const covariance = dynamic.covariance || arrayCovariance; + return Object.assign({}, dynamic, {dimension, transition, covariance}); +}; + +},{"../linalgebra/identity.js":18}],11:[function(require,module,exports){ +const identity = require('../linalgebra/identity.js'); +/** +*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters +* @param {DynamicConfig} dynamic +* @param {ObservationConfig} observation +* @returns {DynamicConfig} +*/ + +module.exports = function (dynamic, observation) { + let dimension = dynamic.dimension; + const observationDimension = observation.dimension; + const observedProjection = observation.observedProjection; + const stateProjection = observation.stateProjection; + let covariance = dynamic.covariance; + + if (!dynamic.dimension) { + if (observationDimension) { + dimension = observationDimension; + } else if (observedProjection) { + dimension = observedProjection[0].length; + } else if (stateProjection) { + dimension = stateProjection[0].length; + } + } + + const transition = identity(dimension); + covariance = covariance || identity(dimension); + return Object.assign({}, dynamic, {dimension, transition, covariance}); +}; + +},{"../linalgebra/identity.js":18}],12:[function(require,module,exports){ +const identity = require('../linalgebra/identity.js'); + +/** +*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters +* @param {DynamicConfig} dynamic +* @param {ObservationConfig} observation +* @returns {DynamicConfig} +*/ + +module.exports = function (dynamic, observation) { + const timeStep = dynamic.timeStep || 1; + const observedProjection = observation.observedProjection; + const stateProjection = observation.stateProjection; + const observationDimension = observation.dimension; + let dimension; + + if (stateProjection && Number.isInteger(stateProjection[0].length / 2)) { + dimension = observation.stateProjection[0].length; + } else if (observedProjection) { + dimension = observedProjection[0].length * 2; + } else if (observationDimension) { + dimension = observationDimension * 2; + } else { + throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter')); + } + + const baseDimension = dimension / 2; + // We construct the transition and covariance matrices + const transition = identity(dimension); + for (let i = 0; i < baseDimension; i++) { + transition[i][i + baseDimension] = timeStep; + } + + const arrayCovariance = new Array(baseDimension).fill(1).concat(new Array(baseDimension).fill(timeStep * timeStep)); + const covariance = dynamic.covariance || arrayCovariance; + return Object.assign({}, dynamic, {dimension, transition, covariance}); +}; + +},{"../linalgebra/identity.js":18}],13:[function(require,module,exports){ +const CoreKalmanFilter = require('./core-kalman-filter.js'); + +const arrayToMatrix = require('../lib/utils/array-to-matrix.js'); +const setDimensions = require('../lib/setup/set-dimensions.js'); +const checkDimensions = require('../lib/setup/check-dimensions.js'); +const buildStateProjection = require('../lib/setup/build-state-projection.js'); +const extendDynamicInit = require('../lib/setup/extend-dynamic-init.js'); +const modelCollection = require('./model-collection.js'); +const toFunction = require('../lib/utils/to-function.js'); +const deepAssign = require('../lib/utils/deep-assign.js'); +const polymorphMatrix = require('../lib/utils/polymorph-matrix.js'); +const State = require('./state.js'); +const distanceMat = require('../lib/linalgebra/distance-mat.js'); + +/** +*This function fills the given options by successively checking if it uses a registered model, +* it builds and checks the dynamic and observation dimensions, build the stateProjection if only observedProjection +*is given, and initialize dynamic.init +*@param {DynamicConfig} options.dynamic +*@param {ObservationConfig} options.observation +*/ + +const setupModelsParameters = function ({observation, dynamic}) { + if (typeof (observation.name) === 'string') { + observation = modelCollection.buildObservation(observation); + } + + if (typeof (dynamic.name) === 'string') { + dynamic = modelCollection.buildDynamic(dynamic, observation); + } + + const withDimensionOptions = setDimensions({observation, dynamic}); + const checkedDimensionOptions = checkDimensions(withDimensionOptions); + const buildStateProjectionOptions = buildStateProjection(checkedDimensionOptions); + return extendDynamicInit(buildStateProjectionOptions); +}; + +/** +*Returns the corresponding model without arrays as values but only functions +*@param {ObservationConfig} observation +*@param {DynamicConfig} dynamic +*@returns {ObservationConfig, DynamicConfig} model with respect of the Core Kalman Filter properties +*/ +const modelsParametersToCoreOptions = function (modelToBeChanged) { + const {observation, dynamic} = modelToBeChanged; + return deepAssign(modelToBeChanged, { + observation: { + stateProjection: toFunction(polymorphMatrix(observation.stateProjection)), + covariance: toFunction(polymorphMatrix(observation.covariance, {dimension: observation.dimension})) + }, + dynamic: { + transition: toFunction(polymorphMatrix(dynamic.transition)), + covariance: toFunction(polymorphMatrix(dynamic.covariance, {dimension: dynamic.dimension})) + } + }); +}; + +class KalmanFilter extends CoreKalmanFilter { + /** + * @param {DynamicConfig} options.dynamic + * @param {ObservationConfig} options.observation the system's observation model + */ + constructor(options) { + const modelsParameters = setupModelsParameters(options); + const coreOptions = modelsParametersToCoreOptions(modelsParameters); + + super(Object.assign({}, options, coreOptions)); + } + + correct({predicted, observation}) { + const coreObservation = arrayToMatrix({observation, dimension: this.observation.dimension}); + return super.correct({predicted, observation: coreObservation}); + } + + /** + *Performs the prediction and the correction steps + *@param {State} previousCorrected + *@param {>} observation + *@returns {Array.} the mean of the corrections + */ + + filter({previousCorrected, observation}) { + const predicted = super.predict({previousCorrected}); + return this.correct({predicted, observation}); + } + + /** +*Filters all the observations +*@param {Array.>} observations +*@returns {Array.} the mean of the corrections +*/ + filterAll(observations) { + const {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init; + let previousCorrected = new State({ + mean: meanInit, + covariance: covarianceInit, + index: indexInit}); + const results = []; + for (const observation of observations) { + const predicted = this.predict({previousCorrected}); + previousCorrected = this.correct({ + predicted, + observation + }); + results.push(previousCorrected.mean); + } + + return results; + } + + /** + * Returns an estimation of the asymptotic state covariance as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form + * in practice this can be used as a init.covariance value but is very costful calculation (that's why this is not made by default) + * @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance + * @return {>>} covariance + */ + asymptoticStateCovariance(limitIterations = 1e2, tolerance = 1e-6) { + let previousCorrected = super.getInitState(); + let predicted; + const results = []; + for (let i = 0; i < limitIterations; i++) { + let count = 0; + predicted = new State({covariance: super.getPredictedCovariance({previousCorrected})}); + previousCorrected = new State({covariance: super.getCorrectedCovariance({predicted})}); + results.push(previousCorrected.covariance); + for (let j = 1; j < 4; j++) { + if (distanceMat(previousCorrected.covariance, results[i - j]) < tolerance) { + count += 1; + } + } + + if (count === 3) { + return results[i]; + } + } + + throw (new Error('The state covariance does not converge asymptotically')); + } + + /** + * Returns an estimation of the asymptotic gain, as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form + * @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance + * @return {>>} gain + */ + asymptoticGain(tolerance = 1e-6) { + const asymptoticState = new State({covariance: this.asymptoticStateCovariance(tolerance)}); + return super.getGain({previousCorrected: asymptoticState}); + } +} + +module.exports = KalmanFilter; + +},{"../lib/linalgebra/distance-mat.js":16,"../lib/setup/build-state-projection.js":29,"../lib/setup/check-dimensions.js":30,"../lib/setup/extend-dynamic-init.js":31,"../lib/setup/set-dimensions.js":32,"../lib/utils/array-to-matrix.js":34,"../lib/utils/deep-assign.js":35,"../lib/utils/polymorph-matrix.js":36,"../lib/utils/to-function.js":37,"./core-kalman-filter.js":9,"./model-collection.js":27,"./state.js":33}],14:[function(require,module,exports){ +const elemWise = require('./elem-wise'); +/** +* Add matrixes together +* @param {...>} args list of matrix +* @returns {Array.>} sum +*/ +module.exports = function (...args) { + return elemWise(args, args2 => { + return args2.reduce((a, b) => a + b, 0); + }); +}; + +},{"./elem-wise":17}],15:[function(require,module,exports){ +const zeros = require('./zeros'); + +module.exports = function (mat) { + const result = zeros(mat.length, mat.length); + + for (const [i, element] of mat.entries()) { + result[i][i] = element; + } + + return result; +}; + +},{"./zeros":26}],16:[function(require,module,exports){ +const trace = require('./trace.js'); +const transpose = require('./transpose.js'); +const matSub = require('./sub.js'); +const matMul = require('./mat-mul.js'); +const sum = require('./sum.js'); + +// [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm ) +module.exports = function (array1, array2) { + if (typeof (array1) === 'undefined') { + return sum(array2); + } + + if (typeof (array2) === 'undefined') { + return sum(array1); + } + + const m = matSub(array1, array2); + const p = matMul(transpose(m), m); + return Math.sqrt(trace(p)); +}; + +},{"./mat-mul.js":20,"./sub.js":22,"./sum.js":23,"./trace.js":24,"./transpose.js":25}],17:[function(require,module,exports){ +/** +* @callback elemWiseCb +* @param {Array.} arr +* @param {Number} rowId +* @param {Number} colId +*/ +/** +* run a function on cell per cell for each Matrixes +* @param {>>} arrMatrixes list of matrixes +* @param {elemWiseCb} fn +* @returns {Array.>} resulting matrix +* @example +// this will do m1 + m2 + m3 + m4 on matrixes +elemWise([m1, m2, m3, m4], args2 => { + return args2.reduce((a, b) => a + b, 0); +}); +*/ + +module.exports = function (arrayMatrixes, fn) { + return arrayMatrixes[0].map((row, rowId) => { + return row.map((cell, colId) => { + const array = arrayMatrixes.map(m => m[rowId][colId]); + return fn(array, rowId, colId); + }); + }); +}; + + +},{}],18:[function(require,module,exports){ +module.exports = function (stateSize) { + const identityArray = []; + for (let i = 0; i < stateSize; i++) { + const rowIdentity = []; + for (let j = 0; j < stateSize; j++) { + if (i === j) { + rowIdentity.push(1); + } else { + rowIdentity.push(0); + } + } + + identityArray.push(rowIdentity); + } + + return identityArray; +}; + +},{}],19:[function(require,module,exports){ +const matrixInverse = require('matrix-inverse'); + +module.exports = function (m) { + return matrixInverse(m); +}; + +},{"matrix-inverse":39}],20:[function(require,module,exports){ +/** +* Multiply 2 matrixes together +* @param {>} m1 +* @param {>} m2 +* @returns {Array.>} +*/ +module.exports = function (m1, m2) { + // Console.log({m1, m2}); + const result = []; + for (let i = 0; i < m1.length; i++) { + result[i] = []; + for (let j = 0; j < m2[0].length; j++) { + let sum = 0; + for (let k = 0; k < m1[0].length; k++) { + sum += m1[i][k] * m2[k][j]; + } + + result[i][j] = sum; + } + } + + return result; +}; + +},{}],21:[function(require,module,exports){ +/** +*This function returns the stateProjection paded with zeros with respect to a given +*observedProjection +*@param {Array. | Array.>} array the array we need to pad +*@param {Number} dimension in our case, the dynamic dimension +*@returns {Array. | Array.>} paded array +*/ +module.exports = function (array, {dimension}) { + const l = array[0].length; + if (dimension < l) { + throw (new TypeError('Dynamic dimension does not match with observedProjection')); + } + + for (let i = 0; i < l; i++) { + for (let j = 0; j < dimension - l; j++) { + array[i].push(0); + } + } + + return array; +}; + +},{}],22:[function(require,module,exports){ +const elemWise = require('./elem-wise'); + +module.exports = function (...args) { + return elemWise(args, ([a, b]) => a - b); +}; + +},{"./elem-wise":17}],23:[function(require,module,exports){ +// Sum all the terms of a given matrix +module.exports = function (array) { + let s = 0; + for (let i = 0; i < array.length; i++) { + for (let j = 0; j < array.length; j++) { + s += array[i][j]; + } + } + + return s; +}; + +},{}],24:[function(require,module,exports){ +module.exports = function (array) { + let diag = 0; + for (const [row, element] of array.entries()) { + diag += element[row]; + } + + return diag; +}; + +},{}],25:[function(require,module,exports){ +module.exports = function (array) { + return array[0].map((col, i) => array.map(row => row[i])); +}; + +},{}],26:[function(require,module,exports){ +module.exports = function (rows, cols) { + return new Array(rows).fill(1).map(() => new Array(cols).fill(0)); +}; + +},{}],27:[function(require,module,exports){ +const registeredDynamicModels = { + 'constant-position': require('../lib/dynamic/constant-position.js'), + 'constant-speed': require('../lib/dynamic/constant-speed.js'), + 'constant-acceleration': require('../lib/dynamic/constant-acceleration.js') +}; +const registeredObservationModels = { + sensors: require('../lib/observation/sensor.js') +}; + +/** +*RegisterObservation enables to create a new observation model and stock it +* @param {String} name +* @callback fn the function corresponding to the desired model +*/ + +/** +*registerDynamic enables to create a new dynamic model and stocks it +* @param {String} name +* @callback fn the function corresponding to the desired model +*/ + +/** +*buildObservation enables to build a model given an observation configuration +* @param {ObservationConfig} observation +* @returns {ObservationConfig} the configuration with respect to the model +*/ + +/** +*buildDynamic enables to build a model given dynamic and observation configurations +* @param {DynamicConfig} dynamic +* @param {ObservationConfig} observation +* @returns {DynamicConfig} the dynamic configuration with respect to the model +*/ + +module.exports = { + registerObservation: (name, fn) => { + registeredObservationModels[name] = fn; + }, + registerDynamic: (name, fn) => { + registeredDynamicModels[name] = fn; + }, + buildObservation: observation => { + if (!registeredObservationModels[observation.name]) { + throw (new Error('The provided observation model name is not registered')); + } + + return registeredObservationModels[observation.name](observation); + }, + buildDynamic: (dynamic, observation) => { + if (!registeredDynamicModels[dynamic.name]) { + throw (new Error('The provided dynamic model name is not registered')); + } + + return registeredDynamicModels[dynamic.name](dynamic, observation); + } +}; + +},{"../lib/dynamic/constant-acceleration.js":10,"../lib/dynamic/constant-position.js":11,"../lib/dynamic/constant-speed.js":12,"../lib/observation/sensor.js":28}],28:[function(require,module,exports){ +const identity = require('../linalgebra/identity.js'); +const polymorphMatrix = require('../utils/polymorph-matrix.js'); + +/** +* @param {Number} sensorDimension +* @param {CovarianceParam} sensorCovariance +* @param {Number} nSensors +* @returns {ObservationConfig} +*/ + +module.exports = function (options) { + const {sensorDimension = 1, sensorCovariance = 1, nSensors = 1} = options; + const sensorsCovariance = polymorphMatrix(sensorCovariance, {dimension: sensorDimension}); + const oneSensorObservedProjection = identity(sensorDimension); + let concatenatedObservedProjection = []; + let concatenatedCovariance = []; + for (let i = 0; i < nSensors; i++) { + concatenatedObservedProjection = concatenatedObservedProjection.concat(oneSensorObservedProjection); + concatenatedCovariance = concatenatedCovariance.concat(sensorsCovariance); + } + + const formattedCovariance = polymorphMatrix(concatenatedCovariance, {dimension: nSensors * sensorDimension}); + return Object.assign({}, options, { + dimension: sensorDimension * nSensors, + observedProjection: concatenatedObservedProjection, + covariance: formattedCovariance + }); +}; + +},{"../linalgebra/identity.js":18,"../utils/polymorph-matrix.js":36}],29:[function(require,module,exports){ +const padWithZeros = require('../linalgebra/pad-with-zeros.js'); +const identity = require('../linalgebra/identity.js'); +/** +*Builds the stateProjection given an observedProjection +*@param {ObservationConfig} observation +*@param {DynamicConfig} dynamic +*@returns {ObservationConfig, DynamicConfig} the model containing the created stateProjection +*/ + +module.exports = function ({observation, dynamic}) { + const {observedProjection, stateProjection} = observation; + const observationDimension = observation.dimension; + const dynamicDimension = dynamic.dimension; + if (observedProjection && stateProjection) { + throw (new TypeError('You cannot use both observedProjection and stateProjection')); + } + + if (observedProjection) { + return { + observation: Object.assign({}, observation, { + stateProjection: padWithZeros(observedProjection, {dimension: dynamicDimension}) + }), + dynamic + }; + } + + if (observationDimension && dynamicDimension) { + const observationMatrix = identity(observationDimension); + return { + observation: Object.assign({}, observation, { + stateProjection: padWithZeros(observationMatrix, {dimension: dynamicDimension}) + }), + dynamic + }; + } + + return {observation, dynamic}; +}; + +},{"../linalgebra/identity.js":18,"../linalgebra/pad-with-zeros.js":21}],30:[function(require,module,exports){ +/** +*Verifies that dynamic.dimension and observation.dimension are set +*@param {ObservationConfig} observation +*@param {DynamicConfig} dynamic +*/ + +module.exports = function ({observation, dynamic}) { + const dynamicDimension = dynamic.dimension; + const observationDimension = observation.dimension; + if (!dynamicDimension || !observationDimension) { + throw (new TypeError('Dimension is not set')); + } + + return {observation, dynamic}; +}; + +},{}],31:[function(require,module,exports){ +const diag = require('../linalgebra/diag.js'); + +/** +*Initializes the dynamic.init when not given +*@param {ObservationConfig} observation +*@param {DynamicConfig} dynamic +*@returns {ObservationConfig, DynamicConfig} +*/ + +module.exports = function ({observation, dynamic}) { + if (!dynamic.init) { + const huge = 1e6; + const dynamicDimension = dynamic.dimension; + const meanArray = new Array(dynamicDimension).fill(0); + const covarianceArray = new Array(dynamicDimension).fill(huge); + const withInitOptions = { + observation, + dynamic: Object.assign({}, dynamic, { + init: { + mean: meanArray.map(element => [element]), + covariance: diag(covarianceArray) + } + }) + }; + return withInitOptions; + } + + return {observation, dynamic}; +}; + +},{"../linalgebra/diag.js":15}],32:[function(require,module,exports){ +/** +*Verifies that dimensions are matching and set dynamic.dimension and observation.dimension +* with respect of stateProjection and transition dimensions +*@param {ObservationConfig} observation +*@param {DynamicConfig} dynamic +*@returns {ObservationConfig, DynamicConfig} +*/ + +module.exports = function ({observation, dynamic}) { + const stateProjection = observation.stateProjection; + const transition = dynamic.transition; + const dynamicDimension = dynamic.dimension; + const observationDimension = observation.dimension; + + if (dynamicDimension && observationDimension && Array.isArray(stateProjection)) { + if (dynamicDimension !== stateProjection[0].length || observationDimension !== stateProjection.length) { + throw (new TypeError('stateProjection dimensions not matching with observation and dynamic dimensions')); + } + } + + if (dynamicDimension && Array.isArray(transition)) { + if (dynamicDimension !== transition.length) { + throw (new TypeError('transition dimension not matching with dynamic dimension')); + } + } + + if (Array.isArray(stateProjection)) { + return { + observation: Object.assign({}, observation, { + dimension: stateProjection.length + }), + dynamic: Object.assign({}, dynamic, { + dimension: stateProjection[0].length + }) + }; + } + + if (Array.isArray(transition)) { + return { + observation, + dynamic: Object.assign({}, dynamic, { + dimension: transition.length + }) + }; + } + + return {observation, dynamic}; +}; + +},{}],33:[function(require,module,exports){ +const checkMatrix = function (matrix, shape) { + if (matrix.reduce((a, b) => a.concat(b)).filter(a => Number.isNaN(a)).length > 0) { + throw (new Error('Matrix should not have a NaN')); + } + + if (shape) { + checkShape(matrix, shape); + } +}; + +const checkShape = function (matrix, shape) { + if (matrix.length !== shape[0]) { + throw (new Error('shape and length do not match')); + } + + if (shape.length > 1) { + return matrix.forEach(m => checkShape(m, shape.slice(1))); + } +}; + +/** + * @class + * Class representing a multi dimensionnal gaussian, with his mean and his covariance + * @property {Number} [index=0] the index of the State in the process, this is not mandatory for simple Kalman Filter, but is needed for most of the use case of extended kalman filter + * @property {Array.>} covariance square matrix of size dimension + * @property {Array.>} mean column matrix of size dimension x 1 + */ +class State { + constructor({mean, covariance, index}) { + this.mean = mean; + this.covariance = covariance; + this.index = index; + } + + /** + * Check the consistency of the State + */ + check() { + this.constructor.check(this); + } + + /** + * Check the consistency of the State's attributes + */ + + static check(state, {dimension = null} = {}) { + if (!(state instanceof State)) { + throw (new TypeError('The argument is not a state')); + } + + const {mean, covariance} = state; // Index + const meanDimension = mean.length; + if (typeof (dimension) === 'number' && meanDimension !== dimension) { + throw (new Error(`${meanDimension} and ${dimension} are not the same`)); + } + + checkMatrix(mean, [meanDimension, 1]); + checkMatrix(covariance, [meanDimension, meanDimension]); + + // If (typeof (index) !== 'number') { + // throw (new TypeError('t must be a number')); + // } + } +} + +module.exports = State; + +},{}],34:[function(require,module,exports){ +/** +*Returns the corresponding matrix in dim*1, given an dim matrix, and checks +* if corresponding with the observation dimension +*@param {Array. | Array.>} observation +*@param {Number} dimension +*@returns {Array.>} +*/ + +module.exports = function ({observation, dimension}) { + if (!Array.isArray(observation)) { + throw (new TypeError('The observation should be an array')); + } + + if (observation.length !== dimension) { + throw (new TypeError('Observation and dimension not matching')); + } + + if (typeof (observation[0]) === 'number') { + return observation.map(element => [element]); + } + + return observation; +}; + +},{}],35:[function(require,module,exports){ +const uniq = require('./uniq.js'); +const limit = 100; + +/** +*Equivalent to the Object.assign methode, takes several arguments and creates a new object corresponding to the assignment of the arguments +* @param {Object} args +* @param {Number} step +*/ +const deepAssign = function (args, step) { + if (step > limit) { + throw (new Error(`In deepAssign, number of recursive call (${step}) reached limit (${limit}), deepAssign is not working on self-referencing objects`)); + } + + const filterArguments = args.filter(arg => typeof (arg) !== 'undefined' && arg !== null); + const lastArgument = filterArguments[filterArguments.length - 1]; + if (filterArguments.length === 1) { + return filterArguments[0]; + } + + if (typeof (lastArgument) !== 'object' || Array.isArray(lastArgument)) { + return lastArgument; + } + + if (filterArguments.length === 0) { + return null; + } + + const objectsArguments = filterArguments.filter(arg => typeof (arg) === 'object'); + let keys = []; + objectsArguments.forEach(arg => { + keys = keys.concat(Object.keys(arg)); + }); + const uniqKeys = uniq(keys); + const result = {}; + uniqKeys.forEach(key => { + const values = objectsArguments.map(arg => arg[key]); + result[key] = deepAssign(values, step + 1); + }); + return result; +}; + +module.exports = ((...args) => deepAssign(args, 0)); + +},{"./uniq.js":38}],36:[function(require,module,exports){ +/** +* @typedef {Number | Array. | Array.>} CovarianceParam +*/ +const diag = require('../linalgebra/diag'); +/** +* If cov is a number, result will be Identity*cov +* If cov is an Array., result will be diag(cov) +* If cov is an Array.>, result will be cov +* @param {CovarianceParam} cov +* @param {Number} dimension +* @returns {Array.>} +*/ +module.exports = function (array, {dimension} = {}) { + if (typeof (array) === 'number' || Array.isArray(array)) { + if (typeof (array) === 'number' && typeof (dimension) === 'number') { + return diag(new Array(dimension).fill(array)); + } + + if ((Array.isArray(array)) && (Array.isArray(array[0]))) { + return array; + } + + if ((Array.isArray(array)) && (typeof (array[0]) === 'number')) { + return diag(array); + } + } + + return array; +}; + +},{"../linalgebra/diag":15}],37:[function(require,module,exports){ +// Const diag = require('../linalgebra/diag.js'); + +/** +* @callback MatrixCallback +* @returns > +*/ + +/** +* Tranforms: +** a 2d array into a function (() => array) +** a 1d array into a function (() => diag(array)) +*@param {Array. | Array.>} array +*@returns {MatrixCallback} +*/ + +module.exports = function (array) { + if (typeof (array) === 'function') { + return array; + } + + if (Array.isArray(array)) { + return function () { + return array; + }; + } + + throw (new Error('Only arrays and functions are authorized')); +}; + +},{}],38:[function(require,module,exports){ +module.exports = function (array) { + return array.filter((value, index) => + array.indexOf(value) === index + ); +}; + +},{}],39:[function(require,module,exports){ +var Sylvester = {} + +Sylvester.Matrix = function() {} + +Sylvester.Matrix.create = function(elements) { + var M = new Sylvester.Matrix() + return M.setElements(elements) +} + +Sylvester.Matrix.I = function(n) { + var els = [], + i = n, + j + while (i--) { + j = n + els[i] = [] + while (j--) { + els[i][j] = i === j ? 1 : 0 + } + } + return Sylvester.Matrix.create(els) +} + +Sylvester.Matrix.prototype = { + dup: function() { + return Sylvester.Matrix.create(this.elements) + }, + + isSquare: function() { + var cols = this.elements.length === 0 ? 0 : this.elements[0].length + return this.elements.length === cols + }, + + toRightTriangular: function() { + if (this.elements.length === 0) return Sylvester.Matrix.create([]) + var M = this.dup(), + els + var n = this.elements.length, + i, + j, + np = this.elements[0].length, + p + for (i = 0; i < n; i++) { + if (M.elements[i][i] === 0) { + for (j = i + 1; j < n; j++) { + if (M.elements[j][i] !== 0) { + els = [] + for (p = 0; p < np; p++) { + els.push(M.elements[i][p] + M.elements[j][p]) + } + M.elements[i] = els + break + } + } + } + if (M.elements[i][i] !== 0) { + for (j = i + 1; j < n; j++) { + var multiplier = M.elements[j][i] / M.elements[i][i] + els = [] + for (p = 0; p < np; p++) { + // Elements with column numbers up to an including the number of the + // row that we're subtracting can safely be set straight to zero, + // since that's the point of this routine and it avoids having to + // loop over and correct rounding errors later + els.push( + p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier + ) + } + M.elements[j] = els + } + } + } + return M + }, + + determinant: function() { + if (this.elements.length === 0) { + return 1 + } + if (!this.isSquare()) { + return null + } + var M = this.toRightTriangular() + var det = M.elements[0][0], + n = M.elements.length + for (var i = 1; i < n; i++) { + det = det * M.elements[i][i] + } + return det + }, + + isSingular: function() { + return this.isSquare() && this.determinant() === 0 + }, + + augment: function(matrix) { + if (this.elements.length === 0) { + return this.dup() + } + var M = matrix.elements || matrix + if (typeof M[0][0] === 'undefined') { + M = Sylvester.Matrix.create(M).elements + } + var T = this.dup(), + cols = T.elements[0].length + var i = T.elements.length, + nj = M[0].length, + j + if (i !== M.length) { + return null + } + while (i--) { + j = nj + while (j--) { + T.elements[i][cols + j] = M[i][j] + } + } + return T + }, + + inverse: function() { + if (this.elements.length === 0) { + return null + } + if (!this.isSquare() || this.isSingular()) { + return null + } + var n = this.elements.length, + i = n, + j + var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular() + var np = M.elements[0].length, + p, + els, + divisor + var inverse_elements = [], + new_element + // Sylvester.Matrix is non-singular so there will be no zeros on the + // diagonal. Cycle through rows from last to first. + while (i--) { + // First, normalise diagonal elements to 1 + els = [] + inverse_elements[i] = [] + divisor = M.elements[i][i] + for (p = 0; p < np; p++) { + new_element = M.elements[i][p] / divisor + els.push(new_element) + // Shuffle off the current row of the right hand side into the results + // array as it will not be modified by later runs through this loop + if (p >= n) { + inverse_elements[i].push(new_element) + } + } + M.elements[i] = els + // Then, subtract this row from those above it to give the identity matrix + // on the left hand side + j = i + while (j--) { + els = [] + for (p = 0; p < np; p++) { + els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i]) + } + M.elements[j] = els + } + } + return Sylvester.Matrix.create(inverse_elements) + }, + + setElements: function(els) { + var i, + j, + elements = els.elements || els + if (elements[0] && typeof elements[0][0] !== 'undefined') { + i = elements.length + this.elements = [] + while (i--) { + j = elements[i].length + this.elements[i] = [] + while (j--) { + this.elements[i][j] = elements[i][j] + } + } + return this + } + var n = elements.length + this.elements = [] + for (i = 0; i < n; i++) { + this.elements.push([elements[i]]) + } + return this + }, +} + +module.exports = function(elements) { + return Sylvester.Matrix.create(elements).inverse().elements +} + +},{}],"main":[function(require,module,exports){ +const KalmanFilter = require('../../lib/kalman-filter'); + +const noisyObservations = require('./observations.json').observations; +const kfOptions = require('./kf-options.js'); +const createElement = require('./views/create-element'); +const createGroupBoxes = require('./views/create-group-boxes'); + +const kf = new KalmanFilter(kfOptions); +let predicted = kf.predict(); + +const img = document.querySelector('#bikes');// eslint-disable-line no-undef + +// Create all the elements of the prediction or correction phase +const delay = 100; + +let promise = Promise.resolve(); +let previousCorrected = null; + +const delayPromise = delay => new Promise(resolve => setTimeout(resolve, delay)); + +module.exports = { + run(){ + noisyObservations.forEach((box, index) => { + promise = promise + .then(() => { + predicted = kf.predict({previousCorrected}); + const {mean, covariance} = predicted; + + createGroupBoxes({mean, covariance, parent: img, className: 'predicted', color: 'blue'}); + + return delayPromise(delay); + }) + .then((b => { + createElement({ + className: 'observation', + bbox: [ + b[0] + (b[2] / 2), + b[1] + (b[3] / 2), + b[2], + b[3] + ], + parent: img, + color: 'white', + lineStyle: 'solid' + }); + + return delayPromise(delay); + }).bind(null, box, index)) + .then((b => { + previousCorrected = kf.correct({predicted, observation: b}); + const {mean, covariance} = previousCorrected; + + createGroupBoxes({mean, covariance, parent: img, className: 'corrected', color: 'red'}); + + return delayPromise(delay); + }).bind(null, box, index)); + }) + } +} + + +},{"../../lib/kalman-filter":13,"./kf-options.js":1,"./observations.json":3,"./views/create-element":6,"./views/create-group-boxes":7}]},{},[]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../.nvm/versions/node/v12.18.0/lib/node_modules/browserify/node_modules/browser-pack/_prelude.js","demo/src/kf-options.js","demo/src/observation-covariance.json","demo/src/observations.json","demo/src/views/create-arrow.js","demo/src/views/create-custom-dashed-line.js","demo/src/views/create-element.js","demo/src/views/create-group-boxes.js","demo/src/views/create-point.js","lib/core-kalman-filter.js","lib/dynamic/constant-acceleration.js","lib/dynamic/constant-position.js","lib/dynamic/constant-speed.js","lib/kalman-filter.js","lib/linalgebra/add.js","lib/linalgebra/diag.js","lib/linalgebra/distance-mat.js","lib/linalgebra/elem-wise.js","lib/linalgebra/identity.js","lib/linalgebra/invert.js","lib/linalgebra/mat-mul.js","lib/linalgebra/pad-with-zeros.js","lib/linalgebra/sub.js","lib/linalgebra/sum.js","lib/linalgebra/trace.js","lib/linalgebra/transpose.js","lib/linalgebra/zeros.js","lib/model-collection.js","lib/observation/sensor.js","lib/setup/build-state-projection.js","lib/setup/check-dimensions.js","lib/setup/extend-dynamic-init.js","lib/setup/set-dimensions.js","lib/state.js","lib/utils/array-to-matrix.js","lib/utils/deep-assign.js","lib/utils/polymorph-matrix.js","lib/utils/to-function.js","lib/utils/uniq.js","node_modules/matrix-inverse/matrix-inverse.js","demo/src/main.js"],"names":[],"mappings":"AAAA;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;;AC5DA;;ACAA;;ACAA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;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;;ACrBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;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;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;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;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","const observationCovariance = require('./observation-covariance.json');\nconst posVar = 100;\nconst timeStep = 0.2;\nconst sizeVar = 1;\n\nmodule.exports = {\n\tobservation: {\n\t\tdimension: 4,\n\t\tstateProjection: [\n\t\t\t[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t\t[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t\t[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t\t[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]\n\t\t],\n\t\t// Covariance generated thanks to getCovariance\n\t\tcovariance: observationCovariance\n\t\t// Covariance: [posVar, posVar, posVar, posVar],\n\n\t},\n\n\tdynamic: {\n\t\tname: 'constant-acceleration',\n\t\ttimeStep: 0.2,\n\t\t// Init: {\n\t\t// \tmean: [[943], [385], [75], [65], [-200], [-200], [0], [0], [-20], [-20], [0], [0]],\n\t\t//\n\t\t// \tcovariance: [\n\t\t// \t\t[huge, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, huge, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, huge, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, huge, 0, 0, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, huge, 0, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, huge, 0, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, huge, 0, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, 0, huge, 0, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, 0, 0, huge, 0, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, 0, 0, 0, huge, 0, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, huge, 0],\n\t\t// \t\t[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, huge],\n\t\t// \t]\n\t\t// },\n\n\t\tdimension: 12,\n\n\t\tcovariance: [\n\t\t\tposVar,\n\t\t\tposVar,\n\t\t\tsizeVar,\n\t\t\tsizeVar,\n\t\t\tposVar * timeStep * timeStep,\n\t\t\tposVar * timeStep * timeStep,\n\t\t\tsizeVar * timeStep * timeStep,\n\t\t\tsizeVar * timeStep * timeStep,\n\t\t\tposVar * (timeStep ** 4),\n\t\t\tposVar * (timeStep ** 4),\n\t\t\tsizeVar * (timeStep ** 4),\n\t\t\tsizeVar * (timeStep ** 4)\n\t\t]\n\t}\n};\n","module.exports=[[34.31428571428572,-8.114285714285714,-9.185714285714285,3.0428571428571427],[-8.114285714285714,39.08571428571429,1.1857142857142857,-5.5285714285714285],[-9.185714285714285,1.1857142857142857,34.628571428571426,0.7857142857142857],[3.0428571428571427,-5.5285714285714285,0.7857142857142857,39.857142857142854]]","module.exports={\"observations\":[[842,286,82,81],[714,184,92,80],[560,107,112,116],[418,94,96,110],[277,141,89,89],[146,200,88,72],[22,306,77,82]]}","module.exports = function ({className, tag = 'div', bbox, parent, rotationCoefficient, scale, color}) {\n\tconst element = document.createElement(tag);// eslint-disable-line no-undef\n\telement.id = 'arrow';\n\telement.className = className;\n\telement.style.top = Math.round(bbox[1]) + 'px';\n\telement.style.left = Math.round(bbox[0]) + 'px';\n\tif (rotationCoefficient) {\n\t\telement.style.transform = `rotate(${rotationCoefficient}deg)`;\n\t\telement.style.transformOrigin = '-5px 12px';\n\t}\n\n\telement.style.scale = scale;\n\telement.style.color = color;\n\tparent.append(element);\n\treturn element;\n};\n","module.exports = function ({\n\tclassName,\n\ttag = 'div',\n\tbbox,\n\tparent,\n\tcolor,\n\tpercentage,\n\tposition = 'vertical'\n}) {\n\t// Bbox contains 3 elements: left, top and bottom of the dashed line or top, left and right\n\tconst element = document.createElement(tag);// eslint-disable-line no-undef\n\t// If (color) {\n\t// \tel.style.backgroundColor = color\n\t// }\n\telement.className = className;\n\tif (position === 'vertical') {\n\t\telement.style.width = 1 + 'px';\n\t\telement.style.height = Math.abs(bbox[1] - bbox[2]) + 'px';\n\t\telement.style.top = bbox[1] + 'px';\n\t\telement.style.left = bbox[0] + 'px';\n\t}\n\n\tif (position === 'horizontal') {\n\t\telement.style.height = 1 + 'px';\n\t\telement.style.width = Math.abs(bbox[1] - bbox[2]) + 'px';\n\t\telement.style.left = bbox[1] + 'px';\n\t\telement.style.top = bbox[0] + 'px';\n\t}\n\n\t// El.style.opacity = 1-percentage\n\tconst urlString = 'data:image/svg+xml,%3csvg ' +\n\t\t'width=\\'100%25\\' ' +\n\t\t'height=\\'100%25\\' ' +\n\t\t'xmlns=\\'http://www.w3.org/2000/svg\\'%3e%3crect ' +\n\t\t'width=\\'100%25\\' ' +\n\t\t'height=\\'100%25\\' ' +\n\t\t'fill=\\'none\\' ' +\n\t\t`stroke='${color}' ` +\n\t\t'stroke-width=\\'4\\' ' +\n\t\t`stroke-dasharray='10%2c${Math.floor(percentage * 100)}' ` +\n\t\t'stroke-dashoffset=\\'0\\' ' +\n\t\t'stroke-linecap=\\'round\\'/%3e%3c/svg%3e';\n\n\tconst backgroundImage1 = `url(\"${urlString}\")`;\n\n\t// Const backgroundImage2 = \"url(\\\"data:image/svg+xml,%3csvg width='100%25' height='100%25' xmlns='http://www.w3.org/2000/svg'%3e%3crect width='100%25' height='100%25' fill='none' stroke='%23333' stroke-width='4' stroke-dasharray='10%2c20' stroke-dashoffset='0' stroke-linecap='square'/%3e%3c/svg%3e\\\")\"\n\t// console.log(backgroundImage1, backgroundImage2, backgroundImage1===backgroundImage2)\n\telement.style.backgroundImage = backgroundImage1;\n\tparent.append(element);\n\treturn element;\n};\n","module.exports = function ({id, className, tag = 'div', bbox, parent, rotationCoefficient}) {\n\tconst element = document.createElement(tag);// eslint-disable-line no-undef\n\telement.className = className;\n\telement.id = id;\n\t// If (color && lineStyle) {\n\t// \tel.style.border = `1px ${lineStyle} ${color}`\n\t// }\n\telement.style.width = Math.round(bbox[2]) + 'px';\n\telement.style.height = Math.round(bbox[3]) + 'px';\n\telement.style.top = Math.round(bbox[1] - (bbox[3] / 2)) + 'px';\n\telement.style.left = Math.round(bbox[0] - (bbox[2] / 2)) + 'px';\n\tif (rotationCoefficient) {\n\t\telement.style.transform = `rotate(${rotationCoefficient}deg)`;\n\t}\n\n\tparent.append(element);\n\treturn element;\n};\n","const createElement = require('./create-element');\nconst createPoint = require('./create-point');\nconst createArrow = require('./create-arrow');\nconst createCustomDashedLine = require('./create-custom-dashed-line');\n\nmodule.exports = function ({mean, covariance, color, parent, className, tag = 'div'}) {\n\tconst container = document.createElement(tag); // eslint-disable-line no-undef\n\n\tcontainer.className = className;\n\tconst center = [mean[0][0] + (mean[2][0] / 2), mean[1][0] + (mean[3][0] / 2)];\n\tcreateElement({\n\t\tclassName: 'box',\n\t\tbbox: [center[0], center[1], mean[2][0], mean[3][0]],\n\t\tparent: container,\n\t\tcolor,\n\t\tlineStyle: 'solid'\n\t});\n\tcreateElement({\n\t\tclassName: 'box stdDev',\n\t\tbbox: [\n\t\t\tcenter[0],\n\t\t\tcenter[1],\n\t\t\tmean[2][0] + (2 * 3 * Math.sqrt(covariance[2][2])),\n\t\t\tmean[3][0] + (2 * 3 * Math.sqrt(covariance[3][3]))\n\t\t],\n\t\tparent: container,\n\t\tcolor\n\t});\n\tcreatePoint({\n\t\tbbox: [center[0], center[1], 2, 2],\n\t\tparent: container,\n\t\tcolor\n\t});\n\tconst correlationXY = covariance[0][1] / (Math.sqrt(covariance[0][0]) * Math.sqrt(covariance[1][1]));\n\tcreateElement({\n\t\tclassName: 'ellipse stdDev',\n\t\tbbox: [\n\t\t\tcenter[0],\n\t\t\tcenter[1],\n\t\t\t2 * 3 * Math.sqrt(covariance[0][0]),\n\t\t\t2 * 3 * Math.sqrt(covariance[1][1])\n\t\t],\n\t\tparent: container,\n\t\trotationCoefficient: correlationXY,\n\t\tcolor\n\t});\n\tconst correlationXW = covariance[0][2] / (Math.sqrt(covariance[0][0]) * Math.sqrt(covariance[2][2]));\n\tcreateCustomDashedLine({\n\t\tclassName: 'dashedLine',\n\t\tbbox: [\n\t\t\tcenter[0],\n\t\t\tcenter[1] + (3 * Math.sqrt(covariance[1][1])),\n\t\t\tcenter[1] + (mean[3][0] / 2) + (3 * Math.sqrt(covariance[3][3]))\n\t\t],\n\t\tparent: container,\n\t\tpercentage: Math.abs(correlationXW),\n\t\tcolor\n\t});\n\tconst correlationYH = covariance[1][3] / (Math.sqrt(covariance[1][1]) * Math.sqrt(covariance[3][3]));\n\tcreateCustomDashedLine({\n\t\tclassName: 'dashedLine',\n\t\tbbox: [\n\t\t\tcenter[1],\n\t\t\tcenter[0] + (3 * Math.sqrt(covariance[0][0])),\n\t\t\tcenter[0] + (mean[2][0] / 2) + (3 * Math.sqrt(covariance[2][2]))\n\t\t],\n\t\tparent: container,\n\t\tpercentage: Math.abs(correlationYH),\n\t\tposition: 'horizontal',\n\t\tcolor\n\t});\n\tconst arrowRotation = (-1 * Math.atan(mean[4][0] / mean[5][0]) * 180 / Math.PI) - 45;\n\tconst arrowScale = Math.sqrt((mean[4][0] ** 2) + (mean[5][0] ** 2));\n\tcreateArrow({\n\t\tclassName: 'arrow',\n\t\tbbox: [\n\t\t\tcenter[0] + 6,\n\t\t\tcenter[1] - 9\n\t\t],\n\t\tparent: container,\n\t\trotationCoefficient: arrowRotation,\n\t\tscale: arrowScale,\n\t\tcolor\n\t});\n\tparent.append(container);\n};\n","module.exports = function ({className = 'point', tag = 'div', bbox, parent}) {\n\tconst element = document.createElement(tag);// eslint-disable-line no-undef\n\telement.className = className;\n\t// If (color) {\n\t// \tel.style.border = `2px solid ${color}`,\n\t// \tel.style.backgroundColor = `${color}`\n\t// }\n\telement.style.width = Math.round(bbox[2]) + 'px';\n\telement.style.height = Math.round(bbox[3]) + 'px';\n\telement.style.top = Math.round(bbox[1] - (bbox[3] / 2)) + 'px';\n\telement.style.left = Math.round(bbox[0] - (bbox[2] / 2)) + 'px';\n\tparent.append(element);\n\treturn element;\n};\n","const matMul = require('../lib/linalgebra/mat-mul.js');\nconst transpose = require('../lib/linalgebra/transpose.js');\nconst add = require('../lib/linalgebra/add.js');\nconst invert = require('../lib/linalgebra/invert.js');\nconst sub = require('../lib/linalgebra/sub.js');\nconst getIdentity = require('../lib/linalgebra/identity.js');\nconst State = require('./state.js');\n\n/**\n* @callback ObservationCallback\n* @param {Object} opts\n* @param {Number} opts.index\n* @param {Number} opts.previousCorrected\n*/\n\n/**\n* @typedef {Object} ObservationConfig\n* @property {Number} dimension\n* @property {Array.Array.<Number>> | ObservationCallback} stateProjection,\n* @property {Array.Array.<Number>> | ObservationCallback} covariance\n*/\n\n/**\n* @callback DynamicCallback\n* @param {Object} opts\n* @param {Number} opts.index\n* @param {State} opts.predicted\n* @param {Observation} opts.observation\n*/\n\n/**\n* @typedef {Object} DynamicConfig\n* @property {Number} dimension\n* @property {Array.Array.<Number>> | DynamicCallback} transition,\n* @property {Array.Array.<Number>> | DynamicCallback} covariance\n*/\n\nconst defaultLogger = {\n\tinfo: (...args) => console.log(...args),\n\tdebug: () => {},\n\twarn: (...args) => console.log(...args),\n\terror: (...args) => console.log(...args)\n};\n\n/**\n* @class\n* @property {DynamicConfig} dynamic the system's dynamic model\n* @property {ObservationConfig} observation the system's observation model\n*@property logger a Winston-like logger\n*/\nclass CoreKalmanFilter {\n\t/**\n\t* @param {DynamicConfig} dynamic\n\t* @param {ObservationConfig} observation the system's observation model\n\t*/\n\n\tconstructor({dynamic, observation, logger = defaultLogger}) {\n\t\tthis.dynamic = dynamic;\n\t\tthis.observation = observation;\n\t\tthis.logger = logger;\n\t}\n\n\tgetValue(fn, options) {\n\t\treturn (typeof (fn) === 'function' ? fn(options) : fn);\n\t}\n\n\tgetInitState() {\n\t\tconst {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init;\n\t\tconst initState = new State({\n\t\t\tmean: meanInit,\n\t\t\tcovariance: covarianceInit,\n\t\t\tindex: indexInit});\n\t\treturn initState;\n\t}\n\n\t/**\n\tThis will return the predicted covariance of a given previousCorrected State, this will help us to build the asymptoticState.\n\t* @param {State} previousCorrected\n\t* @returns{Array.<Array.<Number>>}\n\t*/\n\n\tgetPredictedCovariance({previousCorrected} = {}) {\n\t\tpreviousCorrected = previousCorrected || this.getInitState();\n\n\t\tconst getValueOptions = {previousCorrected, index: previousCorrected.index};\n\t\tconst d = this.getValue(this.dynamic.transition, getValueOptions);\n\t\tconst dTransposed = transpose(d);\n\t\tconst covarianceInter = matMul(d, previousCorrected.covariance);\n\t\tconst covariancePrevious = matMul(covarianceInter, dTransposed);\n\t\tconst dynCov = this.getValue(this.dynamic.covariance, getValueOptions);\n\n\t\tconst covariance = add(\n\t\t\tdynCov,\n\t\t\tcovariancePrevious\n\t\t);\n\t\treturn covariance;\n\t}\n\n\t/**\n\tThis will return the new prediction, relatively to the dynamic model chosen\n\t* @param {State} previousCorrected State relative to our dynamic model\n\t* @returns{State} predicted State\n\t*/\n\n\tpredict({previousCorrected} = {}) {\n\t\tpreviousCorrected = previousCorrected || this.getInitState();\n\n\t\tState.check(previousCorrected, {dimension: this.dynamic.dimension});\n\n\t\tconst getValueOptions = {previousCorrected, index: previousCorrected.index};\n\t\tconst d = this.getValue(this.dynamic.transition, getValueOptions);\n\n\t\tconst mean = matMul(d, previousCorrected.mean);\n\n\t\tconst covariance = this.getPredictedCovariance({previousCorrected});\n\t\tlet index;\n\t\tif (typeof (previousCorrected.index) === 'number') {\n\t\t\tindex = previousCorrected.index + 1;\n\t\t}\n\t\telse {\n\t\t\tindex = null;\n\t\t}\n\n\t\tconst predicted = new State({mean, covariance, index});\n\t\tthis.logger.debug('Prediction done', predicted);\n\t\treturn predicted;\n\t}\n\t/**\n\tThis will return the new correction, taking into account the prediction made\n\tand the observation of the sensor\n\t* @param {State} predicted the previous State\n\t* @returns{Array<Array>} kalmanGain\n\t*/\n\n\tgetGain({predicted, stateProjection}) {\n\t\tconst getValueOptions = {predicted, index: predicted.index};\n\t\tstateProjection = stateProjection || this.getValue(this.observation.stateProjection, getValueOptions);\n\t\tconst obsCovariance = this.getValue(this.observation.covariance, getValueOptions);\n\t\tconst stateProjTransposed = transpose(stateProjection);\n\t\tconst noiselessInnovation = matMul(\n\t\t\tmatMul(stateProjection, predicted.covariance),\n\t\t\tstateProjTransposed\n\t\t);\n\t\tconst innovationCovariance = add(noiselessInnovation, obsCovariance);\n\t\tconst optimalKalmanGain = matMul(\n\t\t\tmatMul(predicted.covariance, stateProjTransposed),\n\t\t\tinvert(innovationCovariance)\n\t\t);\n\t\treturn optimalKalmanGain;\n\t}\n\n\t/**\n\tThis will return the corrected covariance of a given predicted State, this will help us to build the asymptoticState.\n\t* @param {State} predicted the previous State\n\t* @returns{Array.<Array.<Number>>}\n\t*/\n\n\tgetCorrectedCovariance({predicted}) {\n\t\tconst getValueOptions = {predicted, index: predicted.index};\n\t\tconst identity = getIdentity(predicted.covariance.length);\n\t\tconst stateProj = this.getValue(this.observation.stateProjection, getValueOptions);\n\t\tconst optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj});\n\t\treturn matMul(\n\t\t\tsub(identity, matMul(optimalKalmanGain, stateProj)),\n\t\t\tpredicted.covariance\n\t\t);\n\t}\n\n\t/**\n\tThis will return the new correction, taking into account the prediction made\n\tand the observation of the sensor\n\t* @param {State} predicted the previous State\n\t* @param {Array} observation the observation of the sensor\n\t* @returns{State} corrected State of the Kalman Filter\n\t*/\n\n\tcorrect({predicted, observation}) {\n\t\tState.check(predicted, {dimension: this.dynamic.dimension});\n\t\tif (!observation) {\n\t\t\tthrow (new Error('no measure available'));\n\t\t}\n\n\t\tconst getValueOptions = {predicted, index: predicted.index};\n\t\tconst stateProj = this.getValue(this.observation.stateProjection, getValueOptions);\n\n\t\tconst optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj});\n\t\tconst innovation = sub(\n\t\t\tobservation,\n\t\t\tmatMul(stateProj, predicted.mean)\n\t\t);\n\t\tconst mean = add(\n\t\t\tpredicted.mean,\n\t\t\tmatMul(optimalKalmanGain, innovation)\n\t\t);\n\t\tif(isNaN(mean[0][0])){\n\t\t\tthrow(new Error('Mean is NaN after correction'))\n\t\t}\n\n\t\tconst covariance = this.getCorrectedCovariance({predicted});\n\t\tconst corrected = new State({mean, covariance, index: predicted.index});\n\t\tthis.logger.debug('Correction done', corrected);\n\t\treturn corrected;\n\t}\n}\n\nmodule.exports = CoreKalmanFilter;\n","const identity = require('../linalgebra/identity.js');\n\n/**\n*Creates a dynamic model, following constant acceleration model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tconst timeStep = dynamic.timeStep || 1;\n\tconst observedProjection = observation.observedProjection;\n\tconst stateProjection = observation.stateProjection;\n\tconst observationDimension = observation.dimension;\n\tlet dimension;\n\n\tif (stateProjection && Number.isInteger(stateProjection[0].length / 3)) {\n\t\tdimension = observation.stateProjection[0].length;\n\t} else if (observedProjection) {\n\t\tdimension = observedProjection[0].length * 3;\n\t} else if (observationDimension) {\n\t\tdimension = observationDimension * 3;\n\t} else {\n\t\tthrow (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));\n\t}\n\n\tconst baseDimension = dimension / 3;\n\t// We construct the transition and covariance matrices\n\tconst transition = identity(dimension);\n\tfor (let i = 0; i < baseDimension; i++) {\n\t\ttransition[i][i + baseDimension] = timeStep;\n\t\ttransition[i][i + (2 * baseDimension)] = 0.5 * (timeStep ** 2);\n\t\ttransition[i + baseDimension][i + (2 * baseDimension)] = timeStep;\n\t}\n\n\tconst arrayCovariance = new Array(baseDimension).fill(1)\n\t\t.concat(new Array(baseDimension).fill(timeStep * timeStep))\n\t\t.concat(new Array(baseDimension).fill(timeStep ** 4));\n\tconst covariance = dynamic.covariance || arrayCovariance;\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","const identity = require('../linalgebra/identity.js');\n/**\n*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tlet dimension = dynamic.dimension;\n\tconst observationDimension = observation.dimension;\n\tconst observedProjection = observation.observedProjection;\n\tconst stateProjection = observation.stateProjection;\n\tlet covariance = dynamic.covariance;\n\n\tif (!dynamic.dimension) {\n\t\tif (observationDimension) {\n\t\t\tdimension = observationDimension;\n\t\t} else if (observedProjection) {\n\t\t\tdimension = observedProjection[0].length;\n\t\t} else if (stateProjection) {\n\t\t\tdimension = stateProjection[0].length;\n\t\t}\n\t}\n\n\tconst transition = identity(dimension);\n\tcovariance = covariance || identity(dimension);\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","const identity = require('../linalgebra/identity.js');\n\n/**\n*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig}\n*/\n\nmodule.exports = function (dynamic, observation) {\n\tconst timeStep = dynamic.timeStep || 1;\n\tconst observedProjection = observation.observedProjection;\n\tconst stateProjection = observation.stateProjection;\n\tconst observationDimension = observation.dimension;\n\tlet dimension;\n\n\tif (stateProjection && Number.isInteger(stateProjection[0].length / 2)) {\n\t\tdimension = observation.stateProjection[0].length;\n\t} else if (observedProjection) {\n\t\tdimension = observedProjection[0].length * 2;\n\t} else if (observationDimension) {\n\t\tdimension = observationDimension * 2;\n\t} else {\n\t\tthrow (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter'));\n\t}\n\n\tconst baseDimension = dimension / 2;\n\t// We construct the transition and covariance matrices\n\tconst transition = identity(dimension);\n\tfor (let i = 0; i < baseDimension; i++) {\n\t\ttransition[i][i + baseDimension] = timeStep;\n\t}\n\n\tconst arrayCovariance = new Array(baseDimension).fill(1).concat(new Array(baseDimension).fill(timeStep * timeStep));\n\tconst covariance = dynamic.covariance || arrayCovariance;\n\treturn Object.assign({}, dynamic, {dimension, transition, covariance});\n};\n","const CoreKalmanFilter = require('./core-kalman-filter.js');\n\nconst arrayToMatrix = require('../lib/utils/array-to-matrix.js');\nconst setDimensions = require('../lib/setup/set-dimensions.js');\nconst checkDimensions = require('../lib/setup/check-dimensions.js');\nconst buildStateProjection = require('../lib/setup/build-state-projection.js');\nconst extendDynamicInit = require('../lib/setup/extend-dynamic-init.js');\nconst modelCollection = require('./model-collection.js');\nconst toFunction = require('../lib/utils/to-function.js');\nconst deepAssign = require('../lib/utils/deep-assign.js');\nconst polymorphMatrix = require('../lib/utils/polymorph-matrix.js');\nconst State = require('./state.js');\nconst distanceMat = require('../lib/linalgebra/distance-mat.js');\n\n/**\n*This function fills the given options by successively checking if it uses a registered model,\n* it builds and checks the dynamic and observation dimensions, build the stateProjection if only observedProjection\n*is given, and initialize dynamic.init\n*@param {DynamicConfig} options.dynamic\n*@param {ObservationConfig} options.observation\n*/\n\nconst setupModelsParameters = function ({observation, dynamic}) {\n\tif (typeof (observation.name) === 'string') {\n\t\tobservation = modelCollection.buildObservation(observation);\n\t}\n\n\tif (typeof (dynamic.name) === 'string') {\n\t\tdynamic = modelCollection.buildDynamic(dynamic, observation);\n\t}\n\n\tconst withDimensionOptions = setDimensions({observation, dynamic});\n\tconst checkedDimensionOptions = checkDimensions(withDimensionOptions);\n\tconst buildStateProjectionOptions = buildStateProjection(checkedDimensionOptions);\n\treturn extendDynamicInit(buildStateProjectionOptions);\n};\n\n/**\n*Returns the corresponding model without arrays as values but only functions\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig} model with respect of the Core Kalman Filter properties\n*/\nconst modelsParametersToCoreOptions = function (modelToBeChanged) {\n\tconst {observation, dynamic} = modelToBeChanged;\n\treturn deepAssign(modelToBeChanged, {\n\t\tobservation: {\n\t\t\tstateProjection: toFunction(polymorphMatrix(observation.stateProjection)),\n\t\t\tcovariance: toFunction(polymorphMatrix(observation.covariance, {dimension: observation.dimension}))\n\t\t},\n\t\tdynamic: {\n\t\t\ttransition: toFunction(polymorphMatrix(dynamic.transition)),\n\t\t\tcovariance: toFunction(polymorphMatrix(dynamic.covariance, {dimension: dynamic.dimension}))\n\t\t}\n\t});\n};\n\nclass KalmanFilter extends CoreKalmanFilter {\n\t/**\n\t* @param {DynamicConfig} options.dynamic\n\t* @param {ObservationConfig} options.observation the system's observation model\n\t*/\n\tconstructor(options) {\n\t\tconst modelsParameters = setupModelsParameters(options);\n\t\tconst coreOptions = modelsParametersToCoreOptions(modelsParameters);\n\n\t\tsuper(Object.assign({}, options, coreOptions));\n\t}\n\n\tcorrect({predicted, observation}) {\n\t\tconst coreObservation = arrayToMatrix({observation, dimension: this.observation.dimension});\n\t\treturn super.correct({predicted, observation: coreObservation});\n\t}\n\n\t/**\n\t*Performs the prediction and the correction steps\n\t*@param {State} previousCorrected\n\t*@param {<Array.<Number>>} observation\n\t*@returns {Array.<Number>} the mean of the corrections\n\t*/\n\n\tfilter({previousCorrected, observation}) {\n\t\tconst predicted = super.predict({previousCorrected});\n\t\treturn this.correct({predicted, observation});\n\t}\n\n\t/**\n*Filters all the observations\n*@param {Array.<Array.<Number>>} observations\n*@returns {Array.<Number>} the mean of the corrections\n*/\n\tfilterAll(observations) {\n\t\tconst {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init;\n\t\tlet previousCorrected = new State({\n\t\t\tmean: meanInit,\n\t\t\tcovariance: covarianceInit,\n\t\t\tindex: indexInit});\n\t\tconst results = [];\n\t\tfor (const observation of observations) {\n\t\t\tconst predicted = this.predict({previousCorrected});\n\t\t\tpreviousCorrected = this.correct({\n\t\t\t\tpredicted,\n\t\t\t\tobservation\n\t\t\t});\n\t\t\tresults.push(previousCorrected.mean);\n\t\t}\n\n\t\treturn results;\n\t}\n\n\t/**\n\t* Returns an estimation of the asymptotic state covariance as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form\n\t* in practice this can be used as a init.covariance value but is very costful calculation (that's why this is not made by default)\n\t* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance\n\t* @return {<Array.<Array.<Number>>>} covariance\n\t*/\n\tasymptoticStateCovariance(limitIterations = 1e2, tolerance = 1e-6) {\n\t\tlet previousCorrected = super.getInitState();\n\t\tlet predicted;\n\t\tconst results = [];\n\t\tfor (let i = 0; i < limitIterations; i++) {\n\t\t\tlet count = 0;\n\t\t\tpredicted = new State({covariance: super.getPredictedCovariance({previousCorrected})});\n\t\t\tpreviousCorrected = new State({covariance: super.getCorrectedCovariance({predicted})});\n\t\t\tresults.push(previousCorrected.covariance);\n\t\t\tfor (let j = 1; j < 4; j++) {\n\t\t\t\tif (distanceMat(previousCorrected.covariance, results[i - j]) < tolerance) {\n\t\t\t\t\tcount += 1;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (count === 3) {\n\t\t\t\treturn results[i];\n\t\t\t}\n\t\t}\n\n\t\tthrow (new Error('The state covariance does not converge asymptotically'));\n\t}\n\n\t/**\n\t* Returns an estimation of the asymptotic gain, as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form\n\t* @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance\n\t* @return {<Array.<Array.<Number>>>} gain\n\t*/\n\tasymptoticGain(tolerance = 1e-6) {\n\t\tconst asymptoticState = new State({covariance: this.asymptoticStateCovariance(tolerance)});\n\t\treturn super.getGain({previousCorrected: asymptoticState});\n\t}\n}\n\nmodule.exports = KalmanFilter;\n","const elemWise = require('./elem-wise');\n/**\n* Add matrixes together\n* @param {...<Array.<Array.<Number>>} args list of matrix\n* @returns {Array.<Array.<Number>>} sum\n*/\nmodule.exports = function (...args) {\n\treturn elemWise(args, args2 => {\n\t\treturn args2.reduce((a, b) => a + b, 0);\n\t});\n};\n","const zeros = require('./zeros');\n\nmodule.exports = function (mat) {\n\tconst result = zeros(mat.length, mat.length);\n\n\tfor (const [i, element] of mat.entries()) {\n\t\tresult[i][i] = element;\n\t}\n\n\treturn result;\n};\n","const trace = require('./trace.js');\nconst transpose = require('./transpose.js');\nconst matSub = require('./sub.js');\nconst matMul = require('./mat-mul.js');\nconst sum = require('./sum.js');\n\n// [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm )\nmodule.exports = function (array1, array2) {\n\tif (typeof (array1) === 'undefined') {\n\t\treturn sum(array2);\n\t}\n\n\tif (typeof (array2) === 'undefined') {\n\t\treturn sum(array1);\n\t}\n\n\tconst m = matSub(array1, array2);\n\tconst p = matMul(transpose(m), m);\n\treturn Math.sqrt(trace(p));\n};\n","/**\n* @callback elemWiseCb\n* @param {Array.<Number>} arr\n* @param {Number} rowId\n* @param {Number} colId\n*/\n/**\n* run a function on cell per cell for each Matrixes\n* @param {<Array.<Array.<Array.<Number>>>} arrMatrixes list of matrixes\n* @param {elemWiseCb} fn\n* @returns {Array.<Array.<Number>>} resulting matrix\n* @example\n// this will do m1 + m2 + m3 + m4 on matrixes\nelemWise([m1, m2, m3, m4], args2 => {\n\treturn args2.reduce((a, b) => a + b, 0);\n});\n*/\n\nmodule.exports = function (arrayMatrixes, fn) {\n\treturn arrayMatrixes[0].map((row, rowId) => {\n\t\treturn row.map((cell, colId) => {\n\t\t\tconst array = arrayMatrixes.map(m => m[rowId][colId]);\n\t\t\treturn fn(array, rowId, colId);\n\t\t});\n\t});\n};\n\n","module.exports = function (stateSize) {\n\tconst identityArray = [];\n\tfor (let i = 0; i < stateSize; i++) {\n\t\tconst rowIdentity = [];\n\t\tfor (let j = 0; j < stateSize; j++) {\n\t\t\tif (i === j) {\n\t\t\t\trowIdentity.push(1);\n\t\t\t} else {\n\t\t\t\trowIdentity.push(0);\n\t\t\t}\n\t\t}\n\n\t\tidentityArray.push(rowIdentity);\n\t}\n\n\treturn identityArray;\n};\n","const matrixInverse = require('matrix-inverse');\n\nmodule.exports = function (m) {\n\treturn matrixInverse(m);\n};\n","/**\n* Multiply 2 matrixes together\n* @param {<Array.<Array.<Number>>} m1\n* @param {<Array.<Array.<Number>>} m2\n* @returns {Array.<Array.<Number>>}\n*/\nmodule.exports = function (m1, m2) {\n\t// Console.log({m1, m2});\n\tconst result = [];\n\tfor (let i = 0; i < m1.length; i++) {\n\t\tresult[i] = [];\n\t\tfor (let j = 0; j < m2[0].length; j++) {\n\t\t\tlet sum = 0;\n\t\t\tfor (let k = 0; k < m1[0].length; k++) {\n\t\t\t\tsum += m1[i][k] * m2[k][j];\n\t\t\t}\n\n\t\t\tresult[i][j] = sum;\n\t\t}\n\t}\n\n\treturn result;\n};\n","/**\n*This function returns the stateProjection paded with zeros with respect to a given\n*observedProjection\n*@param {Array.<Number> | Array.<Array.<Number>>} array the array we need to pad\n*@param {Number} dimension in our case, the dynamic dimension\n*@returns {Array.<Number> | Array.<Array.<Number>>} paded array\n*/\nmodule.exports = function (array, {dimension}) {\n\tconst l = array[0].length;\n\tif (dimension < l) {\n\t\tthrow (new TypeError('Dynamic dimension does not match with observedProjection'));\n\t}\n\n\tfor (let i = 0; i < l; i++) {\n\t\tfor (let j = 0; j < dimension - l; j++) {\n\t\t\tarray[i].push(0);\n\t\t}\n\t}\n\n\treturn array;\n};\n","const elemWise = require('./elem-wise');\n\nmodule.exports = function (...args) {\n\treturn elemWise(args, ([a, b]) => a - b);\n};\n","// Sum all the terms of a given matrix\nmodule.exports = function (array) {\n\tlet s = 0;\n\tfor (let i = 0; i < array.length; i++) {\n\t\tfor (let j = 0; j < array.length; j++) {\n\t\t\ts += array[i][j];\n\t\t}\n\t}\n\n\treturn s;\n};\n","module.exports = function (array) {\n\tlet diag = 0;\n\tfor (const [row, element] of array.entries()) {\n\t\tdiag += element[row];\n\t}\n\n\treturn diag;\n};\n","module.exports = function (array) {\n\treturn array[0].map((col, i) => array.map(row => row[i]));\n};\n","module.exports = function (rows, cols) {\n\treturn new Array(rows).fill(1).map(() => new Array(cols).fill(0));\n};\n","const registeredDynamicModels = {\n\t'constant-position': require('../lib/dynamic/constant-position.js'),\n\t'constant-speed': require('../lib/dynamic/constant-speed.js'),\n\t'constant-acceleration': require('../lib/dynamic/constant-acceleration.js')\n};\nconst registeredObservationModels = {\n\tsensors: require('../lib/observation/sensor.js')\n};\n\n/**\n*RegisterObservation enables to create a new observation model and stock it\n* @param {String} name\n* @callback fn the function corresponding to the desired model\n*/\n\n/**\n*registerDynamic enables to create a new dynamic model and stocks it\n* @param {String} name\n* @callback fn the function corresponding to the desired model\n*/\n\n/**\n*buildObservation enables to build a model given an observation configuration\n* @param {ObservationConfig} observation\n* @returns {ObservationConfig} the configuration with respect to the model\n*/\n\n/**\n*buildDynamic enables to build a model given dynamic and observation configurations\n* @param {DynamicConfig} dynamic\n* @param {ObservationConfig} observation\n* @returns {DynamicConfig} the dynamic configuration with respect to the model\n*/\n\nmodule.exports = {\n\tregisterObservation: (name, fn) => {\n\t\tregisteredObservationModels[name] = fn;\n\t},\n\tregisterDynamic: (name, fn) => {\n\t\tregisteredDynamicModels[name] = fn;\n\t},\n\tbuildObservation: observation => {\n\t\tif (!registeredObservationModels[observation.name]) {\n\t\t\tthrow (new Error('The provided observation model name is not registered'));\n\t\t}\n\n\t\treturn registeredObservationModels[observation.name](observation);\n\t},\n\tbuildDynamic: (dynamic, observation) => {\n\t\tif (!registeredDynamicModels[dynamic.name]) {\n\t\t\tthrow (new Error('The provided dynamic model name is not registered'));\n\t\t}\n\n\t\treturn registeredDynamicModels[dynamic.name](dynamic, observation);\n\t}\n};\n","const identity = require('../linalgebra/identity.js');\nconst polymorphMatrix = require('../utils/polymorph-matrix.js');\n\n/**\n* @param {Number} sensorDimension\n* @param {CovarianceParam} sensorCovariance\n* @param {Number} nSensors\n* @returns {ObservationConfig}\n*/\n\nmodule.exports = function (options) {\n\tconst {sensorDimension = 1, sensorCovariance = 1, nSensors = 1} = options;\n\tconst sensorsCovariance = polymorphMatrix(sensorCovariance, {dimension: sensorDimension});\n\tconst oneSensorObservedProjection = identity(sensorDimension);\n\tlet concatenatedObservedProjection = [];\n\tlet concatenatedCovariance = [];\n\tfor (let i = 0; i < nSensors; i++) {\n\t\tconcatenatedObservedProjection = concatenatedObservedProjection.concat(oneSensorObservedProjection);\n\t\tconcatenatedCovariance = concatenatedCovariance.concat(sensorsCovariance);\n\t}\n\n\tconst formattedCovariance = polymorphMatrix(concatenatedCovariance, {dimension: nSensors * sensorDimension});\n\treturn Object.assign({}, options, {\n\t\tdimension: sensorDimension * nSensors,\n\t\tobservedProjection: concatenatedObservedProjection,\n\t\tcovariance: formattedCovariance\n\t});\n};\n","const padWithZeros = require('../linalgebra/pad-with-zeros.js');\nconst identity = require('../linalgebra/identity.js');\n/**\n*Builds the stateProjection given an observedProjection\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig} the model containing the created stateProjection\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst {observedProjection, stateProjection} = observation;\n\tconst observationDimension = observation.dimension;\n\tconst dynamicDimension = dynamic.dimension;\n\tif (observedProjection && stateProjection) {\n\t\tthrow (new TypeError('You cannot use both observedProjection and stateProjection'));\n\t}\n\n\tif (observedProjection) {\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tstateProjection: padWithZeros(observedProjection, {dimension: dynamicDimension})\n\t\t\t}),\n\t\t\tdynamic\n\t\t};\n\t}\n\n\tif (observationDimension && dynamicDimension) {\n\t\tconst observationMatrix = identity(observationDimension);\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tstateProjection: padWithZeros(observationMatrix, {dimension: dynamicDimension})\n\t\t\t}),\n\t\t\tdynamic\n\t\t};\n\t}\n\n\treturn {observation, dynamic};\n};\n","/**\n*Verifies that dynamic.dimension and observation.dimension are set\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst dynamicDimension = dynamic.dimension;\n\tconst observationDimension = observation.dimension;\n\tif (!dynamicDimension || !observationDimension) {\n\t\tthrow (new TypeError('Dimension is not set'));\n\t}\n\n\treturn {observation, dynamic};\n};\n","const diag = require('../linalgebra/diag.js');\n\n/**\n*Initializes the dynamic.init when not given\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig}\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tif (!dynamic.init) {\n\t\tconst huge = 1e6;\n\t\tconst dynamicDimension = dynamic.dimension;\n\t\tconst meanArray = new Array(dynamicDimension).fill(0);\n\t\tconst covarianceArray = new Array(dynamicDimension).fill(huge);\n\t\tconst withInitOptions = {\n\t\t\tobservation,\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tinit: {\n\t\t\t\t\tmean: meanArray.map(element => [element]),\n\t\t\t\t\tcovariance: diag(covarianceArray)\n\t\t\t\t}\n\t\t\t})\n\t\t};\n\t\treturn withInitOptions;\n\t}\n\n\treturn {observation, dynamic};\n};\n","/**\n*Verifies that dimensions are matching and set dynamic.dimension and observation.dimension\n* with respect of stateProjection and transition dimensions\n*@param {ObservationConfig} observation\n*@param {DynamicConfig} dynamic\n*@returns {ObservationConfig, DynamicConfig}\n*/\n\nmodule.exports = function ({observation, dynamic}) {\n\tconst stateProjection = observation.stateProjection;\n\tconst transition = dynamic.transition;\n\tconst dynamicDimension = dynamic.dimension;\n\tconst observationDimension = observation.dimension;\n\n\tif (dynamicDimension && observationDimension && Array.isArray(stateProjection)) {\n\t\tif (dynamicDimension !== stateProjection[0].length || observationDimension !== stateProjection.length) {\n\t\t\tthrow (new TypeError('stateProjection dimensions not matching with observation and dynamic dimensions'));\n\t\t}\n\t}\n\n\tif (dynamicDimension && Array.isArray(transition)) {\n\t\tif (dynamicDimension !== transition.length) {\n\t\t\tthrow (new TypeError('transition dimension not matching with dynamic dimension'));\n\t\t}\n\t}\n\n\tif (Array.isArray(stateProjection)) {\n\t\treturn {\n\t\t\tobservation: Object.assign({}, observation, {\n\t\t\t\tdimension: stateProjection.length\n\t\t\t}),\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tdimension: stateProjection[0].length\n\t\t\t})\n\t\t};\n\t}\n\n\tif (Array.isArray(transition)) {\n\t\treturn {\n\t\t\tobservation,\n\t\t\tdynamic: Object.assign({}, dynamic, {\n\t\t\t\tdimension: transition.length\n\t\t\t})\n\t\t};\n\t}\n\n\treturn {observation, dynamic};\n};\n","const checkMatrix = function (matrix, shape) {\n\tif (matrix.reduce((a, b) => a.concat(b)).filter(a => Number.isNaN(a)).length > 0) {\n\t\tthrow (new Error('Matrix should not have a NaN'));\n\t}\n\n\tif (shape) {\n\t\tcheckShape(matrix, shape);\n\t}\n};\n\nconst checkShape = function (matrix, shape) {\n\tif (matrix.length !== shape[0]) {\n\t\tthrow (new Error('shape and length do not match'));\n\t}\n\n\tif (shape.length > 1) {\n\t\treturn matrix.forEach(m => checkShape(m, shape.slice(1)));\n\t}\n};\n\n/**\n * @class\n * Class representing a multi dimensionnal gaussian, with his mean and his covariance\n * @property {Number} [index=0] the index of the State in the process, this is not mandatory for simple Kalman Filter, but is needed for most of the use case of extended kalman filter\n * @property {Array.<Array.<Number>>} covariance square matrix of size dimension\n * @property {Array.<Array<Number>>} mean column matrix of size dimension x 1\n */\nclass State {\n\tconstructor({mean, covariance, index}) {\n\t\tthis.mean = mean;\n\t\tthis.covariance = covariance;\n\t\tthis.index = index;\n\t}\n\n\t/**\n\t* Check the consistency of the State\n\t*/\n\tcheck() {\n\t\tthis.constructor.check(this);\n\t}\n\n\t/**\n\t* Check the consistency of the State's attributes\n\t*/\n\n\tstatic check(state, {dimension = null} = {}) {\n\t\tif (!(state instanceof State)) {\n\t\t\tthrow (new TypeError('The argument is not a state'));\n\t\t}\n\n\t\tconst {mean, covariance} = state; // Index\n\t\tconst meanDimension = mean.length;\n\t\tif (typeof (dimension) === 'number' && meanDimension !== dimension) {\n\t\t\tthrow (new Error(`${meanDimension} and ${dimension} are not the same`));\n\t\t}\n\n\t\tcheckMatrix(mean, [meanDimension, 1]);\n\t\tcheckMatrix(covariance, [meanDimension, meanDimension]);\n\n\t\t// If (typeof (index) !== 'number') {\n\t\t// \tthrow (new TypeError('t must be a number'));\n\t\t// }\n\t}\n}\n\nmodule.exports = State;\n","/**\n*Returns the corresponding matrix in dim*1, given an dim matrix, and checks\n* if corresponding with the observation dimension\n*@param {Array.<Number> | Array.<Array.<Number>>} observation\n*@param {Number} dimension\n*@returns {Array.<Array.<Number>>}\n*/\n\nmodule.exports = function ({observation, dimension}) {\n\tif (!Array.isArray(observation)) {\n\t\tthrow (new TypeError('The observation should be an array'));\n\t}\n\n\tif (observation.length !== dimension) {\n\t\tthrow (new TypeError('Observation and dimension not matching'));\n\t}\n\n\tif (typeof (observation[0]) === 'number') {\n\t\treturn observation.map(element => [element]);\n\t}\n\n\treturn observation;\n};\n","const uniq = require('./uniq.js');\nconst limit = 100;\n\n/**\n*Equivalent to the Object.assign methode, takes several arguments and creates a new object corresponding to the assignment of the arguments\n* @param {Object} args\n* @param {Number} step\n*/\nconst deepAssign = function (args, step) {\n\tif (step > limit) {\n\t\tthrow (new Error(`In deepAssign, number of recursive call (${step}) reached limit (${limit}), deepAssign is not working on  self-referencing objects`));\n\t}\n\n\tconst filterArguments = args.filter(arg => typeof (arg) !== 'undefined' && arg !== null);\n\tconst lastArgument = filterArguments[filterArguments.length - 1];\n\tif (filterArguments.length === 1) {\n\t\treturn filterArguments[0];\n\t}\n\n\tif (typeof (lastArgument) !== 'object' || Array.isArray(lastArgument)) {\n\t\treturn lastArgument;\n\t}\n\n\tif (filterArguments.length === 0) {\n\t\treturn null;\n\t}\n\n\tconst objectsArguments = filterArguments.filter(arg => typeof (arg) === 'object');\n\tlet keys = [];\n\tobjectsArguments.forEach(arg => {\n\t\tkeys = keys.concat(Object.keys(arg));\n\t});\n\tconst uniqKeys = uniq(keys);\n\tconst result = {};\n\tuniqKeys.forEach(key => {\n\t\tconst values = objectsArguments.map(arg => arg[key]);\n\t\tresult[key] = deepAssign(values, step + 1);\n\t});\n\treturn result;\n};\n\nmodule.exports = ((...args) => deepAssign(args, 0));\n","/**\n* @typedef {Number | Array.<Number> | Array.<Array.<Number>>} CovarianceParam\n*/\nconst diag = require('../linalgebra/diag');\n/**\n* If cov is a number, result will be Identity*cov\n* If cov is an Array.<Number>, result will be diag(cov)\n* If cov is an Array.<Array.<Number>>, result will be cov\n* @param {CovarianceParam} cov\n* @param {Number} dimension\n* @returns {Array.<Array.<Number>>}\n*/\nmodule.exports = function (array, {dimension} = {}) {\n\tif (typeof (array) === 'number' || Array.isArray(array)) {\n\t\tif (typeof (array) === 'number' && typeof (dimension) === 'number') {\n\t\t\treturn diag(new Array(dimension).fill(array));\n\t\t}\n\n\t\tif ((Array.isArray(array)) && (Array.isArray(array[0]))) {\n\t\t\treturn array;\n\t\t}\n\n\t\tif ((Array.isArray(array)) && (typeof (array[0]) === 'number')) {\n\t\t\treturn diag(array);\n\t\t}\n\t}\n\n\treturn array;\n};\n","// Const diag = require('../linalgebra/diag.js');\n\n/**\n* @callback MatrixCallback\n* @returns <Array.<Array.<Number>>\n*/\n\n/**\n* Tranforms:\n** a 2d array into a function (() => array)\n** a 1d array into a function (() => diag(array))\n*@param {Array.<Number> | Array.<Array.<Number>>} array\n*@returns {MatrixCallback}\n*/\n\nmodule.exports = function (array) {\n\tif (typeof (array) === 'function') {\n\t\treturn array;\n\t}\n\n\tif (Array.isArray(array)) {\n\t\treturn function () {\n\t\t\treturn array;\n\t\t};\n\t}\n\n\tthrow (new Error('Only arrays and functions are authorized'));\n};\n","module.exports = function (array) {\n\treturn array.filter((value, index) =>\n\t\tarray.indexOf(value) === index\n\t);\n};\n","var Sylvester = {}\n\nSylvester.Matrix = function() {}\n\nSylvester.Matrix.create = function(elements) {\n  var M = new Sylvester.Matrix()\n  return M.setElements(elements)\n}\n\nSylvester.Matrix.I = function(n) {\n  var els = [],\n    i = n,\n    j\n  while (i--) {\n    j = n\n    els[i] = []\n    while (j--) {\n      els[i][j] = i === j ? 1 : 0\n    }\n  }\n  return Sylvester.Matrix.create(els)\n}\n\nSylvester.Matrix.prototype = {\n  dup: function() {\n    return Sylvester.Matrix.create(this.elements)\n  },\n\n  isSquare: function() {\n    var cols = this.elements.length === 0 ? 0 : this.elements[0].length\n    return this.elements.length === cols\n  },\n\n  toRightTriangular: function() {\n    if (this.elements.length === 0) return Sylvester.Matrix.create([])\n    var M = this.dup(),\n      els\n    var n = this.elements.length,\n      i,\n      j,\n      np = this.elements[0].length,\n      p\n    for (i = 0; i < n; i++) {\n      if (M.elements[i][i] === 0) {\n        for (j = i + 1; j < n; j++) {\n          if (M.elements[j][i] !== 0) {\n            els = []\n            for (p = 0; p < np; p++) {\n              els.push(M.elements[i][p] + M.elements[j][p])\n            }\n            M.elements[i] = els\n            break\n          }\n        }\n      }\n      if (M.elements[i][i] !== 0) {\n        for (j = i + 1; j < n; j++) {\n          var multiplier = M.elements[j][i] / M.elements[i][i]\n          els = []\n          for (p = 0; p < np; p++) {\n            // Elements with column numbers up to an including the number of the\n            // row that we're subtracting can safely be set straight to zero,\n            // since that's the point of this routine and it avoids having to\n            // loop over and correct rounding errors later\n            els.push(\n              p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier\n            )\n          }\n          M.elements[j] = els\n        }\n      }\n    }\n    return M\n  },\n\n  determinant: function() {\n    if (this.elements.length === 0) {\n      return 1\n    }\n    if (!this.isSquare()) {\n      return null\n    }\n    var M = this.toRightTriangular()\n    var det = M.elements[0][0],\n      n = M.elements.length\n    for (var i = 1; i < n; i++) {\n      det = det * M.elements[i][i]\n    }\n    return det\n  },\n\n  isSingular: function() {\n    return this.isSquare() && this.determinant() === 0\n  },\n\n  augment: function(matrix) {\n    if (this.elements.length === 0) {\n      return this.dup()\n    }\n    var M = matrix.elements || matrix\n    if (typeof M[0][0] === 'undefined') {\n      M = Sylvester.Matrix.create(M).elements\n    }\n    var T = this.dup(),\n      cols = T.elements[0].length\n    var i = T.elements.length,\n      nj = M[0].length,\n      j\n    if (i !== M.length) {\n      return null\n    }\n    while (i--) {\n      j = nj\n      while (j--) {\n        T.elements[i][cols + j] = M[i][j]\n      }\n    }\n    return T\n  },\n\n  inverse: function() {\n    if (this.elements.length === 0) {\n      return null\n    }\n    if (!this.isSquare() || this.isSingular()) {\n      return null\n    }\n    var n = this.elements.length,\n      i = n,\n      j\n    var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular()\n    var np = M.elements[0].length,\n      p,\n      els,\n      divisor\n    var inverse_elements = [],\n      new_element\n    // Sylvester.Matrix is non-singular so there will be no zeros on the\n    // diagonal. Cycle through rows from last to first.\n    while (i--) {\n      // First, normalise diagonal elements to 1\n      els = []\n      inverse_elements[i] = []\n      divisor = M.elements[i][i]\n      for (p = 0; p < np; p++) {\n        new_element = M.elements[i][p] / divisor\n        els.push(new_element)\n        // Shuffle off the current row of the right hand side into the results\n        // array as it will not be modified by later runs through this loop\n        if (p >= n) {\n          inverse_elements[i].push(new_element)\n        }\n      }\n      M.elements[i] = els\n      // Then, subtract this row from those above it to give the identity matrix\n      // on the left hand side\n      j = i\n      while (j--) {\n        els = []\n        for (p = 0; p < np; p++) {\n          els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i])\n        }\n        M.elements[j] = els\n      }\n    }\n    return Sylvester.Matrix.create(inverse_elements)\n  },\n\n  setElements: function(els) {\n    var i,\n      j,\n      elements = els.elements || els\n    if (elements[0] && typeof elements[0][0] !== 'undefined') {\n      i = elements.length\n      this.elements = []\n      while (i--) {\n        j = elements[i].length\n        this.elements[i] = []\n        while (j--) {\n          this.elements[i][j] = elements[i][j]\n        }\n      }\n      return this\n    }\n    var n = elements.length\n    this.elements = []\n    for (i = 0; i < n; i++) {\n      this.elements.push([elements[i]])\n    }\n    return this\n  },\n}\n\nmodule.exports = function(elements) {\n  return Sylvester.Matrix.create(elements).inverse().elements\n}\n","const KalmanFilter = require('../../lib/kalman-filter');\n\nconst noisyObservations = require('./observations.json').observations;\nconst kfOptions = require('./kf-options.js');\nconst createElement = require('./views/create-element');\nconst createGroupBoxes = require('./views/create-group-boxes');\n\nconst kf = new KalmanFilter(kfOptions);\nlet predicted = kf.predict();\n\nconst img = document.querySelector('#bikes');// eslint-disable-line no-undef\n\n// Create all the elements of the prediction or correction phase\nconst delay = 100;\n\nlet promise = Promise.resolve();\nlet previousCorrected = null;\n\nconst delayPromise = delay => new Promise(resolve => setTimeout(resolve, delay));\n\nmodule.exports = {\n\trun(){\n\t\tnoisyObservations.forEach((box, index) => {\n\t\t\tpromise = promise\n\t\t\t\t.then(() => {\n\t\t\t\t\tpredicted = kf.predict({previousCorrected});\n\t\t\t\t\tconst {mean, covariance} = predicted;\n\n\t\t\t\t\tcreateGroupBoxes({mean, covariance, parent: img, className: 'predicted', color: 'blue'});\n\n\t\t\t\t\treturn delayPromise(delay);\n\t\t\t\t})\n\t\t\t\t.then((b => {\n\t\t\t\t\tcreateElement({\n\t\t\t\t\t\tclassName: 'observation',\n\t\t\t\t\t\tbbox: [\n\t\t\t\t\t\t\tb[0] + (b[2] / 2),\n\t\t\t\t\t\t\tb[1] + (b[3] / 2),\n\t\t\t\t\t\t\tb[2],\n\t\t\t\t\t\t\tb[3]\n\t\t\t\t\t\t],\n\t\t\t\t\t\tparent: img,\n\t\t\t\t\t\tcolor: 'white',\n\t\t\t\t\t\tlineStyle: 'solid'\n\t\t\t\t\t});\n\n\t\t\t\t\treturn delayPromise(delay);\n\t\t\t\t}).bind(null, box, index))\n\t\t\t\t.then((b => {\n\t\t\t\t\tpreviousCorrected = kf.correct({predicted, observation: b});\n\t\t\t\t\tconst {mean, covariance} = previousCorrected;\n\n\t\t\t\t\tcreateGroupBoxes({mean, covariance, parent: img, className: 'corrected', color: 'red'});\n\n\t\t\t\t\treturn delayPromise(delay);\n\t\t\t\t}).bind(null, box, index));\n\t\t})\n\t}\n}\n\n"]} diff --git a/demo/kalman-filter.js b/demo/kalman-filter.js deleted file mode 100644 index c2ec29a..0000000 --- a/demo/kalman-filter.js +++ /dev/null @@ -1,9567 +0,0 @@ -require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // Trim off extra bytes after placeholder bytes are found - // See: https://github.com/beatgammit/base64-js/issues/42 - var validLen = b64.indexOf('=') - if (validLen === -1) validLen = len - - var placeHoldersLen = validLen === len - ? 0 - : 4 - (validLen % 4) - - return [validLen, placeHoldersLen] -} - -// base64 is 4/3 + up to two characters of the original data -function byteLength (b64) { - var lens = getLens(b64) - var validLen = lens[0] - var placeHoldersLen = lens[1] - return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen -} - -function _byteLength (b64, validLen, placeHoldersLen) { - return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen -} - -function toByteArray (b64) { - var tmp - var lens = getLens(b64) - var validLen = lens[0] - var placeHoldersLen = lens[1] - - var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) - - var curByte = 0 - - // if there are placeholders, only get up to the last complete 4 chars - var len = placeHoldersLen > 0 - ? validLen - 4 - : validLen - - var i - for (i = 0; i < len; i += 4) { - tmp = - (revLookup[b64.charCodeAt(i)] << 18) | - (revLookup[b64.charCodeAt(i + 1)] << 12) | - (revLookup[b64.charCodeAt(i + 2)] << 6) | - revLookup[b64.charCodeAt(i + 3)] - arr[curByte++] = (tmp >> 16) & 0xFF - arr[curByte++] = (tmp >> 8) & 0xFF - arr[curByte++] = tmp & 0xFF - } - - if (placeHoldersLen === 2) { - tmp = - (revLookup[b64.charCodeAt(i)] << 2) | - (revLookup[b64.charCodeAt(i + 1)] >> 4) - arr[curByte++] = tmp & 0xFF - } - - if (placeHoldersLen === 1) { - tmp = - (revLookup[b64.charCodeAt(i)] << 10) | - (revLookup[b64.charCodeAt(i + 1)] << 4) | - (revLookup[b64.charCodeAt(i + 2)] >> 2) - arr[curByte++] = (tmp >> 8) & 0xFF - arr[curByte++] = tmp & 0xFF - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + - lookup[num >> 12 & 0x3F] + - lookup[num >> 6 & 0x3F] + - lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp - var output = [] - for (var i = start; i < end; i += 3) { - tmp = - ((uint8[i] << 16) & 0xFF0000) + - ((uint8[i + 1] << 8) & 0xFF00) + - (uint8[i + 2] & 0xFF) - output.push(tripletToBase64(tmp)) - } - return output.join('') -} - -function fromByteArray (uint8) { - var tmp - var len = uint8.length - var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes - var parts = [] - var maxChunkLength = 16383 // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk( - uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength) - )) - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1] - parts.push( - lookup[tmp >> 2] + - lookup[(tmp << 4) & 0x3F] + - '==' - ) - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + uint8[len - 1] - parts.push( - lookup[tmp >> 10] + - lookup[(tmp >> 4) & 0x3F] + - lookup[(tmp << 2) & 0x3F] + - '=' - ) - } - - return parts.join('') -} - -},{}],2:[function(require,module,exports){ - -},{}],3:[function(require,module,exports){ -(function (Buffer){ -/*! - * The buffer module from node.js, for the browser. - * - * @author Feross Aboukhadijeh - * @license MIT - */ -/* eslint-disable no-proto */ - -'use strict' - -var base64 = require('base64-js') -var ieee754 = require('ieee754') - -exports.Buffer = Buffer -exports.SlowBuffer = SlowBuffer -exports.INSPECT_MAX_BYTES = 50 - -var K_MAX_LENGTH = 0x7fffffff -exports.kMaxLength = K_MAX_LENGTH - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Print warning and recommend using `buffer` v4.x which has an Object - * implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * We report that the browser does not support typed arrays if the are not subclassable - * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array` - * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support - * for __proto__ and has a buggy typed array implementation. - */ -Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport() - -if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && - typeof console.error === 'function') { - console.error( - 'This browser lacks typed array (Uint8Array) support which is required by ' + - '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.' - ) -} - -function typedArraySupport () { - // Can typed array instances can be augmented? - try { - var arr = new Uint8Array(1) - arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } } - return arr.foo() === 42 - } catch (e) { - return false - } -} - -Object.defineProperty(Buffer.prototype, 'parent', { - enumerable: true, - get: function () { - if (!Buffer.isBuffer(this)) return undefined - return this.buffer - } -}) - -Object.defineProperty(Buffer.prototype, 'offset', { - enumerable: true, - get: function () { - if (!Buffer.isBuffer(this)) return undefined - return this.byteOffset - } -}) - -function createBuffer (length) { - if (length > K_MAX_LENGTH) { - throw new RangeError('The value "' + length + '" is invalid for option "size"') - } - // Return an augmented `Uint8Array` instance - var buf = new Uint8Array(length) - buf.__proto__ = Buffer.prototype - return buf -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new TypeError( - 'The "string" argument must be of type string. Received type number' - ) - } - return allocUnsafe(arg) - } - return from(arg, encodingOrOffset, length) -} - -// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 -if (typeof Symbol !== 'undefined' && Symbol.species != null && - Buffer[Symbol.species] === Buffer) { - Object.defineProperty(Buffer, Symbol.species, { - value: null, - configurable: true, - enumerable: false, - writable: false - }) -} - -Buffer.poolSize = 8192 // not used by this implementation - -function from (value, encodingOrOffset, length) { - if (typeof value === 'string') { - return fromString(value, encodingOrOffset) - } - - if (ArrayBuffer.isView(value)) { - return fromArrayLike(value) - } - - if (value == null) { - throw TypeError( - 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + - 'or Array-like Object. Received type ' + (typeof value) - ) - } - - if (isInstance(value, ArrayBuffer) || - (value && isInstance(value.buffer, ArrayBuffer))) { - return fromArrayBuffer(value, encodingOrOffset, length) - } - - if (typeof value === 'number') { - throw new TypeError( - 'The "value" argument must not be of type number. Received type number' - ) - } - - var valueOf = value.valueOf && value.valueOf() - if (valueOf != null && valueOf !== value) { - return Buffer.from(valueOf, encodingOrOffset, length) - } - - var b = fromObject(value) - if (b) return b - - if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null && - typeof value[Symbol.toPrimitive] === 'function') { - return Buffer.from( - value[Symbol.toPrimitive]('string'), encodingOrOffset, length - ) - } - - throw new TypeError( - 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' + - 'or Array-like Object. Received type ' + (typeof value) - ) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(value, encodingOrOffset, length) -} - -// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug: -// https://github.com/feross/buffer/pull/148 -Buffer.prototype.__proto__ = Uint8Array.prototype -Buffer.__proto__ = Uint8Array - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be of type number') - } else if (size < 0) { - throw new RangeError('The value "' + size + '" is invalid for option "size"') - } -} - -function alloc (size, fill, encoding) { - assertSize(size) - if (size <= 0) { - return createBuffer(size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(size).fill(fill, encoding) - : createBuffer(size).fill(fill) - } - return createBuffer(size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(size, fill, encoding) -} - -function allocUnsafe (size) { - assertSize(size) - return createBuffer(size < 0 ? 0 : checked(size) | 0) -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(size) -} -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(size) -} - -function fromString (string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8' - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - - var length = byteLength(string, encoding) | 0 - var buf = createBuffer(length) - - var actual = buf.write(string, encoding) - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - buf = buf.slice(0, actual) - } - - return buf -} - -function fromArrayLike (array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0 - var buf = createBuffer(length) - for (var i = 0; i < length; i += 1) { - buf[i] = array[i] & 255 - } - return buf -} - -function fromArrayBuffer (array, byteOffset, length) { - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('"offset" is outside of buffer bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('"length" is outside of buffer bounds') - } - - var buf - if (byteOffset === undefined && length === undefined) { - buf = new Uint8Array(array) - } else if (length === undefined) { - buf = new Uint8Array(array, byteOffset) - } else { - buf = new Uint8Array(array, byteOffset, length) - } - - // Return an augmented `Uint8Array` instance - buf.__proto__ = Buffer.prototype - return buf -} - -function fromObject (obj) { - if (Buffer.isBuffer(obj)) { - var len = checked(obj.length) | 0 - var buf = createBuffer(len) - - if (buf.length === 0) { - return buf - } - - obj.copy(buf, 0, 0, len) - return buf - } - - if (obj.length !== undefined) { - if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) { - return createBuffer(0) - } - return fromArrayLike(obj) - } - - if (obj.type === 'Buffer' && Array.isArray(obj.data)) { - return fromArrayLike(obj.data) - } -} - -function checked (length) { - // Note: cannot use `length < K_MAX_LENGTH` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= K_MAX_LENGTH) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes') - } - return length | 0 -} - -function SlowBuffer (length) { - if (+length != length) { // eslint-disable-line eqeqeq - length = 0 - } - return Buffer.alloc(+length) -} - -Buffer.isBuffer = function isBuffer (b) { - return b != null && b._isBuffer === true && - b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false -} - -Buffer.compare = function compare (a, b) { - if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength) - if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength) - if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { - throw new TypeError( - 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' - ) - } - - if (a === b) return 0 - - var x = a.length - var y = b.length - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i] - y = b[i] - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -} - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -} - -Buffer.concat = function concat (list, length) { - if (!Array.isArray(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i - if (length === undefined) { - length = 0 - for (i = 0; i < list.length; ++i) { - length += list[i].length - } - } - - var buffer = Buffer.allocUnsafe(length) - var pos = 0 - for (i = 0; i < list.length; ++i) { - var buf = list[i] - if (isInstance(buf, Uint8Array)) { - buf = Buffer.from(buf) - } - if (!Buffer.isBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos) - pos += buf.length - } - return buffer -} - -function byteLength (string, encoding) { - if (Buffer.isBuffer(string)) { - return string.length - } - if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - throw new TypeError( - 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' + - 'Received type ' + typeof string - ) - } - - var len = string.length - var mustMatch = (arguments.length > 2 && arguments[2] === true) - if (!mustMatch && len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) { - return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8 - } - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } - } -} -Buffer.byteLength = byteLength - -function slowToString (encoding, start, end) { - var loweredCase = false - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0 - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0 - start >>>= 0 - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8' - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase() - loweredCase = true - } - } -} - -// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package) -// to detect a Buffer instance. It's not possible to use `instanceof Buffer` -// reliably in a browserify context because there could be multiple different -// copies of the 'buffer' package in use. This method works even for Buffer -// instances that were created from another copy of the `buffer` package. -// See: https://github.com/feross/buffer/issues/154 -Buffer.prototype._isBuffer = true - -function swap (b, n, m) { - var i = b[n] - b[n] = b[m] - b[m] = i -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1) - } - return this -} - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3) - swap(this, i + 1, i + 2) - } - return this -} - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7) - swap(this, i + 1, i + 6) - swap(this, i + 2, i + 5) - swap(this, i + 3, i + 4) - } - return this -} - -Buffer.prototype.toString = function toString () { - var length = this.length - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -} - -Buffer.prototype.toLocaleString = Buffer.prototype.toString - -Buffer.prototype.equals = function equals (b) { - if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -} - -Buffer.prototype.inspect = function inspect () { - var str = '' - var max = exports.INSPECT_MAX_BYTES - str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim() - if (this.length > max) str += ' ... ' - return '' -} - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (isInstance(target, Uint8Array)) { - target = Buffer.from(target, target.offset, target.byteLength) - } - if (!Buffer.isBuffer(target)) { - throw new TypeError( - 'The "target" argument must be one of type Buffer or Uint8Array. ' + - 'Received type ' + (typeof target) - ) - } - - if (start === undefined) { - start = 0 - } - if (end === undefined) { - end = target ? target.length : 0 - } - if (thisStart === undefined) { - thisStart = 0 - } - if (thisEnd === undefined) { - thisEnd = this.length - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0 - end >>>= 0 - thisStart >>>= 0 - thisEnd >>>= 0 - - if (this === target) return 0 - - var x = thisEnd - thisStart - var y = end - start - var len = Math.min(x, y) - - var thisCopy = this.slice(thisStart, thisEnd) - var targetCopy = target.slice(start, end) - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i] - y = targetCopy[i] - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -} - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset - byteOffset = 0 - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000 - } - byteOffset = +byteOffset // Coerce to Number. - if (numberIsNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1) - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1 - } else if (byteOffset < 0) { - if (dir) byteOffset = 0 - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding) - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (Buffer.isBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF // Search for a byte value [0-255] - if (typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1 - var arrLength = arr.length - var valLength = val.length - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase() - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2 - arrLength /= 2 - valLength /= 2 - byteOffset /= 2 - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i - if (dir) { - var foundIndex = -1 - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex - foundIndex = -1 - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength - for (i = byteOffset; i >= 0; i--) { - var found = true - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -} - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -} - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -} - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0 - var remaining = buf.length - offset - if (!length) { - length = remaining - } else { - length = Number(length) - if (length > remaining) { - length = remaining - } - } - - var strLen = string.length - - if (length > strLen / 2) { - length = strLen / 2 - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16) - if (numberIsNaN(parsed)) return i - buf[offset + i] = parsed - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8' - length = this.length - offset = 0 - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset - length = this.length - offset = 0 - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset >>> 0 - if (isFinite(length)) { - length = length >>> 0 - if (encoding === undefined) encoding = 'utf8' - } else { - encoding = length - length = undefined - } - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset - if (length === undefined || length > remaining) length = remaining - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8' - - var loweredCase = false - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } - } -} - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -} - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return base64.fromByteArray(buf) - } else { - return base64.fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end) - var res = [] - - var i = start - while (i < end) { - var firstByte = buf[i] - var codePoint = null - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1 - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte - } - break - case 2: - secondByte = buf[i + 1] - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint - } - } - break - case 3: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint - } - } - break - case 4: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - fourthByte = buf[i + 3] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD - bytesPerSequence = 1 - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000 - res.push(codePoint >>> 10 & 0x3FF | 0xD800) - codePoint = 0xDC00 | codePoint & 0x3FF - } - - res.push(codePoint) - i += bytesPerSequence - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000 - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = '' - var i = 0 - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ) - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F) - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]) - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length - - if (!start || start < 0) start = 0 - if (!end || end < 0 || end > len) end = len - - var out = '' - for (var i = start; i < end; ++i) { - out += toHex(buf[i]) - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end) - var res = '' - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256)) - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length - start = ~~start - end = end === undefined ? len : ~~end - - if (start < 0) { - start += len - if (start < 0) start = 0 - } else if (start > len) { - start = len - } - - if (end < 0) { - end += len - if (end < 0) end = 0 - } else if (end > len) { - end = len - } - - if (end < start) end = start - - var newBuf = this.subarray(start, end) - // Return an augmented `Uint8Array` instance - newBuf.__proto__ = Buffer.prototype - return newBuf -} - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) - - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } - - return val -} - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) { - checkOffset(offset, byteLength, this.length) - } - - var val = this[offset + --byteLength] - var mul = 1 - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul - } - - return val -} - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 1, this.length) - return this[offset] -} - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 2, this.length) - return this[offset] | (this[offset + 1] << 8) -} - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 2, this.length) - return (this[offset] << 8) | this[offset + 1] -} - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -} - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -} - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) - - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } - mul *= 0x80 - - if (val >= mul) val -= Math.pow(2, 8 * byteLength) - - return val -} - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) - - var i = byteLength - var mul = 1 - var val = this[offset + --i] - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul - } - mul *= 0x80 - - if (val >= mul) val -= Math.pow(2, 8 * byteLength) - - return val -} - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 1, this.length) - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -} - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset] | (this[offset + 1] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val -} - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset + 1] | (this[offset] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val -} - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -} - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -} - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, true, 23, 4) -} - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, false, 23, 4) -} - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, true, 52, 8) -} - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - offset = offset >>> 0 - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, false, 52, 8) -} - -function checkInt (buf, value, offset, ext, max, min) { - if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1 - checkInt(this, value, offset, byteLength, maxBytes, 0) - } - - var mul = 1 - var i = 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } - - return offset + byteLength -} - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset >>> 0 - byteLength = byteLength >>> 0 - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1 - checkInt(this, value, offset, byteLength, maxBytes, 0) - } - - var i = byteLength - 1 - var mul = 1 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } - - return offset + byteLength -} - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) - this[offset] = (value & 0xff) - return offset + 1 -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - return offset + 2 -} - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - return offset + 2 -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - this[offset + 3] = (value >>> 24) - this[offset + 2] = (value >>> 16) - this[offset + 1] = (value >>> 8) - this[offset] = (value & 0xff) - return offset + 4 -} - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - return offset + 4 -} - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) { - var limit = Math.pow(2, (8 * byteLength) - 1) - - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } - - var i = 0 - var mul = 1 - var sub = 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1 - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } - - return offset + byteLength -} - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) { - var limit = Math.pow(2, (8 * byteLength) - 1) - - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } - - var i = byteLength - 1 - var mul = 1 - var sub = 0 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1 - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } - - return offset + byteLength -} - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) - if (value < 0) value = 0xff + value + 1 - this[offset] = (value & 0xff) - return offset + 1 -} - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - return offset + 2 -} - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - return offset + 2 -} - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - this[offset + 2] = (value >>> 16) - this[offset + 3] = (value >>> 24) - return offset + 4 -} - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - if (value < 0) value = 0xffffffff + value + 1 - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - return offset + 4 -} - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) { - checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) - } - ieee754.write(buf, value, offset, littleEndian, 23, 4) - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -} - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -} - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - value = +value - offset = offset >>> 0 - if (!noAssert) { - checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) - } - ieee754.write(buf, value, offset, littleEndian, 52, 8) - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -} - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -} - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer') - if (!start) start = 0 - if (!end && end !== 0) end = this.length - if (targetStart >= target.length) targetStart = target.length - if (!targetStart) targetStart = 0 - if (end > 0 && end < start) end = start - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('Index out of range') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start - } - - var len = end - start - - if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') { - // Use built-in when available, missing from IE11 - this.copyWithin(targetStart, start, end) - } else if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (var i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start] - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, end), - targetStart - ) - } - - return len -} - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start - start = 0 - end = this.length - } else if (typeof end === 'string') { - encoding = end - end = this.length - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - if (val.length === 1) { - var code = val.charCodeAt(0) - if ((encoding === 'utf8' && code < 128) || - encoding === 'latin1') { - // Fast path: If `val` fits into a single byte, use that numeric value. - val = code - } - } - } else if (typeof val === 'number') { - val = val & 255 - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0 - end = end === undefined ? this.length : end >>> 0 - - if (!val) val = 0 - - var i - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val - } - } else { - var bytes = Buffer.isBuffer(val) - ? val - : Buffer.from(val, encoding) - var len = bytes.length - if (len === 0) { - throw new TypeError('The value "' + val + - '" is invalid for argument "value"') - } - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len] - } - } - - return this -} - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g - -function base64clean (str) { - // Node takes equal signs as end of the Base64 encoding - str = str.split('=')[0] - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = str.trim().replace(INVALID_BASE64_RE, '') - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '=' - } - return str -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity - var codePoint - var length = string.length - var leadSurrogate = null - var bytes = [] - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i) - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } - - // valid lead - leadSurrogate = codePoint - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - leadSurrogate = codePoint - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - } - - leadSurrogate = null - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint) - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = [] - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF) - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo - var byteArray = [] - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i) - hi = c >> 8 - lo = c % 256 - byteArray.push(lo) - byteArray.push(hi) - } - - return byteArray -} - -function base64ToBytes (str) { - return base64.toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i] - } - return i -} - -// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass -// the `instanceof` check but they should be treated as of that type. -// See: https://github.com/feross/buffer/issues/166 -function isInstance (obj, type) { - return obj instanceof type || - (obj != null && obj.constructor != null && obj.constructor.name != null && - obj.constructor.name === type.name) -} -function numberIsNaN (obj) { - // For IE11 support - return obj !== obj // eslint-disable-line no-self-compare -} - -}).call(this,require("buffer").Buffer) -},{"base64-js":1,"buffer":3,"ieee754":6}],4:[function(require,module,exports){ -(function (Buffer){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. - -function isArray(arg) { - if (Array.isArray) { - return Array.isArray(arg); - } - return objectToString(arg) === '[object Array]'; -} -exports.isArray = isArray; - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} -exports.isBoolean = isBoolean; - -function isNull(arg) { - return arg === null; -} -exports.isNull = isNull; - -function isNullOrUndefined(arg) { - return arg == null; -} -exports.isNullOrUndefined = isNullOrUndefined; - -function isNumber(arg) { - return typeof arg === 'number'; -} -exports.isNumber = isNumber; - -function isString(arg) { - return typeof arg === 'string'; -} -exports.isString = isString; - -function isSymbol(arg) { - return typeof arg === 'symbol'; -} -exports.isSymbol = isSymbol; - -function isUndefined(arg) { - return arg === void 0; -} -exports.isUndefined = isUndefined; - -function isRegExp(re) { - return objectToString(re) === '[object RegExp]'; -} -exports.isRegExp = isRegExp; - -function isObject(arg) { - return typeof arg === 'object' && arg !== null; -} -exports.isObject = isObject; - -function isDate(d) { - return objectToString(d) === '[object Date]'; -} -exports.isDate = isDate; - -function isError(e) { - return (objectToString(e) === '[object Error]' || e instanceof Error); -} -exports.isError = isError; - -function isFunction(arg) { - return typeof arg === 'function'; -} -exports.isFunction = isFunction; - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} -exports.isPrimitive = isPrimitive; - -exports.isBuffer = Buffer.isBuffer; - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - -}).call(this,{"isBuffer":require("../../is-buffer/index.js")}) -},{"../../is-buffer/index.js":8}],5:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -var objectCreate = Object.create || objectCreatePolyfill -var objectKeys = Object.keys || objectKeysPolyfill -var bind = Function.prototype.bind || functionBindPolyfill - -function EventEmitter() { - if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) { - this._events = objectCreate(null); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -} -module.exports = EventEmitter; - -// Backwards-compat with node 0.10.x -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -var defaultMaxListeners = 10; - -var hasDefineProperty; -try { - var o = {}; - if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 }); - hasDefineProperty = o.x === 0; -} catch (err) { hasDefineProperty = false } -if (hasDefineProperty) { - Object.defineProperty(EventEmitter, 'defaultMaxListeners', { - enumerable: true, - get: function() { - return defaultMaxListeners; - }, - set: function(arg) { - // check whether the input is a positive number (whose value is zero or - // greater and not a NaN). - if (typeof arg !== 'number' || arg < 0 || arg !== arg) - throw new TypeError('"defaultMaxListeners" must be a positive number'); - defaultMaxListeners = arg; - } - }); -} else { - EventEmitter.defaultMaxListeners = defaultMaxListeners; -} - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - // If there is no 'error' event listener then throw. - if (doError) { - if (arguments.length > 1) - er = arguments[1]; - if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Unhandled "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = objectCreate(null); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = - prepend ? [listener, existing] : [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' "' + String(type) + '" listeners ' + - 'added. Use emitter.setMaxListeners() to ' + - 'increase limit.'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - if (typeof console === 'object' && console.warn) { - console.warn('%s: %s', w.name, w.message); - } - } - } - } - - return target; -} - -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function onceWrapper() { - if (!this.fired) { - this.target.removeListener(this.type, this.wrapFn); - this.fired = true; - switch (arguments.length) { - case 0: - return this.listener.call(this.target); - case 1: - return this.listener.call(this.target, arguments[0]); - case 2: - return this.listener.call(this.target, arguments[0], arguments[1]); - case 3: - return this.listener.call(this.target, arguments[0], arguments[1], - arguments[2]); - default: - var args = new Array(arguments.length); - for (var i = 0; i < args.length; ++i) - args[i] = arguments[i]; - this.listener.apply(this.target, args); - } - } -} - -function _onceWrap(target, type, listener) { - var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; - var wrapped = bind.call(onceWrapper, state); - wrapped.listener = listener; - state.wrapFn = wrapped; - return wrapped; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// Emits a 'removeListener' event if and only if the listener was removed. -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || list.listener === listener) { - if (--this._eventsCount === 0) - this._events = objectCreate(null); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length - 1; i >= 0; i--) { - if (list[i] === listener || list[i].listener === listener) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (position === 0) - list.shift(); - else - spliceOne(list, position); - - if (list.length === 1) - events[type] = list[0]; - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events, i; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = objectCreate(null); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = objectCreate(null); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = objectKeys(events); - var key; - for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = objectCreate(null); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - for (i = listeners.length - 1; i >= 0; i--) { - this.removeListener(type, listeners[i]); - } - } - - return this; - }; - -function _listeners(target, type, unwrap) { - var events = target._events; - - if (!events) - return []; - - var evlistener = events[type]; - if (!evlistener) - return []; - - if (typeof evlistener === 'function') - return unwrap ? [evlistener.listener || evlistener] : [evlistener]; - - return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); -} - -EventEmitter.prototype.listeners = function listeners(type) { - return _listeners(this, type, true); -}; - -EventEmitter.prototype.rawListeners = function rawListeners(type) { - return _listeners(this, type, false); -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount; -function listenerCount(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, n) { - var copy = new Array(n); - for (var i = 0; i < n; ++i) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -function objectCreatePolyfill(proto) { - var F = function() {}; - F.prototype = proto; - return new F; -} -function objectKeysPolyfill(obj) { - var keys = []; - for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) { - keys.push(k); - } - return k; -} -function functionBindPolyfill(context) { - var fn = this; - return function () { - return fn.apply(context, arguments); - }; -} - -},{}],6:[function(require,module,exports){ -exports.read = function (buffer, offset, isLE, mLen, nBytes) { - var e, m - var eLen = (nBytes * 8) - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var nBits = -7 - var i = isLE ? (nBytes - 1) : 0 - var d = isLE ? -1 : 1 - var s = buffer[offset + i] - - i += d - - e = s & ((1 << (-nBits)) - 1) - s >>= (-nBits) - nBits += eLen - for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1) - e >>= (-nBits) - nBits += mLen - for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen) - e = e - eBias - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c - var eLen = (nBytes * 8) - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) - var i = isLE ? 0 : (nBytes - 1) - var d = isLE ? 1 : -1 - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 - - value = Math.abs(value) - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0 - e = eMax - } else { - e = Math.floor(Math.log(value) / Math.LN2) - if (value * (c = Math.pow(2, -e)) < 1) { - e-- - c *= 2 - } - if (e + eBias >= 1) { - value += rt / c - } else { - value += rt * Math.pow(2, 1 - eBias) - } - if (value * c >= 2) { - e++ - c /= 2 - } - - if (e + eBias >= eMax) { - m = 0 - e = eMax - } else if (e + eBias >= 1) { - m = ((value * c) - 1) * Math.pow(2, mLen) - e = e + eBias - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) - e = 0 - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m - eLen += mLen - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128 -} - -},{}],7:[function(require,module,exports){ -if (typeof Object.create === 'function') { - // implementation from standard node.js 'util' module - module.exports = function inherits(ctor, superCtor) { - if (superCtor) { - ctor.super_ = superCtor - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }) - } - }; -} else { - // old school shim for old browsers - module.exports = function inherits(ctor, superCtor) { - if (superCtor) { - ctor.super_ = superCtor - var TempCtor = function () {} - TempCtor.prototype = superCtor.prototype - ctor.prototype = new TempCtor() - ctor.prototype.constructor = ctor - } - } -} - -},{}],8:[function(require,module,exports){ -/*! - * Determine if an object is a Buffer - * - * @author Feross Aboukhadijeh - * @license MIT - */ - -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -module.exports = function (obj) { - return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) -} - -function isBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0)) -} - -},{}],9:[function(require,module,exports){ -var toString = {}.toString; - -module.exports = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -},{}],10:[function(require,module,exports){ -(function (process){ -'use strict'; - -if (typeof process === 'undefined' || - !process.version || - process.version.indexOf('v0.') === 0 || - process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { - module.exports = { nextTick: nextTick }; -} else { - module.exports = process -} - -function nextTick(fn, arg1, arg2, arg3) { - if (typeof fn !== 'function') { - throw new TypeError('"callback" argument must be a function'); - } - var len = arguments.length; - var args, i; - switch (len) { - case 0: - case 1: - return process.nextTick(fn); - case 2: - return process.nextTick(function afterTickOne() { - fn.call(null, arg1); - }); - case 3: - return process.nextTick(function afterTickTwo() { - fn.call(null, arg1, arg2); - }); - case 4: - return process.nextTick(function afterTickThree() { - fn.call(null, arg1, arg2, arg3); - }); - default: - args = new Array(len - 1); - i = 0; - while (i < args.length) { - args[i++] = arguments[i]; - } - return process.nextTick(function afterTick() { - fn.apply(null, args); - }); - } -} - - -}).call(this,require('_process')) -},{"_process":11}],11:[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; }; - -},{}],12:[function(require,module,exports){ -(function (global){ -/*! https://mths.be/punycode v1.4.1 by @mathias */ -;(function(root) { - - /** Detect free variables */ - var freeExports = typeof exports == 'object' && exports && - !exports.nodeType && exports; - var freeModule = typeof module == 'object' && module && - !module.nodeType && module; - var freeGlobal = typeof global == 'object' && global; - if ( - freeGlobal.global === freeGlobal || - freeGlobal.window === freeGlobal || - freeGlobal.self === freeGlobal - ) { - root = freeGlobal; - } - - /** - * The `punycode` object. - * @name punycode - * @type Object - */ - var punycode, - - /** Highest positive signed 32-bit float value */ - maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 - - /** Bootstring parameters */ - base = 36, - tMin = 1, - tMax = 26, - skew = 38, - damp = 700, - initialBias = 72, - initialN = 128, // 0x80 - delimiter = '-', // '\x2D' - - /** Regular expressions */ - regexPunycode = /^xn--/, - regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars - regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators - - /** Error messages */ - errors = { - 'overflow': 'Overflow: input needs wider integers to process', - 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', - 'invalid-input': 'Invalid input' - }, - - /** Convenience shortcuts */ - baseMinusTMin = base - tMin, - floor = Math.floor, - stringFromCharCode = String.fromCharCode, - - /** Temporary variable */ - key; - - /*--------------------------------------------------------------------------*/ - - /** - * A generic error utility function. - * @private - * @param {String} type The error type. - * @returns {Error} Throws a `RangeError` with the applicable error message. - */ - function error(type) { - throw new RangeError(errors[type]); - } - - /** - * A generic `Array#map` utility function. - * @private - * @param {Array} array The array to iterate over. - * @param {Function} callback The function that gets called for every array - * item. - * @returns {Array} A new array of values returned by the callback function. - */ - function map(array, fn) { - var length = array.length; - var result = []; - while (length--) { - result[length] = fn(array[length]); - } - return result; - } - - /** - * A simple `Array#map`-like wrapper to work with domain name strings or email - * addresses. - * @private - * @param {String} domain The domain name or email address. - * @param {Function} callback The function that gets called for every - * character. - * @returns {Array} A new string of characters returned by the callback - * function. - */ - function mapDomain(string, fn) { - var parts = string.split('@'); - var result = ''; - if (parts.length > 1) { - // In email addresses, only the domain name should be punycoded. Leave - // the local part (i.e. everything up to `@`) intact. - result = parts[0] + '@'; - string = parts[1]; - } - // Avoid `split(regex)` for IE8 compatibility. See #17. - string = string.replace(regexSeparators, '\x2E'); - var labels = string.split('.'); - var encoded = map(labels, fn).join('.'); - return result + encoded; - } - - /** - * Creates an array containing the numeric code points of each Unicode - * character in the string. While JavaScript uses UCS-2 internally, - * this function will convert a pair of surrogate halves (each of which - * UCS-2 exposes as separate characters) into a single code point, - * matching UTF-16. - * @see `punycode.ucs2.encode` - * @see - * @memberOf punycode.ucs2 - * @name decode - * @param {String} string The Unicode input string (UCS-2). - * @returns {Array} The new array of code points. - */ - function ucs2decode(string) { - var output = [], - counter = 0, - length = string.length, - value, - extra; - while (counter < length) { - value = string.charCodeAt(counter++); - if (value >= 0xD800 && value <= 0xDBFF && counter < length) { - // high surrogate, and there is a next character - extra = string.charCodeAt(counter++); - if ((extra & 0xFC00) == 0xDC00) { // low surrogate - output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); - } else { - // unmatched surrogate; only append this code unit, in case the next - // code unit is the high surrogate of a surrogate pair - output.push(value); - counter--; - } - } else { - output.push(value); - } - } - return output; - } - - /** - * Creates a string based on an array of numeric code points. - * @see `punycode.ucs2.decode` - * @memberOf punycode.ucs2 - * @name encode - * @param {Array} codePoints The array of numeric code points. - * @returns {String} The new Unicode string (UCS-2). - */ - function ucs2encode(array) { - return map(array, function(value) { - var output = ''; - if (value > 0xFFFF) { - value -= 0x10000; - output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); - value = 0xDC00 | value & 0x3FF; - } - output += stringFromCharCode(value); - return output; - }).join(''); - } - - /** - * Converts a basic code point into a digit/integer. - * @see `digitToBasic()` - * @private - * @param {Number} codePoint The basic numeric code point value. - * @returns {Number} The numeric value of a basic code point (for use in - * representing integers) in the range `0` to `base - 1`, or `base` if - * the code point does not represent a value. - */ - function basicToDigit(codePoint) { - if (codePoint - 48 < 10) { - return codePoint - 22; - } - if (codePoint - 65 < 26) { - return codePoint - 65; - } - if (codePoint - 97 < 26) { - return codePoint - 97; - } - return base; - } - - /** - * Converts a digit/integer into a basic code point. - * @see `basicToDigit()` - * @private - * @param {Number} digit The numeric value of a basic code point. - * @returns {Number} The basic code point whose value (when used for - * representing integers) is `digit`, which needs to be in the range - * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is - * used; else, the lowercase form is used. The behavior is undefined - * if `flag` is non-zero and `digit` has no uppercase form. - */ - function digitToBasic(digit, flag) { - // 0..25 map to ASCII a..z or A..Z - // 26..35 map to ASCII 0..9 - return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); - } - - /** - * Bias adaptation function as per section 3.4 of RFC 3492. - * https://tools.ietf.org/html/rfc3492#section-3.4 - * @private - */ - function adapt(delta, numPoints, firstTime) { - var k = 0; - delta = firstTime ? floor(delta / damp) : delta >> 1; - delta += floor(delta / numPoints); - for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { - delta = floor(delta / baseMinusTMin); - } - return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); - } - - /** - * Converts a Punycode string of ASCII-only symbols to a string of Unicode - * symbols. - * @memberOf punycode - * @param {String} input The Punycode string of ASCII-only symbols. - * @returns {String} The resulting string of Unicode symbols. - */ - function decode(input) { - // Don't use UCS-2 - var output = [], - inputLength = input.length, - out, - i = 0, - n = initialN, - bias = initialBias, - basic, - j, - index, - oldi, - w, - k, - digit, - t, - /** Cached calculation results */ - baseMinusT; - - // Handle the basic code points: let `basic` be the number of input code - // points before the last delimiter, or `0` if there is none, then copy - // the first basic code points to the output. - - basic = input.lastIndexOf(delimiter); - if (basic < 0) { - basic = 0; - } - - for (j = 0; j < basic; ++j) { - // if it's not a basic code point - if (input.charCodeAt(j) >= 0x80) { - error('not-basic'); - } - output.push(input.charCodeAt(j)); - } - - // Main decoding loop: start just after the last delimiter if any basic code - // points were copied; start at the beginning otherwise. - - for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { - - // `index` is the index of the next character to be consumed. - // Decode a generalized variable-length integer into `delta`, - // which gets added to `i`. The overflow checking is easier - // if we increase `i` as we go, then subtract off its starting - // value at the end to obtain `delta`. - for (oldi = i, w = 1, k = base; /* no condition */; k += base) { - - if (index >= inputLength) { - error('invalid-input'); - } - - digit = basicToDigit(input.charCodeAt(index++)); - - if (digit >= base || digit > floor((maxInt - i) / w)) { - error('overflow'); - } - - i += digit * w; - t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); - - if (digit < t) { - break; - } - - baseMinusT = base - t; - if (w > floor(maxInt / baseMinusT)) { - error('overflow'); - } - - w *= baseMinusT; - - } - - out = output.length + 1; - bias = adapt(i - oldi, out, oldi == 0); - - // `i` was supposed to wrap around from `out` to `0`, - // incrementing `n` each time, so we'll fix that now: - if (floor(i / out) > maxInt - n) { - error('overflow'); - } - - n += floor(i / out); - i %= out; - - // Insert `n` at position `i` of the output - output.splice(i++, 0, n); - - } - - return ucs2encode(output); - } - - /** - * Converts a string of Unicode symbols (e.g. a domain name label) to a - * Punycode string of ASCII-only symbols. - * @memberOf punycode - * @param {String} input The string of Unicode symbols. - * @returns {String} The resulting Punycode string of ASCII-only symbols. - */ - function encode(input) { - var n, - delta, - handledCPCount, - basicLength, - bias, - j, - m, - q, - k, - t, - currentValue, - output = [], - /** `inputLength` will hold the number of code points in `input`. */ - inputLength, - /** Cached calculation results */ - handledCPCountPlusOne, - baseMinusT, - qMinusT; - - // Convert the input in UCS-2 to Unicode - input = ucs2decode(input); - - // Cache the length - inputLength = input.length; - - // Initialize the state - n = initialN; - delta = 0; - bias = initialBias; - - // Handle the basic code points - for (j = 0; j < inputLength; ++j) { - currentValue = input[j]; - if (currentValue < 0x80) { - output.push(stringFromCharCode(currentValue)); - } - } - - handledCPCount = basicLength = output.length; - - // `handledCPCount` is the number of code points that have been handled; - // `basicLength` is the number of basic code points. - - // Finish the basic string - if it is not empty - with a delimiter - if (basicLength) { - output.push(delimiter); - } - - // Main encoding loop: - while (handledCPCount < inputLength) { - - // All non-basic code points < n have been handled already. Find the next - // larger one: - for (m = maxInt, j = 0; j < inputLength; ++j) { - currentValue = input[j]; - if (currentValue >= n && currentValue < m) { - m = currentValue; - } - } - - // Increase `delta` enough to advance the decoder's state to , - // but guard against overflow - handledCPCountPlusOne = handledCPCount + 1; - if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { - error('overflow'); - } - - delta += (m - n) * handledCPCountPlusOne; - n = m; - - for (j = 0; j < inputLength; ++j) { - currentValue = input[j]; - - if (currentValue < n && ++delta > maxInt) { - error('overflow'); - } - - if (currentValue == n) { - // Represent delta as a generalized variable-length integer - for (q = delta, k = base; /* no condition */; k += base) { - t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); - if (q < t) { - break; - } - qMinusT = q - t; - baseMinusT = base - t; - output.push( - stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) - ); - q = floor(qMinusT / baseMinusT); - } - - output.push(stringFromCharCode(digitToBasic(q, 0))); - bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); - delta = 0; - ++handledCPCount; - } - } - - ++delta; - ++n; - - } - return output.join(''); - } - - /** - * Converts a Punycode string representing a domain name or an email address - * to Unicode. Only the Punycoded parts of the input will be converted, i.e. - * it doesn't matter if you call it on a string that has already been - * converted to Unicode. - * @memberOf punycode - * @param {String} input The Punycoded domain name or email address to - * convert to Unicode. - * @returns {String} The Unicode representation of the given Punycode - * string. - */ - function toUnicode(input) { - return mapDomain(input, function(string) { - return regexPunycode.test(string) - ? decode(string.slice(4).toLowerCase()) - : string; - }); - } - - /** - * Converts a Unicode string representing a domain name or an email address to - * Punycode. Only the non-ASCII parts of the domain name will be converted, - * i.e. it doesn't matter if you call it with a domain that's already in - * ASCII. - * @memberOf punycode - * @param {String} input The domain name or email address to convert, as a - * Unicode string. - * @returns {String} The Punycode representation of the given domain name or - * email address. - */ - function toASCII(input) { - return mapDomain(input, function(string) { - return regexNonASCII.test(string) - ? 'xn--' + encode(string) - : string; - }); - } - - /*--------------------------------------------------------------------------*/ - - /** Define the public API */ - punycode = { - /** - * A string representing the current Punycode.js version number. - * @memberOf punycode - * @type String - */ - 'version': '1.4.1', - /** - * An object of methods to convert from JavaScript's internal character - * representation (UCS-2) to Unicode code points, and back. - * @see - * @memberOf punycode - * @type Object - */ - 'ucs2': { - 'decode': ucs2decode, - 'encode': ucs2encode - }, - 'decode': decode, - 'encode': encode, - 'toASCII': toASCII, - 'toUnicode': toUnicode - }; - - /** Expose `punycode` */ - // Some AMD build optimizers, like r.js, check for specific condition patterns - // like the following: - if ( - typeof define == 'function' && - typeof define.amd == 'object' && - define.amd - ) { - define('punycode', function() { - return punycode; - }); - } else if (freeExports && freeModule) { - if (module.exports == freeExports) { - // in Node.js, io.js, or RingoJS v0.8.0+ - freeModule.exports = punycode; - } else { - // in Narwhal or RingoJS v0.7.0- - for (key in punycode) { - punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]); - } - } - } else { - // in Rhino or a web browser - root.punycode = punycode; - } - -}(this)); - -}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],13:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -'use strict'; - -// If obj.hasOwnProperty has been overridden, then calling -// obj.hasOwnProperty(prop) will break. -// See: https://github.com/joyent/node/issues/1707 -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -module.exports = function(qs, sep, eq, options) { - sep = sep || '&'; - eq = eq || '='; - var obj = {}; - - if (typeof qs !== 'string' || qs.length === 0) { - return obj; - } - - var regexp = /\+/g; - qs = qs.split(sep); - - var maxKeys = 1000; - if (options && typeof options.maxKeys === 'number') { - maxKeys = options.maxKeys; - } - - var len = qs.length; - // maxKeys <= 0 means that we should not limit keys count - if (maxKeys > 0 && len > maxKeys) { - len = maxKeys; - } - - for (var i = 0; i < len; ++i) { - var x = qs[i].replace(regexp, '%20'), - idx = x.indexOf(eq), - kstr, vstr, k, v; - - if (idx >= 0) { - kstr = x.substr(0, idx); - vstr = x.substr(idx + 1); - } else { - kstr = x; - vstr = ''; - } - - k = decodeURIComponent(kstr); - v = decodeURIComponent(vstr); - - if (!hasOwnProperty(obj, k)) { - obj[k] = v; - } else if (isArray(obj[k])) { - obj[k].push(v); - } else { - obj[k] = [obj[k], v]; - } - } - - return obj; -}; - -var isArray = Array.isArray || function (xs) { - return Object.prototype.toString.call(xs) === '[object Array]'; -}; - -},{}],14:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -'use strict'; - -var stringifyPrimitive = function(v) { - switch (typeof v) { - case 'string': - return v; - - case 'boolean': - return v ? 'true' : 'false'; - - case 'number': - return isFinite(v) ? v : ''; - - default: - return ''; - } -}; - -module.exports = function(obj, sep, eq, name) { - sep = sep || '&'; - eq = eq || '='; - if (obj === null) { - obj = undefined; - } - - if (typeof obj === 'object') { - return map(objectKeys(obj), function(k) { - var ks = encodeURIComponent(stringifyPrimitive(k)) + eq; - if (isArray(obj[k])) { - return map(obj[k], function(v) { - return ks + encodeURIComponent(stringifyPrimitive(v)); - }).join(sep); - } else { - return ks + encodeURIComponent(stringifyPrimitive(obj[k])); - } - }).join(sep); - - } - - if (!name) return ''; - return encodeURIComponent(stringifyPrimitive(name)) + eq + - encodeURIComponent(stringifyPrimitive(obj)); -}; - -var isArray = Array.isArray || function (xs) { - return Object.prototype.toString.call(xs) === '[object Array]'; -}; - -function map (xs, f) { - if (xs.map) return xs.map(f); - var res = []; - for (var i = 0; i < xs.length; i++) { - res.push(f(xs[i], i)); - } - return res; -} - -var objectKeys = Object.keys || function (obj) { - var res = []; - for (var key in obj) { - if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key); - } - return res; -}; - -},{}],15:[function(require,module,exports){ -'use strict'; - -exports.decode = exports.parse = require('./decode'); -exports.encode = exports.stringify = require('./encode'); - -},{"./decode":13,"./encode":14}],16:[function(require,module,exports){ -module.exports = require('./lib/_stream_duplex.js'); - -},{"./lib/_stream_duplex.js":17}],17:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -// a duplex stream is just a stream that is both readable and writable. -// Since JS doesn't have multiple prototypal inheritance, this class -// prototypally inherits from Readable, and then parasitically from -// Writable. - -'use strict'; - -/**/ - -var pna = require('process-nextick-args'); -/**/ - -/**/ -var objectKeys = Object.keys || function (obj) { - var keys = []; - for (var key in obj) { - keys.push(key); - }return keys; -}; -/**/ - -module.exports = Duplex; - -/**/ -var util = Object.create(require('core-util-is')); -util.inherits = require('inherits'); -/**/ - -var Readable = require('./_stream_readable'); -var Writable = require('./_stream_writable'); - -util.inherits(Duplex, Readable); - -{ - // avoid scope creep, the keys array can then be collected - var keys = objectKeys(Writable.prototype); - for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; - } -} - -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { - // making it explicit this property is not enumerable - // because otherwise some prototype manipulation in - // userland will fail - enumerable: false, - get: function () { - return this._writableState.highWaterMark; - } -}); - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - pna.nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -Object.defineProperty(Duplex.prototype, 'destroyed', { - get: function () { - if (this._readableState === undefined || this._writableState === undefined) { - return false; - } - return this._readableState.destroyed && this._writableState.destroyed; - }, - set: function (value) { - // we ignore the value if the stream - // has not been initialized yet - if (this._readableState === undefined || this._writableState === undefined) { - return; - } - - // backward compatibility, the user is explicitly - // managing destroyed - this._readableState.destroyed = value; - this._writableState.destroyed = value; - } -}); - -Duplex.prototype._destroy = function (err, cb) { - this.push(null); - this.end(); - - pna.nextTick(cb, err); -}; -},{"./_stream_readable":19,"./_stream_writable":21,"core-util-is":4,"inherits":7,"process-nextick-args":10}],18:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -// a passthrough stream. -// basically just the most minimal sort of Transform stream. -// Every written chunk gets output as-is. - -'use strict'; - -module.exports = PassThrough; - -var Transform = require('./_stream_transform'); - -/**/ -var util = Object.create(require('core-util-is')); -util.inherits = require('inherits'); -/**/ - -util.inherits(PassThrough, Transform); - -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; -},{"./_stream_transform":20,"core-util-is":4,"inherits":7}],19:[function(require,module,exports){ -(function (process,global){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -'use strict'; - -/**/ - -var pna = require('process-nextick-args'); -/**/ - -module.exports = Readable; - -/**/ -var isArray = require('isarray'); -/**/ - -/**/ -var Duplex; -/**/ - -Readable.ReadableState = ReadableState; - -/**/ -var EE = require('events').EventEmitter; - -var EElistenerCount = function (emitter, type) { - return emitter.listeners(type).length; -}; -/**/ - -/**/ -var Stream = require('./internal/streams/stream'); -/**/ - -/**/ - -var Buffer = require('safe-buffer').Buffer; -var OurUint8Array = global.Uint8Array || function () {}; -function _uint8ArrayToBuffer(chunk) { - return Buffer.from(chunk); -} -function _isUint8Array(obj) { - return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; -} - -/**/ - -/**/ -var util = Object.create(require('core-util-is')); -util.inherits = require('inherits'); -/**/ - -/**/ -var debugUtil = require('util'); -var debug = void 0; -if (debugUtil && debugUtil.debuglog) { - debug = debugUtil.debuglog('stream'); -} else { - debug = function () {}; -} -/**/ - -var BufferList = require('./internal/streams/BufferList'); -var destroyImpl = require('./internal/streams/destroy'); -var StringDecoder; - -util.inherits(Readable, Stream); - -var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); - - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; -} - -function ReadableState(options, stream) { - Duplex = Duplex || require('./_stream_duplex'); - - options = options || {}; - - // Duplex streams are both readable and writable, but share - // the same options object. - // However, some cases require setting options to different - // values for the readable and the writable sides of the duplex stream. - // These options can be provided separately as readableXXX and writableXXX. - var isDuplex = stream instanceof Duplex; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var readableHwm = options.readableHighWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - - if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm; - - // cast to ints. - this.highWaterMark = Math.floor(this.highWaterMark); - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the event 'readable'/'data' is emitted - // immediately, or on a later tick. We set this to true at first, because - // any actions that shouldn't happen until "later" should generally also - // not happen before the first read call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // has it been destroyed - this.destroyed = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} - -function Readable(options) { - Duplex = Duplex || require('./_stream_duplex'); - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options) { - if (typeof options.read === 'function') this._read = options.read; - - if (typeof options.destroy === 'function') this._destroy = options.destroy; - } - - Stream.call(this); -} - -Object.defineProperty(Readable.prototype, 'destroyed', { - get: function () { - if (this._readableState === undefined) { - return false; - } - return this._readableState.destroyed; - }, - set: function (value) { - // we ignore the value if the stream - // has not been initialized yet - if (!this._readableState) { - return; - } - - // backward compatibility, the user is explicitly - // managing destroyed - this._readableState.destroyed = value; - } -}); - -Readable.prototype.destroy = destroyImpl.destroy; -Readable.prototype._undestroy = destroyImpl.undestroy; -Readable.prototype._destroy = function (err, cb) { - this.push(null); - cb(err); -}; - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - var skipChunkCheck; - - if (!state.objectMode) { - if (typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - skipChunkCheck = true; - } - } else { - skipChunkCheck = true; - } - - return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - return readableAddChunk(this, chunk, null, true, false); -}; - -function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { - var state = stream._readableState; - if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else { - var er; - if (!skipChunkCheck) er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { - chunk = _uint8ArrayToBuffer(chunk); - } - - if (addToFront) { - if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); - } else if (state.ended) { - stream.emit('error', new Error('stream.push() after EOF')); - } else { - state.reading = false; - if (state.decoder && !encoding) { - chunk = state.decoder.write(chunk); - if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); - } else { - addChunk(stream, state, chunk, false); - } - } - } else if (!addToFront) { - state.reading = false; - } - } - - return needMoreData(state); -} - -function addChunk(stream, state, chunk, addToFront) { - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - maybeReadMore(stream, state); -} - -function chunkInvalid(state, chunk) { - var er; - if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder; - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - pna.nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('_read() is not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; - - var endFn = doEnd ? onend : unpipe; - if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable, unpipeInfo) { - debug('onunpipe'); - if (readable === src) { - if (unpipeInfo && unpipeInfo.hasUnpiped === false) { - unpipeInfo.hasUnpiped = true; - cleanup(); - } - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', unpipe); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - var unpipeInfo = { hasUnpiped: false }; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this, unpipeInfo); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var i = 0; i < len; i++) { - dests[i].emit('unpipe', this, unpipeInfo); - }return this; - } - - // try to find the right one. - var index = indexOf(state.pipes, dest); - if (index === -1) return this; - - state.pipes.splice(index, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this, unpipeInfo); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = Stream.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - pna.nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - pna.nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var _this = this; - - var state = this._readableState; - var paused = false; - - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) _this.push(chunk); - } - - _this.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = _this.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - for (var n = 0; n < kProxyEvents.length; n++) { - stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); - } - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - this._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return this; -}; - -Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { - // making it explicit this property is not enumerable - // because otherwise some prototype manipulation in - // userland will fail - enumerable: false, - get: function () { - return this._readableState.highWaterMark; - } -}); - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - pna.nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} -}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{"./_stream_duplex":17,"./internal/streams/BufferList":22,"./internal/streams/destroy":23,"./internal/streams/stream":24,"_process":11,"core-util-is":4,"events":5,"inherits":7,"isarray":9,"process-nextick-args":10,"safe-buffer":25,"string_decoder/":26,"util":2}],20:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -// a transform stream is a readable/writable stream where you do -// something with the data. Sometimes it's called a "filter", -// but that's not a great name for it, since that implies a thing where -// some bits pass through, and others are simply ignored. (That would -// be a valid example of a transform, of course.) -// -// While the output is causally related to the input, it's not a -// necessarily symmetric or synchronous transformation. For example, -// a zlib stream might take multiple plain-text writes(), and then -// emit a single compressed chunk some time in the future. -// -// Here's how this works: -// -// The Transform stream has all the aspects of the readable and writable -// stream classes. When you write(chunk), that calls _write(chunk,cb) -// internally, and returns false if there's a lot of pending writes -// buffered up. When you call read(), that calls _read(n) until -// there's enough pending readable data buffered up. -// -// In a transform stream, the written data is placed in a buffer. When -// _read(n) is called, it transforms the queued up data, calling the -// buffered _write cb's as it consumes chunks. If consuming a single -// written chunk would result in multiple output chunks, then the first -// outputted bit calls the readcb, and subsequent chunks just go into -// the read buffer, and will cause it to emit 'readable' if necessary. -// -// This way, back-pressure is actually determined by the reading side, -// since _read has to be called to start processing a new chunk. However, -// a pathological inflate type of transform can cause excessive buffering -// here. For example, imagine a stream where every byte of input is -// interpreted as an integer from 0-255, and then results in that many -// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in -// 1kb of data being output. In this case, you could write a very small -// amount of input, and end up with a very large amount of output. In -// such a pathological inflating mechanism, there'd be no way to tell -// the system to stop doing the transform. A single 4MB write could -// cause the system to run out of memory. -// -// However, even in such a pathological case, only a single written chunk -// would be consumed, and then the rest would wait (un-transformed) until -// the results of the previous transformed chunk were consumed. - -'use strict'; - -module.exports = Transform; - -var Duplex = require('./_stream_duplex'); - -/**/ -var util = Object.create(require('core-util-is')); -util.inherits = require('inherits'); -/**/ - -util.inherits(Transform, Duplex); - -function afterTransform(er, data) { - var ts = this._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) { - return this.emit('error', new Error('write callback called multiple times')); - } - - ts.writechunk = null; - ts.writecb = null; - - if (data != null) // single equals check for both `null` and `undefined` - this.push(data); - - cb(er); - - var rs = this._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - this._read(rs.highWaterMark); - } -} - -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = { - afterTransform: afterTransform.bind(this), - needTransform: false, - transforming: false, - writecb: null, - writechunk: null, - writeencoding: null - }; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - // When the writable side finishes, then flush out anything remaining. - this.on('prefinish', prefinish); -} - -function prefinish() { - var _this = this; - - if (typeof this._flush === 'function') { - this._flush(function (er, data) { - done(_this, er, data); - }); - } else { - done(this, null, null); - } -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('_transform() is not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -Transform.prototype._destroy = function (err, cb) { - var _this2 = this; - - Duplex.prototype._destroy.call(this, err, function (err2) { - cb(err2); - _this2.emit('close'); - }); -}; - -function done(stream, er, data) { - if (er) return stream.emit('error', er); - - if (data != null) // single equals check for both `null` and `undefined` - stream.push(data); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0'); - - if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} -},{"./_stream_duplex":17,"core-util-is":4,"inherits":7}],21:[function(require,module,exports){ -(function (process,global,setImmediate){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -// A bit simpler than readable streams. -// Implement an async ._write(chunk, encoding, cb), and it'll handle all -// the drain event emission and buffering. - -'use strict'; - -/**/ - -var pna = require('process-nextick-args'); -/**/ - -module.exports = Writable; - -/* */ -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - this.finish = function () { - onCorkedFinish(_this, state); - }; -} -/* */ - -/**/ -var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; -/**/ - -/**/ -var Duplex; -/**/ - -Writable.WritableState = WritableState; - -/**/ -var util = Object.create(require('core-util-is')); -util.inherits = require('inherits'); -/**/ - -/**/ -var internalUtil = { - deprecate: require('util-deprecate') -}; -/**/ - -/**/ -var Stream = require('./internal/streams/stream'); -/**/ - -/**/ - -var Buffer = require('safe-buffer').Buffer; -var OurUint8Array = global.Uint8Array || function () {}; -function _uint8ArrayToBuffer(chunk) { - return Buffer.from(chunk); -} -function _isUint8Array(obj) { - return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; -} - -/**/ - -var destroyImpl = require('./internal/streams/destroy'); - -util.inherits(Writable, Stream); - -function nop() {} - -function WritableState(options, stream) { - Duplex = Duplex || require('./_stream_duplex'); - - options = options || {}; - - // Duplex streams are both readable and writable, but share - // the same options object. - // However, some cases require setting options to different - // values for the readable and the writable sides of the duplex stream. - // These options can be provided separately as readableXXX and writableXXX. - var isDuplex = stream instanceof Duplex; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var writableHwm = options.writableHighWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - - if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; - - // cast to ints. - this.highWaterMark = Math.floor(this.highWaterMark); - - // if _final has been called - this.finalCalled = false; - - // drain event flag. - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // has it been destroyed - this.destroyed = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function getBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; - -(function () { - try { - Object.defineProperty(WritableState.prototype, 'buffer', { - get: internalUtil.deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') - }); - } catch (_) {} -})(); - -// Test _writableState for inheritance to account for Duplex streams, -// whose prototype chain only points to Readable. -var realHasInstance; -if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { - realHasInstance = Function.prototype[Symbol.hasInstance]; - Object.defineProperty(Writable, Symbol.hasInstance, { - value: function (object) { - if (realHasInstance.call(this, object)) return true; - if (this !== Writable) return false; - - return object && object._writableState instanceof WritableState; - } - }); -} else { - realHasInstance = function (object) { - return object instanceof this; - }; -} - -function Writable(options) { - Duplex = Duplex || require('./_stream_duplex'); - - // Writable ctor is applied to Duplexes, too. - // `realHasInstance` is necessary because using plain `instanceof` - // would return false, as no `_writableState` property is attached. - - // Trying to use the custom `instanceof` for Writable here will also break the - // Node.js LazyTransform implementation, which has a non-trivial getter for - // `_writableState` that would lead to infinite recursion. - if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { - return new Writable(options); - } - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - - if (typeof options.destroy === 'function') this._destroy = options.destroy; - - if (typeof options.final === 'function') this._final = options.final; - } - - Stream.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - pna.nextTick(cb, er); -} - -// Checks that a user-supplied chunk is valid, especially for the particular -// mode the stream is in. Currently this means that `null` is never accepted -// and undefined/non-string values are only allowed in object mode. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - pna.nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - var isBuf = !state.objectMode && _isUint8Array(chunk); - - if (isBuf && !Buffer.isBuffer(chunk)) { - chunk = _uint8ArrayToBuffer(chunk); - } - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { - // making it explicit this property is not enumerable - // because otherwise some prototype manipulation in - // userland will fail - enumerable: false, - get: function () { - return this._writableState.highWaterMark; - } -}); - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { - if (!isBuf) { - var newChunk = decodeChunk(state, chunk, encoding); - if (chunk !== newChunk) { - isBuf = true; - encoding = 'buffer'; - chunk = newChunk; - } - } - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = { - chunk: chunk, - encoding: encoding, - isBuf: isBuf, - callback: cb, - next: null - }; - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - - if (sync) { - // defer the callback if we are being called synchronously - // to avoid piling up things on the stack - pna.nextTick(cb, er); - // this can emit finish, and it will always happen - // after error - pna.nextTick(finishMaybe, stream, state); - stream._writableState.errorEmitted = true; - stream.emit('error', er); - } else { - // the caller expect this to happen before if - // it is async - cb(er); - stream._writableState.errorEmitted = true; - stream.emit('error', er); - // this can emit finish, but finish must - // always follow error - finishMaybe(stream, state); - } -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - asyncWrite(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - var allBuffers = true; - while (entry) { - buffer[count] = entry; - if (!entry.isBuf) allBuffers = false; - entry = entry.next; - count += 1; - } - buffer.allBuffers = allBuffers; - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - state.bufferedRequestCount = 0; - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - state.bufferedRequestCount--; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('_write() is not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} -function callFinal(stream, state) { - stream._final(function (err) { - state.pendingcb--; - if (err) { - stream.emit('error', err); - } - state.prefinished = true; - stream.emit('prefinish'); - finishMaybe(stream, state); - }); -} -function prefinish(stream, state) { - if (!state.prefinished && !state.finalCalled) { - if (typeof stream._final === 'function') { - state.pendingcb++; - state.finalCalled = true; - pna.nextTick(callFinal, stream, state); - } else { - state.prefinished = true; - stream.emit('prefinish'); - } - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - prefinish(stream, state); - if (state.pendingcb === 0) { - state.finished = true; - stream.emit('finish'); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) pna.nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -function onCorkedFinish(corkReq, state, err) { - var entry = corkReq.entry; - corkReq.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = corkReq; - } else { - state.corkedRequestsFree = corkReq; - } -} - -Object.defineProperty(Writable.prototype, 'destroyed', { - get: function () { - if (this._writableState === undefined) { - return false; - } - return this._writableState.destroyed; - }, - set: function (value) { - // we ignore the value if the stream - // has not been initialized yet - if (!this._writableState) { - return; - } - - // backward compatibility, the user is explicitly - // managing destroyed - this._writableState.destroyed = value; - } -}); - -Writable.prototype.destroy = destroyImpl.destroy; -Writable.prototype._undestroy = destroyImpl.undestroy; -Writable.prototype._destroy = function (err, cb) { - this.end(); - cb(err); -}; -}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate) -},{"./_stream_duplex":17,"./internal/streams/destroy":23,"./internal/streams/stream":24,"_process":11,"core-util-is":4,"inherits":7,"process-nextick-args":10,"safe-buffer":25,"timers":32,"util-deprecate":34}],22:[function(require,module,exports){ -'use strict'; - -function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } - -var Buffer = require('safe-buffer').Buffer; -var util = require('util'); - -function copyBuffer(src, target, offset) { - src.copy(target, offset); -} - -module.exports = function () { - function BufferList() { - _classCallCheck(this, BufferList); - - this.head = null; - this.tail = null; - this.length = 0; - } - - BufferList.prototype.push = function push(v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; - }; - - BufferList.prototype.unshift = function unshift(v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; - }; - - BufferList.prototype.shift = function shift() { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; - }; - - BufferList.prototype.clear = function clear() { - this.head = this.tail = null; - this.length = 0; - }; - - BufferList.prototype.join = function join(s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; - }; - - BufferList.prototype.concat = function concat(n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - copyBuffer(p.data, ret, i); - i += p.data.length; - p = p.next; - } - return ret; - }; - - return BufferList; -}(); - -if (util && util.inspect && util.inspect.custom) { - module.exports.prototype[util.inspect.custom] = function () { - var obj = util.inspect({ length: this.length }); - return this.constructor.name + ' ' + obj; - }; -} -},{"safe-buffer":25,"util":2}],23:[function(require,module,exports){ -'use strict'; - -/**/ - -var pna = require('process-nextick-args'); -/**/ - -// undocumented cb() API, needed for core, not for public API -function destroy(err, cb) { - var _this = this; - - var readableDestroyed = this._readableState && this._readableState.destroyed; - var writableDestroyed = this._writableState && this._writableState.destroyed; - - if (readableDestroyed || writableDestroyed) { - if (cb) { - cb(err); - } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { - pna.nextTick(emitErrorNT, this, err); - } - return this; - } - - // we set destroyed to true before firing error callbacks in order - // to make it re-entrance safe in case destroy() is called within callbacks - - if (this._readableState) { - this._readableState.destroyed = true; - } - - // if this is a duplex stream mark the writable part as destroyed as well - if (this._writableState) { - this._writableState.destroyed = true; - } - - this._destroy(err || null, function (err) { - if (!cb && err) { - pna.nextTick(emitErrorNT, _this, err); - if (_this._writableState) { - _this._writableState.errorEmitted = true; - } - } else if (cb) { - cb(err); - } - }); - - return this; -} - -function undestroy() { - if (this._readableState) { - this._readableState.destroyed = false; - this._readableState.reading = false; - this._readableState.ended = false; - this._readableState.endEmitted = false; - } - - if (this._writableState) { - this._writableState.destroyed = false; - this._writableState.ended = false; - this._writableState.ending = false; - this._writableState.finished = false; - this._writableState.errorEmitted = false; - } -} - -function emitErrorNT(self, err) { - self.emit('error', err); -} - -module.exports = { - destroy: destroy, - undestroy: undestroy -}; -},{"process-nextick-args":10}],24:[function(require,module,exports){ -module.exports = require('events').EventEmitter; - -},{"events":5}],25:[function(require,module,exports){ -/* eslint-disable node/no-deprecated-api */ -var buffer = require('buffer') -var Buffer = buffer.Buffer - -// alternative to using Object.keys for old browsers -function copyProps (src, dst) { - for (var key in src) { - dst[key] = src[key] - } -} -if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { - module.exports = buffer -} else { - // Copy properties from require('buffer') - copyProps(buffer, exports) - exports.Buffer = SafeBuffer -} - -function SafeBuffer (arg, encodingOrOffset, length) { - return Buffer(arg, encodingOrOffset, length) -} - -// Copy static methods from Buffer -copyProps(Buffer, SafeBuffer) - -SafeBuffer.from = function (arg, encodingOrOffset, length) { - if (typeof arg === 'number') { - throw new TypeError('Argument must not be a number') - } - return Buffer(arg, encodingOrOffset, length) -} - -SafeBuffer.alloc = function (size, fill, encoding) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - var buf = Buffer(size) - if (fill !== undefined) { - if (typeof encoding === 'string') { - buf.fill(fill, encoding) - } else { - buf.fill(fill) - } - } else { - buf.fill(0) - } - return buf -} - -SafeBuffer.allocUnsafe = function (size) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - return Buffer(size) -} - -SafeBuffer.allocUnsafeSlow = function (size) { - if (typeof size !== 'number') { - throw new TypeError('Argument must be a number') - } - return buffer.SlowBuffer(size) -} - -},{"buffer":3}],26:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -'use strict'; - -/**/ - -var Buffer = require('safe-buffer').Buffer; -/**/ - -var isEncoding = Buffer.isEncoding || function (encoding) { - encoding = '' + encoding; - switch (encoding && encoding.toLowerCase()) { - case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': - return true; - default: - return false; - } -}; - -function _normalizeEncoding(enc) { - if (!enc) return 'utf8'; - var retried; - while (true) { - switch (enc) { - case 'utf8': - case 'utf-8': - return 'utf8'; - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return 'utf16le'; - case 'latin1': - case 'binary': - return 'latin1'; - case 'base64': - case 'ascii': - case 'hex': - return enc; - default: - if (retried) return; // undefined - enc = ('' + enc).toLowerCase(); - retried = true; - } - } -}; - -// Do not cache `Buffer.isEncoding` when checking encoding names as some -// modules monkey-patch it to support additional encodings -function normalizeEncoding(enc) { - var nenc = _normalizeEncoding(enc); - if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); - return nenc || enc; -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. -exports.StringDecoder = StringDecoder; -function StringDecoder(encoding) { - this.encoding = normalizeEncoding(encoding); - var nb; - switch (this.encoding) { - case 'utf16le': - this.text = utf16Text; - this.end = utf16End; - nb = 4; - break; - case 'utf8': - this.fillLast = utf8FillLast; - nb = 4; - break; - case 'base64': - this.text = base64Text; - this.end = base64End; - nb = 3; - break; - default: - this.write = simpleWrite; - this.end = simpleEnd; - return; - } - this.lastNeed = 0; - this.lastTotal = 0; - this.lastChar = Buffer.allocUnsafe(nb); -} - -StringDecoder.prototype.write = function (buf) { - if (buf.length === 0) return ''; - var r; - var i; - if (this.lastNeed) { - r = this.fillLast(buf); - if (r === undefined) return ''; - i = this.lastNeed; - this.lastNeed = 0; - } else { - i = 0; - } - if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); - return r || ''; -}; - -StringDecoder.prototype.end = utf8End; - -// Returns only complete characters in a Buffer -StringDecoder.prototype.text = utf8Text; - -// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer -StringDecoder.prototype.fillLast = function (buf) { - if (this.lastNeed <= buf.length) { - buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); - return this.lastChar.toString(this.encoding, 0, this.lastTotal); - } - buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); - this.lastNeed -= buf.length; -}; - -// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a -// continuation byte. If an invalid byte is detected, -2 is returned. -function utf8CheckByte(byte) { - if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; - return byte >> 6 === 0x02 ? -1 : -2; -} - -// Checks at most 3 bytes at the end of a Buffer in order to detect an -// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) -// needed to complete the UTF-8 character (if applicable) are returned. -function utf8CheckIncomplete(self, buf, i) { - var j = buf.length - 1; - if (j < i) return 0; - var nb = utf8CheckByte(buf[j]); - if (nb >= 0) { - if (nb > 0) self.lastNeed = nb - 1; - return nb; - } - if (--j < i || nb === -2) return 0; - nb = utf8CheckByte(buf[j]); - if (nb >= 0) { - if (nb > 0) self.lastNeed = nb - 2; - return nb; - } - if (--j < i || nb === -2) return 0; - nb = utf8CheckByte(buf[j]); - if (nb >= 0) { - if (nb > 0) { - if (nb === 2) nb = 0;else self.lastNeed = nb - 3; - } - return nb; - } - return 0; -} - -// Validates as many continuation bytes for a multi-byte UTF-8 character as -// needed or are available. If we see a non-continuation byte where we expect -// one, we "replace" the validated continuation bytes we've seen so far with -// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding -// behavior. The continuation byte check is included three times in the case -// where all of the continuation bytes for a character exist in the same buffer. -// It is also done this way as a slight performance increase instead of using a -// loop. -function utf8CheckExtraBytes(self, buf, p) { - if ((buf[0] & 0xC0) !== 0x80) { - self.lastNeed = 0; - return '\ufffd'; - } - if (self.lastNeed > 1 && buf.length > 1) { - if ((buf[1] & 0xC0) !== 0x80) { - self.lastNeed = 1; - return '\ufffd'; - } - if (self.lastNeed > 2 && buf.length > 2) { - if ((buf[2] & 0xC0) !== 0x80) { - self.lastNeed = 2; - return '\ufffd'; - } - } - } -} - -// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. -function utf8FillLast(buf) { - var p = this.lastTotal - this.lastNeed; - var r = utf8CheckExtraBytes(this, buf, p); - if (r !== undefined) return r; - if (this.lastNeed <= buf.length) { - buf.copy(this.lastChar, p, 0, this.lastNeed); - return this.lastChar.toString(this.encoding, 0, this.lastTotal); - } - buf.copy(this.lastChar, p, 0, buf.length); - this.lastNeed -= buf.length; -} - -// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a -// partial character, the character's bytes are buffered until the required -// number of bytes are available. -function utf8Text(buf, i) { - var total = utf8CheckIncomplete(this, buf, i); - if (!this.lastNeed) return buf.toString('utf8', i); - this.lastTotal = total; - var end = buf.length - (total - this.lastNeed); - buf.copy(this.lastChar, 0, end); - return buf.toString('utf8', i, end); -} - -// For UTF-8, a replacement character is added when ending on a partial -// character. -function utf8End(buf) { - var r = buf && buf.length ? this.write(buf) : ''; - if (this.lastNeed) return r + '\ufffd'; - return r; -} - -// UTF-16LE typically needs two bytes per character, but even if we have an even -// number of bytes available, we need to check if we end on a leading/high -// surrogate. In that case, we need to wait for the next two bytes in order to -// decode the last character properly. -function utf16Text(buf, i) { - if ((buf.length - i) % 2 === 0) { - var r = buf.toString('utf16le', i); - if (r) { - var c = r.charCodeAt(r.length - 1); - if (c >= 0xD800 && c <= 0xDBFF) { - this.lastNeed = 2; - this.lastTotal = 4; - this.lastChar[0] = buf[buf.length - 2]; - this.lastChar[1] = buf[buf.length - 1]; - return r.slice(0, -1); - } - } - return r; - } - this.lastNeed = 1; - this.lastTotal = 2; - this.lastChar[0] = buf[buf.length - 1]; - return buf.toString('utf16le', i, buf.length - 1); -} - -// For UTF-16LE we do not explicitly append special replacement characters if we -// end on a partial character, we simply let v8 handle that. -function utf16End(buf) { - var r = buf && buf.length ? this.write(buf) : ''; - if (this.lastNeed) { - var end = this.lastTotal - this.lastNeed; - return r + this.lastChar.toString('utf16le', 0, end); - } - return r; -} - -function base64Text(buf, i) { - var n = (buf.length - i) % 3; - if (n === 0) return buf.toString('base64', i); - this.lastNeed = 3 - n; - this.lastTotal = 3; - if (n === 1) { - this.lastChar[0] = buf[buf.length - 1]; - } else { - this.lastChar[0] = buf[buf.length - 2]; - this.lastChar[1] = buf[buf.length - 1]; - } - return buf.toString('base64', i, buf.length - n); -} - -function base64End(buf) { - var r = buf && buf.length ? this.write(buf) : ''; - if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); - return r; -} - -// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) -function simpleWrite(buf) { - return buf.toString(this.encoding); -} - -function simpleEnd(buf) { - return buf && buf.length ? this.write(buf) : ''; -} -},{"safe-buffer":25}],27:[function(require,module,exports){ -module.exports = require('./readable').PassThrough - -},{"./readable":28}],28:[function(require,module,exports){ -exports = module.exports = require('./lib/_stream_readable.js'); -exports.Stream = exports; -exports.Readable = exports; -exports.Writable = require('./lib/_stream_writable.js'); -exports.Duplex = require('./lib/_stream_duplex.js'); -exports.Transform = require('./lib/_stream_transform.js'); -exports.PassThrough = require('./lib/_stream_passthrough.js'); - -},{"./lib/_stream_duplex.js":17,"./lib/_stream_passthrough.js":18,"./lib/_stream_readable.js":19,"./lib/_stream_transform.js":20,"./lib/_stream_writable.js":21}],29:[function(require,module,exports){ -module.exports = require('./readable').Transform - -},{"./readable":28}],30:[function(require,module,exports){ -module.exports = require('./lib/_stream_writable.js'); - -},{"./lib/_stream_writable.js":21}],31:[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -module.exports = Stream; - -var EE = require('events').EventEmitter; -var inherits = require('inherits'); - -inherits(Stream, EE); -Stream.Readable = require('readable-stream/readable.js'); -Stream.Writable = require('readable-stream/writable.js'); -Stream.Duplex = require('readable-stream/duplex.js'); -Stream.Transform = require('readable-stream/transform.js'); -Stream.PassThrough = require('readable-stream/passthrough.js'); - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - - - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EE.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EE.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; - -},{"events":5,"inherits":7,"readable-stream/duplex.js":16,"readable-stream/passthrough.js":27,"readable-stream/readable.js":28,"readable-stream/transform.js":29,"readable-stream/writable.js":30}],32:[function(require,module,exports){ -(function (setImmediate,clearImmediate){ -var nextTick = require('process/browser.js').nextTick; -var apply = Function.prototype.apply; -var slice = Array.prototype.slice; -var immediateIds = {}; -var nextImmediateId = 0; - -// DOM APIs, for completeness - -exports.setTimeout = function() { - return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout); -}; -exports.setInterval = function() { - return new Timeout(apply.call(setInterval, window, arguments), clearInterval); -}; -exports.clearTimeout = -exports.clearInterval = function(timeout) { timeout.close(); }; - -function Timeout(id, clearFn) { - this._id = id; - this._clearFn = clearFn; -} -Timeout.prototype.unref = Timeout.prototype.ref = function() {}; -Timeout.prototype.close = function() { - this._clearFn.call(window, this._id); -}; - -// Does not start the time, just sets up the members needed. -exports.enroll = function(item, msecs) { - clearTimeout(item._idleTimeoutId); - item._idleTimeout = msecs; -}; - -exports.unenroll = function(item) { - clearTimeout(item._idleTimeoutId); - item._idleTimeout = -1; -}; - -exports._unrefActive = exports.active = function(item) { - clearTimeout(item._idleTimeoutId); - - var msecs = item._idleTimeout; - if (msecs >= 0) { - item._idleTimeoutId = setTimeout(function onTimeout() { - if (item._onTimeout) - item._onTimeout(); - }, msecs); - } -}; - -// That's not how node.js implements it but the exposed api is the same. -exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { - var id = nextImmediateId++; - var args = arguments.length < 2 ? false : slice.call(arguments, 1); - - immediateIds[id] = true; - - nextTick(function onNextTick() { - if (immediateIds[id]) { - // fn.call() is faster so we optimize for the common use-case - // @see http://jsperf.com/call-apply-segu - if (args) { - fn.apply(null, args); - } else { - fn.call(null); - } - // Prevent ids from leaking - exports.clearImmediate(id); - } - }); - - return id; -}; - -exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { - delete immediateIds[id]; -}; -}).call(this,require("timers").setImmediate,require("timers").clearImmediate) -},{"process/browser.js":11,"timers":32}],33:[function(require,module,exports){ -'use strict'; - -module.exports = { - isString: function(arg) { - return typeof(arg) === 'string'; - }, - isObject: function(arg) { - return typeof(arg) === 'object' && arg !== null; - }, - isNull: function(arg) { - return arg === null; - }, - isNullOrUndefined: function(arg) { - return arg == null; - } -}; - -},{}],34:[function(require,module,exports){ -(function (global){ - -/** - * Module exports. - */ - -module.exports = deprecate; - -/** - * Mark that a method should not be used. - * Returns a modified function which warns once by default. - * - * If `localStorage.noDeprecation = true` is set, then it is a no-op. - * - * If `localStorage.throwDeprecation = true` is set, then deprecated functions - * will throw an Error when invoked. - * - * If `localStorage.traceDeprecation = true` is set, then deprecated functions - * will invoke `console.trace()` instead of `console.error()`. - * - * @param {Function} fn - the function to deprecate - * @param {String} msg - the string to print to the console when `fn` is invoked - * @returns {Function} a new "deprecated" version of `fn` - * @api public - */ - -function deprecate (fn, msg) { - if (config('noDeprecation')) { - return fn; - } - - var warned = false; - function deprecated() { - if (!warned) { - if (config('throwDeprecation')) { - throw new Error(msg); - } else if (config('traceDeprecation')) { - console.trace(msg); - } else { - console.warn(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -/** - * Checks `localStorage` for boolean values for the given `name`. - * - * @param {String} name - * @returns {Boolean} - * @api private - */ - -function config (name) { - // accessing global.localStorage can trigger a DOMException in sandboxed iframes - try { - if (!global.localStorage) return false; - } catch (_) { - return false; - } - var val = global.localStorage[name]; - if (null == val) return false; - return String(val).toLowerCase() === 'true'; -} - -}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) -},{}],35:[function(require,module,exports){ -const matMul = require('../lib/linalgebra/mat-mul.js'); -const transpose = require('../lib/linalgebra/transpose.js'); -const add = require('../lib/linalgebra/add.js'); -const invert = require('../lib/linalgebra/invert.js'); -const sub = require('../lib/linalgebra/sub.js'); -const getIdentity = require('../lib/linalgebra/identity.js'); -const State = require('./state.js'); - -/** -* @callback ObservationCallback -* @param {Object} opts -* @param {Number} opts.index -* @param {Number} opts.previousCorrected -*/ - -/** -* @typedef {Object} ObservationConfig -* @property {Number} dimension -* @property {Array.Array.> | ObservationCallback} stateProjection, -* @property {Array.Array.> | ObservationCallback} covariance -*/ - -/** -* @callback DynamicCallback -* @param {Object} opts -* @param {Number} opts.index -* @param {State} opts.predicted -* @param {Observation} opts.observation -*/ - -/** -* @typedef {Object} DynamicConfig -* @property {Number} dimension -* @property {Array.Array.> | DynamicCallback} transition, -* @property {Array.Array.> | DynamicCallback} covariance -*/ - -const defaultLogger = { - info: (...args) => console.log(...args), - debug: () => {}, - warn: (...args) => console.log(...args), - error: (...args) => console.log(...args) -}; - -/** -* @class -* @property {DynamicConfig} dynamic the system's dynamic model -* @property {ObservationConfig} observation the system's observation model -*@property logger a Winston-like logger -*/ -class CoreKalmanFilter { - /** - * @param {DynamicConfig} dynamic - * @param {ObservationConfig} observation the system's observation model - */ - - constructor({dynamic, observation, logger = defaultLogger}) { - this.dynamic = dynamic; - this.observation = observation; - this.logger = logger; - } - - getValue(fn, options) { - return (typeof (fn) === 'function' ? fn(options) : fn); - } - - getInitState() { - const {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init; - const initState = new State({ - mean: meanInit, - covariance: covarianceInit, - index: indexInit}); - return initState; - } - - /** - This will return the predicted covariance of a given previousCorrected State, this will help us to build the asymptoticState. - * @param {State} previousCorrected - * @returns{Array.>} - */ - - getPredictedCovariance({previousCorrected} = {}) { - previousCorrected = previousCorrected || this.getInitState(); - - const getValueOptions = {previousCorrected, index: previousCorrected.index}; - const d = this.getValue(this.dynamic.transition, getValueOptions); - const dTransposed = transpose(d); - const covarianceInter = matMul(d, previousCorrected.covariance); - const covariancePrevious = matMul(covarianceInter, dTransposed); - const dynCov = this.getValue(this.dynamic.covariance, getValueOptions); - - const covariance = add( - dynCov, - covariancePrevious - ); - return covariance; - } - - /** - This will return the new prediction, relatively to the dynamic model chosen - * @param {State} previousCorrected State relative to our dynamic model - * @returns{State} predicted State - */ - - predict({previousCorrected} = {}) { - previousCorrected = previousCorrected || this.getInitState(); - - State.check(previousCorrected, {dimension: this.dynamic.dimension}); - - const getValueOptions = {previousCorrected, index: previousCorrected.index}; - const d = this.getValue(this.dynamic.transition, getValueOptions); - - const mean = matMul(d, previousCorrected.mean); - - const covariance = this.getPredictedCovariance({previousCorrected}); - let index; - if (typeof (previousCorrected.index) === 'number') { - index = previousCorrected.index + 1; - } - else { - index = 'Index key is not defined' - } - - const predicted = new State({mean, covariance, index}); - this.logger.debug('Prediction done', predicted); - return predicted; - } - /** - This will return the new correction, taking into account the prediction made - and the observation of the sensor - * @param {State} predicted the previous State - * @returns{Array} kalmanGain - */ - - getGain({predicted, stateProjection}) { - const getValueOptions = {predicted, index: predicted.index}; - stateProjection = stateProjection || this.getValue(this.observation.stateProjection, getValueOptions); - const obsCovariance = this.getValue(this.observation.covariance, getValueOptions); - const stateProjTransposed = transpose(stateProjection); - const noiselessInnovation = matMul( - matMul(stateProjection, predicted.covariance), - stateProjTransposed - ); - const innovationCovariance = add(noiselessInnovation, obsCovariance); - const optimalKalmanGain = matMul( - matMul(predicted.covariance, stateProjTransposed), - invert(innovationCovariance) - ); - return optimalKalmanGain; - } - - /** - This will return the corrected covariance of a given predicted State, this will help us to build the asymptoticState. - * @param {State} predicted the previous State - * @returns{Array.>} - */ - - getCorrectedCovariance({predicted}) { - const getValueOptions = {predicted, index: predicted.index}; - const identity = getIdentity(predicted.covariance.length); - const stateProj = this.getValue(this.observation.stateProjection, getValueOptions); - const optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj}); - return matMul( - sub(identity, matMul(optimalKalmanGain, stateProj)), - predicted.covariance - ); - } - - /** - This will return the new correction, taking into account the prediction made - and the observation of the sensor - * @param {State} predicted the previous State - * @param {Array} observation the observation of the sensor - * @returns{State} corrected State of the Kalman Filter - */ - - correct({predicted, observation}) { - State.check(predicted, {dimension: this.dynamic.dimension}); - if (!observation) { - throw (new Error('no measure available')); - } - - const getValueOptions = {predicted, index: predicted.index}; - const stateProj = this.getValue(this.observation.stateProjection, getValueOptions); - - const optimalKalmanGain = this.getGain({predicted, stateProjection: stateProj}); - const innovation = sub( - observation, - matMul(stateProj, predicted.mean) - ); - const mean = add( - predicted.mean, - matMul(optimalKalmanGain, innovation) - ); - - const covariance = this.getCorrectedCovariance({predicted}); - const corrected = new State({mean, covariance, index: predicted.index}); - this.logger.debug('Correction done', corrected); - return corrected; - } -} - -module.exports = CoreKalmanFilter; - -},{"../lib/linalgebra/add.js":39,"../lib/linalgebra/identity.js":43,"../lib/linalgebra/invert.js":44,"../lib/linalgebra/mat-mul.js":45,"../lib/linalgebra/sub.js":47,"../lib/linalgebra/transpose.js":50,"./state.js":58}],36:[function(require,module,exports){ -const identity = require('../linalgebra/identity.js'); - -/** -*Creates a dynamic model, following constant acceleration model with respect with the dimensions provided in the observation parameters -* @param {DynamicConfig} dynamic -* @param {ObservationConfig} observation -* @returns {DynamicConfig} -*/ - -module.exports = function (dynamic, observation) { - const timeStep = dynamic.timeStep || 1; - const observedProjection = observation.observedProjection; - const stateProjection = observation.stateProjection; - const observationDimension = observation.dimension; - let dimension; - - if (stateProjection && Number.isInteger(stateProjection[0].length / 3)) { - dimension = observation.stateProjection[0].length; - } else if (observedProjection) { - dimension = observedProjection[0].length * 3; - } else if (observationDimension) { - dimension = observationDimension * 3; - } else { - throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter')); - } - - const baseDimension = dimension / 3; - // We construct the transition and covariance matrices - const transition = identity(dimension); - for (let i = 0; i < baseDimension; i++) { - transition[i][i + baseDimension] = timeStep; - transition[i][i + (2 * baseDimension)] = 0.5 * (timeStep ** 2); - transition[i + baseDimension][i + (2 * baseDimension)] = timeStep; - } - - const arrayCovariance = new Array(baseDimension).fill(1) - .concat(new Array(baseDimension).fill(timeStep * timeStep)) - .concat(new Array(baseDimension).fill(timeStep ** 4)); - const covariance = dynamic.covariance || arrayCovariance; - return Object.assign({}, dynamic, {dimension, transition, covariance}); -}; - -},{"../linalgebra/identity.js":43}],37:[function(require,module,exports){ -const identity = require('../linalgebra/identity.js'); -/** -*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters -* @param {DynamicConfig} dynamic -* @param {ObservationConfig} observation -* @returns {DynamicConfig} -*/ - -module.exports = function (dynamic, observation) { - let dimension = dynamic.dimension; - const observationDimension = observation.dimension; - const observedProjection = observation.observedProjection; - const stateProjection = observation.stateProjection; - let covariance = dynamic.covariance; - - if (!dynamic.dimension) { - if (observationDimension) { - dimension = observationDimension; - } else if (observedProjection) { - dimension = observedProjection[0].length; - } else if (stateProjection) { - dimension = stateProjection[0].length; - } - } - - const transition = identity(dimension); - covariance = covariance || identity(dimension); - return Object.assign({}, dynamic, {dimension, transition, covariance}); -}; - -},{"../linalgebra/identity.js":43}],38:[function(require,module,exports){ -const identity = require('../linalgebra/identity.js'); - -/** -*Creates a dynamic model, following constant position model with respect with the dimensions provided in the observation parameters -* @param {DynamicConfig} dynamic -* @param {ObservationConfig} observation -* @returns {DynamicConfig} -*/ - -module.exports = function (dynamic, observation) { - const timeStep = dynamic.timeStep || 1; - const observedProjection = observation.observedProjection; - const stateProjection = observation.stateProjection; - const observationDimension = observation.dimension; - let dimension; - - if (stateProjection && Number.isInteger(stateProjection[0].length / 2)) { - dimension = observation.stateProjection[0].length; - } else if (observedProjection) { - dimension = observedProjection[0].length * 2; - } else if (observationDimension) { - dimension = observationDimension * 2; - } else { - throw (new Error('observedProjection or stateProjection should be defined in observation in order to use constant-speed filter')); - } - - const baseDimension = dimension / 2; - // We construct the transition and covariance matrices - const transition = identity(dimension); - for (let i = 0; i < baseDimension; i++) { - transition[i][i + baseDimension] = timeStep; - } - - const arrayCovariance = new Array(baseDimension).fill(1).concat(new Array(baseDimension).fill(timeStep * timeStep)); - const covariance = dynamic.covariance || arrayCovariance; - return Object.assign({}, dynamic, {dimension, transition, covariance}); -}; - -},{"../linalgebra/identity.js":43}],39:[function(require,module,exports){ -const elemWise = require('./elem-wise'); -/** -* Add matrixes together -* @param {...>} args list of matrix -* @returns {Array.>} sum -*/ -module.exports = function (...args) { - return elemWise(args, args2 => { - return args2.reduce((a, b) => a + b, 0); - }); -}; - -},{"./elem-wise":42}],40:[function(require,module,exports){ -const zeros = require('./zeros'); - -module.exports = function (mat) { - const result = zeros(mat.length, mat.length); - - for (const [i, element] of mat.entries()) { - result[i][i] = element; - } - - return result; -}; - -},{"./zeros":51}],41:[function(require,module,exports){ -const trace = require('./trace.js'); -const transpose = require('./transpose.js'); -const matSub = require('./sub.js'); -const matMul = require('./mat-mul.js'); -const sum = require('./sum.js'); - -// [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm ) -module.exports = function (array1, array2) { - if (typeof (array1) === 'undefined') { - return sum(array2); - } - - if (typeof (array2) === 'undefined') { - return sum(array1); - } - - const m = matSub(array1, array2); - const p = matMul(transpose(m), m); - return Math.sqrt(trace(p)); -}; - -},{"./mat-mul.js":45,"./sub.js":47,"./sum.js":48,"./trace.js":49,"./transpose.js":50}],42:[function(require,module,exports){ -/** -* @callback elemWiseCb -* @param {Array.} arr -* @param {Number} rowId -* @param {Number} colId -*/ -/** -* run a function on cell per cell for each Matrixes -* @param {>>} arrMatrixes list of matrixes -* @param {elemWiseCb} fn -* @returns {Array.>} resulting matrix -* @example -// this will do m1 + m2 + m3 + m4 on matrixes -elemWise([m1, m2, m3, m4], args2 => { - return args2.reduce((a, b) => a + b, 0); -}); -*/ - -module.exports = function (arrayMatrixes, fn) { - return arrayMatrixes[0].map((row, rowId) => { - return row.map((cell, colId) => { - const array = arrayMatrixes.map(m => m[rowId][colId]); - return fn(array, rowId, colId); - }); - }); -}; - - -},{}],43:[function(require,module,exports){ -module.exports = function (stateSize) { - const identityArray = []; - for (let i = 0; i < stateSize; i++) { - const rowIdentity = []; - for (let j = 0; j < stateSize; j++) { - if (i === j) { - rowIdentity.push(1); - } else { - rowIdentity.push(0); - } - } - - identityArray.push(rowIdentity); - } - - return identityArray; -}; - -},{}],44:[function(require,module,exports){ -const matrixInverse = require('matrix-inverse'); - -module.exports = function (m) { - return matrixInverse(m); -}; - -},{"matrix-inverse":81}],45:[function(require,module,exports){ -/** -* Multiply 2 matrixes together -* @param {>} m1 -* @param {>} m2 -* @returns {Array.>} -*/ -module.exports = function (m1, m2) { - // Console.log({m1, m2}); - const result = []; - for (let i = 0; i < m1.length; i++) { - result[i] = []; - for (let j = 0; j < m2[0].length; j++) { - let sum = 0; - for (let k = 0; k < m1[0].length; k++) { - sum += m1[i][k] * m2[k][j]; - } - - result[i][j] = sum; - } - } - - return result; -}; - -},{}],46:[function(require,module,exports){ -/** -*This function returns the stateProjection paded with zeros with respect to a given -*observedProjection -*@param {Array. | Array.>} array the array we need to pad -*@param {Number} dimension in our case, the dynamic dimension -*@returns {Array. | Array.>} paded array -*/ -module.exports = function (array, {dimension}) { - const l = array[0].length; - if (dimension < l) { - throw (new TypeError('Dynamic dimension does not match with observedProjection')); - } - - for (let i = 0; i < l; i++) { - for (let j = 0; j < dimension - l; j++) { - array[i].push(0); - } - } - - return array; -}; - -},{}],47:[function(require,module,exports){ -const elemWise = require('./elem-wise'); - -module.exports = function (...args) { - return elemWise(args, ([a, b]) => a - b); -}; - -},{"./elem-wise":42}],48:[function(require,module,exports){ -// Sum all the terms of a given matrix -module.exports = function (array) { - let s = 0; - for (let i = 0; i < array.length; i++) { - for (let j = 0; j < array.length; j++) { - s += array[i][j]; - } - } - - return s; -}; - -},{}],49:[function(require,module,exports){ -module.exports = function (array) { - let diag = 0; - for (const [row, element] of array.entries()) { - diag += element[row]; - } - - return diag; -}; - -},{}],50:[function(require,module,exports){ -module.exports = function (array) { - return array[0].map((col, i) => array.map(row => row[i])); -}; - -},{}],51:[function(require,module,exports){ -module.exports = function (rows, cols) { - return new Array(rows).fill(1).map(() => new Array(cols).fill(0)); -}; - -},{}],52:[function(require,module,exports){ -const registeredDynamicModels = { - 'constant-position': require('../lib/dynamic/constant-position.js'), - 'constant-speed': require('../lib/dynamic/constant-speed.js'), - 'constant-acceleration': require('../lib/dynamic/constant-acceleration.js') -}; -const registeredObservationModels = { - sensors: require('../lib/observation/sensor.js') -}; - -/** -*RegisterObservation enables to create a new observation model and stock it -* @param {String} name -* @callback fn the function corresponding to the desired model -*/ - -/** -*registerDynamic enables to create a new dynamic model and stocks it -* @param {String} name -* @callback fn the function corresponding to the desired model -*/ - -/** -*buildObservation enables to build a model given an observation configuration -* @param {ObservationConfig} observation -* @returns {ObservationConfig} the configuration with respect to the model -*/ - -/** -*buildDynamic enables to build a model given dynamic and observation configurations -* @param {DynamicConfig} dynamic -* @param {ObservationConfig} observation -* @returns {DynamicConfig} the dynamic configuration with respect to the model -*/ - -module.exports = { - registerObservation: (name, fn) => { - registeredObservationModels[name] = fn; - }, - registerDynamic: (name, fn) => { - registeredDynamicModels[name] = fn; - }, - buildObservation: observation => { - if (!registeredObservationModels[observation.name]) { - throw (new Error('The provided observation model name is not registered')); - } - - return registeredObservationModels[observation.name](observation); - }, - buildDynamic: (dynamic, observation) => { - if (!registeredDynamicModels[dynamic.name]) { - throw (new Error('The provided dynamic model name is not registered')); - } - - return registeredDynamicModels[dynamic.name](dynamic, observation); - } -}; - -},{"../lib/dynamic/constant-acceleration.js":36,"../lib/dynamic/constant-position.js":37,"../lib/dynamic/constant-speed.js":38,"../lib/observation/sensor.js":53}],53:[function(require,module,exports){ -const identity = require('../linalgebra/identity.js'); -const polymorphMatrix = require('../utils/polymorph-matrix.js'); - -/** -* @param {Number} sensorDimension -* @param {CovarianceParam} sensorCovariance -* @param {Number} nSensors -* @returns {ObservationConfig} -*/ - -module.exports = function (options) { - const {sensorDimension = 1, sensorCovariance = 1, nSensors = 1} = options; - const sensorsCovariance = polymorphMatrix(sensorCovariance, {dimension: sensorDimension}); - const oneSensorObservedProjection = identity(sensorDimension); - let concatenatedObservedProjection = []; - let concatenatedCovariance = []; - for (let i = 0; i < nSensors; i++) { - concatenatedObservedProjection = concatenatedObservedProjection.concat(oneSensorObservedProjection); - concatenatedCovariance = concatenatedCovariance.concat(sensorsCovariance); - } - - const formattedCovariance = polymorphMatrix(concatenatedCovariance, {dimension: nSensors * sensorDimension}); - return Object.assign({}, options, { - dimension: sensorDimension * nSensors, - observedProjection: concatenatedObservedProjection, - covariance: formattedCovariance - }); -}; - -},{"../linalgebra/identity.js":43,"../utils/polymorph-matrix.js":62}],54:[function(require,module,exports){ -const padWithZeros = require('../linalgebra/pad-with-zeros.js'); -const identity = require('../linalgebra/identity.js'); -/** -*Builds the stateProjection given an observedProjection -*@param {ObservationConfig} observation -*@param {DynamicConfig} dynamic -*@returns {ObservationConfig, DynamicConfig} the model containing the created stateProjection -*/ - -module.exports = function ({observation, dynamic}) { - const {observedProjection, stateProjection} = observation; - const observationDimension = observation.dimension; - const dynamicDimension = dynamic.dimension; - if (observedProjection && stateProjection) { - throw (new TypeError('You cannot use both observedProjection and stateProjection')); - } - - if (observedProjection) { - return { - observation: Object.assign({}, observation, { - stateProjection: padWithZeros(observedProjection, {dimension: dynamicDimension}) - }), - dynamic - }; - } - - if (observationDimension && dynamicDimension) { - const observationMatrix = identity(observationDimension); - return { - observation: Object.assign({}, observation, { - stateProjection: padWithZeros(observationMatrix, {dimension: dynamicDimension}) - }), - dynamic - }; - } - - return {observation, dynamic}; -}; - -},{"../linalgebra/identity.js":43,"../linalgebra/pad-with-zeros.js":46}],55:[function(require,module,exports){ -/** -*Verifies that dynamic.dimension and observation.dimension are set -*@param {ObservationConfig} observation -*@param {DynamicConfig} dynamic -*/ - -module.exports = function ({observation, dynamic}) { - const dynamicDimension = dynamic.dimension; - const observationDimension = observation.dimension; - if (!dynamicDimension || !observationDimension) { - throw (new TypeError('Dimension is not set')); - } - - return {observation, dynamic}; -}; - -},{}],56:[function(require,module,exports){ -const diag = require('../linalgebra/diag.js'); - -/** -*Initializes the dynamic.init when not given -*@param {ObservationConfig} observation -*@param {DynamicConfig} dynamic -*@returns {ObservationConfig, DynamicConfig} -*/ - -module.exports = function ({observation, dynamic}) { - if (!dynamic.init) { - const huge = 1e6; - const dynamicDimension = dynamic.dimension; - const meanArray = new Array(dynamicDimension).fill(0); - const covarianceArray = new Array(dynamicDimension).fill(huge); - const withInitOptions = { - observation, - dynamic: Object.assign({}, dynamic, { - init: { - mean: meanArray.map(element => [element]), - covariance: diag(covarianceArray) - } - }) - }; - return withInitOptions; - } - - return {observation, dynamic}; -}; - -},{"../linalgebra/diag.js":40}],57:[function(require,module,exports){ -/** -*Verifies that dimensions are matching and set dynamic.dimension and observation.dimension -* with respect of stateProjection and transition dimensions -*@param {ObservationConfig} observation -*@param {DynamicConfig} dynamic -*@returns {ObservationConfig, DynamicConfig} -*/ - -module.exports = function ({observation, dynamic}) { - const stateProjection = observation.stateProjection; - const transition = dynamic.transition; - const dynamicDimension = dynamic.dimension; - const observationDimension = observation.dimension; - - if (dynamicDimension && observationDimension && Array.isArray(stateProjection)) { - if (dynamicDimension !== stateProjection[0].length || observationDimension !== stateProjection.length) { - throw (new TypeError('stateProjection dimensions not matching with observation and dynamic dimensions')); - } - } - - if (dynamicDimension && Array.isArray(transition)) { - if (dynamicDimension !== transition.length) { - throw (new TypeError('transition dimension not matching with dynamic dimension')); - } - } - - if (Array.isArray(stateProjection)) { - return { - observation: Object.assign({}, observation, { - dimension: stateProjection.length - }), - dynamic: Object.assign({}, dynamic, { - dimension: stateProjection[0].length - }) - }; - } - - if (Array.isArray(transition)) { - return { - observation, - dynamic: Object.assign({}, dynamic, { - dimension: transition.length - }) - }; - } - - return {observation, dynamic}; -}; - -},{}],58:[function(require,module,exports){ -const checkMatrix = function (matrix, shape) { - if (matrix.reduce((a, b) => a.concat(b)).filter(a => Number.isNaN(a)).length > 0) { - throw (new Error('Matrix should not have a NaN')); - } - - if (shape) { - checkShape(matrix, shape); - } -}; - -const checkShape = function (matrix, shape) { - if (matrix.length !== shape[0]) { - throw (new Error('shape and length do not match')); - } - - if (shape.length > 1) { - return matrix.forEach(m => checkShape(m, shape.slice(1))); - } -}; - -/** - * @class - * Class representing a multi dimensionnal gaussian, with his mean and his covariance - * @property {Number} [index=0] the index of the State in the process, this is not mandatory for simple Kalman Filter, but is needed for most of the use case of extended kalman filter - * @property {Array.>} covariance square matrix of size dimension - * @property {Array.>} mean column matrix of size dimension x 1 - */ -class State { - constructor({mean, covariance, index}) { - this.mean = mean; - this.covariance = covariance; - this.index = index; - } - - /** - * Check the consistency of the State - */ - check() { - this.constructor.check(this); - } - - /** - * Check the consistency of the State's attributes - */ - - static check(state, {dimension = null} = {}) { - if (!(state instanceof State)) { - throw (new TypeError('The argument is not a state')); - } - - const {mean, covariance} = state; // Index - const meanDimension = mean.length; - if (typeof (dimension) === 'number' && meanDimension !== dimension) { - throw (new Error(`${meanDimension} and ${dimension} are not the same`)); - } - - checkMatrix(mean, [meanDimension, 1]); - checkMatrix(covariance, [meanDimension, meanDimension]); - - // If (typeof (index) !== 'number') { - // throw (new TypeError('t must be a number')); - // } - } -} - -module.exports = State; - -},{}],59:[function(require,module,exports){ -/** -*Returns the corresponding matrix in dim*1, given an dim matrix, and checks -* if corresponding with the observation dimension -*@param {Array. | Array.>} observation -*@param {Number} dimension -*@returns {Array.>} -*/ - -module.exports = function ({observation, dimension}) { - if (!Array.isArray(observation)) { - throw (new TypeError('The observation should be an array')); - } - - if (observation.length !== dimension) { - throw (new TypeError('Observation and dimension not matching')); - } - - if (typeof (observation[0]) === 'number') { - return observation.map(element => [element]); - } - - return observation; -}; - -},{}],60:[function(require,module,exports){ -const uniq = require('./uniq.js'); -const limit = 100; - -/** -*Equivalent to the Object.assign methode, takes several arguments and creates a new object corresponding to the assignment of the arguments -* @param {Object} args -* @param {Number} step -*/ -const deepAssign = function (args, step) { - if (step > limit) { - throw (new Error(`In deepAssign, number of recursive call (${step}) reached limit (${limit}), deepAssign is not working on self-referencing objects`)); - } - - const filterArguments = args.filter(arg => typeof (arg) !== 'undefined' && arg !== null); - const lastArgument = filterArguments[filterArguments.length - 1]; - if (filterArguments.length === 1) { - return filterArguments[0]; - } - - if (typeof (lastArgument) !== 'object' || Array.isArray(lastArgument)) { - return lastArgument; - } - - if (filterArguments.length === 0) { - return null; - } - - const objectsArguments = filterArguments.filter(arg => typeof (arg) === 'object'); - let keys = []; - objectsArguments.forEach(arg => { - keys = keys.concat(Object.keys(arg)); - }); - const uniqKeys = uniq(keys); - const result = {}; - uniqKeys.forEach(key => { - const values = objectsArguments.map(arg => arg[key]); - result[key] = deepAssign(values, step + 1); - }); - return result; -}; - -module.exports = ((...args) => deepAssign(args, 0)); - -},{"./uniq.js":64}],61:[function(require,module,exports){ -/** -* @param {Object} opts -* @param {Array.>} opts.measures a list of measure, size is LxN L the number of sample, N the dimension -* @param {Array.>} opts.averages a list of averages, size is LxN L the number of sample, N the dimension -* @returns {Array.>} covariance matrix size is NxN -*/ - -module.exports = function ({measures, averages}) { - const l = measures.length; - const n = measures[0].length; - - if (l === 0) { - throw (new Error('Cannot find covariance for empty sample')); - } - - return (new Array(n).fill(1)).map((_, rowIndex) => { - return (new Array(n).fill(1)).map((_, colIndex) => { - const stds = measures.map((m, i) => (m[rowIndex] - averages[i][rowIndex]) * (m[colIndex] - averages[i][colIndex])); - const result = stds.reduce((a, b) => a + b) / l; - if (Number.isNaN(result)) { - throw (new TypeError('result is NaN')); - } - - return result; - }); - }); -}; - -},{}],62:[function(require,module,exports){ -/** -* @typedef {Number | Array. | Array.>} CovarianceParam -*/ -const diag = require('../linalgebra/diag'); -/** -* If cov is a number, result will be Identity*cov -* If cov is an Array., result will be diag(cov) -* If cov is an Array.>, result will be cov -* @param {CovarianceParam} cov -* @param {Number} dimension -* @returns {Array.>} -*/ -module.exports = function (array, {dimension} = {}) { - if (typeof (array) === 'number' || Array.isArray(array)) { - if (typeof (array) === 'number' && typeof (dimension) === 'number') { - return diag(new Array(dimension).fill(array)); - } - - if ((Array.isArray(array)) && (Array.isArray(array[0]))) { - return array; - } - - if ((Array.isArray(array)) && (typeof (array[0]) === 'number')) { - return diag(array); - } - } - - return array; -}; - -},{"../linalgebra/diag":40}],63:[function(require,module,exports){ -// Const diag = require('../linalgebra/diag.js'); - -/** -* @callback MatrixCallback -* @returns > -*/ - -/** -* Tranforms: -** a 2d array into a function (() => array) -** a 1d array into a function (() => diag(array)) -*@param {Array. | Array.>} array -*@returns {MatrixCallback} -*/ - -module.exports = function (array) { - if (typeof (array) === 'function') { - return array; - } - - if (Array.isArray(array)) { - return function () { - return array; - }; - } - - throw (new Error('Only arrays and functions are authorized')); -}; - -},{}],64:[function(require,module,exports){ -module.exports = function (array) { - return array.filter((value, index) => - array.indexOf(value) === index - ); -}; - -},{}],65:[function(require,module,exports){ -const Abstract = require('./lib/hasard/abstract'); -const Function = require('./lib/hasard/function'); -const operators = require('./lib/operators'); - -const cstrs = { - Integer: require('./lib/hasard/integer'), - Value: require('./lib/hasard/value'), - Array: require('./lib/hasard/array'), - Object: require('./lib/hasard/object'), - Number: require('./lib/hasard/number'), - Matrix: require('./lib/hasard/matrix'), - String: require('./lib/hasard/string'), - Boolean: require('./lib/hasard/boolean'), - Reference: require('./lib/hasard/reference'), - Function -}; - -const shortcuts = {}; -Object.keys(cstrs).forEach(key => { - shortcuts[key.toLowerCase()] = cstrs[key].build.bind(cstrs[key], this); -}); - -const helpers = { - isHasard: Abstract.isHasard, - fn: shortcuts.function, - int: shortcuts.integer, - num: shortcuts.number, - str: shortcuts.string, - ref: shortcuts.reference -}; - -const methods = function (hasardContext) { - return Object.assign({}, cstrs, shortcuts, operators(hasardContext), helpers); -}; - -class Hasard { - constructor(prng = Math.random.bind(Math)) { - this.prng = prng; - const meths = methods(this); - Object.keys(meths).forEach(m => { - this[m] = meths[m].bind(this); - }); - } -} - -module.exports = Object.assign(Hasard, methods(null)); - -},{"./lib/hasard/abstract":66,"./lib/hasard/array":67,"./lib/hasard/boolean":68,"./lib/hasard/function":69,"./lib/hasard/integer":70,"./lib/hasard/matrix":71,"./lib/hasard/number":72,"./lib/hasard/object":73,"./lib/hasard/reference":74,"./lib/hasard/string":75,"./lib/hasard/value":76,"./lib/operators":80}],66:[function(require,module,exports){ -const HasardReadableStream = require('../helpers/readable-stream.js'); - -class AbstractHasard { - constructor(...args) { - this._hasard = true; - if (args.length === 0) { - return; - } - - this.set(...args); - } - - set(opts) { - this._set = true; - this._opts = opts; - const all = this.getOpts(opts); - this._unresolved = {}; - this._resolved = {}; - if (opts && (typeof (opts.prng) === 'function')) { - this._prng = opts.prng.bind(opts); - } - - this._contextName = opts && opts.contextName; - Object.keys(all).forEach(k => { - if (AbstractHasard.isHasard(all[k])) { - this._unresolved[k] = all[k]; - } else { - this.check(k, all[k]); - this._resolved[k] = all[k]; - } - }); - } - - static build(hasardContext, ...args) { - const instance = new this(...args); - if (hasardContext && hasardContext.prng) { - hasardContext._prng = hasardContext.prng; - } - - return instance; - } - - prng() { - return this._prng ? this._prng() : Math.random(); - } - - static isHasard(o) { - return o && Boolean(o._hasard); - } - - runAsync(n) { - return Promise.resolve(this.run(n)); - } - - stream(number, runOpts) { - return new HasardReadableStream({ - hasardInstance: this, - number, - runOpts - }); - } - - resolve(unresolved, runOpts) { - const ctxt = {}; - if (typeof (unresolved) === 'undefined') { - throw (new TypeError('This instance of hasard has not been set properly')); - } - - Object.keys(unresolved).forEach(k => { - ctxt[k] = unresolved[k].runOnce(runOpts); - this.check(k, ctxt[k]); - }); - return ctxt; - } - - _runOnce(runOpts) { - const ctxt = Object.assign({}, this.resolve(this._unresolved, runOpts), this._resolved); - - const res = this.generate(ctxt, runOpts); - if (this._contextName && runOpts.refs && runOpts.refs[this._contextName]) { - delete runOpts.refs[this._contextName]; - } - - return res; - } - - run(n, runOpts) { - const res = []; - for (let i = 0; i < n; i++) { - res.push(this.runOnce(runOpts)); - } - - return res; - } - - runOnce(runOpts = {}) { - return this._runOnce(runOpts); - } - - generate() { - throw (new Error('override me')); - } - - getOpts(opts) { - delete opts.prng; - return opts; - } - - check() { - // Do nothing, override me to do sthg - } -} - -module.exports = AbstractHasard; - -},{"../helpers/readable-stream.js":77}],67:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -class ArrayHasard extends AbstractHasard { - check(key, value) { - if (key === 'values' && value !== null && typeof (value) !== 'undefined') { - if (!Array.isArray(value)) { - throw (new TypeError(`${key} ${value} must be an array`)); - } - } - } - - resolve(unresolved, runOpts) { - // Do not resolve "value" here, it will be resolved in generate - const overrideUnresolved = Object.assign({}, unresolved); - delete overrideUnresolved.value; - - return Object.assign(super.resolve(overrideUnresolved, runOpts), {value: unresolved.value}); - } - - getOpts(opts) { - let values = null; - let size; - let value; - let randomOrder; - if (Array.isArray(opts)) { - values = opts; - size = values.length; - value = null; - randomOrder = false; - } else { - size = opts.size; - values = opts.values; - value = opts.value; - randomOrder = opts.randomOrder; - } - - return { - size, - value, - values, - randomOrder - }; - } - - generate(ctx, runOpts) { - if (ArrayHasard.isHasard(ctx.value)) { - return new Array(ctx.size).fill(1).map(() => ctx.value.runOnce(runOpts)); - } - - if (ctx.values) { - let newValues; - - if (typeof (ctx.size) === 'number' || ctx.randomOrder) { - const size = typeof (ctx.size) === 'number' ? ctx.size : ctx.values.length; - - if (size > ctx.values.length) { - throw (new Error(`Cannot pick ${size} elements in ${ctx.values.length}-size array`)); - } - - let selectedObjs = ctx.values - .map((v, i) => ({strength: this.prng(), value: v, index: i})) - .sort((a, b) => a.strength - b.strength) - .slice(0, size); - - if (!ctx.randomOrder) { - selectedObjs = selectedObjs.sort((a, b) => a.index - b.index); - } - - newValues = selectedObjs.map(({value}) => value); - } else { - newValues = ctx.values; - } - - return newValues.map(v => { - if (ArrayHasard.isHasard(v)) { - const res = v.runOnce(runOpts); - return res; - } - - return v; - }); - } - - return new Array(ctx.size).fill(1).map(() => ctx.value); - } -} - -module.exports = ArrayHasard; - -},{"./abstract":66}],68:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -class BooleanHasard extends AbstractHasard { - constructor(...args) { - super(...args); - if (args.length === 0) { - return this.set(0.5); - } - - this.set(...args); - } - - check(key, value) { - if (key === 'prob') { - if (typeof (value) !== 'number') { - throw (new TypeError(`${key} ${value} must be a number`)); - } - - if (value < 0 || value > 1) { - throw (new Error(`${key} ${value} must be between 0 and 1`)); - } - } - } - - getOpts(prob = 0.5) { - return { - prob - }; - } - - generate(ctx) { - if (typeof (ctx.prob) !== 'number') { - return (this.prng() > 0.5); - } - - return (this.prng() < ctx.prob); - } -} - -module.exports = BooleanHasard; - -},{"./abstract":66}],69:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); -const RandomArray = require('./array'); - -class FunctionHasard extends AbstractHasard { - check(key, value) { - if (key === 'fn') { - if (typeof (value) !== 'function') { - throw (new TypeError(`${key} ${value} must be a function`)); - } - } - - if (key === 'args') { - if (value && !Array.isArray(value)) { - throw (new TypeError(`${key} ${value} must be an array`)); - } - } - } - - getOpts({args, fn}) { - return { - args, - fn - }; - } - - generate(ctx) { - return ctx.fn(...ctx.args); - } - - static build(hasardContext, fn) { - return function (...args) { - const f = new FunctionHasard({args: new RandomArray(args), fn}); - if (hasardContext && hasardContext.prng) { - f._prng = hasardContext.prng; - } - - return f; - }; - } -} - -module.exports = FunctionHasard; - -},{"./abstract":66,"./array":67}],70:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -class IntegerHasard extends AbstractHasard { - check(key, value) { - if (key === 'start' || key === 'end') { - if (Math.floor(value) !== value) { - throw (new TypeError(`${key} (${value}) must be an integer`)); - } - } - - if (key === 'type' && ['poisson', 'uniform'].indexOf(value) === -1) { - throw (new TypeError(`${key} ${value} is invalid`)); - } - } - - set(start, end) { - if (typeof (end) === 'undefined') { - super.set(start); - } else if (typeof (end) === 'number' || this.constructor.isHasard(end)) { - super.set([start, end]); - } else { - throw (new Error(`second argument ${end} is not valid`)); - } - } - - getOpts(opts) { - if (Array.isArray(opts)) { - if (opts.length !== 2) { - throw (new TypeError(`${opts} must be a length-2 array`)); - } - - const start = opts[0]; - const end = opts[1]; - return { - start, - end, - type: 'uniform' - }; - } - - return opts; - } - - generate(ctx) { - if (ctx.type === 'poisson') { - const l = Math.exp(-ctx.lambda); - let p = 1; - let k = 0; - - do { - k++; - p *= this.prng(); - } while (p > l); - - return k - 1; - } - - return Math.floor(ctx.start + (this.prng() * (ctx.end + 1 - ctx.start))); - } -} - -module.exports = IntegerHasard; - -},{"./abstract":66}],71:[function(require,module,exports){ -const reshape = require('../helpers/reshape'); -const ArrayHasard = require('./array'); - -const fact = function (array) { - if (array.length === 0) { - return 1; - } - - return array[0] * fact(array.slice(1)); -}; - -class MatrixHasard extends ArrayHasard { - check(key, value) { - super.check(key, value); - if (key === 'shape') { - if (!Array.isArray(value)) { - throw (new TypeError(`${key} (${value}) must be an array`)); - } - - if (value.length === 0) { - throw (new Error(`${key} (${value}) should not be empty`)); - } - - value.forEach(v => { - if (Math.floor(v) !== v) { - throw (new Error(`${key} (${v}) must be an integer`)); - } - }); - } - } - - getOpts(opts) { - return Object.assign({}, super.getOpts(opts), {shape: opts.shape}); - } - - generate(ctx, runOpts) { - const size = fact(ctx.shape); - const ctx2 = Object.assign({}, ctx, {size}); - const resArray = super.generate(ctx2, runOpts); - return reshape(resArray, [size], ctx.shape); - } -} - -module.exports = MatrixHasard; - -},{"../helpers/reshape":79,"./array":67}],72:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -class NumberHasard extends AbstractHasard { - check(key, value) { - if (key === 'start' || key === 'end') { - if (typeof (value) !== 'number') { - throw (new TypeError(`${key} (${value}) must be a number`)); - } - } - - if (key === 'type' && ['normal', 'uniform', 'truncated-normal'].indexOf(value) === -1) { - throw (new TypeError(`${key} ${value} is invalid`)); - } - } - - set(start, end) { - if (typeof (end) === 'undefined') { - super.set(start); - } else if (typeof (end) === 'number' || this.constructor.isHasard(end)) { - super.set([start, end]); - } else { - throw (new Error(`second argument ${end} is not valid`)); - } - } - - getOpts(opts) { - let res = opts; - - if (Array.isArray(opts)) { - if (opts.length !== 2) { - throw (new TypeError('invalid array, range array length must be 2')); - } - - res = { - type: 'uniform', - start: opts[0], - end: opts[1] - }; - } else { - res = opts; - } - - return res; - } - - _pickNormalNumber(mean = 0, std = 1) { - // From http://blog.yjl.im/2010/09/simulating-normal-random-variable-using.html - - let v1; - let v2; - let s; - - do { - const u1 = this.prng(); - const u2 = this.prng(); - v1 = (2 * u1) - 1; - v2 = (2 * u2) - 1; - s = (v1 * v1) + (v2 * v2); - } while (s > 1); - - return mean + (std * Math.sqrt(-2 * Math.log(s) / s) * v1); - } - - generate(ctx) { - if (ctx.type === 'uniform') { - return ctx.start + (this.prng() * (ctx.end - ctx.start)); - } - - if (ctx.type === 'normal') { - const mean = ctx.mean || 0; - const std = ctx.std || 1; - return this._pickNormalNumber(mean, std); - } - - if (ctx.type === 'truncated-normal') { - const mean = ctx.mean || 0; - const std = ctx.std || 1; - let n; - do { - n = this._pickNormalNumber(mean, std); - } while ((n > mean + (2 * std)) || (n < mean - (2 * std))); - - return n; - } - - throw (new Error(`type ${ctx.type} is invalid`)); - } -} - -module.exports = NumberHasard; - -},{"./abstract":66}],73:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -class ObjectHasard extends AbstractHasard { - set(keys, value) { - if (ObjectHasard.isHasard(keys) || Array.isArray(keys)) { - if (typeof (value) === 'undefined') { - throw (new TypeError('h.object(keys, value) should have a value param')); - } - - super.set(Object.assign({}, {__hasardKeys: keys, __hasardValue: value})); - } else if (typeof (keys) === 'object') { - super.set(Object.assign({}, keys)); - } else { - throw (new TypeError('invalid params for h.object')); - } - } - - check(key, value) { - if (key === '__hasardKeys' && value !== null && typeof (value) !== 'undefined') { - const k = 'keys'; - if (!Array.isArray(value)) { - throw (new TypeError(`${k} ${value} must be an array`)); - } - - value.forEach((v, index) => { - // Check unicity - if (value.indexOf(v) !== index) { - throw (new TypeError(`keys must be unique (${k}[${index}] '${v}' is duplicated)`)); - } - - // Check string type - if (typeof (v) !== 'string') { - throw (new TypeError(`keys must be string array (${k}[${index}] '${v}' should be a string)`)); - } - }); - } - } - - getOpts(opts) { - const res = Object.assign({}, opts, {__hasardKeys: opts.__hasardKeys, __hasardValue: opts.__hasardValue}); - return res; - } - - resolve(unresolved, runOpts) { - // Do not resolve "value" here, it will be resolved in generate - const overrideUnresolved = Object.assign({}, unresolved); - delete overrideUnresolved.__hasardValue; - const res = Object.assign(super.resolve(overrideUnresolved, runOpts), {__hasardValue: unresolved.__hasardValue}); - return res; - } - - generate(ctx, runOpts) { - if (ctx.__hasardKeys) { - // Console.log('here', ctx, this.constructor.isHasard(ctx.__hasardValue), ctx.__hasardValue) - let values; - if (this.constructor.isHasard(ctx.__hasardValue)) { - values = ctx.__hasardValue.run(ctx.__hasardKeys.length, runOpts); - } else { - values = new Array(ctx.__hasardKeys.length).fill(ctx.__hasardValue); - } - - const res = {}; - ctx.__hasardKeys.forEach((k, index) => { - res[k] = values[index]; - }); - return res; - } - - delete ctx.__hasardKeys; - delete ctx.__hasardValue; - return ctx; - } -} - -module.exports = ObjectHasard; - -},{"./abstract":66}],74:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); -const RandomString = require('./string'); -const RandomValue = require('./value'); - -class ReferenceHasard extends AbstractHasard { - resolve(unresolved, runOpts) { - // Do not resolve "source" here, it will be resolved in generate - const overrideUnresolved = Object.assign({}, unresolved); - delete overrideUnresolved.source; - - return Object.assign(super.resolve(overrideUnresolved, runOpts), {source: unresolved.source}); - } - - generate({id, context, source}, runOpts) { - if (!this.constructor.isHasard(source)) { - return source; - } - - const ctx = typeof (context) === 'string' ? context : 'global'; - - if (!runOpts.refs || !runOpts.refs[ctx] || typeof (runOpts.refs[ctx][id]) === 'undefined') { - const res = source.runOnce(runOpts); - if (!runOpts.refs) { - runOpts.refs = {}; - } - - if (!runOpts.refs[ctx]) { - runOpts.refs[ctx] = {}; - } - - runOpts.refs[ctx][id] = res; - return res; - } - - return runOpts.refs[ctx][id]; - } - - check(key, value) { - if (key === 'context' && value !== null && typeof (value) !== 'undefined') { - if (typeof (value) !== 'string') { - throw (new TypeError(`${key} (${value}) must be a string`)); - } - } - } - - getOpts(opts) { - const randomString = new RandomString({ - value: new RandomValue('0123456789ABCDEF'.split('')), - size: 16 - }); - let source; - let context; - if (AbstractHasard.isHasard(opts)) { - source = opts; - context = null; - } else if (typeof (opts) === 'object') { - source = opts.source; - context = opts.context; - } else { - source = opts; - context = null; - } - - return { - source, - context, - id: randomString.runOnce() - }; - } -} - -module.exports = ReferenceHasard; - -},{"./abstract":66,"./string":75,"./value":76}],75:[function(require,module,exports){ -const ArrayHasard = require('./array'); - -class StringHasard extends ArrayHasard { - generate(ctx, runOpts) { - return super.generate(ctx, runOpts).join(''); - } -} - -module.exports = StringHasard; - -},{"./array":67}],76:[function(require,module,exports){ -const AbstractHasard = require('./abstract'); - -const getRanges = function (array) { - const res = []; - let current = 0; - array.forEach(v => { - res.push([current, current + v]); - current += v; - }); - return res; -}; - -class ValueHasard extends AbstractHasard { - check(key, value) { - if (key === 'weights' && Array.isArray(value)) { - const sum = value.reduce((a, b) => a + b, 0); - const tolerance = 1e-6; - if (Math.abs(sum - 1) > tolerance) { - throw (new Error(`sum of weights must be 1 (is ${sum})`)); - } - } - } - - getOpts(opts) { - let choices; - - if (Array.isArray(opts)) { - choices = opts; - } else if (AbstractHasard.isHasard(opts)) { - choices = opts; - } else { - choices = opts.choices; - } - - const {weights} = opts; - - return { - choices, - weights - }; - } - - generate(ctx) { - let choice; - - if (ctx.weights) { - if (!Array.isArray(ctx.choices)) { - throw (new TypeError('choices must be defined in h.value')); - } - - const ranges = getRanges(ctx.weights); - const v = this.prng(); - const {index} = ranges.map((value, index) => ({value, index})).filter(({value}) => (value[0] <= v && v < value[1]))[0]; - choice = ctx.choices[index]; - } else { - choice = ctx.choices[Math.floor(this.prng() * ctx.choices.length)]; - } - - if (this.constructor.isHasard(choice)) { - return choice.runOnce(); - } - - return choice; - } -} - -module.exports = ValueHasard; - -},{"./abstract":66}],77:[function(require,module,exports){ -(function (setImmediate){ -const {Readable} = require('stream'); - -class HasardReadableStream extends Readable { - constructor(options) { - options.objectMode = true; - super(options); - const { - hasardInstance, - number, - runOpts - } = options; - - this._hasardInstance = hasardInstance; - this._end = number; - this._runOpts = runOpts; - this._curr = 0; - } - - _read() { - setImmediate(() => { - const res = this._hasardInstance.runOnce(this._runOpts); - const obj = Object.assign({}, res, {index: this._curr}); - this.push(obj); - this._curr++; - if (this._curr === this._end) { - this.push(null); - } - }); - } -} - -module.exports = HasardReadableStream; - -}).call(this,require("timers").setImmediate) -},{"stream":31,"timers":32}],78:[function(require,module,exports){ -const recursiveEach = function (array, inShape, fn, index = 0) { - if (Array.isArray(array) && inShape.length > 0) { - const size = array.length; - array.forEach((item, indexLocal) => { - recursiveEach(item, inShape.slice(1), fn, (index * size) + indexLocal); - }); - } else { - fn(array, index); - } -}; - -module.exports = recursiveEach; - -},{}],79:[function(require,module,exports){ -const recursiveEach = require('./recursive-each'); - -module.exports = function (arr, inShape, outShape) { - const newArr = []; - const reverseShape = outShape.concat([]).reverse(); - recursiveEach(arr, inShape, (item, index) => { - let remIndex = index; - const indexes = []; - - reverseShape.forEach(s => { - const previousRem = remIndex; - remIndex = Math.floor(remIndex / s); - indexes.unshift(previousRem - (remIndex * s)); - }); - let current = newArr; - indexes.slice(0, -1).forEach(index => { - if (!current[index]) { - current[index] = []; - } - - current = current[index]; - }); - current[indexes[indexes.length - 1]] = item; - }); - return newArr; -}; - -},{"./recursive-each":78}],80:[function(require,module,exports){ -const Hfunction = require('./hasard/function'); - -module.exports = function (hasardContext) { - const fn = Hfunction.build.bind(Hfunction, hasardContext); - return { - multiply: fn((...args) => args.reduce((a, b) => a * b, 1)), - divide: fn((a, b) => a / b), - add: fn((...args) => args.reduce((a, b) => a + b)), - substract: fn((a, b) => a - b), - if: fn((condition, iftrue, iffalse) => condition ? iftrue : iffalse), - round: fn(n => Math.round(n)), - ceil: fn(n => Math.ceil(n)), - floor: fn(n => Math.floor(n)), - concat: fn((a, b) => a.concat(b)), - getProperty: fn((key, obj) => obj[key]) - }; -}; - -},{"./hasard/function":69}],81:[function(require,module,exports){ -var Sylvester = {} - -Sylvester.Matrix = function() {} - -Sylvester.Matrix.create = function(elements) { - var M = new Sylvester.Matrix() - return M.setElements(elements) -} - -Sylvester.Matrix.I = function(n) { - var els = [], - i = n, - j - while (i--) { - j = n - els[i] = [] - while (j--) { - els[i][j] = i === j ? 1 : 0 - } - } - return Sylvester.Matrix.create(els) -} - -Sylvester.Matrix.prototype = { - dup: function() { - return Sylvester.Matrix.create(this.elements) - }, - - isSquare: function() { - var cols = this.elements.length === 0 ? 0 : this.elements[0].length - return this.elements.length === cols - }, - - toRightTriangular: function() { - if (this.elements.length === 0) return Sylvester.Matrix.create([]) - var M = this.dup(), - els - var n = this.elements.length, - i, - j, - np = this.elements[0].length, - p - for (i = 0; i < n; i++) { - if (M.elements[i][i] === 0) { - for (j = i + 1; j < n; j++) { - if (M.elements[j][i] !== 0) { - els = [] - for (p = 0; p < np; p++) { - els.push(M.elements[i][p] + M.elements[j][p]) - } - M.elements[i] = els - break - } - } - } - if (M.elements[i][i] !== 0) { - for (j = i + 1; j < n; j++) { - var multiplier = M.elements[j][i] / M.elements[i][i] - els = [] - for (p = 0; p < np; p++) { - // Elements with column numbers up to an including the number of the - // row that we're subtracting can safely be set straight to zero, - // since that's the point of this routine and it avoids having to - // loop over and correct rounding errors later - els.push( - p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier - ) - } - M.elements[j] = els - } - } - } - return M - }, - - determinant: function() { - if (this.elements.length === 0) { - return 1 - } - if (!this.isSquare()) { - return null - } - var M = this.toRightTriangular() - var det = M.elements[0][0], - n = M.elements.length - for (var i = 1; i < n; i++) { - det = det * M.elements[i][i] - } - return det - }, - - isSingular: function() { - return this.isSquare() && this.determinant() === 0 - }, - - augment: function(matrix) { - if (this.elements.length === 0) { - return this.dup() - } - var M = matrix.elements || matrix - if (typeof M[0][0] === 'undefined') { - M = Sylvester.Matrix.create(M).elements - } - var T = this.dup(), - cols = T.elements[0].length - var i = T.elements.length, - nj = M[0].length, - j - if (i !== M.length) { - return null - } - while (i--) { - j = nj - while (j--) { - T.elements[i][cols + j] = M[i][j] - } - } - return T - }, - - inverse: function() { - if (this.elements.length === 0) { - return null - } - if (!this.isSquare() || this.isSingular()) { - return null - } - var n = this.elements.length, - i = n, - j - var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular() - var np = M.elements[0].length, - p, - els, - divisor - var inverse_elements = [], - new_element - // Sylvester.Matrix is non-singular so there will be no zeros on the - // diagonal. Cycle through rows from last to first. - while (i--) { - // First, normalise diagonal elements to 1 - els = [] - inverse_elements[i] = [] - divisor = M.elements[i][i] - for (p = 0; p < np; p++) { - new_element = M.elements[i][p] / divisor - els.push(new_element) - // Shuffle off the current row of the right hand side into the results - // array as it will not be modified by later runs through this loop - if (p >= n) { - inverse_elements[i].push(new_element) - } - } - M.elements[i] = els - // Then, subtract this row from those above it to give the identity matrix - // on the left hand side - j = i - while (j--) { - els = [] - for (p = 0; p < np; p++) { - els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i]) - } - M.elements[j] = els - } - } - return Sylvester.Matrix.create(inverse_elements) - }, - - setElements: function(els) { - var i, - j, - elements = els.elements || els - if (elements[0] && typeof elements[0][0] !== 'undefined') { - i = elements.length - this.elements = [] - while (i--) { - j = elements[i].length - this.elements[i] = [] - while (j--) { - this.elements[i][j] = elements[i][j] - } - } - return this - } - var n = elements.length - this.elements = [] - for (i = 0; i < n; i++) { - this.elements.push([elements[i]]) - } - return this - }, -} - -module.exports = function(elements) { - return Sylvester.Matrix.create(elements).inverse().elements -} - -},{}],"KalmanFilter":[function(require,module,exports){ -const CoreKalmanFilter = require('./core-kalman-filter.js'); - -const arrayToMatrix = require('../lib/utils/array-to-matrix.js'); -const setDimensions = require('../lib/setup/set-dimensions.js'); -const checkDimensions = require('../lib/setup/check-dimensions.js'); -const buildStateProjection = require('../lib/setup/build-state-projection.js'); -const extendDynamicInit = require('../lib/setup/extend-dynamic-init.js'); -const modelCollection = require('./model-collection.js'); -const toFunction = require('../lib/utils/to-function.js'); -const deepAssign = require('../lib/utils/deep-assign.js'); -const polymorphMatrix = require('../lib/utils/polymorph-matrix.js'); -const State = require('./state.js'); -const distanceMat = require('../lib/linalgebra/distance-mat.js'); - -/** -*This function fills the given options by successively checking if it uses a registered model, -* it builds and checks the dynamic and observation dimensions, build the stateProjection if only observedProjection -*is given, and initialize dynamic.init -*@param {DynamicConfig} options.dynamic -*@param {ObservationConfig} options.observation -*/ - -const setupModelsParameters = function ({observation, dynamic}) { - if (typeof (observation.name) === 'string') { - observation = modelCollection.buildObservation(observation); - } - - if (typeof (dynamic.name) === 'string') { - dynamic = modelCollection.buildDynamic(dynamic, observation); - } - - const withDimensionOptions = setDimensions({observation, dynamic}); - const checkedDimensionOptions = checkDimensions(withDimensionOptions); - const buildStateProjectionOptions = buildStateProjection(checkedDimensionOptions); - return extendDynamicInit(buildStateProjectionOptions); -}; - -/** -*Returns the corresponding model without arrays as values but only functions -*@param {ObservationConfig} observation -*@param {DynamicConfig} dynamic -*@returns {ObservationConfig, DynamicConfig} model with respect of the Core Kalman Filter properties -*/ -const modelsParametersToCoreOptions = function (modelToBeChanged) { - const {observation, dynamic} = modelToBeChanged; - return deepAssign(modelToBeChanged, { - observation: { - stateProjection: toFunction(polymorphMatrix(observation.stateProjection)), - covariance: toFunction(polymorphMatrix(observation.covariance, {dimension: observation.dimension})) - }, - dynamic: { - transition: toFunction(polymorphMatrix(dynamic.transition)), - covariance: toFunction(polymorphMatrix(dynamic.covariance, {dimension: dynamic.dimension})) - } - }); -}; - -class KalmanFilter extends CoreKalmanFilter { - /** - * @param {DynamicConfig} options.dynamic - * @param {ObservationConfig} options.observation the system's observation model - */ - constructor(options) { - const modelsParameters = setupModelsParameters(options); - const coreOptions = modelsParametersToCoreOptions(modelsParameters); - - super(Object.assign({}, options, coreOptions)); - } - - correct({predicted, observation}) { - const coreObservation = arrayToMatrix({observation, dimension: this.observation.dimension}); - return super.correct({predicted, observation: coreObservation}); - } - - /** - *Performs the prediction and the correction steps - *@param {State} previousCorrected - *@param {>} observation - *@returns {Array.} the mean of the corrections - */ - - filter({previousCorrected, observation}) { - const predicted = super.predict({previousCorrected}); - return this.correct({predicted, observation}); - } - - /** -*Filters all the observations -*@param {Array.>} observations -*@returns {Array.} the mean of the corrections -*/ - filterAll(observations) { - const {mean: meanInit, covariance: covarianceInit, index: indexInit} = this.dynamic.init; - let previousCorrected = new State({ - mean: meanInit, - covariance: covarianceInit, - index: indexInit}); - const results = []; - for (const observation of observations) { - const predicted = this.predict({previousCorrected}); - previousCorrected = this.correct({ - predicted, - observation - }); - results.push(previousCorrected.mean); - } - - return results; - } - - /** - * Returns an estimation of the asymptotic state covariance as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form - * in practice this can be used as a init.covariance value but is very costful calculation (that's why this is not made by default) - * @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance - * @return {>>} covariance - */ - asymptoticStateCovariance(limitIterations = 1e2, tolerance = 1e-6) { - let previousCorrected = super.getInitState(); - let predicted; - const results = []; - for (let i = 0; i < limitIterations; i++) { - let count = 0; - predicted = new State({covariance: super.getPredictedCovariance({previousCorrected})}); - previousCorrected = new State({covariance: super.getCorrectedCovariance({predicted})}); - results.push(previousCorrected.covariance); - for (let j = 1; j < 4; j++) { - if (distanceMat(previousCorrected.covariance, results[i - j]) < tolerance) { - count += 1; - } - } - - if (count === 3) { - return results[i]; - } - } - - throw (new Error('The state covariance does not converge asymptotically')); - } - - /** - * Returns an estimation of the asymptotic gain, as explained in https://en.wikipedia.org/wiki/Kalman_filter#Asymptotic_form - * @param {Number} [tolerance=1e-6] returns when the last values differences are less than tolerance - * @return {>>} gain - */ - asymptoticGain(tolerance = 1e-6) { - const asymptoticState = new State({covariance: this.asymptoticStateCovariance(tolerance)}); - return super.getGain({previousCorrected: asymptoticState}); - } -} - -module.exports = KalmanFilter; - -},{"../lib/linalgebra/distance-mat.js":41,"../lib/setup/build-state-projection.js":54,"../lib/setup/check-dimensions.js":55,"../lib/setup/extend-dynamic-init.js":56,"../lib/setup/set-dimensions.js":57,"../lib/utils/array-to-matrix.js":59,"../lib/utils/deep-assign.js":60,"../lib/utils/polymorph-matrix.js":62,"../lib/utils/to-function.js":63,"./core-kalman-filter.js":35,"./model-collection.js":52,"./state.js":58}],"calculateObservationCovariance":[function(require,module,exports){ -const generateNoisyObservation = require('./generate-noisy-observation.js'); -const getCovariance = require('../../lib/utils/get-covariance.js'); - -const calculateObservationCovariance = function ({groundTruths, rangeNoise = 10, numberRun = 1}) { - const noisyMatrixes = generateNoisyObservation({groundTruths, rangeNoise, numberRun}); - return noisyMatrixes.map(noisyMatrix => getCovariance({measures: noisyMatrix, averages: groundTruths})); -}; - -module.exports = calculateObservationCovariance; - -},{"../../lib/utils/get-covariance.js":61,"./generate-noisy-observation.js":"generateNoisyObservation"}],"generateNoisyObservation":[function(require,module,exports){ -const h = require('hasard'); -const elemWise = require('../../lib/linalgebra/elem-wise.js'); - -const generateNoisyObservation = function ({groundTruths, rangeNoise = 10, numberRun = 1}) { - const hasardNoise = h.matrix({ - shape: [groundTruths.length, groundTruths[0].length], - value: h.integer(-rangeNoise, rangeNoise) - }); - const combinedMatrix = h.fn((noise, gT) => { - return elemWise([noise, gT], ([n, gTCell]) => n + gTCell); - })(hasardNoise, groundTruths); - return combinedMatrix.run(numberRun); -}; - -module.exports = generateNoisyObservation; -// Console.log('Noisy observation', generateNoiseMatrix({groundTruths: demoGroundTruths})) - -},{"../../lib/linalgebra/elem-wise.js":42,"hasard":65}],"url":[function(require,module,exports){ -// Copyright Joyent, Inc. and other Node contributors. -// -// 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. - -'use strict'; - -var punycode = require('punycode'); -var util = require('./util'); - -exports.parse = urlParse; -exports.resolve = urlResolve; -exports.resolveObject = urlResolveObject; -exports.format = urlFormat; - -exports.Url = Url; - -function Url() { - this.protocol = null; - this.slashes = null; - this.auth = null; - this.host = null; - this.port = null; - this.hostname = null; - this.hash = null; - this.search = null; - this.query = null; - this.pathname = null; - this.path = null; - this.href = null; -} - -// Reference: RFC 3986, RFC 1808, RFC 2396 - -// define these here so at least they only have to be -// compiled once on the first module load. -var protocolPattern = /^([a-z0-9.+-]+:)/i, - portPattern = /:[0-9]*$/, - - // Special case for a simple path URL - simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/, - - // RFC 2396: characters reserved for delimiting URLs. - // We actually just auto-escape these. - delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'], - - // RFC 2396: characters not allowed for various reasons. - unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims), - - // Allowed by RFCs, but cause of XSS attacks. Always escape these. - autoEscape = ['\''].concat(unwise), - // Characters that are never ever allowed in a hostname. - // Note that any invalid chars are also handled, but these - // are the ones that are *expected* to be seen, so we fast-path - // them. - nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape), - hostEndingChars = ['/', '?', '#'], - hostnameMaxLen = 255, - hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, - hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, - // protocols that can allow "unsafe" and "unwise" chars. - unsafeProtocol = { - 'javascript': true, - 'javascript:': true - }, - // protocols that never have a hostname. - hostlessProtocol = { - 'javascript': true, - 'javascript:': true - }, - // protocols that always contain a // bit. - slashedProtocol = { - 'http': true, - 'https': true, - 'ftp': true, - 'gopher': true, - 'file': true, - 'http:': true, - 'https:': true, - 'ftp:': true, - 'gopher:': true, - 'file:': true - }, - querystring = require('querystring'); - -function urlParse(url, parseQueryString, slashesDenoteHost) { - if (url && util.isObject(url) && url instanceof Url) return url; - - var u = new Url; - u.parse(url, parseQueryString, slashesDenoteHost); - return u; -} - -Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) { - if (!util.isString(url)) { - throw new TypeError("Parameter 'url' must be a string, not " + typeof url); - } - - // Copy chrome, IE, opera backslash-handling behavior. - // Back slashes before the query string get converted to forward slashes - // See: https://code.google.com/p/chromium/issues/detail?id=25916 - var queryIndex = url.indexOf('?'), - splitter = - (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#', - uSplit = url.split(splitter), - slashRegex = /\\/g; - uSplit[0] = uSplit[0].replace(slashRegex, '/'); - url = uSplit.join(splitter); - - var rest = url; - - // trim before proceeding. - // This is to support parse stuff like " http://foo.com \n" - rest = rest.trim(); - - if (!slashesDenoteHost && url.split('#').length === 1) { - // Try fast path regexp - var simplePath = simplePathPattern.exec(rest); - if (simplePath) { - this.path = rest; - this.href = rest; - this.pathname = simplePath[1]; - if (simplePath[2]) { - this.search = simplePath[2]; - if (parseQueryString) { - this.query = querystring.parse(this.search.substr(1)); - } else { - this.query = this.search.substr(1); - } - } else if (parseQueryString) { - this.search = ''; - this.query = {}; - } - return this; - } - } - - var proto = protocolPattern.exec(rest); - if (proto) { - proto = proto[0]; - var lowerProto = proto.toLowerCase(); - this.protocol = lowerProto; - rest = rest.substr(proto.length); - } - - // figure out if it's got a host - // user@server is *always* interpreted as a hostname, and url - // resolution will treat //foo/bar as host=foo,path=bar because that's - // how the browser resolves relative URLs. - if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) { - var slashes = rest.substr(0, 2) === '//'; - if (slashes && !(proto && hostlessProtocol[proto])) { - rest = rest.substr(2); - this.slashes = true; - } - } - - if (!hostlessProtocol[proto] && - (slashes || (proto && !slashedProtocol[proto]))) { - - // there's a hostname. - // the first instance of /, ?, ;, or # ends the host. - // - // If there is an @ in the hostname, then non-host chars *are* allowed - // to the left of the last @ sign, unless some host-ending character - // comes *before* the @-sign. - // URLs are obnoxious. - // - // ex: - // http://a@b@c/ => user:a@b host:c - // http://a@b?@c => user:a host:c path:/?@c - - // v0.12 TODO(isaacs): This is not quite how Chrome does things. - // Review our test case against browsers more comprehensively. - - // find the first instance of any hostEndingChars - var hostEnd = -1; - for (var i = 0; i < hostEndingChars.length; i++) { - var hec = rest.indexOf(hostEndingChars[i]); - if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) - hostEnd = hec; - } - - // at this point, either we have an explicit point where the - // auth portion cannot go past, or the last @ char is the decider. - var auth, atSign; - if (hostEnd === -1) { - // atSign can be anywhere. - atSign = rest.lastIndexOf('@'); - } else { - // atSign must be in auth portion. - // http://a@b/c@d => host:b auth:a path:/c@d - atSign = rest.lastIndexOf('@', hostEnd); - } - - // Now we have a portion which is definitely the auth. - // Pull that off. - if (atSign !== -1) { - auth = rest.slice(0, atSign); - rest = rest.slice(atSign + 1); - this.auth = decodeURIComponent(auth); - } - - // the host is the remaining to the left of the first non-host char - hostEnd = -1; - for (var i = 0; i < nonHostChars.length; i++) { - var hec = rest.indexOf(nonHostChars[i]); - if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) - hostEnd = hec; - } - // if we still have not hit it, then the entire thing is a host. - if (hostEnd === -1) - hostEnd = rest.length; - - this.host = rest.slice(0, hostEnd); - rest = rest.slice(hostEnd); - - // pull out port. - this.parseHost(); - - // we've indicated that there is a hostname, - // so even if it's empty, it has to be present. - this.hostname = this.hostname || ''; - - // if hostname begins with [ and ends with ] - // assume that it's an IPv6 address. - var ipv6Hostname = this.hostname[0] === '[' && - this.hostname[this.hostname.length - 1] === ']'; - - // validate a little. - if (!ipv6Hostname) { - var hostparts = this.hostname.split(/\./); - for (var i = 0, l = hostparts.length; i < l; i++) { - var part = hostparts[i]; - if (!part) continue; - if (!part.match(hostnamePartPattern)) { - var newpart = ''; - for (var j = 0, k = part.length; j < k; j++) { - if (part.charCodeAt(j) > 127) { - // we replace non-ASCII char with a temporary placeholder - // we need this to make sure size of hostname is not - // broken by replacing non-ASCII by nothing - newpart += 'x'; - } else { - newpart += part[j]; - } - } - // we test again with ASCII char only - if (!newpart.match(hostnamePartPattern)) { - var validParts = hostparts.slice(0, i); - var notHost = hostparts.slice(i + 1); - var bit = part.match(hostnamePartStart); - if (bit) { - validParts.push(bit[1]); - notHost.unshift(bit[2]); - } - if (notHost.length) { - rest = '/' + notHost.join('.') + rest; - } - this.hostname = validParts.join('.'); - break; - } - } - } - } - - if (this.hostname.length > hostnameMaxLen) { - this.hostname = ''; - } else { - // hostnames are always lower case. - this.hostname = this.hostname.toLowerCase(); - } - - if (!ipv6Hostname) { - // IDNA Support: Returns a punycoded representation of "domain". - // It only converts parts of the domain name that - // have non-ASCII characters, i.e. it doesn't matter if - // you call it with a domain that already is ASCII-only. - this.hostname = punycode.toASCII(this.hostname); - } - - var p = this.port ? ':' + this.port : ''; - var h = this.hostname || ''; - this.host = h + p; - this.href += this.host; - - // strip [ and ] from the hostname - // the host field still retains them, though - if (ipv6Hostname) { - this.hostname = this.hostname.substr(1, this.hostname.length - 2); - if (rest[0] !== '/') { - rest = '/' + rest; - } - } - } - - // now rest is set to the post-host stuff. - // chop off any delim chars. - if (!unsafeProtocol[lowerProto]) { - - // First, make 100% sure that any "autoEscape" chars get - // escaped, even if encodeURIComponent doesn't think they - // need to be. - for (var i = 0, l = autoEscape.length; i < l; i++) { - var ae = autoEscape[i]; - if (rest.indexOf(ae) === -1) - continue; - var esc = encodeURIComponent(ae); - if (esc === ae) { - esc = escape(ae); - } - rest = rest.split(ae).join(esc); - } - } - - - // chop off from the tail first. - var hash = rest.indexOf('#'); - if (hash !== -1) { - // got a fragment string. - this.hash = rest.substr(hash); - rest = rest.slice(0, hash); - } - var qm = rest.indexOf('?'); - if (qm !== -1) { - this.search = rest.substr(qm); - this.query = rest.substr(qm + 1); - if (parseQueryString) { - this.query = querystring.parse(this.query); - } - rest = rest.slice(0, qm); - } else if (parseQueryString) { - // no query string, but parseQueryString still requested - this.search = ''; - this.query = {}; - } - if (rest) this.pathname = rest; - if (slashedProtocol[lowerProto] && - this.hostname && !this.pathname) { - this.pathname = '/'; - } - - //to support http.request - if (this.pathname || this.search) { - var p = this.pathname || ''; - var s = this.search || ''; - this.path = p + s; - } - - // finally, reconstruct the href based on what has been validated. - this.href = this.format(); - return this; -}; - -// format a parsed object into a url string -function urlFormat(obj) { - // ensure it's an object, and not a string url. - // If it's an obj, this is a no-op. - // this way, you can call url_format() on strings - // to clean up potentially wonky urls. - if (util.isString(obj)) obj = urlParse(obj); - if (!(obj instanceof Url)) return Url.prototype.format.call(obj); - return obj.format(); -} - -Url.prototype.format = function() { - var auth = this.auth || ''; - if (auth) { - auth = encodeURIComponent(auth); - auth = auth.replace(/%3A/i, ':'); - auth += '@'; - } - - var protocol = this.protocol || '', - pathname = this.pathname || '', - hash = this.hash || '', - host = false, - query = ''; - - if (this.host) { - host = auth + this.host; - } else if (this.hostname) { - host = auth + (this.hostname.indexOf(':') === -1 ? - this.hostname : - '[' + this.hostname + ']'); - if (this.port) { - host += ':' + this.port; - } - } - - if (this.query && - util.isObject(this.query) && - Object.keys(this.query).length) { - query = querystring.stringify(this.query); - } - - var search = this.search || (query && ('?' + query)) || ''; - - if (protocol && protocol.substr(-1) !== ':') protocol += ':'; - - // only the slashedProtocols get the //. Not mailto:, xmpp:, etc. - // unless they had them to begin with. - if (this.slashes || - (!protocol || slashedProtocol[protocol]) && host !== false) { - host = '//' + (host || ''); - if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname; - } else if (!host) { - host = ''; - } - - if (hash && hash.charAt(0) !== '#') hash = '#' + hash; - if (search && search.charAt(0) !== '?') search = '?' + search; - - pathname = pathname.replace(/[?#]/g, function(match) { - return encodeURIComponent(match); - }); - search = search.replace('#', '%23'); - - return protocol + host + pathname + search + hash; -}; - -function urlResolve(source, relative) { - return urlParse(source, false, true).resolve(relative); -} - -Url.prototype.resolve = function(relative) { - return this.resolveObject(urlParse(relative, false, true)).format(); -}; - -function urlResolveObject(source, relative) { - if (!source) return relative; - return urlParse(source, false, true).resolveObject(relative); -} - -Url.prototype.resolveObject = function(relative) { - if (util.isString(relative)) { - var rel = new Url(); - rel.parse(relative, false, true); - relative = rel; - } - - var result = new Url(); - var tkeys = Object.keys(this); - for (var tk = 0; tk < tkeys.length; tk++) { - var tkey = tkeys[tk]; - result[tkey] = this[tkey]; - } - - // hash is always overridden, no matter what. - // even href="" will remove it. - result.hash = relative.hash; - - // if the relative url is empty, then there's nothing left to do here. - if (relative.href === '') { - result.href = result.format(); - return result; - } - - // hrefs like //foo/bar always cut to the protocol. - if (relative.slashes && !relative.protocol) { - // take everything except the protocol from relative - var rkeys = Object.keys(relative); - for (var rk = 0; rk < rkeys.length; rk++) { - var rkey = rkeys[rk]; - if (rkey !== 'protocol') - result[rkey] = relative[rkey]; - } - - //urlParse appends trailing / to urls like http://www.example.com - if (slashedProtocol[result.protocol] && - result.hostname && !result.pathname) { - result.path = result.pathname = '/'; - } - - result.href = result.format(); - return result; - } - - if (relative.protocol && relative.protocol !== result.protocol) { - // if it's a known url protocol, then changing - // the protocol does weird things - // first, if it's not file:, then we MUST have a host, - // and if there was a path - // to begin with, then we MUST have a path. - // if it is file:, then the host is dropped, - // because that's known to be hostless. - // anything else is assumed to be absolute. - if (!slashedProtocol[relative.protocol]) { - var keys = Object.keys(relative); - for (var v = 0; v < keys.length; v++) { - var k = keys[v]; - result[k] = relative[k]; - } - result.href = result.format(); - return result; - } - - result.protocol = relative.protocol; - if (!relative.host && !hostlessProtocol[relative.protocol]) { - var relPath = (relative.pathname || '').split('/'); - while (relPath.length && !(relative.host = relPath.shift())); - if (!relative.host) relative.host = ''; - if (!relative.hostname) relative.hostname = ''; - if (relPath[0] !== '') relPath.unshift(''); - if (relPath.length < 2) relPath.unshift(''); - result.pathname = relPath.join('/'); - } else { - result.pathname = relative.pathname; - } - result.search = relative.search; - result.query = relative.query; - result.host = relative.host || ''; - result.auth = relative.auth; - result.hostname = relative.hostname || relative.host; - result.port = relative.port; - // to support http.request - if (result.pathname || result.search) { - var p = result.pathname || ''; - var s = result.search || ''; - result.path = p + s; - } - result.slashes = result.slashes || relative.slashes; - result.href = result.format(); - return result; - } - - var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'), - isRelAbs = ( - relative.host || - relative.pathname && relative.pathname.charAt(0) === '/' - ), - mustEndAbs = (isRelAbs || isSourceAbs || - (result.host && relative.pathname)), - removeAllDots = mustEndAbs, - srcPath = result.pathname && result.pathname.split('/') || [], - relPath = relative.pathname && relative.pathname.split('/') || [], - psychotic = result.protocol && !slashedProtocol[result.protocol]; - - // if the url is a non-slashed url, then relative - // links like ../.. should be able - // to crawl up to the hostname, as well. This is strange. - // result.protocol has already been set by now. - // Later on, put the first path part into the host field. - if (psychotic) { - result.hostname = ''; - result.port = null; - if (result.host) { - if (srcPath[0] === '') srcPath[0] = result.host; - else srcPath.unshift(result.host); - } - result.host = ''; - if (relative.protocol) { - relative.hostname = null; - relative.port = null; - if (relative.host) { - if (relPath[0] === '') relPath[0] = relative.host; - else relPath.unshift(relative.host); - } - relative.host = null; - } - mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === ''); - } - - if (isRelAbs) { - // it's absolute. - result.host = (relative.host || relative.host === '') ? - relative.host : result.host; - result.hostname = (relative.hostname || relative.hostname === '') ? - relative.hostname : result.hostname; - result.search = relative.search; - result.query = relative.query; - srcPath = relPath; - // fall through to the dot-handling below. - } else if (relPath.length) { - // it's relative - // throw away the existing file, and take the new path instead. - if (!srcPath) srcPath = []; - srcPath.pop(); - srcPath = srcPath.concat(relPath); - result.search = relative.search; - result.query = relative.query; - } else if (!util.isNullOrUndefined(relative.search)) { - // just pull out the search. - // like href='?foo'. - // Put this after the other two cases because it simplifies the booleans - if (psychotic) { - result.hostname = result.host = srcPath.shift(); - //occationaly the auth can get stuck only in host - //this especially happens in cases like - //url.resolveObject('mailto:local1@domain1', 'local2@domain2') - var authInHost = result.host && result.host.indexOf('@') > 0 ? - result.host.split('@') : false; - if (authInHost) { - result.auth = authInHost.shift(); - result.host = result.hostname = authInHost.shift(); - } - } - result.search = relative.search; - result.query = relative.query; - //to support http.request - if (!util.isNull(result.pathname) || !util.isNull(result.search)) { - result.path = (result.pathname ? result.pathname : '') + - (result.search ? result.search : ''); - } - result.href = result.format(); - return result; - } - - if (!srcPath.length) { - // no path at all. easy. - // we've already handled the other stuff above. - result.pathname = null; - //to support http.request - if (result.search) { - result.path = '/' + result.search; - } else { - result.path = null; - } - result.href = result.format(); - return result; - } - - // if a url ENDs in . or .., then it must get a trailing slash. - // however, if it ends in anything else non-slashy, - // then it must NOT get a trailing slash. - var last = srcPath.slice(-1)[0]; - var hasTrailingSlash = ( - (result.host || relative.host || srcPath.length > 1) && - (last === '.' || last === '..') || last === ''); - - // strip single dots, resolve double dots to parent dir - // if the path tries to go above the root, `up` ends up > 0 - var up = 0; - for (var i = srcPath.length; i >= 0; i--) { - last = srcPath[i]; - if (last === '.') { - srcPath.splice(i, 1); - } else if (last === '..') { - srcPath.splice(i, 1); - up++; - } else if (up) { - srcPath.splice(i, 1); - up--; - } - } - - // if the path is allowed to go above the root, restore leading ..s - if (!mustEndAbs && !removeAllDots) { - for (; up--; up) { - srcPath.unshift('..'); - } - } - - if (mustEndAbs && srcPath[0] !== '' && - (!srcPath[0] || srcPath[0].charAt(0) !== '/')) { - srcPath.unshift(''); - } - - if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) { - srcPath.push(''); - } - - var isAbsolute = srcPath[0] === '' || - (srcPath[0] && srcPath[0].charAt(0) === '/'); - - // put the host back - if (psychotic) { - result.hostname = result.host = isAbsolute ? '' : - srcPath.length ? srcPath.shift() : ''; - //occationaly the auth can get stuck only in host - //this especially happens in cases like - //url.resolveObject('mailto:local1@domain1', 'local2@domain2') - var authInHost = result.host && result.host.indexOf('@') > 0 ? - result.host.split('@') : false; - if (authInHost) { - result.auth = authInHost.shift(); - result.host = result.hostname = authInHost.shift(); - } - } - - mustEndAbs = mustEndAbs || (result.host && srcPath.length); - - if (mustEndAbs && !isAbsolute) { - srcPath.unshift(''); - } - - if (!srcPath.length) { - result.pathname = null; - result.path = null; - } else { - result.pathname = srcPath.join('/'); - } - - //to support request.http - if (!util.isNull(result.pathname) || !util.isNull(result.search)) { - result.path = (result.pathname ? result.pathname : '') + - (result.search ? result.search : ''); - } - result.auth = relative.auth || result.auth; - result.slashes = result.slashes || relative.slashes; - result.href = result.format(); - return result; -}; - -Url.prototype.parseHost = function() { - var host = this.host; - var port = portPattern.exec(host); - if (port) { - port = port[0]; - if (port !== ':') { - this.port = port.substr(1); - } - host = host.substr(0, host.length - port.length); - } - if (host) this.hostname = host; -}; - -},{"./util":33,"punycode":12,"querystring":15}]},{},[]); diff --git a/demo/src/main.js b/demo/src/main.js index d0b8e40..a2047f4 100644 --- a/demo/src/main.js +++ b/demo/src/main.js @@ -1,6 +1,6 @@ const KalmanFilter = require('../../lib/kalman-filter'); -const noisyObservations = require('./observation.json'); +const noisyObservations = require('./observations.json').observations; const kfOptions = require('./kf-options.js'); const createElement = require('./views/create-element'); const createGroupBoxes = require('./views/create-group-boxes'); @@ -11,45 +11,50 @@ let predicted = kf.predict(); const img = document.querySelector('#bikes');// eslint-disable-line no-undef // Create all the elements of the prediction or correction phase -const delay = 1000; +const delay = 100; let promise = Promise.resolve(); let previousCorrected = null; const delayPromise = delay => new Promise(resolve => setTimeout(resolve, delay)); -noisyObservations.forEach((box, index) => { - promise = promise - .then(() => { - predicted = kf.predict({previousCorrected}); - const {mean, covariance} = predicted; - - createGroupBoxes({mean, covariance, parent: img, className: 'predicted', color: 'blue'}); - - return delayPromise(delay); - }) - .then((b => { - createElement({ - className: 'observation', - bbox: [ - b[0] + (b[2] / 2), - b[1] + (b[3] / 2), - b[2], - b[3] - ], - parent: img, - color: 'white', - lineStyle: 'solid' - }); - - return delayPromise(delay); - }).bind(null, box, index)) - .then((b => { - previousCorrected = kf.correct({predicted, observation: b}); - const {mean, covariance} = previousCorrected; - - createGroupBoxes({mean, covariance, parent: img, className: 'corrected', color: 'red'}); - - return delayPromise(delay); - }).bind(null, box, index)); -}); +module.exports = { + run() { + noisyObservations.forEach((box, index) => { + promise = promise + .then(() => { + predicted = kf.predict({previousCorrected}); + const {mean, covariance} = predicted; + + createGroupBoxes({mean, covariance, parent: img, className: 'predicted', color: 'blue'}); + + return delayPromise(delay); + }) + .then((b => { + createElement({ + className: 'observation', + bbox: [ + b[0] + (b[2] / 2), + b[1] + (b[3] / 2), + b[2], + b[3] + ], + parent: img, + color: 'white', + lineStyle: 'solid' + }); + + return delayPromise(delay); + }).bind(null, box, index)) + .then((b => { + previousCorrected = kf.correct({predicted, observation: b}); + const {mean, covariance} = previousCorrected; + + createGroupBoxes({mean, covariance, parent: img, className: 'corrected', color: 'red'}); + + return delayPromise(delay); + }).bind(null, box, index)); + }); + } +}; + diff --git a/demo/src/observation-covariance.json b/demo/src/observation-covariance.json new file mode 100644 index 0000000..6d6736e --- /dev/null +++ b/demo/src/observation-covariance.json @@ -0,0 +1 @@ +[[34.31428571428572,-8.114285714285714,-9.185714285714285,3.0428571428571427],[-8.114285714285714,39.08571428571429,1.1857142857142857,-5.5285714285714285],[-9.185714285714285,1.1857142857142857,34.628571428571426,0.7857142857142857],[3.0428571428571427,-5.5285714285714285,0.7857142857142857,39.857142857142854]] \ No newline at end of file diff --git a/demo/src/observations.json b/demo/src/observations.json index e0cdb66..abae056 100644 --- a/demo/src/observations.json +++ b/demo/src/observations.json @@ -1 +1 @@ -{"observations":[[845,290,89,84],[699,181,95,92],[570,104,111,119],[437,93,86,101],[285,129,82,96],[149,205,85,78],[15,295,73,91]]} \ No newline at end of file +{"observations":[[842,286,82,81],[714,184,92,80],[560,107,112,116],[418,94,96,110],[277,141,89,89],[146,200,88,72],[22,306,77,82]]} \ No newline at end of file diff --git a/demo/src/views/create-group-boxes.js b/demo/src/views/create-group-boxes.js index 9509cb2..5c7e3fe 100644 --- a/demo/src/views/create-group-boxes.js +++ b/demo/src/views/create-group-boxes.js @@ -82,6 +82,5 @@ module.exports = function ({mean, covariance, color, parent, className, tag = 'd scale: arrowScale, color }); - container.style.display = 'none'; parent.append(container); }; diff --git a/demo/style.css b/demo/style.css new file mode 100644 index 0000000..eb747f1 --- /dev/null +++ b/demo/style.css @@ -0,0 +1,98 @@ + .img{ + position: relative; + display: inline-block; /* Make the width of box same as image */ + overflow: hidden; + } + .img .box{ + position: absolute; + z-index: 999; + margin: 0 auto; + border: 1px solid white; + } + .img .observation{ + position: absolute; + z-index: 999; + margin: 0 auto; + border: 1px solid white; + } + .img .dashedLine{ + position: absolute; + z-index: 999; + margin: 0 auto; + } + .top-right { + position: absolute; + top: 20px; + right: 20px; + background-color: grey; + color: white; + padding-left: 20px; + padding-right: 20px; + } + .img .point{ + position: absolute; + z-index: 999; + margin: 0 auto; + border: 2px solid red; + + } + .img .ellipse { + position: absolute; + z-index: 999; + margin: 0 auto; + border-radius: 50%; + } + .img .arrow { + position: absolute; + border-width: 4px; + border-style: solid; + border-bottom-color: transparent; + border-left-color: transparent; + display: inline-block; + vertical-align: middle; + box-sizing: border-box; + } + + .img.observation .observation, .img.predicted .predicted,.img.corrected .corrected { + display: block; + } + + .img.not-observation .observation { + display: none; + } + .img.not-predicted .predicted { + display: none; + } + .img.not-corrected .corrected { + display: none; + } + .img.not-covariances .dashedLine { + display: none; + } + .img.not-variances .stdDev { + display: none; + } + .img.not-speedVectors .arrow { + display: none; + } + .img .arrow:before{ + right: 0; + top: -3px; + position: absolute; + height: 3px; + box-shadow: inset 0 0 0 32px; + transform: rotate(-45deg); + width: 15px; + transform-origin: right top; + content: ""; + box-sizing: border-box; + } + div.img .stdDev{ + border-style: dotted; + } + .img .predicted .box,.img .predicted .ellipse, .img .predicted .point{ + border-color: blue; + } + .img .corrected .box,.img .corrected .ellipse, .img .corrected .point{ + border-color: red; + } \ No newline at end of file diff --git a/lib/core-kalman-filter.js b/lib/core-kalman-filter.js index 3d837bd..49d2315 100644 --- a/lib/core-kalman-filter.js +++ b/lib/core-kalman-filter.js @@ -116,9 +116,8 @@ class CoreKalmanFilter { let index; if (typeof (previousCorrected.index) === 'number') { index = previousCorrected.index + 1; - } - else { - index = 'Index key is not defined' + } else { + index = null; } const predicted = new State({mean, covariance, index}); @@ -192,6 +191,9 @@ class CoreKalmanFilter { predicted.mean, matMul(optimalKalmanGain, innovation) ); + if (Number.isNaN(mean[0][0])) { + throw (new TypeError('Mean is NaN after correction')); + } const covariance = this.getCorrectedCovariance({predicted}); const corrected = new State({mean, covariance, index: predicted.index}); diff --git a/package.json b/package.json index 3ca70af..07b5e90 100644 --- a/package.json +++ b/package.json @@ -4,7 +4,8 @@ "description": "Kalman filter (and Extended Kalman Filter) Multi-dimensional implementation in Javascript", "main": "index.js", "scripts": { - "test": "xo && ava test/unit/kalman-filter/*" + "test": "xo && ava test/unit/kalman-filter/*", + "build-demo": "browserify -d -r ./demo/src/main.js:main > demo/dist/demo.js" }, "repository": { "type": "git", @@ -59,6 +60,7 @@ "matrix-inverse": "^1.0.1" }, "xo": { + "ignores": ["./demo/dist/**"], "rules": { "no-multi-assign": 0, "unicorn/no-reduce": 0, diff --git a/script/demo/helpers/calculate-observation-covariance.js b/script/demo/helpers/calculate-observation-covariance.js index 3c1f3f8..3ff732c 100644 --- a/script/demo/helpers/calculate-observation-covariance.js +++ b/script/demo/helpers/calculate-observation-covariance.js @@ -1,9 +1,18 @@ const generateNoisyObservation = require('./generate-noisy-observation.js'); -const getCovariance = require('../../lib/utils/get-covariance.js'); +const getCovariance = require('../../../lib/utils/get-covariance.js'); const calculateObservationCovariance = function ({groundTruths, rangeNoise = 10, numberRun = 1}) { const noisyMatrixes = generateNoisyObservation({groundTruths, rangeNoise, numberRun}); - return noisyMatrixes.map(noisyMatrix => getCovariance({measures: noisyMatrix, averages: groundTruths})); + const measures = noisyMatrixes.reduce((a, b) => a.concat(b)); + + const averages = new Array(numberRun).fill(0).map(() => groundTruths).reduce((a, b) => a.concat(b)); + const covariance = getCovariance({ + measures, + averages + }); + // Console.log(measures, averages, measures.length, averages.length,covariance); + + return covariance; }; module.exports = calculateObservationCovariance; diff --git a/script/demo/helpers/generate-noisy-observation.js b/script/demo/helpers/generate-noisy-observation.js index 996fc0a..be5c0af 100644 --- a/script/demo/helpers/generate-noisy-observation.js +++ b/script/demo/helpers/generate-noisy-observation.js @@ -1,7 +1,7 @@ const h = require('hasard'); const elemWise = require('../../../lib/linalgebra/elem-wise.js'); -const generateNoisyObservation = function ({groundTruths, rangeNoise = 10}) { +const generateNoisyObservation = function ({groundTruths, rangeNoise = 10, numberRun = 1}) { const hasardNoise = h.matrix({ shape: [groundTruths.length, groundTruths[0].length], value: h.integer(-rangeNoise, rangeNoise) @@ -9,7 +9,7 @@ const generateNoisyObservation = function ({groundTruths, rangeNoise = 10}) { const combinedMatrix = h.fn((noise, gT) => { return elemWise([noise, gT], ([n, gTCell]) => n + gTCell); })(hasardNoise, groundTruths); - return combinedMatrix.runOnce(); + return combinedMatrix.run(numberRun); }; module.exports = generateNoisyObservation; diff --git a/script/demo/update-input-data.js b/script/demo/update-input-data.js index 41bca89..d94f5bd 100644 --- a/script/demo/update-input-data.js +++ b/script/demo/update-input-data.js @@ -1,4 +1,5 @@ -var generateNoisyObservation = require('./helpers/generate-noisy-observation'); +const generateNoisyObservation = require('./helpers/generate-noisy-observation'); +const calculateObservationCovariance = require('./helpers/calculate-observation-covariance'); const fs = require('fs'); const boxes = [ @@ -25,5 +26,9 @@ const boxes = [ ] ]; -const noisyObservations = generateNoisyObservation({groundTruths: boxes}); -fs.writeFileSync('./demo/observations.json', JSON.stringify({observations: noisyObservations})); \ No newline at end of file +const noisyObservations = generateNoisyObservation({groundTruths: boxes})[0]; +fs.writeFileSync('./demo/src/observations.json', JSON.stringify({observations: noisyObservations})); + +const observationCovariance = calculateObservationCovariance({groundTruths: boxes, numberRun: 10}); + +fs.writeFileSync('./demo/src/observation-covariance.json', JSON.stringify(observationCovariance)); diff --git a/test/api/basic.js b/test/api/basic.js index c7eba0f..647b19c 100644 --- a/test/api/basic.js +++ b/test/api/basic.js @@ -4,8 +4,7 @@ const test = require('ava'); const KalmanFilter = require('../../lib/kalman-filter.js'); const State = require('../../lib/state.js'); -// const getCovariance = require('../../lib/utils/get-covariance.js'); -const identity = require('../../lib/linalgebra/identity.js') +// Const getCovariance = require('../../lib/utils/get-covariance.js'); const observations = [[0, 2], [0.1, 4], [0.5, 9], [0.2, 12]]; test('Constant-position on 2D Data', t => { @@ -177,97 +176,38 @@ test('Simple Batch Usage', t => { t.is(results.length, 4); }); -// test('getCovariance', t => { -// -// // Ground truth values in the dynamic model hidden state -// const groundTruthStates = [ // Here this is (x, vx) -// [[0, 1.1], [1.1, 1], [2.1, 0.9], [3, 1], [4, 1.2]], // Example 1 -// [[8, 1.1], [9.1, 1], [10.1, 0.9], [11, 1], [12, 1.2]] // Example 2 -// ]; -// -// // Observations of this values -// const measures = [ // Here this is x only -// [[0.1], [1.3], [2.4], [2.6], [3.8]], // Example 1 -// [[8.1], [9.3], [10.4], [10.6], [11.8]] // Example 2 -// ]; -// -// let kFilter = new KalmanFilter({ -// observation: { -// name: 'sensors', -// sensorDimension: 1 -// }, -// dynamic: { -// name: 'constant-speed' -// } -// }); -// const dynamicCovariance = getCovariance({ -// measures: groundTruthStates.map(ex => { -// return ex.slice(1).map((_, index) => { -// console.log('mean', ex[0]); -// console.log('covariance', identity(groundTruthStates[0][0].length)) -// const previousCorrected = new State({ -// mean: ex[index], -// covariance: identity(groundTruthStates[0][0].length) -// }); -// return kFilter.predict({previousCorrected}).mean; -// }); -// }).reduce((a, b) => a.concat(b)), -// averages: groundTruthStates.map(ex => { -// return ex.slice(1); -// }).reduce((a, b) => a.concat(b)) -// }); -// -// const observationCovariance = getCovariance({ -// measures: measures.reduce((a, b) => a.concat(b)), -// averages: groundTruthStates.map(a => a[0]).reduce((a, b) => a.concat(b)) -// }); -// -// kFilter = Object.assign({}, kFilter, { -// observation: { -// covariance: observationCovariance -// }, -// dynamic: { -// covariance: dynamicCovariance -// } -// }) -// const predicted = kFilter.predict(); -// t.is(observationCovariance.length, 1); -// t.is(dynamicCovariance.length, 2); -// t.is(predcited instanceof State); -// }); +test('Model fits ', t => { + const kFilter = new KalmanFilter({ + observation: { + sensorDimension: 2, + name: 'sensors' + }, + dynamic: { + name: 'constant-speed', // Observation.sensorDimension == dynamic.dimension + covariance: [3, 4]// Equivalent to diag([3, 4]) + } + }); + const observations = [[0, 2], [0.1, 4], [0.5, 9], [0.2, 12]]; + + // Online kalman filter + let previousCorrected = null; + const distances = []; + observations.forEach(observation => { + const predicted = kFilter.predict({ + previousCorrected + }); + + const dist = predicted.mahalanobis(observation); + + previousCorrected = kFilter.correct({ + predicted, + observation + }); -// test('Model fits ', t => { -// const kFilter = new KalmanFilter({ -// observation: { -// sensorDimension: 2, -// name: 'sensors' -// }, -// dynamic: { -// name: 'constant-speed', // Observation.sensorDimension == dynamic.dimension -// covariance: [3, 4]// Equivalent to diag([3, 4]) -// } -// }); -// const observations = [[0, 2], [0.1, 4], [0.5, 9], [0.2, 12]]; -// -// // Online kalman filter -// let previousCorrected = null; -// const distances = []; -// observations.forEach(observation => { -// const predicted = kFilter.predict({ -// previousCorrected -// }); -// -// const dist = predicted.mahalanobis(observation); -// -// previousCorrected = kFilter.correct({ -// predicted, -// observation -// }); -// -// distances.push(dist); -// }); -// -// const distance = distances.reduce((d1, d2) => d1 + d2, 0); -// -// t.true(distance > 0); -// }); + distances.push(dist); + }); + + const distance = distances.reduce((d1, d2) => d1 + d2, 0); + + t.true(distance > 0); +}); diff --git a/test/unit/kalman-filter/filter.js b/test/unit/kalman-filter/filter.js index 0d6ce31..055df17 100644 --- a/test/unit/kalman-filter/filter.js +++ b/test/unit/kalman-filter/filter.js @@ -15,7 +15,7 @@ test('Filter method', t => { name: 'sensors' } }); - const filtered = kf.filter({observation: observations[0]}); + const filtered = kf.filter({observation: observations[0]});// eslint-disable-line unicorn/no-fn-reference-in-iterator t.true(filtered instanceof State); const predicted = kf.predict(); @@ -35,7 +35,7 @@ test('FilterAll', t => { }); const allFiltered = kf.filterAll(observations); t.is(allFiltered.length, 3); - const filtered = kf.filter({observation: observations[0]}); + const filtered = kf.filter({observation: observations[0]});// eslint-disable-line unicorn/no-fn-reference-in-iterator const firstMean = filtered.mean; t.deepEqual(firstMean, allFiltered[0]); });