mirror of
https://github.com/Esri/offline-editor-js.git
synced 2025-12-15 15:20:05 +00:00
4658 lines
154 KiB
JavaScript
4658 lines
154 KiB
JavaScript
/*! offline-editor-js - v2.7.0 - 2015-04-27
|
|
* Copyright (c) 2015 Environmental Systems Research Institute, Inc.
|
|
* Apache License*/
|
|
/**
|
|
* Library for reading an ArcGIS Tile Package (.tpk) file and displaying the tiles
|
|
* as a map that can be used both online and offline.
|
|
*
|
|
* Note: you may have to rename your .tpk file to use .zip in order for it to be recognized.
|
|
*
|
|
* Author: Andy Gup
|
|
* Credits: Mansour Raad for his ArcGIS API for Flex TPKLayer,
|
|
* and Jon leighton for his super fast ArrayBuffer to Base64 convert.
|
|
*/
|
|
define([
|
|
"dojo/_base/declare","esri/geometry/Extent","dojo/query","esri/SpatialReference",
|
|
"esri/layers/TileInfo","esri/layers/TiledMapServiceLayer",
|
|
"dojo/Deferred","dojo/promise/all","dojo/Evented"],
|
|
function(declare,Extent,query,SpatialReference,TileInfo,TiledMapServiceLayer,
|
|
Deferred,all,Evented){
|
|
return declare("O.esri.TPK.TPKLayer",[TiledMapServiceLayer,Evented],{
|
|
|
|
//
|
|
// Public Properties
|
|
//
|
|
map: null,
|
|
store: null, // Reference to the local database store and hooks to it's functionality
|
|
MAX_DB_SIZE: 75, // Recommended maximum size in MBs
|
|
TILE_PATH:"", // The absolute path to the root of bundle/bundleX files e.g. V101/YOSEMITE_MAP/
|
|
RECENTER_DELAY: 350, // Millisecond delay before attempting to recent map after an orientation change
|
|
PARSING_ERROR: 'parsingError', // An error was encountered while parsing a TPK file.
|
|
DB_INIT_ERROR: "dbInitError", // An error occurred while initializing the database.
|
|
DB_FULL_ERROR: "dbFullError", // No space left in the database.
|
|
NO_SUPPORT_ERROR: "libNotSupportedError", // Error indicating this library is not supported in a particular browser.
|
|
PROGRESS_START: "start",
|
|
PROGRESS_END: "end",
|
|
WINDOW_VALIDATED: "windowValidated", // All window functionality checks have passed
|
|
DB_VALIDATED: "dbValidated", // All database functionality checks have passed
|
|
|
|
//
|
|
// Events
|
|
//
|
|
DATABASE_ERROR_EVENT: "databaseErrorEvent", // An error thrown by the database.
|
|
VALIDATION_EVENT: "validationEvent", // Library validation checks.
|
|
PROGRESS_EVENT: "progress", // Event dispatched while parsing a bundle file.
|
|
|
|
//
|
|
// Private properties
|
|
//
|
|
_maxDBSize: 75, // User configurable maximum size in MBs.
|
|
_isDBWriteable: true, // Manually allow or stop writing to the database.
|
|
_isDBValid: false, // Does the browser support IndexedDB or IndexedDBShim
|
|
_autoCenter: null, // Auto center the map
|
|
_fileEntriesLength: 0, // Number of files in zip
|
|
_inMemTilesObject: null, // Stores unzipped files from tpk
|
|
_inMemTilesObjectLength: 0,
|
|
_zeroLengthFileCounter: 0, // For counting the number of zero length files in the tpk (e.g. directories)
|
|
|
|
constructor:function(){
|
|
this._self = this;
|
|
this._inMemTilesIndex = [];
|
|
this._inMemTilesObject = {};
|
|
this.store = new O.esri.Tiles.TilesStore();
|
|
this._validate();
|
|
},
|
|
|
|
extend: function(files){
|
|
this._fileEntriesLength = files.length;
|
|
this.emit(this.PROGRESS_EVENT,this.PROGRESS_START);
|
|
|
|
this._parseInMemFiles(files,function (){
|
|
//Parse conf.xml and conf.cdi to get the required setup info
|
|
this._parseConfCdi(function(initExtent){
|
|
this.initialExtent = (this.fullExtent = initExtent);
|
|
this._parseConfXml(function(result){
|
|
this.tileInfo = new TileInfo(result);
|
|
this.spatialReference = new SpatialReference({wkid:this.tileInfo.spatialReference.wkid});
|
|
this.loaded = true;
|
|
this.onLoad(this);
|
|
this.emit(this.PROGRESS_EVENT,this.PROGRESS_END);
|
|
}.bind(this._self));
|
|
}.bind(this._self));
|
|
}.bind(this._self));
|
|
},
|
|
|
|
/**
|
|
* Overrides getTileUrl method
|
|
* @param level
|
|
* @param row
|
|
* @param col
|
|
* @returns {string}
|
|
*/
|
|
getTileUrl:function(level,row,col){
|
|
this.emit(this.PROGRESS_EVENT,this.PROGRESS_START);
|
|
var layersDir = this._self.TILE_PATH + "_alllayers";
|
|
var url = this._getCacheFilePath(layersDir,level,row,col);
|
|
|
|
if(this._inMemTilesObject != {}) {
|
|
/* temporary URL returned immediately, as we haven't retrieved the image from the indexeddb yet */
|
|
var tileid = "void:/" + level + "/" + row + "/" + col;
|
|
|
|
if(this.map == null) this.map = this.getMap();
|
|
if(this._autoCenter == null) {
|
|
this._autoCenter = new O.esri.TPK.autoCenterMap(this.map,this.RECENTER_DELAY);
|
|
this._autoCenter.init();
|
|
}
|
|
|
|
this._getInMemTiles(url,layersDir, level, row, col,tileid,function (result,tileid,url) {
|
|
var img = query("img[src=" + tileid + "]")[0];
|
|
if (typeof img == "undefined")img = new Image(); //create a blank place holder for undefined images
|
|
var imgURL;
|
|
|
|
if (result) {
|
|
console.log("found tile offline", url);
|
|
var png = "data:image/png;base64,";
|
|
switch(this.tileInfo.format) {
|
|
case "JPEG":
|
|
imgURL = "data:image/jpg;base64," + result;
|
|
break;
|
|
case "PNG":
|
|
imgURL = png + result;
|
|
break;
|
|
case "PNG8":
|
|
imgURL = png + result;
|
|
break;
|
|
case "PNG24":
|
|
imgURL = png + result;
|
|
break;
|
|
case "PNG32":
|
|
imgURL = png + result;
|
|
break;
|
|
default:
|
|
imgURL = "data:image/jpg;base64," + result;
|
|
|
|
}
|
|
img.style.borderColor = "blue";
|
|
}
|
|
else {
|
|
img.style.borderColor = "green";
|
|
console.log("tile is not in the offline store", url);
|
|
imgURL = "data:image/png;base64,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";
|
|
}
|
|
// when we return a nonexistent url to the image, the TiledMapServiceLayer::_tileErrorHandler() method
|
|
// sets img visibility to 'hidden', so we need to show the image back once we have put the data:image
|
|
img.style.visibility = "visible";
|
|
img.src = imgURL;
|
|
console.log("URL length " + imgURL.length + ", image: " + imgURL);
|
|
this.emit(this.PROGRESS_EVENT,this.PROGRESS_END);
|
|
return "";
|
|
/* this result goes nowhere, seriously */
|
|
}.bind(this._self))
|
|
|
|
return tileid;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Optional. Set the maximum database size. Recommended maximum for mobile devices is 100MBs.
|
|
* Making the database too large can result in browser crashes and slow performance.
|
|
* TPKs can contain a lot of data!
|
|
* @param size
|
|
*/
|
|
setMaxDBSize: function(size){
|
|
//Make sure the entry is an integer.
|
|
var testRegex = /^\d+$/;
|
|
if(testRegex.test(size) && size <= this.MAX_DB_SIZE){
|
|
this._maxDBSize = size;
|
|
}
|
|
else{
|
|
console.log("setMaxDBSize Error: invalid entry. Integers only and less than " + this.MAX_DB_SIZE + "MBs");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Returns the size of the tiles database.
|
|
* @param callback {size , error}. Note, size is in bytes.
|
|
*/
|
|
getDBSize: function(callback){
|
|
this.store.usedSpace(function(size,err){
|
|
callback(size,err);
|
|
}.bind(this))
|
|
},
|
|
|
|
/**
|
|
* Sets whether or not tiles can be written to the database. This function
|
|
* can help you manage the size of the tiles database.
|
|
* Use this in conjunction with getDBSize() on a map pan or zoom event listener.
|
|
* @param value
|
|
*/
|
|
setDBWriteable: function(/* Boolean */ value){
|
|
this._isDBWriteable = value;
|
|
},
|
|
|
|
/**
|
|
* Validates whether or not the browser supports this library
|
|
* @returns {boolean}
|
|
*/
|
|
isDBValid: function(){
|
|
this._validate();
|
|
return this._isDBValid;
|
|
},
|
|
|
|
/**
|
|
* Reads a tile into tile database. Works with offlineTilesEnabler.js and OfflineTilesEnablerLayer.js
|
|
* saveToFile() functionality.
|
|
* IMPORTANT! The tile must confirm to an object using the pattern shown in _storeTile().
|
|
* @param file
|
|
* @param callback callback( boolean, error)
|
|
*/
|
|
loadFromURL: function (tile, callback) // callback(success,msg)
|
|
{
|
|
if (this.isDBValid()) {
|
|
this.store.store(tile, function (success,err) {
|
|
//Check the result
|
|
if (success) {
|
|
console.log("loadFromURL() success.");
|
|
callback(true, "");
|
|
}
|
|
else {
|
|
console.log("loadFromURL() Failed.");
|
|
callback(false, err);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
callback(false, "not supported");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Runs specific validation tasks. Reserved for future use.
|
|
* Currently only throws console errors. Does not stop execution of the library!
|
|
* @private
|
|
*/
|
|
_validate: function(){
|
|
//Verify if basic functionality is supported by the browser
|
|
if(!window.File && !window.FileReader && !window.Blob && !window.btoa && !window.DataView){
|
|
console.log("TPKLayer library is not supported by this browser");
|
|
this.emit(this.VALIDATION_EVENT,{msg:this.NO_SUPPORT_ERROR, err : null});
|
|
}
|
|
else{
|
|
this.emit(this.VALIDATION_EVENT,{msg:this.WINDOW_VALIDATED, err : null});
|
|
}
|
|
|
|
//Verify if IndexedDB is supported and initializes properly
|
|
if( /*false &&*/ this.store.isSupported() )
|
|
{
|
|
this.store.init(function(result){
|
|
if(result == false){
|
|
console.log("There was an error initializing the TPKLayer database");
|
|
this.emit(this.DATABASE_ERROR_EVENT,{msg:this.DB_INIT_ERROR, err: null});
|
|
}
|
|
else{
|
|
this.store.usedSpace(function(size,err){
|
|
var mb = this._bytes2MBs(size.sizeBytes);
|
|
if(mb > this.MAX_DB_SIZE){
|
|
console.log("Database is full!");
|
|
this.emit(this.DATABASE_ERROR_EVENT,{msg:this.DB_FULL_ERROR,err : err});
|
|
}
|
|
this.emit(this.VALIDATION_EVENT,{msg:this.DB_VALIDATED,err : null})
|
|
console.log("DB size: " + mb + " MBs, Tile count: " + size.tileCount + ", Error: " + err);
|
|
this._isDBValid = true;
|
|
}.bind(this))
|
|
}
|
|
}.bind(this));
|
|
}
|
|
else
|
|
{
|
|
console.log("IndexedDB is not supported on your browser.");
|
|
this.emit(this.VALIDATION_EVENT,{msg:this.NO_SUPPORT_ERROR, err : null});
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Function for pulling out individual files from the .tpk/zip and storing
|
|
* them in memory.
|
|
* @param files
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_parseInMemFiles: function(files,callback){
|
|
|
|
var inMemTilesLength = this._fileEntriesLength;
|
|
this._zeroLengthFileCounter = 0;
|
|
var promises = [];
|
|
|
|
for(var i=0;i < inMemTilesLength;i++){
|
|
|
|
var deferred = new Deferred();
|
|
var name = files[i].filename.toLocaleUpperCase();
|
|
|
|
var index = name.indexOf("_ALLLAYERS",0);
|
|
if(index != -1){
|
|
this.TILE_PATH = name.slice(0,index);
|
|
}
|
|
|
|
if(files[i].compressedSize == 0) this._zeroLengthFileCounter++;
|
|
|
|
var indexCDI = name.indexOf("CONF.CDI",0);
|
|
var indexXML = name.indexOf("CONF.XML",0);
|
|
var indexBUNDLE = name.indexOf("BUNDLE",0);
|
|
var indexBUNDLX = name.indexOf("BUNDLX",0);
|
|
|
|
if(indexCDI != -1 || indexXML != -1){
|
|
this._unzipConfFiles(files,i,deferred,function(/* deferred */ d, /* token */ t){ console.log("CONF FILE")
|
|
d.resolve(t);
|
|
});
|
|
}
|
|
else if(indexBUNDLE != -1 || indexBUNDLX != -1){
|
|
this._unzipTileFiles(files,i,deferred,function(/* deferred */ d, /* token */ t){
|
|
d.resolve(t);
|
|
});
|
|
}
|
|
else{
|
|
deferred.resolve(i);
|
|
}
|
|
promises.push(deferred);
|
|
}
|
|
|
|
all(promises).then( function(results)
|
|
{
|
|
callback && callback(results);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Calculate the size of an Object based on whether or not the item is enumerable.
|
|
* Native Objects don't have a built in size property.
|
|
* More info: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
|
|
* @param obj
|
|
* @returns {number}
|
|
* @constructor
|
|
*/
|
|
ObjectSize: function(obj) {
|
|
var size = 0, key;
|
|
for (key in obj) {
|
|
if (obj.hasOwnProperty(key)) size++;
|
|
}
|
|
return size;
|
|
},
|
|
|
|
/**
|
|
* Retrieve XML config files
|
|
* @param files
|
|
* @param token
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_unzipConfFiles: function(files,token,deferred,callback){
|
|
files[token].getData(new O.esri.zip.TextWriter(token),function(data){
|
|
this._inMemTilesIndex.push("blank");
|
|
var name = files[data.token].filename.toLocaleUpperCase();
|
|
this._inMemTilesObject[name]= data.string;
|
|
var size = this.ObjectSize(this._inMemTilesObject);
|
|
if(size > 0){
|
|
callback(deferred,data.token);
|
|
}
|
|
}.bind(this));
|
|
},
|
|
|
|
/**
|
|
* Retrieve binary tile files as ArrayBuffers
|
|
* @param files
|
|
* @param token
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_unzipTileFiles: function(files,token,deferred,callback){
|
|
var that = this;
|
|
files[token].getData(new O.esri.zip.BlobWriter(token),function(data){
|
|
if(data.size != 0){
|
|
var reader = new FileReader();
|
|
reader.token = data.token;
|
|
reader.onerror = function (event) {
|
|
console.error("_unzipTileFiles Error: " + event.target.error.message);
|
|
that.emit(that.PARSING_ERROR, {msg: "Error parsing file: ", err: event.target.error});
|
|
}
|
|
reader.addEventListener("loadend", function (evt) {
|
|
if(this.token != undefined){
|
|
that._inMemTilesIndex.push("blank");
|
|
var name = files[this.token].filename.toLocaleUpperCase();
|
|
that._inMemTilesObject[name]= this.result;
|
|
var size = that.ObjectSize(that._inMemTilesObject);
|
|
if(size > 0){
|
|
callback(deferred,data.token);
|
|
}
|
|
}
|
|
});
|
|
reader.readAsArrayBuffer(data); //open bundleX
|
|
}
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Parse conf.cdi
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_parseConfCdi: function(callback){
|
|
var m_conf_i = this._inMemTilesObject[this.TILE_PATH + "CONF.CDI"];
|
|
|
|
var x2js = new O.esri.TPK.X2JS();
|
|
|
|
var jsonObj = x2js.xml_str2json( m_conf_i );
|
|
var envelopeInfo = jsonObj.EnvelopeN;
|
|
var xmin = parseFloat(envelopeInfo.XMin);
|
|
var ymin = parseFloat(envelopeInfo.YMin);
|
|
var xmax = parseFloat(envelopeInfo.XMax);
|
|
var ymax = parseFloat(envelopeInfo.YMax);
|
|
var sr = parseInt(envelopeInfo.SpatialReference.WKID);
|
|
|
|
var initExtent = new Extent(
|
|
xmin,ymin,xmax,ymax, new SpatialReference({wkid:sr})
|
|
);
|
|
|
|
callback(initExtent);
|
|
},
|
|
|
|
/**
|
|
* Parse conf.xml
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_parseConfXml:function(callback) {
|
|
var m_conf = this._inMemTilesObject[this.TILE_PATH + "CONF.XML"];
|
|
|
|
var x2js = new O.esri.TPK.X2JS();
|
|
|
|
var jsonObj = x2js.xml_str2json(m_conf);
|
|
var cacheInfo = jsonObj.CacheInfo;
|
|
var tileInfo = {};
|
|
tileInfo.rows = parseInt(cacheInfo.TileCacheInfo.TileRows);
|
|
tileInfo.cols = parseInt(cacheInfo.TileCacheInfo.TileCols);
|
|
tileInfo.dpi = parseInt(cacheInfo.TileCacheInfo.DPI);
|
|
tileInfo.format = cacheInfo.TileImageInfo.CacheTileFormat;
|
|
tileInfo.compressionQuality = parseInt(cacheInfo.TileImageInfo.CompressionQuality);
|
|
tileInfo.origin = {
|
|
x: parseInt(cacheInfo.TileCacheInfo.TileOrigin.X),
|
|
y: parseInt(cacheInfo.TileCacheInfo.TileOrigin.Y)
|
|
}
|
|
tileInfo.spatialReference = {
|
|
"wkid": parseInt(cacheInfo.TileCacheInfo.SpatialReference.WKID)
|
|
}
|
|
|
|
var lods = cacheInfo.TileCacheInfo.LODInfos.LODInfo;
|
|
var finalLods = [];
|
|
for (var i = 0; i < lods.length; i++) {
|
|
finalLods.push({
|
|
"level": parseFloat(lods[i].LevelID),
|
|
"resolution": parseFloat(lods[i].Resolution),
|
|
"scale": parseFloat(lods[i].Scale)})
|
|
}
|
|
|
|
tileInfo.lods = finalLods;
|
|
callback(tileInfo);
|
|
},
|
|
|
|
/**
|
|
* Parses the in-memory tile cache and returns a base64 tile image
|
|
* @param layersDir
|
|
* @param level
|
|
* @param row
|
|
* @param col
|
|
* @param tileCount - number of tiles in the Extent
|
|
* @param tiledId - id of the associated tile being passed
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_getInMemTiles: function(url,layersDir,level,row,col,tileId,callback){
|
|
|
|
var that = this._self;
|
|
var db = this.store;
|
|
|
|
//First check in the database if the tile exists.
|
|
//If not then we store the tile in the database later.
|
|
this.store.retrieve(url, function(success, offlineTile){
|
|
if( success )
|
|
{
|
|
console.log("Tile found in storage: " + url)
|
|
callback(offlineTile.img,tileId,url);
|
|
}
|
|
else {
|
|
console.log("Tile is not in storage: " + url)
|
|
var snappedRow = Math.floor(row / 128) * 128;
|
|
var snappedCol = Math.floor(col / 128) * 128;
|
|
|
|
var path = this._getCacheFilePath(layersDir, level, snappedRow, snappedCol).toLocaleUpperCase();
|
|
|
|
var offset;
|
|
var bundleIndex = path + ".BUNDLE";
|
|
var bufferI = this._inMemTilesObject[bundleIndex];
|
|
var bufferX = this._inMemTilesObject[path + ".BUNDLX"];
|
|
|
|
if(bufferI != undefined || bufferX != undefined) {
|
|
offset = this._getOffset(level, row, col, snappedRow, snappedCol);
|
|
var pointer = that._getPointer(bufferX, offset);
|
|
|
|
that._buffer2Base64(bufferI,pointer,function(result){
|
|
if (that._isDBWriteable)that._storeTile(url, result, db,function(success,err){
|
|
if(err){
|
|
console.log("TPKLayer - Error writing to database." + err.message);
|
|
that.emit(that.DATABASE_ERROR_EVENT,{msg:"Error writing to database. ", err : err});
|
|
}
|
|
});
|
|
callback(result,tileId, url);
|
|
}.bind(that));
|
|
}
|
|
else{
|
|
console.log("_getInMemTiles Error: Invalid values");
|
|
callback(null,tileId,url);
|
|
}
|
|
}
|
|
}.bind(that))
|
|
},
|
|
|
|
/**
|
|
* Stores a tile in the local database.
|
|
* @param url
|
|
* @param base64Str
|
|
* @param db
|
|
* @param callback
|
|
* @private
|
|
*/
|
|
_storeTile: function(url,base64Str,db,callback){
|
|
var tile = {
|
|
url: url,
|
|
img: base64Str
|
|
};
|
|
|
|
db.store(tile,function(success,err){
|
|
callback(success,err);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Returns a pointer for reading a BUNDLE binary file as based on the given offset.
|
|
* @param buffer
|
|
* @param offset
|
|
* @returns {Uint8}
|
|
* @private
|
|
*/
|
|
_getPointer: function(/* ArrayBuffer */ buffer,offset){
|
|
var snip = buffer.slice(offset);
|
|
var dv = new DataView(snip,0,5);
|
|
|
|
var nume1 = dv.getUint8(0,true);
|
|
var nume2 = dv.getUint8(1,true);
|
|
var nume3 = dv.getUint8(2,true);
|
|
var nume4 = dv.getUint8(3,true);
|
|
var nume5 = dv.getUint8(4,true);
|
|
|
|
var value = nume5;
|
|
value = value * 256 + nume4;
|
|
value = value * 256 + nume3;
|
|
value = value * 256 + nume2;
|
|
value = value * 256 + nume1;
|
|
|
|
return value;
|
|
},
|
|
|
|
/**
|
|
* Convert an ArrayBuffer to base64. My testing shows this to be
|
|
* much faster than combining Blobs and btoa().
|
|
* ALL CREDITS: https://gist.github.com/jonleighton/958841
|
|
* NO licensing listed at the gist repo.
|
|
* @param arrayBuffer
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
_base64ArrayBuffer: function(arrayBuffer) {
|
|
var base64 = ''
|
|
var encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
|
|
|
var bytes = new Uint8Array(arrayBuffer)
|
|
var byteLength = bytes.byteLength
|
|
var byteRemainder = byteLength % 3
|
|
var mainLength = byteLength - byteRemainder
|
|
|
|
var a, b, c, d
|
|
var chunk
|
|
|
|
// Main loop deals with bytes in chunks of 3
|
|
for (var i = 0; i < mainLength; i = i + 3) {
|
|
// Combine the three bytes into a single integer
|
|
chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]
|
|
|
|
// Use bitmasks to extract 6-bit segments from the triplet
|
|
a = (chunk & 16515072) >> 18 // 16515072 = (2^6 - 1) << 18
|
|
b = (chunk & 258048) >> 12 // 258048 = (2^6 - 1) << 12
|
|
c = (chunk & 4032) >> 6 // 4032 = (2^6 - 1) << 6
|
|
d = chunk & 63 // 63 = 2^6 - 1
|
|
|
|
// Convert the raw binary segments to the appropriate ASCII encoding
|
|
base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d]
|
|
}
|
|
|
|
// Deal with the remaining bytes and padding
|
|
if (byteRemainder == 1) {
|
|
chunk = bytes[mainLength]
|
|
|
|
a = (chunk & 252) >> 2 // 252 = (2^6 - 1) << 2
|
|
|
|
// Set the 4 least significant bits to zero
|
|
b = (chunk & 3) << 4 // 3 = 2^2 - 1
|
|
|
|
base64 += encodings[a] + encodings[b] + '=='
|
|
} else if (byteRemainder == 2) {
|
|
chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1]
|
|
|
|
a = (chunk & 64512) >> 10 // 64512 = (2^6 - 1) << 10
|
|
b = (chunk & 1008) >> 4 // 1008 = (2^6 - 1) << 4
|
|
|
|
// Set the 2 least significant bits to zero
|
|
c = (chunk & 15) << 2 // 15 = 2^4 - 1
|
|
|
|
base64 += encodings[a] + encodings[b] + encodings[c] + '='
|
|
}
|
|
|
|
return base64
|
|
},
|
|
|
|
/**
|
|
* Given a ArrayBuffer and a position it will return a Base64 tile image
|
|
* @param arrayBuffer
|
|
* @param position
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
_buffer2Base64: function(/* ArrayBuffer */arrayBuffer,/* int */ position,callback){
|
|
var view = new DataView(arrayBuffer,position);
|
|
var chunk = view.getInt32(0,true);
|
|
var buffer = view.buffer.slice(position + 4,position + 4 + chunk);
|
|
var string = this._base64ArrayBuffer(buffer);
|
|
callback(string);
|
|
},
|
|
|
|
/**
|
|
* Converts an integer to hex
|
|
* @param value
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
_int2HexString: function(/* int */ value){
|
|
var text = value.toString(16).toUpperCase();
|
|
if (text.length === 1)
|
|
{
|
|
return "000" + text;
|
|
}
|
|
if (text.length === 2)
|
|
{
|
|
return "00" + text;
|
|
}
|
|
if (text.length === 3)
|
|
{
|
|
return "0" + text;
|
|
}
|
|
return text.substr(0, text.length);
|
|
},
|
|
|
|
/**
|
|
* Determines where to start reading a BUNDLEX binary file
|
|
* @param level
|
|
* @param row
|
|
* @param col
|
|
* @param startRow
|
|
* @param startCol
|
|
* @returns {number}
|
|
* @private
|
|
*/
|
|
_getOffset: function(/* int */level, /* number */row,/* number */col, /* number */startRow, /* number */ startCol){
|
|
var recordNumber = 128 * (col - startCol) + (row - startRow);
|
|
return 16 + recordNumber * 5;
|
|
},
|
|
|
|
/**
|
|
* Returns a hexadecimal representation of a cache file path
|
|
* @param layerDir
|
|
* @param level
|
|
* @param row
|
|
* @param col
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
_getCacheFilePath: function(/* String */ layerDir, /* int */level, /* int */row, /* int */ col){
|
|
var arr = [];
|
|
|
|
arr.push(layerDir);
|
|
arr.push("/");
|
|
arr.push("L");
|
|
arr.push(level < 10 ? "0" + level : level);
|
|
arr.push("/");
|
|
arr.push("R");
|
|
arr.push(this._int2HexString(row));
|
|
arr.push("C");
|
|
arr.push(this._int2HexString(col));
|
|
|
|
return arr.join("");
|
|
},
|
|
|
|
/**
|
|
* Returns database size in MBs.
|
|
* @returns {string}
|
|
* @private
|
|
*/
|
|
_bytes2MBs: function(bytes){
|
|
return (bytes >>> 20 ) + '.' + ( bytes & (2*0x3FF ) )
|
|
}
|
|
})
|
|
}
|
|
)
|
|
/**
|
|
* Creates a namespace for the non-AMD libraries in this directory
|
|
*/
|
|
|
|
|
|
if(typeof O != "undefined"){
|
|
O.esri.TPK = {}
|
|
}
|
|
else{
|
|
O = {};
|
|
O.esri = {
|
|
TPK: {},
|
|
Tiles: {}
|
|
}
|
|
}
|
|
|
|
"use strict";
|
|
|
|
|
|
/*global indexedDB */
|
|
/**
|
|
* Library for handling the storing of map tiles in IndexedDB.
|
|
*
|
|
* Author: Andy Gup (@agup)
|
|
* Contributor: Javier Abadia (@javierabadia)
|
|
*/
|
|
|
|
O.esri.Tiles.TilesStore = function(){
|
|
/**
|
|
* Internal reference to the local database
|
|
* @type {null}
|
|
* @private
|
|
*/
|
|
this._db = null;
|
|
|
|
var DB_NAME = "offline_tile_store";
|
|
|
|
/**
|
|
* Determines if indexedDB is supported
|
|
* @returns {boolean}
|
|
*/
|
|
this.isSupported = function(){
|
|
|
|
if(!window.indexedDB && !window.openDatabase){
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
/**
|
|
* Adds an object to the database
|
|
* @param urlDataPair
|
|
* @param callback callback(boolean, err)
|
|
*/
|
|
this.store = function(urlDataPair,callback)
|
|
{
|
|
try
|
|
{
|
|
var transaction = this._db.transaction(["tilepath"],"readwrite");
|
|
|
|
transaction.oncomplete = function()
|
|
{
|
|
callback(true);
|
|
};
|
|
|
|
transaction.onerror = function(event)
|
|
{
|
|
callback(false,event.target.error.message);
|
|
};
|
|
|
|
var objectStore = transaction.objectStore("tilepath");
|
|
var request = objectStore.put(urlDataPair);
|
|
request.onsuccess = function()
|
|
{
|
|
//console.log("item added to db " + event.target.result);
|
|
};
|
|
}
|
|
catch(err)
|
|
{
|
|
console.log("TilesStore: " + err.stack);
|
|
callback(false, err.stack);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Retrieve a record.
|
|
* @param url
|
|
* @param callback
|
|
*/
|
|
this.retrieve = function(/* String */ url,callback)
|
|
{
|
|
if(this._db !== null)
|
|
{
|
|
var objectStore = this._db.transaction(["tilepath"]).objectStore("tilepath");
|
|
var request = objectStore.get(url);
|
|
request.onsuccess = function(event)
|
|
{
|
|
var result = event.target.result;
|
|
if(result == undefined)
|
|
{
|
|
callback(false,"not found");
|
|
}
|
|
else
|
|
{
|
|
callback(true,result);
|
|
}
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
console.log(err);
|
|
callback(false, err);
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Deletes entire database
|
|
* @param callback callback(boolean, err)
|
|
*/
|
|
this.deleteAll = function(callback)
|
|
{
|
|
if(this._db !== null)
|
|
{
|
|
var request = this._db.transaction(["tilepath"],"readwrite")
|
|
.objectStore("tilepath")
|
|
.clear();
|
|
request.onsuccess = function()
|
|
{
|
|
callback(true);
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
callback(false, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(false,null);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Delete an individual entry
|
|
* @param url
|
|
* @param callback callback(boolean, err)
|
|
*/
|
|
this.delete = function(/* String */ url,callback)
|
|
{
|
|
if(this._db !== null)
|
|
{
|
|
var request = this._db.transaction(["tilepath"],"readwrite")
|
|
.objectStore("tilepath")
|
|
.delete(url);
|
|
request.onsuccess = function()
|
|
{
|
|
callback(true);
|
|
};
|
|
request.onerror = function(err)
|
|
{
|
|
callback(false, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(false,null);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Retrieve all tiles from indexeddb
|
|
* @param callback callback(url, img, err)
|
|
*/
|
|
this.getAllTiles = function(callback)
|
|
{
|
|
if(this._db !== null){
|
|
var transaction = this._db.transaction(["tilepath"])
|
|
.objectStore("tilepath")
|
|
.openCursor();
|
|
|
|
transaction.onsuccess = function(event)
|
|
{
|
|
var cursor = event.target.result;
|
|
if(cursor){
|
|
var url = cursor.value.url;
|
|
var img = cursor.value.img;
|
|
callback(url,img,null);
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(null, null, "end");
|
|
}
|
|
}.bind(this);
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null, null, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(null, null, "no db");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Provides the size of database in bytes
|
|
* @param callback callback(size, null) or callback(null, error)
|
|
*/
|
|
this.usedSpace = function(callback){
|
|
if(this._db !== null){
|
|
var usage = { sizeBytes: 0, tileCount: 0 };
|
|
|
|
var transaction = this._db.transaction(["tilepath"])
|
|
.objectStore("tilepath")
|
|
.openCursor();
|
|
|
|
transaction.onsuccess = function(event){
|
|
var cursor = event.target.result;
|
|
if(cursor){
|
|
var storedObject = cursor.value;
|
|
var json = JSON.stringify(storedObject);
|
|
usage.sizeBytes += this._stringBytes(json);
|
|
usage.tileCount += 1;
|
|
cursor.continue();
|
|
}
|
|
else
|
|
{
|
|
callback(usage,null);
|
|
}
|
|
}.bind(this);
|
|
transaction.onerror = function(err)
|
|
{
|
|
callback(null, err);
|
|
};
|
|
}
|
|
else
|
|
{
|
|
callback(null,null);
|
|
}
|
|
};
|
|
|
|
this._stringBytes = function(str) {
|
|
return str.length /**2*/ ;
|
|
};
|
|
|
|
this.init = function(callback)
|
|
{
|
|
var request = indexedDB.open(DB_NAME, 4);
|
|
callback = callback || function(success) { console.log("TilesStore::init() success:", success); }.bind(this);
|
|
|
|
request.onerror = function(event)
|
|
{
|
|
console.log("indexedDB error: " + event.target.errorCode);
|
|
callback(false,event.target.errorCode);
|
|
}.bind(this);
|
|
|
|
request.onupgradeneeded = function(event)
|
|
{
|
|
var db = event.target.result;
|
|
|
|
if( db.objectStoreNames.contains("tilepath"))
|
|
{
|
|
db.deleteObjectStore("tilepath");
|
|
}
|
|
|
|
db.createObjectStore("tilepath", { keyPath: "url" });
|
|
}.bind(this);
|
|
|
|
request.onsuccess = function(event)
|
|
{
|
|
this._db = event.target.result;
|
|
console.log("database opened successfully");
|
|
callback(true);
|
|
}.bind(this);
|
|
};
|
|
};
|
|
|
|
|
|
//https://github.com/gildas-lormeau/zip.js/blob/master/WebContent/zip.js
|
|
/*
|
|
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in
|
|
the documentation and/or other materials provided with the distribution.
|
|
|
|
3. The names of the authors may not be used to endorse or promote products
|
|
derived from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
|
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
(function(obj) {
|
|
|
|
var ERR_BAD_FORMAT = "File format is not recognized.";
|
|
var ERR_ENCRYPTED = "File contains encrypted entry.";
|
|
var ERR_ZIP64 = "File is using Zip64 (4gb+ file size).";
|
|
var ERR_READ = "Error while reading zip file.";
|
|
var ERR_WRITE = "Error while writing zip file.";
|
|
var ERR_WRITE_DATA = "Error while writing file data.";
|
|
var ERR_READ_DATA = "Error while reading file data.";
|
|
var ERR_DUPLICATED_NAME = "File already exists.";
|
|
var CHUNK_SIZE = 512 * 1024;
|
|
|
|
var INFLATE_JS = ""; //left blank intentionally! Modified by @agup
|
|
var DEFLATE_JS = "deflate.js";
|
|
|
|
var TEXT_PLAIN = "text/plain";
|
|
|
|
var MESSAGE_EVENT = "message";
|
|
|
|
var appendABViewSupported;
|
|
try {
|
|
appendABViewSupported = new Blob([ new DataView(new ArrayBuffer(0)) ]).size === 0;
|
|
} catch (e) {
|
|
}
|
|
|
|
function Crc32() {
|
|
var crc = -1, that = this;
|
|
that.append = function(data) {
|
|
var offset, table = that.table;
|
|
for (offset = 0; offset < data.length; offset++)
|
|
crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
|
|
};
|
|
that.get = function() {
|
|
return ~crc;
|
|
};
|
|
}
|
|
Crc32.prototype.table = (function() {
|
|
var i, j, t, table = [];
|
|
for (i = 0; i < 256; i++) {
|
|
t = i;
|
|
for (j = 0; j < 8; j++)
|
|
if (t & 1)
|
|
t = (t >>> 1) ^ 0xEDB88320;
|
|
else
|
|
t = t >>> 1;
|
|
table[i] = t;
|
|
}
|
|
return table;
|
|
})();
|
|
|
|
function blobSlice(blob, index, length) {
|
|
if (blob.slice)
|
|
return blob.slice(index, index + length);
|
|
else if (blob.webkitSlice)
|
|
return blob.webkitSlice(index, index + length);
|
|
else if (blob.mozSlice)
|
|
return blob.mozSlice(index, index + length);
|
|
else if (blob.msSlice)
|
|
return blob.msSlice(index, index + length);
|
|
}
|
|
|
|
function getDataHelper(byteLength, bytes) {
|
|
var dataBuffer, dataArray;
|
|
dataBuffer = new ArrayBuffer(byteLength);
|
|
dataArray = new Uint8Array(dataBuffer);
|
|
if (bytes)
|
|
dataArray.set(bytes, 0);
|
|
return {
|
|
buffer : dataBuffer,
|
|
array : dataArray,
|
|
view : new DataView(dataBuffer)
|
|
};
|
|
}
|
|
|
|
// Readers
|
|
function Reader() {
|
|
}
|
|
|
|
function TextReader(text) {
|
|
var that = this, blobReader;
|
|
|
|
function init(callback, onerror) {
|
|
var blob = new Blob([ text ], {
|
|
type : TEXT_PLAIN
|
|
});
|
|
blobReader = new BlobReader(blob);
|
|
blobReader.init(function() {
|
|
that.size = blobReader.size;
|
|
callback();
|
|
}, onerror);
|
|
}
|
|
|
|
function readUint8Array(index, length, callback, onerror) {
|
|
blobReader.readUint8Array(index, length, callback, onerror);
|
|
}
|
|
|
|
that.size = 0;
|
|
that.init = init;
|
|
that.readUint8Array = readUint8Array;
|
|
}
|
|
TextReader.prototype = new Reader();
|
|
TextReader.prototype.constructor = TextReader;
|
|
|
|
function Data64URIReader(dataURI) {
|
|
var that = this, dataStart;
|
|
|
|
function init(callback) {
|
|
var dataEnd = dataURI.length;
|
|
while (dataURI.charAt(dataEnd - 1) == "=")
|
|
dataEnd--;
|
|
dataStart = dataURI.indexOf(",") + 1;
|
|
that.size = Math.floor((dataEnd - dataStart) * 0.75);
|
|
callback();
|
|
}
|
|
|
|
function readUint8Array(index, length, callback) {
|
|
var i, data = getDataHelper(length);
|
|
var start = Math.floor(index / 3) * 4;
|
|
var end = Math.ceil((index + length) / 3) * 4;
|
|
var bytes = obj.atob(dataURI.substring(start + dataStart, end + dataStart));
|
|
var delta = index - Math.floor(start / 4) * 3;
|
|
for (i = delta; i < delta + length; i++)
|
|
data.array[i - delta] = bytes.charCodeAt(i);
|
|
callback(data.array);
|
|
}
|
|
|
|
that.size = 0;
|
|
that.init = init;
|
|
that.readUint8Array = readUint8Array;
|
|
}
|
|
Data64URIReader.prototype = new Reader();
|
|
Data64URIReader.prototype.constructor = Data64URIReader;
|
|
|
|
function BlobReader(blob) {
|
|
var that = this;
|
|
|
|
function init(callback) {
|
|
this.size = blob.size;
|
|
callback();
|
|
}
|
|
|
|
function readUint8Array(index, length, callback, onerror) {
|
|
var reader = new FileReader();
|
|
reader.onload = function(e) {
|
|
callback(new Uint8Array(e.target.result));
|
|
};
|
|
reader.onerror = onerror;
|
|
reader.readAsArrayBuffer(blobSlice(blob, index, length));
|
|
}
|
|
|
|
that.size = 0;
|
|
that.init = init;
|
|
that.readUint8Array = readUint8Array;
|
|
}
|
|
BlobReader.prototype = new Reader();
|
|
BlobReader.prototype.constructor = BlobReader;
|
|
|
|
// Writers
|
|
|
|
function Writer() {
|
|
}
|
|
Writer.prototype.getData = function(callback) {
|
|
callback(this.data);
|
|
};
|
|
|
|
//Added by Andy G. Tracking token
|
|
function TextWriter(token,encoding) {
|
|
var that = this, blob;
|
|
|
|
function init(callback) {
|
|
blob = new Blob([], {
|
|
type: TEXT_PLAIN
|
|
});
|
|
callback();
|
|
}
|
|
|
|
function writeUint8Array(array, callback) {
|
|
blob = new Blob([ blob, appendABViewSupported ? array : array.buffer ], {
|
|
type: TEXT_PLAIN
|
|
});
|
|
callback();
|
|
}
|
|
|
|
function getData(callback, onerror) {
|
|
var reader = new FileReader();
|
|
reader.onload = function (e) {
|
|
var obj = {string: e.target.result,token:token};
|
|
callback(obj);
|
|
};
|
|
reader.onerror = onerror;
|
|
reader.readAsText(blob, encoding);
|
|
}
|
|
|
|
that.init = init;
|
|
that.writeUint8Array = writeUint8Array;
|
|
that.getData = getData;
|
|
}
|
|
TextWriter.prototype = new Writer();
|
|
TextWriter.prototype.constructor = TextWriter;
|
|
|
|
function Data64URIWriter(contentType) {
|
|
var that = this, data = "", pending = "";
|
|
|
|
function init(callback) {
|
|
data += "data:" + (contentType || "") + ";base64,";
|
|
callback();
|
|
}
|
|
|
|
function writeUint8Array(array, callback) {
|
|
var i, delta = pending.length, dataString = pending;
|
|
pending = "";
|
|
for (i = 0; i < (Math.floor((delta + array.length) / 3) * 3) - delta; i++)
|
|
dataString += String.fromCharCode(array[i]);
|
|
for (; i < array.length; i++)
|
|
pending += String.fromCharCode(array[i]);
|
|
if (dataString.length > 2)
|
|
data += obj.btoa(dataString);
|
|
else
|
|
pending = dataString;
|
|
callback();
|
|
}
|
|
|
|
function getData(callback) {
|
|
callback(data + obj.btoa(pending));
|
|
}
|
|
|
|
that.init = init;
|
|
that.writeUint8Array = writeUint8Array;
|
|
that.getData = getData;
|
|
}
|
|
Data64URIWriter.prototype = new Writer();
|
|
Data64URIWriter.prototype.constructor = Data64URIWriter;
|
|
|
|
//Added by Andy G. Tracking token
|
|
function BlobWriter(token,contentType) {
|
|
var blob, that = this ;
|
|
|
|
function init(callback) {
|
|
blob = new Blob([], {
|
|
type: contentType
|
|
});
|
|
callback();
|
|
}
|
|
|
|
function writeUint8Array(array, callback) {
|
|
blob = new Blob([ blob, appendABViewSupported ? array : array.buffer ], {
|
|
type: contentType
|
|
});
|
|
blob.token = token;
|
|
callback();
|
|
}
|
|
|
|
function getData(callback) {
|
|
callback(blob);
|
|
}
|
|
|
|
that.init = init;
|
|
that.writeUint8Array = writeUint8Array;
|
|
that.getData = getData;
|
|
}
|
|
BlobWriter.prototype = new Writer();
|
|
BlobWriter.prototype.constructor = BlobWriter;
|
|
|
|
// inflate/deflate core functions
|
|
|
|
function launchWorkerProcess(worker, reader, writer, offset, size, onappend, onprogress, onend, onreaderror, onwriteerror) {
|
|
var chunkIndex = 0, index, outputSize;
|
|
|
|
function onflush() {
|
|
worker.removeEventListener(MESSAGE_EVENT, onmessage, false);
|
|
onend(outputSize);
|
|
}
|
|
|
|
function onmessage(event) {
|
|
var message = event.data, data = message.data;
|
|
|
|
if (message.onappend) {
|
|
outputSize += data.length;
|
|
writer.writeUint8Array(data, function() {
|
|
onappend(false, data);
|
|
step();
|
|
}, onwriteerror);
|
|
}
|
|
if (message.onflush)
|
|
if (data) {
|
|
outputSize += data.length;
|
|
writer.writeUint8Array(data, function() {
|
|
onappend(false, data);
|
|
onflush();
|
|
}, onwriteerror);
|
|
} else
|
|
onflush();
|
|
if (message.progress && onprogress)
|
|
onprogress(index + message.current, size);
|
|
}
|
|
|
|
function step() {
|
|
index = chunkIndex * CHUNK_SIZE;
|
|
if (index < size)
|
|
reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(array) {
|
|
worker.postMessage({
|
|
append : true,
|
|
data : array
|
|
});
|
|
chunkIndex++;
|
|
if (onprogress)
|
|
onprogress(index, size);
|
|
onappend(true, array);
|
|
}, onreaderror);
|
|
else
|
|
worker.postMessage({
|
|
flush : true
|
|
});
|
|
}
|
|
|
|
outputSize = 0;
|
|
worker.addEventListener(MESSAGE_EVENT, onmessage, false);
|
|
step();
|
|
}
|
|
|
|
function launchProcess(process, reader, writer, offset, size, onappend, onprogress, onend, onreaderror, onwriteerror) {
|
|
var chunkIndex = 0, index, outputSize = 0;
|
|
|
|
function step() {
|
|
var outputData;
|
|
index = chunkIndex * CHUNK_SIZE;
|
|
if (index < size)
|
|
reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(inputData) {
|
|
var outputData = process.append(inputData, function() {
|
|
if (onprogress)
|
|
onprogress(offset + index, size);
|
|
});
|
|
outputSize += outputData.length;
|
|
onappend(true, inputData);
|
|
writer.writeUint8Array(outputData, function() {
|
|
onappend(false, outputData);
|
|
chunkIndex++;
|
|
setTimeout(step, 1);
|
|
}, onwriteerror);
|
|
if (onprogress)
|
|
onprogress(index, size);
|
|
}, onreaderror);
|
|
else {
|
|
outputData = process.flush();
|
|
if (outputData) {
|
|
outputSize += outputData.length;
|
|
writer.writeUint8Array(outputData, function() {
|
|
onappend(false, outputData);
|
|
onend(outputSize);
|
|
}, onwriteerror);
|
|
} else
|
|
onend(outputSize);
|
|
}
|
|
}
|
|
|
|
step();
|
|
}
|
|
|
|
function inflate(reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) {
|
|
var worker, crc32 = new Crc32();
|
|
|
|
function oninflateappend(sending, array) {
|
|
if (computeCrc32 && !sending)
|
|
crc32.append(array);
|
|
}
|
|
|
|
function oninflateend(outputSize) {
|
|
onend(outputSize, crc32.get());
|
|
}
|
|
|
|
if (obj.zip.useWebWorkers) {
|
|
|
|
worker = new Worker(obj.zip.workerScriptsPath + INFLATE_JS);
|
|
launchWorkerProcess(worker, reader, writer, offset, size, oninflateappend, onprogress, oninflateend, onreaderror, onwriteerror);
|
|
} else
|
|
launchProcess(new obj.zip.Inflater(), reader, writer, offset, size, oninflateappend, onprogress, oninflateend, onreaderror, onwriteerror);
|
|
return worker;
|
|
}
|
|
|
|
function deflate(reader, writer, level, onend, onprogress, onreaderror, onwriteerror) {
|
|
var worker, crc32 = new Crc32();
|
|
|
|
function ondeflateappend(sending, array) {
|
|
if (sending)
|
|
crc32.append(array);
|
|
}
|
|
|
|
function ondeflateend(outputSize) {
|
|
onend(outputSize, crc32.get());
|
|
}
|
|
|
|
function onmessage() {
|
|
worker.removeEventListener(MESSAGE_EVENT, onmessage, false);
|
|
launchWorkerProcess(worker, reader, writer, 0, reader.size, ondeflateappend, onprogress, ondeflateend, onreaderror, onwriteerror);
|
|
}
|
|
|
|
if (obj.zip.useWebWorkers) {
|
|
worker = new Worker(obj.zip.workerScriptsPath + DEFLATE_JS);
|
|
worker.addEventListener(MESSAGE_EVENT, onmessage, false);
|
|
worker.postMessage({
|
|
init : true,
|
|
level : level
|
|
});
|
|
} else
|
|
launchProcess(new obj.zip.Deflater(), reader, writer, 0, reader.size, ondeflateappend, onprogress, ondeflateend, onreaderror, onwriteerror);
|
|
return worker;
|
|
}
|
|
|
|
function copy(reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) {
|
|
var chunkIndex = 0, crc32 = new Crc32();
|
|
|
|
function step() {
|
|
var index = chunkIndex * CHUNK_SIZE;
|
|
if (index < size)
|
|
reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(array) {
|
|
if (computeCrc32)
|
|
crc32.append(array);
|
|
if (onprogress)
|
|
onprogress(index, size, array);
|
|
writer.writeUint8Array(array, function() {
|
|
chunkIndex++;
|
|
step();
|
|
}, onwriteerror);
|
|
}, onreaderror);
|
|
else
|
|
onend(size, crc32.get());
|
|
}
|
|
|
|
step();
|
|
}
|
|
|
|
// ZipReader
|
|
|
|
function decodeASCII(str) {
|
|
var i, out = "", charCode, extendedASCII = [ '\u00C7', '\u00FC', '\u00E9', '\u00E2', '\u00E4', '\u00E0', '\u00E5', '\u00E7', '\u00EA', '\u00EB',
|
|
'\u00E8', '\u00EF', '\u00EE', '\u00EC', '\u00C4', '\u00C5', '\u00C9', '\u00E6', '\u00C6', '\u00F4', '\u00F6', '\u00F2', '\u00FB', '\u00F9',
|
|
'\u00FF', '\u00D6', '\u00DC', '\u00F8', '\u00A3', '\u00D8', '\u00D7', '\u0192', '\u00E1', '\u00ED', '\u00F3', '\u00FA', '\u00F1', '\u00D1',
|
|
'\u00AA', '\u00BA', '\u00BF', '\u00AE', '\u00AC', '\u00BD', '\u00BC', '\u00A1', '\u00AB', '\u00BB', '_', '_', '_', '\u00A6', '\u00A6',
|
|
'\u00C1', '\u00C2', '\u00C0', '\u00A9', '\u00A6', '\u00A6', '+', '+', '\u00A2', '\u00A5', '+', '+', '-', '-', '+', '-', '+', '\u00E3',
|
|
'\u00C3', '+', '+', '-', '-', '\u00A6', '-', '+', '\u00A4', '\u00F0', '\u00D0', '\u00CA', '\u00CB', '\u00C8', 'i', '\u00CD', '\u00CE',
|
|
'\u00CF', '+', '+', '_', '_', '\u00A6', '\u00CC', '_', '\u00D3', '\u00DF', '\u00D4', '\u00D2', '\u00F5', '\u00D5', '\u00B5', '\u00FE',
|
|
'\u00DE', '\u00DA', '\u00DB', '\u00D9', '\u00FD', '\u00DD', '\u00AF', '\u00B4', '\u00AD', '\u00B1', '_', '\u00BE', '\u00B6', '\u00A7',
|
|
'\u00F7', '\u00B8', '\u00B0', '\u00A8', '\u00B7', '\u00B9', '\u00B3', '\u00B2', '_', ' ' ];
|
|
for (i = 0; i < str.length; i++) {
|
|
charCode = str.charCodeAt(i) & 0xFF;
|
|
if (charCode > 127)
|
|
out += extendedASCII[charCode - 128];
|
|
else
|
|
out += String.fromCharCode(charCode);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function decodeUTF8(string) {
|
|
return decodeURIComponent(escape(string));
|
|
}
|
|
|
|
function getString(bytes) {
|
|
var i, str = "";
|
|
for (i = 0; i < bytes.length; i++)
|
|
str += String.fromCharCode(bytes[i]);
|
|
return str;
|
|
}
|
|
|
|
function getDate(timeRaw) {
|
|
var date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & 0x0000ffff;
|
|
try {
|
|
return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5,
|
|
(time & 0x001F) * 2, 0);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
|
|
function readCommonHeader(entry, data, index, centralDirectory, onerror) {
|
|
entry.version = data.view.getUint16(index, true);
|
|
entry.bitFlag = data.view.getUint16(index + 2, true);
|
|
entry.compressionMethod = data.view.getUint16(index + 4, true);
|
|
entry.lastModDateRaw = data.view.getUint32(index + 6, true);
|
|
entry.lastModDate = getDate(entry.lastModDateRaw);
|
|
if ((entry.bitFlag & 0x01) === 0x01) {
|
|
onerror(ERR_ENCRYPTED);
|
|
return;
|
|
}
|
|
if (centralDirectory || (entry.bitFlag & 0x0008) != 0x0008) {
|
|
entry.crc32 = data.view.getUint32(index + 10, true);
|
|
entry.compressedSize = data.view.getUint32(index + 14, true);
|
|
entry.uncompressedSize = data.view.getUint32(index + 18, true);
|
|
}
|
|
if (entry.compressedSize === 0xFFFFFFFF || entry.uncompressedSize === 0xFFFFFFFF) {
|
|
onerror(ERR_ZIP64);
|
|
return;
|
|
}
|
|
entry.filenameLength = data.view.getUint16(index + 22, true);
|
|
entry.extraFieldLength = data.view.getUint16(index + 24, true);
|
|
}
|
|
|
|
function createZipReader(reader, onerror) {
|
|
function Entry() {
|
|
}
|
|
|
|
Entry.prototype.getData = function(writer, onend, onprogress, checkCrc32) {
|
|
var that = this, worker;
|
|
|
|
function terminate(callback, param) {
|
|
if (worker)
|
|
worker.terminate();
|
|
worker = null;
|
|
if (callback)
|
|
callback(param);
|
|
}
|
|
|
|
function testCrc32(crc32) {
|
|
var dataCrc32 = getDataHelper(4);
|
|
dataCrc32.view.setUint32(0, crc32);
|
|
return that.crc32 == dataCrc32.view.getUint32(0);
|
|
}
|
|
|
|
function getWriterData(uncompressedSize, crc32) {
|
|
if (checkCrc32 && !testCrc32(crc32))
|
|
onreaderror();
|
|
else
|
|
writer.getData(function(data) {
|
|
terminate(onend, data);
|
|
});
|
|
}
|
|
|
|
function onreaderror() {
|
|
terminate(onerror, ERR_READ_DATA);
|
|
}
|
|
|
|
function onwriteerror() {
|
|
terminate(onerror, ERR_WRITE_DATA);
|
|
}
|
|
|
|
reader.readUint8Array(that.offset, 30, function(bytes) {
|
|
var data = getDataHelper(bytes.length, bytes), dataOffset;
|
|
if (data.view.getUint32(0) != 0x504b0304) {
|
|
onerror(ERR_BAD_FORMAT);
|
|
return;
|
|
}
|
|
readCommonHeader(that, data, 4, false, onerror);
|
|
dataOffset = that.offset + 30 + that.filenameLength + that.extraFieldLength;
|
|
writer.init(function() {
|
|
if (that.compressionMethod === 0)
|
|
copy(reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror);
|
|
else
|
|
worker = inflate(reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror);
|
|
}, onwriteerror);
|
|
}, onreaderror);
|
|
};
|
|
|
|
function seekEOCDR(offset, entriesCallback) {
|
|
reader.readUint8Array(reader.size - offset, offset, function(bytes) {
|
|
var dataView = getDataHelper(bytes.length, bytes).view;
|
|
if (dataView.getUint32(0) != 0x504b0506) {
|
|
seekEOCDR(offset + 1, entriesCallback);
|
|
} else {
|
|
entriesCallback(dataView);
|
|
}
|
|
}, function() {
|
|
onerror(ERR_READ);
|
|
});
|
|
}
|
|
|
|
return {
|
|
getEntries : function(callback) {
|
|
if (reader.size < 22) {
|
|
onerror(ERR_BAD_FORMAT);
|
|
return;
|
|
}
|
|
// look for End of central directory record
|
|
seekEOCDR(22, function(dataView) {
|
|
var datalength, fileslength;
|
|
datalength = dataView.getUint32(16, true);
|
|
fileslength = dataView.getUint16(8, true);
|
|
reader.readUint8Array(datalength, reader.size - datalength, function(bytes) {
|
|
var i, index = 0, entries = [], entry, filename, comment, data = getDataHelper(bytes.length, bytes);
|
|
for (i = 0; i < fileslength; i++) {
|
|
entry = new Entry();
|
|
if (data.view.getUint32(index) != 0x504b0102) {
|
|
onerror(ERR_BAD_FORMAT);
|
|
return;
|
|
}
|
|
readCommonHeader(entry, data, index + 6, true, onerror);
|
|
entry.commentLength = data.view.getUint16(index + 32, true);
|
|
entry.directory = ((data.view.getUint8(index + 38) & 0x10) == 0x10);
|
|
entry.offset = data.view.getUint32(index + 42, true);
|
|
filename = getString(data.array.subarray(index + 46, index + 46 + entry.filenameLength));
|
|
entry.filename = ((entry.bitFlag & 0x0800) === 0x0800) ? decodeUTF8(filename) : decodeASCII(filename);
|
|
if (!entry.directory && entry.filename.charAt(entry.filename.length - 1) == "/")
|
|
entry.directory = true;
|
|
comment = getString(data.array.subarray(index + 46 + entry.filenameLength + entry.extraFieldLength, index + 46
|
|
+ entry.filenameLength + entry.extraFieldLength + entry.commentLength));
|
|
entry.comment = ((entry.bitFlag & 0x0800) === 0x0800) ? decodeUTF8(comment) : decodeASCII(comment);
|
|
entries.push(entry);
|
|
index += 46 + entry.filenameLength + entry.extraFieldLength + entry.commentLength;
|
|
}
|
|
callback(entries);
|
|
}, function() {
|
|
onerror(ERR_READ);
|
|
});
|
|
});
|
|
},
|
|
close : function(callback) {
|
|
if (callback)
|
|
callback();
|
|
}
|
|
};
|
|
}
|
|
|
|
// ZipWriter
|
|
|
|
function encodeUTF8(string) {
|
|
return unescape(encodeURIComponent(string));
|
|
}
|
|
|
|
function getBytes(str) {
|
|
var i, array = [];
|
|
for (i = 0; i < str.length; i++)
|
|
array.push(str.charCodeAt(i));
|
|
return array;
|
|
}
|
|
|
|
function createZipWriter(writer, onerror, dontDeflate) {
|
|
var worker, files = {}, filenames = [], datalength = 0;
|
|
|
|
function terminate(callback, message) {
|
|
if (worker)
|
|
worker.terminate();
|
|
worker = null;
|
|
if (callback)
|
|
callback(message);
|
|
}
|
|
|
|
function onwriteerror() {
|
|
terminate(onerror, ERR_WRITE);
|
|
}
|
|
|
|
function onreaderror() {
|
|
terminate(onerror, ERR_READ_DATA);
|
|
}
|
|
|
|
return {
|
|
add : function(name, reader, onend, onprogress, options) {
|
|
var header, filename, date;
|
|
|
|
function writeHeader(callback) {
|
|
var data;
|
|
date = options.lastModDate || new Date();
|
|
header = getDataHelper(26);
|
|
files[name] = {
|
|
headerArray : header.array,
|
|
directory : options.directory,
|
|
filename : filename,
|
|
offset : datalength,
|
|
comment : getBytes(encodeUTF8(options.comment || ""))
|
|
};
|
|
header.view.setUint32(0, 0x14000808);
|
|
if (options.version)
|
|
header.view.setUint8(0, options.version);
|
|
if (!dontDeflate && options.level !== 0 && !options.directory)
|
|
header.view.setUint16(4, 0x0800);
|
|
header.view.setUint16(6, (((date.getHours() << 6) | date.getMinutes()) << 5) | date.getSeconds() / 2, true);
|
|
header.view.setUint16(8, ((((date.getFullYear() - 1980) << 4) | (date.getMonth() + 1)) << 5) | date.getDate(), true);
|
|
header.view.setUint16(22, filename.length, true);
|
|
data = getDataHelper(30 + filename.length);
|
|
data.view.setUint32(0, 0x504b0304);
|
|
data.array.set(header.array, 4);
|
|
data.array.set(filename, 30);
|
|
datalength += data.array.length;
|
|
writer.writeUint8Array(data.array, callback, onwriteerror);
|
|
}
|
|
|
|
function writeFooter(compressedLength, crc32) {
|
|
var footer = getDataHelper(16);
|
|
datalength += compressedLength || 0;
|
|
footer.view.setUint32(0, 0x504b0708);
|
|
if (typeof crc32 != "undefined") {
|
|
header.view.setUint32(10, crc32, true);
|
|
footer.view.setUint32(4, crc32, true);
|
|
}
|
|
if (reader) {
|
|
footer.view.setUint32(8, compressedLength, true);
|
|
header.view.setUint32(14, compressedLength, true);
|
|
footer.view.setUint32(12, reader.size, true);
|
|
header.view.setUint32(18, reader.size, true);
|
|
}
|
|
writer.writeUint8Array(footer.array, function() {
|
|
datalength += 16;
|
|
terminate(onend);
|
|
}, onwriteerror);
|
|
}
|
|
|
|
function writeFile() {
|
|
options = options || {};
|
|
name = name.trim();
|
|
if (options.directory && name.charAt(name.length - 1) != "/")
|
|
name += "/";
|
|
if (files.hasOwnProperty(name)) {
|
|
onerror(ERR_DUPLICATED_NAME);
|
|
return;
|
|
}
|
|
filename = getBytes(encodeUTF8(name));
|
|
filenames.push(name);
|
|
writeHeader(function() {
|
|
if (reader)
|
|
if (dontDeflate || options.level === 0)
|
|
copy(reader, writer, 0, reader.size, true, writeFooter, onprogress, onreaderror, onwriteerror);
|
|
else
|
|
worker = deflate(reader, writer, options.level, writeFooter, onprogress, onreaderror, onwriteerror);
|
|
else
|
|
writeFooter();
|
|
}, onwriteerror);
|
|
}
|
|
|
|
if (reader)
|
|
reader.init(writeFile, onreaderror);
|
|
else
|
|
writeFile();
|
|
},
|
|
close : function(callback) {
|
|
var data, length = 0, index = 0, indexFilename, file;
|
|
for (indexFilename = 0; indexFilename < filenames.length; indexFilename++) {
|
|
file = files[filenames[indexFilename]];
|
|
length += 46 + file.filename.length + file.comment.length;
|
|
}
|
|
data = getDataHelper(length + 22);
|
|
for (indexFilename = 0; indexFilename < filenames.length; indexFilename++) {
|
|
file = files[filenames[indexFilename]];
|
|
data.view.setUint32(index, 0x504b0102);
|
|
data.view.setUint16(index + 4, 0x1400);
|
|
data.array.set(file.headerArray, index + 6);
|
|
data.view.setUint16(index + 32, file.comment.length, true);
|
|
if (file.directory)
|
|
data.view.setUint8(index + 38, 0x10);
|
|
data.view.setUint32(index + 42, file.offset, true);
|
|
data.array.set(file.filename, index + 46);
|
|
data.array.set(file.comment, index + 46 + file.filename.length);
|
|
index += 46 + file.filename.length + file.comment.length;
|
|
}
|
|
data.view.setUint32(index, 0x504b0506);
|
|
data.view.setUint16(index + 8, filenames.length, true);
|
|
data.view.setUint16(index + 10, filenames.length, true);
|
|
data.view.setUint32(index + 12, length, true);
|
|
data.view.setUint32(index + 16, datalength, true);
|
|
writer.writeUint8Array(data.array, function() {
|
|
terminate(function() {
|
|
writer.getData(callback);
|
|
});
|
|
}, onwriteerror);
|
|
}
|
|
};
|
|
}
|
|
|
|
obj.zip = {
|
|
Reader : Reader,
|
|
Writer : Writer,
|
|
BlobReader : BlobReader,
|
|
Data64URIReader : Data64URIReader,
|
|
TextReader : TextReader,
|
|
BlobWriter : BlobWriter,
|
|
Data64URIWriter : Data64URIWriter,
|
|
TextWriter : TextWriter,
|
|
createReader : function(reader, callback, onerror) {
|
|
reader.init(function() {
|
|
callback(createZipReader(reader, onerror));
|
|
}, onerror);
|
|
},
|
|
createWriter : function(writer, callback, onerror, dontDeflate) {
|
|
writer.init(function() {
|
|
callback(createZipWriter(writer, onerror, dontDeflate));
|
|
}, onerror);
|
|
},
|
|
workerScriptsPath : "",
|
|
useWebWorkers : true
|
|
};
|
|
|
|
}(O.esri));
|
|
/**
|
|
* This library assists with autoCenter the map upon orientation change
|
|
* IMPORTANT: There are Esri dependencies in this library including
|
|
* esri.Geometry.Point, esri.SpatialReference and Esri.Map.
|
|
* The fact that these dependencies exist is implied that they were
|
|
* loaded via some other means and made globally available.
|
|
* Sometimes this happens by default, as is true in this case.
|
|
* @param map
|
|
* @param delay
|
|
*/
|
|
O.esri.TPK.autoCenterMap = function(/* Map */ map,/* int */ delay){
|
|
|
|
/**
|
|
* Activates the orientation listener and listens for native events.
|
|
*/
|
|
function _setOrientationListener(delay){
|
|
var supportsOrientationChange = "onorientationchange" in window,
|
|
orientationEvent = supportsOrientationChange ? "orientationchange" : "resize";
|
|
|
|
window.addEventListener(orientationEvent, _debounceMap(function(){
|
|
_centerMap();
|
|
},delay))
|
|
}
|
|
|
|
/**
|
|
* Center the map based on locations pulled from local storage
|
|
* @param context
|
|
* @param delay
|
|
* @private
|
|
*/
|
|
function _centerMap(){
|
|
var locationStr = _getCenterPt().split(",");
|
|
var wkid = map.spatialReference.wkid;
|
|
var mapPt = null;
|
|
|
|
if(wkid == 4326){
|
|
mapPt = new esri.geometry.Point(locationStr[1],locationStr[0]);
|
|
}
|
|
else if(wkid = 102100){
|
|
mapPt = new esri.geometry.Point(locationStr[0],locationStr[1], new esri.SpatialReference({ wkid: wkid }));
|
|
}
|
|
map.centerAt(mapPt);
|
|
}
|
|
|
|
/**
|
|
* Minimize the number of times window readjustment fires a function
|
|
* http://davidwalsh.name/javascript-debounce-function
|
|
* @param func
|
|
* @param wait
|
|
* @param immediate
|
|
* @returns {Function}
|
|
*/
|
|
function _debounceMap(func, wait, immediate) {
|
|
var timeout;
|
|
return function() {
|
|
var context = this, args = arguments;
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(function() {
|
|
timeout = null;
|
|
if (!immediate) func.apply(context, args);
|
|
}, wait);
|
|
if (immediate && !timeout) func.apply(context, args);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Automatically sets new center point in local storage.
|
|
*/
|
|
function _setPanListener(){
|
|
map.on("pan-end",function(){
|
|
var center = map.extent.getCenter();
|
|
_setCenterPt(center.x,center.y,map.spatialReference.wkid);
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Automatically sets new center point and zoom level in
|
|
* local storage.
|
|
*/
|
|
function _setZoomListener(){
|
|
map.on("zoom-end",function(){
|
|
var center = map.extent.getCenter();
|
|
_setCenterPt(center.x,center.y,map.spatialReference.wkid);
|
|
map.setZoom(map.getZoom());
|
|
}.bind(self))
|
|
}
|
|
|
|
/**
|
|
* Uses localStorage to save a location.
|
|
* @param lat
|
|
* @param lon
|
|
* @param spatialReference
|
|
*/
|
|
function _setCenterPt(lat,lon,spatialReference){
|
|
localStorage.setItem("_centerPtX", lat);
|
|
localStorage.setItem("_centerPtY", lon);
|
|
localStorage.setItem("_spatialReference", spatialReference);
|
|
}
|
|
|
|
/**
|
|
* Pulls a saved location from localStorage
|
|
* Requires that setCenterPt() has been set.
|
|
* @returns String x,y,spatialReference
|
|
*/
|
|
function _getCenterPt(){
|
|
var value = null;
|
|
|
|
try{
|
|
value = localStorage.getItem("_centerPtX") + "," + localStorage.getItem("_centerPtY") + "," +
|
|
localStorage.getItem("_spatialReference");
|
|
}
|
|
catch(err)
|
|
{
|
|
console.log("getCenterFromLocalStorage: " + err.message);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
this.init = function(){
|
|
_setPanListener();
|
|
_setZoomListener();
|
|
_setOrientationListener(delay);
|
|
var centerPt = map.extent.getCenter();
|
|
_setCenterPt(centerPt.x,centerPt.y,map.spatialReference.wkid);
|
|
}
|
|
}
|
|
/*
|
|
Copyright (c) 2013 Gildas Lormeau. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in
|
|
the documentation and/or other materials provided with the distribution.
|
|
|
|
3. The names of the authors may not be used to endorse or promote products
|
|
derived from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
|
|
INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
|
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* This program is based on JZlib 1.0.2 ymnk, JCraft,Inc.
|
|
* JZlib is based on zlib-1.1.3, so all credit should go authors
|
|
* Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
|
|
* and contributors of zlib.
|
|
*/
|
|
|
|
O.esri.TPK.inflate = function(obj) {
|
|
|
|
// Global
|
|
var MAX_BITS = 15;
|
|
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_NEED_DICT = 2;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_MEM_ERROR = -4;
|
|
var Z_BUF_ERROR = -5;
|
|
|
|
var inflate_mask = [ 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff,
|
|
0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff ];
|
|
|
|
var MANY = 1440;
|
|
|
|
// JZlib version : "1.0.2"
|
|
var Z_NO_FLUSH = 0;
|
|
var Z_FINISH = 4;
|
|
|
|
// InfTree
|
|
var fixed_bl = 9;
|
|
var fixed_bd = 5;
|
|
|
|
var fixed_tl = [ 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0,
|
|
0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40,
|
|
0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13,
|
|
0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60,
|
|
0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7,
|
|
35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8,
|
|
26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80,
|
|
7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0,
|
|
8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0,
|
|
8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97,
|
|
0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210,
|
|
81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117,
|
|
0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154,
|
|
84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83,
|
|
0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230,
|
|
80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139,
|
|
0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174,
|
|
0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111,
|
|
0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9,
|
|
193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8,
|
|
120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8,
|
|
227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8,
|
|
92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9,
|
|
249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8,
|
|
130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9,
|
|
181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8,
|
|
102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9,
|
|
221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0,
|
|
8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9,
|
|
147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8,
|
|
85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9,
|
|
235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8,
|
|
141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9,
|
|
167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8,
|
|
107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9,
|
|
207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8,
|
|
127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255 ];
|
|
var fixed_td = [ 80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5,
|
|
8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5,
|
|
24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577 ];
|
|
|
|
// Tables for deflate from PKZIP's appnote.txt.
|
|
var cplens = [ // Copy lengths for literal codes 257..285
|
|
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 ];
|
|
|
|
// see note #13 above about 258
|
|
var cplext = [ // Extra bits for literal codes 257..285
|
|
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112 // 112==invalid
|
|
];
|
|
|
|
var cpdist = [ // Copy offsets for distance codes 0..29
|
|
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 ];
|
|
|
|
var cpdext = [ // Extra bits for distance codes
|
|
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 ];
|
|
|
|
// If BMAX needs to be larger than 16, then h and x[] should be uLong.
|
|
var BMAX = 15; // maximum bit length of any code
|
|
|
|
function InfTree() {
|
|
var that = this;
|
|
|
|
var hn; // hufts used in space
|
|
var v; // work area for huft_build
|
|
var c; // bit length count table
|
|
var r; // table entry for structure assignment
|
|
var u; // table stack
|
|
var x; // bit offsets, then code stack
|
|
|
|
function huft_build(b, // code lengths in bits (all assumed <=
|
|
// BMAX)
|
|
bindex, n, // number of codes (assumed <= 288)
|
|
s, // number of simple-valued codes (0..s-1)
|
|
d, // list of base values for non-simple codes
|
|
e, // list of extra bits for non-simple codes
|
|
t, // result: starting table
|
|
m, // maximum lookup bits, returns actual
|
|
hp,// space for trees
|
|
hn,// hufts used in space
|
|
v // working area: values in order of bit length
|
|
) {
|
|
// Given a list of code lengths and a maximum table size, make a set of
|
|
// tables to decode that set of codes. Return Z_OK on success,
|
|
// Z_BUF_ERROR
|
|
// if the given code set is incomplete (the tables are still built in
|
|
// this
|
|
// case), Z_DATA_ERROR if the input is invalid (an over-subscribed set
|
|
// of
|
|
// lengths), or Z_MEM_ERROR if not enough memory.
|
|
|
|
var a; // counter for codes of length k
|
|
var f; // i repeats in table every f entries
|
|
var g; // maximum code length
|
|
var h; // table level
|
|
var i; // counter, current code
|
|
var j; // counter
|
|
var k; // number of bits in current code
|
|
var l; // bits per table (returned in m)
|
|
var mask; // (1 << w) - 1, to avoid cc -O bug on HP
|
|
var p; // pointer into c[], b[], or v[]
|
|
var q; // points to current table
|
|
var w; // bits before this table == (l * h)
|
|
var xp; // pointer into x
|
|
var y; // number of dummy codes added
|
|
var z; // number of entries in current table
|
|
|
|
// Generate counts for each bit length
|
|
|
|
p = 0;
|
|
i = n;
|
|
do {
|
|
c[b[bindex + p]]++;
|
|
p++;
|
|
i--; // assume all entries <= BMAX
|
|
} while (i !== 0);
|
|
|
|
if (c[0] == n) { // null input--all zero length codes
|
|
t[0] = -1;
|
|
m[0] = 0;
|
|
return Z_OK;
|
|
}
|
|
|
|
// Find minimum and maximum length, bound *m by those
|
|
l = m[0];
|
|
for (j = 1; j <= BMAX; j++)
|
|
if (c[j] !== 0)
|
|
break;
|
|
k = j; // minimum code length
|
|
if (l < j) {
|
|
l = j;
|
|
}
|
|
for (i = BMAX; i !== 0; i--) {
|
|
if (c[i] !== 0)
|
|
break;
|
|
}
|
|
g = i; // maximum code length
|
|
if (l > i) {
|
|
l = i;
|
|
}
|
|
m[0] = l;
|
|
|
|
// Adjust last length count to fill out codes, if needed
|
|
for (y = 1 << j; j < i; j++, y <<= 1) {
|
|
if ((y -= c[j]) < 0) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
}
|
|
if ((y -= c[i]) < 0) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
c[i] += y;
|
|
|
|
// Generate starting offsets into the value table for each length
|
|
x[1] = j = 0;
|
|
p = 1;
|
|
xp = 2;
|
|
while (--i !== 0) { // note that i == g from above
|
|
x[xp] = (j += c[p]);
|
|
xp++;
|
|
p++;
|
|
}
|
|
|
|
// Make a table of values in order of bit lengths
|
|
i = 0;
|
|
p = 0;
|
|
do {
|
|
if ((j = b[bindex + p]) !== 0) {
|
|
v[x[j]++] = i;
|
|
}
|
|
p++;
|
|
} while (++i < n);
|
|
n = x[g]; // set n to length of v
|
|
|
|
// Generate the Huffman codes and for each, make the table entries
|
|
x[0] = i = 0; // first Huffman code is zero
|
|
p = 0; // grab values in bit order
|
|
h = -1; // no tables yet--level -1
|
|
w = -l; // bits decoded == (l * h)
|
|
u[0] = 0; // just to keep compilers happy
|
|
q = 0; // ditto
|
|
z = 0; // ditto
|
|
|
|
// go through the bit lengths (k already is bits in shortest code)
|
|
for (; k <= g; k++) {
|
|
a = c[k];
|
|
while (a-- !== 0) {
|
|
// here i is the Huffman code of length k bits for value *p
|
|
// make tables up to required level
|
|
while (k > w + l) {
|
|
h++;
|
|
w += l; // previous table always l bits
|
|
// compute minimum size table less than or equal to l bits
|
|
z = g - w;
|
|
z = (z > l) ? l : z; // table size upper limit
|
|
if ((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table
|
|
// too few codes for
|
|
// k-w bit table
|
|
f -= a + 1; // deduct codes from patterns left
|
|
xp = k;
|
|
if (j < z) {
|
|
while (++j < z) { // try smaller tables up to z bits
|
|
if ((f <<= 1) <= c[++xp])
|
|
break; // enough codes to use up j bits
|
|
f -= c[xp]; // else deduct codes from patterns
|
|
}
|
|
}
|
|
}
|
|
z = 1 << j; // table entries for j-bit table
|
|
|
|
// allocate new table
|
|
if (hn[0] + z > MANY) { // (note: doesn't matter for fixed)
|
|
return Z_DATA_ERROR; // overflow of MANY
|
|
}
|
|
u[h] = q = /* hp+ */hn[0]; // DEBUG
|
|
hn[0] += z;
|
|
|
|
// connect to last table, if there is one
|
|
if (h !== 0) {
|
|
x[h] = i; // save pattern for backing up
|
|
r[0] = /* (byte) */j; // bits in this table
|
|
r[1] = /* (byte) */l; // bits to dump before this table
|
|
j = i >>> (w - l);
|
|
r[2] = /* (int) */(q - u[h - 1] - j); // offset to this table
|
|
hp.set(r, (u[h - 1] + j) * 3);
|
|
// to
|
|
// last
|
|
// table
|
|
} else {
|
|
t[0] = q; // first table is returned result
|
|
}
|
|
}
|
|
|
|
// set up table entry in r
|
|
r[1] = /* (byte) */(k - w);
|
|
if (p >= n) {
|
|
r[0] = 128 + 64; // out of values--invalid code
|
|
} else if (v[p] < s) {
|
|
r[0] = /* (byte) */(v[p] < 256 ? 0 : 32 + 64); // 256 is
|
|
// end-of-block
|
|
r[2] = v[p++]; // simple code is just the value
|
|
} else {
|
|
r[0] = /* (byte) */(e[v[p] - s] + 16 + 64); // non-simple--look
|
|
// up in lists
|
|
r[2] = d[v[p++] - s];
|
|
}
|
|
|
|
// fill code-like entries with r
|
|
f = 1 << (k - w);
|
|
for (j = i >>> w; j < z; j += f) {
|
|
hp.set(r, (q + j) * 3);
|
|
}
|
|
|
|
// backwards increment the k-bit code i
|
|
for (j = 1 << (k - 1); (i & j) !== 0; j >>>= 1) {
|
|
i ^= j;
|
|
}
|
|
i ^= j;
|
|
|
|
// backup over finished tables
|
|
mask = (1 << w) - 1; // needed on HP, cc -O bug
|
|
while ((i & mask) != x[h]) {
|
|
h--; // don't need to update q
|
|
w -= l;
|
|
mask = (1 << w) - 1;
|
|
}
|
|
}
|
|
}
|
|
// Return Z_BUF_ERROR if we were given an incomplete table
|
|
return y !== 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
|
|
}
|
|
|
|
function initWorkArea(vsize) {
|
|
var i;
|
|
if (!hn) {
|
|
hn = []; // []; //new Array(1);
|
|
v = []; // new Array(vsize);
|
|
c = new Int32Array(BMAX + 1); // new Array(BMAX + 1);
|
|
r = []; // new Array(3);
|
|
u = new Int32Array(BMAX); // new Array(BMAX);
|
|
x = new Int32Array(BMAX + 1); // new Array(BMAX + 1);
|
|
}
|
|
if (v.length < vsize) {
|
|
v = []; // new Array(vsize);
|
|
}
|
|
for (i = 0; i < vsize; i++) {
|
|
v[i] = 0;
|
|
}
|
|
for (i = 0; i < BMAX + 1; i++) {
|
|
c[i] = 0;
|
|
}
|
|
for (i = 0; i < 3; i++) {
|
|
r[i] = 0;
|
|
}
|
|
// for(int i=0; i<BMAX; i++){u[i]=0;}
|
|
u.set(c.subarray(0, BMAX), 0);
|
|
// for(int i=0; i<BMAX+1; i++){x[i]=0;}
|
|
x.set(c.subarray(0, BMAX + 1), 0);
|
|
}
|
|
|
|
that.inflate_trees_bits = function(c, // 19 code lengths
|
|
bb, // bits tree desired/actual depth
|
|
tb, // bits tree result
|
|
hp, // space for trees
|
|
z // for messages
|
|
) {
|
|
var result;
|
|
initWorkArea(19);
|
|
hn[0] = 0;
|
|
result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
|
|
|
|
if (result == Z_DATA_ERROR) {
|
|
z.msg = "oversubscribed dynamic bit lengths tree";
|
|
} else if (result == Z_BUF_ERROR || bb[0] === 0) {
|
|
z.msg = "incomplete dynamic bit lengths tree";
|
|
result = Z_DATA_ERROR;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
that.inflate_trees_dynamic = function(nl, // number of literal/length codes
|
|
nd, // number of distance codes
|
|
c, // that many (total) code lengths
|
|
bl, // literal desired/actual bit depth
|
|
bd, // distance desired/actual bit depth
|
|
tl, // literal/length tree result
|
|
td, // distance tree result
|
|
hp, // space for trees
|
|
z // for messages
|
|
) {
|
|
var result;
|
|
|
|
// build literal/length tree
|
|
initWorkArea(288);
|
|
hn[0] = 0;
|
|
result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
|
|
if (result != Z_OK || bl[0] === 0) {
|
|
if (result == Z_DATA_ERROR) {
|
|
z.msg = "oversubscribed literal/length tree";
|
|
} else if (result != Z_MEM_ERROR) {
|
|
z.msg = "incomplete literal/length tree";
|
|
result = Z_DATA_ERROR;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// build distance tree
|
|
initWorkArea(288);
|
|
result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
|
|
|
|
if (result != Z_OK || (bd[0] === 0 && nl > 257)) {
|
|
if (result == Z_DATA_ERROR) {
|
|
z.msg = "oversubscribed distance tree";
|
|
} else if (result == Z_BUF_ERROR) {
|
|
z.msg = "incomplete distance tree";
|
|
result = Z_DATA_ERROR;
|
|
} else if (result != Z_MEM_ERROR) {
|
|
z.msg = "empty distance tree with lengths";
|
|
result = Z_DATA_ERROR;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
return Z_OK;
|
|
};
|
|
|
|
}
|
|
|
|
InfTree.inflate_trees_fixed = function(bl, // literal desired/actual bit depth
|
|
bd, // distance desired/actual bit depth
|
|
tl,// literal/length tree result
|
|
td// distance tree result
|
|
) {
|
|
bl[0] = fixed_bl;
|
|
bd[0] = fixed_bd;
|
|
tl[0] = fixed_tl;
|
|
td[0] = fixed_td;
|
|
return Z_OK;
|
|
};
|
|
|
|
// InfCodes
|
|
|
|
// waiting for "i:"=input,
|
|
// "o:"=output,
|
|
// "x:"=nothing
|
|
var START = 0; // x: set up for LEN
|
|
var LEN = 1; // i: get length/literal/eob next
|
|
var LENEXT = 2; // i: getting length extra (have base)
|
|
var DIST = 3; // i: get distance next
|
|
var DISTEXT = 4;// i: getting distance extra
|
|
var COPY = 5; // o: copying bytes in window, waiting
|
|
// for space
|
|
var LIT = 6; // o: got literal, waiting for output
|
|
// space
|
|
var WASH = 7; // o: got eob, possibly still output
|
|
// waiting
|
|
var END = 8; // x: got eob and all data flushed
|
|
var BADCODE = 9;// x: got error
|
|
|
|
function InfCodes() {
|
|
var that = this;
|
|
|
|
var mode; // current inflate_codes mode
|
|
|
|
// mode dependent information
|
|
var len = 0;
|
|
|
|
var tree; // pointer into tree
|
|
var tree_index = 0;
|
|
var need = 0; // bits needed
|
|
|
|
var lit = 0;
|
|
|
|
// if EXT or COPY, where and how much
|
|
var get = 0; // bits to get for extra
|
|
var dist = 0; // distance back to copy from
|
|
|
|
var lbits = 0; // ltree bits decoded per branch
|
|
var dbits = 0; // dtree bits decoder per branch
|
|
var ltree; // literal/length/eob tree
|
|
var ltree_index = 0; // literal/length/eob tree
|
|
var dtree; // distance tree
|
|
var dtree_index = 0; // distance tree
|
|
|
|
// Called with number of bytes left to write in window at least 258
|
|
// (the maximum string length) and number of input bytes available
|
|
// at least ten. The ten bytes are six bytes for the longest length/
|
|
// distance pair plus four bytes for overloading the bit buffer.
|
|
|
|
function inflate_fast(bl, bd, tl, tl_index, td, td_index, s, z) {
|
|
var t; // temporary pointer
|
|
var tp; // temporary pointer
|
|
var tp_index; // temporary pointer
|
|
var e; // extra bits or operation
|
|
var b; // bit buffer
|
|
var k; // bits in bit buffer
|
|
var p; // input data pointer
|
|
var n; // bytes available there
|
|
var q; // output window write pointer
|
|
var m; // bytes to end of window or read pointer
|
|
var ml; // mask for literal/length tree
|
|
var md; // mask for distance tree
|
|
var c; // bytes to copy
|
|
var d; // distance back to copy from
|
|
var r; // copy source pointer
|
|
|
|
var tp_index_t_3; // (tp_index+t)*3
|
|
|
|
// load input, output, bit values
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
// initialize masks
|
|
ml = inflate_mask[bl];
|
|
md = inflate_mask[bd];
|
|
|
|
// do until not enough input or output space for fast loop
|
|
do { // assume called with m >= 258 && n >= 10
|
|
// get literal/length code
|
|
while (k < (20)) { // max bits for literal/length code
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
t = b & ml;
|
|
tp = tl;
|
|
tp_index = tl_index;
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
if ((e = tp[tp_index_t_3]) === 0) {
|
|
b >>= (tp[tp_index_t_3 + 1]);
|
|
k -= (tp[tp_index_t_3 + 1]);
|
|
|
|
s.window[q++] = /* (byte) */tp[tp_index_t_3 + 2];
|
|
m--;
|
|
continue;
|
|
}
|
|
do {
|
|
|
|
b >>= (tp[tp_index_t_3 + 1]);
|
|
k -= (tp[tp_index_t_3 + 1]);
|
|
|
|
if ((e & 16) !== 0) {
|
|
e &= 15;
|
|
c = tp[tp_index_t_3 + 2] + (/* (int) */b & inflate_mask[e]);
|
|
|
|
b >>= e;
|
|
k -= e;
|
|
|
|
// decode distance base of block to copy
|
|
while (k < (15)) { // max bits for distance code
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
t = b & md;
|
|
tp = td;
|
|
tp_index = td_index;
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
e = tp[tp_index_t_3];
|
|
|
|
do {
|
|
|
|
b >>= (tp[tp_index_t_3 + 1]);
|
|
k -= (tp[tp_index_t_3 + 1]);
|
|
|
|
if ((e & 16) !== 0) {
|
|
// get extra bits to add to distance base
|
|
e &= 15;
|
|
while (k < (e)) { // get extra bits (up to 13)
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
d = tp[tp_index_t_3 + 2] + (b & inflate_mask[e]);
|
|
|
|
b >>= (e);
|
|
k -= (e);
|
|
|
|
// do the copy
|
|
m -= c;
|
|
if (q >= d) { // offset before dest
|
|
// just copy
|
|
r = q - d;
|
|
if (q - r > 0 && 2 > (q - r)) {
|
|
s.window[q++] = s.window[r++]; // minimum
|
|
// count is
|
|
// three,
|
|
s.window[q++] = s.window[r++]; // so unroll
|
|
// loop a
|
|
// little
|
|
c -= 2;
|
|
} else {
|
|
s.window.set(s.window.subarray(r, r + 2), q);
|
|
q += 2;
|
|
r += 2;
|
|
c -= 2;
|
|
}
|
|
} else { // else offset after destination
|
|
r = q - d;
|
|
do {
|
|
r += s.end; // force pointer in window
|
|
} while (r < 0); // covers invalid distances
|
|
e = s.end - r;
|
|
if (c > e) { // if source crosses,
|
|
c -= e; // wrapped copy
|
|
if (q - r > 0 && e > (q - r)) {
|
|
do {
|
|
s.window[q++] = s.window[r++];
|
|
} while (--e !== 0);
|
|
} else {
|
|
s.window.set(s.window.subarray(r, r + e), q);
|
|
q += e;
|
|
r += e;
|
|
e = 0;
|
|
}
|
|
r = 0; // copy rest from start of window
|
|
}
|
|
|
|
}
|
|
|
|
// copy all or what's left
|
|
if (q - r > 0 && c > (q - r)) {
|
|
do {
|
|
s.window[q++] = s.window[r++];
|
|
} while (--c !== 0);
|
|
} else {
|
|
s.window.set(s.window.subarray(r, r + c), q);
|
|
q += c;
|
|
r += c;
|
|
c = 0;
|
|
}
|
|
break;
|
|
} else if ((e & 64) === 0) {
|
|
t += tp[tp_index_t_3 + 2];
|
|
t += (b & inflate_mask[e]);
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
e = tp[tp_index_t_3];
|
|
} else {
|
|
z.msg = "invalid distance code";
|
|
|
|
c = z.avail_in - n;
|
|
c = (k >> 3) < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
|
|
return Z_DATA_ERROR;
|
|
}
|
|
} while (true);
|
|
break;
|
|
}
|
|
|
|
if ((e & 64) === 0) {
|
|
t += tp[tp_index_t_3 + 2];
|
|
t += (b & inflate_mask[e]);
|
|
tp_index_t_3 = (tp_index + t) * 3;
|
|
if ((e = tp[tp_index_t_3]) === 0) {
|
|
|
|
b >>= (tp[tp_index_t_3 + 1]);
|
|
k -= (tp[tp_index_t_3 + 1]);
|
|
|
|
s.window[q++] = /* (byte) */tp[tp_index_t_3 + 2];
|
|
m--;
|
|
break;
|
|
}
|
|
} else if ((e & 32) !== 0) {
|
|
|
|
c = z.avail_in - n;
|
|
c = (k >> 3) < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
|
|
return Z_STREAM_END;
|
|
} else {
|
|
z.msg = "invalid literal/length code";
|
|
|
|
c = z.avail_in - n;
|
|
c = (k >> 3) < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
|
|
return Z_DATA_ERROR;
|
|
}
|
|
} while (true);
|
|
} while (m >= 258 && n >= 10);
|
|
|
|
// not enough input or output--restore pointers and return
|
|
c = z.avail_in - n;
|
|
c = (k >> 3) < c ? k >> 3 : c;
|
|
n += c;
|
|
p -= c;
|
|
k -= c << 3;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
|
|
return Z_OK;
|
|
}
|
|
|
|
that.init = function(bl, bd, tl, tl_index, td, td_index) {
|
|
mode = START;
|
|
lbits = /* (byte) */bl;
|
|
dbits = /* (byte) */bd;
|
|
ltree = tl;
|
|
ltree_index = tl_index;
|
|
dtree = td;
|
|
dtree_index = td_index;
|
|
tree = null;
|
|
};
|
|
|
|
that.proc = function(s, z, r) {
|
|
var j; // temporary storage
|
|
var tindex; // temporary pointer
|
|
var e; // extra bits or operation
|
|
var b = 0; // bit buffer
|
|
var k = 0; // bits in bit buffer
|
|
var p = 0; // input data pointer
|
|
var n; // bytes available there
|
|
var q; // output window write pointer
|
|
var m; // bytes to end of window or read pointer
|
|
var f; // pointer to copy strings from
|
|
|
|
// copy input/output information to locals (UPDATE macro restores)
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
// process input and output based on current state
|
|
while (true) {
|
|
switch (mode) {
|
|
// waiting for "i:"=input, "o:"=output, "x:"=nothing
|
|
case START: // x: set up for LEN
|
|
if (m >= 258 && n >= 10) {
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
r = inflate_fast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, s, z);
|
|
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = s.bitb;
|
|
k = s.bitk;
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
if (r != Z_OK) {
|
|
mode = r == Z_STREAM_END ? WASH : BADCODE;
|
|
break;
|
|
}
|
|
}
|
|
need = lbits;
|
|
tree = ltree;
|
|
tree_index = ltree_index;
|
|
|
|
mode = LEN;
|
|
case LEN: // i: get length/literal/eob next
|
|
j = need;
|
|
|
|
while (k < (j)) {
|
|
if (n !== 0)
|
|
r = Z_OK;
|
|
else {
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
tindex = (tree_index + (b & inflate_mask[j])) * 3;
|
|
|
|
b >>>= (tree[tindex + 1]);
|
|
k -= (tree[tindex + 1]);
|
|
|
|
e = tree[tindex];
|
|
|
|
if (e === 0) { // literal
|
|
lit = tree[tindex + 2];
|
|
mode = LIT;
|
|
break;
|
|
}
|
|
if ((e & 16) !== 0) { // length
|
|
get = e & 15;
|
|
len = tree[tindex + 2];
|
|
mode = LENEXT;
|
|
break;
|
|
}
|
|
if ((e & 64) === 0) { // next table
|
|
need = e;
|
|
tree_index = tindex / 3 + tree[tindex + 2];
|
|
break;
|
|
}
|
|
if ((e & 32) !== 0) { // end of block
|
|
mode = WASH;
|
|
break;
|
|
}
|
|
mode = BADCODE; // invalid code
|
|
z.msg = "invalid literal/length code";
|
|
r = Z_DATA_ERROR;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
|
|
case LENEXT: // i: getting length extra (have base)
|
|
j = get;
|
|
|
|
while (k < (j)) {
|
|
if (n !== 0)
|
|
r = Z_OK;
|
|
else {
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
len += (b & inflate_mask[j]);
|
|
|
|
b >>= j;
|
|
k -= j;
|
|
|
|
need = dbits;
|
|
tree = dtree;
|
|
tree_index = dtree_index;
|
|
mode = DIST;
|
|
case DIST: // i: get distance next
|
|
j = need;
|
|
|
|
while (k < (j)) {
|
|
if (n !== 0)
|
|
r = Z_OK;
|
|
else {
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
tindex = (tree_index + (b & inflate_mask[j])) * 3;
|
|
|
|
b >>= tree[tindex + 1];
|
|
k -= tree[tindex + 1];
|
|
|
|
e = (tree[tindex]);
|
|
if ((e & 16) !== 0) { // distance
|
|
get = e & 15;
|
|
dist = tree[tindex + 2];
|
|
mode = DISTEXT;
|
|
break;
|
|
}
|
|
if ((e & 64) === 0) { // next table
|
|
need = e;
|
|
tree_index = tindex / 3 + tree[tindex + 2];
|
|
break;
|
|
}
|
|
mode = BADCODE; // invalid code
|
|
z.msg = "invalid distance code";
|
|
r = Z_DATA_ERROR;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
|
|
case DISTEXT: // i: getting distance extra
|
|
j = get;
|
|
|
|
while (k < (j)) {
|
|
if (n !== 0)
|
|
r = Z_OK;
|
|
else {
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
dist += (b & inflate_mask[j]);
|
|
|
|
b >>= j;
|
|
k -= j;
|
|
|
|
mode = COPY;
|
|
case COPY: // o: copying bytes in window, waiting for space
|
|
f = q - dist;
|
|
while (f < 0) { // modulo window size-"while" instead
|
|
f += s.end; // of "if" handles invalid distances
|
|
}
|
|
while (len !== 0) {
|
|
|
|
if (m === 0) {
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
|
|
if (m === 0) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
}
|
|
|
|
s.window[q++] = s.window[f++];
|
|
m--;
|
|
|
|
if (f == s.end)
|
|
f = 0;
|
|
len--;
|
|
}
|
|
mode = START;
|
|
break;
|
|
case LIT: // o: got literal, waiting for output space
|
|
if (m === 0) {
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
if (q == s.end && s.read !== 0) {
|
|
q = 0;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
}
|
|
if (m === 0) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
}
|
|
r = Z_OK;
|
|
|
|
s.window[q++] = /* (byte) */lit;
|
|
m--;
|
|
|
|
mode = START;
|
|
break;
|
|
case WASH: // o: got eob, possibly more output
|
|
if (k > 7) { // return unused byte, if any
|
|
k -= 8;
|
|
n++;
|
|
p--; // can always return one
|
|
}
|
|
|
|
s.write = q;
|
|
r = s.inflate_flush(z, r);
|
|
q = s.write;
|
|
m = q < s.read ? s.read - q - 1 : s.end - q;
|
|
|
|
if (s.read != s.write) {
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
mode = END;
|
|
case END:
|
|
r = Z_STREAM_END;
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
|
|
case BADCODE: // x: got error
|
|
|
|
r = Z_DATA_ERROR;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
|
|
default:
|
|
r = Z_STREAM_ERROR;
|
|
|
|
s.bitb = b;
|
|
s.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
s.write = q;
|
|
return s.inflate_flush(z, r);
|
|
}
|
|
}
|
|
};
|
|
|
|
that.free = function() {
|
|
// ZFREE(z, c);
|
|
};
|
|
|
|
}
|
|
|
|
// InfBlocks
|
|
|
|
// Table for deflate from PKZIP's appnote.txt.
|
|
var border = [ // Order of the bit length code lengths
|
|
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
|
|
|
|
var TYPE = 0; // get type bits (3, including end bit)
|
|
var LENS = 1; // get lengths for stored
|
|
var STORED = 2;// processing stored block
|
|
var TABLE = 3; // get table lengths
|
|
var BTREE = 4; // get bit lengths tree for a dynamic
|
|
// block
|
|
var DTREE = 5; // get length, distance trees for a
|
|
// dynamic block
|
|
var CODES = 6; // processing fixed or dynamic block
|
|
var DRY = 7; // output remaining window bytes
|
|
var DONELOCKS = 8; // finished last block, done
|
|
var BADBLOCKS = 9; // ot a data error--stuck here
|
|
|
|
function InfBlocks(z, w) {
|
|
var that = this;
|
|
|
|
var mode = TYPE; // current inflate_block mode
|
|
|
|
var left = 0; // if STORED, bytes left to copy
|
|
|
|
var table = 0; // table lengths (14 bits)
|
|
var index = 0; // index into blens (or border)
|
|
var blens; // bit lengths of codes
|
|
var bb = [ 0 ]; // bit length tree depth
|
|
var tb = [ 0 ]; // bit length decoding tree
|
|
|
|
var codes = new InfCodes(); // if CODES, current state
|
|
|
|
var last = 0; // true if this block is the last block
|
|
|
|
var hufts = new Int32Array(MANY * 3); // single malloc for tree space
|
|
var check = 0; // check on output
|
|
var inftree = new InfTree();
|
|
|
|
that.bitk = 0; // bits in bit buffer
|
|
that.bitb = 0; // bit buffer
|
|
that.window = new Uint8Array(w); // sliding window
|
|
that.end = w; // one byte after sliding window
|
|
that.read = 0; // window read pointer
|
|
that.write = 0; // window write pointer
|
|
|
|
that.reset = function(z, c) {
|
|
if (c)
|
|
c[0] = check;
|
|
// if (mode == BTREE || mode == DTREE) {
|
|
// }
|
|
if (mode == CODES) {
|
|
codes.free(z);
|
|
}
|
|
mode = TYPE;
|
|
that.bitk = 0;
|
|
that.bitb = 0;
|
|
that.read = that.write = 0;
|
|
};
|
|
|
|
that.reset(z, null);
|
|
|
|
// copy as much as possible from the sliding window to the output area
|
|
that.inflate_flush = function(z, r) {
|
|
var n;
|
|
var p;
|
|
var q;
|
|
|
|
// local copies of source and destination pointers
|
|
p = z.next_out_index;
|
|
q = that.read;
|
|
|
|
// compute number of bytes to copy as far as end of window
|
|
n = /* (int) */((q <= that.write ? that.write : that.end) - q);
|
|
if (n > z.avail_out)
|
|
n = z.avail_out;
|
|
if (n !== 0 && r == Z_BUF_ERROR)
|
|
r = Z_OK;
|
|
|
|
// update counters
|
|
z.avail_out -= n;
|
|
z.total_out += n;
|
|
|
|
// copy as far as end of window
|
|
z.next_out.set(that.window.subarray(q, q + n), p);
|
|
p += n;
|
|
q += n;
|
|
|
|
// see if more to copy at beginning of window
|
|
if (q == that.end) {
|
|
// wrap pointers
|
|
q = 0;
|
|
if (that.write == that.end)
|
|
that.write = 0;
|
|
|
|
// compute bytes to copy
|
|
n = that.write - q;
|
|
if (n > z.avail_out)
|
|
n = z.avail_out;
|
|
if (n !== 0 && r == Z_BUF_ERROR)
|
|
r = Z_OK;
|
|
|
|
// update counters
|
|
z.avail_out -= n;
|
|
z.total_out += n;
|
|
|
|
// copy
|
|
z.next_out.set(that.window.subarray(q, q + n), p);
|
|
p += n;
|
|
q += n;
|
|
}
|
|
|
|
// update pointers
|
|
z.next_out_index = p;
|
|
that.read = q;
|
|
|
|
// done
|
|
return r;
|
|
};
|
|
|
|
that.proc = function(z, r) {
|
|
var t; // temporary storage
|
|
var b; // bit buffer
|
|
var k; // bits in bit buffer
|
|
var p; // input data pointer
|
|
var n; // bytes available there
|
|
var q; // output window write pointer
|
|
var m; // bytes to end of window or read pointer
|
|
|
|
var i;
|
|
|
|
// copy input/output information to locals (UPDATE macro restores)
|
|
// {
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = that.bitb;
|
|
k = that.bitk;
|
|
// }
|
|
// {
|
|
q = that.write;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
// }
|
|
|
|
// process input based on current state
|
|
// DEBUG dtree
|
|
while (true) {
|
|
switch (mode) {
|
|
case TYPE:
|
|
|
|
while (k < (3)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
t = /* (int) */(b & 7);
|
|
last = t & 1;
|
|
|
|
switch (t >>> 1) {
|
|
case 0: // stored
|
|
// {
|
|
b >>>= (3);
|
|
k -= (3);
|
|
// }
|
|
t = k & 7; // go to byte boundary
|
|
|
|
// {
|
|
b >>>= (t);
|
|
k -= (t);
|
|
// }
|
|
mode = LENS; // get length of stored block
|
|
break;
|
|
case 1: // fixed
|
|
// {
|
|
var bl = []; // new Array(1);
|
|
var bd = []; // new Array(1);
|
|
var tl = [ [] ]; // new Array(1);
|
|
var td = [ [] ]; // new Array(1);
|
|
|
|
InfTree.inflate_trees_fixed(bl, bd, tl, td);
|
|
codes.init(bl[0], bd[0], tl[0], 0, td[0], 0);
|
|
// }
|
|
|
|
// {
|
|
b >>>= (3);
|
|
k -= (3);
|
|
// }
|
|
|
|
mode = CODES;
|
|
break;
|
|
case 2: // dynamic
|
|
|
|
// {
|
|
b >>>= (3);
|
|
k -= (3);
|
|
// }
|
|
|
|
mode = TABLE;
|
|
break;
|
|
case 3: // illegal
|
|
|
|
// {
|
|
b >>>= (3);
|
|
k -= (3);
|
|
// }
|
|
mode = BADBLOCKS;
|
|
z.msg = "invalid block type";
|
|
r = Z_DATA_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
break;
|
|
case LENS:
|
|
|
|
while (k < (32)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
if ((((~b) >>> 16) & 0xffff) != (b & 0xffff)) {
|
|
mode = BADBLOCKS;
|
|
z.msg = "invalid stored block lengths";
|
|
r = Z_DATA_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
left = (b & 0xffff);
|
|
b = k = 0; // dump bits
|
|
mode = left !== 0 ? STORED : (last !== 0 ? DRY : TYPE);
|
|
break;
|
|
case STORED:
|
|
if (n === 0) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
|
|
if (m === 0) {
|
|
if (q == that.end && that.read !== 0) {
|
|
q = 0;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
}
|
|
if (m === 0) {
|
|
that.write = q;
|
|
r = that.inflate_flush(z, r);
|
|
q = that.write;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
if (q == that.end && that.read !== 0) {
|
|
q = 0;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
}
|
|
if (m === 0) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
}
|
|
}
|
|
r = Z_OK;
|
|
|
|
t = left;
|
|
if (t > n)
|
|
t = n;
|
|
if (t > m)
|
|
t = m;
|
|
that.window.set(z.read_buf(p, t), q);
|
|
p += t;
|
|
n -= t;
|
|
q += t;
|
|
m -= t;
|
|
if ((left -= t) !== 0)
|
|
break;
|
|
mode = last !== 0 ? DRY : TYPE;
|
|
break;
|
|
case TABLE:
|
|
|
|
while (k < (14)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
table = t = (b & 0x3fff);
|
|
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) {
|
|
mode = BADBLOCKS;
|
|
z.msg = "too many length or distance symbols";
|
|
r = Z_DATA_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
|
|
if (!blens || blens.length < t) {
|
|
blens = []; // new Array(t);
|
|
} else {
|
|
for (i = 0; i < t; i++) {
|
|
blens[i] = 0;
|
|
}
|
|
}
|
|
|
|
// {
|
|
b >>>= (14);
|
|
k -= (14);
|
|
// }
|
|
|
|
index = 0;
|
|
mode = BTREE;
|
|
case BTREE:
|
|
while (index < 4 + (table >>> 10)) {
|
|
while (k < (3)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
blens[border[index++]] = b & 7;
|
|
|
|
// {
|
|
b >>>= (3);
|
|
k -= (3);
|
|
// }
|
|
}
|
|
|
|
while (index < 19) {
|
|
blens[border[index++]] = 0;
|
|
}
|
|
|
|
bb[0] = 7;
|
|
t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z);
|
|
if (t != Z_OK) {
|
|
r = t;
|
|
if (r == Z_DATA_ERROR) {
|
|
blens = null;
|
|
mode = BADBLOCKS;
|
|
}
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
|
|
index = 0;
|
|
mode = DTREE;
|
|
case DTREE:
|
|
while (true) {
|
|
t = table;
|
|
if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))) {
|
|
break;
|
|
}
|
|
|
|
var j, c;
|
|
|
|
t = bb[0];
|
|
|
|
while (k < (t)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
// if (tb[0] == -1) {
|
|
// System.err.println("null...");
|
|
// }
|
|
|
|
t = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 1];
|
|
c = hufts[(tb[0] + (b & inflate_mask[t])) * 3 + 2];
|
|
|
|
if (c < 16) {
|
|
b >>>= (t);
|
|
k -= (t);
|
|
blens[index++] = c;
|
|
} else { // c == 16..18
|
|
i = c == 18 ? 7 : c - 14;
|
|
j = c == 18 ? 11 : 3;
|
|
|
|
while (k < (t + i)) {
|
|
if (n !== 0) {
|
|
r = Z_OK;
|
|
} else {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
n--;
|
|
b |= (z.read_byte(p++) & 0xff) << k;
|
|
k += 8;
|
|
}
|
|
|
|
b >>>= (t);
|
|
k -= (t);
|
|
|
|
j += (b & inflate_mask[i]);
|
|
|
|
b >>>= (i);
|
|
k -= (i);
|
|
|
|
i = index;
|
|
t = table;
|
|
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1)) {
|
|
blens = null;
|
|
mode = BADBLOCKS;
|
|
z.msg = "invalid bit length repeat";
|
|
r = Z_DATA_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
|
|
c = c == 16 ? blens[i - 1] : 0;
|
|
do {
|
|
blens[i++] = c;
|
|
} while (--j !== 0);
|
|
index = i;
|
|
}
|
|
}
|
|
|
|
tb[0] = -1;
|
|
// {
|
|
var bl_ = []; // new Array(1);
|
|
var bd_ = []; // new Array(1);
|
|
var tl_ = []; // new Array(1);
|
|
var td_ = []; // new Array(1);
|
|
bl_[0] = 9; // must be <= 9 for lookahead assumptions
|
|
bd_[0] = 6; // must be <= 9 for lookahead assumptions
|
|
|
|
t = table;
|
|
t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl_, bd_, tl_, td_, hufts, z);
|
|
|
|
if (t != Z_OK) {
|
|
if (t == Z_DATA_ERROR) {
|
|
blens = null;
|
|
mode = BADBLOCKS;
|
|
}
|
|
r = t;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
codes.init(bl_[0], bd_[0], hufts, tl_[0], hufts, td_[0]);
|
|
// }
|
|
mode = CODES;
|
|
case CODES:
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
|
|
if ((r = codes.proc(that, z, r)) != Z_STREAM_END) {
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
r = Z_OK;
|
|
codes.free(z);
|
|
|
|
p = z.next_in_index;
|
|
n = z.avail_in;
|
|
b = that.bitb;
|
|
k = that.bitk;
|
|
q = that.write;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
|
|
if (last === 0) {
|
|
mode = TYPE;
|
|
break;
|
|
}
|
|
mode = DRY;
|
|
case DRY:
|
|
that.write = q;
|
|
r = that.inflate_flush(z, r);
|
|
q = that.write;
|
|
m = /* (int) */(q < that.read ? that.read - q - 1 : that.end - q);
|
|
if (that.read != that.write) {
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
mode = DONELOCKS;
|
|
case DONELOCKS:
|
|
r = Z_STREAM_END;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
case BADBLOCKS:
|
|
r = Z_DATA_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
|
|
default:
|
|
r = Z_STREAM_ERROR;
|
|
|
|
that.bitb = b;
|
|
that.bitk = k;
|
|
z.avail_in = n;
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
that.write = q;
|
|
return that.inflate_flush(z, r);
|
|
}
|
|
}
|
|
};
|
|
|
|
that.free = function(z) {
|
|
that.reset(z, null);
|
|
that.window = null;
|
|
hufts = null;
|
|
// ZFREE(z, s);
|
|
};
|
|
|
|
that.set_dictionary = function(d, start, n) {
|
|
that.window.set(d.subarray(start, start + n), 0);
|
|
that.read = that.write = n;
|
|
};
|
|
|
|
// Returns true if inflate is currently at the end of a block generated
|
|
// by Z_SYNC_FLUSH or Z_FULL_FLUSH.
|
|
that.sync_point = function() {
|
|
return mode == LENS ? 1 : 0;
|
|
};
|
|
|
|
}
|
|
|
|
// Inflate
|
|
|
|
// preset dictionary flag in zlib header
|
|
var PRESET_DICT = 0x20;
|
|
|
|
var Z_DEFLATED = 8;
|
|
|
|
var METHOD = 0; // waiting for method byte
|
|
var FLAG = 1; // waiting for flag byte
|
|
var DICT4 = 2; // four dictionary check bytes to go
|
|
var DICT3 = 3; // three dictionary check bytes to go
|
|
var DICT2 = 4; // two dictionary check bytes to go
|
|
var DICT1 = 5; // one dictionary check byte to go
|
|
var DICT0 = 6; // waiting for inflateSetDictionary
|
|
var BLOCKS = 7; // decompressing blocks
|
|
var DONE = 12; // finished check, done
|
|
var BAD = 13; // got an error--stay here
|
|
|
|
var mark = [ 0, 0, 0xff, 0xff ];
|
|
|
|
function Inflate() {
|
|
var that = this;
|
|
|
|
that.mode = 0; // current inflate mode
|
|
|
|
// mode dependent information
|
|
that.method = 0; // if FLAGS, method byte
|
|
|
|
// if CHECK, check values to compare
|
|
that.was = [ 0 ]; // new Array(1); // computed check value
|
|
that.need = 0; // stream check value
|
|
|
|
// if BAD, inflateSync's marker bytes count
|
|
that.marker = 0;
|
|
|
|
// mode independent information
|
|
that.wbits = 0; // log2(window size) (8..15, defaults to 15)
|
|
|
|
// this.blocks; // current inflate_blocks state
|
|
|
|
function inflateReset(z) {
|
|
if (!z || !z.istate)
|
|
return Z_STREAM_ERROR;
|
|
|
|
z.total_in = z.total_out = 0;
|
|
z.msg = null;
|
|
z.istate.mode = BLOCKS;
|
|
z.istate.blocks.reset(z, null);
|
|
return Z_OK;
|
|
}
|
|
|
|
that.inflateEnd = function(z) {
|
|
if (that.blocks)
|
|
that.blocks.free(z);
|
|
that.blocks = null;
|
|
// ZFREE(z, z->state);
|
|
return Z_OK;
|
|
};
|
|
|
|
that.inflateInit = function(z, w) {
|
|
z.msg = null;
|
|
that.blocks = null;
|
|
|
|
// set window size
|
|
if (w < 8 || w > 15) {
|
|
that.inflateEnd(z);
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
that.wbits = w;
|
|
|
|
z.istate.blocks = new InfBlocks(z, 1 << w);
|
|
|
|
// reset state
|
|
inflateReset(z);
|
|
return Z_OK;
|
|
};
|
|
|
|
that.inflate = function(z, f) {
|
|
var r;
|
|
var b;
|
|
|
|
if (!z || !z.istate || !z.next_in)
|
|
return Z_STREAM_ERROR;
|
|
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
|
|
r = Z_BUF_ERROR;
|
|
while (true) {
|
|
// System.out.println("mode: "+z.istate.mode);
|
|
switch (z.istate.mode) {
|
|
case METHOD:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
if (((z.istate.method = z.read_byte(z.next_in_index++)) & 0xf) != Z_DEFLATED) {
|
|
z.istate.mode = BAD;
|
|
z.msg = "unknown compression method";
|
|
z.istate.marker = 5; // can't try inflateSync
|
|
break;
|
|
}
|
|
if ((z.istate.method >> 4) + 8 > z.istate.wbits) {
|
|
z.istate.mode = BAD;
|
|
z.msg = "invalid window size";
|
|
z.istate.marker = 5; // can't try inflateSync
|
|
break;
|
|
}
|
|
z.istate.mode = FLAG;
|
|
case FLAG:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
b = (z.read_byte(z.next_in_index++)) & 0xff;
|
|
|
|
if ((((z.istate.method << 8) + b) % 31) !== 0) {
|
|
z.istate.mode = BAD;
|
|
z.msg = "incorrect header check";
|
|
z.istate.marker = 5; // can't try inflateSync
|
|
break;
|
|
}
|
|
|
|
if ((b & PRESET_DICT) === 0) {
|
|
z.istate.mode = BLOCKS;
|
|
break;
|
|
}
|
|
z.istate.mode = DICT4;
|
|
case DICT4:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
z.istate.need = ((z.read_byte(z.next_in_index++) & 0xff) << 24) & 0xff000000;
|
|
z.istate.mode = DICT3;
|
|
case DICT3:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
z.istate.need += ((z.read_byte(z.next_in_index++) & 0xff) << 16) & 0xff0000;
|
|
z.istate.mode = DICT2;
|
|
case DICT2:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
z.istate.need += ((z.read_byte(z.next_in_index++) & 0xff) << 8) & 0xff00;
|
|
z.istate.mode = DICT1;
|
|
case DICT1:
|
|
|
|
if (z.avail_in === 0)
|
|
return r;
|
|
r = f;
|
|
|
|
z.avail_in--;
|
|
z.total_in++;
|
|
z.istate.need += (z.read_byte(z.next_in_index++) & 0xff);
|
|
z.istate.mode = DICT0;
|
|
return Z_NEED_DICT;
|
|
case DICT0:
|
|
z.istate.mode = BAD;
|
|
z.msg = "need dictionary";
|
|
z.istate.marker = 0; // can try inflateSync
|
|
return Z_STREAM_ERROR;
|
|
case BLOCKS:
|
|
|
|
r = z.istate.blocks.proc(z, r);
|
|
if (r == Z_DATA_ERROR) {
|
|
z.istate.mode = BAD;
|
|
z.istate.marker = 0; // can try inflateSync
|
|
break;
|
|
}
|
|
if (r == Z_OK) {
|
|
r = f;
|
|
}
|
|
if (r != Z_STREAM_END) {
|
|
return r;
|
|
}
|
|
r = f;
|
|
z.istate.blocks.reset(z, z.istate.was);
|
|
z.istate.mode = DONE;
|
|
case DONE:
|
|
return Z_STREAM_END;
|
|
case BAD:
|
|
return Z_DATA_ERROR;
|
|
default:
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
}
|
|
};
|
|
|
|
that.inflateSetDictionary = function(z, dictionary, dictLength) {
|
|
var index = 0;
|
|
var length = dictLength;
|
|
if (!z || !z.istate || z.istate.mode != DICT0)
|
|
return Z_STREAM_ERROR;
|
|
|
|
if (length >= (1 << z.istate.wbits)) {
|
|
length = (1 << z.istate.wbits) - 1;
|
|
index = dictLength - length;
|
|
}
|
|
z.istate.blocks.set_dictionary(dictionary, index, length);
|
|
z.istate.mode = BLOCKS;
|
|
return Z_OK;
|
|
};
|
|
|
|
that.inflateSync = function(z) {
|
|
var n; // number of bytes to look at
|
|
var p; // pointer to bytes
|
|
var m; // number of marker bytes found in a row
|
|
var r, w; // temporaries to save total_in and total_out
|
|
|
|
// set up
|
|
if (!z || !z.istate)
|
|
return Z_STREAM_ERROR;
|
|
if (z.istate.mode != BAD) {
|
|
z.istate.mode = BAD;
|
|
z.istate.marker = 0;
|
|
}
|
|
if ((n = z.avail_in) === 0)
|
|
return Z_BUF_ERROR;
|
|
p = z.next_in_index;
|
|
m = z.istate.marker;
|
|
|
|
// search
|
|
while (n !== 0 && m < 4) {
|
|
if (z.read_byte(p) == mark[m]) {
|
|
m++;
|
|
} else if (z.read_byte(p) !== 0) {
|
|
m = 0;
|
|
} else {
|
|
m = 4 - m;
|
|
}
|
|
p++;
|
|
n--;
|
|
}
|
|
|
|
// restore
|
|
z.total_in += p - z.next_in_index;
|
|
z.next_in_index = p;
|
|
z.avail_in = n;
|
|
z.istate.marker = m;
|
|
|
|
// return no joy or set up to restart on a new block
|
|
if (m != 4) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
r = z.total_in;
|
|
w = z.total_out;
|
|
inflateReset(z);
|
|
z.total_in = r;
|
|
z.total_out = w;
|
|
z.istate.mode = BLOCKS;
|
|
return Z_OK;
|
|
};
|
|
|
|
// Returns true if inflate is currently at the end of a block generated
|
|
// by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
|
|
// implementation to provide an additional safety check. PPP uses
|
|
// Z_SYNC_FLUSH
|
|
// but removes the length bytes of the resulting empty stored block. When
|
|
// decompressing, PPP checks that at the end of input packet, inflate is
|
|
// waiting for these length bytes.
|
|
that.inflateSyncPoint = function(z) {
|
|
if (!z || !z.istate || !z.istate.blocks)
|
|
return Z_STREAM_ERROR;
|
|
return z.istate.blocks.sync_point();
|
|
};
|
|
}
|
|
|
|
// ZStream
|
|
|
|
function ZStream() {
|
|
}
|
|
|
|
ZStream.prototype = {
|
|
inflateInit : function(bits) {
|
|
var that = this;
|
|
that.istate = new Inflate();
|
|
if (!bits)
|
|
bits = MAX_BITS;
|
|
return that.istate.inflateInit(that, bits);
|
|
},
|
|
|
|
inflate : function(f) {
|
|
var that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR;
|
|
return that.istate.inflate(that, f);
|
|
},
|
|
|
|
inflateEnd : function() {
|
|
var that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR;
|
|
var ret = that.istate.inflateEnd(that);
|
|
that.istate = null;
|
|
return ret;
|
|
},
|
|
|
|
inflateSync : function() {
|
|
var that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR;
|
|
return that.istate.inflateSync(that);
|
|
},
|
|
inflateSetDictionary : function(dictionary, dictLength) {
|
|
var that = this;
|
|
if (!that.istate)
|
|
return Z_STREAM_ERROR;
|
|
return that.istate.inflateSetDictionary(that, dictionary, dictLength);
|
|
},
|
|
read_byte : function(start) {
|
|
var that = this;
|
|
return that.next_in.subarray(start, start + 1)[0];
|
|
},
|
|
read_buf : function(start, size) {
|
|
var that = this;
|
|
return that.next_in.subarray(start, start + size);
|
|
}
|
|
};
|
|
|
|
// Inflater
|
|
|
|
function Inflater() {
|
|
var that = this;
|
|
var z = new ZStream();
|
|
var bufsize = 512;
|
|
var flush = Z_NO_FLUSH;
|
|
var buf = new Uint8Array(bufsize);
|
|
var nomoreinput = false;
|
|
|
|
z.inflateInit();
|
|
z.next_out = buf;
|
|
|
|
that.append = function(data, onprogress) {
|
|
var err, buffers = [], lastIndex = 0, bufferIndex = 0, bufferSize = 0, array;
|
|
if (data.length === 0)
|
|
return;
|
|
z.next_in_index = 0;
|
|
z.next_in = data;
|
|
z.avail_in = data.length;
|
|
do {
|
|
z.next_out_index = 0;
|
|
z.avail_out = bufsize;
|
|
if ((z.avail_in === 0) && (!nomoreinput)) { // if buffer is empty and more input is available, refill it
|
|
z.next_in_index = 0;
|
|
nomoreinput = true;
|
|
}
|
|
err = z.inflate(flush);
|
|
if (nomoreinput && (err == Z_BUF_ERROR))
|
|
return -1;
|
|
if (err != Z_OK && err != Z_STREAM_END)
|
|
throw "inflating: " + z.msg;
|
|
if ((nomoreinput || err == Z_STREAM_END) && (z.avail_in == data.length))
|
|
return -1;
|
|
if (z.next_out_index)
|
|
if (z.next_out_index == bufsize)
|
|
buffers.push(new Uint8Array(buf));
|
|
else
|
|
buffers.push(new Uint8Array(buf.subarray(0, z.next_out_index)));
|
|
bufferSize += z.next_out_index;
|
|
if (onprogress && z.next_in_index > 0 && z.next_in_index != lastIndex) {
|
|
onprogress(z.next_in_index);
|
|
lastIndex = z.next_in_index;
|
|
}
|
|
} while (z.avail_in > 0 || z.avail_out === 0);
|
|
array = new Uint8Array(bufferSize);
|
|
buffers.forEach(function(chunk) {
|
|
array.set(chunk, bufferIndex);
|
|
bufferIndex += chunk.length;
|
|
});
|
|
return array;
|
|
};
|
|
that.flush = function() {
|
|
z.inflateEnd();
|
|
};
|
|
}
|
|
|
|
var inflater;
|
|
|
|
if (obj.zip)
|
|
obj.zip.Inflater = Inflater;
|
|
else {
|
|
inflater = new Inflater();
|
|
obj.addEventListener("message", function(event) {
|
|
var message = event.data;
|
|
|
|
if (message.append)
|
|
obj.postMessage({
|
|
onappend : true,
|
|
data : inflater.append(message.data, function(current) {
|
|
obj.postMessage({
|
|
progress : true,
|
|
current : current
|
|
});
|
|
})
|
|
});
|
|
if (message.flush) {
|
|
inflater.flush();
|
|
obj.postMessage({
|
|
onflush : true
|
|
});
|
|
}
|
|
}, false);
|
|
}
|
|
|
|
};
|
|
|
|
// @agup
|
|
// Convert the inflate library to a blobURL
|
|
O.esri.TPK.___test = O.esri.TPK.inflate.toString();
|
|
|
|
O.esri.TPK.___blobURL = URL.createObjectURL(
|
|
new Blob([
|
|
'(',
|
|
O.esri.TPK.___test,
|
|
')(this)'],
|
|
{type: 'application/javascript'}
|
|
)
|
|
)
|
|
|
|
O.esri.zip.workerScriptsPath = O.esri.TPK.___blobURL;
|
|
|
|
//https://github.com/abdmob/x2js/blob/master/xml2json.js
|
|
/*
|
|
Copyright 2011-2013 Abdulla Abdurakhmanov
|
|
Original sources are available at https://code.google.com/p/x2js/
|
|
|
|
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.
|
|
*/
|
|
|
|
O.esri.TPK.X2JS = function(config){
|
|
'use strict';
|
|
|
|
var VERSION = "1.1.5";
|
|
|
|
var config = config || {};
|
|
initConfigDefaults();
|
|
initRequiredPolyfills();
|
|
|
|
function initConfigDefaults() {
|
|
if (config.escapeMode === undefined) {
|
|
config.escapeMode = true;
|
|
}
|
|
config.attributePrefix = config.attributePrefix || "_";
|
|
config.arrayAccessForm = config.arrayAccessForm || "none";
|
|
config.emptyNodeForm = config.emptyNodeForm || "text";
|
|
if (config.enableToStringFunc === undefined) {
|
|
config.enableToStringFunc = true;
|
|
}
|
|
config.arrayAccessFormPaths = config.arrayAccessFormPaths || [];
|
|
if (config.skipEmptyTextNodesForObj === undefined) {
|
|
config.skipEmptyTextNodesForObj = true;
|
|
}
|
|
if (config.stripWhitespaces === undefined) {
|
|
config.stripWhitespaces = true;
|
|
}
|
|
config.datetimeAccessFormPaths = config.datetimeAccessFormPaths || [];
|
|
}
|
|
|
|
var DOMNodeTypes = {
|
|
ELEMENT_NODE: 1,
|
|
TEXT_NODE: 3,
|
|
CDATA_SECTION_NODE: 4,
|
|
COMMENT_NODE: 8,
|
|
DOCUMENT_NODE: 9
|
|
};
|
|
|
|
function initRequiredPolyfills() {
|
|
function pad(number) {
|
|
var r = String(number);
|
|
if (r.length === 1) {
|
|
r = '0' + r;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
// Hello IE8-
|
|
if (typeof String.prototype.trim !== 'function') {
|
|
String.prototype.trim = function () {
|
|
return this.replace(/^\s+|^\n+|(\s|\n)+$/g, '');
|
|
}
|
|
}
|
|
if (typeof Date.prototype.toISOString !== 'function') {
|
|
// Implementation from http://stackoverflow.com/questions/2573521/how-do-i-output-an-iso-8601-formatted-string-in-javascript
|
|
Date.prototype.toISOString = function () {
|
|
return this.getUTCFullYear()
|
|
+ '-' + pad(this.getUTCMonth() + 1)
|
|
+ '-' + pad(this.getUTCDate())
|
|
+ 'T' + pad(this.getUTCHours())
|
|
+ ':' + pad(this.getUTCMinutes())
|
|
+ ':' + pad(this.getUTCSeconds())
|
|
+ '.' + String((this.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
|
|
+ 'Z';
|
|
};
|
|
}
|
|
}
|
|
|
|
function getNodeLocalName(node) {
|
|
var nodeLocalName = node.localName;
|
|
if (nodeLocalName == null) // Yeah, this is IE!!
|
|
nodeLocalName = node.baseName;
|
|
if (nodeLocalName == null || nodeLocalName == "") // =="" is IE too
|
|
nodeLocalName = node.nodeName;
|
|
return nodeLocalName;
|
|
}
|
|
|
|
function getNodePrefix(node) {
|
|
return node.prefix;
|
|
}
|
|
|
|
function escapeXmlChars(str) {
|
|
if (typeof(str) == "string")
|
|
return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, ''').replace(/\//g, '/');
|
|
else
|
|
return str;
|
|
}
|
|
|
|
function unescapeXmlChars(str) {
|
|
return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, "'").replace(///g, '\/');
|
|
}
|
|
|
|
function toArrayAccessForm(obj, childName, path) {
|
|
switch (config.arrayAccessForm) {
|
|
case "property":
|
|
if (!(obj[childName] instanceof Array))
|
|
obj[childName + "_asArray"] = [obj[childName]];
|
|
else
|
|
obj[childName + "_asArray"] = obj[childName];
|
|
break;
|
|
/*case "none":
|
|
break;*/
|
|
}
|
|
|
|
if (!(obj[childName] instanceof Array) && config.arrayAccessFormPaths.length > 0) {
|
|
var idx = 0;
|
|
for (; idx < config.arrayAccessFormPaths.length; idx++) {
|
|
var arrayPath = config.arrayAccessFormPaths[idx];
|
|
if (typeof arrayPath === "string") {
|
|
if (arrayPath == path)
|
|
break;
|
|
}
|
|
else if (arrayPath instanceof RegExp) {
|
|
if (arrayPath.test(path))
|
|
break;
|
|
}
|
|
else if (typeof arrayPath === "function") {
|
|
if (arrayPath(obj, childName, path))
|
|
break;
|
|
}
|
|
}
|
|
if (idx != config.arrayAccessFormPaths.length) {
|
|
obj[childName] = [obj[childName]];
|
|
}
|
|
}
|
|
}
|
|
|
|
function fromXmlDateTime(prop) {
|
|
// Implementation based up on http://stackoverflow.com/questions/8178598/xml-datetime-to-javascript-date-object
|
|
// Improved to support full spec and optional parts
|
|
var bits = prop.split(/[-T:+Z]/g);
|
|
|
|
var d = new Date(bits[0], bits[1] - 1, bits[2]);
|
|
var secondBits = bits[5].split("\.");
|
|
d.setHours(bits[3], bits[4], secondBits[0]);
|
|
if (secondBits.length > 1)
|
|
d.setMilliseconds(secondBits[1]);
|
|
|
|
// Get supplied time zone offset in minutes
|
|
if (bits[6] && bits[7]) {
|
|
var offsetMinutes = bits[6] * 60 + Number(bits[7]);
|
|
var sign = /\d\d-\d\d:\d\d$/.test(prop) ? '-' : '+';
|
|
|
|
// Apply the sign
|
|
offsetMinutes = 0 + (sign == '-' ? -1 * offsetMinutes : offsetMinutes);
|
|
|
|
// Apply offset and local timezone
|
|
d.setMinutes(d.getMinutes() - offsetMinutes - d.getTimezoneOffset())
|
|
}
|
|
else if (prop.indexOf("Z", prop.length - 1) !== -1) {
|
|
d = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()));
|
|
}
|
|
|
|
// d is now a local time equivalent to the supplied time
|
|
return d;
|
|
}
|
|
|
|
function checkFromXmlDateTimePaths(value, childName, fullPath) {
|
|
if (config.datetimeAccessFormPaths.length > 0) {
|
|
var path = fullPath.split("\.#")[0];
|
|
var idx = 0;
|
|
for (; idx < config.datetimeAccessFormPaths.length; idx++) {
|
|
var dtPath = config.datetimeAccessFormPaths[idx];
|
|
if (typeof dtPath === "string") {
|
|
if (dtPath == path)
|
|
break;
|
|
}
|
|
else if (dtPath instanceof RegExp) {
|
|
if (dtPath.test(path))
|
|
break;
|
|
}
|
|
else if (typeof dtPath === "function") {
|
|
if (dtPath(obj, childName, path))
|
|
break;
|
|
}
|
|
}
|
|
if (idx != config.datetimeAccessFormPaths.length) {
|
|
return fromXmlDateTime(value);
|
|
}
|
|
else
|
|
return value;
|
|
}
|
|
else
|
|
return value;
|
|
}
|
|
|
|
function parseDOMChildren(node, path) {
|
|
if (node.nodeType == DOMNodeTypes.DOCUMENT_NODE) {
|
|
var result = new Object;
|
|
var nodeChildren = node.childNodes;
|
|
// Alternative for firstElementChild which is not supported in some environments
|
|
for (var cidx = 0; cidx < nodeChildren.length; cidx++) {
|
|
var child = nodeChildren.item(cidx);
|
|
if (child.nodeType == DOMNodeTypes.ELEMENT_NODE) {
|
|
var childName = getNodeLocalName(child);
|
|
result[childName] = parseDOMChildren(child, childName);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
else if (node.nodeType == DOMNodeTypes.ELEMENT_NODE) {
|
|
var result = new Object;
|
|
result.__cnt = 0;
|
|
|
|
var nodeChildren = node.childNodes;
|
|
|
|
// Children nodes
|
|
for (var cidx = 0; cidx < nodeChildren.length; cidx++) {
|
|
var child = nodeChildren.item(cidx); // nodeChildren[cidx];
|
|
var childName = getNodeLocalName(child);
|
|
|
|
if (child.nodeType != DOMNodeTypes.COMMENT_NODE) {
|
|
result.__cnt++;
|
|
if (result[childName] == null) {
|
|
result[childName] = parseDOMChildren(child, path + "." + childName);
|
|
toArrayAccessForm(result, childName, path + "." + childName);
|
|
}
|
|
else {
|
|
if (result[childName] != null) {
|
|
if (!(result[childName] instanceof Array)) {
|
|
result[childName] = [result[childName]];
|
|
toArrayAccessForm(result, childName, path + "." + childName);
|
|
}
|
|
}
|
|
(result[childName])[result[childName].length] = parseDOMChildren(child, path + "." + childName);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Attributes
|
|
for (var aidx = 0; aidx < node.attributes.length; aidx++) {
|
|
var attr = node.attributes.item(aidx); // [aidx];
|
|
result.__cnt++;
|
|
result[config.attributePrefix + attr.name] = attr.value;
|
|
}
|
|
|
|
// Node namespace prefix
|
|
var nodePrefix = getNodePrefix(node);
|
|
if (nodePrefix != null && nodePrefix != "") {
|
|
result.__cnt++;
|
|
result.__prefix = nodePrefix;
|
|
}
|
|
|
|
if (result["#text"] != null) {
|
|
result.__text = result["#text"];
|
|
if (result.__text instanceof Array) {
|
|
result.__text = result.__text.join("\n");
|
|
}
|
|
if (config.escapeMode)
|
|
result.__text = unescapeXmlChars(result.__text);
|
|
if (config.stripWhitespaces)
|
|
result.__text = result.__text.trim();
|
|
delete result["#text"];
|
|
if (config.arrayAccessForm == "property")
|
|
delete result["#text_asArray"];
|
|
result.__text = checkFromXmlDateTimePaths(result.__text, childName, path + "." + childName);
|
|
}
|
|
if (result["#cdata-section"] != null) {
|
|
result.__cdata = result["#cdata-section"];
|
|
delete result["#cdata-section"];
|
|
if (config.arrayAccessForm == "property")
|
|
delete result["#cdata-section_asArray"];
|
|
}
|
|
|
|
if (result.__cnt == 1 && result.__text != null) {
|
|
result = result.__text;
|
|
}
|
|
else if (result.__cnt == 0 && config.emptyNodeForm == "text") {
|
|
result = '';
|
|
}
|
|
else if (result.__cnt > 1 && result.__text != null && config.skipEmptyTextNodesForObj) {
|
|
if ((config.stripWhitespaces && result.__text == "") || (result.__text.trim() == "")) {
|
|
delete result.__text;
|
|
}
|
|
}
|
|
delete result.__cnt;
|
|
|
|
if (config.enableToStringFunc && (result.__text != null || result.__cdata != null )) {
|
|
result.toString = function () {
|
|
return (this.__text != null ? this.__text : '') + ( this.__cdata != null ? this.__cdata : '');
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
else if (node.nodeType == DOMNodeTypes.TEXT_NODE || node.nodeType == DOMNodeTypes.CDATA_SECTION_NODE) {
|
|
return node.nodeValue;
|
|
}
|
|
}
|
|
|
|
function startTag(jsonObj, element, attrList, closed) {
|
|
var resultStr = "<" + ( (jsonObj != null && jsonObj.__prefix != null) ? (jsonObj.__prefix + ":") : "") + element;
|
|
if (attrList != null) {
|
|
for (var aidx = 0; aidx < attrList.length; aidx++) {
|
|
var attrName = attrList[aidx];
|
|
var attrVal = jsonObj[attrName];
|
|
if (config.escapeMode)
|
|
attrVal = escapeXmlChars(attrVal);
|
|
resultStr += " " + attrName.substr(config.attributePrefix.length) + "='" + attrVal + "'";
|
|
}
|
|
}
|
|
if (!closed)
|
|
resultStr += ">";
|
|
else
|
|
resultStr += "/>";
|
|
return resultStr;
|
|
}
|
|
|
|
function endTag(jsonObj, elementName) {
|
|
return "</" + (jsonObj.__prefix != null ? (jsonObj.__prefix + ":") : "") + elementName + ">";
|
|
}
|
|
|
|
function endsWith(str, suffix) {
|
|
return str.indexOf(suffix, str.length - suffix.length) !== -1;
|
|
}
|
|
|
|
function jsonXmlSpecialElem(jsonObj, jsonObjField) {
|
|
if ((config.arrayAccessForm == "property" && endsWith(jsonObjField.toString(), ("_asArray")))
|
|
|| jsonObjField.toString().indexOf(config.attributePrefix) == 0
|
|
|| jsonObjField.toString().indexOf("__") == 0
|
|
|| (jsonObj[jsonObjField] instanceof Function))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
function jsonXmlElemCount(jsonObj) {
|
|
var elementsCnt = 0;
|
|
if (jsonObj instanceof Object) {
|
|
for (var it in jsonObj) {
|
|
if (jsonXmlSpecialElem(jsonObj, it))
|
|
continue;
|
|
elementsCnt++;
|
|
}
|
|
}
|
|
return elementsCnt;
|
|
}
|
|
|
|
function parseJSONAttributes(jsonObj) {
|
|
var attrList = [];
|
|
if (jsonObj instanceof Object) {
|
|
for (var ait in jsonObj) {
|
|
if (ait.toString().indexOf("__") == -1 && ait.toString().indexOf(config.attributePrefix) == 0) {
|
|
attrList.push(ait);
|
|
}
|
|
}
|
|
}
|
|
return attrList;
|
|
}
|
|
|
|
function parseJSONTextAttrs(jsonTxtObj) {
|
|
var result = "";
|
|
|
|
if (jsonTxtObj.__cdata != null) {
|
|
result += "<![CDATA[" + jsonTxtObj.__cdata + "]]>";
|
|
}
|
|
|
|
if (jsonTxtObj.__text != null) {
|
|
if (config.escapeMode)
|
|
result += escapeXmlChars(jsonTxtObj.__text);
|
|
else
|
|
result += jsonTxtObj.__text;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function parseJSONTextObject(jsonTxtObj) {
|
|
var result = "";
|
|
|
|
if (jsonTxtObj instanceof Object) {
|
|
result += parseJSONTextAttrs(jsonTxtObj);
|
|
}
|
|
else if (jsonTxtObj != null) {
|
|
if (config.escapeMode)
|
|
result += escapeXmlChars(jsonTxtObj);
|
|
else
|
|
result += jsonTxtObj;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function parseJSONArray(jsonArrRoot, jsonArrObj, attrList) {
|
|
var result = "";
|
|
if (jsonArrRoot.length == 0) {
|
|
result += startTag(jsonArrRoot, jsonArrObj, attrList, true);
|
|
}
|
|
else {
|
|
for (var arIdx = 0; arIdx < jsonArrRoot.length; arIdx++) {
|
|
result += startTag(jsonArrRoot[arIdx], jsonArrObj, parseJSONAttributes(jsonArrRoot[arIdx]), false);
|
|
result += parseJSONObject(jsonArrRoot[arIdx]);
|
|
result += endTag(jsonArrRoot[arIdx], jsonArrObj);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function parseJSONObject(jsonObj) {
|
|
var result = "";
|
|
|
|
var elementsCnt = jsonXmlElemCount(jsonObj);
|
|
|
|
if (elementsCnt > 0) {
|
|
for (var it in jsonObj) {
|
|
|
|
if (jsonXmlSpecialElem(jsonObj, it))
|
|
continue;
|
|
|
|
var subObj = jsonObj[it];
|
|
|
|
var attrList = parseJSONAttributes(subObj)
|
|
|
|
if (subObj == null || subObj == undefined) {
|
|
result += startTag(subObj, it, attrList, true);
|
|
}
|
|
else if (subObj instanceof Object) {
|
|
|
|
if (subObj instanceof Array) {
|
|
result += parseJSONArray(subObj, it, attrList);
|
|
}
|
|
else if (subObj instanceof Date) {
|
|
result += startTag(subObj, it, attrList, false);
|
|
result += subObj.toISOString();
|
|
result += endTag(subObj, it);
|
|
}
|
|
else {
|
|
var subObjElementsCnt = jsonXmlElemCount(subObj);
|
|
if (subObjElementsCnt > 0 || subObj.__text != null || subObj.__cdata != null) {
|
|
result += startTag(subObj, it, attrList, false);
|
|
result += parseJSONObject(subObj);
|
|
result += endTag(subObj, it);
|
|
}
|
|
else {
|
|
result += startTag(subObj, it, attrList, true);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
result += startTag(subObj, it, attrList, false);
|
|
result += parseJSONTextObject(subObj);
|
|
result += endTag(subObj, it);
|
|
}
|
|
}
|
|
}
|
|
result += parseJSONTextObject(jsonObj);
|
|
|
|
return result;
|
|
}
|
|
|
|
this.parseXmlString = function (xmlDocStr) {
|
|
var isIEParser = window.ActiveXObject || "ActiveXObject" in window;
|
|
if (xmlDocStr === undefined) {
|
|
return null;
|
|
}
|
|
var xmlDoc;
|
|
if (window.DOMParser) {
|
|
var parser = new window.DOMParser();
|
|
var parsererrorNS = null;
|
|
// IE9+ now is here
|
|
if (!isIEParser) {
|
|
try {
|
|
parsererrorNS = parser.parseFromString("INVALID", "text/xml").childNodes[0].namespaceURI;
|
|
}
|
|
catch (err) {
|
|
parsererrorNS = null;
|
|
}
|
|
}
|
|
try {
|
|
xmlDoc = parser.parseFromString(xmlDocStr, "text/xml");
|
|
if (parsererrorNS != null && xmlDoc.getElementsByTagNameNS(parsererrorNS, "parsererror").length > 0) {
|
|
//throw new Error('Error parsing XML: '+xmlDocStr);
|
|
xmlDoc = null;
|
|
}
|
|
}
|
|
catch (err) {
|
|
xmlDoc = null;
|
|
}
|
|
}
|
|
else {
|
|
// IE :(
|
|
if (xmlDocStr.indexOf("<?") == 0) {
|
|
xmlDocStr = xmlDocStr.substr(xmlDocStr.indexOf("?>") + 2);
|
|
}
|
|
xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
|
|
xmlDoc.async = "false";
|
|
xmlDoc.loadXML(xmlDocStr);
|
|
}
|
|
return xmlDoc;
|
|
};
|
|
|
|
this.asArray = function (prop) {
|
|
if (prop instanceof Array)
|
|
return prop;
|
|
else
|
|
return [prop];
|
|
};
|
|
|
|
this.toXmlDateTime = function (dt) {
|
|
if (dt instanceof Date)
|
|
return dt.toISOString();
|
|
else if (typeof(dt) === 'number')
|
|
return new Date(dt).toISOString();
|
|
else
|
|
return null;
|
|
};
|
|
|
|
this.asDateTime = function (prop) {
|
|
if (typeof(prop) == "string") {
|
|
return fromXmlDateTime(prop);
|
|
}
|
|
else
|
|
return prop;
|
|
};
|
|
|
|
this.xml2json = function (xmlDoc) {
|
|
return parseDOMChildren(xmlDoc);
|
|
};
|
|
|
|
this.xml_str2json = function(xmlDocStr) {
|
|
var xmlDoc = this.parseXmlString(xmlDocStr);
|
|
if (xmlDoc != null)
|
|
return this.xml2json(xmlDoc);
|
|
else
|
|
return null;
|
|
};
|
|
|
|
this.json2xml_str = function (jsonObj) {
|
|
return parseJSONObject(jsonObj);
|
|
};
|
|
|
|
this.json2xml = function (jsonObj) {
|
|
var xmlDocStr = this.json2xml_str(jsonObj);
|
|
return this.parseXmlString(xmlDocStr);
|
|
};
|
|
|
|
this.getVersion = function () {
|
|
return VERSION;
|
|
};
|
|
|
|
} |