4983 lines
185 KiB
JavaScript
4983 lines
185 KiB
JavaScript
/**
|
|
* Cesium - https://github.com/AnalyticalGraphicsInc/cesium
|
|
*
|
|
* Copyright 2011-2017 Cesium Contributors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Columbus View (Pat. Pend.)
|
|
*
|
|
* Portions licensed separately.
|
|
* See https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md for full licensing details.
|
|
*/
|
|
(function () {
|
|
define('Core/defined',[],function() {
|
|
'use strict';
|
|
|
|
/**
|
|
* @exports defined
|
|
*
|
|
* @param {*} value The object.
|
|
* @returns {Boolean} Returns true if the object is defined, returns false otherwise.
|
|
*
|
|
* @example
|
|
* if (Cesium.defined(positions)) {
|
|
* doSomething();
|
|
* } else {
|
|
* doSomethingElse();
|
|
* }
|
|
*/
|
|
function defined(value) {
|
|
return value !== undefined && value !== null;
|
|
}
|
|
|
|
return defined;
|
|
});
|
|
|
|
define('Core/DeveloperError',[
|
|
'./defined'
|
|
], function(
|
|
defined) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Constructs an exception object that is thrown due to a developer error, e.g., invalid argument,
|
|
* argument out of range, etc. This exception should only be thrown during development;
|
|
* it usually indicates a bug in the calling code. This exception should never be
|
|
* caught; instead the calling code should strive not to generate it.
|
|
* <br /><br />
|
|
* On the other hand, a {@link RuntimeError} indicates an exception that may
|
|
* be thrown at runtime, e.g., out of memory, that the calling code should be prepared
|
|
* to catch.
|
|
*
|
|
* @alias DeveloperError
|
|
* @constructor
|
|
* @extends Error
|
|
*
|
|
* @param {String} [message] The error message for this exception.
|
|
*
|
|
* @see RuntimeError
|
|
*/
|
|
function DeveloperError(message) {
|
|
/**
|
|
* 'DeveloperError' indicating that this exception was thrown due to a developer error.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.name = 'DeveloperError';
|
|
|
|
/**
|
|
* The explanation for why this exception was thrown.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.message = message;
|
|
|
|
//Browsers such as IE don't have a stack property until you actually throw the error.
|
|
var stack;
|
|
try {
|
|
throw new Error();
|
|
} catch (e) {
|
|
stack = e.stack;
|
|
}
|
|
|
|
/**
|
|
* The stack trace of this exception, if available.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.stack = stack;
|
|
}
|
|
|
|
if (defined(Object.create)) {
|
|
DeveloperError.prototype = Object.create(Error.prototype);
|
|
DeveloperError.prototype.constructor = DeveloperError;
|
|
}
|
|
|
|
DeveloperError.prototype.toString = function() {
|
|
var str = this.name + ': ' + this.message;
|
|
|
|
if (defined(this.stack)) {
|
|
str += '\n' + this.stack.toString();
|
|
}
|
|
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
DeveloperError.throwInstantiationError = function() {
|
|
throw new DeveloperError('This function defines an interface and should not be called directly.');
|
|
};
|
|
|
|
return DeveloperError;
|
|
});
|
|
|
|
define('Core/Check',[
|
|
'./defined',
|
|
'./DeveloperError'
|
|
], function(
|
|
defined,
|
|
DeveloperError) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Contains functions for checking that supplied arguments are of a specified type
|
|
* or meet specified conditions
|
|
* @private
|
|
*/
|
|
var Check = {};
|
|
|
|
/**
|
|
* Contains type checking functions, all using the typeof operator
|
|
*/
|
|
Check.typeOf = {};
|
|
|
|
function getUndefinedErrorMessage(name) {
|
|
return name + ' is required, actual value was undefined';
|
|
}
|
|
|
|
function getFailedTypeErrorMessage(actual, expected, name) {
|
|
return 'Expected ' + name + ' to be typeof ' + expected + ', actual typeof was ' + actual;
|
|
}
|
|
|
|
/**
|
|
* Throws if test is not defined
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value that is to be checked
|
|
* @exception {DeveloperError} test must be defined
|
|
*/
|
|
Check.defined = function (name, test) {
|
|
if (!defined(test)) {
|
|
throw new DeveloperError(getUndefinedErrorMessage(name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'function'
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @exception {DeveloperError} test must be typeof 'function'
|
|
*/
|
|
Check.typeOf.func = function (name, test) {
|
|
if (typeof test !== 'function') {
|
|
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'function', name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'string'
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @exception {DeveloperError} test must be typeof 'string'
|
|
*/
|
|
Check.typeOf.string = function (name, test) {
|
|
if (typeof test !== 'string') {
|
|
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'string', name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'number'
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @exception {DeveloperError} test must be typeof 'number'
|
|
*/
|
|
Check.typeOf.number = function (name, test) {
|
|
if (typeof test !== 'number') {
|
|
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'number', name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'number' and less than limit
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @param {Number} limit The limit value to compare against
|
|
* @exception {DeveloperError} test must be typeof 'number' and less than limit
|
|
*/
|
|
Check.typeOf.number.lessThan = function (name, test, limit) {
|
|
Check.typeOf.number(name, test);
|
|
if (test >= limit) {
|
|
throw new DeveloperError('Expected ' + name + ' to be less than ' + limit + ', actual value was ' + test);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'number' and less than or equal to limit
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @param {Number} limit The limit value to compare against
|
|
* @exception {DeveloperError} test must be typeof 'number' and less than or equal to limit
|
|
*/
|
|
Check.typeOf.number.lessThanOrEquals = function (name, test, limit) {
|
|
Check.typeOf.number(name, test);
|
|
if (test > limit) {
|
|
throw new DeveloperError('Expected ' + name + ' to be less than or equal to ' + limit + ', actual value was ' + test);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'number' and greater than limit
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @param {Number} limit The limit value to compare against
|
|
* @exception {DeveloperError} test must be typeof 'number' and greater than limit
|
|
*/
|
|
Check.typeOf.number.greaterThan = function (name, test, limit) {
|
|
Check.typeOf.number(name, test);
|
|
if (test <= limit) {
|
|
throw new DeveloperError('Expected ' + name + ' to be greater than ' + limit + ', actual value was ' + test);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'number' and greater than or equal to limit
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @param {Number} limit The limit value to compare against
|
|
* @exception {DeveloperError} test must be typeof 'number' and greater than or equal to limit
|
|
*/
|
|
Check.typeOf.number.greaterThanOrEquals = function (name, test, limit) {
|
|
Check.typeOf.number(name, test);
|
|
if (test < limit) {
|
|
throw new DeveloperError('Expected ' + name + ' to be greater than or equal to' + limit + ', actual value was ' + test);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'object'
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @exception {DeveloperError} test must be typeof 'object'
|
|
*/
|
|
Check.typeOf.object = function (name, test) {
|
|
if (typeof test !== 'object') {
|
|
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'object', name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test is not typeof 'boolean'
|
|
*
|
|
* @param {String} name The name of the variable being tested
|
|
* @param {*} test The value to test
|
|
* @exception {DeveloperError} test must be typeof 'boolean'
|
|
*/
|
|
Check.typeOf.bool = function (name, test) {
|
|
if (typeof test !== 'boolean') {
|
|
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'boolean', name));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Throws if test1 and test2 is not typeof 'number' and not equal in value
|
|
*
|
|
* @param {String} name1 The name of the first variable being tested
|
|
* @param {String} name2 The name of the second variable being tested against
|
|
* @param {*} test1 The value to test
|
|
* @param {*} test2 The value to test against
|
|
* @exception {DeveloperError} test1 and test2 should be type of 'number' and be equal in value
|
|
*/
|
|
Check.typeOf.number.equals = function (name1, name2, test1, test2) {
|
|
Check.typeOf.number(name1, test1);
|
|
Check.typeOf.number(name2, test2);
|
|
if (test1 !== test2) {
|
|
throw new DeveloperError(name1 + ' must be equal to ' + name2 + ', the actual values are ' + test1 + ' and ' + test2);
|
|
}
|
|
};
|
|
|
|
return Check;
|
|
});
|
|
|
|
define('Core/RuntimeError',[
|
|
'./defined'
|
|
], function(
|
|
defined) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Constructs an exception object that is thrown due to an error that can occur at runtime, e.g.,
|
|
* out of memory, could not compile shader, etc. If a function may throw this
|
|
* exception, the calling code should be prepared to catch it.
|
|
* <br /><br />
|
|
* On the other hand, a {@link DeveloperError} indicates an exception due
|
|
* to a developer error, e.g., invalid argument, that usually indicates a bug in the
|
|
* calling code.
|
|
*
|
|
* @alias RuntimeError
|
|
* @constructor
|
|
* @extends Error
|
|
*
|
|
* @param {String} [message] The error message for this exception.
|
|
*
|
|
* @see DeveloperError
|
|
*/
|
|
function RuntimeError(message) {
|
|
/**
|
|
* 'RuntimeError' indicating that this exception was thrown due to a runtime error.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.name = 'RuntimeError';
|
|
|
|
/**
|
|
* The explanation for why this exception was thrown.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.message = message;
|
|
|
|
//Browsers such as IE don't have a stack property until you actually throw the error.
|
|
var stack;
|
|
try {
|
|
throw new Error();
|
|
} catch (e) {
|
|
stack = e.stack;
|
|
}
|
|
|
|
/**
|
|
* The stack trace of this exception, if available.
|
|
* @type {String}
|
|
* @readonly
|
|
*/
|
|
this.stack = stack;
|
|
}
|
|
|
|
if (defined(Object.create)) {
|
|
RuntimeError.prototype = Object.create(Error.prototype);
|
|
RuntimeError.prototype.constructor = RuntimeError;
|
|
}
|
|
|
|
RuntimeError.prototype.toString = function() {
|
|
var str = this.name + ': ' + this.message;
|
|
|
|
if (defined(this.stack)) {
|
|
str += '\n' + this.stack.toString();
|
|
}
|
|
|
|
return str;
|
|
};
|
|
|
|
return RuntimeError;
|
|
});
|
|
|
|
define('Core/decodeGoogleEarthEnterpriseData',[
|
|
'./Check',
|
|
'./RuntimeError'
|
|
], function(
|
|
Check,
|
|
RuntimeError) {
|
|
'use strict';
|
|
|
|
var compressedMagic = 0x7468dead;
|
|
var compressedMagicSwap = 0xadde6874;
|
|
|
|
/**
|
|
* Decodes data that is received from the Google Earth Enterprise server.
|
|
*
|
|
* @param {ArrayBuffer} key The key used during decoding.
|
|
* @param {ArrayBuffer} data The data to be decoded.
|
|
*
|
|
* @private
|
|
*/
|
|
function decodeGoogleEarthEnterpriseData(key, data) {
|
|
if (decodeGoogleEarthEnterpriseData.passThroughDataForTesting) {
|
|
return data;
|
|
}
|
|
|
|
Check.typeOf.object('key', key);
|
|
Check.typeOf.object('data', data);
|
|
|
|
var keyLength = key.byteLength;
|
|
if (keyLength === 0 || (keyLength % 4) !== 0) {
|
|
throw new RuntimeError('The length of key must be greater than 0 and a multiple of 4.');
|
|
}
|
|
|
|
var dataView = new DataView(data);
|
|
var magic = dataView.getUint32(0, true);
|
|
if (magic === compressedMagic || magic === compressedMagicSwap) {
|
|
// Occasionally packets don't come back encoded, so just return
|
|
return data;
|
|
}
|
|
|
|
var keyView = new DataView(key);
|
|
|
|
var dp = 0;
|
|
var dpend = data.byteLength;
|
|
var dpend64 = dpend - (dpend % 8);
|
|
var kpend = keyLength;
|
|
var kp;
|
|
var off = 8;
|
|
|
|
// This algorithm is intentionally asymmetric to make it more difficult to
|
|
// guess. Security through obscurity. :-(
|
|
|
|
// while we have a full uint64 (8 bytes) left to do
|
|
// assumes buffer is 64bit aligned (or processor doesn't care)
|
|
while (dp < dpend64) {
|
|
// rotate the key each time through by using the offets 16,0,8,16,0,8,...
|
|
off = (off + 8) % 24;
|
|
kp = off;
|
|
|
|
// run through one key length xor'ing one uint64 at a time
|
|
// then drop out to rotate the key for the next bit
|
|
while ((dp < dpend64) && (kp < kpend)) {
|
|
dataView.setUint32(dp, dataView.getUint32(dp, true) ^ keyView.getUint32(kp, true), true);
|
|
dataView.setUint32(dp + 4, dataView.getUint32(dp + 4, true) ^ keyView.getUint32(kp + 4, true), true);
|
|
dp += 8;
|
|
kp += 24;
|
|
}
|
|
}
|
|
|
|
// now the remaining 1 to 7 bytes
|
|
if (dp < dpend) {
|
|
if (kp >= kpend) {
|
|
// rotate the key one last time (if necessary)
|
|
off = (off + 8) % 24;
|
|
kp = off;
|
|
}
|
|
|
|
while (dp < dpend) {
|
|
dataView.setUint8(dp, dataView.getUint8(dp) ^ keyView.getUint8(kp));
|
|
dp++;
|
|
kp++;
|
|
}
|
|
}
|
|
}
|
|
|
|
decodeGoogleEarthEnterpriseData.passThroughDataForTesting = false;
|
|
|
|
return decodeGoogleEarthEnterpriseData;
|
|
});
|
|
|
|
define('Core/isBitSet',[], function() {
|
|
'use strict';
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
function isBitSet(bits, mask) {
|
|
return ((bits & mask) !== 0);
|
|
}
|
|
|
|
return isBitSet;
|
|
});
|
|
|
|
define('Core/GoogleEarthEnterpriseTileInformation',[
|
|
'./defined',
|
|
'./isBitSet'
|
|
], function(
|
|
defined,
|
|
isBitSet) {
|
|
'use strict';
|
|
|
|
// Bitmask for checking tile properties
|
|
var childrenBitmasks = [0x01, 0x02, 0x04, 0x08];
|
|
var anyChildBitmask = 0x0F;
|
|
var cacheFlagBitmask = 0x10; // True if there is a child subtree
|
|
var imageBitmask = 0x40;
|
|
var terrainBitmask = 0x80;
|
|
|
|
/**
|
|
* Contains information about each tile from a Google Earth Enterprise server
|
|
*
|
|
* @param {Number} bits Bitmask that contains the type of data and available children for each tile.
|
|
* @param {Number} cnodeVersion Version of the request for subtree metadata.
|
|
* @param {Number} imageryVersion Version of the request for imagery tile.
|
|
* @param {Number} terrainVersion Version of the request for terrain tile.
|
|
* @param {Number} imageryProvider Id of imagery provider.
|
|
* @param {Number} terrainProvider Id of terrain provider.
|
|
*
|
|
* @private
|
|
*/
|
|
function GoogleEarthEnterpriseTileInformation(bits, cnodeVersion, imageryVersion, terrainVersion, imageryProvider, terrainProvider) {
|
|
this._bits = bits;
|
|
this.cnodeVersion = cnodeVersion;
|
|
this.imageryVersion = imageryVersion;
|
|
this.terrainVersion = terrainVersion;
|
|
this.imageryProvider = imageryProvider;
|
|
this.terrainProvider = terrainProvider;
|
|
this.ancestorHasTerrain = false; // Set it later once we find its parent
|
|
this.terrainState = undefined;
|
|
}
|
|
|
|
/**
|
|
* Creates GoogleEarthEnterpriseTileInformation from an object
|
|
*
|
|
* @param {Object} info Object to be cloned
|
|
* @param {GoogleEarthEnterpriseTileInformation} [result] The object onto which to store the result.
|
|
* @returns {GoogleEarthEnterpriseTileInformation} The modified result parameter or a new GoogleEarthEnterpriseTileInformation instance if none was provided.
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.clone = function(info, result) {
|
|
if (!defined(result)) {
|
|
result = new GoogleEarthEnterpriseTileInformation(info._bits, info.cnodeVersion, info.imageryVersion, info.terrainVersion,
|
|
info.imageryProvider, info.terrainProvider);
|
|
} else {
|
|
result._bits = info._bits;
|
|
result.cnodeVersion = info.cnodeVersion;
|
|
result.imageryVersion = info.imageryVersion;
|
|
result.terrainVersion = info.terrainVersion;
|
|
result.imageryProvider = info.imageryProvider;
|
|
result.terrainProvider = info.terrainProvider;
|
|
}
|
|
result.ancestorHasTerrain = info.ancestorHasTerrain;
|
|
result.terrainState = info.terrainState;
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Sets the parent for the tile
|
|
*
|
|
* @param {GoogleEarthEnterpriseTileInformation} parent Parent tile
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.setParent = function(parent) {
|
|
this.ancestorHasTerrain = parent.ancestorHasTerrain || this.hasTerrain();
|
|
};
|
|
|
|
/**
|
|
* Gets whether a subtree is available
|
|
*
|
|
* @returns {Boolean} true if subtree is available, false otherwise.
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.hasSubtree = function() {
|
|
return isBitSet(this._bits, cacheFlagBitmask);
|
|
};
|
|
|
|
/**
|
|
* Gets whether imagery is available
|
|
*
|
|
* @returns {Boolean} true if imagery is available, false otherwise.
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.hasImagery = function() {
|
|
return isBitSet(this._bits, imageBitmask);
|
|
};
|
|
|
|
/**
|
|
* Gets whether terrain is available
|
|
*
|
|
* @returns {Boolean} true if terrain is available, false otherwise.
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.hasTerrain = function() {
|
|
return isBitSet(this._bits, terrainBitmask);
|
|
};
|
|
|
|
/**
|
|
* Gets whether any children are present
|
|
*
|
|
* @returns {Boolean} true if any children are available, false otherwise.
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.hasChildren = function() {
|
|
return isBitSet(this._bits, anyChildBitmask);
|
|
};
|
|
|
|
/**
|
|
* Gets whether a specified child is available
|
|
*
|
|
* @param {Number} index Index of child tile
|
|
*
|
|
* @returns {Boolean} true if child is available, false otherwise
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.hasChild = function(index) {
|
|
return isBitSet(this._bits, childrenBitmasks[index]);
|
|
};
|
|
|
|
/**
|
|
* Gets bitmask containing children
|
|
*
|
|
* @returns {Number} Children bitmask
|
|
*/
|
|
GoogleEarthEnterpriseTileInformation.prototype.getChildBitmask = function() {
|
|
return this._bits & anyChildBitmask;
|
|
};
|
|
|
|
return GoogleEarthEnterpriseTileInformation;
|
|
});
|
|
|
|
/* pako 1.0.4 nodeca/pako */(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define('ThirdParty/pako_inflate',[],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.pako = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
|
|
(typeof Uint16Array !== 'undefined') &&
|
|
(typeof Int32Array !== 'undefined');
|
|
|
|
|
|
exports.assign = function (obj /*from1, from2, from3, ...*/) {
|
|
var sources = Array.prototype.slice.call(arguments, 1);
|
|
while (sources.length) {
|
|
var source = sources.shift();
|
|
if (!source) { continue; }
|
|
|
|
if (typeof source !== 'object') {
|
|
throw new TypeError(source + 'must be non-object');
|
|
}
|
|
|
|
for (var p in source) {
|
|
if (source.hasOwnProperty(p)) {
|
|
obj[p] = source[p];
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
|
|
// reduce buffer size, avoiding mem copy
|
|
exports.shrinkBuf = function (buf, size) {
|
|
if (buf.length === size) { return buf; }
|
|
if (buf.subarray) { return buf.subarray(0, size); }
|
|
buf.length = size;
|
|
return buf;
|
|
};
|
|
|
|
|
|
var fnTyped = {
|
|
arraySet: function (dest, src, src_offs, len, dest_offs) {
|
|
if (src.subarray && dest.subarray) {
|
|
dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
|
|
return;
|
|
}
|
|
// Fallback to ordinary array
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
// Join array of chunks to single array.
|
|
flattenChunks: function (chunks) {
|
|
var i, l, len, pos, chunk, result;
|
|
|
|
// calculate data length
|
|
len = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
len += chunks[i].length;
|
|
}
|
|
|
|
// join chunks
|
|
result = new Uint8Array(len);
|
|
pos = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
chunk = chunks[i];
|
|
result.set(chunk, pos);
|
|
pos += chunk.length;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var fnUntyped = {
|
|
arraySet: function (dest, src, src_offs, len, dest_offs) {
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
// Join array of chunks to single array.
|
|
flattenChunks: function (chunks) {
|
|
return [].concat.apply([], chunks);
|
|
}
|
|
};
|
|
|
|
|
|
// Enable/Disable typed arrays use, for testing
|
|
//
|
|
exports.setTyped = function (on) {
|
|
if (on) {
|
|
exports.Buf8 = Uint8Array;
|
|
exports.Buf16 = Uint16Array;
|
|
exports.Buf32 = Int32Array;
|
|
exports.assign(exports, fnTyped);
|
|
} else {
|
|
exports.Buf8 = Array;
|
|
exports.Buf16 = Array;
|
|
exports.Buf32 = Array;
|
|
exports.assign(exports, fnUntyped);
|
|
}
|
|
};
|
|
|
|
exports.setTyped(TYPED_OK);
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
// String encode/decode helpers
|
|
'use strict';
|
|
|
|
|
|
var utils = require('./common');
|
|
|
|
|
|
// Quick check if we can use fast array to bin string conversion
|
|
//
|
|
// - apply(Array) can fail on Android 2.2
|
|
// - apply(Uint8Array) can fail on iOS 5.1 Safary
|
|
//
|
|
var STR_APPLY_OK = true;
|
|
var STR_APPLY_UIA_OK = true;
|
|
|
|
try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
|
|
try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
|
|
|
|
|
|
// Table with utf8 lengths (calculated by first byte of sequence)
|
|
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
|
|
// because max possible codepoint is 0x10ffff
|
|
var _utf8len = new utils.Buf8(256);
|
|
for (var q = 0; q < 256; q++) {
|
|
_utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
|
|
}
|
|
_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
|
|
|
|
|
|
// convert string to array (typed, when possible)
|
|
exports.string2buf = function (str) {
|
|
var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
|
|
|
|
// count binary size
|
|
for (m_pos = 0; m_pos < str_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 0xfc00) === 0xdc00) {
|
|
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
|
|
m_pos++;
|
|
}
|
|
}
|
|
buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
|
|
}
|
|
|
|
// allocate buffer
|
|
buf = new utils.Buf8(buf_len);
|
|
|
|
// convert
|
|
for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 0xfc00) === 0xdc00) {
|
|
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
|
|
m_pos++;
|
|
}
|
|
}
|
|
if (c < 0x80) {
|
|
/* one byte */
|
|
buf[i++] = c;
|
|
} else if (c < 0x800) {
|
|
/* two bytes */
|
|
buf[i++] = 0xC0 | (c >>> 6);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
} else if (c < 0x10000) {
|
|
/* three bytes */
|
|
buf[i++] = 0xE0 | (c >>> 12);
|
|
buf[i++] = 0x80 | (c >>> 6 & 0x3f);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
} else {
|
|
/* four bytes */
|
|
buf[i++] = 0xf0 | (c >>> 18);
|
|
buf[i++] = 0x80 | (c >>> 12 & 0x3f);
|
|
buf[i++] = 0x80 | (c >>> 6 & 0x3f);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
}
|
|
}
|
|
|
|
return buf;
|
|
};
|
|
|
|
// Helper (used in 2 places)
|
|
function buf2binstring(buf, len) {
|
|
// use fallback for big arrays to avoid stack overflow
|
|
if (len < 65537) {
|
|
if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
|
|
return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
|
|
}
|
|
}
|
|
|
|
var result = '';
|
|
for (var i = 0; i < len; i++) {
|
|
result += String.fromCharCode(buf[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Convert byte array to binary string
|
|
exports.buf2binstring = function (buf) {
|
|
return buf2binstring(buf, buf.length);
|
|
};
|
|
|
|
|
|
// Convert binary string (typed, when possible)
|
|
exports.binstring2buf = function (str) {
|
|
var buf = new utils.Buf8(str.length);
|
|
for (var i = 0, len = buf.length; i < len; i++) {
|
|
buf[i] = str.charCodeAt(i);
|
|
}
|
|
return buf;
|
|
};
|
|
|
|
|
|
// convert array to string
|
|
exports.buf2string = function (buf, max) {
|
|
var i, out, c, c_len;
|
|
var len = max || buf.length;
|
|
|
|
// Reserve max possible length (2 words per char)
|
|
// NB: by unknown reasons, Array is significantly faster for
|
|
// String.fromCharCode.apply than Uint16Array.
|
|
var utf16buf = new Array(len * 2);
|
|
|
|
for (out = 0, i = 0; i < len;) {
|
|
c = buf[i++];
|
|
// quick process ascii
|
|
if (c < 0x80) { utf16buf[out++] = c; continue; }
|
|
|
|
c_len = _utf8len[c];
|
|
// skip 5 & 6 byte codes
|
|
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
|
|
|
|
// apply mask on first byte
|
|
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
|
|
// join the rest
|
|
while (c_len > 1 && i < len) {
|
|
c = (c << 6) | (buf[i++] & 0x3f);
|
|
c_len--;
|
|
}
|
|
|
|
// terminated by end of string?
|
|
if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
|
|
|
|
if (c < 0x10000) {
|
|
utf16buf[out++] = c;
|
|
} else {
|
|
c -= 0x10000;
|
|
utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
|
|
utf16buf[out++] = 0xdc00 | (c & 0x3ff);
|
|
}
|
|
}
|
|
|
|
return buf2binstring(utf16buf, out);
|
|
};
|
|
|
|
|
|
// Calculate max possible position in utf8 buffer,
|
|
// that will not break sequence. If that's not possible
|
|
// - (very small limits) return max size as is.
|
|
//
|
|
// buf[] - utf8 bytes array
|
|
// max - length limit (mandatory);
|
|
exports.utf8border = function (buf, max) {
|
|
var pos;
|
|
|
|
max = max || buf.length;
|
|
if (max > buf.length) { max = buf.length; }
|
|
|
|
// go back from last position, until start of sequence found
|
|
pos = max - 1;
|
|
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
|
|
|
|
// Fuckup - very small and broken sequence,
|
|
// return max, because we should return something anyway.
|
|
if (pos < 0) { return max; }
|
|
|
|
// If we came to start of buffer - that means vuffer is too small,
|
|
// return max too.
|
|
if (pos === 0) { return max; }
|
|
|
|
return (pos + _utf8len[buf[pos]] > max) ? pos : max;
|
|
};
|
|
|
|
},{"./common":1}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// Note: adler32 takes 12% for level 0 and 2% for level 6.
|
|
// It doesn't worth to make additional optimizationa as in original.
|
|
// Small size is preferable.
|
|
|
|
function adler32(adler, buf, len, pos) {
|
|
var s1 = (adler & 0xffff) |0,
|
|
s2 = ((adler >>> 16) & 0xffff) |0,
|
|
n = 0;
|
|
|
|
while (len !== 0) {
|
|
// Set limit ~ twice less than 5552, to keep
|
|
// s2 in 31-bits, because we force signed ints.
|
|
// in other case %= will fail.
|
|
n = len > 2000 ? 2000 : len;
|
|
len -= n;
|
|
|
|
do {
|
|
s1 = (s1 + buf[pos++]) |0;
|
|
s2 = (s2 + s1) |0;
|
|
} while (--n);
|
|
|
|
s1 %= 65521;
|
|
s2 %= 65521;
|
|
}
|
|
|
|
return (s1 | (s2 << 16)) |0;
|
|
}
|
|
|
|
|
|
module.exports = adler32;
|
|
|
|
},{}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
module.exports = {
|
|
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
Z_NO_FLUSH: 0,
|
|
Z_PARTIAL_FLUSH: 1,
|
|
Z_SYNC_FLUSH: 2,
|
|
Z_FULL_FLUSH: 3,
|
|
Z_FINISH: 4,
|
|
Z_BLOCK: 5,
|
|
Z_TREES: 6,
|
|
|
|
/* Return codes for the compression/decompression functions. Negative values
|
|
* are errors, positive values are used for special but normal events.
|
|
*/
|
|
Z_OK: 0,
|
|
Z_STREAM_END: 1,
|
|
Z_NEED_DICT: 2,
|
|
Z_ERRNO: -1,
|
|
Z_STREAM_ERROR: -2,
|
|
Z_DATA_ERROR: -3,
|
|
//Z_MEM_ERROR: -4,
|
|
Z_BUF_ERROR: -5,
|
|
//Z_VERSION_ERROR: -6,
|
|
|
|
/* compression levels */
|
|
Z_NO_COMPRESSION: 0,
|
|
Z_BEST_SPEED: 1,
|
|
Z_BEST_COMPRESSION: 9,
|
|
Z_DEFAULT_COMPRESSION: -1,
|
|
|
|
|
|
Z_FILTERED: 1,
|
|
Z_HUFFMAN_ONLY: 2,
|
|
Z_RLE: 3,
|
|
Z_FIXED: 4,
|
|
Z_DEFAULT_STRATEGY: 0,
|
|
|
|
/* Possible values of the data_type field (though see inflate()) */
|
|
Z_BINARY: 0,
|
|
Z_TEXT: 1,
|
|
//Z_ASCII: 1, // = Z_TEXT (deprecated)
|
|
Z_UNKNOWN: 2,
|
|
|
|
/* The deflate compression method */
|
|
Z_DEFLATED: 8
|
|
//Z_NULL: null // Use -1 or null inline, depending on var type
|
|
};
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// Note: we can't get significant speed boost here.
|
|
// So write code to minimize size - no pregenerated tables
|
|
// and array tools dependencies.
|
|
|
|
|
|
// Use ordinary array, since untyped makes no boost here
|
|
function makeTable() {
|
|
var c, table = [];
|
|
|
|
for (var n = 0; n < 256; n++) {
|
|
c = n;
|
|
for (var k = 0; k < 8; k++) {
|
|
c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
|
|
}
|
|
table[n] = c;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
// Create table on load. Just 255 signed longs. Not a problem.
|
|
var crcTable = makeTable();
|
|
|
|
|
|
function crc32(crc, buf, len, pos) {
|
|
var t = crcTable,
|
|
end = pos + len;
|
|
|
|
crc ^= -1;
|
|
|
|
for (var i = pos; i < end; i++) {
|
|
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
|
|
}
|
|
|
|
return (crc ^ (-1)); // >>> 0;
|
|
}
|
|
|
|
|
|
module.exports = crc32;
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
function GZheader() {
|
|
/* true if compressed data believed to be text */
|
|
this.text = 0;
|
|
/* modification time */
|
|
this.time = 0;
|
|
/* extra flags (not used when writing a gzip file) */
|
|
this.xflags = 0;
|
|
/* operating system */
|
|
this.os = 0;
|
|
/* pointer to extra field or Z_NULL if none */
|
|
this.extra = null;
|
|
/* extra field length (valid if extra != Z_NULL) */
|
|
this.extra_len = 0; // Actually, we don't need it in JS,
|
|
// but leave for few code modifications
|
|
|
|
//
|
|
// Setup limits is not necessary because in js we should not preallocate memory
|
|
// for inflate use constant limit in 65536 bytes
|
|
//
|
|
|
|
/* space at extra (only when reading header) */
|
|
// this.extra_max = 0;
|
|
/* pointer to zero-terminated file name or Z_NULL */
|
|
this.name = '';
|
|
/* space at name (only when reading header) */
|
|
// this.name_max = 0;
|
|
/* pointer to zero-terminated comment or Z_NULL */
|
|
this.comment = '';
|
|
/* space at comment (only when reading header) */
|
|
// this.comm_max = 0;
|
|
/* true if there was or will be a header crc */
|
|
this.hcrc = 0;
|
|
/* true when done reading gzip header (not used when writing a gzip file) */
|
|
this.done = false;
|
|
}
|
|
|
|
module.exports = GZheader;
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// See state defs from inflate.js
|
|
var BAD = 30; /* got a data error -- remain here until reset */
|
|
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
|
|
|
|
/*
|
|
Decode literal, length, and distance codes and write out the resulting
|
|
literal and match bytes until either not enough input or output is
|
|
available, an end-of-block is encountered, or a data error is encountered.
|
|
When large enough input and output buffers are supplied to inflate(), for
|
|
example, a 16K input buffer and a 64K output buffer, more than 95% of the
|
|
inflate execution time is spent in this routine.
|
|
|
|
Entry assumptions:
|
|
|
|
state.mode === LEN
|
|
strm.avail_in >= 6
|
|
strm.avail_out >= 258
|
|
start >= strm.avail_out
|
|
state.bits < 8
|
|
|
|
On return, state.mode is one of:
|
|
|
|
LEN -- ran out of enough output space or enough available input
|
|
TYPE -- reached end of block code, inflate() to interpret next block
|
|
BAD -- error in block data
|
|
|
|
Notes:
|
|
|
|
- The maximum input bits used by a length/distance pair is 15 bits for the
|
|
length code, 5 bits for the length extra, 15 bits for the distance code,
|
|
and 13 bits for the distance extra. This totals 48 bits, or six bytes.
|
|
Therefore if strm.avail_in >= 6, then there is enough input to avoid
|
|
checking for available input while decoding.
|
|
|
|
- The maximum bytes that a single length/distance pair can output is 258
|
|
bytes, which is the maximum length that can be coded. inflate_fast()
|
|
requires strm.avail_out >= 258 for each loop to avoid checking for
|
|
output space.
|
|
*/
|
|
module.exports = function inflate_fast(strm, start) {
|
|
var state;
|
|
var _in; /* local strm.input */
|
|
var last; /* have enough input while in < last */
|
|
var _out; /* local strm.output */
|
|
var beg; /* inflate()'s initial strm.output */
|
|
var end; /* while out < end, enough space available */
|
|
//#ifdef INFLATE_STRICT
|
|
var dmax; /* maximum distance from zlib header */
|
|
//#endif
|
|
var wsize; /* window size or zero if not using window */
|
|
var whave; /* valid bytes in the window */
|
|
var wnext; /* window write index */
|
|
// Use `s_window` instead `window`, avoid conflict with instrumentation tools
|
|
var s_window; /* allocated sliding window, if wsize != 0 */
|
|
var hold; /* local strm.hold */
|
|
var bits; /* local strm.bits */
|
|
var lcode; /* local strm.lencode */
|
|
var dcode; /* local strm.distcode */
|
|
var lmask; /* mask for first level of length codes */
|
|
var dmask; /* mask for first level of distance codes */
|
|
var here; /* retrieved table entry */
|
|
var op; /* code bits, operation, extra bits, or */
|
|
/* window position, window bytes to copy */
|
|
var len; /* match length, unused bytes */
|
|
var dist; /* match distance */
|
|
var from; /* where to copy match from */
|
|
var from_source;
|
|
|
|
|
|
var input, output; // JS specific, because we have no pointers
|
|
|
|
/* copy state to local variables */
|
|
state = strm.state;
|
|
//here = state.here;
|
|
_in = strm.next_in;
|
|
input = strm.input;
|
|
last = _in + (strm.avail_in - 5);
|
|
_out = strm.next_out;
|
|
output = strm.output;
|
|
beg = _out - (start - strm.avail_out);
|
|
end = _out + (strm.avail_out - 257);
|
|
//#ifdef INFLATE_STRICT
|
|
dmax = state.dmax;
|
|
//#endif
|
|
wsize = state.wsize;
|
|
whave = state.whave;
|
|
wnext = state.wnext;
|
|
s_window = state.window;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
lcode = state.lencode;
|
|
dcode = state.distcode;
|
|
lmask = (1 << state.lenbits) - 1;
|
|
dmask = (1 << state.distbits) - 1;
|
|
|
|
|
|
/* decode literals and length/distances until end-of-block or not enough
|
|
input data or output space */
|
|
|
|
top:
|
|
do {
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
|
|
here = lcode[hold & lmask];
|
|
|
|
dolen:
|
|
for (;;) { // Goto emulation
|
|
op = here >>> 24/*here.bits*/;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = (here >>> 16) & 0xff/*here.op*/;
|
|
if (op === 0) { /* literal */
|
|
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
|
// "inflate: literal '%c'\n" :
|
|
// "inflate: literal 0x%02x\n", here.val));
|
|
output[_out++] = here & 0xffff/*here.val*/;
|
|
}
|
|
else if (op & 16) { /* length base */
|
|
len = here & 0xffff/*here.val*/;
|
|
op &= 15; /* number of extra bits */
|
|
if (op) {
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
len += hold & ((1 << op) - 1);
|
|
hold >>>= op;
|
|
bits -= op;
|
|
}
|
|
//Tracevv((stderr, "inflate: length %u\n", len));
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
here = dcode[hold & dmask];
|
|
|
|
dodist:
|
|
for (;;) { // goto emulation
|
|
op = here >>> 24/*here.bits*/;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = (here >>> 16) & 0xff/*here.op*/;
|
|
|
|
if (op & 16) { /* distance base */
|
|
dist = here & 0xffff/*here.val*/;
|
|
op &= 15; /* number of extra bits */
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
}
|
|
dist += hold & ((1 << op) - 1);
|
|
//#ifdef INFLATE_STRICT
|
|
if (dist > dmax) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
//#endif
|
|
hold >>>= op;
|
|
bits -= op;
|
|
//Tracevv((stderr, "inflate: distance %u\n", dist));
|
|
op = _out - beg; /* max distance in output */
|
|
if (dist > op) { /* see if copy from window */
|
|
op = dist - op; /* distance back in window */
|
|
if (op > whave) {
|
|
if (state.sane) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
// (!) This block is disabled in zlib defailts,
|
|
// don't enable it for binary compatibility
|
|
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
|
// if (len <= op - whave) {
|
|
// do {
|
|
// output[_out++] = 0;
|
|
// } while (--len);
|
|
// continue top;
|
|
// }
|
|
// len -= op - whave;
|
|
// do {
|
|
// output[_out++] = 0;
|
|
// } while (--op > whave);
|
|
// if (op === 0) {
|
|
// from = _out - dist;
|
|
// do {
|
|
// output[_out++] = output[from++];
|
|
// } while (--len);
|
|
// continue top;
|
|
// }
|
|
//#endif
|
|
}
|
|
from = 0; // window index
|
|
from_source = s_window;
|
|
if (wnext === 0) { /* very common case */
|
|
from += wsize - op;
|
|
if (op < len) { /* some from window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
else if (wnext < op) { /* wrap around window */
|
|
from += wsize + wnext - op;
|
|
op -= wnext;
|
|
if (op < len) { /* some from end of window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = 0;
|
|
if (wnext < len) { /* some from start of window */
|
|
op = wnext;
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
}
|
|
else { /* contiguous in window */
|
|
from += wnext - op;
|
|
if (op < len) { /* some from window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
while (len > 2) {
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
len -= 3;
|
|
}
|
|
if (len) {
|
|
output[_out++] = from_source[from++];
|
|
if (len > 1) {
|
|
output[_out++] = from_source[from++];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
from = _out - dist; /* copy direct from output */
|
|
do { /* minimum length is three */
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
len -= 3;
|
|
} while (len > 2);
|
|
if (len) {
|
|
output[_out++] = output[from++];
|
|
if (len > 1) {
|
|
output[_out++] = output[from++];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((op & 64) === 0) { /* 2nd level distance code */
|
|
here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
|
|
continue dodist;
|
|
}
|
|
else {
|
|
strm.msg = 'invalid distance code';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
break; // need to emulate goto via "continue"
|
|
}
|
|
}
|
|
else if ((op & 64) === 0) { /* 2nd level length code */
|
|
here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
|
|
continue dolen;
|
|
}
|
|
else if (op & 32) { /* end-of-block */
|
|
//Tracevv((stderr, "inflate: end of block\n"));
|
|
state.mode = TYPE;
|
|
break top;
|
|
}
|
|
else {
|
|
strm.msg = 'invalid literal/length code';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
break; // need to emulate goto via "continue"
|
|
}
|
|
} while (_in < last && _out < end);
|
|
|
|
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */
|
|
len = bits >> 3;
|
|
_in -= len;
|
|
bits -= len << 3;
|
|
hold &= (1 << bits) - 1;
|
|
|
|
/* update state and return */
|
|
strm.next_in = _in;
|
|
strm.next_out = _out;
|
|
strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
|
|
strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
return;
|
|
};
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var utils = require('../utils/common');
|
|
var adler32 = require('./adler32');
|
|
var crc32 = require('./crc32');
|
|
var inflate_fast = require('./inffast');
|
|
var inflate_table = require('./inftrees');
|
|
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
|
|
/* Public constants ==========================================================*/
|
|
/* ===========================================================================*/
|
|
|
|
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
//var Z_NO_FLUSH = 0;
|
|
//var Z_PARTIAL_FLUSH = 1;
|
|
//var Z_SYNC_FLUSH = 2;
|
|
//var Z_FULL_FLUSH = 3;
|
|
var Z_FINISH = 4;
|
|
var Z_BLOCK = 5;
|
|
var Z_TREES = 6;
|
|
|
|
|
|
/* Return codes for the compression/decompression functions. Negative values
|
|
* are errors, positive values are used for special but normal events.
|
|
*/
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_NEED_DICT = 2;
|
|
//var Z_ERRNO = -1;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_MEM_ERROR = -4;
|
|
var Z_BUF_ERROR = -5;
|
|
//var Z_VERSION_ERROR = -6;
|
|
|
|
/* The deflate compression method */
|
|
var Z_DEFLATED = 8;
|
|
|
|
|
|
/* STATES ====================================================================*/
|
|
/* ===========================================================================*/
|
|
|
|
|
|
var HEAD = 1; /* i: waiting for magic header */
|
|
var FLAGS = 2; /* i: waiting for method and flags (gzip) */
|
|
var TIME = 3; /* i: waiting for modification time (gzip) */
|
|
var OS = 4; /* i: waiting for extra flags and operating system (gzip) */
|
|
var EXLEN = 5; /* i: waiting for extra length (gzip) */
|
|
var EXTRA = 6; /* i: waiting for extra bytes (gzip) */
|
|
var NAME = 7; /* i: waiting for end of file name (gzip) */
|
|
var COMMENT = 8; /* i: waiting for end of comment (gzip) */
|
|
var HCRC = 9; /* i: waiting for header crc (gzip) */
|
|
var DICTID = 10; /* i: waiting for dictionary check value */
|
|
var DICT = 11; /* waiting for inflateSetDictionary() call */
|
|
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
|
|
var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */
|
|
var STORED = 14; /* i: waiting for stored size (length and complement) */
|
|
var COPY_ = 15; /* i/o: same as COPY below, but only first time in */
|
|
var COPY = 16; /* i/o: waiting for input or output to copy stored block */
|
|
var TABLE = 17; /* i: waiting for dynamic block table lengths */
|
|
var LENLENS = 18; /* i: waiting for code length code lengths */
|
|
var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */
|
|
var LEN_ = 20; /* i: same as LEN below, but only first time in */
|
|
var LEN = 21; /* i: waiting for length/lit/eob code */
|
|
var LENEXT = 22; /* i: waiting for length extra bits */
|
|
var DIST = 23; /* i: waiting for distance code */
|
|
var DISTEXT = 24; /* i: waiting for distance extra bits */
|
|
var MATCH = 25; /* o: waiting for output space to copy string */
|
|
var LIT = 26; /* o: waiting for output space to write literal */
|
|
var CHECK = 27; /* i: waiting for 32-bit check value */
|
|
var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */
|
|
var DONE = 29; /* finished check, done -- remain here until reset */
|
|
var BAD = 30; /* got a data error -- remain here until reset */
|
|
var MEM = 31; /* got an inflate() memory error -- remain here until reset */
|
|
var SYNC = 32; /* looking for synchronization bytes to restart inflate() */
|
|
|
|
/* ===========================================================================*/
|
|
|
|
|
|
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
|
|
|
var MAX_WBITS = 15;
|
|
/* 32K LZ77 window */
|
|
var DEF_WBITS = MAX_WBITS;
|
|
|
|
|
|
function zswap32(q) {
|
|
return (((q >>> 24) & 0xff) +
|
|
((q >>> 8) & 0xff00) +
|
|
((q & 0xff00) << 8) +
|
|
((q & 0xff) << 24));
|
|
}
|
|
|
|
|
|
function InflateState() {
|
|
this.mode = 0; /* current inflate mode */
|
|
this.last = false; /* true if processing last block */
|
|
this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
|
|
this.havedict = false; /* true if dictionary provided */
|
|
this.flags = 0; /* gzip header method and flags (0 if zlib) */
|
|
this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
|
|
this.check = 0; /* protected copy of check value */
|
|
this.total = 0; /* protected copy of output count */
|
|
// TODO: may be {}
|
|
this.head = null; /* where to save gzip header information */
|
|
|
|
/* sliding window */
|
|
this.wbits = 0; /* log base 2 of requested window size */
|
|
this.wsize = 0; /* window size or zero if not using window */
|
|
this.whave = 0; /* valid bytes in the window */
|
|
this.wnext = 0; /* window write index */
|
|
this.window = null; /* allocated sliding window, if needed */
|
|
|
|
/* bit accumulator */
|
|
this.hold = 0; /* input bit accumulator */
|
|
this.bits = 0; /* number of bits in "in" */
|
|
|
|
/* for string and stored block copying */
|
|
this.length = 0; /* literal or length of data to copy */
|
|
this.offset = 0; /* distance back to copy string from */
|
|
|
|
/* for table and code decoding */
|
|
this.extra = 0; /* extra bits needed */
|
|
|
|
/* fixed and dynamic code tables */
|
|
this.lencode = null; /* starting table for length/literal codes */
|
|
this.distcode = null; /* starting table for distance codes */
|
|
this.lenbits = 0; /* index bits for lencode */
|
|
this.distbits = 0; /* index bits for distcode */
|
|
|
|
/* dynamic table building */
|
|
this.ncode = 0; /* number of code length code lengths */
|
|
this.nlen = 0; /* number of length code lengths */
|
|
this.ndist = 0; /* number of distance code lengths */
|
|
this.have = 0; /* number of code lengths in lens[] */
|
|
this.next = null; /* next available space in codes[] */
|
|
|
|
this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
|
|
this.work = new utils.Buf16(288); /* work area for code table building */
|
|
|
|
/*
|
|
because we don't have pointers in js, we use lencode and distcode directly
|
|
as buffers so we don't need codes
|
|
*/
|
|
//this.codes = new utils.Buf32(ENOUGH); /* space for code tables */
|
|
this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */
|
|
this.distdyn = null; /* dynamic table for distance codes (JS specific) */
|
|
this.sane = 0; /* if false, allow invalid distance too far */
|
|
this.back = 0; /* bits back of last unprocessed length/lit */
|
|
this.was = 0; /* initial length of match */
|
|
}
|
|
|
|
function inflateResetKeep(strm) {
|
|
var state;
|
|
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
strm.total_in = strm.total_out = state.total = 0;
|
|
strm.msg = ''; /*Z_NULL*/
|
|
if (state.wrap) { /* to support ill-conceived Java test suite */
|
|
strm.adler = state.wrap & 1;
|
|
}
|
|
state.mode = HEAD;
|
|
state.last = 0;
|
|
state.havedict = 0;
|
|
state.dmax = 32768;
|
|
state.head = null/*Z_NULL*/;
|
|
state.hold = 0;
|
|
state.bits = 0;
|
|
//state.lencode = state.distcode = state.next = state.codes;
|
|
state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
|
|
state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
|
|
|
|
state.sane = 1;
|
|
state.back = -1;
|
|
//Tracev((stderr, "inflate: reset\n"));
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateReset(strm) {
|
|
var state;
|
|
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
state.wsize = 0;
|
|
state.whave = 0;
|
|
state.wnext = 0;
|
|
return inflateResetKeep(strm);
|
|
|
|
}
|
|
|
|
function inflateReset2(strm, windowBits) {
|
|
var wrap;
|
|
var state;
|
|
|
|
/* get the state */
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
|
|
/* extract wrap request from windowBits parameter */
|
|
if (windowBits < 0) {
|
|
wrap = 0;
|
|
windowBits = -windowBits;
|
|
}
|
|
else {
|
|
wrap = (windowBits >> 4) + 1;
|
|
if (windowBits < 48) {
|
|
windowBits &= 15;
|
|
}
|
|
}
|
|
|
|
/* set number of window bits, free window if different */
|
|
if (windowBits && (windowBits < 8 || windowBits > 15)) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (state.window !== null && state.wbits !== windowBits) {
|
|
state.window = null;
|
|
}
|
|
|
|
/* update state and reset the rest of it */
|
|
state.wrap = wrap;
|
|
state.wbits = windowBits;
|
|
return inflateReset(strm);
|
|
}
|
|
|
|
function inflateInit2(strm, windowBits) {
|
|
var ret;
|
|
var state;
|
|
|
|
if (!strm) { return Z_STREAM_ERROR; }
|
|
//strm.msg = Z_NULL; /* in case we return an error */
|
|
|
|
state = new InflateState();
|
|
|
|
//if (state === Z_NULL) return Z_MEM_ERROR;
|
|
//Tracev((stderr, "inflate: allocated\n"));
|
|
strm.state = state;
|
|
state.window = null/*Z_NULL*/;
|
|
ret = inflateReset2(strm, windowBits);
|
|
if (ret !== Z_OK) {
|
|
strm.state = null/*Z_NULL*/;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function inflateInit(strm) {
|
|
return inflateInit2(strm, DEF_WBITS);
|
|
}
|
|
|
|
|
|
/*
|
|
Return state with length and distance decoding tables and index sizes set to
|
|
fixed code decoding. Normally this returns fixed tables from inffixed.h.
|
|
If BUILDFIXED is defined, then instead this routine builds the tables the
|
|
first time it's called, and returns those tables the first time and
|
|
thereafter. This reduces the size of the code by about 2K bytes, in
|
|
exchange for a little execution time. However, BUILDFIXED should not be
|
|
used for threaded applications, since the rewriting of the tables and virgin
|
|
may not be thread-safe.
|
|
*/
|
|
var virgin = true;
|
|
|
|
var lenfix, distfix; // We have no pointers in JS, so keep tables separate
|
|
|
|
function fixedtables(state) {
|
|
/* build fixed huffman tables if first call (may not be thread safe) */
|
|
if (virgin) {
|
|
var sym;
|
|
|
|
lenfix = new utils.Buf32(512);
|
|
distfix = new utils.Buf32(32);
|
|
|
|
/* literal/length table */
|
|
sym = 0;
|
|
while (sym < 144) { state.lens[sym++] = 8; }
|
|
while (sym < 256) { state.lens[sym++] = 9; }
|
|
while (sym < 280) { state.lens[sym++] = 7; }
|
|
while (sym < 288) { state.lens[sym++] = 8; }
|
|
|
|
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
|
|
|
|
/* distance table */
|
|
sym = 0;
|
|
while (sym < 32) { state.lens[sym++] = 5; }
|
|
|
|
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
|
|
|
|
/* do this just once */
|
|
virgin = false;
|
|
}
|
|
|
|
state.lencode = lenfix;
|
|
state.lenbits = 9;
|
|
state.distcode = distfix;
|
|
state.distbits = 5;
|
|
}
|
|
|
|
|
|
/*
|
|
Update the window with the last wsize (normally 32K) bytes written before
|
|
returning. If window does not exist yet, create it. This is only called
|
|
when a window is already in use, or when output has been written during this
|
|
inflate call, but the end of the deflate stream has not been reached yet.
|
|
It is also called to create a window for dictionary data when a dictionary
|
|
is loaded.
|
|
|
|
Providing output buffers larger than 32K to inflate() should provide a speed
|
|
advantage, since only the last 32K of output is copied to the sliding window
|
|
upon return from inflate(), and since all distances after the first 32K of
|
|
output will fall in the output data, making match copies simpler and faster.
|
|
The advantage may be dependent on the size of the processor's data caches.
|
|
*/
|
|
function updatewindow(strm, src, end, copy) {
|
|
var dist;
|
|
var state = strm.state;
|
|
|
|
/* if it hasn't been done already, allocate space for the window */
|
|
if (state.window === null) {
|
|
state.wsize = 1 << state.wbits;
|
|
state.wnext = 0;
|
|
state.whave = 0;
|
|
|
|
state.window = new utils.Buf8(state.wsize);
|
|
}
|
|
|
|
/* copy state->wsize or less output bytes into the circular window */
|
|
if (copy >= state.wsize) {
|
|
utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
|
|
state.wnext = 0;
|
|
state.whave = state.wsize;
|
|
}
|
|
else {
|
|
dist = state.wsize - state.wnext;
|
|
if (dist > copy) {
|
|
dist = copy;
|
|
}
|
|
//zmemcpy(state->window + state->wnext, end - copy, dist);
|
|
utils.arraySet(state.window, src, end - copy, dist, state.wnext);
|
|
copy -= dist;
|
|
if (copy) {
|
|
//zmemcpy(state->window, end - copy, copy);
|
|
utils.arraySet(state.window, src, end - copy, copy, 0);
|
|
state.wnext = copy;
|
|
state.whave = state.wsize;
|
|
}
|
|
else {
|
|
state.wnext += dist;
|
|
if (state.wnext === state.wsize) { state.wnext = 0; }
|
|
if (state.whave < state.wsize) { state.whave += dist; }
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function inflate(strm, flush) {
|
|
var state;
|
|
var input, output; // input/output buffers
|
|
var next; /* next input INDEX */
|
|
var put; /* next output INDEX */
|
|
var have, left; /* available input and output */
|
|
var hold; /* bit buffer */
|
|
var bits; /* bits in bit buffer */
|
|
var _in, _out; /* save starting available input and output */
|
|
var copy; /* number of stored or match bytes to copy */
|
|
var from; /* where to copy match bytes from */
|
|
var from_source;
|
|
var here = 0; /* current decoding table entry */
|
|
var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
|
|
//var last; /* parent table entry */
|
|
var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
|
|
var len; /* length to copy for repeats, bits to drop */
|
|
var ret; /* return code */
|
|
var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */
|
|
var opts;
|
|
|
|
var n; // temporary var for NEED_BITS
|
|
|
|
var order = /* permutation of code lengths */
|
|
[ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
|
|
|
|
|
|
if (!strm || !strm.state || !strm.output ||
|
|
(!strm.input && strm.avail_in !== 0)) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
state = strm.state;
|
|
if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
|
|
|
|
|
|
//--- LOAD() ---
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
//---
|
|
|
|
_in = have;
|
|
_out = left;
|
|
ret = Z_OK;
|
|
|
|
inf_leave: // goto emulation
|
|
for (;;) {
|
|
switch (state.mode) {
|
|
case HEAD:
|
|
if (state.wrap === 0) {
|
|
state.mode = TYPEDO;
|
|
break;
|
|
}
|
|
//=== NEEDBITS(16);
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */
|
|
state.check = 0/*crc32(0L, Z_NULL, 0)*/;
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = FLAGS;
|
|
break;
|
|
}
|
|
state.flags = 0; /* expect zlib header */
|
|
if (state.head) {
|
|
state.head.done = false;
|
|
}
|
|
if (!(state.wrap & 1) || /* check if zlib header allowed */
|
|
(((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
|
|
strm.msg = 'incorrect header check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
|
|
strm.msg = 'unknown compression method';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//--- DROPBITS(4) ---//
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
//---//
|
|
len = (hold & 0x0f)/*BITS(4)*/ + 8;
|
|
if (state.wbits === 0) {
|
|
state.wbits = len;
|
|
}
|
|
else if (len > state.wbits) {
|
|
strm.msg = 'invalid window size';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.dmax = 1 << len;
|
|
//Tracev((stderr, "inflate: zlib header ok\n"));
|
|
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
|
|
state.mode = hold & 0x200 ? DICTID : TYPE;
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
break;
|
|
case FLAGS:
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.flags = hold;
|
|
if ((state.flags & 0xff) !== Z_DEFLATED) {
|
|
strm.msg = 'unknown compression method';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.flags & 0xe000) {
|
|
strm.msg = 'unknown header flags set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.head) {
|
|
state.head.text = ((hold >> 8) & 1);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = TIME;
|
|
/* falls through */
|
|
case TIME:
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (state.head) {
|
|
state.head.time = hold;
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC4(state.check, hold)
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
hbuf[2] = (hold >>> 16) & 0xff;
|
|
hbuf[3] = (hold >>> 24) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 4, 0);
|
|
//===
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = OS;
|
|
/* falls through */
|
|
case OS:
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (state.head) {
|
|
state.head.xflags = (hold & 0xff);
|
|
state.head.os = (hold >> 8);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = EXLEN;
|
|
/* falls through */
|
|
case EXLEN:
|
|
if (state.flags & 0x0400) {
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.length = hold;
|
|
if (state.head) {
|
|
state.head.extra_len = hold;
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
}
|
|
else if (state.head) {
|
|
state.head.extra = null/*Z_NULL*/;
|
|
}
|
|
state.mode = EXTRA;
|
|
/* falls through */
|
|
case EXTRA:
|
|
if (state.flags & 0x0400) {
|
|
copy = state.length;
|
|
if (copy > have) { copy = have; }
|
|
if (copy) {
|
|
if (state.head) {
|
|
len = state.head.extra_len - state.length;
|
|
if (!state.head.extra) {
|
|
// Use untyped array for more conveniend processing later
|
|
state.head.extra = new Array(state.head.extra_len);
|
|
}
|
|
utils.arraySet(
|
|
state.head.extra,
|
|
input,
|
|
next,
|
|
// extra field is limited to 65536 bytes
|
|
// - no need for additional size check
|
|
copy,
|
|
/*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
|
|
len
|
|
);
|
|
//zmemcpy(state.head.extra + len, next,
|
|
// len + copy > state.head.extra_max ?
|
|
// state.head.extra_max - len : copy);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
state.length -= copy;
|
|
}
|
|
if (state.length) { break inf_leave; }
|
|
}
|
|
state.length = 0;
|
|
state.mode = NAME;
|
|
/* falls through */
|
|
case NAME:
|
|
if (state.flags & 0x0800) {
|
|
if (have === 0) { break inf_leave; }
|
|
copy = 0;
|
|
do {
|
|
// TODO: 2 or 1 bytes?
|
|
len = input[next + copy++];
|
|
/* use constant limit because in js we should not preallocate memory */
|
|
if (state.head && len &&
|
|
(state.length < 65536 /*state.head.name_max*/)) {
|
|
state.head.name += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy < have);
|
|
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
if (len) { break inf_leave; }
|
|
}
|
|
else if (state.head) {
|
|
state.head.name = null;
|
|
}
|
|
state.length = 0;
|
|
state.mode = COMMENT;
|
|
/* falls through */
|
|
case COMMENT:
|
|
if (state.flags & 0x1000) {
|
|
if (have === 0) { break inf_leave; }
|
|
copy = 0;
|
|
do {
|
|
len = input[next + copy++];
|
|
/* use constant limit because in js we should not preallocate memory */
|
|
if (state.head && len &&
|
|
(state.length < 65536 /*state.head.comm_max*/)) {
|
|
state.head.comment += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy < have);
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
if (len) { break inf_leave; }
|
|
}
|
|
else if (state.head) {
|
|
state.head.comment = null;
|
|
}
|
|
state.mode = HCRC;
|
|
/* falls through */
|
|
case HCRC:
|
|
if (state.flags & 0x0200) {
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (hold !== (state.check & 0xffff)) {
|
|
strm.msg = 'header crc mismatch';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
}
|
|
if (state.head) {
|
|
state.head.hcrc = ((state.flags >> 9) & 1);
|
|
state.head.done = true;
|
|
}
|
|
strm.adler = state.check = 0;
|
|
state.mode = TYPE;
|
|
break;
|
|
case DICTID:
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
strm.adler = state.check = zswap32(hold);
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = DICT;
|
|
/* falls through */
|
|
case DICT:
|
|
if (state.havedict === 0) {
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
return Z_NEED_DICT;
|
|
}
|
|
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
|
|
state.mode = TYPE;
|
|
/* falls through */
|
|
case TYPE:
|
|
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case TYPEDO:
|
|
if (state.last) {
|
|
//--- BYTEBITS() ---//
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
//---//
|
|
state.mode = CHECK;
|
|
break;
|
|
}
|
|
//=== NEEDBITS(3); */
|
|
while (bits < 3) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.last = (hold & 0x01)/*BITS(1)*/;
|
|
//--- DROPBITS(1) ---//
|
|
hold >>>= 1;
|
|
bits -= 1;
|
|
//---//
|
|
|
|
switch ((hold & 0x03)/*BITS(2)*/) {
|
|
case 0: /* stored block */
|
|
//Tracev((stderr, "inflate: stored block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = STORED;
|
|
break;
|
|
case 1: /* fixed block */
|
|
fixedtables(state);
|
|
//Tracev((stderr, "inflate: fixed codes block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = LEN_; /* decode codes */
|
|
if (flush === Z_TREES) {
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
break inf_leave;
|
|
}
|
|
break;
|
|
case 2: /* dynamic block */
|
|
//Tracev((stderr, "inflate: dynamic codes block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = TABLE;
|
|
break;
|
|
case 3:
|
|
strm.msg = 'invalid block type';
|
|
state.mode = BAD;
|
|
}
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
break;
|
|
case STORED:
|
|
//--- BYTEBITS() ---// /* go to byte boundary */
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
//---//
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
|
|
strm.msg = 'invalid stored block lengths';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.length = hold & 0xffff;
|
|
//Tracev((stderr, "inflate: stored length %u\n",
|
|
// state.length));
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = COPY_;
|
|
if (flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case COPY_:
|
|
state.mode = COPY;
|
|
/* falls through */
|
|
case COPY:
|
|
copy = state.length;
|
|
if (copy) {
|
|
if (copy > have) { copy = have; }
|
|
if (copy > left) { copy = left; }
|
|
if (copy === 0) { break inf_leave; }
|
|
//--- zmemcpy(put, next, copy); ---
|
|
utils.arraySet(output, input, next, copy, put);
|
|
//---//
|
|
have -= copy;
|
|
next += copy;
|
|
left -= copy;
|
|
put += copy;
|
|
state.length -= copy;
|
|
break;
|
|
}
|
|
//Tracev((stderr, "inflate: stored end\n"));
|
|
state.mode = TYPE;
|
|
break;
|
|
case TABLE:
|
|
//=== NEEDBITS(14); */
|
|
while (bits < 14) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
|
|
//--- DROPBITS(5) ---//
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
//---//
|
|
state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
|
|
//--- DROPBITS(5) ---//
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
//---//
|
|
state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
|
|
//--- DROPBITS(4) ---//
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
//---//
|
|
//#ifndef PKZIP_BUG_WORKAROUND
|
|
if (state.nlen > 286 || state.ndist > 30) {
|
|
strm.msg = 'too many length or distance symbols';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//#endif
|
|
//Tracev((stderr, "inflate: table sizes ok\n"));
|
|
state.have = 0;
|
|
state.mode = LENLENS;
|
|
/* falls through */
|
|
case LENLENS:
|
|
while (state.have < state.ncode) {
|
|
//=== NEEDBITS(3);
|
|
while (bits < 3) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
|
|
//--- DROPBITS(3) ---//
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
//---//
|
|
}
|
|
while (state.have < 19) {
|
|
state.lens[order[state.have++]] = 0;
|
|
}
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
//state.next = state.codes;
|
|
//state.lencode = state.next;
|
|
// Switch to use dynamic table
|
|
state.lencode = state.lendyn;
|
|
state.lenbits = 7;
|
|
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
|
|
state.lenbits = opts.bits;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid code lengths set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//Tracev((stderr, "inflate: code lengths ok\n"));
|
|
state.have = 0;
|
|
state.mode = CODELENS;
|
|
/* falls through */
|
|
case CODELENS:
|
|
while (state.have < state.nlen + state.ndist) {
|
|
for (;;) {
|
|
here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if (here_val < 16) {
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.lens[state.have++] = here_val;
|
|
}
|
|
else {
|
|
if (here_val === 16) {
|
|
//=== NEEDBITS(here.bits + 2);
|
|
n = here_bits + 2;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
if (state.have === 0) {
|
|
strm.msg = 'invalid bit length repeat';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
len = state.lens[state.have - 1];
|
|
copy = 3 + (hold & 0x03);//BITS(2);
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
}
|
|
else if (here_val === 17) {
|
|
//=== NEEDBITS(here.bits + 3);
|
|
n = here_bits + 3;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
len = 0;
|
|
copy = 3 + (hold & 0x07);//BITS(3);
|
|
//--- DROPBITS(3) ---//
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
//---//
|
|
}
|
|
else {
|
|
//=== NEEDBITS(here.bits + 7);
|
|
n = here_bits + 7;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
len = 0;
|
|
copy = 11 + (hold & 0x7f);//BITS(7);
|
|
//--- DROPBITS(7) ---//
|
|
hold >>>= 7;
|
|
bits -= 7;
|
|
//---//
|
|
}
|
|
if (state.have + copy > state.nlen + state.ndist) {
|
|
strm.msg = 'invalid bit length repeat';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
while (copy--) {
|
|
state.lens[state.have++] = len;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* handle error breaks in while */
|
|
if (state.mode === BAD) { break; }
|
|
|
|
/* check for end-of-block code (better have one) */
|
|
if (state.lens[256] === 0) {
|
|
strm.msg = 'invalid code -- missing end-of-block';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
|
|
/* build code tables -- note: do not change the lenbits or distbits
|
|
values here (9 and 6) without reading the comments in inftrees.h
|
|
concerning the ENOUGH constants, which depend on those values */
|
|
state.lenbits = 9;
|
|
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
// state.next_index = opts.table_index;
|
|
state.lenbits = opts.bits;
|
|
// state.lencode = state.next;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid literal/lengths set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
|
|
state.distbits = 6;
|
|
//state.distcode.copy(state.codes);
|
|
// Switch to use dynamic table
|
|
state.distcode = state.distdyn;
|
|
opts = { bits: state.distbits };
|
|
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
// state.next_index = opts.table_index;
|
|
state.distbits = opts.bits;
|
|
// state.distcode = state.next;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid distances set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//Tracev((stderr, 'inflate: codes ok\n'));
|
|
state.mode = LEN_;
|
|
if (flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case LEN_:
|
|
state.mode = LEN;
|
|
/* falls through */
|
|
case LEN:
|
|
if (have >= 6 && left >= 258) {
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
inflate_fast(strm, _out);
|
|
//--- LOAD() ---
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
//---
|
|
|
|
if (state.mode === TYPE) {
|
|
state.back = -1;
|
|
}
|
|
break;
|
|
}
|
|
state.back = 0;
|
|
for (;;) {
|
|
here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if (here_bits <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if (here_op && (here_op & 0xf0) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (;;) {
|
|
here = state.lencode[last_val +
|
|
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((last_bits + here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
//--- DROPBITS(last.bits) ---//
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
//---//
|
|
state.back += last_bits;
|
|
}
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.back += here_bits;
|
|
state.length = here_val;
|
|
if (here_op === 0) {
|
|
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
|
// "inflate: literal '%c'\n" :
|
|
// "inflate: literal 0x%02x\n", here.val));
|
|
state.mode = LIT;
|
|
break;
|
|
}
|
|
if (here_op & 32) {
|
|
//Tracevv((stderr, "inflate: end of block\n"));
|
|
state.back = -1;
|
|
state.mode = TYPE;
|
|
break;
|
|
}
|
|
if (here_op & 64) {
|
|
strm.msg = 'invalid literal/length code';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.extra = here_op & 15;
|
|
state.mode = LENEXT;
|
|
/* falls through */
|
|
case LENEXT:
|
|
if (state.extra) {
|
|
//=== NEEDBITS(state.extra);
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
|
|
//--- DROPBITS(state.extra) ---//
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
//---//
|
|
state.back += state.extra;
|
|
}
|
|
//Tracevv((stderr, "inflate: length %u\n", state.length));
|
|
state.was = state.length;
|
|
state.mode = DIST;
|
|
/* falls through */
|
|
case DIST:
|
|
for (;;) {
|
|
here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if ((here_op & 0xf0) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (;;) {
|
|
here = state.distcode[last_val +
|
|
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((last_bits + here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
//--- DROPBITS(last.bits) ---//
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
//---//
|
|
state.back += last_bits;
|
|
}
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.back += here_bits;
|
|
if (here_op & 64) {
|
|
strm.msg = 'invalid distance code';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.offset = here_val;
|
|
state.extra = (here_op) & 15;
|
|
state.mode = DISTEXT;
|
|
/* falls through */
|
|
case DISTEXT:
|
|
if (state.extra) {
|
|
//=== NEEDBITS(state.extra);
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
|
|
//--- DROPBITS(state.extra) ---//
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
//---//
|
|
state.back += state.extra;
|
|
}
|
|
//#ifdef INFLATE_STRICT
|
|
if (state.offset > state.dmax) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//#endif
|
|
//Tracevv((stderr, "inflate: distance %u\n", state.offset));
|
|
state.mode = MATCH;
|
|
/* falls through */
|
|
case MATCH:
|
|
if (left === 0) { break inf_leave; }
|
|
copy = _out - left;
|
|
if (state.offset > copy) { /* copy from window */
|
|
copy = state.offset - copy;
|
|
if (copy > state.whave) {
|
|
if (state.sane) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
// (!) This block is disabled in zlib defailts,
|
|
// don't enable it for binary compatibility
|
|
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
|
// Trace((stderr, "inflate.c too far\n"));
|
|
// copy -= state.whave;
|
|
// if (copy > state.length) { copy = state.length; }
|
|
// if (copy > left) { copy = left; }
|
|
// left -= copy;
|
|
// state.length -= copy;
|
|
// do {
|
|
// output[put++] = 0;
|
|
// } while (--copy);
|
|
// if (state.length === 0) { state.mode = LEN; }
|
|
// break;
|
|
//#endif
|
|
}
|
|
if (copy > state.wnext) {
|
|
copy -= state.wnext;
|
|
from = state.wsize - copy;
|
|
}
|
|
else {
|
|
from = state.wnext - copy;
|
|
}
|
|
if (copy > state.length) { copy = state.length; }
|
|
from_source = state.window;
|
|
}
|
|
else { /* copy from output */
|
|
from_source = output;
|
|
from = put - state.offset;
|
|
copy = state.length;
|
|
}
|
|
if (copy > left) { copy = left; }
|
|
left -= copy;
|
|
state.length -= copy;
|
|
do {
|
|
output[put++] = from_source[from++];
|
|
} while (--copy);
|
|
if (state.length === 0) { state.mode = LEN; }
|
|
break;
|
|
case LIT:
|
|
if (left === 0) { break inf_leave; }
|
|
output[put++] = state.length;
|
|
left--;
|
|
state.mode = LEN;
|
|
break;
|
|
case CHECK:
|
|
if (state.wrap) {
|
|
//=== NEEDBITS(32);
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
// Use '|' insdead of '+' to make sure that result is signed
|
|
hold |= input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
_out -= left;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (_out) {
|
|
strm.adler = state.check =
|
|
/*UPDATE(state.check, put - _out, _out);*/
|
|
(state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
|
|
|
|
}
|
|
_out = left;
|
|
// NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
|
|
if ((state.flags ? hold : zswap32(hold)) !== state.check) {
|
|
strm.msg = 'incorrect data check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
//Tracev((stderr, "inflate: check matches trailer\n"));
|
|
}
|
|
state.mode = LENGTH;
|
|
/* falls through */
|
|
case LENGTH:
|
|
if (state.wrap && state.flags) {
|
|
//=== NEEDBITS(32);
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (hold !== (state.total & 0xffffffff)) {
|
|
strm.msg = 'incorrect length check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
//Tracev((stderr, "inflate: length matches trailer\n"));
|
|
}
|
|
state.mode = DONE;
|
|
/* falls through */
|
|
case DONE:
|
|
ret = Z_STREAM_END;
|
|
break inf_leave;
|
|
case BAD:
|
|
ret = Z_DATA_ERROR;
|
|
break inf_leave;
|
|
case MEM:
|
|
return Z_MEM_ERROR;
|
|
case SYNC:
|
|
/* falls through */
|
|
default:
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
}
|
|
|
|
// inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
|
|
|
|
/*
|
|
Return from inflate(), updating the total counts and the check value.
|
|
If there was no progress during the inflate() call, return a buffer
|
|
error. Call updatewindow() to create and/or update the window state.
|
|
Note: a memory error from inflate() is non-recoverable.
|
|
*/
|
|
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
|
|
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
|
|
(state.mode < CHECK || flush !== Z_FINISH))) {
|
|
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
}
|
|
_in -= strm.avail_in;
|
|
_out -= strm.avail_out;
|
|
strm.total_in += _in;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (state.wrap && _out) {
|
|
strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
|
|
(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
|
|
}
|
|
strm.data_type = state.bits + (state.last ? 64 : 0) +
|
|
(state.mode === TYPE ? 128 : 0) +
|
|
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
|
|
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
|
|
ret = Z_BUF_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function inflateEnd(strm) {
|
|
|
|
if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
var state = strm.state;
|
|
if (state.window) {
|
|
state.window = null;
|
|
}
|
|
strm.state = null;
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateGetHeader(strm, head) {
|
|
var state;
|
|
|
|
/* check state */
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
|
|
|
|
/* save header structure */
|
|
state.head = head;
|
|
head.done = false;
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateSetDictionary(strm, dictionary) {
|
|
var dictLength = dictionary.length;
|
|
|
|
var state;
|
|
var dictid;
|
|
var ret;
|
|
|
|
/* check state */
|
|
if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
|
|
if (state.wrap !== 0 && state.mode !== DICT) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
/* check for correct dictionary identifier */
|
|
if (state.mode === DICT) {
|
|
dictid = 1; /* adler32(0, null, 0)*/
|
|
/* dictid = adler32(dictid, dictionary, dictLength); */
|
|
dictid = adler32(dictid, dictionary, dictLength, 0);
|
|
if (dictid !== state.check) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
}
|
|
/* copy dictionary to window using updatewindow(), which will amend the
|
|
existing dictionary if appropriate */
|
|
ret = updatewindow(strm, dictionary, dictLength, dictLength);
|
|
if (ret) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
state.havedict = 1;
|
|
// Tracev((stderr, "inflate: dictionary set\n"));
|
|
return Z_OK;
|
|
}
|
|
|
|
exports.inflateReset = inflateReset;
|
|
exports.inflateReset2 = inflateReset2;
|
|
exports.inflateResetKeep = inflateResetKeep;
|
|
exports.inflateInit = inflateInit;
|
|
exports.inflateInit2 = inflateInit2;
|
|
exports.inflate = inflate;
|
|
exports.inflateEnd = inflateEnd;
|
|
exports.inflateGetHeader = inflateGetHeader;
|
|
exports.inflateSetDictionary = inflateSetDictionary;
|
|
exports.inflateInfo = 'pako inflate (from Nodeca project)';
|
|
|
|
/* Not implemented
|
|
exports.inflateCopy = inflateCopy;
|
|
exports.inflateGetDictionary = inflateGetDictionary;
|
|
exports.inflateMark = inflateMark;
|
|
exports.inflatePrime = inflatePrime;
|
|
exports.inflateSync = inflateSync;
|
|
exports.inflateSyncPoint = inflateSyncPoint;
|
|
exports.inflateUndermine = inflateUndermine;
|
|
*/
|
|
|
|
},{"../utils/common":1,"./adler32":3,"./crc32":5,"./inffast":7,"./inftrees":9}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var utils = require('../utils/common');
|
|
|
|
var MAXBITS = 15;
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
|
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
|
|
var lbase = [ /* Length codes 257..285 base */
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
|
|
];
|
|
|
|
var lext = [ /* Length codes 257..285 extra */
|
|
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
|
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
|
|
];
|
|
|
|
var dbase = [ /* Distance codes 0..29 base */
|
|
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
|
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
|
8193, 12289, 16385, 24577, 0, 0
|
|
];
|
|
|
|
var dext = [ /* Distance codes 0..29 extra */
|
|
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
|
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
|
28, 28, 29, 29, 64, 64
|
|
];
|
|
|
|
module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
|
|
{
|
|
var bits = opts.bits;
|
|
//here = opts.here; /* table entry for duplication */
|
|
|
|
var len = 0; /* a code's length in bits */
|
|
var sym = 0; /* index of code symbols */
|
|
var min = 0, max = 0; /* minimum and maximum code lengths */
|
|
var root = 0; /* number of index bits for root table */
|
|
var curr = 0; /* number of index bits for current table */
|
|
var drop = 0; /* code bits to drop for sub-table */
|
|
var left = 0; /* number of prefix codes available */
|
|
var used = 0; /* code entries in table used */
|
|
var huff = 0; /* Huffman code */
|
|
var incr; /* for incrementing code, index */
|
|
var fill; /* index for replicating entries */
|
|
var low; /* low bits for current root entry */
|
|
var mask; /* mask for low root bits */
|
|
var next; /* next available space in table */
|
|
var base = null; /* base value table to use */
|
|
var base_index = 0;
|
|
// var shoextra; /* extra bits table to use */
|
|
var end; /* use base and extra for symbol > end */
|
|
var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
|
|
var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
|
|
var extra = null;
|
|
var extra_index = 0;
|
|
|
|
var here_bits, here_op, here_val;
|
|
|
|
/*
|
|
Process a set of code lengths to create a canonical Huffman code. The
|
|
code lengths are lens[0..codes-1]. Each length corresponds to the
|
|
symbols 0..codes-1. The Huffman code is generated by first sorting the
|
|
symbols by length from short to long, and retaining the symbol order
|
|
for codes with equal lengths. Then the code starts with all zero bits
|
|
for the first code of the shortest length, and the codes are integer
|
|
increments for the same length, and zeros are appended as the length
|
|
increases. For the deflate format, these bits are stored backwards
|
|
from their more natural integer increment ordering, and so when the
|
|
decoding tables are built in the large loop below, the integer codes
|
|
are incremented backwards.
|
|
|
|
This routine assumes, but does not check, that all of the entries in
|
|
lens[] are in the range 0..MAXBITS. The caller must assure this.
|
|
1..MAXBITS is interpreted as that code length. zero means that that
|
|
symbol does not occur in this code.
|
|
|
|
The codes are sorted by computing a count of codes for each length,
|
|
creating from that a table of starting indices for each length in the
|
|
sorted table, and then entering the symbols in order in the sorted
|
|
table. The sorted table is work[], with that space being provided by
|
|
the caller.
|
|
|
|
The length counts are used for other purposes as well, i.e. finding
|
|
the minimum and maximum length codes, determining if there are any
|
|
codes at all, checking for a valid set of lengths, and looking ahead
|
|
at length counts to determine sub-table sizes when building the
|
|
decoding tables.
|
|
*/
|
|
|
|
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
|
|
for (len = 0; len <= MAXBITS; len++) {
|
|
count[len] = 0;
|
|
}
|
|
for (sym = 0; sym < codes; sym++) {
|
|
count[lens[lens_index + sym]]++;
|
|
}
|
|
|
|
/* bound code lengths, force root to be within code lengths */
|
|
root = bits;
|
|
for (max = MAXBITS; max >= 1; max--) {
|
|
if (count[max] !== 0) { break; }
|
|
}
|
|
if (root > max) {
|
|
root = max;
|
|
}
|
|
if (max === 0) { /* no symbols to code at all */
|
|
//table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
|
|
//table.bits[opts.table_index] = 1; //here.bits = (var char)1;
|
|
//table.val[opts.table_index++] = 0; //here.val = (var short)0;
|
|
table[table_index++] = (1 << 24) | (64 << 16) | 0;
|
|
|
|
|
|
//table.op[opts.table_index] = 64;
|
|
//table.bits[opts.table_index] = 1;
|
|
//table.val[opts.table_index++] = 0;
|
|
table[table_index++] = (1 << 24) | (64 << 16) | 0;
|
|
|
|
opts.bits = 1;
|
|
return 0; /* no symbols, but wait for decoding to report error */
|
|
}
|
|
for (min = 1; min < max; min++) {
|
|
if (count[min] !== 0) { break; }
|
|
}
|
|
if (root < min) {
|
|
root = min;
|
|
}
|
|
|
|
/* check for an over-subscribed or incomplete set of lengths */
|
|
left = 1;
|
|
for (len = 1; len <= MAXBITS; len++) {
|
|
left <<= 1;
|
|
left -= count[len];
|
|
if (left < 0) {
|
|
return -1;
|
|
} /* over-subscribed */
|
|
}
|
|
if (left > 0 && (type === CODES || max !== 1)) {
|
|
return -1; /* incomplete set */
|
|
}
|
|
|
|
/* generate offsets into symbol table for each length for sorting */
|
|
offs[1] = 0;
|
|
for (len = 1; len < MAXBITS; len++) {
|
|
offs[len + 1] = offs[len] + count[len];
|
|
}
|
|
|
|
/* sort symbols by length, by symbol order within each length */
|
|
for (sym = 0; sym < codes; sym++) {
|
|
if (lens[lens_index + sym] !== 0) {
|
|
work[offs[lens[lens_index + sym]]++] = sym;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Create and fill in decoding tables. In this loop, the table being
|
|
filled is at next and has curr index bits. The code being used is huff
|
|
with length len. That code is converted to an index by dropping drop
|
|
bits off of the bottom. For codes where len is less than drop + curr,
|
|
those top drop + curr - len bits are incremented through all values to
|
|
fill the table with replicated entries.
|
|
|
|
root is the number of index bits for the root table. When len exceeds
|
|
root, sub-tables are created pointed to by the root entry with an index
|
|
of the low root bits of huff. This is saved in low to check for when a
|
|
new sub-table should be started. drop is zero when the root table is
|
|
being filled, and drop is root when sub-tables are being filled.
|
|
|
|
When a new sub-table is needed, it is necessary to look ahead in the
|
|
code lengths to determine what size sub-table is needed. The length
|
|
counts are used for this, and so count[] is decremented as codes are
|
|
entered in the tables.
|
|
|
|
used keeps track of how many table entries have been allocated from the
|
|
provided *table space. It is checked for LENS and DIST tables against
|
|
the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
|
|
the initial root table size constants. See the comments in inftrees.h
|
|
for more information.
|
|
|
|
sym increments through all symbols, and the loop terminates when
|
|
all codes of length max, i.e. all codes, have been processed. This
|
|
routine permits incomplete codes, so another loop after this one fills
|
|
in the rest of the decoding tables with invalid code markers.
|
|
*/
|
|
|
|
/* set up for code type */
|
|
// poor man optimization - use if-else instead of switch,
|
|
// to avoid deopts in old v8
|
|
if (type === CODES) {
|
|
base = extra = work; /* dummy value--not used */
|
|
end = 19;
|
|
|
|
} else if (type === LENS) {
|
|
base = lbase;
|
|
base_index -= 257;
|
|
extra = lext;
|
|
extra_index -= 257;
|
|
end = 256;
|
|
|
|
} else { /* DISTS */
|
|
base = dbase;
|
|
extra = dext;
|
|
end = -1;
|
|
}
|
|
|
|
/* initialize opts for loop */
|
|
huff = 0; /* starting code */
|
|
sym = 0; /* starting code symbol */
|
|
len = min; /* starting code length */
|
|
next = table_index; /* current table to fill in */
|
|
curr = root; /* current table index bits */
|
|
drop = 0; /* current bits to drop from code for index */
|
|
low = -1; /* trigger new sub-table when len > root */
|
|
used = 1 << root; /* use root table entries */
|
|
mask = used - 1; /* mask for comparing low */
|
|
|
|
/* check available table space */
|
|
if ((type === LENS && used > ENOUGH_LENS) ||
|
|
(type === DISTS && used > ENOUGH_DISTS)) {
|
|
return 1;
|
|
}
|
|
|
|
/* process all codes and make table entries */
|
|
for (;;) {
|
|
/* create table entry */
|
|
here_bits = len - drop;
|
|
if (work[sym] < end) {
|
|
here_op = 0;
|
|
here_val = work[sym];
|
|
}
|
|
else if (work[sym] > end) {
|
|
here_op = extra[extra_index + work[sym]];
|
|
here_val = base[base_index + work[sym]];
|
|
}
|
|
else {
|
|
here_op = 32 + 64; /* end of block */
|
|
here_val = 0;
|
|
}
|
|
|
|
/* replicate for those indices with low len bits equal to huff */
|
|
incr = 1 << (len - drop);
|
|
fill = 1 << curr;
|
|
min = fill; /* save offset to next table */
|
|
do {
|
|
fill -= incr;
|
|
table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
|
|
} while (fill !== 0);
|
|
|
|
/* backwards increment the len-bit code huff */
|
|
incr = 1 << (len - 1);
|
|
while (huff & incr) {
|
|
incr >>= 1;
|
|
}
|
|
if (incr !== 0) {
|
|
huff &= incr - 1;
|
|
huff += incr;
|
|
} else {
|
|
huff = 0;
|
|
}
|
|
|
|
/* go to next symbol, update count, len */
|
|
sym++;
|
|
if (--count[len] === 0) {
|
|
if (len === max) { break; }
|
|
len = lens[lens_index + work[sym]];
|
|
}
|
|
|
|
/* create new sub-table if needed */
|
|
if (len > root && (huff & mask) !== low) {
|
|
/* if first time, transition to sub-tables */
|
|
if (drop === 0) {
|
|
drop = root;
|
|
}
|
|
|
|
/* increment past last table */
|
|
next += min; /* here min is 1 << curr */
|
|
|
|
/* determine length of next table */
|
|
curr = len - drop;
|
|
left = 1 << curr;
|
|
while (curr + drop < max) {
|
|
left -= count[curr + drop];
|
|
if (left <= 0) { break; }
|
|
curr++;
|
|
left <<= 1;
|
|
}
|
|
|
|
/* check for enough space */
|
|
used += 1 << curr;
|
|
if ((type === LENS && used > ENOUGH_LENS) ||
|
|
(type === DISTS && used > ENOUGH_DISTS)) {
|
|
return 1;
|
|
}
|
|
|
|
/* point entry in root table to sub-table */
|
|
low = huff & mask;
|
|
/*table.op[low] = curr;
|
|
table.bits[low] = root;
|
|
table.val[low] = next - opts.table_index;*/
|
|
table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
|
|
}
|
|
}
|
|
|
|
/* fill in remaining table entry if code is incomplete (guaranteed to have
|
|
at most one remaining entry, since if the code is incomplete, the
|
|
maximum code length that was allowed to get this far is one bit) */
|
|
if (huff !== 0) {
|
|
//table.op[next + huff] = 64; /* invalid code marker */
|
|
//table.bits[next + huff] = len - drop;
|
|
//table.val[next + huff] = 0;
|
|
table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
|
|
}
|
|
|
|
/* set return parameters */
|
|
//opts.table_index += used;
|
|
opts.bits = root;
|
|
return 0;
|
|
};
|
|
|
|
},{"../utils/common":1}],10:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = {
|
|
2: 'need dictionary', /* Z_NEED_DICT 2 */
|
|
1: 'stream end', /* Z_STREAM_END 1 */
|
|
0: '', /* Z_OK 0 */
|
|
'-1': 'file error', /* Z_ERRNO (-1) */
|
|
'-2': 'stream error', /* Z_STREAM_ERROR (-2) */
|
|
'-3': 'data error', /* Z_DATA_ERROR (-3) */
|
|
'-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */
|
|
'-5': 'buffer error', /* Z_BUF_ERROR (-5) */
|
|
'-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
|
|
};
|
|
|
|
},{}],11:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
function ZStream() {
|
|
/* next input byte */
|
|
this.input = null; // JS specific, because we have no pointers
|
|
this.next_in = 0;
|
|
/* number of bytes available at input */
|
|
this.avail_in = 0;
|
|
/* total number of input bytes read so far */
|
|
this.total_in = 0;
|
|
/* next output byte should be put there */
|
|
this.output = null; // JS specific, because we have no pointers
|
|
this.next_out = 0;
|
|
/* remaining free space at output */
|
|
this.avail_out = 0;
|
|
/* total number of bytes output so far */
|
|
this.total_out = 0;
|
|
/* last error message, NULL if no error */
|
|
this.msg = ''/*Z_NULL*/;
|
|
/* not visible by applications */
|
|
this.state = null;
|
|
/* best guess about the data type: binary or text */
|
|
this.data_type = 2/*Z_UNKNOWN*/;
|
|
/* adler32 value of the uncompressed data */
|
|
this.adler = 0;
|
|
}
|
|
|
|
module.exports = ZStream;
|
|
|
|
},{}],"/lib/inflate.js":[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var zlib_inflate = require('./zlib/inflate');
|
|
var utils = require('./utils/common');
|
|
var strings = require('./utils/strings');
|
|
var c = require('./zlib/constants');
|
|
var msg = require('./zlib/messages');
|
|
var ZStream = require('./zlib/zstream');
|
|
var GZheader = require('./zlib/gzheader');
|
|
|
|
var toString = Object.prototype.toString;
|
|
|
|
/**
|
|
* class Inflate
|
|
*
|
|
* Generic JS-style wrapper for zlib calls. If you don't need
|
|
* streaming behaviour - use more simple functions: [[inflate]]
|
|
* and [[inflateRaw]].
|
|
**/
|
|
|
|
/* internal
|
|
* inflate.chunks -> Array
|
|
*
|
|
* Chunks of output data, if [[Inflate#onData]] not overriden.
|
|
**/
|
|
|
|
/**
|
|
* Inflate.result -> Uint8Array|Array|String
|
|
*
|
|
* Uncompressed result, generated by default [[Inflate#onData]]
|
|
* and [[Inflate#onEnd]] handlers. Filled after you push last chunk
|
|
* (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
|
|
* push a chunk with explicit flush (call [[Inflate#push]] with
|
|
* `Z_SYNC_FLUSH` param).
|
|
**/
|
|
|
|
/**
|
|
* Inflate.err -> Number
|
|
*
|
|
* Error code after inflate finished. 0 (Z_OK) on success.
|
|
* Should be checked if broken data possible.
|
|
**/
|
|
|
|
/**
|
|
* Inflate.msg -> String
|
|
*
|
|
* Error message, if [[Inflate.err]] != 0
|
|
**/
|
|
|
|
|
|
/**
|
|
* new Inflate(options)
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Creates new inflator instance with specified params. Throws exception
|
|
* on bad params. Supported options:
|
|
*
|
|
* - `windowBits`
|
|
* - `dictionary`
|
|
*
|
|
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
|
* for more information on these.
|
|
*
|
|
* Additional options, for internal needs:
|
|
*
|
|
* - `chunkSize` - size of generated data chunks (16K by default)
|
|
* - `raw` (Boolean) - do raw inflate
|
|
* - `to` (String) - if equal to 'string', then result will be converted
|
|
* from utf8 to utf16 (javascript) string. When string output requested,
|
|
* chunk length can differ from `chunkSize`, depending on content.
|
|
*
|
|
* By default, when no options set, autodetect deflate/gzip data format via
|
|
* wrapper header.
|
|
*
|
|
* ##### Example:
|
|
*
|
|
* ```javascript
|
|
* var pako = require('pako')
|
|
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
|
|
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
|
|
*
|
|
* var inflate = new pako.Inflate({ level: 3});
|
|
*
|
|
* inflate.push(chunk1, false);
|
|
* inflate.push(chunk2, true); // true -> last chunk
|
|
*
|
|
* if (inflate.err) { throw new Error(inflate.err); }
|
|
*
|
|
* console.log(inflate.result);
|
|
* ```
|
|
**/
|
|
function Inflate(options) {
|
|
if (!(this instanceof Inflate)) return new Inflate(options);
|
|
|
|
this.options = utils.assign({
|
|
chunkSize: 16384,
|
|
windowBits: 0,
|
|
to: ''
|
|
}, options || {});
|
|
|
|
var opt = this.options;
|
|
|
|
// Force window size for `raw` data, if not set directly,
|
|
// because we have no header for autodetect.
|
|
if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
|
|
opt.windowBits = -opt.windowBits;
|
|
if (opt.windowBits === 0) { opt.windowBits = -15; }
|
|
}
|
|
|
|
// If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
|
|
if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
|
|
!(options && options.windowBits)) {
|
|
opt.windowBits += 32;
|
|
}
|
|
|
|
// Gzip header has no info about windows size, we can do autodetect only
|
|
// for deflate. So, if window size not set, force it to max when gzip possible
|
|
if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
|
|
// bit 3 (16) -> gzipped data
|
|
// bit 4 (32) -> autodetect gzip/deflate
|
|
if ((opt.windowBits & 15) === 0) {
|
|
opt.windowBits |= 15;
|
|
}
|
|
}
|
|
|
|
this.err = 0; // error code, if happens (0 = Z_OK)
|
|
this.msg = ''; // error message
|
|
this.ended = false; // used to avoid multiple onEnd() calls
|
|
this.chunks = []; // chunks of compressed data
|
|
|
|
this.strm = new ZStream();
|
|
this.strm.avail_out = 0;
|
|
|
|
var status = zlib_inflate.inflateInit2(
|
|
this.strm,
|
|
opt.windowBits
|
|
);
|
|
|
|
if (status !== c.Z_OK) {
|
|
throw new Error(msg[status]);
|
|
}
|
|
|
|
this.header = new GZheader();
|
|
|
|
zlib_inflate.inflateGetHeader(this.strm, this.header);
|
|
}
|
|
|
|
/**
|
|
* Inflate#push(data[, mode]) -> Boolean
|
|
* - data (Uint8Array|Array|ArrayBuffer|String): input data
|
|
* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
|
|
* See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
|
|
*
|
|
* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
|
|
* new output chunks. Returns `true` on success. The last data block must have
|
|
* mode Z_FINISH (or `true`). That will flush internal pending buffers and call
|
|
* [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
|
|
* can use mode Z_SYNC_FLUSH, keeping the decompression context.
|
|
*
|
|
* On fail call [[Inflate#onEnd]] with error code and return false.
|
|
*
|
|
* We strongly recommend to use `Uint8Array` on input for best speed (output
|
|
* format is detected automatically). Also, don't skip last param and always
|
|
* use the same type in your code (boolean or number). That will improve JS speed.
|
|
*
|
|
* For regular `Array`-s make sure all elements are [0..255].
|
|
*
|
|
* ##### Example
|
|
*
|
|
* ```javascript
|
|
* push(chunk, false); // push one of data chunks
|
|
* ...
|
|
* push(chunk, true); // push last chunk
|
|
* ```
|
|
**/
|
|
Inflate.prototype.push = function (data, mode) {
|
|
var strm = this.strm;
|
|
var chunkSize = this.options.chunkSize;
|
|
var dictionary = this.options.dictionary;
|
|
var status, _mode;
|
|
var next_out_utf8, tail, utf8str;
|
|
var dict;
|
|
|
|
// Flag to properly process Z_BUF_ERROR on testing inflate call
|
|
// when we check that all output data was flushed.
|
|
var allowBufError = false;
|
|
|
|
if (this.ended) { return false; }
|
|
_mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
|
|
|
|
// Convert data if needed
|
|
if (typeof data === 'string') {
|
|
// Only binary strings can be decompressed on practice
|
|
strm.input = strings.binstring2buf(data);
|
|
} else if (toString.call(data) === '[object ArrayBuffer]') {
|
|
strm.input = new Uint8Array(data);
|
|
} else {
|
|
strm.input = data;
|
|
}
|
|
|
|
strm.next_in = 0;
|
|
strm.avail_in = strm.input.length;
|
|
|
|
do {
|
|
if (strm.avail_out === 0) {
|
|
strm.output = new utils.Buf8(chunkSize);
|
|
strm.next_out = 0;
|
|
strm.avail_out = chunkSize;
|
|
}
|
|
|
|
status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */
|
|
|
|
if (status === c.Z_NEED_DICT && dictionary) {
|
|
// Convert data if needed
|
|
if (typeof dictionary === 'string') {
|
|
dict = strings.string2buf(dictionary);
|
|
} else if (toString.call(dictionary) === '[object ArrayBuffer]') {
|
|
dict = new Uint8Array(dictionary);
|
|
} else {
|
|
dict = dictionary;
|
|
}
|
|
|
|
status = zlib_inflate.inflateSetDictionary(this.strm, dict);
|
|
|
|
}
|
|
|
|
if (status === c.Z_BUF_ERROR && allowBufError === true) {
|
|
status = c.Z_OK;
|
|
allowBufError = false;
|
|
}
|
|
|
|
if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
|
|
this.onEnd(status);
|
|
this.ended = true;
|
|
return false;
|
|
}
|
|
|
|
if (strm.next_out) {
|
|
if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {
|
|
|
|
if (this.options.to === 'string') {
|
|
|
|
next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
|
|
|
|
tail = strm.next_out - next_out_utf8;
|
|
utf8str = strings.buf2string(strm.output, next_out_utf8);
|
|
|
|
// move tail
|
|
strm.next_out = tail;
|
|
strm.avail_out = chunkSize - tail;
|
|
if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
|
|
|
|
this.onData(utf8str);
|
|
|
|
} else {
|
|
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
|
|
}
|
|
}
|
|
}
|
|
|
|
// When no more input data, we should check that internal inflate buffers
|
|
// are flushed. The only way to do it when avail_out = 0 - run one more
|
|
// inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
|
|
// Here we set flag to process this error properly.
|
|
//
|
|
// NOTE. Deflate does not return error in this case and does not needs such
|
|
// logic.
|
|
if (strm.avail_in === 0 && strm.avail_out === 0) {
|
|
allowBufError = true;
|
|
}
|
|
|
|
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
|
|
|
|
if (status === c.Z_STREAM_END) {
|
|
_mode = c.Z_FINISH;
|
|
}
|
|
|
|
// Finalize on the last chunk.
|
|
if (_mode === c.Z_FINISH) {
|
|
status = zlib_inflate.inflateEnd(this.strm);
|
|
this.onEnd(status);
|
|
this.ended = true;
|
|
return status === c.Z_OK;
|
|
}
|
|
|
|
// callback interim results if Z_SYNC_FLUSH.
|
|
if (_mode === c.Z_SYNC_FLUSH) {
|
|
this.onEnd(c.Z_OK);
|
|
strm.avail_out = 0;
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* Inflate#onData(chunk) -> Void
|
|
* - chunk (Uint8Array|Array|String): ouput data. Type of array depends
|
|
* on js engine support. When string output requested, each chunk
|
|
* will be string.
|
|
*
|
|
* By default, stores data blocks in `chunks[]` property and glue
|
|
* those in `onEnd`. Override this handler, if you need another behaviour.
|
|
**/
|
|
Inflate.prototype.onData = function (chunk) {
|
|
this.chunks.push(chunk);
|
|
};
|
|
|
|
|
|
/**
|
|
* Inflate#onEnd(status) -> Void
|
|
* - status (Number): inflate status. 0 (Z_OK) on success,
|
|
* other if not.
|
|
*
|
|
* Called either after you tell inflate that the input stream is
|
|
* complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
|
|
* or if an error happened. By default - join collected chunks,
|
|
* free memory and fill `results` / `err` properties.
|
|
**/
|
|
Inflate.prototype.onEnd = function (status) {
|
|
// On success - join
|
|
if (status === c.Z_OK) {
|
|
if (this.options.to === 'string') {
|
|
// Glue & convert here, until we teach pako to send
|
|
// utf8 alligned strings to onData
|
|
this.result = this.chunks.join('');
|
|
} else {
|
|
this.result = utils.flattenChunks(this.chunks);
|
|
}
|
|
}
|
|
this.chunks = [];
|
|
this.err = status;
|
|
this.msg = this.strm.msg;
|
|
};
|
|
|
|
|
|
/**
|
|
* inflate(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Decompress `data` with inflate/ungzip and `options`. Autodetect
|
|
* format via wrapper header by default. That's why we don't provide
|
|
* separate `ungzip` method.
|
|
*
|
|
* Supported options are:
|
|
*
|
|
* - windowBits
|
|
*
|
|
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
|
* for more information.
|
|
*
|
|
* Sugar (options):
|
|
*
|
|
* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
|
|
* negative windowBits implicitly.
|
|
* - `to` (String) - if equal to 'string', then result will be converted
|
|
* from utf8 to utf16 (javascript) string. When string output requested,
|
|
* chunk length can differ from `chunkSize`, depending on content.
|
|
*
|
|
*
|
|
* ##### Example:
|
|
*
|
|
* ```javascript
|
|
* var pako = require('pako')
|
|
* , input = pako.deflate([1,2,3,4,5,6,7,8,9])
|
|
* , output;
|
|
*
|
|
* try {
|
|
* output = pako.inflate(input);
|
|
* } catch (err)
|
|
* console.log(err);
|
|
* }
|
|
* ```
|
|
**/
|
|
function inflate(input, options) {
|
|
var inflator = new Inflate(options);
|
|
|
|
inflator.push(input, true);
|
|
|
|
// That will never happens, if you don't cheat with options :)
|
|
if (inflator.err) { throw inflator.msg || msg[inflator.err]; }
|
|
|
|
return inflator.result;
|
|
}
|
|
|
|
|
|
/**
|
|
* inflateRaw(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* The same as [[inflate]], but creates raw data, without wrapper
|
|
* (header and adler32 crc).
|
|
**/
|
|
function inflateRaw(input, options) {
|
|
options = options || {};
|
|
options.raw = true;
|
|
return inflate(input, options);
|
|
}
|
|
|
|
|
|
/**
|
|
* ungzip(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Just shortcut to [[inflate]], because it autodetects format
|
|
* by header.content. Done for convenience.
|
|
**/
|
|
|
|
|
|
exports.Inflate = Inflate;
|
|
exports.inflate = inflate;
|
|
exports.inflateRaw = inflateRaw;
|
|
exports.ungzip = inflate;
|
|
|
|
},{"./utils/common":1,"./utils/strings":2,"./zlib/constants":4,"./zlib/gzheader":6,"./zlib/inflate":8,"./zlib/messages":10,"./zlib/zstream":11}]},{},[])("/lib/inflate.js")
|
|
});
|
|
|
|
/**
|
|
@license
|
|
when.js - https://github.com/cujojs/when
|
|
|
|
MIT License (c) copyright B Cavalier & J Hann
|
|
|
|
* A lightweight CommonJS Promises/A and when() implementation
|
|
* when is part of the cujo.js family of libraries (http://cujojs.com/)
|
|
*
|
|
* Licensed under the MIT License at:
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
*
|
|
* @version 1.7.1
|
|
*/
|
|
|
|
(function(define) { 'use strict';
|
|
define('ThirdParty/when',[],function () {
|
|
var reduceArray, slice, undef;
|
|
|
|
//
|
|
// Public API
|
|
//
|
|
|
|
when.defer = defer; // Create a deferred
|
|
when.resolve = resolve; // Create a resolved promise
|
|
when.reject = reject; // Create a rejected promise
|
|
|
|
when.join = join; // Join 2 or more promises
|
|
|
|
when.all = all; // Resolve a list of promises
|
|
when.map = map; // Array.map() for promises
|
|
when.reduce = reduce; // Array.reduce() for promises
|
|
|
|
when.any = any; // One-winner race
|
|
when.some = some; // Multi-winner race
|
|
|
|
when.chain = chain; // Make a promise trigger another resolver
|
|
|
|
when.isPromise = isPromise; // Determine if a thing is a promise
|
|
|
|
/**
|
|
* Register an observer for a promise or immediate value.
|
|
*
|
|
* @param {*} promiseOrValue
|
|
* @param {function?} [onFulfilled] callback to be called when promiseOrValue is
|
|
* successfully fulfilled. If promiseOrValue is an immediate value, callback
|
|
* will be invoked immediately.
|
|
* @param {function?} [onRejected] callback to be called when promiseOrValue is
|
|
* rejected.
|
|
* @param {function?} [onProgress] callback to be called when progress updates
|
|
* are issued for promiseOrValue.
|
|
* @returns {Promise} a new {@link Promise} that will complete with the return
|
|
* value of callback or errback or the completion value of promiseOrValue if
|
|
* callback and/or errback is not supplied.
|
|
*/
|
|
function when(promiseOrValue, onFulfilled, onRejected, onProgress) {
|
|
// Get a trusted promise for the input promiseOrValue, and then
|
|
// register promise handlers
|
|
return resolve(promiseOrValue).then(onFulfilled, onRejected, onProgress);
|
|
}
|
|
|
|
/**
|
|
* Returns promiseOrValue if promiseOrValue is a {@link Promise}, a new Promise if
|
|
* promiseOrValue is a foreign promise, or a new, already-fulfilled {@link Promise}
|
|
* whose value is promiseOrValue if promiseOrValue is an immediate value.
|
|
*
|
|
* @param {*} promiseOrValue
|
|
* @returns Guaranteed to return a trusted Promise. If promiseOrValue is a when.js {@link Promise}
|
|
* returns promiseOrValue, otherwise, returns a new, already-resolved, when.js {@link Promise}
|
|
* whose resolution value is:
|
|
* * the resolution value of promiseOrValue if it's a foreign promise, or
|
|
* * promiseOrValue if it's a value
|
|
*/
|
|
function resolve(promiseOrValue) {
|
|
var promise, deferred;
|
|
|
|
if(promiseOrValue instanceof Promise) {
|
|
// It's a when.js promise, so we trust it
|
|
promise = promiseOrValue;
|
|
|
|
} else {
|
|
// It's not a when.js promise. See if it's a foreign promise or a value.
|
|
if(isPromise(promiseOrValue)) {
|
|
// It's a thenable, but we don't know where it came from, so don't trust
|
|
// its implementation entirely. Introduce a trusted middleman when.js promise
|
|
deferred = defer();
|
|
|
|
// IMPORTANT: This is the only place when.js should ever call .then() on an
|
|
// untrusted promise. Don't expose the return value to the untrusted promise
|
|
promiseOrValue.then(
|
|
function(value) { deferred.resolve(value); },
|
|
function(reason) { deferred.reject(reason); },
|
|
function(update) { deferred.progress(update); }
|
|
);
|
|
|
|
promise = deferred.promise;
|
|
|
|
} else {
|
|
// It's a value, not a promise. Create a resolved promise for it.
|
|
promise = fulfilled(promiseOrValue);
|
|
}
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
/**
|
|
* Returns a rejected promise for the supplied promiseOrValue. The returned
|
|
* promise will be rejected with:
|
|
* - promiseOrValue, if it is a value, or
|
|
* - if promiseOrValue is a promise
|
|
* - promiseOrValue's value after it is fulfilled
|
|
* - promiseOrValue's reason after it is rejected
|
|
* @param {*} promiseOrValue the rejected value of the returned {@link Promise}
|
|
* @returns {Promise} rejected {@link Promise}
|
|
*/
|
|
function reject(promiseOrValue) {
|
|
return when(promiseOrValue, rejected);
|
|
}
|
|
|
|
/**
|
|
* Trusted Promise constructor. A Promise created from this constructor is
|
|
* a trusted when.js promise. Any other duck-typed promise is considered
|
|
* untrusted.
|
|
* @constructor
|
|
* @name Promise
|
|
*/
|
|
function Promise(then) {
|
|
this.then = then;
|
|
}
|
|
|
|
Promise.prototype = {
|
|
/**
|
|
* Register a callback that will be called when a promise is
|
|
* fulfilled or rejected. Optionally also register a progress handler.
|
|
* Shortcut for .then(onFulfilledOrRejected, onFulfilledOrRejected, onProgress)
|
|
* @param {function?} [onFulfilledOrRejected]
|
|
* @param {function?} [onProgress]
|
|
* @returns {Promise}
|
|
*/
|
|
always: function(onFulfilledOrRejected, onProgress) {
|
|
return this.then(onFulfilledOrRejected, onFulfilledOrRejected, onProgress);
|
|
},
|
|
|
|
/**
|
|
* Register a rejection handler. Shortcut for .then(undefined, onRejected)
|
|
* @param {function?} onRejected
|
|
* @returns {Promise}
|
|
*/
|
|
otherwise: function(onRejected) {
|
|
return this.then(undef, onRejected);
|
|
},
|
|
|
|
/**
|
|
* Shortcut for .then(function() { return value; })
|
|
* @param {*} value
|
|
* @returns {Promise} a promise that:
|
|
* - is fulfilled if value is not a promise, or
|
|
* - if value is a promise, will fulfill with its value, or reject
|
|
* with its reason.
|
|
*/
|
|
yield: function(value) {
|
|
return this.then(function() {
|
|
return value;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Assumes that this promise will fulfill with an array, and arranges
|
|
* for the onFulfilled to be called with the array as its argument list
|
|
* i.e. onFulfilled.spread(undefined, array).
|
|
* @param {function} onFulfilled function to receive spread arguments
|
|
* @returns {Promise}
|
|
*/
|
|
spread: function(onFulfilled) {
|
|
return this.then(function(array) {
|
|
// array may contain promises, so resolve its contents.
|
|
return all(array, function(array) {
|
|
return onFulfilled.apply(undef, array);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create an already-resolved promise for the supplied value
|
|
* @private
|
|
*
|
|
* @param {*} value
|
|
* @returns {Promise} fulfilled promise
|
|
*/
|
|
function fulfilled(value) {
|
|
var p = new Promise(function(onFulfilled) {
|
|
// TODO: Promises/A+ check typeof onFulfilled
|
|
try {
|
|
return resolve(onFulfilled ? onFulfilled(value) : value);
|
|
} catch(e) {
|
|
return rejected(e);
|
|
}
|
|
});
|
|
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Create an already-rejected {@link Promise} with the supplied
|
|
* rejection reason.
|
|
* @private
|
|
*
|
|
* @param {*} reason
|
|
* @returns {Promise} rejected promise
|
|
*/
|
|
function rejected(reason) {
|
|
var p = new Promise(function(_, onRejected) {
|
|
// TODO: Promises/A+ check typeof onRejected
|
|
try {
|
|
return onRejected ? resolve(onRejected(reason)) : rejected(reason);
|
|
} catch(e) {
|
|
return rejected(e);
|
|
}
|
|
});
|
|
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* Creates a new, Deferred with fully isolated resolver and promise parts,
|
|
* either or both of which may be given out safely to consumers.
|
|
* The Deferred itself has the full API: resolve, reject, progress, and
|
|
* then. The resolver has resolve, reject, and progress. The promise
|
|
* only has then.
|
|
*
|
|
* @returns {Deferred}
|
|
*/
|
|
function defer() {
|
|
var deferred, promise, handlers, progressHandlers,
|
|
_then, _progress, _resolve;
|
|
|
|
/**
|
|
* The promise for the new deferred
|
|
* @type {Promise}
|
|
*/
|
|
promise = new Promise(then);
|
|
|
|
/**
|
|
* The full Deferred object, with {@link Promise} and {@link Resolver} parts
|
|
* @class Deferred
|
|
* @name Deferred
|
|
*/
|
|
deferred = {
|
|
then: then, // DEPRECATED: use deferred.promise.then
|
|
resolve: promiseResolve,
|
|
reject: promiseReject,
|
|
// TODO: Consider renaming progress() to notify()
|
|
progress: promiseProgress,
|
|
|
|
promise: promise,
|
|
|
|
resolver: {
|
|
resolve: promiseResolve,
|
|
reject: promiseReject,
|
|
progress: promiseProgress
|
|
}
|
|
};
|
|
|
|
handlers = [];
|
|
progressHandlers = [];
|
|
|
|
/**
|
|
* Pre-resolution then() that adds the supplied callback, errback, and progback
|
|
* functions to the registered listeners
|
|
* @private
|
|
*
|
|
* @param {function?} [onFulfilled] resolution handler
|
|
* @param {function?} [onRejected] rejection handler
|
|
* @param {function?} [onProgress] progress handler
|
|
*/
|
|
_then = function(onFulfilled, onRejected, onProgress) {
|
|
// TODO: Promises/A+ check typeof onFulfilled, onRejected, onProgress
|
|
var deferred, progressHandler;
|
|
|
|
deferred = defer();
|
|
|
|
progressHandler = typeof onProgress === 'function'
|
|
? function(update) {
|
|
try {
|
|
// Allow progress handler to transform progress event
|
|
deferred.progress(onProgress(update));
|
|
} catch(e) {
|
|
// Use caught value as progress
|
|
deferred.progress(e);
|
|
}
|
|
}
|
|
: function(update) { deferred.progress(update); };
|
|
|
|
handlers.push(function(promise) {
|
|
promise.then(onFulfilled, onRejected)
|
|
.then(deferred.resolve, deferred.reject, progressHandler);
|
|
});
|
|
|
|
progressHandlers.push(progressHandler);
|
|
|
|
return deferred.promise;
|
|
};
|
|
|
|
/**
|
|
* Issue a progress event, notifying all progress listeners
|
|
* @private
|
|
* @param {*} update progress event payload to pass to all listeners
|
|
*/
|
|
_progress = function(update) {
|
|
processQueue(progressHandlers, update);
|
|
return update;
|
|
};
|
|
|
|
/**
|
|
* Transition from pre-resolution state to post-resolution state, notifying
|
|
* all listeners of the resolution or rejection
|
|
* @private
|
|
* @param {*} value the value of this deferred
|
|
*/
|
|
_resolve = function(value) {
|
|
value = resolve(value);
|
|
|
|
// Replace _then with one that directly notifies with the result.
|
|
_then = value.then;
|
|
// Replace _resolve so that this Deferred can only be resolved once
|
|
_resolve = resolve;
|
|
// Make _progress a noop, to disallow progress for the resolved promise.
|
|
_progress = noop;
|
|
|
|
// Notify handlers
|
|
processQueue(handlers, value);
|
|
|
|
// Free progressHandlers array since we'll never issue progress events
|
|
progressHandlers = handlers = undef;
|
|
|
|
return value;
|
|
};
|
|
|
|
return deferred;
|
|
|
|
/**
|
|
* Wrapper to allow _then to be replaced safely
|
|
* @param {function?} [onFulfilled] resolution handler
|
|
* @param {function?} [onRejected] rejection handler
|
|
* @param {function?} [onProgress] progress handler
|
|
* @returns {Promise} new promise
|
|
*/
|
|
function then(onFulfilled, onRejected, onProgress) {
|
|
// TODO: Promises/A+ check typeof onFulfilled, onRejected, onProgress
|
|
return _then(onFulfilled, onRejected, onProgress);
|
|
}
|
|
|
|
/**
|
|
* Wrapper to allow _resolve to be replaced
|
|
*/
|
|
function promiseResolve(val) {
|
|
return _resolve(val);
|
|
}
|
|
|
|
/**
|
|
* Wrapper to allow _reject to be replaced
|
|
*/
|
|
function promiseReject(err) {
|
|
return _resolve(rejected(err));
|
|
}
|
|
|
|
/**
|
|
* Wrapper to allow _progress to be replaced
|
|
*/
|
|
function promiseProgress(update) {
|
|
return _progress(update);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if promiseOrValue is a promise or not. Uses the feature
|
|
* test from http://wiki.commonjs.org/wiki/Promises/A to determine if
|
|
* promiseOrValue is a promise.
|
|
*
|
|
* @param {*} promiseOrValue anything
|
|
* @returns {boolean} true if promiseOrValue is a {@link Promise}
|
|
*/
|
|
function isPromise(promiseOrValue) {
|
|
return promiseOrValue && typeof promiseOrValue.then === 'function';
|
|
}
|
|
|
|
/**
|
|
* Initiates a competitive race, returning a promise that will resolve when
|
|
* howMany of the supplied promisesOrValues have resolved, or will reject when
|
|
* it becomes impossible for howMany to resolve, for example, when
|
|
* (promisesOrValues.length - howMany) + 1 input promises reject.
|
|
*
|
|
* @param {Array} promisesOrValues array of anything, may contain a mix
|
|
* of promises and values
|
|
* @param howMany {number} number of promisesOrValues to resolve
|
|
* @param {function?} [onFulfilled] resolution handler
|
|
* @param {function?} [onRejected] rejection handler
|
|
* @param {function?} [onProgress] progress handler
|
|
* @returns {Promise} promise that will resolve to an array of howMany values that
|
|
* resolved first, or will reject with an array of (promisesOrValues.length - howMany) + 1
|
|
* rejection reasons.
|
|
*/
|
|
function some(promisesOrValues, howMany, onFulfilled, onRejected, onProgress) {
|
|
|
|
checkCallbacks(2, arguments);
|
|
|
|
return when(promisesOrValues, function(promisesOrValues) {
|
|
|
|
var toResolve, toReject, values, reasons, deferred, fulfillOne, rejectOne, progress, len, i;
|
|
|
|
len = promisesOrValues.length >>> 0;
|
|
|
|
toResolve = Math.max(0, Math.min(howMany, len));
|
|
values = [];
|
|
|
|
toReject = (len - toResolve) + 1;
|
|
reasons = [];
|
|
|
|
deferred = defer();
|
|
|
|
// No items in the input, resolve immediately
|
|
if (!toResolve) {
|
|
deferred.resolve(values);
|
|
|
|
} else {
|
|
progress = deferred.progress;
|
|
|
|
rejectOne = function(reason) {
|
|
reasons.push(reason);
|
|
if(!--toReject) {
|
|
fulfillOne = rejectOne = noop;
|
|
deferred.reject(reasons);
|
|
}
|
|
};
|
|
|
|
fulfillOne = function(val) {
|
|
// This orders the values based on promise resolution order
|
|
// Another strategy would be to use the original position of
|
|
// the corresponding promise.
|
|
values.push(val);
|
|
|
|
if (!--toResolve) {
|
|
fulfillOne = rejectOne = noop;
|
|
deferred.resolve(values);
|
|
}
|
|
};
|
|
|
|
for(i = 0; i < len; ++i) {
|
|
if(i in promisesOrValues) {
|
|
when(promisesOrValues[i], fulfiller, rejecter, progress);
|
|
}
|
|
}
|
|
}
|
|
|
|
return deferred.then(onFulfilled, onRejected, onProgress);
|
|
|
|
function rejecter(reason) {
|
|
rejectOne(reason);
|
|
}
|
|
|
|
function fulfiller(val) {
|
|
fulfillOne(val);
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initiates a competitive race, returning a promise that will resolve when
|
|
* any one of the supplied promisesOrValues has resolved or will reject when
|
|
* *all* promisesOrValues have rejected.
|
|
*
|
|
* @param {Array|Promise} promisesOrValues array of anything, may contain a mix
|
|
* of {@link Promise}s and values
|
|
* @param {function?} [onFulfilled] resolution handler
|
|
* @param {function?} [onRejected] rejection handler
|
|
* @param {function?} [onProgress] progress handler
|
|
* @returns {Promise} promise that will resolve to the value that resolved first, or
|
|
* will reject with an array of all rejected inputs.
|
|
*/
|
|
function any(promisesOrValues, onFulfilled, onRejected, onProgress) {
|
|
|
|
function unwrapSingleResult(val) {
|
|
return onFulfilled ? onFulfilled(val[0]) : val[0];
|
|
}
|
|
|
|
return some(promisesOrValues, 1, unwrapSingleResult, onRejected, onProgress);
|
|
}
|
|
|
|
/**
|
|
* Return a promise that will resolve only once all the supplied promisesOrValues
|
|
* have resolved. The resolution value of the returned promise will be an array
|
|
* containing the resolution values of each of the promisesOrValues.
|
|
* @memberOf when
|
|
*
|
|
* @param {Array|Promise} promisesOrValues array of anything, may contain a mix
|
|
* of {@link Promise}s and values
|
|
* @param {function?} [onFulfilled] resolution handler
|
|
* @param {function?} [onRejected] rejection handler
|
|
* @param {function?} [onProgress] progress handler
|
|
* @returns {Promise}
|
|
*/
|
|
function all(promisesOrValues, onFulfilled, onRejected, onProgress) {
|
|
checkCallbacks(1, arguments);
|
|
return map(promisesOrValues, identity).then(onFulfilled, onRejected, onProgress);
|
|
}
|
|
|
|
/**
|
|
* Joins multiple promises into a single returned promise.
|
|
* @returns {Promise} a promise that will fulfill when *all* the input promises
|
|
* have fulfilled, or will reject when *any one* of the input promises rejects.
|
|
*/
|
|
function join(/* ...promises */) {
|
|
return map(arguments, identity);
|
|
}
|
|
|
|
/**
|
|
* Traditional map function, similar to `Array.prototype.map()`, but allows
|
|
* input to contain {@link Promise}s and/or values, and mapFunc may return
|
|
* either a value or a {@link Promise}
|
|
*
|
|
* @param {Array|Promise} promise array of anything, may contain a mix
|
|
* of {@link Promise}s and values
|
|
* @param {function} mapFunc mapping function mapFunc(value) which may return
|
|
* either a {@link Promise} or value
|
|
* @returns {Promise} a {@link Promise} that will resolve to an array containing
|
|
* the mapped output values.
|
|
*/
|
|
function map(promise, mapFunc) {
|
|
return when(promise, function(array) {
|
|
var results, len, toResolve, resolve, i, d;
|
|
|
|
// Since we know the resulting length, we can preallocate the results
|
|
// array to avoid array expansions.
|
|
toResolve = len = array.length >>> 0;
|
|
results = [];
|
|
d = defer();
|
|
|
|
if(!toResolve) {
|
|
d.resolve(results);
|
|
} else {
|
|
|
|
resolve = function resolveOne(item, i) {
|
|
when(item, mapFunc).then(function(mapped) {
|
|
results[i] = mapped;
|
|
|
|
if(!--toResolve) {
|
|
d.resolve(results);
|
|
}
|
|
}, d.reject);
|
|
};
|
|
|
|
// Since mapFunc may be async, get all invocations of it into flight
|
|
for(i = 0; i < len; i++) {
|
|
if(i in array) {
|
|
resolve(array[i], i);
|
|
} else {
|
|
--toResolve;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return d.promise;
|
|
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Traditional reduce function, similar to `Array.prototype.reduce()`, but
|
|
* input may contain promises and/or values, and reduceFunc
|
|
* may return either a value or a promise, *and* initialValue may
|
|
* be a promise for the starting value.
|
|
*
|
|
* @param {Array|Promise} promise array or promise for an array of anything,
|
|
* may contain a mix of promises and values.
|
|
* @param {function} reduceFunc reduce function reduce(currentValue, nextValue, index, total),
|
|
* where total is the total number of items being reduced, and will be the same
|
|
* in each call to reduceFunc.
|
|
* @returns {Promise} that will resolve to the final reduced value
|
|
*/
|
|
function reduce(promise, reduceFunc /*, initialValue */) {
|
|
var args = slice.call(arguments, 1);
|
|
|
|
return when(promise, function(array) {
|
|
var total;
|
|
|
|
total = array.length;
|
|
|
|
// Wrap the supplied reduceFunc with one that handles promises and then
|
|
// delegates to the supplied.
|
|
args[0] = function (current, val, i) {
|
|
return when(current, function (c) {
|
|
return when(val, function (value) {
|
|
return reduceFunc(c, value, i, total);
|
|
});
|
|
});
|
|
};
|
|
|
|
return reduceArray.apply(array, args);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Ensure that resolution of promiseOrValue will trigger resolver with the
|
|
* value or reason of promiseOrValue, or instead with resolveValue if it is provided.
|
|
*
|
|
* @param promiseOrValue
|
|
* @param {Object} resolver
|
|
* @param {function} resolver.resolve
|
|
* @param {function} resolver.reject
|
|
* @param {*} [resolveValue]
|
|
* @returns {Promise}
|
|
*/
|
|
function chain(promiseOrValue, resolver, resolveValue) {
|
|
var useResolveValue = arguments.length > 2;
|
|
|
|
return when(promiseOrValue,
|
|
function(val) {
|
|
val = useResolveValue ? resolveValue : val;
|
|
resolver.resolve(val);
|
|
return val;
|
|
},
|
|
function(reason) {
|
|
resolver.reject(reason);
|
|
return rejected(reason);
|
|
},
|
|
resolver.progress
|
|
);
|
|
}
|
|
|
|
//
|
|
// Utility functions
|
|
//
|
|
|
|
/**
|
|
* Apply all functions in queue to value
|
|
* @param {Array} queue array of functions to execute
|
|
* @param {*} value argument passed to each function
|
|
*/
|
|
function processQueue(queue, value) {
|
|
var handler, i = 0;
|
|
|
|
while (handler = queue[i++]) {
|
|
handler(value);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper that checks arrayOfCallbacks to ensure that each element is either
|
|
* a function, or null or undefined.
|
|
* @private
|
|
* @param {number} start index at which to start checking items in arrayOfCallbacks
|
|
* @param {Array} arrayOfCallbacks array to check
|
|
* @throws {Error} if any element of arrayOfCallbacks is something other than
|
|
* a functions, null, or undefined.
|
|
*/
|
|
function checkCallbacks(start, arrayOfCallbacks) {
|
|
// TODO: Promises/A+ update type checking and docs
|
|
var arg, i = arrayOfCallbacks.length;
|
|
|
|
while(i > start) {
|
|
arg = arrayOfCallbacks[--i];
|
|
|
|
if (arg != null && typeof arg != 'function') {
|
|
throw new Error('arg '+i+' must be a function');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* No-Op function used in method replacement
|
|
* @private
|
|
*/
|
|
function noop() {}
|
|
|
|
slice = [].slice;
|
|
|
|
// ES5 reduce implementation if native not available
|
|
// See: http://es5.github.com/#x15.4.4.21 as there are many
|
|
// specifics and edge cases.
|
|
reduceArray = [].reduce ||
|
|
function(reduceFunc /*, initialValue */) {
|
|
/*jshint maxcomplexity: 7*/
|
|
|
|
// ES5 dictates that reduce.length === 1
|
|
|
|
// This implementation deviates from ES5 spec in the following ways:
|
|
// 1. It does not check if reduceFunc is a Callable
|
|
|
|
var arr, args, reduced, len, i;
|
|
|
|
i = 0;
|
|
// This generates a jshint warning, despite being valid
|
|
// "Missing 'new' prefix when invoking a constructor."
|
|
// See https://github.com/jshint/jshint/issues/392
|
|
arr = Object(this);
|
|
len = arr.length >>> 0;
|
|
args = arguments;
|
|
|
|
// If no initialValue, use first item of array (we know length !== 0 here)
|
|
// and adjust i to start at second item
|
|
if(args.length <= 1) {
|
|
// Skip to the first real element in the array
|
|
for(;;) {
|
|
if(i in arr) {
|
|
reduced = arr[i++];
|
|
break;
|
|
}
|
|
|
|
// If we reached the end of the array without finding any real
|
|
// elements, it's a TypeError
|
|
if(++i >= len) {
|
|
throw new TypeError();
|
|
}
|
|
}
|
|
} else {
|
|
// If initialValue provided, use it
|
|
reduced = args[1];
|
|
}
|
|
|
|
// Do the actual reduce
|
|
for(;i < len; ++i) {
|
|
// Skip holes
|
|
if(i in arr) {
|
|
reduced = reduceFunc(reduced, arr[i], i, arr);
|
|
}
|
|
}
|
|
|
|
return reduced;
|
|
};
|
|
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
|
|
return when;
|
|
});
|
|
})(typeof define == 'function' && define.amd
|
|
? define
|
|
: function (factory) { typeof exports === 'object'
|
|
? (module.exports = factory())
|
|
: (this.when = factory());
|
|
}
|
|
// Boilerplate for AMD, Node, and browser global
|
|
);
|
|
|
|
define('Core/freezeObject',[
|
|
'./defined'
|
|
], function(
|
|
defined) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Freezes an object, using Object.freeze if available, otherwise returns
|
|
* the object unchanged. This function should be used in setup code to prevent
|
|
* errors from completely halting JavaScript execution in legacy browsers.
|
|
*
|
|
* @private
|
|
*
|
|
* @exports freezeObject
|
|
*/
|
|
var freezeObject = Object.freeze;
|
|
if (!defined(freezeObject)) {
|
|
freezeObject = function(o) {
|
|
return o;
|
|
};
|
|
}
|
|
|
|
return freezeObject;
|
|
});
|
|
|
|
define('Core/defaultValue',[
|
|
'./freezeObject'
|
|
], function(
|
|
freezeObject) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Returns the first parameter if not undefined, otherwise the second parameter.
|
|
* Useful for setting a default value for a parameter.
|
|
*
|
|
* @exports defaultValue
|
|
*
|
|
* @param {*} a
|
|
* @param {*} b
|
|
* @returns {*} Returns the first parameter if not undefined, otherwise the second parameter.
|
|
*
|
|
* @example
|
|
* param = Cesium.defaultValue(param, 'default');
|
|
*/
|
|
function defaultValue(a, b) {
|
|
if (a !== undefined && a !== null) {
|
|
return a;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
/**
|
|
* A frozen empty object that can be used as the default value for options passed as
|
|
* an object literal.
|
|
* @type {Object}
|
|
*/
|
|
defaultValue.EMPTY_OBJECT = freezeObject({});
|
|
|
|
return defaultValue;
|
|
});
|
|
|
|
define('Core/formatError',[
|
|
'./defined'
|
|
], function(
|
|
defined) {
|
|
'use strict';
|
|
|
|
/**
|
|
* Formats an error object into a String. If available, uses name, message, and stack
|
|
* properties, otherwise, falls back on toString().
|
|
*
|
|
* @exports formatError
|
|
*
|
|
* @param {*} object The item to find in the array.
|
|
* @returns {String} A string containing the formatted error.
|
|
*/
|
|
function formatError(object) {
|
|
var result;
|
|
|
|
var name = object.name;
|
|
var message = object.message;
|
|
if (defined(name) && defined(message)) {
|
|
result = name + ': ' + message;
|
|
} else {
|
|
result = object.toString();
|
|
}
|
|
|
|
var stack = object.stack;
|
|
if (defined(stack)) {
|
|
result += '\n' + stack;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return formatError;
|
|
});
|
|
|
|
define('Workers/createTaskProcessorWorker',[
|
|
'../ThirdParty/when',
|
|
'../Core/defaultValue',
|
|
'../Core/defined',
|
|
'../Core/formatError'
|
|
], function(
|
|
when,
|
|
defaultValue,
|
|
defined,
|
|
formatError) {
|
|
'use strict';
|
|
|
|
// createXXXGeometry functions may return Geometry or a Promise that resolves to Geometry
|
|
// if the function requires access to ApproximateTerrainHeights.
|
|
// For fully synchronous functions, just wrapping the function call in a `when` Promise doesn't
|
|
// handle errors correctly, hence try-catch
|
|
function callAndWrap(workerFunction, parameters, transferableObjects) {
|
|
var resultOrPromise;
|
|
try {
|
|
resultOrPromise = workerFunction(parameters, transferableObjects);
|
|
return resultOrPromise; // errors handled by Promise
|
|
} catch (e) {
|
|
return when.reject(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an adapter function to allow a calculation function to operate as a Web Worker,
|
|
* paired with TaskProcessor, to receive tasks and return results.
|
|
*
|
|
* @exports createTaskProcessorWorker
|
|
*
|
|
* @param {createTaskProcessorWorker~WorkerFunction} workerFunction The calculation function,
|
|
* which takes parameters and returns a result.
|
|
* @returns {createTaskProcessorWorker~TaskProcessorWorkerFunction} A function that adapts the
|
|
* calculation function to work as a Web Worker onmessage listener with TaskProcessor.
|
|
*
|
|
*
|
|
* @example
|
|
* function doCalculation(parameters, transferableObjects) {
|
|
* // calculate some result using the inputs in parameters
|
|
* return result;
|
|
* }
|
|
*
|
|
* return Cesium.createTaskProcessorWorker(doCalculation);
|
|
* // the resulting function is compatible with TaskProcessor
|
|
*
|
|
* @see TaskProcessor
|
|
* @see {@link http://www.w3.org/TR/workers/|Web Workers}
|
|
* @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
|
|
*/
|
|
function createTaskProcessorWorker(workerFunction) {
|
|
var postMessage;
|
|
|
|
return function(event) {
|
|
/*global self*/
|
|
var data = event.data;
|
|
|
|
var transferableObjects = [];
|
|
var responseMessage = {
|
|
id : data.id,
|
|
result : undefined,
|
|
error : undefined
|
|
};
|
|
|
|
return when(callAndWrap(workerFunction, data.parameters, transferableObjects))
|
|
.then(function(result) {
|
|
responseMessage.result = result;
|
|
})
|
|
.otherwise(function(e) {
|
|
if (e instanceof Error) {
|
|
// Errors can't be posted in a message, copy the properties
|
|
responseMessage.error = {
|
|
name : e.name,
|
|
message : e.message,
|
|
stack : e.stack
|
|
};
|
|
} else {
|
|
responseMessage.error = e;
|
|
}
|
|
})
|
|
.always(function() {
|
|
if (!defined(postMessage)) {
|
|
postMessage = defaultValue(self.webkitPostMessage, self.postMessage);
|
|
}
|
|
|
|
if (!data.canTransferArrayBuffer) {
|
|
transferableObjects.length = 0;
|
|
}
|
|
|
|
try {
|
|
postMessage(responseMessage, transferableObjects);
|
|
} catch (e) {
|
|
// something went wrong trying to post the message, post a simpler
|
|
// error that we can be sure will be cloneable
|
|
responseMessage.result = undefined;
|
|
responseMessage.error = 'postMessage failed with error: ' + formatError(e) + '\n with responseMessage: ' + JSON.stringify(responseMessage);
|
|
postMessage(responseMessage);
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* A function that performs a calculation in a Web Worker.
|
|
* @callback createTaskProcessorWorker~WorkerFunction
|
|
*
|
|
* @param {Object} parameters Parameters to the calculation.
|
|
* @param {Array} transferableObjects An array that should be filled with references to objects inside
|
|
* the result that should be transferred back to the main document instead of copied.
|
|
* @returns {Object} The result of the calculation.
|
|
*
|
|
* @example
|
|
* function calculate(parameters, transferableObjects) {
|
|
* // perform whatever calculation is necessary.
|
|
* var typedArray = new Float32Array(0);
|
|
*
|
|
* // typed arrays are transferable
|
|
* transferableObjects.push(typedArray)
|
|
*
|
|
* return {
|
|
* typedArray : typedArray
|
|
* };
|
|
* }
|
|
*/
|
|
|
|
/**
|
|
* A Web Worker message event handler function that handles the interaction with TaskProcessor,
|
|
* specifically, task ID management and posting a response message containing the result.
|
|
* @callback createTaskProcessorWorker~TaskProcessorWorkerFunction
|
|
*
|
|
* @param {Object} event The onmessage event object.
|
|
*/
|
|
|
|
return createTaskProcessorWorker;
|
|
});
|
|
|
|
define('Workers/decodeGoogleEarthEnterprisePacket',[
|
|
'../Core/decodeGoogleEarthEnterpriseData',
|
|
'../Core/GoogleEarthEnterpriseTileInformation',
|
|
'../Core/RuntimeError',
|
|
'../ThirdParty/pako_inflate',
|
|
'./createTaskProcessorWorker'
|
|
], function(
|
|
decodeGoogleEarthEnterpriseData,
|
|
GoogleEarthEnterpriseTileInformation,
|
|
RuntimeError,
|
|
pako,
|
|
createTaskProcessorWorker) {
|
|
'use strict';
|
|
|
|
// Datatype sizes
|
|
var sizeOfUint16 = Uint16Array.BYTES_PER_ELEMENT;
|
|
var sizeOfInt32 = Int32Array.BYTES_PER_ELEMENT;
|
|
var sizeOfUint32 = Uint32Array.BYTES_PER_ELEMENT;
|
|
|
|
var Types = {
|
|
METADATA : 0,
|
|
TERRAIN : 1,
|
|
DBROOT : 2
|
|
};
|
|
|
|
Types.fromString = function(s) {
|
|
if (s === 'Metadata') {
|
|
return Types.METADATA;
|
|
} else if (s === 'Terrain') {
|
|
return Types.TERRAIN;
|
|
} else if (s === 'DbRoot') {
|
|
return Types.DBROOT;
|
|
}
|
|
};
|
|
|
|
function decodeGoogleEarthEnterprisePacket(parameters, transferableObjects) {
|
|
var type = Types.fromString(parameters.type);
|
|
var buffer = parameters.buffer;
|
|
decodeGoogleEarthEnterpriseData(parameters.key, buffer);
|
|
|
|
var uncompressedTerrain = uncompressPacket(buffer);
|
|
buffer = uncompressedTerrain.buffer;
|
|
var length = uncompressedTerrain.length;
|
|
|
|
switch (type) {
|
|
case Types.METADATA:
|
|
return processMetadata(buffer, length, parameters.quadKey);
|
|
case Types.TERRAIN:
|
|
return processTerrain(buffer, length, transferableObjects);
|
|
case Types.DBROOT:
|
|
transferableObjects.push(buffer);
|
|
return {
|
|
buffer : buffer
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
var qtMagic = 32301;
|
|
|
|
function processMetadata(buffer, totalSize, quadKey) {
|
|
var dv = new DataView(buffer);
|
|
var offset = 0;
|
|
var magic = dv.getUint32(offset, true);
|
|
offset += sizeOfUint32;
|
|
if (magic !== qtMagic) {
|
|
throw new RuntimeError('Invalid magic');
|
|
}
|
|
|
|
var dataTypeId = dv.getUint32(offset, true);
|
|
offset += sizeOfUint32;
|
|
if (dataTypeId !== 1) {
|
|
throw new RuntimeError('Invalid data type. Must be 1 for QuadTreePacket');
|
|
}
|
|
|
|
// Tile format version
|
|
var quadVersion = dv.getUint32(offset, true);
|
|
offset += sizeOfUint32;
|
|
if (quadVersion !== 2) {
|
|
throw new RuntimeError('Invalid QuadTreePacket version. Only version 2 is supported.');
|
|
}
|
|
|
|
var numInstances = dv.getInt32(offset, true);
|
|
offset += sizeOfInt32;
|
|
|
|
var dataInstanceSize = dv.getInt32(offset, true);
|
|
offset += sizeOfInt32;
|
|
if (dataInstanceSize !== 32) {
|
|
throw new RuntimeError('Invalid instance size.');
|
|
}
|
|
|
|
var dataBufferOffset = dv.getInt32(offset, true);
|
|
offset += sizeOfInt32;
|
|
|
|
var dataBufferSize = dv.getInt32(offset, true);
|
|
offset += sizeOfInt32;
|
|
|
|
var metaBufferSize = dv.getInt32(offset, true);
|
|
offset += sizeOfInt32;
|
|
|
|
// Offset from beginning of packet (instances + current offset)
|
|
if (dataBufferOffset !== (numInstances * dataInstanceSize + offset)) {
|
|
throw new RuntimeError('Invalid dataBufferOffset');
|
|
}
|
|
|
|
// Verify the packets is all there header + instances + dataBuffer + metaBuffer
|
|
if (dataBufferOffset + dataBufferSize + metaBufferSize !== totalSize) {
|
|
throw new RuntimeError('Invalid packet offsets');
|
|
}
|
|
|
|
// Read all the instances
|
|
var instances = [];
|
|
for (var i = 0; i < numInstances; ++i) {
|
|
var bitfield = dv.getUint8(offset);
|
|
++offset;
|
|
|
|
++offset; // 2 byte align
|
|
|
|
var cnodeVersion = dv.getUint16(offset, true);
|
|
offset += sizeOfUint16;
|
|
|
|
var imageVersion = dv.getUint16(offset, true);
|
|
offset += sizeOfUint16;
|
|
|
|
var terrainVersion = dv.getUint16(offset, true);
|
|
offset += sizeOfUint16;
|
|
|
|
// Number of channels stored in the dataBuffer
|
|
offset += sizeOfUint16;
|
|
|
|
offset += sizeOfUint16; // 4 byte align
|
|
|
|
// Channel type offset into dataBuffer
|
|
offset += sizeOfInt32;
|
|
|
|
// Channel version offset into dataBuffer
|
|
offset += sizeOfInt32;
|
|
|
|
offset += 8; // Ignore image neighbors for now
|
|
|
|
// Data providers
|
|
var imageProvider = dv.getUint8(offset++);
|
|
var terrainProvider = dv.getUint8(offset++);
|
|
offset += sizeOfUint16; // 4 byte align
|
|
|
|
instances.push(new GoogleEarthEnterpriseTileInformation(bitfield, cnodeVersion,
|
|
imageVersion, terrainVersion, imageProvider, terrainProvider));
|
|
}
|
|
|
|
var tileInfo = [];
|
|
var index = 0;
|
|
|
|
function populateTiles(parentKey, parent, level) {
|
|
var isLeaf = false;
|
|
if (level === 4) {
|
|
if (parent.hasSubtree()) {
|
|
return; // We have a subtree, so just return
|
|
}
|
|
|
|
isLeaf = true; // No subtree, so set all children to null
|
|
}
|
|
for (var i = 0; i < 4; ++i) {
|
|
var childKey = parentKey + i.toString();
|
|
if (isLeaf) {
|
|
// No subtree so set all children to null
|
|
tileInfo[childKey] = null;
|
|
} else if (level < 4) {
|
|
// We are still in the middle of the subtree, so add child
|
|
// only if their bits are set, otherwise set child to null.
|
|
if (!parent.hasChild(i)) {
|
|
tileInfo[childKey] = null;
|
|
} else {
|
|
if (index === numInstances) {
|
|
console.log('Incorrect number of instances');
|
|
return;
|
|
}
|
|
|
|
var instance = instances[index++];
|
|
tileInfo[childKey] = instance;
|
|
populateTiles(childKey, instance, level + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var level = 0;
|
|
var root = instances[index++];
|
|
if (quadKey === '') {
|
|
// Root tile has data at its root and one less level
|
|
++level;
|
|
} else {
|
|
tileInfo[quadKey] = root; // This will only contain the child bitmask
|
|
}
|
|
|
|
populateTiles(quadKey, root, level);
|
|
|
|
return tileInfo;
|
|
}
|
|
|
|
function processTerrain(buffer, totalSize, transferableObjects) {
|
|
var dv = new DataView(buffer);
|
|
|
|
var offset = 0;
|
|
var terrainTiles = [];
|
|
while (offset < totalSize) {
|
|
// Each tile is split into 4 parts
|
|
var tileStart = offset;
|
|
for (var quad = 0; quad < 4; ++quad) {
|
|
var size = dv.getUint32(offset, true);
|
|
offset += sizeOfUint32;
|
|
offset += size;
|
|
}
|
|
var tile = buffer.slice(tileStart, offset);
|
|
transferableObjects.push(tile);
|
|
terrainTiles.push(tile);
|
|
}
|
|
|
|
return terrainTiles;
|
|
}
|
|
|
|
var compressedMagic = 0x7468dead;
|
|
var compressedMagicSwap = 0xadde6874;
|
|
|
|
function uncompressPacket(data) {
|
|
// The layout of this decoded data is
|
|
// Magic Uint32
|
|
// Size Uint32
|
|
// [GZipped chunk of Size bytes]
|
|
|
|
// Pullout magic and verify we have the correct data
|
|
var dv = new DataView(data);
|
|
var offset = 0;
|
|
var magic = dv.getUint32(offset, true);
|
|
offset += sizeOfUint32;
|
|
if (magic !== compressedMagic && magic !== compressedMagicSwap) {
|
|
throw new RuntimeError('Invalid magic');
|
|
}
|
|
|
|
// Get the size of the compressed buffer - the endianness depends on which magic was used
|
|
var size = dv.getUint32(offset, (magic === compressedMagic));
|
|
offset += sizeOfUint32;
|
|
|
|
var compressedPacket = new Uint8Array(data, offset);
|
|
var uncompressedPacket = pako.inflate(compressedPacket);
|
|
|
|
if (uncompressedPacket.length !== size) {
|
|
throw new RuntimeError('Size of packet doesn\'t match header');
|
|
}
|
|
|
|
return uncompressedPacket;
|
|
}
|
|
|
|
return createTaskProcessorWorker(decodeGoogleEarthEnterprisePacket);
|
|
});
|
|
|
|
}()); |