-
-
X
-
+
+
TODO
+
-
-
stop
-
play
-
prev
-
next
-
B=0x0000
-
T=0x0000
-
Madeon - Finale
-
Megumi
-
white
-
\ No newline at end of file
diff --git a/js/HuesCanvas.js b/js/HuesCanvas.js
new file mode 100644
index 0000000..e212429
--- /dev/null
+++ b/js/HuesCanvas.js
@@ -0,0 +1,303 @@
+
+/* Takes an element name to attach to, and an audio context element for
+ getting the current time with reasonable accuracy */
+function HuesCanvas(element, aContext, core) {
+ 'use strict';
+ this.aContext = aContext;
+ this.core = core;
+
+ this.needsRedraw = false;
+ this.colour = 0xFFFFFF;
+ this.image = null;
+
+ this.animTimeout;
+ this.animFrame;
+
+ // set later
+ this.blurDecay;
+ this.blurAmount;
+ this.blurIterations;
+ this.blurMin;
+ this.blurMax;
+ this.blurDelta;
+ this.blurAlpha;
+ // dynamic
+ this.blurStart = 0;
+ this.blurDistance = 0;
+ this.xBlur = false;
+ this.yBlur = false;
+
+ this.blackout = false;
+ this.blackoutColour = "#000"; // for the whiteout case we must store this
+ this.blackoutTimeout;
+
+ this.colourFade = false;
+ this.colourFadeStart=0;
+ this.colourFadeLength=0;
+ this.oldColour=0xFFFFFF;
+ this.newColour=0xFFFFFF;
+
+ this.blendMode = "hard-light";
+ // Chosen because they look decent
+ this.setBlurAmount(15);
+ this.setBlurIterations(5);
+ this.setBlurDecay(25);
+ this.canvas = document.getElementById(element).getContext("2d");
+ window.addEventListener('resize', this.resizeHandler(this));
+ this.resize();
+
+ this.animating = true;
+ requestAnimationFrame(this.getAnimLoop());
+}
+
+HuesCanvas.prototype.resizeHandler = function(that) {
+ return function() {that.resize();};
+}
+
+HuesCanvas.prototype.resize = function() {
+ // height is constant 720px, we expand width to suit
+ var ratio = window.innerWidth / window.innerHeight;
+ this.canvas.canvas.width = 720 * ratio + 1;
+ this.needsRedraw = true;
+}
+
+HuesCanvas.prototype.redraw = function() {
+ var offset; // for centering/right/left align
+ var bOpacity;
+ var width = this.canvas.canvas.width;
+
+ var cTime = this.aContext.currentTime;
+ // white BG for the hard light filter
+ this.canvas.globalAlpha = 1;
+ this.canvas.globalCompositeOperation = "source-over";
+ if(this.blackout) {
+ // original is 3 frames at 30fps, this is close
+ bOpacity = (cTime - this.blackoutStart)*10;
+ if(bOpacity > 1) { // optimise the draw
+ this.canvas.fillStyle = this.blackoutColour;
+ this.canvas.fillRect(0,0,width,720);
+ this.needsRedraw = false;
+ return;
+ }
+ } else {
+ this.canvas.fillStyle = "#FFF";
+ this.canvas.fillRect(0,0,width,720);
+ }
+
+ if(this.image) {
+ var bitmap = this.image.animated ?
+ this.image.bitmaps[this.animFrame] : this.image.bitmap;
+ switch(this.image.align) {
+ case "left":
+ offset = 0;
+ break;
+ case "right":
+ offset = width - bitmap.width;
+ break;
+ default:
+ offset = width/2 - bitmap.width/2;
+ break;
+ }
+ if(this.xBlur || this.yBlur) {
+ this.canvas.globalAlpha = this.blurAlpha;
+ var delta = cTime - this.blurStart;
+ this.blurDistance = this.blurAmount * Math.exp(-this.blurDecay * delta);
+ }
+ if(this.xBlur) {
+ for(var i=this.blurMin; i<=this.blurMax; i+= this.blurDelta) {
+ this.canvas.drawImage(bitmap, Math.floor(this.blurDistance * i) + offset, 0);
+ }
+ } else if(this.yBlur) {
+ for(var i=this.blurMin; i<=this.blurMax; i+= this.blurDelta) {
+ this.canvas.drawImage(bitmap, offset, Math.floor(this.blurDistance * i));
+ }
+ } else {
+ this.canvas.globalAlpha = 1;
+ this.canvas.drawImage(bitmap, offset, 0);
+ }
+ }
+ this.canvas.globalAlpha = 0.7;
+ this.canvas.fillStyle = this.intToHex(this.colour);
+ this.canvas.globalCompositeOperation = this.blendMode;
+ this.canvas.fillRect(0,0,width,720);
+ if(this.blackout) {
+ this.canvas.globalAlpha = bOpacity;
+ this.canvas.fillStyle = this.blackoutColour;
+ this.canvas.fillRect(0,0,width,720);
+ this.needsRedraw = true;
+ } else {
+ this.needsRedraw = false;
+ }
+}
+
+/* Second fastest method from
+ http://stackoverflow.com/questions/10073699/pad-a-number-with-leading-zeros-in-javascript
+ It stil does millions of ops per second, and isn't ugly like the integer if/else */
+HuesCanvas.prototype.intToHex = function(num) {
+ return '#' + ("00000"+num.toString(16)).slice(-6);
+}
+
+HuesCanvas.prototype.getAnimLoop = function() {
+ var that = this;
+ return function() {that.animationLoop()};
+}
+
+HuesCanvas.prototype.animationLoop = function() {
+ if (this.colourFade) {
+ var delta = this.aContext.currentTime - this.colourFadeStart;
+ var fadeVal = delta / this.colourFadeLength;
+ if (fadeVal >= 1) {
+ this.stopFade();
+ this.colour = this.newColour;
+ } else {
+ this.mixColours(fadeVal);
+ }
+ this.needsRedraw = true;
+ }
+ if(this.blackoutTimeout && this.aContext.currentTime > this.blackoutTimeout) {
+ this.clearBlackout();
+ }
+ if(this.image && this.image.animated
+ && this.animTimeout < this.aContext.currentTime) {
+ this.animFrame++;
+ this.animFrame %= this.image.frameDurations.length;
+ this.animTimeout = this.aContext.currentTime +
+ this.image.frameDurations[this.animFrame]/1000;
+ this.needsRedraw = true;
+ }
+ if(this.blurStart) {
+ var dist = this.blurDistance / this.blurAmount;
+ if(this.xBlur)
+ this.core.blurUpdated(dist, 0);
+ else
+ this.core.blurUpdated(0, dist);
+ }
+ if(this.blurStart && this.blurDistance < 0.3) {
+ this.core.blurUpdated(0, 0);
+ this.blurDistance = 0;
+ this.blurStart = 0;
+ this.xBlur = this.yBlur = false;
+ this.redraw();
+ } else if(this.blurStart) {
+ this.redraw();
+ } else if(this.needsRedraw){
+ this.redraw();
+ }
+ if(this.animating) {
+ requestAnimationFrame(this.getAnimLoop());
+ }
+}
+
+HuesCanvas.prototype.setImage = function(image) {
+ this.needsRedraw = true;
+ this.image = image;
+ // Null images don't need anything interesting done to them
+ if(!image || (!image.bitmap && !image.bitmaps)) {
+ return;
+ }
+ if(image.animated) {
+ this.animFrame = 0;
+ this.animTimeout = this.aContext.currentTime + image.frameDurations[0]/1000;
+ }
+}
+
+HuesCanvas.prototype.setColour = function(colour) {
+ this.stopFade();
+ this.colour = colour;
+ this.needsRedraw = true;
+}
+
+HuesCanvas.prototype.doBlackout = function(whiteout) {
+ if (typeof(whiteout)==='undefined') whiteout = false;
+ if(whiteout) {
+ this.blackoutColour = "#FFF";
+ } else {
+ this.blackoutColour = "#000";
+ }
+ this.blackoutTimeout = 0; // indefinite
+ this.blackoutStart = this.aContext.currentTime;
+ this.blackout = true;
+ this.needsRedraw = true;
+}
+
+// for song changes
+HuesCanvas.prototype.clearBlackout = function() {
+ this.blackout = false;
+ this.blackoutTimeout = 0;
+ this.needsRedraw = true;
+}
+
+HuesCanvas.prototype.doShortBlackout = function(beatTime) {
+ this.doBlackout();
+ // GetRandomWaifu(); TODO IMPLEMENT IN CORE INSTEAD
+ this.blackoutTimeout = this.aContext.currentTime + beatTime / 1.7;
+ // looks better if we go right to black
+ this.blackoutStart = 0;
+}
+
+HuesCanvas.prototype.doColourFade = function(length, newColour) {
+ this.colourFade = true;
+ this.colourFadeLength = length;
+ this.colourFadeStart = this.aContext.currentTime;
+ this.oldColour = this.colour;
+ this.newColour = newColour;
+}
+
+HuesCanvas.prototype.stopFade = function() {
+ this.colourFade = false;
+ this.colourFadeStart = 0;
+ this.colourFadeLength = 0;
+}
+
+HuesCanvas.prototype.mixColours = function(percent) {
+ percent = Math.min(1, percent);
+ var oldR = this.oldColour >> 16 & 0xFF;
+ var oldG = this.oldColour >> 8 & 0xFF;
+ var oldB = this.oldColour & 0xFF;
+ var newR = this.newColour >> 16 & 0xFF;
+ var newG = this.newColour >> 8 & 0xFF;
+ var newB = this.newColour & 0xFF;
+ var mixR = oldR * (1 - percent) + newR * percent;
+ var mixG = oldG * (1 - percent) + newG * percent;
+ var mixB = oldB * (1 - percent) + newB * percent;
+ this.colour = mixR << 16 | mixG << 8 | mixB;
+}
+
+HuesCanvas.prototype.doXBlur = function() {
+ this.blurStart = this.aContext.currentTime;
+ this.blurDistance = this.blurAmount;
+ this.xBlur = true;
+ this.yBlur = false;
+ this.needsRedraw = true;
+}
+
+HuesCanvas.prototype.doYBlur = function() {
+ this.blurStart = this.aContext.currentTime;
+ this.blurDistance = this.blurAmount;
+ this.xBlur = false;
+ this.yBlur = true;
+ this.needsRedraw = true;
+}
+
+HuesCanvas.prototype.setBlurDecay = function(decay) {
+ this.blurDecay = decay;
+}
+
+HuesCanvas.prototype.setBlurIterations = function(iterations) {
+ this.blurIterations = iterations;
+ this.blurDelta = this.blurAmount / this.blurIterations;
+ this.blurAlpha = 1/(this.blurIterations/2);
+}
+
+HuesCanvas.prototype.setBlurAmount = function(amount) {
+ this.blurAmount = amount;
+ this.blurMin = -this.blurAmount/2;
+ this.blurMax = this.blurAmount/2;
+}
+
+HuesCanvas.prototype.setAnimating = function(anim) {
+ if(!this.animating && anim) {
+ requestAnimationFrame(this.animationLoop);
+ }
+ this.animating = anim;
+}
\ No newline at end of file
diff --git a/js/HuesCore.js b/js/HuesCore.js
new file mode 100644
index 0000000..d340dcc
--- /dev/null
+++ b/js/HuesCore.js
@@ -0,0 +1,843 @@
+var defaultSettings = {
+ load : true, // Debugging var, for loading zips or not
+ autoplay : true, // Debug, play first song automatically?
+ blurQuality: 2, // low/med/high/extreme 0-3
+
+ // UI accessible config
+ // Autosong stuff is a todo, becuase why even implement that
+ smartAlign: true,
+ blurAmount: 1, // 0,1,2,3 = off,low,med,high
+ blurDecay: 2, // 0,1,2,3 = slow,med,fast,faster!
+ colourSet: "normal", // normal, pastel, 420
+ blackoutUI: false,
+ playBuildups: "on", // off, once, on
+ volume : 0.7
+}
+
+HuesCore = function(defaults) {
+ // Bunch-o-initialisers
+ this.version = "0x01";
+ this.beatIndex = 0;
+ this.beatLength=-1;
+ this.currentSong;
+ this.currentImage;
+ this.songIndex=-1;
+ this.colourIndex=0;
+ this.imageIndex=-1;
+ this.isFullAuto = true;
+ this.currentVolume=70;
+ this.volumeMuted=false;
+ this.loopCount=0;
+ this.doRandom = false;
+ this.lastSC=0;
+ this.buildupDiff=0;
+ this.animTimeoutID;
+ this.fadeOut=false;
+ this.fadeDirection=false;
+ this.loadedFiles=0;
+ this.doBuildup=true;
+ this.userInterface = null;
+
+ for(var attr in defaultSettings) {
+ if(defaults[attr] == undefined)
+ defaults[attr] = defaultSettings[attr];
+ }
+
+ console.log("0x40 Hues - start your engines!");
+ this.colours = this.oldColours;
+ this.uiArray = [];
+ this.lastSongArray = [];
+ this.lastImageArray = [];
+ this.settings = new HuesSettings(defaults);
+ this.autoSong = this.settings.autosong;
+ this.resourceManager = new Resources();
+ this.soundManager = new SoundManager();
+ if(!this.soundManager.canUse) {
+ this.error("Web Audio API not supported in this browser.");
+ return;
+ }
+ this.renderer = new HuesCanvas("waifu", this.soundManager.context, this);
+
+ this.uiArray.push(new RetroUI(), new WeedUI(), new ModernUI(), new XmasUI());
+ this.changeUI(1);
+ this.settings.connectCore(this);
+
+ // todo: only after respacks loaded?
+ var that = this;
+ if(defaults.load) {
+ this.resourceManager.addAll(defaults.respacks, function() {
+ document.getElementById("preloadHelper").className = "loaded";
+ window.setTimeout(function() {
+ document.getElementById("preloadHelper").style.display = "none";
+ }, 1500);
+ that.setImage(0);
+ if(defaults.autoplay) {
+ that.setSong(0);
+ // TODO delete me
+ that.previousSong();
+ that.previousSong();
+ }
+ }, function(progress) {
+ var prog = document.getElementById("preMain");
+ var scale = Math.floor(progress * 0x40);
+ prog.textContent = '0x' + ("00"+scale.toString(16)).slice(-2);
+ });
+ } else {
+ document.getElementById("preloadHelper").style.display = "none";
+ }
+
+ document.onkeydown = function(e){
+ e = e || window.event;
+ var key = e.keyCode || e.which;
+ return that.keyHandler(key);
+ };
+
+ window.onerror = function(msg, url, line, col, error) {
+ that.error(msg);
+
+ // Get more info in console
+ return false;
+ };
+
+ this.animationLoop();
+}
+
+HuesCore.prototype.animationLoop = function() {
+ var that = this;
+ if(!this.soundManager.playing) {
+ requestAnimationFrame(function() {that.animationLoop()});
+ return;
+ }
+ var now = this.soundManager.currentTime();
+ if(now < 0) {
+ this.userInterface.updateTime(0);
+ } else {
+ this.userInterface.updateTime(this.soundManager.displayableTime());
+ }
+ for(var beatTime = this.beatIndex * this.beatLength; beatTime < now;
+ beatTime = ++this.beatIndex * this.beatLength) {
+ var beat = this.getBeat(this.beatIndex);
+ this.beater(beat);
+ }
+ requestAnimationFrame(function() {that.animationLoop()});
+}
+
+HuesCore.prototype.getCurrentMode = function() {
+ return this.isFullAuto ? "FULL AUTO" : "NORMAL";
+}
+
+HuesCore.prototype.getSafeBeatIndex = function() {
+ if(!this.soundManager.playing) {
+ return 0;
+ }
+ if(this.beatIndex < 0) {
+ return 0;
+ } else {
+ return this.beatIndex % this.currentSong.rhythm.length;
+ }
+}
+
+HuesCore.prototype.blurUpdated = function(x, y) {
+ this.userInterface.blurUpdated(x, y);
+}
+
+HuesCore.prototype.nextSong = function() {
+ this.lastSongArray = [];
+ var index = (this.songIndex + 1) % this.resourceManager.enabledSongs.length;
+ this.setSong(index);
+}
+
+HuesCore.prototype.previousSong = function() {
+ this.lastSongArray = [];
+ var index = ((this.songIndex - 1) + this.resourceManager.enabledSongs.length) % this.resourceManager.enabledSongs.length;
+ this.setSong(index);
+}
+
+HuesCore.prototype.setSong = function(index) {
+ this.soundManager.stop();
+ this.songIndex = index;
+ this.currentSong = this.resourceManager.enabledSongs[this.songIndex];
+ if (this.currentSong == undefined) {
+ this.currentSong = {"name":"None", "title":"None", "rhythm":".", "source":null, "crc":"none", "sound":null, "enabled":true, "filename":"none"};
+ }
+ console.log("Next song:", this.songIndex, this.currentSong);
+ this.userInterface.setSongText();
+ this.loopCount = 0;
+ if (this.currentSong.buildup) {
+ if (this.currentSong.force) {
+ if (this.currentSong.force != "song") {
+ this.currentSong.buildupPlayed = false;
+ this.doBuildup = true;
+ } else {
+ this.currentSong.buildupPlayed = true;
+ this.doBuildup = false;
+ }
+ this.currentSong.force = null;
+ } else {
+ switch (this.settings.buildups) {
+ case "off":
+ this.currentSong.buildupPlayed = true;
+ this.doBuildup = false;
+ break;
+ case "on":
+ this.currentSong.buildupPlayed = false;
+ this.doBuildup = true;
+ break;
+ case "once":
+ this.doBuildup = !this.currentSong.buildupPlayed;
+ break;
+ }
+ }
+ }
+ this.resetAudio();
+ var that = this;
+ this.soundManager.playSong(this.currentSong, function() {
+ that.fillBuildup();
+ });
+}
+
+HuesCore.prototype.fillBuildup = function() {
+ this.beatLength = this.soundManager.loopLength / this.currentSong.rhythm.length;
+ var buildBeats = Math.floor(this.soundManager.loopStart / this.beatLength) + 1;
+ if (this.currentSong.buildupRhythm == null) {
+ this.currentSong.buildupRhythm = "";
+ }
+ if (this.currentSong.buildupRhythm.length < buildBeats) {
+ console.log("Filling buildup beatmap");
+ while (this.currentSong.buildupRhythm.length < buildBeats) {
+ this.currentSong.buildupRhythm = this.currentSong.buildupRhythm + ".";
+ }
+ }
+ console.log("Buildup length:", buildBeats);
+ this.beatIndex = this.doBuildup ? -this.currentSong.buildupRhythm.length : 0;
+}
+
+HuesCore.prototype.randomSong = function() {
+ var index=Math.floor((Math.random() * this.resourceManager.enabledSongs.length));
+ if (index == this.songIndex && this.resourceManager.enabledSongs.length > 1 || !(this.lastSongArray.indexOf(index) == -1)) {
+ this.randomSong();
+ } else {
+ console.log("Randoming a song!");
+ this.setSong(index);
+ this.lastSongArray.push(index);
+ noRepeat = Math.min(5, Math.floor((this.resourceManager.enabledSongs.length / 2)));
+ while (this.lastSongArray.length > noRepeat && noRepeat >= 0) {
+ this.lastSongArray.shift();
+ }
+ }
+}
+/*
+HuesCore.prototype.onLoop = function() {
+ this.loopCount = this.loopCount + 1;
+ switch (this.settings.autosong) {
+ case "loop":
+ console.log("Checking loops");
+ if (this.loopCount >= this.settings.autosongDelay) {
+ this.startSongChangeFade();
+ }
+ break;
+ case "time":
+ console.log("Checking times");
+ if (this.currentSong.sound && this.calculateSongLength(this.currentSong.sound) / 1000 * this.loopCount >= this.settings.autosongDelay * 60) {
+ this.startSongChangeFade();
+ }
+ break;
+ }
+}
+
+HuesCore.prototype.startSongChangeFade = function() {
+ this.fadeDirection = true;
+ this.fadeOut = true;
+}
+*/
+HuesCore.prototype.songDataUpdated = function() {
+ if (this.currentSong) {
+ this.beatLength = 0;
+ this.userInterface.updateLists();
+ this.userInterface.updateTexts();
+ this.userInterface.setSongText();
+ this.userInterface.setImageText();
+ } else {
+ this.beatLength = -1;
+ }
+}
+
+HuesCore.prototype.resetAudio = function() {
+ this.samplePosition = 0;
+ this.beatIndex = 0;
+ this.position = 0;
+ this.lastSC = 0;
+ this.buildupDiff = 0;
+ this.songDataUpdated();
+}
+
+HuesCore.prototype.randomImage = function() {
+ var len = this.resourceManager.enabledImages.length;
+ var index=Math.floor(Math.random() * len);
+ if ((index == this.imageIndex || this.lastImageArray.indexOf(index) != -1) && len > 1) {
+ this.randomImage();
+ } else {
+ this.setImage(index);
+ this.lastImageArray.push(index);
+ var cull = Math.min(20, Math.floor((len / 2)));
+ while (this.lastImageArray.length > cull && cull >= 0) {
+ this.lastImageArray.shift();
+ }
+ }
+}
+
+HuesCore.prototype.getImageIndex = function() {
+ return this.imageIndex;
+}
+
+HuesCore.prototype.setImage = function(index) {
+ this.imageIndex = index;
+ var img=this.resourceManager.enabledImages[this.imageIndex];
+ if (img == this.currentImage && !(img == null)) {
+ return;
+ }
+ if (img) {
+ this.currentImage = img;
+ } else if (!this.currentImage) {
+ this.currentImage = {"name":"None", "fullname":"None", "align":"center", "bitmap":null, "source":null, "enabled":true};
+ this.imageIndex = -1;
+ this.lastImageArray = [];
+ }
+ this.renderer.setImage(this.currentImage);
+ this.userInterface.setImageText();
+}
+
+HuesCore.prototype.nextImage = function() {
+ this.setIsFullAuto(false);
+ var img=(this.imageIndex + 1) % this.resourceManager.enabledImages.length;
+ this.setImage(img);
+ this.lastImageArray = [];
+}
+
+HuesCore.prototype.previousImage = function() {
+ this.setIsFullAuto(false);
+ var img=((this.imageIndex - 1) + this.resourceManager.enabledImages.length) % this.resourceManager.enabledImages.length;
+ this.setImage(img);
+ this.lastImageArray = [];
+}
+
+HuesCore.prototype.randomColourIndex = function() {
+ var index=Math.floor((Math.random() * 64));
+ if (index == this.colourIndex) {
+ return this.randomColourIndex();
+ }
+ return index;
+}
+
+HuesCore.prototype.randomColour = function() {
+ var index=this.randomColourIndex();
+ this.setColour(index);
+}
+
+HuesCore.prototype.setColour = function(index) {
+ this.colourIndex = index;
+ this.renderer.setColour(this.colours[this.colourIndex].c);
+ this.userInterface.setColourText();
+}
+
+HuesCore.prototype.getBeat = function(index) {
+ if(index < 0) {
+ return this.currentSong.buildupRhythm[this.currentSong.buildupRhythm.length+index];
+ } else {
+ return this.currentSong.rhythm[index % this.currentSong.rhythm.length];
+ }
+}
+
+HuesCore.prototype.beater = function(beat) {
+ this.userInterface.beat();
+ switch(beat) {
+ case 'X':
+ case 'x':
+ this.renderer.doYBlur();
+ break;
+ case 'O':
+ case 'o':
+ this.renderer.doXBlur();
+ break;
+ case '+':
+ this.renderer.doXBlur();
+ this.renderer.doBlackout();
+ break;
+ case '¤':
+ this.renderer.doXBlur();
+ this.renderer.doBlackout(true);
+ break;
+ case '|':
+ this.renderer.doShortBlackout(this.beatLength);
+ this.randomColour();
+ break;
+ case ':':
+ this.randomColour();
+ break;
+ case '*':
+ if(this.isFullAuto) {
+ this.randomImage();
+ }
+ break;
+ case '=':
+ if(this.isFullAuto) {
+ this.randomImage();
+ }
+ case '~':
+ // case: fade in build, not in rhythm. Must max out fade timer.
+ var maxSearch = this.currentSong.rhythm.length;
+ if(this.beatIndex < 0) {
+ maxSearch -= this.beatIndex;
+ }
+ var fadeLen;
+ for (fadeLen = 1; fadeLen <= maxSearch; fadeLen++) {
+ if (this.getBeat(fadeLen + this.beatIndex) != ".") {
+ break;
+ }
+ }
+ this.stopFade();
+ this.startFade(fadeLen * this.beatLength);
+ break;
+ }
+ if ([".", "+", "|", "¤"].indexOf(beat) == -1) {
+ this.renderer.clearBlackout();
+ }
+ if([".", "+", ":", "*", "X", "O", "~", "="].indexOf(beat) == -1) {
+ this.randomColour();
+ if (this.isFullAuto) {
+ this.randomImage();
+ }
+ }
+}
+
+HuesCore.prototype.getBeatString = function(length) {
+ length = length ? length : 256;
+
+ var beatString = "";
+ var song = this.currentSong;
+ if (song) {
+ if(this.beatIndex < 0) {
+ beatString = song.buildupRhythm.slice(
+ song.buildupRhythm.length + this.beatIndex);
+ } else {
+ beatString = song.rhythm.slice(this.beatIndex % song.rhythm.length);
+ }
+ while (beatString.length < length) {
+ beatString += song.rhythm;
+ }
+ }
+
+ return beatString;
+}
+
+HuesCore.prototype.setIsFullAuto = function(auto) {
+ this.isFullAuto = auto;
+ if (this.userInterface) {
+ this.userInterface.modeUpdated();
+ }
+}
+
+/*HuesCore.prototype.enterFrame = function() {
+ this.setTexts();
+ if (this.fadeOut) {
+ // 30fps frame locked, TODO
+ delta = this.fadeDirection ? -2 : 2;
+ if (this.soundChannel) {
+ fadeTo = Math.max(0, Math.min(this.currentVolume, soundManager.volume + delta));
+ this.soundManager.setVolume(fadeTo);
+ if (fadeTo == 0) {
+ this.fadeOut = false;
+ this.fadeDirection = false;
+ if (this.settings.autosongShuffle) {
+ this.randomSong();
+ } else {
+ this.nextSong();
+ }
+ }
+ }
+ }
+}*/
+
+HuesCore.prototype.respackLoaded = function() {
+ this.init();
+ this.userInterface.updateLists();
+}
+
+/*HuesCore.prototype.rightClickListener = function(event) {
+ switch (event) {
+ case flash.events.MouseEvent.RIGHT_CLICK:
+ this.toggleSettingsWindow();
+ break;
+ case flash.events.MouseEvent.MOUSE_WHEEL:
+ if (event.delta > 0) {
+ this.soundManager.increaseVolume();
+ } else {
+ this.soundManager.decreaseVolume();
+ }
+ break;
+ }
+}*/
+
+HuesCore.prototype.changeUI = function(index) {
+ if (index >= 0 && this.uiArray.length > index && !(this.userInterface == this.uiArray[index])) {
+ if(this.userInterface)
+ this.userInterface.disconnect();
+ this.userInterface = this.uiArray[index];
+ this.userInterface.connectCore(this);
+ this.userInterface.updateLists();
+ this.userInterface.updateTexts();
+ this.userInterface.setSongText();
+ this.userInterface.setImageText();
+ this.userInterface.setColourText(this.colourIndex);
+ this.userInterface.beat();
+ }
+}
+
+HuesCore.prototype.settingsUpdated = function() {
+ console.log("Updating according to this.settings");
+ this.blurMultiplier = {"low":0.5, "medium":1, "high":4}[this.settings.blurAmount];
+ this.blurDecayMultiplier = {"low":0.3, "medium":0.6, "high":1, "vhigh":1.6}[this.settings.blurDecay];
+ //this.settings.blackoutUI;
+ // todo: blackoutUI
+ switch (this.settings.colours) {
+ case "normal":
+ this.colours = this.oldColours;
+ break;
+ case "pastel":
+ this.colours = this.pastelColours;
+ break;
+ case "gp":
+ this.colours = this.weedColours;
+ break;
+ }
+ switch (this.settings.ui) {
+ case "retro":
+ this.changeUI(0);
+ break;
+ case "weed":
+ this.changeUI(1);
+ break;
+ case "modern":
+ this.changeUI(2);
+ break;
+ case "xmas":
+ this.changeUI(3);
+ break;
+ }
+ /*if (this.autoSong == "off" && !(this.settings.autosong == "off")) {
+ console.log("Resetting loopCount since AutoSong was enabled");
+ this.loopCount = 0;
+ this.autoSong = this.settings.autosong;
+ }*/
+}
+
+HuesCore.prototype.enabledChanged = function() {
+ this.resourceManager.rebuildEnabled();
+ this.userInterface.updateLists();
+}
+
+HuesCore.prototype.hideLists = function() {
+ this.userInterface.songList.hide();
+ this.userInterface.imageList.hide();
+}
+
+HuesCore.prototype.toggleSongList = function() {
+ this.userInterface.songList.toggleHide();
+ this.userInterface.imageList.hide();
+}
+
+HuesCore.prototype.toggleImageList = function() {
+ this.userInterface.imageList.toggleHide();
+ this.userInterface.songList.hide();
+}
+
+HuesCore.prototype.openSongSource = function() {
+ if (this.currentSong && this.currentSong.source) {
+ window.open(this.currentSong.source,'_blank');
+ }
+}
+
+HuesCore.prototype.openImageSource = function() {
+ if (this.currentImage && this.currentImage.source) {
+ window.open(this.currentImage.source,'_blank');
+ }
+}
+
+HuesCore.prototype.keyHandler = function(key) {
+ switch (key) {
+ case 37: // LEFT
+ this.previousImage();
+ break;
+ case 39: // RIGHT
+ this.nextImage();
+ break;
+ case 38: // UP
+ this.nextSong();
+ break;
+ case 40: // DOWN
+ this.previousSong();
+ break;
+ case 70: // F
+ this.setIsFullAuto(!this.isFullAuto);
+ break;
+ case 109: // NUMPAD_SUBTRACT
+ case 189: // MINUS
+ case 173: // MINUS, legacy
+ this.soundManager.decreaseVolume();
+ break;
+ case 107: // NUMPAD_ADD
+ case 187: // EQUAL
+ case 61: // EQUAL, legacy
+ this.soundManager.increaseVolume();
+ break;
+ case 77: // M
+ this.soundManager.toggleMute();
+ break;
+ case 72: // H
+ this.userInterface.toggleHide();
+ break;
+ case 82: // R
+ this.window.showRespacks();
+ break;
+ case 69: // E
+ this.window.showEditor();
+ break;
+ case 79: // O
+ this.window.showOptions();
+ break;
+ case 73: // I
+ this.window.showInfo();
+ break;
+ case 49: // NUMBER_1
+ this.changeUI(0);
+ break;
+ case 50: // NUMBER_2
+ this.changeUI(1);
+ break;
+ case 51: // NUMBER_3
+ this.changeUI(2);
+ break;
+ case 52: // NUMBER_4
+ this.changeUI(3);
+ break;
+ case 76: // L
+ this.loadLocal();
+ break;
+ case 67: // C
+ this.toggleImageList();
+ break;
+ case 83: // S
+ this.toggleSongList();
+ break;
+ case 87: // W
+ this.toggleSettingsWindow();
+ break;
+ case 16: // SHIFT
+ this.randomSong();
+ break;
+ default:
+ return true;
+ }
+ return false;
+}
+
+HuesCore.prototype.error = function(message) {
+ document.getElementById("preSub").textContent = "Error: " + message;
+ document.getElementById("preMain").style.color = "#F00";
+}
+
+HuesCore.prototype.oldColours =
+ [{'c': 0x000000, 'n': 'black'},
+ {'c': 0x550000, 'n': 'brick'},
+ {'c': 0xAA0000, 'n': 'crimson'},
+ {'c': 0xFF0000, 'n': 'red'},
+ {'c': 0x005500, 'n': 'turtle'},
+ {'c': 0x555500, 'n': 'sludge'},
+ {'c': 0xAA5500, 'n': 'brown'},
+ {'c': 0xFF5500, 'n': 'orange'},
+ {'c': 0x00AA00, 'n': 'green'},
+ {'c': 0x55AA00, 'n': 'grass'},
+ {'c': 0xAAAA00, 'n': 'maize'},
+ {'c': 0xFFAA00, 'n': 'citrus'},
+ {'c': 0x00FF00, 'n': 'lime'},
+ {'c': 0x55FF00, 'n': 'leaf'},
+ {'c': 0xAAFF00, 'n': 'chartreuse'},
+ {'c': 0xFFFF00, 'n': 'yellow'},
+ {'c': 0x000055, 'n': 'midnight'},
+ {'c': 0x550055, 'n': 'plum'},
+ {'c': 0xAA0055, 'n': 'pomegranate'},
+ {'c': 0xFF0055, 'n': 'rose'},
+ {'c': 0x005555, 'n': 'swamp'},
+ {'c': 0x555555, 'n': 'dust'},
+ {'c': 0xAA5555, 'n': 'dirt'},
+ {'c': 0xFF5555, 'n': 'blossom'},
+ {'c': 0x00AA55, 'n': 'sea'},
+ {'c': 0x55AA55, 'n': 'ill'},
+ {'c': 0xAAAA55, 'n': 'haze'},
+ {'c': 0xFFAA55, 'n': 'peach'},
+ {'c': 0x00FF55, 'n': 'spring'},
+ {'c': 0x55FF55, 'n': 'mantis'},
+ {'c': 0xAAFF55, 'n': 'brilliant'},
+ {'c': 0xFFFF55, 'n': 'canary'},
+ {'c': 0x0000AA, 'n': 'navy'},
+ {'c': 0x5500AA, 'n': 'grape'},
+ {'c': 0xAA00AA, 'n': 'mauve'},
+ {'c': 0xFF00AA, 'n': 'purple'},
+ {'c': 0x0055AA, 'n': 'cornflower'},
+ {'c': 0x5555AA, 'n': 'deep'},
+ {'c': 0xAA55AA, 'n': 'lilac'},
+ {'c': 0xFF55AA, 'n': 'lavender'},
+ {'c': 0x00AAAA, 'n': 'aqua'},
+ {'c': 0x55AAAA, 'n': 'steel'},
+ {'c': 0xAAAAAA, 'n': 'grey'},
+ {'c': 0xFFAAAA, 'n': 'pink'},
+ {'c': 0x00FFAA, 'n': 'bay'},
+ {'c': 0x55FFAA, 'n': 'marina'},
+ {'c': 0xAAFFAA, 'n': 'tornado'},
+ {'c': 0xFFFFAA, 'n': 'saltine'},
+ {'c': 0x0000FF, 'n': 'blue'},
+ {'c': 0x5500FF, 'n': 'twilight'},
+ {'c': 0xAA00FF, 'n': 'orchid'},
+ {'c': 0xFF00FF, 'n': 'magenta'},
+ {'c': 0x0055FF, 'n': 'azure'},
+ {'c': 0x5555FF, 'n': 'liberty'},
+ {'c': 0xAA55FF, 'n': 'royalty'},
+ {'c': 0xFF55FF, 'n': 'thistle'},
+ {'c': 0x00AAFF, 'n': 'ocean'},
+ {'c': 0x55AAFF, 'n': 'sky'},
+ {'c': 0xAAAAFF, 'n': 'periwinkle'},
+ {'c': 0xFFAAFF, 'n': 'carnation'},
+ {'c': 0x00FFFF, 'n': 'cyan'},
+ {'c': 0x55FFFF, 'n': 'turquoise'},
+ {'c': 0xAAFFFF, 'n': 'powder'},
+ {'c': 0xFFFFFF, 'n': 'white'}];
+HuesCore.prototype.pastelColours =
+ [{'c': 0xCD4A4A, 'n': 'Mahogany'},
+ {'c': 0xFAE7B5, 'n': 'Banana Mania'},
+ {'c': 0x9F8170, 'n': 'Beaver'},
+ {'c': 0x232323, 'n': 'Black'},
+ {'c': 0xBC5D58, 'n': 'Chestnut'},
+ {'c': 0xDD9475, 'n': 'Copper'},
+ {'c': 0x9ACEEB, 'n': 'Cornflower'},
+ {'c': 0x2B6CC4, 'n': 'Denim'},
+ {'c': 0xEFCDB8, 'n': 'Desert Sand'},
+ {'c': 0x6E5160, 'n': 'Eggplant'},
+ {'c': 0x1DF914, 'n': 'Electric Lime'},
+ {'c': 0x71BC78, 'n': 'Fern'},
+ {'c': 0xFCD975, 'n': 'Goldenrod'},
+ {'c': 0xA8E4A0, 'n': 'Granny Smith Apple'},
+ {'c': 0x95918C, 'n': 'Gray'},
+ {'c': 0x1CAC78, 'n': 'Green'},
+ {'c': 0xFF1DCE, 'n': 'Hot Magenta'},
+ {'c': 0xB2EC5D, 'n': 'Inch Worm'},
+ {'c': 0x5D76CB, 'n': 'Indigo'},
+ {'c': 0xFDFC74, 'n': 'Laser Lemon'},
+ {'c': 0xFCB4D5, 'n': 'Lavender'},
+ {'c': 0xFFBD88, 'n': 'Macaroni and Cheese'},
+ {'c': 0x979AAA, 'n': 'Manatee'},
+ {'c': 0xFF8243, 'n': 'Mango Tango'},
+ {'c': 0xFDBCB4, 'n': 'Melon'},
+ {'c': 0x1A4876, 'n': 'Midnight Blue'},
+ {'c': 0xFFA343, 'n': 'Neon Carrot'},
+ {'c': 0xBAB86C, 'n': 'Olive Green'},
+ {'c': 0xFF7538, 'n': 'Orange'},
+ {'c': 0xE6A8D7, 'n': 'Orchid'},
+ {'c': 0x414A4C, 'n': 'Outer Space'},
+ {'c': 0xFF6E4A, 'n': 'Outrageous Orange'},
+ {'c': 0x1CA9C9, 'n': 'Pacific Blue'},
+ {'c': 0xC5D0E6, 'n': 'Periwinkle'},
+ {'c': 0x8E4585, 'n': 'Plum'},
+ {'c': 0x7442C8, 'n': 'Purple Heart'},
+ {'c': 0xD68A59, 'n': 'Raw Sienna'},
+ {'c': 0xE3256B, 'n': 'Razzmatazz'},
+ {'c': 0xEE204D, 'n': 'Red'},
+ {'c': 0x1FCECB, 'n': 'Robin Egg Blue'},
+ {'c': 0x7851A9, 'n': 'Royal Purple'},
+ {'c': 0xFF9BAA, 'n': 'Salmon'},
+ {'c': 0xFC2847, 'n': 'Scarlet'},
+ {'c': 0x9FE2BF, 'n': 'Sea Green'},
+ {'c': 0xA5694F, 'n': 'Sepia'},
+ {'c': 0x8A795D, 'n': 'Shadow'},
+ {'c': 0x45CEA2, 'n': 'Shamrock'},
+ {'c': 0xFB7EFD, 'n': 'Shocking Pink'},
+ {'c': 0xECEABE, 'n': 'Spring Green'},
+ {'c': 0xFD5E53, 'n': 'Sunset Orange'},
+ {'c': 0xFAA76C, 'n': 'Tan'},
+ {'c': 0xFC89AC, 'n': 'Tickle Me Pink'},
+ {'c': 0xDBD7D2, 'n': 'Timberwolf'},
+ {'c': 0x17806D, 'n': 'Tropical Rain Forest'},
+ {'c': 0x77DDE7, 'n': 'Turquoise Blue'},
+ {'c': 0xFFA089, 'n': 'Vivid Tangerine'},
+ {'c': 0x8F509D, 'n': 'Vivid Violet'},
+ {'c': 0xEDEDED, 'n': 'White'},
+ {'c': 0xFF43A4, 'n': 'Wild Strawberry'},
+ {'c': 0xFC6C85, 'n': 'Wild Watermelon'},
+ {'c': 0xCDA4DE, 'n': 'Wisteria'},
+ {'c': 0xFCE883, 'n': 'Yellow'},
+ {'c': 0xC5E384, 'n': 'Yellow Green'},
+ {'c': 0xFFB653, 'n': 'Yellow Orange'}];
+HuesCore.prototype.weedColours =
+ [{'c': 0x00FF00, 'n': 'Green'},
+ {'c': 0x5A6351, 'n': 'Lizard'},
+ {'c': 0x636F57, 'n': 'Cactus'},
+ {'c': 0x4A7023, 'n': 'Kakapo'},
+ {'c': 0x3D5229, 'n': 'Wet Moss'},
+ {'c': 0x659D32, 'n': 'Tree Moss'},
+ {'c': 0x324F17, 'n': 'Lime Rind'},
+ {'c': 0x7F8778, 'n': 'Flight Jacket'},
+ {'c': 0xBCED91, 'n': 'Green Mist'},
+ {'c': 0x488214, 'n': 'Holly'},
+ {'c': 0x577A3A, 'n': 'Mtn Dew Bottle'},
+ {'c': 0x748269, 'n': 'Seaweed Roll'},
+ {'c': 0x83F52C, 'n': 'Neon Green'},
+ {'c': 0xC0D9AF, 'n': 'Lichen'},
+ {'c': 0xA6D785, 'n': 'Guacamole'},
+ {'c': 0x687E5A, 'n': 'Pond Scum'},
+ {'c': 0x3F602B, 'n': 'Douglas Fir'},
+ {'c': 0x3F6826, 'n': 'Royal Palm'},
+ {'c': 0x646F5E, 'n': 'Seaweed'},
+ {'c': 0x476A34, 'n': 'Noble Fir'},
+ {'c': 0x5DFC0A, 'n': 'Green Led'},
+ {'c': 0x435D36, 'n': 'Spinach'},
+ {'c': 0x84BE6A, 'n': 'Frog'},
+ {'c': 0x5B9C64, 'n': 'Emerald'},
+ {'c': 0x3A6629, 'n': 'Circuit Board'},
+ {'c': 0x308014, 'n': 'Sapgreen'},
+ {'c': 0x31B94D, 'n': 'Pool Table'},
+ {'c': 0x55AE3A, 'n': 'Leaf'},
+ {'c': 0x4DBD33, 'n': 'Grass'},
+ {'c': 0x596C56, 'n': 'Snake'},
+ {'c': 0x86C67C, 'n': '100 Euro'},
+ {'c': 0x7BCC70, 'n': 'Night Vision'},
+ {'c': 0xA020F0, 'n': 'Purple'},
+ {'c': 0x9B30FF, 'n': 'Purple'},
+ {'c': 0x912CEE, 'n': 'Purple'},
+ {'c': 0x7D26CD, 'n': 'Purple'},
+ {'c': 0xAA00FF, 'n': 'Purple'},
+ {'c': 0x800080, 'n': 'Purple'},
+ {'c': 0xA74CAB, 'n': 'Turnip'},
+ {'c': 0x8F5E99, 'n': 'Violet'},
+ {'c': 0x816687, 'n': 'Eggplant'},
+ {'c': 0xCC00FF, 'n': 'Grape'},
+ {'c': 0x820BBB, 'n': 'Wild Violet'},
+ {'c': 0x660198, 'n': 'Concord Grape'},
+ {'c': 0x71637D, 'n': 'Garden Plum'},
+ {'c': 0xB272A6, 'n': 'Purple Fish'},
+ {'c': 0x5C246E, 'n': 'Ultramarine Violet'},
+ {'c': 0x5E2D79, 'n': 'Purple Rose'},
+ {'c': 0x683A5E, 'n': 'Sea Urchin'},
+ {'c': 0x91219E, 'n': 'Cobalt Violet Deep'},
+ {'c': 0x8B668B, 'n': 'Plum'},
+ {'c': 0x9932CD, 'n': 'Dark Orchid'},
+ {'c': 0xBF5FFF, 'n': 'Violet Flower'},
+ {'c': 0xBDA0CB, 'n': 'Purple Candy'},
+ {'c': 0x551A8B, 'n': 'Deep Purple'},
+ {'c': 0xB5509C, 'n': 'Thistle'},
+ {'c': 0x871F78, 'n': 'Dark Purple'},
+ {'c': 0x9C6B98, 'n': 'Purple Ink'},
+ {'c': 0xDB70DB, 'n': 'Orchid'},
+ {'c': 0x990099, 'n': 'True Purple'},
+ {'c': 0x8B008B, 'n': 'Darkmagenta'},
+ {'c': 0xB62084, 'n': "Harold's Crayon"},
+ {'c': 0x694489, 'n': 'Purple Rain'},
+ {'c': 0xFFD700, 'n': 'Gold'}];
\ No newline at end of file
diff --git a/js/HuesSettings.js b/js/HuesSettings.js
new file mode 100644
index 0000000..9ae12a1
--- /dev/null
+++ b/js/HuesSettings.js
@@ -0,0 +1,387 @@
+function HuesSettings(defaults) {
+ this.core = null;
+ // TODO: HTML5 local storage or something
+}
+
+HuesSettings.prototype.connectCore = function(core) {
+ this.core = core;
+};
+
+//class HuesSettings
+package
+{
+ import flash.display.*;
+ import flash.net.*;
+
+ public class HuesSettings extends Object
+ {
+ public function HuesSettings()
+ {
+ this.bools = ["imageSmoothing", "blurEnabled", "smartAlign", "autosongShuffle", "blackoutUI"];
+ this.numbs = ["autosongDelay"];
+ super();
+ trace("Settings created");
+ this.callbacks = [];
+ this.currentSettings = {};
+ this.setDefaults();
+ this.load();
+ return;
+ }
+
+ public function set autosongDelay(arg1:int):void
+ {
+ trace("AutoSong delay:", arg1);
+ this.currentSettings["autosongDelay"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set autosongShuffle(arg1:Boolean):void
+ {
+ trace("Image scaling:", arg1);
+ this.currentSettings["autosongShuffle"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set imagescaling(arg1:String):void
+ {
+ trace("Image scaling:", arg1);
+ this.currentSettings["imagescaling"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set colors(arg1:String):void
+ {
+ trace("Colors:", arg1);
+ this.currentSettings["colors"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ internal function setDefaults():void
+ {
+ this.currentSettings = {"flashQuality":flash.display.StageQuality.HIGH, "imageSmoothing":true, "blurEnabled":true, "blurAmount":"medium", "blurDecay":"high", "channels":"stereo", "smartAlign":true, "buildups":"once", "blendMode":"hard", "ui":"modern", "autosong":"off", "autosongDelay":5, "autosongShuffle":true, "imagescaling":"on", "colors":"normal", "blackoutUI":false};
+ return;
+ }
+
+ public function defaults():void
+ {
+ this.setDefaults();
+ this.saveSettings();
+ return;
+ }
+
+ public function getSettingsFromParameters(arg1:Object):void
+ {
+ var loc1:*=undefined;
+ var loc2:*=null;
+ if (arg1)
+ {
+ var loc3:*=0;
+ var loc4:*=arg1;
+ for (loc2 in loc4)
+ {
+ loc1 = arg1[loc2];
+ if (this.bools.indexOf(loc2) == -1)
+ {
+ if (this.numbs.indexOf(loc2) != -1)
+ {
+ if (loc1.match(new RegExp("\\d+")))
+ {
+ loc1 = int(loc1);
+ if (loc2 == "autosongDelay")
+ {
+ loc1 = Math.max(1, loc1);
+ }
+ }
+ else
+ {
+ loc1 = null;
+ }
+ }
+ }
+ else if (loc1 != "true")
+ {
+ if (loc1 != "false")
+ {
+ loc1 = null;
+ }
+ else
+ {
+ loc1 = false;
+ }
+ }
+ else
+ {
+ loc1 = true;
+ }
+ if (loc1 == null)
+ {
+ continue;
+ }
+ this.currentSettings[loc2] = loc1;
+ }
+ this.saveSettings();
+ this.callCallbacks();
+ }
+ return;
+ }
+
+ public function saveSettings():void
+ {
+ var so:flash.net.SharedObject;
+ var k:String;
+
+ var loc1:*;
+ k = null;
+ trace("Saving settings!");
+ so = flash.net.SharedObject.getLocal(this.objectName);
+ var loc2:*=0;
+ var loc3:*=this.currentSettings;
+ for (k in loc3)
+ {
+ so.data[k] = this.currentSettings[k];
+ }
+ so.data.saved = true;
+ try
+ {
+ so.flush();
+ }
+ catch (e:Error)
+ {
+ trace("Saving settings failed, oh well");
+ }
+ return;
+ }
+
+ public function load():void
+ {
+ var loc1:*=flash.net.SharedObject.getLocal(this.objectName);
+ if ("saved" in loc1.data)
+ {
+ trace("Old settings");
+ this.currentSettings = loc1.data;
+ }
+ else
+ {
+ trace("Defaults");
+ this.defaults();
+ }
+ this.callCallbacks();
+ return;
+ }
+
+ public function set blackoutUI(arg1:Boolean):void
+ {
+ trace("Blackout UI:", arg1);
+ this.currentSettings["blackoutUI"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function addCallback(arg1:Function):void
+ {
+ if (this.callbacks.indexOf(arg1) == -1)
+ {
+ this.callbacks.push(arg1);
+ arg1();
+ }
+ return;
+ }
+
+ public function callCallbacks():void
+ {
+ var loc1:*=undefined;
+ this.saveSettings();
+ var loc2:*=0;
+ var loc3:*=this.callbacks;
+ for each (loc1 in loc3)
+ {
+ loc1();
+ }
+ return;
+ }
+
+ public function get flashQuality():String
+ {
+ return this.currentSettings["flashQuality"];
+ }
+
+ public function get imageSmoothing():Boolean
+ {
+ return this.currentSettings["imageSmoothing"];
+ }
+
+ public function get blurEnabled():Boolean
+ {
+ return this.currentSettings["blurEnabled"];
+ }
+
+ public function get blurAmount():String
+ {
+ return this.currentSettings["blurAmount"];
+ }
+
+ public function get blurDecay():String
+ {
+ return this.currentSettings["blurDecay"];
+ }
+
+ public function get channels():String
+ {
+ return this.currentSettings["channels"];
+ }
+
+ public function get smartAlign():Boolean
+ {
+ return this.currentSettings["smartAlign"];
+ }
+
+ public function get buildups():String
+ {
+ return this.currentSettings["buildups"];
+ }
+
+ public function get blendMode():String
+ {
+ return this.currentSettings["blendMode"];
+ }
+
+ public function get ui():String
+ {
+ return this.currentSettings["ui"];
+ }
+
+ public function get autosong():String
+ {
+ return this.currentSettings["autosong"];
+ }
+
+ public function get autosongDelay():int
+ {
+ return this.currentSettings["autosongDelay"];
+ }
+
+ public function get autosongShuffle():Boolean
+ {
+ return this.currentSettings["autosongShuffle"];
+ }
+
+ public function get imagescaling():String
+ {
+ return this.currentSettings["imagescaling"];
+ }
+
+ public function get colors():String
+ {
+ return this.currentSettings["colors"];
+ }
+
+ public function get blackoutUI():Boolean
+ {
+ return this.currentSettings["blackoutUI"];
+ }
+
+ public function set flashQuality(arg1:String):void
+ {
+ trace("Flash quality:", arg1);
+ this.currentSettings["flashQuality"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set imageSmoothing(arg1:Boolean):void
+ {
+ trace("Image smoothing:", arg1);
+ this.currentSettings["imageSmoothing"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set blurEnabled(arg1:Boolean):void
+ {
+ trace("Blur:", arg1);
+ this.currentSettings["blurEnabled"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set blurAmount(arg1:String):void
+ {
+ trace("Blur amount:", arg1);
+ this.currentSettings["blurAmount"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set blurDecay(arg1:String):void
+ {
+ trace("Blur decay:", arg1);
+ this.currentSettings["blurDecay"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set channels(arg1:String):void
+ {
+ trace("Channels:", arg1);
+ this.currentSettings["channels"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set smartAlign(arg1:Boolean):void
+ {
+ trace("Smart align:", arg1);
+ this.currentSettings["smartAlign"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set buildups(arg1:String):void
+ {
+ trace("Buildups:", arg1);
+ this.currentSettings["buildups"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set blendMode(arg1:String):void
+ {
+ trace("Blend mode:", arg1);
+ this.currentSettings["blendMode"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set ui(arg1:String):void
+ {
+ trace("UI:", arg1);
+ this.currentSettings["ui"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ public function set autosong(arg1:String):void
+ {
+ trace("AutoSong:", arg1);
+ this.currentSettings["autosong"] = arg1;
+ this.callCallbacks();
+ return;
+ }
+
+ internal var currentSettings:Object;
+
+ internal var bools:Array;
+
+ internal var numbs:Array;
+
+ internal var objectName:*="HuesSettings51";
+
+ internal var callbacks:Array;
+ }
+}
+
+
diff --git a/js/HuesUI.js b/js/HuesUI.js
new file mode 100644
index 0000000..fec4ef6
--- /dev/null
+++ b/js/HuesUI.js
@@ -0,0 +1,423 @@
+/*
+ Base UI Class for Hues display. Parent is an element
+ to put all your own elements under, but make a div
+ underneath so it can be entirely hidden.
+*/
+function HuesUI(parent) {
+ if(!parent) {
+ parent = document.getElementById("huesUI");
+ }
+ this.root = document.createElement("div");
+ this.root.className = this.constructor.name;
+ parent.appendChild(this.root);
+ this.root.style.display = "none";
+
+ this.core = null;
+
+ this.imageName = null;
+ this.imageLink = null;
+
+ this.songName = null;
+ this.songLink = null;
+
+ this.hueName = null;
+
+ this.volInput = null;
+ this.volLabel = null;
+
+ this.initUI();
+}
+
+HuesUI.prototype.initUI = function() {
+ var doc = this.root.ownerDocument
+
+ var imageName = doc.createElement("div");
+ this.imageName = imageName;
+
+ this.imageLink = doc.createElement("a");
+ this.imageLink.target = "_blank";
+ this.imageName.appendChild(this.imageLink);
+
+ var songName = doc.createElement("div");
+ this.songName = songName;
+
+ this.songLink = doc.createElement("a");
+ this.songLink.target = "_blank";
+ this.songName.appendChild(this.songLink);
+
+ var hueName = doc.createElement("div");
+ this.hueName = hueName;
+
+ //this.setupVolume(leftBox)
+}
+
+HuesUI.prototype.connectCore = function(core) {
+ this.core = core;
+ this.root.style.display = "block";
+}
+
+HuesUI.prototype.disconnect = function() {
+ this.core = null;
+ this.root.style.display = "none";
+}
+
+// May do nothing, may scale elements if needed etc etc
+HuesUI.prototype.resize = function() {}
+HuesUI.prototype.modeUpdated = function() {}
+HuesUI.prototype.beat = function() {}
+HuesUI.prototype.updateTime = function() {}
+HuesUI.prototype.blurUpdated = function(x, y) {}
+
+HuesUI.prototype.setSongText = function() {
+ var song = this.core.currentSong;
+
+ if(!song)
+ return;
+
+ this.songLink.textContent = song.title.toUpperCase();
+ this.songLink.href = song.source;
+}
+
+HuesUI.prototype.setImageText = function() {
+ var image = this.core.currentImage;
+
+ if(!image)
+ return;
+
+ this.imageLink.textContent = image.fullname.toUpperCase();
+ this.imageLink.href = image.source;
+}
+
+HuesUI.prototype.setColourText = function(colour) {
+ var colour = this.core.colours[this.core.colourIndex];
+
+ this.hueName.textContent = colour.n.toUpperCase();
+}
+
+HuesUI.prototype.updateLists = function() {
+ var songs = this.core.resourceManager.enabledSongs;
+ var images = this.core.resourceManager.enabledImages;
+ // TODO display this
+}
+
+HuesUI.prototype.updateTexts = function() {
+ // Timer, beat counter
+}
+
+/*
+ Individual UIs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+
+function RetroUI() {
+ this.container = null;
+ this.mode = null;
+ this.beatBar = null;
+ this.beatCount = null;
+ this.timer = null;
+ this.colourIndex = null;
+ this.version = null;
+ HuesUI.call(this);
+}
+RetroUI.prototype = Object.create(HuesUI.prototype);
+RetroUI.prototype.constructor = RetroUI;
+
+RetroUI.prototype.initUI = function() {
+ HuesUI.prototype.initUI.call(this);
+
+ var doc = this.root.ownerDocument;
+
+ var container = doc.createElement("div");
+ container.className = "hues-r-container";
+ this.root.appendChild(container);
+ this.container = container;
+
+ this.mode = doc.createElement("div");
+ container.appendChild(this.mode);
+ container.appendChild(this.imageName);
+
+ this.timer = doc.createElement("div");
+ this.timer.textContent = "T=$0x0000";
+ container.appendChild(this.timer);
+
+ this.beatCount = doc.createElement("div");
+ this.beatCount.textContent = "B=$0x00";
+ container.appendChild(this.beatCount);
+
+ this.xBlur = doc.createElement("div");
+ this.xBlur.textContent = "X=$0x00";
+ container.appendChild(this.xBlur);
+
+ this.yBlur = doc.createElement("div");
+ this.yBlur.textContent = "Y=$0x00";
+ container.appendChild(this.yBlur);
+
+ this.colourIndex = doc.createElement("div");
+ this.colourIndex.textContent = "C=$0x00";
+ container.appendChild(this.colourIndex);
+
+ this.version = doc.createElement("div");
+ container.appendChild(this.version);
+
+ container.appendChild(this.hueName);
+ container.appendChild(this.songName);
+
+ this.beatBar = doc.createElement("div");
+ container.appendChild(this.beatBar);
+}
+
+RetroUI.prototype.connectCore = function(core) {
+ HuesUI.prototype.connectCore.call(this, core);
+
+ this.version.textContent = "V=$" + core.version;
+ this.modeUpdated();
+}
+
+RetroUI.prototype.modeUpdated = function() {
+ this.mode.textContent = "M=" + this.core.getCurrentMode();
+}
+
+RetroUI.prototype.blurUpdated = function(x, y) {
+ x = Math.floor(x * 0xFF);
+ y = Math.floor(y * 0xFF);;
+ this.xBlur.textContent = "X=" + this.intToHex2(x);
+ this.yBlur.textContent = "Y=" + this.intToHex2(y);
+}
+
+RetroUI.prototype.setImageText = function() {
+ var image = this.core.currentImage;
+
+ if(!image)
+ return;
+
+ this.imageLink.textContent = "I=" + image.name.toUpperCase();
+ this.imageLink.href = image.source;
+}
+
+RetroUI.prototype.setColourText = function(colour) {
+ HuesUI.prototype.setColourText.call(this, colour);
+
+ this.colourIndex.textContent = "C=" + this.intToHex2(this.core.colourIndex);
+}
+
+RetroUI.prototype.beat = function() {
+ var beats = this.core.getBeatString();
+ var rest = beats.slice(1);
+
+ this.beatBar.textContent = ">>" + rest;
+
+ this.beatCount.textContent = "B=" + this.intToHex2(this.core.getSafeBeatIndex());
+}
+
+RetroUI.prototype.updateTime = function(time) {
+ time = Math.floor(time * 1000);
+ this.timer.textContent = "T=" + this.intToHex4(time);
+}
+
+RetroUI.prototype.intToHex2 = function(num) {
+ return '$0x' + ("00"+num.toString(16)).slice(-2);
+}
+RetroUI.prototype.intToHex4 = function(num) {
+ return '$0x' + ("0000"+num.toString(16)).slice(-4);
+}
+
+function ModernUI() {
+ this.beatBar = null;
+ this.beatLeft = null;
+ this.beatRight = null;
+ this.beatCenter = null;
+ this.rightBox = null;
+ this.leftBox = null;
+ this.controls = null;
+
+ HuesUI.call(this);
+}
+ModernUI.prototype = Object.create(HuesUI.prototype);
+ModernUI.prototype.constructor = ModernUI;
+
+ModernUI.prototype.initUI = function() {
+ HuesUI.prototype.initUI.call(this);
+
+ var doc = this.root.ownerDocument;
+
+ this.imageName.className = "hues-m-imagename";
+ this.songName.className = "hues-m-songtitle";
+
+ var controls = doc.createElement("div");
+ controls.className = "hues-m-controls";
+ this.root.appendChild(controls);
+ this.controls = controls;
+
+ controls.appendChild(this.imageName);
+ controls.appendChild(this.songName);
+
+ var leftBox = doc.createElement("div");
+ leftBox.className = "hues-m-leftbox";
+ controls.appendChild(leftBox);
+ this.leftBox = leftBox;
+
+ this.hueName.className = "hues-m-huename";
+ leftBox.appendChild(this.hueName);
+
+ var rightBox = doc.createElement("div");
+ rightBox.className = "hues-m-rightbox";
+ controls.appendChild(rightBox);
+ this.rightBox = rightBox;
+
+ var beatBar = doc.createElement("div");
+ beatBar.className = "hues-m-beatbar";
+ this.root.appendChild(beatBar);
+ this.beatBar = beatBar;
+
+ var beatLeft = doc.createElement("div");
+ beatLeft.className = "hues-m-beatleft";
+ beatBar.appendChild(beatLeft);
+ this.beatLeft = beatLeft;
+
+ var beatRight = doc.createElement("div");
+ beatRight.className = "hues-m-beatright";
+ beatBar.appendChild(beatRight);
+ this.beatRight = beatRight;
+
+ var beatCenter = doc.createElement("div");
+ beatCenter.className = "hues-m-beatcenter";
+ this.root.appendChild(beatCenter);
+ this.beatCenter = beatCenter;
+}
+
+ModernUI.prototype.beat = function() {
+ var beats = this.core.getBeatString();
+
+ var current = beats[0];
+ var rest = beats.slice(1);
+
+ this.beatLeft.textContent = rest;
+ this.beatRight.textContent = rest;
+
+
+ if (current != ".") {
+ while (this.beatCenter.firstElementChild) {
+ this.beatCenter.removeChild(this.beatCenter.firstElementChild);
+ }
+ var span = this.beatCenter.ownerDocument.createElement("span");
+ span.textContent = current;
+ this.beatCenter.appendChild(span);
+ }
+}
+
+ModernUI.prototype.setSongText = function() {
+ HuesUI.prototype.setSongText.call(this);
+
+ if(!this.core.currentSong)
+ return;
+
+ var name = this.songName;
+
+ name.className = "hues-m-songtitle"
+ if (name.offsetWidth > name.clientWidth) {
+ name.className = "hues-m-songtitle small"
+ }
+ if (name.offsetWidth > name.clientWidth) {
+ name.className = "hues-m-songtitle x-small"
+ }
+}
+
+ModernUI.prototype.setImageText = function() {
+ HuesUI.prototype.setImageText.call(this);
+
+ if(!this.core.currentImage)
+ return;
+
+ var name = this.imageName
+
+ name.className = "hues-m-imagename"
+ if (name.offsetWidth > name.clientWidth) {
+ name.className = "hues-m-imagename small"
+ }
+ if (name.offsetWidth > name.clientWidth) {
+ name.className = "hues-m-imagename x-small"
+ }
+}
+
+function WeedUI() {
+ RetroUI.call(this);
+
+ this.xVariance = 10;
+ this.yVariance = 20;
+}
+WeedUI.prototype = Object.create(RetroUI.prototype);
+WeedUI.prototype.constructor = WeedUI;
+
+WeedUI.prototype.initUI = function() {
+ RetroUI.prototype.initUI.call(this);
+
+ this.container.removeChild(this.beatBar)
+ var doc = this.root.ownerDocument;
+
+ var beatBar = doc.createElement("div");
+ beatBar.className = "hues-w-beatbar";
+ this.root.appendChild(beatBar);
+ this.beatBar = beatBar;
+
+ var beatLeft = doc.createElement("div");
+ beatLeft.className = "hues-w-beatleft";
+ beatBar.appendChild(beatLeft);
+ this.beatLeft = beatLeft;
+
+ var beatRight = doc.createElement("div");
+ beatRight.className = "hues-w-beatright";
+ beatBar.appendChild(beatRight);
+ this.beatRight = beatRight;
+}
+
+WeedUI.prototype.beat = function() {
+ var beats = this.core.getBeatString();
+ var rest = beats.slice(1);
+
+ this.beatLeft.textContent = rest;
+ this.beatRight.textContent = rest;
+
+ this.beatCount.textContent = "B=" + this.intToHex2(this.core.getSafeBeatIndex());
+
+ if(["x", "o", "X", "O"].indexOf(beats[0]) != -1) {
+ var doc = this.root.ownerDocument;
+ var beatCenter = doc.createElement("div");
+ beatCenter.className = "hues-w-beataccent";
+ var rot = this.round10(15 - Math.random() * 30);
+ var x = this.round10(- this.xVariance / 2 + Math.random() * this.xVariance);
+ var y = this.round10(30 - this.yVariance / 2 + Math.random() * this.yVariance);
+ var transform = "rotate(" + rot + "deg) translate(" + x + "px," + y + "px)";
+ beatCenter.style.MozTransform = transform;
+ beatCenter.style.webkitTransform = transform;
+ beatCenter.style.transform = transform;
+ beatCenter.textContent = beats[0].toUpperCase();
+ this.root.appendChild(beatCenter);
+ window.setTimeout(this.getRemoveBeat(beatCenter), 1500);
+ }
+}
+
+WeedUI.prototype.round10 = function(num) {
+ return Math.round(num * 10) / 10;
+}
+
+WeedUI.prototype.getRemoveBeat = function(element) {
+ var that = this;
+ return function() {
+ that.root.removeChild(element);
+ };
+}
+
+function XmasUI() {
+ ModernUI.call(this);
+
+ this.controls.removeChild(this.leftBox);
+ this.controls.removeChild(this.rightBox);
+
+ this.leftBox = this.rightBox = this.hueName = null;
+
+ this.controls.className = "hues-x-controls";
+ this.beatBar.className = "hues-x-beatbar";
+}
+XmasUI.prototype = Object.create(ModernUI.prototype);
+XmasUI.prototype.constructor = XmasUI;
+
+XmasUI.prototype.setColourText = function(colour) {};
\ No newline at end of file
diff --git a/js/ResourceManager.js b/js/ResourceManager.js
new file mode 100644
index 0000000..a198b97
--- /dev/null
+++ b/js/ResourceManager.js
@@ -0,0 +1,132 @@
+function Resources() {
+ this.resourcePacks = [];
+
+ this.allSongs = [];
+ this.allImages = [];
+ this.enabledSongs = [];
+ this.enabledImages = [];
+
+ this.toLoad = 0;
+ this.progressState = [];
+ this.rToLoad = []
+ this.loadFinishCallback = null;
+ this.progressCallback = null;
+}
+
+// Array of URLs to load, and a callback for when we're done
+// Preserves order of URLs being loaded
+Resources.prototype.addAll = function(urls, callback, progressCallback) {
+ var that = this;
+ this.toLoad += urls.length;
+ if(progressCallback) {
+ this.progressCallback = progressCallback;
+ this.progressState = Array.apply(null, Array(urls.length)).map(Number.prototype.valueOf,0);
+ }
+ if(callback) {
+ this.loadFinishCallback = callback;
+ }
+ for(var i = 0; i < urls.length; i++) {
+ var r = new Respack();
+ this.rToLoad.push(r);
+ r.loadFromURL(urls[i], function() {
+ that.toLoad--;
+ if(that.toLoad <= 0) {
+ // could use a while() and shift(), but it'd be slower
+ for(var i = 0; i < that.rToLoad.length; i++) {
+ that.addPack(that.rToLoad[i]);
+ }
+ that.rToLoad = [];
+ if(that.loadFinishCallback) {
+ that.loadFinishCallback();
+ that.loadFinishCallback = null;
+ }
+ that.progressCallback = null;
+ }
+ }, this.createProgCallback(i));
+ }
+}
+
+Resources.prototype.createProgCallback = function(i) {
+ var that = this;
+ return function(progress) {
+ that.progressState[i] = progress;
+ that.updateProgress();
+ }
+}
+
+Resources.prototype.updateProgress = function() {
+ var total = 0;
+ for(var i = 0; i < this.progressState.length; i++) {
+ total += this.progressState[i];
+ }
+ total /= this.progressState.length;
+ this.progressCallback(total);
+}
+
+Resources.prototype.addPack = function(pack) {
+ console.log("Added", pack.name, "to respacks");
+ this.resourcePacks.push(pack);
+ this.addResourcesToArrays(pack);
+ this.rebuildEnabled();
+}
+
+Resources.prototype.addResourcesToArrays = function(pack) {
+ this.allImages = this.allImages.concat(pack.images);
+ this.allSongs = this.allSongs.concat(pack.songs);
+}
+
+Resources.prototype.rebuildArrays = function() {
+ this.allSongs = [];
+ this.allImages = [];
+ this.allAnimations = [];
+
+ for(var i = 0; i < this.resourcePacks.length; i++) {
+ this.addResourcesToArrays(this.resourcePacks[i]);
+ }
+}
+
+Resources.prototype.rebuildEnabled = function() {
+ enabledSongs = [];
+ enabledImages = [];
+ _enabledAnimations = [];
+
+ for(var i = 0; i < this.resourcePacks.length; i++) {
+ var pack = this.resourcePacks[i];
+ if (pack["enabled"] != true) {
+ continue;
+ }
+ for(var j = 0; j < pack.songs.length; j++) {
+ var song = pack.songs[j];
+ if (song.enabled && this.enabledSongs.indexOf(song) == -1) {
+ this.enabledSongs.push(song);
+ }
+ }
+ for(var j = 0; j < pack.images.length; j++) {
+ var image = pack.images[j];
+ if (image.enabled && this.enabledImages.indexOf(image) == -1) {
+ this.enabledImages.push(image);
+ }
+ }
+ }
+}
+
+Resources.prototype.removePack = function(pack) {
+ var index = this.resourcePacks.indexOf(pack);
+ if (index != -1) {
+ this.resourcePacks.splice(index, 1);
+ this.rebuildArrays();
+ }
+}
+
+Resources.prototype.removeAllPacks = function() {
+ this.resourcePacks = [];
+ this.rebuildArrays();
+}
+
+Resources.prototype.getSongNames = function() {
+ var names = []
+ for(var i = 0; i < this.allSongs.length; i++) {
+ names.push(this.allSongs[i]);
+ }
+ return names;
+}
\ No newline at end of file
diff --git a/js/ResourcePack.js b/js/ResourcePack.js
new file mode 100644
index 0000000..3873c24
--- /dev/null
+++ b/js/ResourcePack.js
@@ -0,0 +1,494 @@
+var debugConsole = false;
+function debug() {
+ if(debugConsole) {
+ console.log.apply(window.console, arguments);
+ }
+}
+
+function Respack(url) {
+ this.songs = [];
+ this.songQueue = [];
+ this.images = [];
+ this.imageQueue = [];
+
+ this.name = "
";
+ this.author = "";
+ this.description = "";
+ this.link = null;
+
+ this.size = -1;
+ this.enabled = true;
+
+ this._songFile = null;
+ this._songFileParsed = false;
+ this._imageFile = null;
+ this._infoFile = null;
+
+ this.totalFiles = -1;
+
+ this.file = null;
+ this._completionCallback = null;
+ // For zip parsing progress events
+ this.progressCallback = null;
+ this.filesToLoad = 0;
+ this.filesLoaded = 0;
+ this.loadedFromURL = false;
+
+ if(url)
+ this.loadFromURL(url);
+}
+
+Respack.prototype.audioExtensions = new RegExp("\\.(mp3)$", "i");
+Respack.prototype.imageExtensions = new RegExp("\\.(png|gif|jpg|jpeg)$", "i");
+Respack.prototype.animRegex = new RegExp("(.*?)_\\d+$");
+
+Respack.prototype.updateProgress = function() {
+ if(this.progressCallback) {
+ var percent = this.filesLoaded / this.filesToLoad;
+ if(this.loadedFromURL) {
+ percent = (percent / 2) + 0.5;
+ }
+ this.progressCallback(percent);
+ }
+}
+
+Respack.prototype.loadFromURL = function(url, callback, progress) {
+ var that = this;
+
+ this.progressCallback = progress;
+ this.loadedFromURL = true;
+
+ var req = new XMLHttpRequest();
+ req.open('GET', url, true);
+ req.responseType = 'blob';
+ req.onload = function() {
+ that.loadBlob(req.response, callback);
+ };
+ req.onerror = function() {
+ console.log("Could not load respack at URL", url);
+ }
+ req.onprogress = function(event) {
+ if (event.lengthComputable) {
+ var percent = event.loaded / event.total;
+ if(progress) {
+ progress(percent / 2); // because of processing too
+ }
+ } else {
+ // Unable to compute progress information since the total size is unknown
+ }
+ }
+ req.on
+ req.send();
+}
+
+Respack.prototype.loadBlob = function(blob, callback) {
+ this._completionCallback = callback;
+ var that = this;
+ this.size = blob.size;
+ this.file = new zip.fs.FS();
+ this.file.importBlob(blob,
+ function() { // success
+ that.parseWholeZip();
+ },
+ function(error) { // failure
+ console.log("Error loading respack : ", error.toString());
+ that.file = null;
+ }
+ );
+}
+
+Respack.prototype.parseWholeZip = function() {
+ // TODO might break on bad file
+ console.log("Loading new respack: " + this.file.root.children[0].name);
+
+ var entries = this.file.entries;
+
+ this.totalFiles = 0;
+ // Progress events
+ this.filesToLoad = 0;
+ this.filesLoaded = 0;
+
+ for(var i = 0; i < entries.length; i++) {
+ if(!entries[i].directory && entries[i].name) {
+ this.totalFiles++;
+ this.parseFile(entries[i]);
+ }
+ }
+
+ debug("ZIP loader: trying to finish");
+ this.tryFinish();
+}
+
+Respack.prototype.parseFile = function(file) {
+ var name = file.name
+ if (name.match(this.audioExtensions)) {
+ this.parseSong(file);
+ this.filesToLoad++;
+ } else if (name.match(this.imageExtensions)) {
+ this.parseImage(file);
+ this.filesToLoad++;
+ }
+ else {
+ switch(name.toLowerCase()) {
+ case "songs.xml":
+ this._songFile = file;
+ break;
+ case "images.xml":
+ this._imageFile = file;
+ break;
+ case "info.xml":
+ this._infoFile = file;
+ break;
+ default:
+ }
+ }
+}
+
+Respack.prototype.parseSong = function(file) {
+ this.songQueue.push(file);
+}
+
+Respack.prototype.parseImage = function(file) {
+ this.imageQueue.push(file);
+}
+
+Respack.prototype.parseXML = function() {
+ var that = this;
+
+ if (this.songs.length > 0) {
+ if (this._songFile) {
+ this._songFile.getText(function(text) {
+ //XML parser will complain about a bare '&'
+ text = text.replace(/&/g, '&');
+ that.parseSongFile(text);
+ // Go to next in series
+ that._songFile = null;
+ that._songFileParsed = true;
+ that.parseXML();
+ });
+ return;
+ } else if(!this._songFileParsed) {
+ console.log("!!!", "Got songs but no songs.xml!");
+ this._songFileParsed = true;
+ }
+ }
+ if (this.images.length > 0 && this._imageFile) {
+ this._imageFile.getText(function(text) {
+ text = text.replace(/&/g, '&');
+ that.parseImageFile(text);
+ that._imageFile = null;
+ that.parseXML();
+ });
+ return;
+ }
+ if (this._infoFile) {
+ this._infoFile.getText(function(text) {
+ text = text.replace(/&/g, '&');
+ that.parseInfoFile(text);
+ that._infoFile = null;
+ that.parseXML();
+ });
+ return;
+ }
+
+ // Finally done!
+ this.file = null;
+ console.log("Loaded", this.name, "successfully with", this.songs.length,
+ "songs and", this.images.length, "images.");
+ if(this._completionCallback) {
+ this._completionCallback();
+ }
+}
+
+// Save some chars
+Element.prototype.getTag = function(tag, def) {
+ var t = this.getElementsByTagName(tag)[0];
+ return t ? t.textContent : (def ? def : null);
+}
+
+Respack.prototype.parseSongFile = function(text) {
+ debug(" - Parsing songFile");
+
+ var oParser = new DOMParser();
+ var oDOM = oParser.parseFromString(text, "text/xml");
+ if(oDOM.documentElement.nodeName !== "songs"){
+ console.log("songs.xml error, corrupt file?")
+ return;
+ }
+
+ var newSongs = [];
+ // Not supported in mobile safari
+ // var songsXML = oDOM.documentElement.children;
+ var el = oDOM.documentElement.firstElementChild;
+ for(; el; el = el.nextElementSibling) {
+ var song = this.getSong(el.attributes[0].value);
+ if(song) {
+ song.title = el.getTag("title");
+ if(!song.title) {
+ song.title = "";
+ debug(" WARNING!", song.name, "has no title!");
+ }
+
+ song.rhythm = el.getTag("rhythm");
+ if(!song.rhythm) {
+ song.rhythm = "..no..rhythm..";
+ debug(" WARNING!!", song.name, "has no rhythm!!");
+ }
+
+ song.startSilence = el.getTag("startSilence");
+ song.endSilence = el.getTag("endSilence");
+ song.buildupLength = el.getTag("buildupLength");
+ if(song.buildupLength) {
+ debug("Using custom BU length:", song.buildupLength);
+ }
+ song.buildup = el.getTag("buildup");
+ if(song.buildup) {
+ debug(" Finding a buildup '" + song.buildup + "' for ", song.name);
+ var build = this.getSong(song.buildup);
+ if(build) {
+ song.buildup = build.sound;
+ song.buildupPlayed = false;
+ // get rid of the junk
+ this.songs.splice(this.songs.indexOf(build), 1);
+ } else {
+ debug(" WARNING!", "Didn't find a buildup '" + buildup + "'!");
+ }
+ }
+
+ song.buildupRhythm = el.getTag("buildupRhythm");
+ song.source = el.getTag("source");
+
+ newSongs.push(song);
+ debug(" [I] " + song.name, ": '" + song.title + "' added to songs");
+ } else {
+ debug(" WARNING!", "songs.xml: element", i + 1,
+ "- no song '" + el.attributes[0].value + "' found");
+ }
+ }
+ for(var i = 0; i < this.songs.length; i++) {
+ if(newSongs.indexOf(this.songs[i]) == -1) {
+ debug(" WARNING!", "We have a file for", song.name, "but no information for it");
+ }
+ }
+ this.songs = newSongs;
+}
+
+Respack.prototype.parseInfoFile = function(text) {
+ debug(" - Parsing infoFile");
+
+ var oParser = new DOMParser();
+ var oDOM = oParser.parseFromString(text, "text/xml");
+ var info = oDOM.documentElement;
+ if(info.nodeName !== "info"){
+ console.log("info.xml error, corrupt file?")
+ return;
+ }
+
+ // self reference strings to avoid changing strings twice in future
+ this.name = info.getTag("name", this.name);
+ this.author = info.getTag("author", this.author);
+ this.description = info.getTag("description", this.description);
+ this.link = info.getTag("link", this.link);
+}
+
+Respack.prototype.parseImageFile = function(text) {
+ debug(" - Parsing imagefile");
+
+ var oParser = new DOMParser();
+ var oDOM = oParser.parseFromString(text, "text/xml");
+ if(oDOM.documentElement.nodeName !== "images"){
+ console.log("images.xml error, corrupt file?")
+ return;
+ }
+
+ var newImages = [];
+ // not in mobile safari
+ // var imagesXML = oDOM.documentElement.children;
+ var el = oDOM.documentElement.firstElementChild;
+ for(; el; el = el.nextElementSibling) {
+ var image = this.getImage(el.attributes[0].value);
+ if(image) {
+ image.fullname = el.getTag("fullname");
+ if(!image.fullname) {
+ debug(" WARNING!", image.name, "has no full name!");
+ }
+ image.source = el.getTag("source");
+ // self reference strings to avoid changing strings twice in future
+ image.align = el.getTag("align", image.align);
+ var frameDur = el.getTag("frameDuration");
+ if(frameDur) {
+ image.frameDurations = []
+ var strSplit = frameDur.split(",");
+ for(var j = 0; j < strSplit.length; j++) {
+ image.frameDurations.push(parseInt(strSplit[j]));
+ }
+ while (image.frameDurations.length < image.bitmaps.length) {
+ image.frameDurations.push(image.frameDurations[image.frameDurations.length - 1]);
+ }
+ debug("Frame durations:", image.frameDurations);
+ }
+ debug(" [I] " + image.name, ":", image.fullname, "added to images");
+ if (image.bitmap || image.bitmaps) {
+ newImages.push(image);
+ }
+ else {
+ debug(" WARNING!!", "Image", image.name, "has no bitmap nor animation frames!");
+ }
+ } else {
+ debug(" WARNING!", "images.xml: element",
+ i + 1, "- no image '" + el.attributes[0].value + "' found");
+ }
+ }
+ for(var i = 0; i < this.images.length; i++) {
+ var image = this.images[i];
+ // Add all images with no info
+ if(newImages.indexOf(image) == -1) {
+ newImages.push(image);
+ }
+ }
+ this.images = newImages;
+}
+
+Respack.prototype.containsSong = function(name) {
+ return this.getSong(name) !== null;
+}
+
+Respack.prototype.containsImage = function(name) {
+ return this.getImage(name) !== null;
+}
+
+Respack.prototype.getSong = function(name) {
+ for(var i = 0; i < this.songs.length; i++) {
+ if (name == this.songs[i].name) {
+ return this.songs[i];
+ }
+ }
+ return null;
+}
+
+Respack.prototype.getImage = function(name) {
+ for(var i = 0; i < this.images.length; i++) {
+ if (name == this.images[i].name) {
+ return this.images[i];
+ }
+ }
+ return null;
+}
+
+Respack.prototype.parseSongQueue = function() {
+ var that = this;
+ var songFile = this.songQueue.shift();
+ var name = songFile.name.replace(this.audioExtensions, "");
+
+ debug("parsing song: " + name);
+ if (this.containsSong(name)) {
+ var oldSong = this.getSong(name);
+ debug("WARNING: Song", name, "already exists! Conflict with", name, "and", oldSong.name);
+ } else {
+ var newSong = {"name":name,
+ "title":null,
+ "rhythm":null,
+ "source":null,
+ //"crc":this.quickCRC(file), TODO
+ "sound":null,
+ "enabled":true,
+ "filename":songFile.name};
+ songFile.getBlob("audio/mpeg3", function(sound) {
+ // Because blobs are crap
+ var fr = new FileReader();
+ fr.onload = function() {
+ newSong.sound = this.result;
+ that.filesLoaded++;
+ that.updateProgress();
+ that.tryFinish();
+ };
+ fr.readAsArrayBuffer(sound);
+ });
+ this.songs.push(newSong);
+ }
+}
+
+Respack.prototype.parseImageQueue = function() {
+ var imgFile = this.imageQueue.shift();
+ var name = imgFile.name.replace(this.imageExtensions, "");
+
+ if (match = name.match(new RegExp("^(.*)_(\\d+)$"))) {
+ var anim = this.getImage(match[1])
+ if(!anim) { // make a fresh one
+ anim = {"name":match[1],
+ "fullname":match[1],
+ "align":"center",
+ //"crc":this.quickCRC(imgFile),
+ "bitmaps":[],
+ "frameDurations":[33],
+ "source":null,
+ "enabled":true,
+ "animated":true};
+ this.images.push(anim);
+ }
+ this.imageLoadStart(imgFile, anim);
+ } else if (!this.containsImage(name)) {
+ var img = {"name":name,
+ "fullname":name,
+ "bitmap":null,
+ "align":"center",
+ //"crc":this.quickCRC(imgFile),
+ "source":null,
+ "enabled":true,
+ "filename":imgFile.name,
+ "animated":false};
+ this.images.push(img);
+ this.imageLoadStart(imgFile, img);
+ } else {
+ existing = this.getImage(name);
+ debug("WARNING: Image", name, "already exists! Conflict with", imgFile.name, "and", existing.name);
+ }
+}
+
+Respack.prototype.imageLoadStart = function(imgFile, imageObj) {
+ var that = this;
+ var extension = imgFile.name.split('.').pop().toLowerCase();
+ var mime;
+ switch(extension) {
+ case "png":
+ mime = "image/png";
+ break;
+ case "gif":
+ mime = "image/gif";
+ break;
+ case "jpg":
+ case "jpeg":
+ mime = "image/jpeg";
+ break;
+ default:
+ mime = "application/octet-stream";
+ }
+ imgFile.getData64URI(mime, function(image) {
+ that.imageLoadComplete(image, imageObj);
+ });
+}
+
+Respack.prototype.imageLoadComplete = function(imageBmp, imageObj) {
+ newImg = new Image();
+ newImg.src = imageBmp;
+ if (imageObj.animated) {
+ imageObj.bitmaps.push(newImg);
+ } else {
+ imageObj.bitmap = newImg;
+ debug("parsing image:", imageObj.name);
+ }
+ this.filesLoaded++;
+ this.updateProgress();
+ this.tryFinish();
+}
+
+Respack.prototype.tryFinish = function() {
+ if (this.imageQueue.length > 0) {
+ this.parseImageQueue();
+ } else if(this.songQueue.length > 0) {
+ this.parseSongQueue();
+ } else {
+ debug("Finished parsing images/songs, parsing xml files...");
+ this.parseXML();
+ }
+}
\ No newline at end of file
diff --git a/js/SoundManager.js b/js/SoundManager.js
new file mode 100644
index 0000000..1763457
--- /dev/null
+++ b/js/SoundManager.js
@@ -0,0 +1,258 @@
+var LAME_DELAY_START = 2258;
+var LAME_DELAY_END = 1000;
+
+function SoundManager() {
+ this.playing = false;
+ this.song = null;
+
+ /* Lower level audio and timing info */
+ this.bufSource = null;
+ this.buffer = null;
+ this.context = null; // Audio context, Web Audio API
+ this.startTime = 0; // File start time - 0 is loop start, not build start
+ this.loopStart = 0; // When the build ends, if any
+ this.loopLength = 0; // For calculating beat lengths
+
+ // Volume
+ this.gainNode = null;
+ this.mute = false;
+ this.lastVol = 1;
+
+ // For concatenating our files
+ this.leftToLoad = 0;
+ this.tmpBuffer = null;
+ this.tmpBuild = null;
+ this.onLoadCallback = null;
+
+ // In case of API non-support
+ this.canUse = true;
+
+ // Check Web Audio API Support
+ try {
+ // More info at http://caniuse.com/#feat=audio-api
+ window.AudioContext = window.AudioContext || window.webkitAudioContext;
+ this.context = new window.AudioContext();
+ this.gainNode = this.context.createGain();
+ this.gainNode.connect(this.context.destination);
+ } catch(e) {
+ this.canUse = false;
+ }
+
+ var that = this;
+ window.addEventListener('touchstart', function() {
+
+ // create empty buffer
+ var buffer = that.context.createBuffer(1, 1, 22050);
+ var source = that.context.createBufferSource();
+ source.buffer = buffer;
+
+ // connect to output (your speakers)
+ source.connect( that.context.destination);
+
+ // play the file
+ source.noteOn(0);
+
+ }, false);
+}
+
+SoundManager.prototype.playSong = function(song, callback) {
+ var that = this;
+ if(this.song == song) {
+ return;
+ }
+ this.stop();
+ this.song = song;
+
+ this.loadBuffer(song, function() {
+ // To prevent race condition if you press "next" twice fast
+ if(song == that.song) {
+ that.startTime = that.context.currentTime + that.loopStart;
+ that.bufSource = that.context.createBufferSource();
+ that.bufSource.buffer = that.buffer;
+ that.bufSource.loop = true;
+ that.bufSource.loopStart = that.loopStart;
+ that.bufSource.loopEnd = that.buffer.duration;
+ that.bufSource.connect(that.gainNode);
+
+ // Mobile Safari requires offset, even if 0
+ that.bufSource.start(0);
+ // offset to after the build
+ //that.startTime = that.context.currentTime + that.loopStart;
+ that.playing = true;
+ if(callback)
+ callback();
+ }
+ });
+}
+
+SoundManager.prototype.stop = function() {
+ if (this.playing) {
+ this.bufSource.stop();
+ this.bufSource.disconnect(); // TODO needed?
+ this.bufSource = null;
+ this.playing = false;
+ this.startTime = 0;
+ this.loopStart = 0;
+ this.loopLength = 0;
+ }
+}
+
+// In seconds, relative to the loop start
+SoundManager.prototype.currentTime = function() {
+ if(!this.playing) {
+ return 0;
+ }
+ return this.context.currentTime - this.startTime;
+}
+
+SoundManager.prototype.displayableTime = function() {
+ if(!this.playing) {
+ return 0;
+ }
+ var time = this.currentTime();
+ if(time < 0) {
+ return 0;
+ } else {
+ return time % this.loopLength;
+ }
+}
+
+SoundManager.prototype.loadBuffer = function(song, callback) {
+ if(callback) {
+ this.onLoadCallback = callback;
+ }
+ if(song.buildup) {
+ this.loadAudioFile(song, true);
+ }
+ this.loadAudioFile(song, false);
+}
+
+SoundManager.prototype.loadAudioFile = function(song, isBuild) {
+ this.context.decodeAudioData(
+ isBuild ? song.buildup : song.sound,
+ this.getAudioCallback(song, isBuild),
+ function() {
+ console.log('Error decoding audio "' + song.name + '".');
+ }
+ );
+}
+
+/* decodeAudioData nukes our original MP3 array, but we want to keep it around
+ for memory saving purposes, so we must duplicate it locally here */
+SoundManager.prototype.getAudioCallback = function(song, isBuild) {
+ var that = this;
+ var current = isBuild ? song.buildup : song.sound;
+ var copy = current.slice(0);
+ return function(buffer) {
+ // before the race condition check or we might lose data
+ if(isBuild) {
+ song.buildup = copy;
+ } else {
+ song.sound = copy;
+ }
+ // race condition prevention
+ if(that.song != song) {
+ return;
+ }
+ if(isBuild) {
+ that.tmpBuild = that.trimMP3(buffer);
+ } else {
+ that.tmpBuffer = that.trimMP3(buffer);
+ }
+ that.onSongLoad(song);
+ };
+}
+
+SoundManager.prototype.onSongLoad = function(song) {
+ // if this fails, we need to wait for the other part to load
+ if(this.tmpBuffer && (!song.buildup || this.tmpBuild)) {
+ if(song.buildup) {
+ this.buffer = this.concatenateAudioBuffers(this.tmpBuild, this.tmpBuffer);
+ this.loopStart = this.tmpBuild.duration;
+ } else {
+ this.buffer = this.tmpBuffer;
+ this.loopStart = 0;
+ }
+ this.loopLength = this.buffer.duration - this.loopStart;
+ // free dat memory
+ this.tmpBuild = this.tmpBuffer = null;
+ if(this.onLoadCallback) {
+ this.onLoadCallback();
+ this.onLoadCallback = null;
+ }
+ }
+}
+
+// because MP3 is bad, we nuke silence
+SoundManager.prototype.trimMP3 = function(buffer) {
+ var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
+ if(!isFirefox) {
+ // Webkit is better than Gecko, clearly
+ return buffer;
+ }
+ var ret = this.context.createBuffer(buffer.numberOfChannels,
+ buffer.length - LAME_DELAY_START - LAME_DELAY_END, buffer.sampleRate);
+ for(var i=0; i max_length) {
+ bits = max_length;
+ overflow++;
+ }
+ tree[n * 2 + 1] = bits;
+ // We overwrite tree[n*2+1] which is no longer needed
+
+ if (n > that.max_code)
+ continue; // not a leaf node
+
+ s.bl_count[bits]++;
+ xbits = 0;
+ if (n >= base)
+ xbits = extra[n - base];
+ f = tree[n * 2];
+ s.opt_len += f * (bits + xbits);
+ if (stree)
+ s.static_len += f * (stree[n * 2 + 1] + xbits);
+ }
+ if (overflow === 0)
+ return;
+
+ // This happens for example on obj2 and pic of the Calgary corpus
+ // Find the first bit length which could increase:
+ do {
+ bits = max_length - 1;
+ while (s.bl_count[bits] === 0)
+ bits--;
+ s.bl_count[bits]--; // move one leaf down the tree
+ s.bl_count[bits + 1] += 2; // move one overflow item as its brother
+ s.bl_count[max_length]--;
+ // The brother of the overflow item also moves one step up,
+ // but this does not affect bl_count[max_length]
+ overflow -= 2;
+ } while (overflow > 0);
+
+ for (bits = max_length; bits !== 0; bits--) {
+ n = s.bl_count[bits];
+ while (n !== 0) {
+ m = s.heap[--h];
+ if (m > that.max_code)
+ continue;
+ if (tree[m * 2 + 1] != bits) {
+ s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
+ tree[m * 2 + 1] = bits;
+ }
+ n--;
+ }
+ }
+ }
+
+ // Reverse the first len bits of a code, using straightforward code (a
+ // faster
+ // method would use a table)
+ // IN assertion: 1 <= len <= 15
+ function bi_reverse(code, // the value to invert
+ len // its bit length
+ ) {
+ var res = 0;
+ do {
+ res |= code & 1;
+ code >>>= 1;
+ res <<= 1;
+ } while (--len > 0);
+ return res >>> 1;
+ }
+
+ // Generate the codes for a given tree and bit counts (which need not be
+ // optimal).
+ // IN assertion: the array bl_count contains the bit length statistics for
+ // the given tree and the field len is set for all tree elements.
+ // OUT assertion: the field code is set for all tree elements of non
+ // zero code length.
+ function gen_codes(tree, // the tree to decorate
+ max_code, // largest code with non zero frequency
+ bl_count // number of codes at each bit length
+ ) {
+ var next_code = []; // next code value for each
+ // bit length
+ var code = 0; // running code value
+ var bits; // bit index
+ var n; // code index
+ var len;
+
+ // The distribution counts are first used to generate the code values
+ // without bit reversal.
+ for (bits = 1; bits <= MAX_BITS; bits++) {
+ next_code[bits] = code = ((code + bl_count[bits - 1]) << 1);
+ }
+
+ // Check that the bit counts in bl_count are consistent. The last code
+ // must be all ones.
+ // Assert (code + bl_count[MAX_BITS]-1 == (1<= 1; n--)
+ s.pqdownheap(tree, n);
+
+ // Construct the Huffman tree by repeatedly combining the least two
+ // frequent nodes.
+
+ node = elems; // next internal node of the tree
+ do {
+ // n = node of least frequency
+ n = s.heap[1];
+ s.heap[1] = s.heap[s.heap_len--];
+ s.pqdownheap(tree, 1);
+ m = s.heap[1]; // m = node of next least frequency
+
+ s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
+ s.heap[--s.heap_max] = m;
+
+ // Create a new node father of n and m
+ tree[node * 2] = (tree[n * 2] + tree[m * 2]);
+ s.depth[node] = Math.max(s.depth[n], s.depth[m]) + 1;
+ tree[n * 2 + 1] = tree[m * 2 + 1] = node;
+
+ // and insert the new node in the heap
+ s.heap[1] = node++;
+ s.pqdownheap(tree, 1);
+ } while (s.heap_len >= 2);
+
+ s.heap[--s.heap_max] = s.heap[1];
+
+ // At this point, the fields freq and dad are set. We can now
+ // generate the bit lengths.
+
+ gen_bitlen(s);
+
+ // The field len is now set, we can generate the bit codes
+ gen_codes(tree, that.max_code, s.bl_count);
+ };
+
+ }
+
+ Tree._length_code = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16,
+ 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+ 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+ 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+ 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 ];
+
+ Tree.base_length = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0 ];
+
+ Tree.base_dist = [ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384,
+ 24576 ];
+
+ // Mapping from a distance to a distance code. dist is the distance - 1 and
+ // must not have side effects. _dist_code[256] and _dist_code[257] are never
+ // used.
+ Tree.d_code = function(dist) {
+ return ((dist) < 256 ? _dist_code[dist] : _dist_code[256 + ((dist) >>> 7)]);
+ };
+
+ // extra bits for each length code
+ Tree.extra_lbits = [ 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 ];
+
+ // extra bits for each distance code
+ Tree.extra_dbits = [ 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 ];
+
+ // extra bits for each bit length code
+ Tree.extra_blbits = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 ];
+
+ Tree.bl_order = [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
+
+ // StaticTree
+
+ function StaticTree(static_tree, extra_bits, extra_base, elems, max_length) {
+ var that = this;
+ that.static_tree = static_tree;
+ that.extra_bits = extra_bits;
+ that.extra_base = extra_base;
+ that.elems = elems;
+ that.max_length = max_length;
+ }
+
+ StaticTree.static_ltree = [ 12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8, 28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8, 2, 8,
+ 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8, 18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8, 10, 8, 138, 8, 74, 8, 202, 8, 42,
+ 8, 170, 8, 106, 8, 234, 8, 26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8, 6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8,
+ 22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8, 14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8, 30, 8, 158, 8, 94, 8,
+ 222, 8, 62, 8, 190, 8, 126, 8, 254, 8, 1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8, 17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113,
+ 8, 241, 8, 9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8, 25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8, 5, 8, 133, 8,
+ 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8, 21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8, 13, 8, 141, 8, 77, 8, 205, 8, 45, 8,
+ 173, 8, 109, 8, 237, 8, 29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8, 19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9,
+ 51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9, 11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9, 43, 9, 299, 9, 171, 9,
+ 427, 9, 107, 9, 363, 9, 235, 9, 491, 9, 27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9, 59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379,
+ 9, 251, 9, 507, 9, 7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9, 39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9, 23,
+ 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9, 55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9, 15, 9, 271, 9, 143, 9,
+ 399, 9, 79, 9, 335, 9, 207, 9, 463, 9, 47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9, 31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9,
+ 223, 9, 479, 9, 63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9, 0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7, 8, 7, 72, 7,
+ 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7, 4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7, 3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8,
+ 99, 8, 227, 8 ];
+
+ StaticTree.static_dtree = [ 0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5, 2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5, 1, 5, 17, 5, 9, 5,
+ 25, 5, 5, 5, 21, 5, 13, 5, 29, 5, 3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 ];
+
+ StaticTree.static_l_desc = new StaticTree(StaticTree.static_ltree, Tree.extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
+
+ StaticTree.static_d_desc = new StaticTree(StaticTree.static_dtree, Tree.extra_dbits, 0, D_CODES, MAX_BITS);
+
+ StaticTree.static_bl_desc = new StaticTree(null, Tree.extra_blbits, 0, BL_CODES, MAX_BL_BITS);
+
+ // Deflate
+
+ var MAX_MEM_LEVEL = 9;
+ var DEF_MEM_LEVEL = 8;
+
+ function Config(good_length, max_lazy, nice_length, max_chain, func) {
+ var that = this;
+ that.good_length = good_length;
+ that.max_lazy = max_lazy;
+ that.nice_length = nice_length;
+ that.max_chain = max_chain;
+ that.func = func;
+ }
+
+ var STORED = 0;
+ var FAST = 1;
+ var SLOW = 2;
+ var config_table = [ new Config(0, 0, 0, 0, STORED), new Config(4, 4, 8, 4, FAST), new Config(4, 5, 16, 8, FAST), new Config(4, 6, 32, 32, FAST),
+ new Config(4, 4, 16, 16, SLOW), new Config(8, 16, 32, 32, SLOW), new Config(8, 16, 128, 128, SLOW), new Config(8, 32, 128, 256, SLOW),
+ new Config(32, 128, 258, 1024, SLOW), new Config(32, 258, 258, 4096, SLOW) ];
+
+ var z_errmsg = [ "need dictionary", // Z_NEED_DICT
+ // 2
+ "stream end", // Z_STREAM_END 1
+ "", // Z_OK 0
+ "", // Z_ERRNO (-1)
+ "stream error", // Z_STREAM_ERROR (-2)
+ "data error", // Z_DATA_ERROR (-3)
+ "", // Z_MEM_ERROR (-4)
+ "buffer error", // Z_BUF_ERROR (-5)
+ "",// Z_VERSION_ERROR (-6)
+ "" ];
+
+ // block not completed, need more input or more output
+ var NeedMore = 0;
+
+ // block flush performed
+ var BlockDone = 1;
+
+ // finish started, need only more output at next deflate
+ var FinishStarted = 2;
+
+ // finish done, accept no more input or output
+ var FinishDone = 3;
+
+ // preset dictionary flag in zlib header
+ var PRESET_DICT = 0x20;
+
+ var INIT_STATE = 42;
+ var BUSY_STATE = 113;
+ var FINISH_STATE = 666;
+
+ // The deflate compression method
+ var Z_DEFLATED = 8;
+
+ var STORED_BLOCK = 0;
+ var STATIC_TREES = 1;
+ var DYN_TREES = 2;
+
+ var MIN_MATCH = 3;
+ var MAX_MATCH = 258;
+ var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
+
+ function smaller(tree, n, m, depth) {
+ var tn2 = tree[n * 2];
+ var tm2 = tree[m * 2];
+ return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
+ }
+
+ function Deflate() {
+
+ var that = this;
+ var strm; // pointer back to this zlib stream
+ var status; // as the name implies
+ // pending_buf; // output still pending
+ var pending_buf_size; // size of pending_buf
+ // pending_out; // next pending byte to output to the stream
+ // pending; // nb of bytes in the pending buffer
+ var method; // STORED (for zip only) or DEFLATED
+ var last_flush; // value of flush param for previous deflate call
+
+ var w_size; // LZ77 window size (32K by default)
+ var w_bits; // log2(w_size) (8..16)
+ var w_mask; // w_size - 1
+
+ var window;
+ // Sliding window. Input bytes are read into the second half of the window,
+ // and move to the first half later to keep a dictionary of at least wSize
+ // bytes. With this organization, matches are limited to a distance of
+ // wSize-MAX_MATCH bytes, but this ensures that IO is always
+ // performed with a length multiple of the block size. Also, it limits
+ // the window size to 64K, which is quite useful on MSDOS.
+ // To do: use the user input buffer as sliding window.
+
+ var window_size;
+ // Actual size of window: 2*wSize, except when the user input buffer
+ // is directly used as sliding window.
+
+ var prev;
+ // Link to older string with same hash index. To limit the size of this
+ // array to 64K, this link is maintained only for the last 32K strings.
+ // An index in this array is thus a window index modulo 32K.
+
+ var head; // Heads of the hash chains or NIL.
+
+ var ins_h; // hash index of string to be inserted
+ var hash_size; // number of elements in hash table
+ var hash_bits; // log2(hash_size)
+ var hash_mask; // hash_size-1
+
+ // Number of bits by which ins_h must be shifted at each input
+ // step. It must be such that after MIN_MATCH steps, the oldest
+ // byte no longer takes part in the hash key, that is:
+ // hash_shift * MIN_MATCH >= hash_bits
+ var hash_shift;
+
+ // Window position at the beginning of the current output block. Gets
+ // negative when the window is moved backwards.
+
+ var block_start;
+
+ var match_length; // length of best match
+ var prev_match; // previous match
+ var match_available; // set if previous match exists
+ var strstart; // start of string to insert
+ var match_start; // start of matching string
+ var lookahead; // number of valid bytes ahead in window
+
+ // Length of the best match at previous step. Matches not greater than this
+ // are discarded. This is used in the lazy match evaluation.
+ var prev_length;
+
+ // To speed up deflation, hash chains are never searched beyond this
+ // length. A higher limit improves compression ratio but degrades the speed.
+ var max_chain_length;
+
+ // Attempt to find a better match only when the current match is strictly
+ // smaller than this value. This mechanism is used only for compression
+ // levels >= 4.
+ var max_lazy_match;
+
+ // Insert new strings in the hash table only if the match length is not
+ // greater than this length. This saves time but degrades compression.
+ // max_insert_length is used only for compression levels <= 3.
+
+ var level; // compression level (1..9)
+ var strategy; // favor or force Huffman coding
+
+ // Use a faster search when the previous match is longer than this
+ var good_match;
+
+ // Stop searching when current match exceeds this
+ var nice_match;
+
+ var dyn_ltree; // literal and length tree
+ var dyn_dtree; // distance tree
+ var bl_tree; // Huffman tree for bit lengths
+
+ var l_desc = new Tree(); // desc for literal tree
+ var d_desc = new Tree(); // desc for distance tree
+ var bl_desc = new Tree(); // desc for bit length tree
+
+ // that.heap_len; // number of elements in the heap
+ // that.heap_max; // element of largest frequency
+ // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+ // The same heap array is used to build all trees.
+
+ // Depth of each subtree used as tie breaker for trees of equal frequency
+ that.depth = [];
+
+ var l_buf; // index for literals or lengths */
+
+ // Size of match buffer for literals/lengths. There are 4 reasons for
+ // limiting lit_bufsize to 64K:
+ // - frequencies can be kept in 16 bit counters
+ // - if compression is not successful for the first block, all input
+ // data is still in the window so we can still emit a stored block even
+ // when input comes from standard input. (This can also be done for
+ // all blocks if lit_bufsize is not greater than 32K.)
+ // - if compression is not successful for a file smaller than 64K, we can
+ // even emit a stored file instead of a stored block (saving 5 bytes).
+ // This is applicable only for zip (not gzip or zlib).
+ // - creating new Huffman trees less frequently may not provide fast
+ // adaptation to changes in the input data statistics. (Take for
+ // example a binary file with poorly compressible code followed by
+ // a highly compressible string table.) Smaller buffer sizes give
+ // fast adaptation but have of course the overhead of transmitting
+ // trees more frequently.
+ // - I can't count above 4
+ var lit_bufsize;
+
+ var last_lit; // running index in l_buf
+
+ // Buffer for distances. To simplify the code, d_buf and l_buf have
+ // the same number of elements. To use different lengths, an extra flag
+ // array would be necessary.
+
+ var d_buf; // index of pendig_buf
+
+ // that.opt_len; // bit length of current block with optimal trees
+ // that.static_len; // bit length of current block with static trees
+ var matches; // number of string matches in current block
+ var last_eob_len; // bit length of EOB code for last block
+
+ // Output buffer. bits are inserted starting at the bottom (least
+ // significant bits).
+ var bi_buf;
+
+ // Number of valid bits in bi_buf. All bits above the last valid bit
+ // are always zero.
+ var bi_valid;
+
+ // number of codes at each bit length for an optimal tree
+ that.bl_count = [];
+
+ // heap used to build the Huffman trees
+ that.heap = [];
+
+ dyn_ltree = [];
+ dyn_dtree = [];
+ bl_tree = [];
+
+ function lm_init() {
+ var i;
+ window_size = 2 * w_size;
+
+ head[hash_size - 1] = 0;
+ for (i = 0; i < hash_size - 1; i++) {
+ head[i] = 0;
+ }
+
+ // Set the default configuration parameters:
+ max_lazy_match = config_table[level].max_lazy;
+ good_match = config_table[level].good_length;
+ nice_match = config_table[level].nice_length;
+ max_chain_length = config_table[level].max_chain;
+
+ strstart = 0;
+ block_start = 0;
+ lookahead = 0;
+ match_length = prev_length = MIN_MATCH - 1;
+ match_available = 0;
+ ins_h = 0;
+ }
+
+ function init_block() {
+ var i;
+ // Initialize the trees.
+ for (i = 0; i < L_CODES; i++)
+ dyn_ltree[i * 2] = 0;
+ for (i = 0; i < D_CODES; i++)
+ dyn_dtree[i * 2] = 0;
+ for (i = 0; i < BL_CODES; i++)
+ bl_tree[i * 2] = 0;
+
+ dyn_ltree[END_BLOCK * 2] = 1;
+ that.opt_len = that.static_len = 0;
+ last_lit = matches = 0;
+ }
+
+ // Initialize the tree data structures for a new zlib stream.
+ function tr_init() {
+
+ l_desc.dyn_tree = dyn_ltree;
+ l_desc.stat_desc = StaticTree.static_l_desc;
+
+ d_desc.dyn_tree = dyn_dtree;
+ d_desc.stat_desc = StaticTree.static_d_desc;
+
+ bl_desc.dyn_tree = bl_tree;
+ bl_desc.stat_desc = StaticTree.static_bl_desc;
+
+ bi_buf = 0;
+ bi_valid = 0;
+ last_eob_len = 8; // enough lookahead for inflate
+
+ // Initialize the first block of the first file:
+ init_block();
+ }
+
+ // Restore the heap property by moving down the tree starting at node k,
+ // exchanging a node with the smallest of its two sons if necessary,
+ // stopping
+ // when the heap property is re-established (each father smaller than its
+ // two sons).
+ that.pqdownheap = function(tree, // the tree to restore
+ k // node to move down
+ ) {
+ var heap = that.heap;
+ var v = heap[k];
+ var j = k << 1; // left son of k
+ while (j <= that.heap_len) {
+ // Set j to the smallest of the two sons:
+ if (j < that.heap_len && smaller(tree, heap[j + 1], heap[j], that.depth)) {
+ j++;
+ }
+ // Exit if v is smaller than both sons
+ if (smaller(tree, v, heap[j], that.depth))
+ break;
+
+ // Exchange v with the smallest son
+ heap[k] = heap[j];
+ k = j;
+ // And continue down the tree, setting j to the left son of k
+ j <<= 1;
+ }
+ heap[k] = v;
+ };
+
+ // Scan a literal or distance tree to determine the frequencies of the codes
+ // in the bit length tree.
+ function scan_tree(tree,// the tree to be scanned
+ max_code // and its largest code of non zero frequency
+ ) {
+ var n; // iterates over all tree elements
+ var prevlen = -1; // last emitted length
+ var curlen; // length of current code
+ var nextlen = tree[0 * 2 + 1]; // length of next code
+ var count = 0; // repeat count of the current code
+ var max_count = 7; // max repeat count
+ var min_count = 4; // min repeat count
+
+ if (nextlen === 0) {
+ max_count = 138;
+ min_count = 3;
+ }
+ tree[(max_code + 1) * 2 + 1] = 0xffff; // guard
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[(n + 1) * 2 + 1];
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ bl_tree[curlen * 2] += count;
+ } else if (curlen !== 0) {
+ if (curlen != prevlen)
+ bl_tree[curlen * 2]++;
+ bl_tree[REP_3_6 * 2]++;
+ } else if (count <= 10) {
+ bl_tree[REPZ_3_10 * 2]++;
+ } else {
+ bl_tree[REPZ_11_138 * 2]++;
+ }
+ count = 0;
+ prevlen = curlen;
+ if (nextlen === 0) {
+ max_count = 138;
+ min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6;
+ min_count = 3;
+ } else {
+ max_count = 7;
+ min_count = 4;
+ }
+ }
+ }
+
+ // Construct the Huffman tree for the bit lengths and return the index in
+ // bl_order of the last bit length code to send.
+ function build_bl_tree() {
+ var max_blindex; // index of last bit length code of non zero freq
+
+ // Determine the bit length frequencies for literal and distance trees
+ scan_tree(dyn_ltree, l_desc.max_code);
+ scan_tree(dyn_dtree, d_desc.max_code);
+
+ // Build the bit length tree:
+ bl_desc.build_tree(that);
+ // opt_len now includes the length of the tree representations, except
+ // the lengths of the bit lengths codes and the 5+5+4 bits for the
+ // counts.
+
+ // Determine the number of bit length codes to send. The pkzip format
+ // requires that at least 4 bit length codes be sent. (appnote.txt says
+ // 3 but the actual value used is 4.)
+ for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
+ if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] !== 0)
+ break;
+ }
+ // Update opt_len to include the bit length tree and counts
+ that.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+
+ return max_blindex;
+ }
+
+ // Output a byte on the stream.
+ // IN assertion: there is enough room in pending_buf.
+ function put_byte(p) {
+ that.pending_buf[that.pending++] = p;
+ }
+
+ function put_short(w) {
+ put_byte(w & 0xff);
+ put_byte((w >>> 8) & 0xff);
+ }
+
+ function putShortMSB(b) {
+ put_byte((b >> 8) & 0xff);
+ put_byte((b & 0xff) & 0xff);
+ }
+
+ function send_bits(value, length) {
+ var val, len = length;
+ if (bi_valid > Buf_size - len) {
+ val = value;
+ // bi_buf |= (val << bi_valid);
+ bi_buf |= ((val << bi_valid) & 0xffff);
+ put_short(bi_buf);
+ bi_buf = val >>> (Buf_size - bi_valid);
+ bi_valid += len - Buf_size;
+ } else {
+ // bi_buf |= (value) << bi_valid;
+ bi_buf |= (((value) << bi_valid) & 0xffff);
+ bi_valid += len;
+ }
+ }
+
+ function send_code(c, tree) {
+ var c2 = c * 2;
+ send_bits(tree[c2] & 0xffff, tree[c2 + 1] & 0xffff);
+ }
+
+ // Send a literal or distance tree in compressed form, using the codes in
+ // bl_tree.
+ function send_tree(tree,// the tree to be sent
+ max_code // and its largest code of non zero frequency
+ ) {
+ var n; // iterates over all tree elements
+ var prevlen = -1; // last emitted length
+ var curlen; // length of current code
+ var nextlen = tree[0 * 2 + 1]; // length of next code
+ var count = 0; // repeat count of the current code
+ var max_count = 7; // max repeat count
+ var min_count = 4; // min repeat count
+
+ if (nextlen === 0) {
+ max_count = 138;
+ min_count = 3;
+ }
+
+ for (n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[(n + 1) * 2 + 1];
+ if (++count < max_count && curlen == nextlen) {
+ continue;
+ } else if (count < min_count) {
+ do {
+ send_code(curlen, bl_tree);
+ } while (--count !== 0);
+ } else if (curlen !== 0) {
+ if (curlen != prevlen) {
+ send_code(curlen, bl_tree);
+ count--;
+ }
+ send_code(REP_3_6, bl_tree);
+ send_bits(count - 3, 2);
+ } else if (count <= 10) {
+ send_code(REPZ_3_10, bl_tree);
+ send_bits(count - 3, 3);
+ } else {
+ send_code(REPZ_11_138, bl_tree);
+ send_bits(count - 11, 7);
+ }
+ count = 0;
+ prevlen = curlen;
+ if (nextlen === 0) {
+ max_count = 138;
+ min_count = 3;
+ } else if (curlen == nextlen) {
+ max_count = 6;
+ min_count = 3;
+ } else {
+ max_count = 7;
+ min_count = 4;
+ }
+ }
+ }
+
+ // Send the header for a block using dynamic Huffman trees: the counts, the
+ // lengths of the bit length codes, the literal tree and the distance tree.
+ // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ function send_all_trees(lcodes, dcodes, blcodes) {
+ var rank; // index in bl_order
+
+ send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt
+ send_bits(dcodes - 1, 5);
+ send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt
+ for (rank = 0; rank < blcodes; rank++) {
+ send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
+ }
+ send_tree(dyn_ltree, lcodes - 1); // literal tree
+ send_tree(dyn_dtree, dcodes - 1); // distance tree
+ }
+
+ // Flush the bit buffer, keeping at most 7 bits in it.
+ function bi_flush() {
+ if (bi_valid == 16) {
+ put_short(bi_buf);
+ bi_buf = 0;
+ bi_valid = 0;
+ } else if (bi_valid >= 8) {
+ put_byte(bi_buf & 0xff);
+ bi_buf >>>= 8;
+ bi_valid -= 8;
+ }
+ }
+
+ // Send one empty static block to give enough lookahead for inflate.
+ // This takes 10 bits, of which 7 may remain in the bit buffer.
+ // The current inflate code requires 9 bits of lookahead. If the
+ // last two codes for the previous block (real code plus EOB) were coded
+ // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+ // the last real code. In this case we send two empty static blocks instead
+ // of one. (There are no problems if the previous block is stored or fixed.)
+ // To simplify the code, we assume the worst case of last real code encoded
+ // on one bit only.
+ function _tr_align() {
+ send_bits(STATIC_TREES << 1, 3);
+ send_code(END_BLOCK, StaticTree.static_ltree);
+
+ bi_flush();
+
+ // Of the 10 bits for the empty block, we have already sent
+ // (10 - bi_valid) bits. The lookahead for the last real code (before
+ // the EOB of the previous block) was thus at least one plus the length
+ // of the EOB plus what we have just sent of the empty static block.
+ if (1 + last_eob_len + 10 - bi_valid < 9) {
+ send_bits(STATIC_TREES << 1, 3);
+ send_code(END_BLOCK, StaticTree.static_ltree);
+ bi_flush();
+ }
+ last_eob_len = 7;
+ }
+
+ // Save the match info and tally the frequency counts. Return true if
+ // the current block must be flushed.
+ function _tr_tally(dist, // distance of matched string
+ lc // match length-MIN_MATCH or unmatched char (if dist==0)
+ ) {
+ var out_length, in_length, dcode;
+ that.pending_buf[d_buf + last_lit * 2] = (dist >>> 8) & 0xff;
+ that.pending_buf[d_buf + last_lit * 2 + 1] = dist & 0xff;
+
+ that.pending_buf[l_buf + last_lit] = lc & 0xff;
+ last_lit++;
+
+ if (dist === 0) {
+ // lc is the unmatched char
+ dyn_ltree[lc * 2]++;
+ } else {
+ matches++;
+ // Here, lc is the match length - MIN_MATCH
+ dist--; // dist = match distance - 1
+ dyn_ltree[(Tree._length_code[lc] + LITERALS + 1) * 2]++;
+ dyn_dtree[Tree.d_code(dist) * 2]++;
+ }
+
+ if ((last_lit & 0x1fff) === 0 && level > 2) {
+ // Compute an upper bound for the compressed length
+ out_length = last_lit * 8;
+ in_length = strstart - block_start;
+ for (dcode = 0; dcode < D_CODES; dcode++) {
+ out_length += dyn_dtree[dcode * 2] * (5 + Tree.extra_dbits[dcode]);
+ }
+ out_length >>>= 3;
+ if ((matches < Math.floor(last_lit / 2)) && out_length < Math.floor(in_length / 2))
+ return true;
+ }
+
+ return (last_lit == lit_bufsize - 1);
+ // We avoid equality with lit_bufsize because of wraparound at 64K
+ // on 16 bit machines and because stored blocks are restricted to
+ // 64K-1 bytes.
+ }
+
+ // Send the block data compressed using the given Huffman trees
+ function compress_block(ltree, dtree) {
+ var dist; // distance of matched string
+ var lc; // match length or unmatched char (if dist === 0)
+ var lx = 0; // running index in l_buf
+ var code; // the code to send
+ var extra; // number of extra bits to send
+
+ if (last_lit !== 0) {
+ do {
+ dist = ((that.pending_buf[d_buf + lx * 2] << 8) & 0xff00) | (that.pending_buf[d_buf + lx * 2 + 1] & 0xff);
+ lc = (that.pending_buf[l_buf + lx]) & 0xff;
+ lx++;
+
+ if (dist === 0) {
+ send_code(lc, ltree); // send a literal byte
+ } else {
+ // Here, lc is the match length - MIN_MATCH
+ code = Tree._length_code[lc];
+
+ send_code(code + LITERALS + 1, ltree); // send the length
+ // code
+ extra = Tree.extra_lbits[code];
+ if (extra !== 0) {
+ lc -= Tree.base_length[code];
+ send_bits(lc, extra); // send the extra length bits
+ }
+ dist--; // dist is now the match distance - 1
+ code = Tree.d_code(dist);
+
+ send_code(code, dtree); // send the distance code
+ extra = Tree.extra_dbits[code];
+ if (extra !== 0) {
+ dist -= Tree.base_dist[code];
+ send_bits(dist, extra); // send the extra distance bits
+ }
+ } // literal or match pair ?
+
+ // Check that the overlay between pending_buf and d_buf+l_buf is
+ // ok:
+ } while (lx < last_lit);
+ }
+
+ send_code(END_BLOCK, ltree);
+ last_eob_len = ltree[END_BLOCK * 2 + 1];
+ }
+
+ // Flush the bit buffer and align the output on a byte boundary
+ function bi_windup() {
+ if (bi_valid > 8) {
+ put_short(bi_buf);
+ } else if (bi_valid > 0) {
+ put_byte(bi_buf & 0xff);
+ }
+ bi_buf = 0;
+ bi_valid = 0;
+ }
+
+ // Copy a stored block, storing first the length and its
+ // one's complement if requested.
+ function copy_block(buf, // the input data
+ len, // its length
+ header // true if block header must be written
+ ) {
+ bi_windup(); // align on byte boundary
+ last_eob_len = 8; // enough lookahead for inflate
+
+ if (header) {
+ put_short(len);
+ put_short(~len);
+ }
+
+ that.pending_buf.set(window.subarray(buf, buf + len), that.pending);
+ that.pending += len;
+ }
+
+ // Send a stored block
+ function _tr_stored_block(buf, // input block
+ stored_len, // length of input block
+ eof // true if this is the last block for a file
+ ) {
+ send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3); // send block type
+ copy_block(buf, stored_len, true); // with header
+ }
+
+ // Determine the best encoding for the current block: dynamic trees, static
+ // trees or store, and output the encoded block to the zip file.
+ function _tr_flush_block(buf, // input block, or NULL if too old
+ stored_len, // length of input block
+ eof // true if this is the last block for a file
+ ) {
+ var opt_lenb, static_lenb;// opt_len and static_len in bytes
+ var max_blindex = 0; // index of last bit length code of non zero freq
+
+ // Build the Huffman trees unless a stored block is forced
+ if (level > 0) {
+ // Construct the literal and distance trees
+ l_desc.build_tree(that);
+
+ d_desc.build_tree(that);
+
+ // At this point, opt_len and static_len are the total bit lengths
+ // of
+ // the compressed block data, excluding the tree representations.
+
+ // Build the bit length tree for the above two trees, and get the
+ // index
+ // in bl_order of the last bit length code to send.
+ max_blindex = build_bl_tree();
+
+ // Determine the best encoding. Compute first the block length in
+ // bytes
+ opt_lenb = (that.opt_len + 3 + 7) >>> 3;
+ static_lenb = (that.static_len + 3 + 7) >>> 3;
+
+ if (static_lenb <= opt_lenb)
+ opt_lenb = static_lenb;
+ } else {
+ opt_lenb = static_lenb = stored_len + 5; // force a stored block
+ }
+
+ if ((stored_len + 4 <= opt_lenb) && buf != -1) {
+ // 4: two words for the lengths
+ // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+ // Otherwise we can't have processed more than WSIZE input bytes
+ // since
+ // the last block flush, because compression would have been
+ // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+ // transform a block into a stored block.
+ _tr_stored_block(buf, stored_len, eof);
+ } else if (static_lenb == opt_lenb) {
+ send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
+ compress_block(StaticTree.static_ltree, StaticTree.static_dtree);
+ } else {
+ send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
+ send_all_trees(l_desc.max_code + 1, d_desc.max_code + 1, max_blindex + 1);
+ compress_block(dyn_ltree, dyn_dtree);
+ }
+
+ // The above check is made mod 2^32, for files larger than 512 MB
+ // and uLong implemented on 32 bits.
+
+ init_block();
+
+ if (eof) {
+ bi_windup();
+ }
+ }
+
+ function flush_block_only(eof) {
+ _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
+ block_start = strstart;
+ strm.flush_pending();
+ }
+
+ // Fill the window when the lookahead becomes insufficient.
+ // Updates strstart and lookahead.
+ //
+ // IN assertion: lookahead < MIN_LOOKAHEAD
+ // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ // At least one byte has been read, or avail_in === 0; reads are
+ // performed for at least two bytes (required for the zip translate_eol
+ // option -- not supported here).
+ function fill_window() {
+ var n, m;
+ var p;
+ var more; // Amount of free space at the end of the window.
+
+ do {
+ more = (window_size - lookahead - strstart);
+
+ // Deal with !@#$% 64K limit:
+ if (more === 0 && strstart === 0 && lookahead === 0) {
+ more = w_size;
+ } else if (more == -1) {
+ // Very unlikely, but possible on 16 bit machine if strstart ==
+ // 0
+ // and lookahead == 1 (input done one byte at time)
+ more--;
+
+ // If the window is almost full and there is insufficient
+ // lookahead,
+ // move the upper half to the lower one to make room in the
+ // upper half.
+ } else if (strstart >= w_size + w_size - MIN_LOOKAHEAD) {
+ window.set(window.subarray(w_size, w_size + w_size), 0);
+
+ match_start -= w_size;
+ strstart -= w_size; // we now have strstart >= MAX_DIST
+ block_start -= w_size;
+
+ // Slide the hash table (could be avoided with 32 bit values
+ // at the expense of memory usage). We slide even when level ==
+ // 0
+ // to keep the hash table consistent if we switch back to level
+ // > 0
+ // later. (Using level 0 permanently is not an optimal usage of
+ // zlib, so we don't care about this pathological case.)
+
+ n = hash_size;
+ p = n;
+ do {
+ m = (head[--p] & 0xffff);
+ head[p] = (m >= w_size ? m - w_size : 0);
+ } while (--n !== 0);
+
+ n = w_size;
+ p = n;
+ do {
+ m = (prev[--p] & 0xffff);
+ prev[p] = (m >= w_size ? m - w_size : 0);
+ // If n is not on any hash chain, prev[n] is garbage but
+ // its value will never be used.
+ } while (--n !== 0);
+ more += w_size;
+ }
+
+ if (strm.avail_in === 0)
+ return;
+
+ // If there was no sliding:
+ // strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+ // more == window_size - lookahead - strstart
+ // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+ // => more >= window_size - 2*WSIZE + 2
+ // In the BIG_MEM or MMAP case (not yet supported),
+ // window_size == input_size + MIN_LOOKAHEAD &&
+ // strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+ // Otherwise, window_size == 2*WSIZE so more >= 2.
+ // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+
+ n = strm.read_buf(window, strstart + lookahead, more);
+ lookahead += n;
+
+ // Initialize the hash value now that we have some input:
+ if (lookahead >= MIN_MATCH) {
+ ins_h = window[strstart] & 0xff;
+ ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+ }
+ // If the whole input has less than MIN_MATCH bytes, ins_h is
+ // garbage,
+ // but this is not important since only literal bytes will be
+ // emitted.
+ } while (lookahead < MIN_LOOKAHEAD && strm.avail_in !== 0);
+ }
+
+ // Copy without compression as much as possible from the input stream,
+ // return
+ // the current block state.
+ // This function does not insert new strings in the dictionary since
+ // uncompressible data is probably not useful. This function is used
+ // only for the level=0 compression option.
+ // NOTE: this function should be optimized to avoid extra copying from
+ // window to pending_buf.
+ function deflate_stored(flush) {
+ // Stored blocks are limited to 0xffff bytes, pending_buf is limited
+ // to pending_buf_size, and each stored block has a 5 byte header:
+
+ var max_block_size = 0xffff;
+ var max_start;
+
+ if (max_block_size > pending_buf_size - 5) {
+ max_block_size = pending_buf_size - 5;
+ }
+
+ // Copy as much as possible from input to output:
+ while (true) {
+ // Fill the window as much as possible:
+ if (lookahead <= 1) {
+ fill_window();
+ if (lookahead === 0 && flush == Z_NO_FLUSH)
+ return NeedMore;
+ if (lookahead === 0)
+ break; // flush the current block
+ }
+
+ strstart += lookahead;
+ lookahead = 0;
+
+ // Emit a stored block if pending_buf will be full:
+ max_start = block_start + max_block_size;
+ if (strstart === 0 || strstart >= max_start) {
+ // strstart === 0 is possible when wraparound on 16-bit machine
+ lookahead = (strstart - max_start);
+ strstart = max_start;
+
+ flush_block_only(false);
+ if (strm.avail_out === 0)
+ return NeedMore;
+
+ }
+
+ // Flush if we may have to slide, otherwise block_start may become
+ // negative and the data will be gone:
+ if (strstart - block_start >= w_size - MIN_LOOKAHEAD) {
+ flush_block_only(false);
+ if (strm.avail_out === 0)
+ return NeedMore;
+ }
+ }
+
+ flush_block_only(flush == Z_FINISH);
+ if (strm.avail_out === 0)
+ return (flush == Z_FINISH) ? FinishStarted : NeedMore;
+
+ return flush == Z_FINISH ? FinishDone : BlockDone;
+ }
+
+ function longest_match(cur_match) {
+ var chain_length = max_chain_length; // max hash chain length
+ var scan = strstart; // current string
+ var match; // matched string
+ var len; // length of current match
+ var best_len = prev_length; // best match length so far
+ var limit = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
+ var _nice_match = nice_match;
+
+ // Stop when cur_match becomes <= limit. To simplify the code,
+ // we prevent matches with the string of window index 0.
+
+ var wmask = w_mask;
+
+ var strend = strstart + MAX_MATCH;
+ var scan_end1 = window[scan + best_len - 1];
+ var scan_end = window[scan + best_len];
+
+ // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of
+ // 16.
+ // It is easy to get rid of this optimization if necessary.
+
+ // Do not waste too much time if we already have a good match:
+ if (prev_length >= good_match) {
+ chain_length >>= 2;
+ }
+
+ // Do not look for matches beyond the end of the input. This is
+ // necessary
+ // to make deflate deterministic.
+ if (_nice_match > lookahead)
+ _nice_match = lookahead;
+
+ do {
+ match = cur_match;
+
+ // Skip to next match if the match length cannot increase
+ // or if the match length is less than 2:
+ if (window[match + best_len] != scan_end || window[match + best_len - 1] != scan_end1 || window[match] != window[scan]
+ || window[++match] != window[scan + 1])
+ continue;
+
+ // The check at best_len-1 can be removed because it will be made
+ // again later. (This heuristic is not always a win.)
+ // It is not necessary to compare scan[2] and match[2] since they
+ // are always equal when the other bytes match, given that
+ // the hash keys are equal and that HASH_BITS >= 8.
+ scan += 2;
+ match++;
+
+ // We check for insufficient lookahead only every 8th comparison;
+ // the 256th check will be made at strstart+258.
+ do {
+ } while (window[++scan] == window[++match] && window[++scan] == window[++match] && window[++scan] == window[++match]
+ && window[++scan] == window[++match] && window[++scan] == window[++match] && window[++scan] == window[++match]
+ && window[++scan] == window[++match] && window[++scan] == window[++match] && scan < strend);
+
+ len = MAX_MATCH - (strend - scan);
+ scan = strend - MAX_MATCH;
+
+ if (len > best_len) {
+ match_start = cur_match;
+ best_len = len;
+ if (len >= _nice_match)
+ break;
+ scan_end1 = window[scan + best_len - 1];
+ scan_end = window[scan + best_len];
+ }
+
+ } while ((cur_match = (prev[cur_match & wmask] & 0xffff)) > limit && --chain_length !== 0);
+
+ if (best_len <= lookahead)
+ return best_len;
+ return lookahead;
+ }
+
+ // Compress as much as possible from the input stream, return the current
+ // block state.
+ // This function does not perform lazy evaluation of matches and inserts
+ // new strings in the dictionary only for unmatched strings or for short
+ // matches. It is used only for the fast compression options.
+ function deflate_fast(flush) {
+ // short hash_head = 0; // head of the hash chain
+ var hash_head = 0; // head of the hash chain
+ var bflush; // set if current block must be flushed
+
+ while (true) {
+ // Make sure that we always have enough lookahead, except
+ // at the end of the input file. We need MAX_MATCH bytes
+ // for the next match, plus MIN_MATCH bytes to insert the
+ // string following the next match.
+ if (lookahead < MIN_LOOKAHEAD) {
+ fill_window();
+ if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return NeedMore;
+ }
+ if (lookahead === 0)
+ break; // flush the current block
+ }
+
+ // Insert the string window[strstart .. strstart+2] in the
+ // dictionary, and set hash_head to the head of the hash chain:
+ if (lookahead >= MIN_MATCH) {
+ ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+
+ // prev[strstart&w_mask]=hash_head=head[ins_h];
+ hash_head = (head[ins_h] & 0xffff);
+ prev[strstart & w_mask] = head[ins_h];
+ head[ins_h] = strstart;
+ }
+
+ // Find the longest match, discarding those <= prev_length.
+ // At this point we have always match_length < MIN_MATCH
+
+ if (hash_head !== 0 && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD) {
+ // To simplify the code, we prevent matches with the string
+ // of window index 0 (in particular we have to avoid a match
+ // of the string with itself at the start of the input file).
+ if (strategy != Z_HUFFMAN_ONLY) {
+ match_length = longest_match(hash_head);
+ }
+ // longest_match() sets match_start
+ }
+ if (match_length >= MIN_MATCH) {
+ // check_match(strstart, match_start, match_length);
+
+ bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
+
+ lookahead -= match_length;
+
+ // Insert new strings in the hash table only if the match length
+ // is not too large. This saves time but degrades compression.
+ if (match_length <= max_lazy_match && lookahead >= MIN_MATCH) {
+ match_length--; // string at strstart already in hash table
+ do {
+ strstart++;
+
+ ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+ // prev[strstart&w_mask]=hash_head=head[ins_h];
+ hash_head = (head[ins_h] & 0xffff);
+ prev[strstart & w_mask] = head[ins_h];
+ head[ins_h] = strstart;
+
+ // strstart never exceeds WSIZE-MAX_MATCH, so there are
+ // always MIN_MATCH bytes ahead.
+ } while (--match_length !== 0);
+ strstart++;
+ } else {
+ strstart += match_length;
+ match_length = 0;
+ ins_h = window[strstart] & 0xff;
+
+ ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+ // If lookahead < MIN_MATCH, ins_h is garbage, but it does
+ // not
+ // matter since it will be recomputed at next deflate call.
+ }
+ } else {
+ // No match, output a literal byte
+
+ bflush = _tr_tally(0, window[strstart] & 0xff);
+ lookahead--;
+ strstart++;
+ }
+ if (bflush) {
+
+ flush_block_only(false);
+ if (strm.avail_out === 0)
+ return NeedMore;
+ }
+ }
+
+ flush_block_only(flush == Z_FINISH);
+ if (strm.avail_out === 0) {
+ if (flush == Z_FINISH)
+ return FinishStarted;
+ else
+ return NeedMore;
+ }
+ return flush == Z_FINISH ? FinishDone : BlockDone;
+ }
+
+ // Same as above, but achieves better compression. We use a lazy
+ // evaluation for matches: a match is finally adopted only if there is
+ // no better match at the next window position.
+ function deflate_slow(flush) {
+ // short hash_head = 0; // head of hash chain
+ var hash_head = 0; // head of hash chain
+ var bflush; // set if current block must be flushed
+ var max_insert;
+
+ // Process the input block.
+ while (true) {
+ // Make sure that we always have enough lookahead, except
+ // at the end of the input file. We need MAX_MATCH bytes
+ // for the next match, plus MIN_MATCH bytes to insert the
+ // string following the next match.
+
+ if (lookahead < MIN_LOOKAHEAD) {
+ fill_window();
+ if (lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+ return NeedMore;
+ }
+ if (lookahead === 0)
+ break; // flush the current block
+ }
+
+ // Insert the string window[strstart .. strstart+2] in the
+ // dictionary, and set hash_head to the head of the hash chain:
+
+ if (lookahead >= MIN_MATCH) {
+ ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+ // prev[strstart&w_mask]=hash_head=head[ins_h];
+ hash_head = (head[ins_h] & 0xffff);
+ prev[strstart & w_mask] = head[ins_h];
+ head[ins_h] = strstart;
+ }
+
+ // Find the longest match, discarding those <= prev_length.
+ prev_length = match_length;
+ prev_match = match_start;
+ match_length = MIN_MATCH - 1;
+
+ if (hash_head !== 0 && prev_length < max_lazy_match && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD) {
+ // To simplify the code, we prevent matches with the string
+ // of window index 0 (in particular we have to avoid a match
+ // of the string with itself at the start of the input file).
+
+ if (strategy != Z_HUFFMAN_ONLY) {
+ match_length = longest_match(hash_head);
+ }
+ // longest_match() sets match_start
+
+ if (match_length <= 5 && (strategy == Z_FILTERED || (match_length == MIN_MATCH && strstart - match_start > 4096))) {
+
+ // If prev_match is also MIN_MATCH, match_start is garbage
+ // but we will ignore the current match anyway.
+ match_length = MIN_MATCH - 1;
+ }
+ }
+
+ // If there was a match at the previous step and the current
+ // match is not better, output the previous match:
+ if (prev_length >= MIN_MATCH && match_length <= prev_length) {
+ max_insert = strstart + lookahead - MIN_MATCH;
+ // Do not insert strings in hash table beyond this.
+
+ // check_match(strstart-1, prev_match, prev_length);
+
+ bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
+
+ // Insert in hash table all strings up to the end of the match.
+ // strstart-1 and strstart are already inserted. If there is not
+ // enough lookahead, the last two strings are not inserted in
+ // the hash table.
+ lookahead -= prev_length - 1;
+ prev_length -= 2;
+ do {
+ if (++strstart <= max_insert) {
+ ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+ // prev[strstart&w_mask]=hash_head=head[ins_h];
+ hash_head = (head[ins_h] & 0xffff);
+ prev[strstart & w_mask] = head[ins_h];
+ head[ins_h] = strstart;
+ }
+ } while (--prev_length !== 0);
+ match_available = 0;
+ match_length = MIN_MATCH - 1;
+ strstart++;
+
+ if (bflush) {
+ flush_block_only(false);
+ if (strm.avail_out === 0)
+ return NeedMore;
+ }
+ } else if (match_available !== 0) {
+
+ // If there was no match at the previous position, output a
+ // single literal. If there was a match but the current match
+ // is longer, truncate the previous match to a single literal.
+
+ bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+
+ if (bflush) {
+ flush_block_only(false);
+ }
+ strstart++;
+ lookahead--;
+ if (strm.avail_out === 0)
+ return NeedMore;
+ } else {
+ // There is no previous match to compare with, wait for
+ // the next step to decide.
+
+ match_available = 1;
+ strstart++;
+ lookahead--;
+ }
+ }
+
+ if (match_available !== 0) {
+ bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+ match_available = 0;
+ }
+ flush_block_only(flush == Z_FINISH);
+
+ if (strm.avail_out === 0) {
+ if (flush == Z_FINISH)
+ return FinishStarted;
+ else
+ return NeedMore;
+ }
+
+ return flush == Z_FINISH ? FinishDone : BlockDone;
+ }
+
+ function deflateReset(strm) {
+ strm.total_in = strm.total_out = 0;
+ strm.msg = null; //
+
+ that.pending = 0;
+ that.pending_out = 0;
+
+ status = BUSY_STATE;
+
+ last_flush = Z_NO_FLUSH;
+
+ tr_init();
+ lm_init();
+ return Z_OK;
+ }
+
+ that.deflateInit = function(strm, _level, bits, _method, memLevel, _strategy) {
+ if (!_method)
+ _method = Z_DEFLATED;
+ if (!memLevel)
+ memLevel = DEF_MEM_LEVEL;
+ if (!_strategy)
+ _strategy = Z_DEFAULT_STRATEGY;
+
+ // byte[] my_version=ZLIB_VERSION;
+
+ //
+ // if (!version || version[0] != my_version[0]
+ // || stream_size != sizeof(z_stream)) {
+ // return Z_VERSION_ERROR;
+ // }
+
+ strm.msg = null;
+
+ if (_level == Z_DEFAULT_COMPRESSION)
+ _level = 6;
+
+ if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || _method != Z_DEFLATED || bits < 9 || bits > 15 || _level < 0 || _level > 9 || _strategy < 0
+ || _strategy > Z_HUFFMAN_ONLY) {
+ return Z_STREAM_ERROR;
+ }
+
+ strm.dstate = that;
+
+ w_bits = bits;
+ w_size = 1 << w_bits;
+ w_mask = w_size - 1;
+
+ hash_bits = memLevel + 7;
+ hash_size = 1 << hash_bits;
+ hash_mask = hash_size - 1;
+ hash_shift = Math.floor((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
+
+ window = new Uint8Array(w_size * 2);
+ prev = [];
+ head = [];
+
+ lit_bufsize = 1 << (memLevel + 6); // 16K elements by default
+
+ // We overlay pending_buf and d_buf+l_buf. This works since the average
+ // output size for (length,distance) codes is <= 24 bits.
+ that.pending_buf = new Uint8Array(lit_bufsize * 4);
+ pending_buf_size = lit_bufsize * 4;
+
+ d_buf = Math.floor(lit_bufsize / 2);
+ l_buf = (1 + 2) * lit_bufsize;
+
+ level = _level;
+
+ strategy = _strategy;
+ method = _method & 0xff;
+
+ return deflateReset(strm);
+ };
+
+ that.deflateEnd = function() {
+ if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE) {
+ return Z_STREAM_ERROR;
+ }
+ // Deallocate in reverse order of allocations:
+ that.pending_buf = null;
+ head = null;
+ prev = null;
+ window = null;
+ // free
+ that.dstate = null;
+ return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+ };
+
+ that.deflateParams = function(strm, _level, _strategy) {
+ var err = Z_OK;
+
+ if (_level == Z_DEFAULT_COMPRESSION) {
+ _level = 6;
+ }
+ if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY) {
+ return Z_STREAM_ERROR;
+ }
+
+ if (config_table[level].func != config_table[_level].func && strm.total_in !== 0) {
+ // Flush the last buffer:
+ err = strm.deflate(Z_PARTIAL_FLUSH);
+ }
+
+ if (level != _level) {
+ level = _level;
+ max_lazy_match = config_table[level].max_lazy;
+ good_match = config_table[level].good_length;
+ nice_match = config_table[level].nice_length;
+ max_chain_length = config_table[level].max_chain;
+ }
+ strategy = _strategy;
+ return err;
+ };
+
+ that.deflateSetDictionary = function(strm, dictionary, dictLength) {
+ var length = dictLength;
+ var n, index = 0;
+
+ if (!dictionary || status != INIT_STATE)
+ return Z_STREAM_ERROR;
+
+ if (length < MIN_MATCH)
+ return Z_OK;
+ if (length > w_size - MIN_LOOKAHEAD) {
+ length = w_size - MIN_LOOKAHEAD;
+ index = dictLength - length; // use the tail of the dictionary
+ }
+ window.set(dictionary.subarray(index, index + length), 0);
+
+ strstart = length;
+ block_start = length;
+
+ // Insert all strings in the hash table (except for the last two bytes).
+ // s->lookahead stays null, so s->ins_h will be recomputed at the next
+ // call of fill_window.
+
+ ins_h = window[0] & 0xff;
+ ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
+
+ for (n = 0; n <= length - MIN_MATCH; n++) {
+ ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+ prev[n & w_mask] = head[ins_h];
+ head[ins_h] = n;
+ }
+ return Z_OK;
+ };
+
+ that.deflate = function(_strm, flush) {
+ var i, header, level_flags, old_flush, bstate;
+
+ if (flush > Z_FINISH || flush < 0) {
+ return Z_STREAM_ERROR;
+ }
+
+ if (!_strm.next_out || (!_strm.next_in && _strm.avail_in !== 0) || (status == FINISH_STATE && flush != Z_FINISH)) {
+ _strm.msg = z_errmsg[Z_NEED_DICT - (Z_STREAM_ERROR)];
+ return Z_STREAM_ERROR;
+ }
+ if (_strm.avail_out === 0) {
+ _strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
+ return Z_BUF_ERROR;
+ }
+
+ strm = _strm; // just in case
+ old_flush = last_flush;
+ last_flush = flush;
+
+ // Write the zlib header
+ if (status == INIT_STATE) {
+ header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
+ level_flags = ((level - 1) & 0xff) >> 1;
+
+ if (level_flags > 3)
+ level_flags = 3;
+ header |= (level_flags << 6);
+ if (strstart !== 0)
+ header |= PRESET_DICT;
+ header += 31 - (header % 31);
+
+ status = BUSY_STATE;
+ putShortMSB(header);
+ }
+
+ // Flush as much pending output as possible
+ if (that.pending !== 0) {
+ strm.flush_pending();
+ if (strm.avail_out === 0) {
+ // console.log(" avail_out==0");
+ // Since avail_out is 0, deflate will be called again with
+ // more output space, but possibly with both pending and
+ // avail_in equal to zero. There won't be anything to do,
+ // but this is not an error situation so make sure we
+ // return OK instead of BUF_ERROR at next call of deflate:
+ last_flush = -1;
+ return Z_OK;
+ }
+
+ // Make sure there is something to do and avoid duplicate
+ // consecutive
+ // flushes. For repeated and useless calls with Z_FINISH, we keep
+ // returning Z_STREAM_END instead of Z_BUFF_ERROR.
+ } else if (strm.avail_in === 0 && flush <= old_flush && flush != Z_FINISH) {
+ strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
+ return Z_BUF_ERROR;
+ }
+
+ // User must not provide more input after the first FINISH:
+ if (status == FINISH_STATE && strm.avail_in !== 0) {
+ _strm.msg = z_errmsg[Z_NEED_DICT - (Z_BUF_ERROR)];
+ return Z_BUF_ERROR;
+ }
+
+ // Start a new block or continue the current one.
+ if (strm.avail_in !== 0 || lookahead !== 0 || (flush != Z_NO_FLUSH && status != FINISH_STATE)) {
+ bstate = -1;
+ switch (config_table[level].func) {
+ case STORED:
+ bstate = deflate_stored(flush);
+ break;
+ case FAST:
+ bstate = deflate_fast(flush);
+ break;
+ case SLOW:
+ bstate = deflate_slow(flush);
+ break;
+ default:
+ }
+
+ if (bstate == FinishStarted || bstate == FinishDone) {
+ status = FINISH_STATE;
+ }
+ if (bstate == NeedMore || bstate == FinishStarted) {
+ if (strm.avail_out === 0) {
+ last_flush = -1; // avoid BUF_ERROR next call, see above
+ }
+ return Z_OK;
+ // If flush != Z_NO_FLUSH && avail_out === 0, the next call
+ // of deflate should use the same flush parameter to make sure
+ // that the flush is complete. So we don't have to output an
+ // empty block here, this will be done at next call. This also
+ // ensures that for a very small output buffer, we emit at most
+ // one empty block.
+ }
+
+ if (bstate == BlockDone) {
+ if (flush == Z_PARTIAL_FLUSH) {
+ _tr_align();
+ } else { // FULL_FLUSH or SYNC_FLUSH
+ _tr_stored_block(0, 0, false);
+ // For a full flush, this empty block will be recognized
+ // as a special marker by inflate_sync().
+ if (flush == Z_FULL_FLUSH) {
+ // state.head[s.hash_size-1]=0;
+ for (i = 0; i < hash_size/*-1*/; i++)
+ // forget history
+ head[i] = 0;
+ }
+ }
+ strm.flush_pending();
+ if (strm.avail_out === 0) {
+ last_flush = -1; // avoid BUF_ERROR at next call, see above
+ return Z_OK;
+ }
+ }
+ }
+
+ if (flush != Z_FINISH)
+ return Z_OK;
+ return Z_STREAM_END;
+ };
+ }
+
+ // ZStream
+
+ function ZStream() {
+ var that = this;
+ that.next_in_index = 0;
+ that.next_out_index = 0;
+ // that.next_in; // next input byte
+ that.avail_in = 0; // number of bytes available at next_in
+ that.total_in = 0; // total nb of input bytes read so far
+ // that.next_out; // next output byte should be put there
+ that.avail_out = 0; // remaining free space at next_out
+ that.total_out = 0; // total nb of bytes output so far
+ // that.msg;
+ // that.dstate;
+ }
+
+ ZStream.prototype = {
+ deflateInit : function(level, bits) {
+ var that = this;
+ that.dstate = new Deflate();
+ if (!bits)
+ bits = MAX_BITS;
+ return that.dstate.deflateInit(that, level, bits);
+ },
+
+ deflate : function(flush) {
+ var that = this;
+ if (!that.dstate) {
+ return Z_STREAM_ERROR;
+ }
+ return that.dstate.deflate(that, flush);
+ },
+
+ deflateEnd : function() {
+ var that = this;
+ if (!that.dstate)
+ return Z_STREAM_ERROR;
+ var ret = that.dstate.deflateEnd();
+ that.dstate = null;
+ return ret;
+ },
+
+ deflateParams : function(level, strategy) {
+ var that = this;
+ if (!that.dstate)
+ return Z_STREAM_ERROR;
+ return that.dstate.deflateParams(that, level, strategy);
+ },
+
+ deflateSetDictionary : function(dictionary, dictLength) {
+ var that = this;
+ if (!that.dstate)
+ return Z_STREAM_ERROR;
+ return that.dstate.deflateSetDictionary(that, dictionary, dictLength);
+ },
+
+ // Read a new buffer from the current input stream, update the
+ // total number of bytes read. All deflate() input goes through
+ // this function so some applications may wish to modify it to avoid
+ // allocating a large strm->next_in buffer and copying from it.
+ // (See also flush_pending()).
+ read_buf : function(buf, start, size) {
+ var that = this;
+ var len = that.avail_in;
+ if (len > size)
+ len = size;
+ if (len === 0)
+ return 0;
+ that.avail_in -= len;
+ buf.set(that.next_in.subarray(that.next_in_index, that.next_in_index + len), start);
+ that.next_in_index += len;
+ that.total_in += len;
+ return len;
+ },
+
+ // Flush as much pending output as possible. All deflate() output goes
+ // through this function so some applications may wish to modify it
+ // to avoid allocating a large strm->next_out buffer and copying into it.
+ // (See also read_buf()).
+ flush_pending : function() {
+ var that = this;
+ var len = that.dstate.pending;
+
+ if (len > that.avail_out)
+ len = that.avail_out;
+ if (len === 0)
+ return;
+
+ // if (that.dstate.pending_buf.length <= that.dstate.pending_out || that.next_out.length <= that.next_out_index
+ // || that.dstate.pending_buf.length < (that.dstate.pending_out + len) || that.next_out.length < (that.next_out_index +
+ // len)) {
+ // console.log(that.dstate.pending_buf.length + ", " + that.dstate.pending_out + ", " + that.next_out.length + ", " +
+ // that.next_out_index + ", " + len);
+ // console.log("avail_out=" + that.avail_out);
+ // }
+
+ that.next_out.set(that.dstate.pending_buf.subarray(that.dstate.pending_out, that.dstate.pending_out + len), that.next_out_index);
+
+ that.next_out_index += len;
+ that.dstate.pending_out += len;
+ that.total_out += len;
+ that.avail_out -= len;
+ that.dstate.pending -= len;
+ if (that.dstate.pending === 0) {
+ that.dstate.pending_out = 0;
+ }
+ }
+ };
+
+ // Deflater
+
+ function Deflater(options) {
+ var that = this;
+ var z = new ZStream();
+ var bufsize = 512;
+ var flush = Z_NO_FLUSH;
+ var buf = new Uint8Array(bufsize);
+ var level = options ? options.level : Z_DEFAULT_COMPRESSION;
+ if (typeof level == "undefined")
+ level = Z_DEFAULT_COMPRESSION;
+ z.deflateInit(level);
+ z.next_out = buf;
+
+ that.append = function(data, onprogress) {
+ var err, buffers = [], lastIndex = 0, bufferIndex = 0, bufferSize = 0, array;
+ if (!data.length)
+ 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;
+ err = z.deflate(flush);
+ if (err != Z_OK)
+ throw new Error("deflating: " + z.msg);
+ 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() {
+ var err, buffers = [], bufferIndex = 0, bufferSize = 0, array;
+ do {
+ z.next_out_index = 0;
+ z.avail_out = bufsize;
+ err = z.deflate(Z_FINISH);
+ if (err != Z_STREAM_END && err != Z_OK)
+ throw new Error("deflating: " + z.msg);
+ if (bufsize - z.avail_out > 0)
+ buffers.push(new Uint8Array(buf.subarray(0, z.next_out_index)));
+ bufferSize += z.next_out_index;
+ } while (z.avail_in > 0 || z.avail_out === 0);
+ z.deflateEnd();
+ array = new Uint8Array(bufferSize);
+ buffers.forEach(function(chunk) {
+ array.set(chunk, bufferIndex);
+ bufferIndex += chunk.length;
+ });
+ return array;
+ };
+ }
+
+ // 'zip' may not be defined in z-worker and some tests
+ var env = global.zip || global;
+ env.Deflater = env._jzlib_Deflater = Deflater;
+})(this);
diff --git a/lib/inflate.js b/lib/inflate.js
new file mode 100644
index 0000000..7174050
--- /dev/null
+++ b/lib/inflate.js
@@ -0,0 +1,2155 @@
+/*
+ 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.
+ */
+
+(function(global) {
+ "use strict";
+
+ // 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 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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;
+ /* falls through */
+ 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)) {
+ if (z.avail_in !== 0)
+ throw new Error("inflating: bad input");
+ } else if (err !== Z_OK && err !== Z_STREAM_END)
+ throw new Error("inflating: " + z.msg);
+ if ((nomoreinput || err === Z_STREAM_END) && (z.avail_in === data.length))
+ throw new Error("inflating: bad input");
+ 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();
+ };
+ }
+
+ // 'zip' may not be defined in z-worker and some tests
+ var env = global.zip || global;
+ env.Inflater = env._jzlib_Inflater = Inflater;
+})(this);
diff --git a/lib/mime-types.js b/lib/mime-types.js
new file mode 100644
index 0000000..b6a9aa6
--- /dev/null
+++ b/lib/mime-types.js
@@ -0,0 +1,1002 @@
+/*
+ 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() {
+ "use strict";
+ var table = {
+ "application" : {
+ "andrew-inset" : "ez",
+ "annodex" : "anx",
+ "atom+xml" : "atom",
+ "atomcat+xml" : "atomcat",
+ "atomserv+xml" : "atomsrv",
+ "bbolin" : "lin",
+ "cap" : [ "cap", "pcap" ],
+ "cu-seeme" : "cu",
+ "davmount+xml" : "davmount",
+ "dsptype" : "tsp",
+ "ecmascript" : [ "es", "ecma" ],
+ "futuresplash" : "spl",
+ "hta" : "hta",
+ "java-archive" : "jar",
+ "java-serialized-object" : "ser",
+ "java-vm" : "class",
+ "javascript" : "js",
+ "m3g" : "m3g",
+ "mac-binhex40" : "hqx",
+ "mathematica" : [ "nb", "ma", "mb" ],
+ "msaccess" : "mdb",
+ "msword" : [ "doc", "dot" ],
+ "mxf" : "mxf",
+ "oda" : "oda",
+ "ogg" : "ogx",
+ "pdf" : "pdf",
+ "pgp-keys" : "key",
+ "pgp-signature" : [ "asc", "sig" ],
+ "pics-rules" : "prf",
+ "postscript" : [ "ps", "ai", "eps", "epsi", "epsf", "eps2", "eps3" ],
+ "rar" : "rar",
+ "rdf+xml" : "rdf",
+ "rss+xml" : "rss",
+ "rtf" : "rtf",
+ "smil" : [ "smi", "smil" ],
+ "xhtml+xml" : [ "xhtml", "xht" ],
+ "xml" : [ "xml", "xsl", "xsd" ],
+ "xspf+xml" : "xspf",
+ "zip" : "zip",
+ "vnd.android.package-archive" : "apk",
+ "vnd.cinderella" : "cdy",
+ "vnd.google-earth.kml+xml" : "kml",
+ "vnd.google-earth.kmz" : "kmz",
+ "vnd.mozilla.xul+xml" : "xul",
+ "vnd.ms-excel" : [ "xls", "xlb", "xlt", "xlm", "xla", "xlc", "xlw" ],
+ "vnd.ms-pki.seccat" : "cat",
+ "vnd.ms-pki.stl" : "stl",
+ "vnd.ms-powerpoint" : [ "ppt", "pps", "pot" ],
+ "vnd.oasis.opendocument.chart" : "odc",
+ "vnd.oasis.opendocument.database" : "odb",
+ "vnd.oasis.opendocument.formula" : "odf",
+ "vnd.oasis.opendocument.graphics" : "odg",
+ "vnd.oasis.opendocument.graphics-template" : "otg",
+ "vnd.oasis.opendocument.image" : "odi",
+ "vnd.oasis.opendocument.presentation" : "odp",
+ "vnd.oasis.opendocument.presentation-template" : "otp",
+ "vnd.oasis.opendocument.spreadsheet" : "ods",
+ "vnd.oasis.opendocument.spreadsheet-template" : "ots",
+ "vnd.oasis.opendocument.text" : "odt",
+ "vnd.oasis.opendocument.text-master" : "odm",
+ "vnd.oasis.opendocument.text-template" : "ott",
+ "vnd.oasis.opendocument.text-web" : "oth",
+ "vnd.openxmlformats-officedocument.spreadsheetml.sheet" : "xlsx",
+ "vnd.openxmlformats-officedocument.spreadsheetml.template" : "xltx",
+ "vnd.openxmlformats-officedocument.presentationml.presentation" : "pptx",
+ "vnd.openxmlformats-officedocument.presentationml.slideshow" : "ppsx",
+ "vnd.openxmlformats-officedocument.presentationml.template" : "potx",
+ "vnd.openxmlformats-officedocument.wordprocessingml.document" : "docx",
+ "vnd.openxmlformats-officedocument.wordprocessingml.template" : "dotx",
+ "vnd.smaf" : "mmf",
+ "vnd.stardivision.calc" : "sdc",
+ "vnd.stardivision.chart" : "sds",
+ "vnd.stardivision.draw" : "sda",
+ "vnd.stardivision.impress" : "sdd",
+ "vnd.stardivision.math" : [ "sdf", "smf" ],
+ "vnd.stardivision.writer" : [ "sdw", "vor" ],
+ "vnd.stardivision.writer-global" : "sgl",
+ "vnd.sun.xml.calc" : "sxc",
+ "vnd.sun.xml.calc.template" : "stc",
+ "vnd.sun.xml.draw" : "sxd",
+ "vnd.sun.xml.draw.template" : "std",
+ "vnd.sun.xml.impress" : "sxi",
+ "vnd.sun.xml.impress.template" : "sti",
+ "vnd.sun.xml.math" : "sxm",
+ "vnd.sun.xml.writer" : "sxw",
+ "vnd.sun.xml.writer.global" : "sxg",
+ "vnd.sun.xml.writer.template" : "stw",
+ "vnd.symbian.install" : [ "sis", "sisx" ],
+ "vnd.visio" : [ "vsd", "vst", "vss", "vsw" ],
+ "vnd.wap.wbxml" : "wbxml",
+ "vnd.wap.wmlc" : "wmlc",
+ "vnd.wap.wmlscriptc" : "wmlsc",
+ "vnd.wordperfect" : "wpd",
+ "vnd.wordperfect5.1" : "wp5",
+ "x-123" : "wk",
+ "x-7z-compressed" : "7z",
+ "x-abiword" : "abw",
+ "x-apple-diskimage" : "dmg",
+ "x-bcpio" : "bcpio",
+ "x-bittorrent" : "torrent",
+ "x-cbr" : [ "cbr", "cba", "cbt", "cb7" ],
+ "x-cbz" : "cbz",
+ "x-cdf" : [ "cdf", "cda" ],
+ "x-cdlink" : "vcd",
+ "x-chess-pgn" : "pgn",
+ "x-cpio" : "cpio",
+ "x-csh" : "csh",
+ "x-debian-package" : [ "deb", "udeb" ],
+ "x-director" : [ "dcr", "dir", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa" ],
+ "x-dms" : "dms",
+ "x-doom" : "wad",
+ "x-dvi" : "dvi",
+ "x-httpd-eruby" : "rhtml",
+ "x-font" : "pcf.Z",
+ "x-freemind" : "mm",
+ "x-gnumeric" : "gnumeric",
+ "x-go-sgf" : "sgf",
+ "x-graphing-calculator" : "gcf",
+ "x-gtar" : [ "gtar", "taz" ],
+ "x-hdf" : "hdf",
+ "x-httpd-php" : [ "phtml", "pht", "php" ],
+ "x-httpd-php-source" : "phps",
+ "x-httpd-php3" : "php3",
+ "x-httpd-php3-preprocessed" : "php3p",
+ "x-httpd-php4" : "php4",
+ "x-httpd-php5" : "php5",
+ "x-ica" : "ica",
+ "x-info" : "info",
+ "x-internet-signup" : [ "ins", "isp" ],
+ "x-iphone" : "iii",
+ "x-iso9660-image" : "iso",
+ "x-java-jnlp-file" : "jnlp",
+ "x-jmol" : "jmz",
+ "x-killustrator" : "kil",
+ "x-koan" : [ "skp", "skd", "skt", "skm" ],
+ "x-kpresenter" : [ "kpr", "kpt" ],
+ "x-kword" : [ "kwd", "kwt" ],
+ "x-latex" : "latex",
+ "x-lha" : "lha",
+ "x-lyx" : "lyx",
+ "x-lzh" : "lzh",
+ "x-lzx" : "lzx",
+ "x-maker" : [ "frm", "maker", "frame", "fm", "fb", "book", "fbdoc" ],
+ "x-ms-wmd" : "wmd",
+ "x-ms-wmz" : "wmz",
+ "x-msdos-program" : [ "com", "exe", "bat", "dll" ],
+ "x-msi" : "msi",
+ "x-netcdf" : [ "nc", "cdf" ],
+ "x-ns-proxy-autoconfig" : [ "pac", "dat" ],
+ "x-nwc" : "nwc",
+ "x-object" : "o",
+ "x-oz-application" : "oza",
+ "x-pkcs7-certreqresp" : "p7r",
+ "x-python-code" : [ "pyc", "pyo" ],
+ "x-qgis" : [ "qgs", "shp", "shx" ],
+ "x-quicktimeplayer" : "qtl",
+ "x-redhat-package-manager" : "rpm",
+ "x-ruby" : "rb",
+ "x-sh" : "sh",
+ "x-shar" : "shar",
+ "x-shockwave-flash" : [ "swf", "swfl" ],
+ "x-silverlight" : "scr",
+ "x-stuffit" : "sit",
+ "x-sv4cpio" : "sv4cpio",
+ "x-sv4crc" : "sv4crc",
+ "x-tar" : "tar",
+ "x-tcl" : "tcl",
+ "x-tex-gf" : "gf",
+ "x-tex-pk" : "pk",
+ "x-texinfo" : [ "texinfo", "texi" ],
+ "x-trash" : [ "~", "%", "bak", "old", "sik" ],
+ "x-troff" : [ "t", "tr", "roff" ],
+ "x-troff-man" : "man",
+ "x-troff-me" : "me",
+ "x-troff-ms" : "ms",
+ "x-ustar" : "ustar",
+ "x-wais-source" : "src",
+ "x-wingz" : "wz",
+ "x-x509-ca-cert" : [ "crt", "der", "cer" ],
+ "x-xcf" : "xcf",
+ "x-xfig" : "fig",
+ "x-xpinstall" : "xpi",
+ "applixware" : "aw",
+ "atomsvc+xml" : "atomsvc",
+ "ccxml+xml" : "ccxml",
+ "cdmi-capability" : "cdmia",
+ "cdmi-container" : "cdmic",
+ "cdmi-domain" : "cdmid",
+ "cdmi-object" : "cdmio",
+ "cdmi-queue" : "cdmiq",
+ "docbook+xml" : "dbk",
+ "dssc+der" : "dssc",
+ "dssc+xml" : "xdssc",
+ "emma+xml" : "emma",
+ "epub+zip" : "epub",
+ "exi" : "exi",
+ "font-tdpfr" : "pfr",
+ "gml+xml" : "gml",
+ "gpx+xml" : "gpx",
+ "gxf" : "gxf",
+ "hyperstudio" : "stk",
+ "inkml+xml" : [ "ink", "inkml" ],
+ "ipfix" : "ipfix",
+ "json" : "json",
+ "jsonml+json" : "jsonml",
+ "lost+xml" : "lostxml",
+ "mads+xml" : "mads",
+ "marc" : "mrc",
+ "marcxml+xml" : "mrcx",
+ "mathml+xml" : "mathml",
+ "mbox" : "mbox",
+ "mediaservercontrol+xml" : "mscml",
+ "metalink+xml" : "metalink",
+ "metalink4+xml" : "meta4",
+ "mets+xml" : "mets",
+ "mods+xml" : "mods",
+ "mp21" : [ "m21", "mp21" ],
+ "mp4" : "mp4s",
+ "oebps-package+xml" : "opf",
+ "omdoc+xml" : "omdoc",
+ "onenote" : [ "onetoc", "onetoc2", "onetmp", "onepkg" ],
+ "oxps" : "oxps",
+ "patch-ops-error+xml" : "xer",
+ "pgp-encrypted" : "pgp",
+ "pkcs10" : "p10",
+ "pkcs7-mime" : [ "p7m", "p7c" ],
+ "pkcs7-signature" : "p7s",
+ "pkcs8" : "p8",
+ "pkix-attr-cert" : "ac",
+ "pkix-crl" : "crl",
+ "pkix-pkipath" : "pkipath",
+ "pkixcmp" : "pki",
+ "pls+xml" : "pls",
+ "prs.cww" : "cww",
+ "pskc+xml" : "pskcxml",
+ "reginfo+xml" : "rif",
+ "relax-ng-compact-syntax" : "rnc",
+ "resource-lists+xml" : "rl",
+ "resource-lists-diff+xml" : "rld",
+ "rls-services+xml" : "rs",
+ "rpki-ghostbusters" : "gbr",
+ "rpki-manifest" : "mft",
+ "rpki-roa" : "roa",
+ "rsd+xml" : "rsd",
+ "sbml+xml" : "sbml",
+ "scvp-cv-request" : "scq",
+ "scvp-cv-response" : "scs",
+ "scvp-vp-request" : "spq",
+ "scvp-vp-response" : "spp",
+ "sdp" : "sdp",
+ "set-payment-initiation" : "setpay",
+ "set-registration-initiation" : "setreg",
+ "shf+xml" : "shf",
+ "sparql-query" : "rq",
+ "sparql-results+xml" : "srx",
+ "srgs" : "gram",
+ "srgs+xml" : "grxml",
+ "sru+xml" : "sru",
+ "ssdl+xml" : "ssdl",
+ "ssml+xml" : "ssml",
+ "tei+xml" : [ "tei", "teicorpus" ],
+ "thraud+xml" : "tfi",
+ "timestamped-data" : "tsd",
+ "vnd.3gpp.pic-bw-large" : "plb",
+ "vnd.3gpp.pic-bw-small" : "psb",
+ "vnd.3gpp.pic-bw-var" : "pvb",
+ "vnd.3gpp2.tcap" : "tcap",
+ "vnd.3m.post-it-notes" : "pwn",
+ "vnd.accpac.simply.aso" : "aso",
+ "vnd.accpac.simply.imp" : "imp",
+ "vnd.acucobol" : "acu",
+ "vnd.acucorp" : [ "atc", "acutc" ],
+ "vnd.adobe.air-application-installer-package+zip" : "air",
+ "vnd.adobe.formscentral.fcdt" : "fcdt",
+ "vnd.adobe.fxp" : [ "fxp", "fxpl" ],
+ "vnd.adobe.xdp+xml" : "xdp",
+ "vnd.adobe.xfdf" : "xfdf",
+ "vnd.ahead.space" : "ahead",
+ "vnd.airzip.filesecure.azf" : "azf",
+ "vnd.airzip.filesecure.azs" : "azs",
+ "vnd.amazon.ebook" : "azw",
+ "vnd.americandynamics.acc" : "acc",
+ "vnd.amiga.ami" : "ami",
+ "vnd.anser-web-certificate-issue-initiation" : "cii",
+ "vnd.anser-web-funds-transfer-initiation" : "fti",
+ "vnd.antix.game-component" : "atx",
+ "vnd.apple.installer+xml" : "mpkg",
+ "vnd.apple.mpegurl" : "m3u8",
+ "vnd.aristanetworks.swi" : "swi",
+ "vnd.astraea-software.iota" : "iota",
+ "vnd.audiograph" : "aep",
+ "vnd.blueice.multipass" : "mpm",
+ "vnd.bmi" : "bmi",
+ "vnd.businessobjects" : "rep",
+ "vnd.chemdraw+xml" : "cdxml",
+ "vnd.chipnuts.karaoke-mmd" : "mmd",
+ "vnd.claymore" : "cla",
+ "vnd.cloanto.rp9" : "rp9",
+ "vnd.clonk.c4group" : [ "c4g", "c4d", "c4f", "c4p", "c4u" ],
+ "vnd.cluetrust.cartomobile-config" : "c11amc",
+ "vnd.cluetrust.cartomobile-config-pkg" : "c11amz",
+ "vnd.commonspace" : "csp",
+ "vnd.contact.cmsg" : "cdbcmsg",
+ "vnd.cosmocaller" : "cmc",
+ "vnd.crick.clicker" : "clkx",
+ "vnd.crick.clicker.keyboard" : "clkk",
+ "vnd.crick.clicker.palette" : "clkp",
+ "vnd.crick.clicker.template" : "clkt",
+ "vnd.crick.clicker.wordbank" : "clkw",
+ "vnd.criticaltools.wbs+xml" : "wbs",
+ "vnd.ctc-posml" : "pml",
+ "vnd.cups-ppd" : "ppd",
+ "vnd.curl.car" : "car",
+ "vnd.curl.pcurl" : "pcurl",
+ "vnd.dart" : "dart",
+ "vnd.data-vision.rdz" : "rdz",
+ "vnd.dece.data" : [ "uvf", "uvvf", "uvd", "uvvd" ],
+ "vnd.dece.ttml+xml" : [ "uvt", "uvvt" ],
+ "vnd.dece.unspecified" : [ "uvx", "uvvx" ],
+ "vnd.dece.zip" : [ "uvz", "uvvz" ],
+ "vnd.denovo.fcselayout-link" : "fe_launch",
+ "vnd.dna" : "dna",
+ "vnd.dolby.mlp" : "mlp",
+ "vnd.dpgraph" : "dpg",
+ "vnd.dreamfactory" : "dfac",
+ "vnd.ds-keypoint" : "kpxx",
+ "vnd.dvb.ait" : "ait",
+ "vnd.dvb.service" : "svc",
+ "vnd.dynageo" : "geo",
+ "vnd.ecowin.chart" : "mag",
+ "vnd.enliven" : "nml",
+ "vnd.epson.esf" : "esf",
+ "vnd.epson.msf" : "msf",
+ "vnd.epson.quickanime" : "qam",
+ "vnd.epson.salt" : "slt",
+ "vnd.epson.ssf" : "ssf",
+ "vnd.eszigno3+xml" : [ "es3", "et3" ],
+ "vnd.ezpix-album" : "ez2",
+ "vnd.ezpix-package" : "ez3",
+ "vnd.fdf" : "fdf",
+ "vnd.fdsn.mseed" : "mseed",
+ "vnd.fdsn.seed" : [ "seed", "dataless" ],
+ "vnd.flographit" : "gph",
+ "vnd.fluxtime.clip" : "ftc",
+ "vnd.framemaker" : [ "fm", "frame", "maker", "book" ],
+ "vnd.frogans.fnc" : "fnc",
+ "vnd.frogans.ltf" : "ltf",
+ "vnd.fsc.weblaunch" : "fsc",
+ "vnd.fujitsu.oasys" : "oas",
+ "vnd.fujitsu.oasys2" : "oa2",
+ "vnd.fujitsu.oasys3" : "oa3",
+ "vnd.fujitsu.oasysgp" : "fg5",
+ "vnd.fujitsu.oasysprs" : "bh2",
+ "vnd.fujixerox.ddd" : "ddd",
+ "vnd.fujixerox.docuworks" : "xdw",
+ "vnd.fujixerox.docuworks.binder" : "xbd",
+ "vnd.fuzzysheet" : "fzs",
+ "vnd.genomatix.tuxedo" : "txd",
+ "vnd.geogebra.file" : "ggb",
+ "vnd.geogebra.tool" : "ggt",
+ "vnd.geometry-explorer" : [ "gex", "gre" ],
+ "vnd.geonext" : "gxt",
+ "vnd.geoplan" : "g2w",
+ "vnd.geospace" : "g3w",
+ "vnd.gmx" : "gmx",
+ "vnd.grafeq" : [ "gqf", "gqs" ],
+ "vnd.groove-account" : "gac",
+ "vnd.groove-help" : "ghf",
+ "vnd.groove-identity-message" : "gim",
+ "vnd.groove-injector" : "grv",
+ "vnd.groove-tool-message" : "gtm",
+ "vnd.groove-tool-template" : "tpl",
+ "vnd.groove-vcard" : "vcg",
+ "vnd.hal+xml" : "hal",
+ "vnd.handheld-entertainment+xml" : "zmm",
+ "vnd.hbci" : "hbci",
+ "vnd.hhe.lesson-player" : "les",
+ "vnd.hp-hpgl" : "hpgl",
+ "vnd.hp-hpid" : "hpid",
+ "vnd.hp-hps" : "hps",
+ "vnd.hp-jlyt" : "jlt",
+ "vnd.hp-pcl" : "pcl",
+ "vnd.hp-pclxl" : "pclxl",
+ "vnd.hydrostatix.sof-data" : "sfd-hdstx",
+ "vnd.ibm.minipay" : "mpy",
+ "vnd.ibm.modcap" : [ "afp", "listafp", "list3820" ],
+ "vnd.ibm.rights-management" : "irm",
+ "vnd.ibm.secure-container" : "sc",
+ "vnd.iccprofile" : [ "icc", "icm" ],
+ "vnd.igloader" : "igl",
+ "vnd.immervision-ivp" : "ivp",
+ "vnd.immervision-ivu" : "ivu",
+ "vnd.insors.igm" : "igm",
+ "vnd.intercon.formnet" : [ "xpw", "xpx" ],
+ "vnd.intergeo" : "i2g",
+ "vnd.intu.qbo" : "qbo",
+ "vnd.intu.qfx" : "qfx",
+ "vnd.ipunplugged.rcprofile" : "rcprofile",
+ "vnd.irepository.package+xml" : "irp",
+ "vnd.is-xpr" : "xpr",
+ "vnd.isac.fcs" : "fcs",
+ "vnd.jam" : "jam",
+ "vnd.jcp.javame.midlet-rms" : "rms",
+ "vnd.jisp" : "jisp",
+ "vnd.joost.joda-archive" : "joda",
+ "vnd.kahootz" : [ "ktz", "ktr" ],
+ "vnd.kde.karbon" : "karbon",
+ "vnd.kde.kchart" : "chrt",
+ "vnd.kde.kformula" : "kfo",
+ "vnd.kde.kivio" : "flw",
+ "vnd.kde.kontour" : "kon",
+ "vnd.kde.kpresenter" : [ "kpr", "kpt" ],
+ "vnd.kde.kspread" : "ksp",
+ "vnd.kde.kword" : [ "kwd", "kwt" ],
+ "vnd.kenameaapp" : "htke",
+ "vnd.kidspiration" : "kia",
+ "vnd.kinar" : [ "kne", "knp" ],
+ "vnd.koan" : [ "skp", "skd", "skt", "skm" ],
+ "vnd.kodak-descriptor" : "sse",
+ "vnd.las.las+xml" : "lasxml",
+ "vnd.llamagraphics.life-balance.desktop" : "lbd",
+ "vnd.llamagraphics.life-balance.exchange+xml" : "lbe",
+ "vnd.lotus-1-2-3" : "123",
+ "vnd.lotus-approach" : "apr",
+ "vnd.lotus-freelance" : "pre",
+ "vnd.lotus-notes" : "nsf",
+ "vnd.lotus-organizer" : "org",
+ "vnd.lotus-screencam" : "scm",
+ "vnd.lotus-wordpro" : "lwp",
+ "vnd.macports.portpkg" : "portpkg",
+ "vnd.mcd" : "mcd",
+ "vnd.medcalcdata" : "mc1",
+ "vnd.mediastation.cdkey" : "cdkey",
+ "vnd.mfer" : "mwf",
+ "vnd.mfmp" : "mfm",
+ "vnd.micrografx.flo" : "flo",
+ "vnd.micrografx.igx" : "igx",
+ "vnd.mif" : "mif",
+ "vnd.mobius.daf" : "daf",
+ "vnd.mobius.dis" : "dis",
+ "vnd.mobius.mbk" : "mbk",
+ "vnd.mobius.mqy" : "mqy",
+ "vnd.mobius.msl" : "msl",
+ "vnd.mobius.plc" : "plc",
+ "vnd.mobius.txf" : "txf",
+ "vnd.mophun.application" : "mpn",
+ "vnd.mophun.certificate" : "mpc",
+ "vnd.ms-artgalry" : "cil",
+ "vnd.ms-cab-compressed" : "cab",
+ "vnd.ms-excel.addin.macroenabled.12" : "xlam",
+ "vnd.ms-excel.sheet.binary.macroenabled.12" : "xlsb",
+ "vnd.ms-excel.sheet.macroenabled.12" : "xlsm",
+ "vnd.ms-excel.template.macroenabled.12" : "xltm",
+ "vnd.ms-fontobject" : "eot",
+ "vnd.ms-htmlhelp" : "chm",
+ "vnd.ms-ims" : "ims",
+ "vnd.ms-lrm" : "lrm",
+ "vnd.ms-officetheme" : "thmx",
+ "vnd.ms-powerpoint.addin.macroenabled.12" : "ppam",
+ "vnd.ms-powerpoint.presentation.macroenabled.12" : "pptm",
+ "vnd.ms-powerpoint.slide.macroenabled.12" : "sldm",
+ "vnd.ms-powerpoint.slideshow.macroenabled.12" : "ppsm",
+ "vnd.ms-powerpoint.template.macroenabled.12" : "potm",
+ "vnd.ms-project" : [ "mpp", "mpt" ],
+ "vnd.ms-word.document.macroenabled.12" : "docm",
+ "vnd.ms-word.template.macroenabled.12" : "dotm",
+ "vnd.ms-works" : [ "wps", "wks", "wcm", "wdb" ],
+ "vnd.ms-wpl" : "wpl",
+ "vnd.ms-xpsdocument" : "xps",
+ "vnd.mseq" : "mseq",
+ "vnd.musician" : "mus",
+ "vnd.muvee.style" : "msty",
+ "vnd.mynfc" : "taglet",
+ "vnd.neurolanguage.nlu" : "nlu",
+ "vnd.nitf" : [ "ntf", "nitf" ],
+ "vnd.noblenet-directory" : "nnd",
+ "vnd.noblenet-sealer" : "nns",
+ "vnd.noblenet-web" : "nnw",
+ "vnd.nokia.n-gage.data" : "ngdat",
+ "vnd.nokia.n-gage.symbian.install" : "n-gage",
+ "vnd.nokia.radio-preset" : "rpst",
+ "vnd.nokia.radio-presets" : "rpss",
+ "vnd.novadigm.edm" : "edm",
+ "vnd.novadigm.edx" : "edx",
+ "vnd.novadigm.ext" : "ext",
+ "vnd.oasis.opendocument.chart-template" : "otc",
+ "vnd.oasis.opendocument.formula-template" : "odft",
+ "vnd.oasis.opendocument.image-template" : "oti",
+ "vnd.olpc-sugar" : "xo",
+ "vnd.oma.dd2+xml" : "dd2",
+ "vnd.openofficeorg.extension" : "oxt",
+ "vnd.openxmlformats-officedocument.presentationml.slide" : "sldx",
+ "vnd.osgeo.mapguide.package" : "mgp",
+ "vnd.osgi.dp" : "dp",
+ "vnd.osgi.subsystem" : "esa",
+ "vnd.palm" : [ "pdb", "pqa", "oprc" ],
+ "vnd.pawaafile" : "paw",
+ "vnd.pg.format" : "str",
+ "vnd.pg.osasli" : "ei6",
+ "vnd.picsel" : "efif",
+ "vnd.pmi.widget" : "wg",
+ "vnd.pocketlearn" : "plf",
+ "vnd.powerbuilder6" : "pbd",
+ "vnd.previewsystems.box" : "box",
+ "vnd.proteus.magazine" : "mgz",
+ "vnd.publishare-delta-tree" : "qps",
+ "vnd.pvi.ptid1" : "ptid",
+ "vnd.quark.quarkxpress" : [ "qxd", "qxt", "qwd", "qwt", "qxl", "qxb" ],
+ "vnd.realvnc.bed" : "bed",
+ "vnd.recordare.musicxml" : "mxl",
+ "vnd.recordare.musicxml+xml" : "musicxml",
+ "vnd.rig.cryptonote" : "cryptonote",
+ "vnd.rn-realmedia" : "rm",
+ "vnd.rn-realmedia-vbr" : "rmvb",
+ "vnd.route66.link66+xml" : "link66",
+ "vnd.sailingtracker.track" : "st",
+ "vnd.seemail" : "see",
+ "vnd.sema" : "sema",
+ "vnd.semd" : "semd",
+ "vnd.semf" : "semf",
+ "vnd.shana.informed.formdata" : "ifm",
+ "vnd.shana.informed.formtemplate" : "itp",
+ "vnd.shana.informed.interchange" : "iif",
+ "vnd.shana.informed.package" : "ipk",
+ "vnd.simtech-mindmapper" : [ "twd", "twds" ],
+ "vnd.smart.teacher" : "teacher",
+ "vnd.solent.sdkm+xml" : [ "sdkm", "sdkd" ],
+ "vnd.spotfire.dxp" : "dxp",
+ "vnd.spotfire.sfs" : "sfs",
+ "vnd.stepmania.package" : "smzip",
+ "vnd.stepmania.stepchart" : "sm",
+ "vnd.sus-calendar" : [ "sus", "susp" ],
+ "vnd.svd" : "svd",
+ "vnd.syncml+xml" : "xsm",
+ "vnd.syncml.dm+wbxml" : "bdm",
+ "vnd.syncml.dm+xml" : "xdm",
+ "vnd.tao.intent-module-archive" : "tao",
+ "vnd.tcpdump.pcap" : [ "pcap", "cap", "dmp" ],
+ "vnd.tmobile-livetv" : "tmo",
+ "vnd.trid.tpt" : "tpt",
+ "vnd.triscape.mxs" : "mxs",
+ "vnd.trueapp" : "tra",
+ "vnd.ufdl" : [ "ufd", "ufdl" ],
+ "vnd.uiq.theme" : "utz",
+ "vnd.umajin" : "umj",
+ "vnd.unity" : "unityweb",
+ "vnd.uoml+xml" : "uoml",
+ "vnd.vcx" : "vcx",
+ "vnd.visionary" : "vis",
+ "vnd.vsf" : "vsf",
+ "vnd.webturbo" : "wtb",
+ "vnd.wolfram.player" : "nbp",
+ "vnd.wqd" : "wqd",
+ "vnd.wt.stf" : "stf",
+ "vnd.xara" : "xar",
+ "vnd.xfdl" : "xfdl",
+ "vnd.yamaha.hv-dic" : "hvd",
+ "vnd.yamaha.hv-script" : "hvs",
+ "vnd.yamaha.hv-voice" : "hvp",
+ "vnd.yamaha.openscoreformat" : "osf",
+ "vnd.yamaha.openscoreformat.osfpvg+xml" : "osfpvg",
+ "vnd.yamaha.smaf-audio" : "saf",
+ "vnd.yamaha.smaf-phrase" : "spf",
+ "vnd.yellowriver-custom-menu" : "cmp",
+ "vnd.zul" : [ "zir", "zirz" ],
+ "vnd.zzazz.deck+xml" : "zaz",
+ "voicexml+xml" : "vxml",
+ "widget" : "wgt",
+ "winhlp" : "hlp",
+ "wsdl+xml" : "wsdl",
+ "wspolicy+xml" : "wspolicy",
+ "x-ace-compressed" : "ace",
+ "x-authorware-bin" : [ "aab", "x32", "u32", "vox" ],
+ "x-authorware-map" : "aam",
+ "x-authorware-seg" : "aas",
+ "x-blorb" : [ "blb", "blorb" ],
+ "x-bzip" : "bz",
+ "x-bzip2" : [ "bz2", "boz" ],
+ "x-cfs-compressed" : "cfs",
+ "x-chat" : "chat",
+ "x-conference" : "nsc",
+ "x-dgc-compressed" : "dgc",
+ "x-dtbncx+xml" : "ncx",
+ "x-dtbook+xml" : "dtb",
+ "x-dtbresource+xml" : "res",
+ "x-eva" : "eva",
+ "x-font-bdf" : "bdf",
+ "x-font-ghostscript" : "gsf",
+ "x-font-linux-psf" : "psf",
+ "x-font-otf" : "otf",
+ "x-font-pcf" : "pcf",
+ "x-font-snf" : "snf",
+ "x-font-ttf" : [ "ttf", "ttc" ],
+ "x-font-type1" : [ "pfa", "pfb", "pfm", "afm" ],
+ "x-font-woff" : "woff",
+ "x-freearc" : "arc",
+ "x-gca-compressed" : "gca",
+ "x-glulx" : "ulx",
+ "x-gramps-xml" : "gramps",
+ "x-install-instructions" : "install",
+ "x-lzh-compressed" : [ "lzh", "lha" ],
+ "x-mie" : "mie",
+ "x-mobipocket-ebook" : [ "prc", "mobi" ],
+ "x-ms-application" : "application",
+ "x-ms-shortcut" : "lnk",
+ "x-ms-xbap" : "xbap",
+ "x-msbinder" : "obd",
+ "x-mscardfile" : "crd",
+ "x-msclip" : "clp",
+ "x-msdownload" : [ "exe", "dll", "com", "bat", "msi" ],
+ "x-msmediaview" : [ "mvb", "m13", "m14" ],
+ "x-msmetafile" : [ "wmf", "wmz", "emf", "emz" ],
+ "x-msmoney" : "mny",
+ "x-mspublisher" : "pub",
+ "x-msschedule" : "scd",
+ "x-msterminal" : "trm",
+ "x-mswrite" : "wri",
+ "x-nzb" : "nzb",
+ "x-pkcs12" : [ "p12", "pfx" ],
+ "x-pkcs7-certificates" : [ "p7b", "spc" ],
+ "x-research-info-systems" : "ris",
+ "x-silverlight-app" : "xap",
+ "x-sql" : "sql",
+ "x-stuffitx" : "sitx",
+ "x-subrip" : "srt",
+ "x-t3vm-image" : "t3",
+ "x-tads" : "gam",
+ "x-tex" : "tex",
+ "x-tex-tfm" : "tfm",
+ "x-tgif" : "obj",
+ "x-xliff+xml" : "xlf",
+ "x-xz" : "xz",
+ "x-zmachine" : [ "z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8" ],
+ "xaml+xml" : "xaml",
+ "xcap-diff+xml" : "xdf",
+ "xenc+xml" : "xenc",
+ "xml-dtd" : "dtd",
+ "xop+xml" : "xop",
+ "xproc+xml" : "xpl",
+ "xslt+xml" : "xslt",
+ "xv+xml" : [ "mxml", "xhvml", "xvml", "xvm" ],
+ "yang" : "yang",
+ "yin+xml" : "yin",
+ "envoy" : "evy",
+ "fractals" : "fif",
+ "internet-property-stream" : "acx",
+ "olescript" : "axs",
+ "vnd.ms-outlook" : "msg",
+ "vnd.ms-pkicertstore" : "sst",
+ "x-compress" : "z",
+ "x-compressed" : "tgz",
+ "x-gzip" : "gz",
+ "x-perfmon" : [ "pma", "pmc", "pml", "pmr", "pmw" ],
+ "x-pkcs7-mime" : [ "p7c", "p7m" ],
+ "ynd.ms-pkipko" : "pko"
+ },
+ "audio" : {
+ "amr" : "amr",
+ "amr-wb" : "awb",
+ "annodex" : "axa",
+ "basic" : [ "au", "snd" ],
+ "flac" : "flac",
+ "midi" : [ "mid", "midi", "kar", "rmi" ],
+ "mpeg" : [ "mpga", "mpega", "mp2", "mp3", "m4a", "mp2a", "m2a", "m3a" ],
+ "mpegurl" : "m3u",
+ "ogg" : [ "oga", "ogg", "spx" ],
+ "prs.sid" : "sid",
+ "x-aiff" : [ "aif", "aiff", "aifc" ],
+ "x-gsm" : "gsm",
+ "x-ms-wma" : "wma",
+ "x-ms-wax" : "wax",
+ "x-pn-realaudio" : "ram",
+ "x-realaudio" : "ra",
+ "x-sd2" : "sd2",
+ "x-wav" : "wav",
+ "adpcm" : "adp",
+ "mp4" : "mp4a",
+ "s3m" : "s3m",
+ "silk" : "sil",
+ "vnd.dece.audio" : [ "uva", "uvva" ],
+ "vnd.digital-winds" : "eol",
+ "vnd.dra" : "dra",
+ "vnd.dts" : "dts",
+ "vnd.dts.hd" : "dtshd",
+ "vnd.lucent.voice" : "lvp",
+ "vnd.ms-playready.media.pya" : "pya",
+ "vnd.nuera.ecelp4800" : "ecelp4800",
+ "vnd.nuera.ecelp7470" : "ecelp7470",
+ "vnd.nuera.ecelp9600" : "ecelp9600",
+ "vnd.rip" : "rip",
+ "webm" : "weba",
+ "x-aac" : "aac",
+ "x-caf" : "caf",
+ "x-matroska" : "mka",
+ "x-pn-realaudio-plugin" : "rmp",
+ "xm" : "xm",
+ "mid" : [ "mid", "rmi" ]
+ },
+ "chemical" : {
+ "x-alchemy" : "alc",
+ "x-cache" : [ "cac", "cache" ],
+ "x-cache-csf" : "csf",
+ "x-cactvs-binary" : [ "cbin", "cascii", "ctab" ],
+ "x-cdx" : "cdx",
+ "x-chem3d" : "c3d",
+ "x-cif" : "cif",
+ "x-cmdf" : "cmdf",
+ "x-cml" : "cml",
+ "x-compass" : "cpa",
+ "x-crossfire" : "bsd",
+ "x-csml" : [ "csml", "csm" ],
+ "x-ctx" : "ctx",
+ "x-cxf" : [ "cxf", "cef" ],
+ "x-embl-dl-nucleotide" : [ "emb", "embl" ],
+ "x-gamess-input" : [ "inp", "gam", "gamin" ],
+ "x-gaussian-checkpoint" : [ "fch", "fchk" ],
+ "x-gaussian-cube" : "cub",
+ "x-gaussian-input" : [ "gau", "gjc", "gjf" ],
+ "x-gaussian-log" : "gal",
+ "x-gcg8-sequence" : "gcg",
+ "x-genbank" : "gen",
+ "x-hin" : "hin",
+ "x-isostar" : [ "istr", "ist" ],
+ "x-jcamp-dx" : [ "jdx", "dx" ],
+ "x-kinemage" : "kin",
+ "x-macmolecule" : "mcm",
+ "x-macromodel-input" : [ "mmd", "mmod" ],
+ "x-mdl-molfile" : "mol",
+ "x-mdl-rdfile" : "rd",
+ "x-mdl-rxnfile" : "rxn",
+ "x-mdl-sdfile" : [ "sd", "sdf" ],
+ "x-mdl-tgf" : "tgf",
+ "x-mmcif" : "mcif",
+ "x-mol2" : "mol2",
+ "x-molconn-Z" : "b",
+ "x-mopac-graph" : "gpt",
+ "x-mopac-input" : [ "mop", "mopcrt", "mpc", "zmt" ],
+ "x-mopac-out" : "moo",
+ "x-ncbi-asn1" : "asn",
+ "x-ncbi-asn1-ascii" : [ "prt", "ent" ],
+ "x-ncbi-asn1-binary" : [ "val", "aso" ],
+ "x-pdb" : [ "pdb", "ent" ],
+ "x-rosdal" : "ros",
+ "x-swissprot" : "sw",
+ "x-vamas-iso14976" : "vms",
+ "x-vmd" : "vmd",
+ "x-xtel" : "xtel",
+ "x-xyz" : "xyz"
+ },
+ "image" : {
+ "gif" : "gif",
+ "ief" : "ief",
+ "jpeg" : [ "jpeg", "jpg", "jpe" ],
+ "pcx" : "pcx",
+ "png" : "png",
+ "svg+xml" : [ "svg", "svgz" ],
+ "tiff" : [ "tiff", "tif" ],
+ "vnd.djvu" : [ "djvu", "djv" ],
+ "vnd.wap.wbmp" : "wbmp",
+ "x-canon-cr2" : "cr2",
+ "x-canon-crw" : "crw",
+ "x-cmu-raster" : "ras",
+ "x-coreldraw" : "cdr",
+ "x-coreldrawpattern" : "pat",
+ "x-coreldrawtemplate" : "cdt",
+ "x-corelphotopaint" : "cpt",
+ "x-epson-erf" : "erf",
+ "x-icon" : "ico",
+ "x-jg" : "art",
+ "x-jng" : "jng",
+ "x-nikon-nef" : "nef",
+ "x-olympus-orf" : "orf",
+ "x-photoshop" : "psd",
+ "x-portable-anymap" : "pnm",
+ "x-portable-bitmap" : "pbm",
+ "x-portable-graymap" : "pgm",
+ "x-portable-pixmap" : "ppm",
+ "x-rgb" : "rgb",
+ "x-xbitmap" : "xbm",
+ "x-xpixmap" : "xpm",
+ "x-xwindowdump" : "xwd",
+ "bmp" : "bmp",
+ "cgm" : "cgm",
+ "g3fax" : "g3",
+ "ktx" : "ktx",
+ "prs.btif" : "btif",
+ "sgi" : "sgi",
+ "vnd.dece.graphic" : [ "uvi", "uvvi", "uvg", "uvvg" ],
+ "vnd.dwg" : "dwg",
+ "vnd.dxf" : "dxf",
+ "vnd.fastbidsheet" : "fbs",
+ "vnd.fpx" : "fpx",
+ "vnd.fst" : "fst",
+ "vnd.fujixerox.edmics-mmr" : "mmr",
+ "vnd.fujixerox.edmics-rlc" : "rlc",
+ "vnd.ms-modi" : "mdi",
+ "vnd.ms-photo" : "wdp",
+ "vnd.net-fpx" : "npx",
+ "vnd.xiff" : "xif",
+ "webp" : "webp",
+ "x-3ds" : "3ds",
+ "x-cmx" : "cmx",
+ "x-freehand" : [ "fh", "fhc", "fh4", "fh5", "fh7" ],
+ "x-pict" : [ "pic", "pct" ],
+ "x-tga" : "tga",
+ "cis-cod" : "cod",
+ "pipeg" : "jfif"
+ },
+ "message" : {
+ "rfc822" : [ "eml", "mime", "mht", "mhtml", "nws" ]
+ },
+ "model" : {
+ "iges" : [ "igs", "iges" ],
+ "mesh" : [ "msh", "mesh", "silo" ],
+ "vrml" : [ "wrl", "vrml" ],
+ "x3d+vrml" : [ "x3dv", "x3dvz" ],
+ "x3d+xml" : [ "x3d", "x3dz" ],
+ "x3d+binary" : [ "x3db", "x3dbz" ],
+ "vnd.collada+xml" : "dae",
+ "vnd.dwf" : "dwf",
+ "vnd.gdl" : "gdl",
+ "vnd.gtw" : "gtw",
+ "vnd.mts" : "mts",
+ "vnd.vtu" : "vtu"
+ },
+ "text" : {
+ "cache-manifest" : [ "manifest", "appcache" ],
+ "calendar" : [ "ics", "icz", "ifb" ],
+ "css" : "css",
+ "csv" : "csv",
+ "h323" : "323",
+ "html" : [ "html", "htm", "shtml", "stm" ],
+ "iuls" : "uls",
+ "mathml" : "mml",
+ "plain" : [ "txt", "text", "brf", "conf", "def", "list", "log", "in", "bas" ],
+ "richtext" : "rtx",
+ "scriptlet" : [ "sct", "wsc" ],
+ "texmacs" : [ "tm", "ts" ],
+ "tab-separated-values" : "tsv",
+ "vnd.sun.j2me.app-descriptor" : "jad",
+ "vnd.wap.wml" : "wml",
+ "vnd.wap.wmlscript" : "wmls",
+ "x-bibtex" : "bib",
+ "x-boo" : "boo",
+ "x-c++hdr" : [ "h++", "hpp", "hxx", "hh" ],
+ "x-c++src" : [ "c++", "cpp", "cxx", "cc" ],
+ "x-component" : "htc",
+ "x-dsrc" : "d",
+ "x-diff" : [ "diff", "patch" ],
+ "x-haskell" : "hs",
+ "x-java" : "java",
+ "x-literate-haskell" : "lhs",
+ "x-moc" : "moc",
+ "x-pascal" : [ "p", "pas" ],
+ "x-pcs-gcd" : "gcd",
+ "x-perl" : [ "pl", "pm" ],
+ "x-python" : "py",
+ "x-scala" : "scala",
+ "x-setext" : "etx",
+ "x-tcl" : [ "tcl", "tk" ],
+ "x-tex" : [ "tex", "ltx", "sty", "cls" ],
+ "x-vcalendar" : "vcs",
+ "x-vcard" : "vcf",
+ "n3" : "n3",
+ "prs.lines.tag" : "dsc",
+ "sgml" : [ "sgml", "sgm" ],
+ "troff" : [ "t", "tr", "roff", "man", "me", "ms" ],
+ "turtle" : "ttl",
+ "uri-list" : [ "uri", "uris", "urls" ],
+ "vcard" : "vcard",
+ "vnd.curl" : "curl",
+ "vnd.curl.dcurl" : "dcurl",
+ "vnd.curl.scurl" : "scurl",
+ "vnd.curl.mcurl" : "mcurl",
+ "vnd.dvb.subtitle" : "sub",
+ "vnd.fly" : "fly",
+ "vnd.fmi.flexstor" : "flx",
+ "vnd.graphviz" : "gv",
+ "vnd.in3d.3dml" : "3dml",
+ "vnd.in3d.spot" : "spot",
+ "x-asm" : [ "s", "asm" ],
+ "x-c" : [ "c", "cc", "cxx", "cpp", "h", "hh", "dic" ],
+ "x-fortran" : [ "f", "for", "f77", "f90" ],
+ "x-opml" : "opml",
+ "x-nfo" : "nfo",
+ "x-sfv" : "sfv",
+ "x-uuencode" : "uu",
+ "webviewhtml" : "htt"
+ },
+ "video" : {
+ "3gpp" : "3gp",
+ "annodex" : "axv",
+ "dl" : "dl",
+ "dv" : [ "dif", "dv" ],
+ "fli" : "fli",
+ "gl" : "gl",
+ "mpeg" : [ "mpeg", "mpg", "mpe", "m1v", "m2v", "mp2", "mpa", "mpv2" ],
+ "mp4" : [ "mp4", "mp4v", "mpg4" ],
+ "quicktime" : [ "qt", "mov" ],
+ "ogg" : "ogv",
+ "vnd.mpegurl" : [ "mxu", "m4u" ],
+ "x-flv" : "flv",
+ "x-la-asf" : [ "lsf", "lsx" ],
+ "x-mng" : "mng",
+ "x-ms-asf" : [ "asf", "asx", "asr" ],
+ "x-ms-wm" : "wm",
+ "x-ms-wmv" : "wmv",
+ "x-ms-wmx" : "wmx",
+ "x-ms-wvx" : "wvx",
+ "x-msvideo" : "avi",
+ "x-sgi-movie" : "movie",
+ "x-matroska" : [ "mpv", "mkv", "mk3d", "mks" ],
+ "3gpp2" : "3g2",
+ "h261" : "h261",
+ "h263" : "h263",
+ "h264" : "h264",
+ "jpeg" : "jpgv",
+ "jpm" : [ "jpm", "jpgm" ],
+ "mj2" : [ "mj2", "mjp2" ],
+ "vnd.dece.hd" : [ "uvh", "uvvh" ],
+ "vnd.dece.mobile" : [ "uvm", "uvvm" ],
+ "vnd.dece.pd" : [ "uvp", "uvvp" ],
+ "vnd.dece.sd" : [ "uvs", "uvvs" ],
+ "vnd.dece.video" : [ "uvv", "uvvv" ],
+ "vnd.dvb.file" : "dvb",
+ "vnd.fvt" : "fvt",
+ "vnd.ms-playready.media.pyv" : "pyv",
+ "vnd.uvvu.mp4" : [ "uvu", "uvvu" ],
+ "vnd.vivo" : "viv",
+ "webm" : "webm",
+ "x-f4v" : "f4v",
+ "x-m4v" : "m4v",
+ "x-ms-vob" : "vob",
+ "x-smv" : "smv"
+ },
+ "x-conference" : {
+ "x-cooltalk" : "ice"
+ },
+ "x-world" : {
+ "x-vrml" : [ "vrm", "vrml", "wrl", "flr", "wrz", "xaf", "xof" ]
+ }
+ };
+
+ var mimeTypes = (function() {
+ var type, subtype, val, index, mimeTypes = {};
+ for (type in table) {
+ if (table.hasOwnProperty(type)) {
+ for (subtype in table[type]) {
+ if (table[type].hasOwnProperty(subtype)) {
+ val = table[type][subtype];
+ if (typeof val == "string") {
+ mimeTypes[val] = type + "/" + subtype;
+ } else {
+ for (index = 0; index < val.length; index++) {
+ mimeTypes[val[index]] = type + "/" + subtype;
+ }
+ }
+ }
+ }
+ }
+ }
+ return mimeTypes;
+ })();
+
+ zip.getMimeType = function(filename) {
+ var defaultValue = "application/octet-stream";
+ return filename && mimeTypes[filename.split(".").pop().toLowerCase()] || defaultValue;
+ };
+
+})();
diff --git a/lib/pako/codecs.js b/lib/pako/codecs.js
new file mode 100644
index 0000000..9ce80fc
--- /dev/null
+++ b/lib/pako/codecs.js
@@ -0,0 +1,64 @@
+/// wrapper for pako (https://github.com/nodeca/pako)
+
+/* globals pako */
+(function(global) {
+ "use strict";
+
+ function Codec(isDeflater, options) {
+ var newOptions = { raw: true, chunkSize: 1024 * 1024 };
+ if (options && typeof options.level === 'number')
+ newOptions.level = options.level;
+ this._backEnd = isDeflater?
+ new pako.Deflate(newOptions) :
+ new pako.Inflate(newOptions);
+ this._chunks = [];
+ this._dataLength = 0;
+ this._backEnd.onData = this._onData.bind(this);
+ }
+ Codec.prototype._onData = function _onData(chunk) {
+ this._chunks.push(chunk);
+ this._dataLength += chunk.length;
+ };
+ Codec.prototype._fetchData = function _fetchData() {
+ var be = this._backEnd;
+ if (be.err !== 0)
+ throw new Error(be.msg);
+ var chunks = this._chunks;
+ var data;
+ if (chunks.length === 1)
+ data = chunks[0];
+ else if (chunks.length > 1) {
+ data = new Uint8Array(this._dataLength);
+ for (var i = 0, n = chunks.length, off = 0; i < n; i++) {
+ var chunk = chunks[i];
+ data.set(chunk, off);
+ off += chunk.length;
+ }
+ }
+ chunks.length = 0;
+ this._dataLength = 0;
+ return data;
+ };
+ Codec.prototype.append = function append(bytes, onprogress) {
+ this._backEnd.push(bytes, false);
+ return this._fetchData();
+ };
+ Codec.prototype.flush = function flush() {
+ this._backEnd.push(new Uint8Array(0), true);
+ return this._fetchData();
+ };
+
+ function Deflater(options) {
+ Codec.call(this, true, options);
+ }
+ Deflater.prototype = Object.create(Codec.prototype);
+ function Inflater() {
+ Codec.call(this, false);
+ }
+ Inflater.prototype = Object.create(Codec.prototype);
+
+ // 'zip' may not be defined in z-worker and some tests
+ var env = global.zip || global;
+ env.Deflater = env._pako_Deflater = Deflater;
+ env.Inflater = env._pako_Inflater = Inflater;
+})(this);
\ No newline at end of file
diff --git a/lib/z-worker.js b/lib/z-worker.js
new file mode 100644
index 0000000..3e4019e
--- /dev/null
+++ b/lib/z-worker.js
@@ -0,0 +1,153 @@
+/* jshint worker:true */
+(function main(global) {
+ "use strict";
+
+ if (global.zWorkerInitialized)
+ throw new Error('z-worker.js should be run only once');
+ global.zWorkerInitialized = true;
+
+ addEventListener("message", function(event) {
+ var message = event.data, type = message.type, sn = message.sn;
+ var handler = handlers[type];
+ if (handler) {
+ try {
+ handler(message);
+ } catch (e) {
+ onError(type, sn, e);
+ }
+ }
+ //for debug
+ //postMessage({type: 'echo', originalType: type, sn: sn});
+ });
+
+ var handlers = {
+ importScripts: doImportScripts,
+ newTask: newTask,
+ append: processData,
+ flush: processData,
+ };
+
+ // deflater/inflater tasks indexed by serial numbers
+ var tasks = {};
+
+ function doImportScripts(msg) {
+ if (msg.scripts && msg.scripts.length > 0)
+ importScripts.apply(undefined, msg.scripts);
+ postMessage({type: 'importScripts'});
+ }
+
+ function newTask(msg) {
+ var CodecClass = global[msg.codecClass];
+ var sn = msg.sn;
+ if (tasks[sn])
+ throw Error('duplicated sn');
+ tasks[sn] = {
+ codec: new CodecClass(msg.options),
+ crcInput: msg.crcType === 'input',
+ crcOutput: msg.crcType === 'output',
+ crc: new Crc32(),
+ };
+ postMessage({type: 'newTask', sn: sn});
+ }
+
+ // performance may not be supported
+ var now = global.performance ? global.performance.now.bind(global.performance) : Date.now;
+
+ function processData(msg) {
+ var sn = msg.sn, type = msg.type, input = msg.data;
+ var task = tasks[sn];
+ // allow creating codec on first append
+ if (!task && msg.codecClass) {
+ newTask(msg);
+ task = tasks[sn];
+ }
+ var isAppend = type === 'append';
+ var start = now();
+ var output;
+ if (isAppend) {
+ try {
+ output = task.codec.append(input, function onprogress(loaded) {
+ postMessage({type: 'progress', sn: sn, loaded: loaded});
+ });
+ } catch (e) {
+ delete tasks[sn];
+ throw e;
+ }
+ } else {
+ delete tasks[sn];
+ output = task.codec.flush();
+ }
+ var codecTime = now() - start;
+
+ start = now();
+ if (input && task.crcInput)
+ task.crc.append(input);
+ if (output && task.crcOutput)
+ task.crc.append(output);
+ var crcTime = now() - start;
+
+ var rmsg = {type: type, sn: sn, codecTime: codecTime, crcTime: crcTime};
+ var transferables = [];
+ if (output) {
+ rmsg.data = output;
+ transferables.push(output.buffer);
+ }
+ if (!isAppend && (task.crcInput || task.crcOutput))
+ rmsg.crc = task.crc.get();
+
+ // posting a message with transferables will fail on IE10
+ try {
+ postMessage(rmsg, transferables);
+ } catch(ex) {
+ postMessage(rmsg); // retry without transferables
+ }
+ }
+
+ function onError(type, sn, e) {
+ var msg = {
+ type: type,
+ sn: sn,
+ error: formatError(e)
+ };
+ postMessage(msg);
+ }
+
+ function formatError(e) {
+ return { message: e.message, stack: e.stack };
+ }
+
+ // Crc32 code copied from file zip.js
+ function Crc32() {
+ this.crc = -1;
+ }
+ Crc32.prototype.append = function append(data) {
+ var crc = this.crc | 0, table = this.table;
+ for (var offset = 0, len = data.length | 0; offset < len; offset++)
+ crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
+ this.crc = crc;
+ };
+ Crc32.prototype.get = function get() {
+ return ~this.crc;
+ };
+ Crc32.prototype.table = (function() {
+ var i, j, t, table = []; // Uint32Array is actually slower than []
+ 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;
+ })();
+
+ // "no-op" codec
+ function NOOP() {}
+ global.NOOP = NOOP;
+ NOOP.prototype.append = function append(bytes, onprogress) {
+ return bytes;
+ };
+ NOOP.prototype.flush = function flush() {};
+})(this);
diff --git a/lib/zip-ext.js b/lib/zip-ext.js
new file mode 100644
index 0000000..0e08dae
--- /dev/null
+++ b/lib/zip-ext.js
@@ -0,0 +1,242 @@
+/*
+ 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() {
+ "use strict";
+
+ var ERR_HTTP_RANGE = "HTTP Range not supported.";
+
+ var Reader = zip.Reader;
+ var Writer = zip.Writer;
+
+ var ZipDirectoryEntry;
+
+ var appendABViewSupported;
+ try {
+ appendABViewSupported = new Blob([ new DataView(new ArrayBuffer(0)) ]).size === 0;
+ } catch (e) {
+ }
+
+ function HttpReader(url) {
+ var that = this;
+
+ function getData(callback, onerror) {
+ var request;
+ if (!that.data) {
+ request = new XMLHttpRequest();
+ request.addEventListener("load", function() {
+ if (!that.size)
+ that.size = Number(request.getResponseHeader("Content-Length"));
+ that.data = new Uint8Array(request.response);
+ callback();
+ }, false);
+ request.addEventListener("error", onerror, false);
+ request.open("GET", url);
+ request.responseType = "arraybuffer";
+ request.send();
+ } else
+ callback();
+ }
+
+ function init(callback, onerror) {
+ var request = new XMLHttpRequest();
+ request.addEventListener("load", function() {
+ that.size = Number(request.getResponseHeader("Content-Length"));
+ callback();
+ }, false);
+ request.addEventListener("error", onerror, false);
+ request.open("HEAD", url);
+ request.send();
+ }
+
+ function readUint8Array(index, length, callback, onerror) {
+ getData(function() {
+ callback(new Uint8Array(that.data.subarray(index, index + length)));
+ }, onerror);
+ }
+
+ that.size = 0;
+ that.init = init;
+ that.readUint8Array = readUint8Array;
+ }
+ HttpReader.prototype = new Reader();
+ HttpReader.prototype.constructor = HttpReader;
+
+ function HttpRangeReader(url) {
+ var that = this;
+
+ function init(callback, onerror) {
+ var request = new XMLHttpRequest();
+ request.addEventListener("load", function() {
+ that.size = Number(request.getResponseHeader("Content-Length"));
+ if (request.getResponseHeader("Accept-Ranges") == "bytes")
+ callback();
+ else
+ onerror(ERR_HTTP_RANGE);
+ }, false);
+ request.addEventListener("error", onerror, false);
+ request.open("HEAD", url);
+ request.send();
+ }
+
+ function readArrayBuffer(index, length, callback, onerror) {
+ var request = new XMLHttpRequest();
+ request.open("GET", url);
+ request.responseType = "arraybuffer";
+ request.setRequestHeader("Range", "bytes=" + index + "-" + (index + length - 1));
+ request.addEventListener("load", function() {
+ callback(request.response);
+ }, false);
+ request.addEventListener("error", onerror, false);
+ request.send();
+ }
+
+ function readUint8Array(index, length, callback, onerror) {
+ readArrayBuffer(index, length, function(arraybuffer) {
+ callback(new Uint8Array(arraybuffer));
+ }, onerror);
+ }
+
+ that.size = 0;
+ that.init = init;
+ that.readUint8Array = readUint8Array;
+ }
+ HttpRangeReader.prototype = new Reader();
+ HttpRangeReader.prototype.constructor = HttpRangeReader;
+
+ function ArrayBufferReader(arrayBuffer) {
+ var that = this;
+
+ function init(callback, onerror) {
+ that.size = arrayBuffer.byteLength;
+ callback();
+ }
+
+ function readUint8Array(index, length, callback, onerror) {
+ callback(new Uint8Array(arrayBuffer.slice(index, index + length)));
+ }
+
+ that.size = 0;
+ that.init = init;
+ that.readUint8Array = readUint8Array;
+ }
+ ArrayBufferReader.prototype = new Reader();
+ ArrayBufferReader.prototype.constructor = ArrayBufferReader;
+
+ function ArrayBufferWriter() {
+ var array, that = this;
+
+ function init(callback, onerror) {
+ array = new Uint8Array();
+ callback();
+ }
+
+ function writeUint8Array(arr, callback, onerror) {
+ var tmpArray = new Uint8Array(array.length + arr.length);
+ tmpArray.set(array);
+ tmpArray.set(arr, array.length);
+ array = tmpArray;
+ callback();
+ }
+
+ function getData(callback) {
+ callback(array.buffer);
+ }
+
+ that.init = init;
+ that.writeUint8Array = writeUint8Array;
+ that.getData = getData;
+ }
+ ArrayBufferWriter.prototype = new Writer();
+ ArrayBufferWriter.prototype.constructor = ArrayBufferWriter;
+
+ function FileWriter(fileEntry, contentType) {
+ var writer, that = this;
+
+ function init(callback, onerror) {
+ fileEntry.createWriter(function(fileWriter) {
+ writer = fileWriter;
+ callback();
+ }, onerror);
+ }
+
+ function writeUint8Array(array, callback, onerror) {
+ var blob = new Blob([ appendABViewSupported ? array : array.buffer ], {
+ type : contentType
+ });
+ writer.onwrite = function() {
+ writer.onwrite = null;
+ callback();
+ };
+ writer.onerror = onerror;
+ writer.write(blob);
+ }
+
+ function getData(callback) {
+ fileEntry.file(callback);
+ }
+
+ that.init = init;
+ that.writeUint8Array = writeUint8Array;
+ that.getData = getData;
+ }
+ FileWriter.prototype = new Writer();
+ FileWriter.prototype.constructor = FileWriter;
+
+ zip.FileWriter = FileWriter;
+ zip.HttpReader = HttpReader;
+ zip.HttpRangeReader = HttpRangeReader;
+ zip.ArrayBufferReader = ArrayBufferReader;
+ zip.ArrayBufferWriter = ArrayBufferWriter;
+
+ if (zip.fs) {
+ ZipDirectoryEntry = zip.fs.ZipDirectoryEntry;
+ ZipDirectoryEntry.prototype.addHttpContent = function(name, URL, useRangeHeader) {
+ function addChild(parent, name, params, directory) {
+ if (parent.directory)
+ return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new zip.fs.ZipFileEntry(parent.fs, name, params, parent);
+ else
+ throw "Parent entry is not a directory.";
+ }
+
+ return addChild(this, name, {
+ data : URL,
+ Reader : useRangeHeader ? HttpRangeReader : HttpReader
+ });
+ };
+ ZipDirectoryEntry.prototype.importHttpContent = function(URL, useRangeHeader, onend, onerror) {
+ this.importZip(useRangeHeader ? new HttpRangeReader(URL) : new HttpReader(URL), onend, onerror);
+ };
+ zip.fs.FS.prototype.importHttpContent = function(URL, useRangeHeader, onend, onerror) {
+ this.entries = [];
+ this.root = new ZipDirectoryEntry(this);
+ this.root.importHttpContent(URL, useRangeHeader, onend, onerror);
+ };
+ }
+
+})();
diff --git a/lib/zip-fs.js b/lib/zip-fs.js
new file mode 100644
index 0000000..20b8003
--- /dev/null
+++ b/lib/zip-fs.js
@@ -0,0 +1,541 @@
+/*
+ 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() {
+ "use strict";
+
+ var CHUNK_SIZE = 512 * 1024;
+
+ var TextWriter = zip.TextWriter, //
+ BlobWriter = zip.BlobWriter, //
+ Data64URIWriter = zip.Data64URIWriter, //
+ Reader = zip.Reader, //
+ TextReader = zip.TextReader, //
+ BlobReader = zip.BlobReader, //
+ Data64URIReader = zip.Data64URIReader, //
+ createReader = zip.createReader, //
+ createWriter = zip.createWriter;
+
+ function ZipBlobReader(entry) {
+ var that = this, blobReader;
+
+ function init(callback) {
+ that.size = entry.uncompressedSize;
+ callback();
+ }
+
+ function getData(callback) {
+ if (that.data)
+ callback();
+ else
+ entry.getData(new BlobWriter(), function(data) {
+ that.data = data;
+ blobReader = new BlobReader(data);
+ callback();
+ }, null, that.checkCrc32);
+ }
+
+ function readUint8Array(index, length, callback, onerror) {
+ getData(function() {
+ blobReader.readUint8Array(index, length, callback, onerror);
+ }, onerror);
+ }
+
+ that.size = 0;
+ that.init = init;
+ that.readUint8Array = readUint8Array;
+ }
+ ZipBlobReader.prototype = new Reader();
+ ZipBlobReader.prototype.constructor = ZipBlobReader;
+ ZipBlobReader.prototype.checkCrc32 = false;
+
+ function getTotalSize(entry) {
+ var size = 0;
+
+ function process(entry) {
+ size += entry.uncompressedSize || 0;
+ entry.children.forEach(process);
+ }
+
+ process(entry);
+ return size;
+ }
+
+ function initReaders(entry, onend, onerror) {
+ var index = 0;
+
+ function next() {
+ index++;
+ if (index < entry.children.length)
+ process(entry.children[index]);
+ else
+ onend();
+ }
+
+ function process(child) {
+ if (child.directory)
+ initReaders(child, next, onerror);
+ else {
+ child.reader = new child.Reader(child.data, onerror);
+ child.reader.init(function() {
+ child.uncompressedSize = child.reader.size;
+ next();
+ });
+ }
+ }
+
+ if (entry.children.length)
+ process(entry.children[index]);
+ else
+ onend();
+ }
+
+ function detach(entry) {
+ var children = entry.parent.children;
+ children.forEach(function(child, index) {
+ if (child.id == entry.id)
+ children.splice(index, 1);
+ });
+ }
+
+ function exportZip(zipWriter, entry, onend, onprogress, totalSize) {
+ var currentIndex = 0;
+
+ function process(zipWriter, entry, onend, onprogress, totalSize) {
+ var childIndex = 0;
+
+ function exportChild() {
+ var child = entry.children[childIndex];
+ if (child)
+ zipWriter.add(child.getFullname(), child.reader, function() {
+ currentIndex += child.uncompressedSize || 0;
+ process(zipWriter, child, function() {
+ childIndex++;
+ exportChild();
+ }, onprogress, totalSize);
+ }, function(index) {
+ if (onprogress)
+ onprogress(currentIndex + index, totalSize);
+ }, {
+ directory : child.directory,
+ version : child.zipVersion
+ });
+ else
+ onend();
+ }
+
+ exportChild();
+ }
+
+ process(zipWriter, entry, onend, onprogress, totalSize);
+ }
+
+ function addFileEntry(zipEntry, fileEntry, onend, onerror) {
+ function getChildren(fileEntry, callback) {
+ if (fileEntry.isDirectory)
+ fileEntry.createReader().readEntries(callback);
+ if (fileEntry.isFile)
+ callback([]);
+ }
+
+ function process(zipEntry, fileEntry, onend) {
+ getChildren(fileEntry, function(children) {
+ var childIndex = 0;
+
+ function addChild(child) {
+ function nextChild(childFileEntry) {
+ process(childFileEntry, child, function() {
+ childIndex++;
+ processChild();
+ });
+ }
+
+ if (child.isDirectory)
+ nextChild(zipEntry.addDirectory(child.name));
+ if (child.isFile)
+ child.file(function(file) {
+ var childZipEntry = zipEntry.addBlob(child.name, file);
+ childZipEntry.uncompressedSize = file.size;
+ nextChild(childZipEntry);
+ }, onerror);
+ }
+
+ function processChild() {
+ var child = children[childIndex];
+ if (child)
+ addChild(child);
+ else
+ onend();
+ }
+
+ processChild();
+ });
+ }
+
+ if (fileEntry.isDirectory)
+ process(zipEntry, fileEntry, onend);
+ else
+ fileEntry.file(function(file) {
+ zipEntry.addBlob(fileEntry.name, file);
+ onend();
+ }, onerror);
+ }
+
+ function getFileEntry(fileEntry, entry, onend, onprogress, onerror, totalSize, checkCrc32) {
+ var currentIndex = 0;
+
+ function process(fileEntry, entry, onend, onprogress, onerror, totalSize) {
+ var childIndex = 0;
+
+ function addChild(child) {
+ function nextChild(childFileEntry) {
+ currentIndex += child.uncompressedSize || 0;
+ process(childFileEntry, child, function() {
+ childIndex++;
+ processChild();
+ }, onprogress, onerror, totalSize);
+ }
+
+ if (child.directory)
+ fileEntry.getDirectory(child.name, {
+ create : true
+ }, nextChild, onerror);
+ else
+ fileEntry.getFile(child.name, {
+ create : true
+ }, function(file) {
+ child.getData(new zip.FileWriter(file, zip.getMimeType(child.name)), nextChild, function(index) {
+ if (onprogress)
+ onprogress(currentIndex + index, totalSize);
+ }, checkCrc32);
+ }, onerror);
+ }
+
+ function processChild() {
+ var child = entry.children[childIndex];
+ if (child)
+ addChild(child);
+ else
+ onend();
+ }
+
+ processChild();
+ }
+
+ if (entry.directory)
+ process(fileEntry, entry, onend, onprogress, onerror, totalSize);
+ else
+ entry.getData(new zip.FileWriter(fileEntry, zip.getMimeType(entry.name)), onend, onprogress, checkCrc32);
+ }
+
+ function resetFS(fs) {
+ fs.entries = [];
+ fs.root = new ZipDirectoryEntry(fs);
+ }
+
+ function bufferedCopy(reader, writer, onend, onprogress, onerror) {
+ var chunkIndex = 0;
+
+ function stepCopy() {
+ var index = chunkIndex * CHUNK_SIZE;
+ if (onprogress)
+ onprogress(index, reader.size);
+ if (index < reader.size)
+ reader.readUint8Array(index, Math.min(CHUNK_SIZE, reader.size - index), function(array) {
+ writer.writeUint8Array(new Uint8Array(array), function() {
+ chunkIndex++;
+ stepCopy();
+ });
+ }, onerror);
+ else
+ writer.getData(onend);
+ }
+
+ stepCopy();
+ }
+
+ function addChild(parent, name, params, directory) {
+ if (parent.directory)
+ return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent);
+ else
+ throw "Parent entry is not a directory.";
+ }
+
+ function ZipEntry() {
+ }
+
+ ZipEntry.prototype = {
+ init : function(fs, name, params, parent) {
+ var that = this;
+ if (fs.root && parent && parent.getChildByName(name))
+ throw "Entry filename already exists.";
+ if (!params)
+ params = {};
+ that.fs = fs;
+ that.name = name;
+ that.id = fs.entries.length;
+ that.parent = parent;
+ that.children = [];
+ that.zipVersion = params.zipVersion || 0x14;
+ that.uncompressedSize = 0;
+ fs.entries.push(that);
+ if (parent)
+ that.parent.children.push(that);
+ },
+ getFileEntry : function(fileEntry, onend, onprogress, onerror, checkCrc32) {
+ var that = this;
+ initReaders(that, function() {
+ getFileEntry(fileEntry, that, onend, onprogress, onerror, getTotalSize(that), checkCrc32);
+ }, onerror);
+ },
+ moveTo : function(target) {
+ var that = this;
+ if (target.directory) {
+ if (!target.isDescendantOf(that)) {
+ if (that != target) {
+ if (target.getChildByName(that.name))
+ throw "Entry filename already exists.";
+ detach(that);
+ that.parent = target;
+ target.children.push(that);
+ }
+ } else
+ throw "Entry is a ancestor of target entry.";
+ } else
+ throw "Target entry is not a directory.";
+ },
+ getFullname : function() {
+ var that = this, fullname = that.name, entry = that.parent;
+ while (entry) {
+ fullname = (entry.name ? entry.name + "/" : "") + fullname;
+ entry = entry.parent;
+ }
+ return fullname;
+ },
+ isDescendantOf : function(ancestor) {
+ var entry = this.parent;
+ while (entry && entry.id != ancestor.id)
+ entry = entry.parent;
+ return !!entry;
+ }
+ };
+ ZipEntry.prototype.constructor = ZipEntry;
+
+ var ZipFileEntryProto;
+
+ function ZipFileEntry(fs, name, params, parent) {
+ var that = this;
+ ZipEntry.prototype.init.call(that, fs, name, params, parent);
+ that.Reader = params.Reader;
+ that.Writer = params.Writer;
+ that.data = params.data;
+ if (params.getData) {
+ that.getData = params.getData;
+ }
+ }
+
+ ZipFileEntry.prototype = ZipFileEntryProto = new ZipEntry();
+ ZipFileEntryProto.constructor = ZipFileEntry;
+ ZipFileEntryProto.getData = function(writer, onend, onprogress, onerror) {
+ var that = this;
+ if (!writer || (writer.constructor == that.Writer && that.data))
+ onend(that.data);
+ else {
+ if (!that.reader)
+ that.reader = new that.Reader(that.data, onerror);
+ that.reader.init(function() {
+ writer.init(function() {
+ bufferedCopy(that.reader, writer, onend, onprogress, onerror);
+ }, onerror);
+ });
+ }
+ };
+
+ ZipFileEntryProto.getText = function(onend, onprogress, checkCrc32, encoding) {
+ this.getData(new TextWriter(encoding), onend, onprogress, checkCrc32);
+ };
+ ZipFileEntryProto.getBlob = function(mimeType, onend, onprogress, checkCrc32) {
+ this.getData(new BlobWriter(mimeType), onend, onprogress, checkCrc32);
+ };
+ ZipFileEntryProto.getData64URI = function(mimeType, onend, onprogress, checkCrc32) {
+ this.getData(new Data64URIWriter(mimeType), onend, onprogress, checkCrc32);
+ };
+
+ var ZipDirectoryEntryProto;
+
+ function ZipDirectoryEntry(fs, name, params, parent) {
+ var that = this;
+ ZipEntry.prototype.init.call(that, fs, name, params, parent);
+ that.directory = true;
+ }
+
+ ZipDirectoryEntry.prototype = ZipDirectoryEntryProto = new ZipEntry();
+ ZipDirectoryEntryProto.constructor = ZipDirectoryEntry;
+ ZipDirectoryEntryProto.addDirectory = function(name) {
+ return addChild(this, name, null, true);
+ };
+ ZipDirectoryEntryProto.addText = function(name, text) {
+ return addChild(this, name, {
+ data : text,
+ Reader : TextReader,
+ Writer : TextWriter
+ });
+ };
+ ZipDirectoryEntryProto.addBlob = function(name, blob) {
+ return addChild(this, name, {
+ data : blob,
+ Reader : BlobReader,
+ Writer : BlobWriter
+ });
+ };
+ ZipDirectoryEntryProto.addData64URI = function(name, dataURI) {
+ return addChild(this, name, {
+ data : dataURI,
+ Reader : Data64URIReader,
+ Writer : Data64URIWriter
+ });
+ };
+ ZipDirectoryEntryProto.addFileEntry = function(fileEntry, onend, onerror) {
+ addFileEntry(this, fileEntry, onend, onerror);
+ };
+ ZipDirectoryEntryProto.addData = function(name, params) {
+ return addChild(this, name, params);
+ };
+ ZipDirectoryEntryProto.importBlob = function(blob, onend, onerror) {
+ this.importZip(new BlobReader(blob), onend, onerror);
+ };
+ ZipDirectoryEntryProto.importText = function(text, onend, onerror) {
+ this.importZip(new TextReader(text), onend, onerror);
+ };
+ ZipDirectoryEntryProto.importData64URI = function(dataURI, onend, onerror) {
+ this.importZip(new Data64URIReader(dataURI), onend, onerror);
+ };
+ ZipDirectoryEntryProto.exportBlob = function(onend, onprogress, onerror) {
+ this.exportZip(new BlobWriter("application/zip"), onend, onprogress, onerror);
+ };
+ ZipDirectoryEntryProto.exportText = function(onend, onprogress, onerror) {
+ this.exportZip(new TextWriter(), onend, onprogress, onerror);
+ };
+ ZipDirectoryEntryProto.exportFileEntry = function(fileEntry, onend, onprogress, onerror) {
+ this.exportZip(new zip.FileWriter(fileEntry, "application/zip"), onend, onprogress, onerror);
+ };
+ ZipDirectoryEntryProto.exportData64URI = function(onend, onprogress, onerror) {
+ this.exportZip(new Data64URIWriter("application/zip"), onend, onprogress, onerror);
+ };
+ ZipDirectoryEntryProto.importZip = function(reader, onend, onerror) {
+ var that = this;
+ createReader(reader, function(zipReader) {
+ zipReader.getEntries(function(entries) {
+ entries.forEach(function(entry) {
+ var parent = that, path = entry.filename.split("/"), name = path.pop();
+ path.forEach(function(pathPart) {
+ parent = parent.getChildByName(pathPart) || new ZipDirectoryEntry(that.fs, pathPart, null, parent);
+ });
+ if (!entry.directory)
+ addChild(parent, name, {
+ data : entry,
+ Reader : ZipBlobReader
+ });
+ });
+ onend();
+ });
+ }, onerror);
+ };
+ ZipDirectoryEntryProto.exportZip = function(writer, onend, onprogress, onerror) {
+ var that = this;
+ initReaders(that, function() {
+ createWriter(writer, function(zipWriter) {
+ exportZip(zipWriter, that, function() {
+ zipWriter.close(onend);
+ }, onprogress, getTotalSize(that));
+ }, onerror);
+ }, onerror);
+ };
+ ZipDirectoryEntryProto.getChildByName = function(name) {
+ var childIndex, child, that = this;
+ for (childIndex = 0; childIndex < that.children.length; childIndex++) {
+ child = that.children[childIndex];
+ if (child.name == name)
+ return child;
+ }
+ };
+
+ function FS() {
+ resetFS(this);
+ }
+ FS.prototype = {
+ remove : function(entry) {
+ detach(entry);
+ this.entries[entry.id] = null;
+ },
+ find : function(fullname) {
+ var index, path = fullname.split("/"), node = this.root;
+ for (index = 0; node && index < path.length; index++)
+ node = node.getChildByName(path[index]);
+ return node;
+ },
+ getById : function(id) {
+ return this.entries[id];
+ },
+ importBlob : function(blob, onend, onerror) {
+ resetFS(this);
+ this.root.importBlob(blob, onend, onerror);
+ },
+ importText : function(text, onend, onerror) {
+ resetFS(this);
+ this.root.importText(text, onend, onerror);
+ },
+ importData64URI : function(dataURI, onend, onerror) {
+ resetFS(this);
+ this.root.importData64URI(dataURI, onend, onerror);
+ },
+ exportBlob : function(onend, onprogress, onerror) {
+ this.root.exportBlob(onend, onprogress, onerror);
+ },
+ exportText : function(onend, onprogress, onerror) {
+ this.root.exportText(onend, onprogress, onerror);
+ },
+ exportFileEntry : function(fileEntry, onend, onprogress, onerror) {
+ this.root.exportFileEntry(fileEntry, onend, onprogress, onerror);
+ },
+ exportData64URI : function(onend, onprogress, onerror) {
+ this.root.exportData64URI(onend, onprogress, onerror);
+ }
+ };
+
+ zip.fs = {
+ FS : FS,
+ ZipDirectoryEntry : ZipDirectoryEntry,
+ ZipFileEntry : ZipFileEntry
+ };
+
+ zip.getMimeType = function() {
+ return "application/octet-stream";
+ };
+
+})();
diff --git a/lib/zip.js b/lib/zip.js
new file mode 100644
index 0000000..4f6f67e
--- /dev/null
+++ b/lib/zip.js
@@ -0,0 +1,966 @@
+/*
+ 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) {
+ "use strict";
+
+ var ERR_BAD_FORMAT = "File format is not recognized.";
+ var ERR_CRC = "CRC failed.";
+ 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 TEXT_PLAIN = "text/plain";
+
+ var appendABViewSupported;
+ try {
+ appendABViewSupported = new Blob([ new DataView(new ArrayBuffer(0)) ]).size === 0;
+ } catch (e) {
+ }
+
+ function Crc32() {
+ this.crc = -1;
+ }
+ Crc32.prototype.append = function append(data) {
+ var crc = this.crc | 0, table = this.table;
+ for (var offset = 0, len = data.length | 0; offset < len; offset++)
+ crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
+ this.crc = crc;
+ };
+ Crc32.prototype.get = function get() {
+ return ~this.crc;
+ };
+ Crc32.prototype.table = (function() {
+ var i, j, t, table = []; // Uint32Array is actually slower than []
+ 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;
+ })();
+
+ // "no-op" codec
+ function NOOP() {}
+ NOOP.prototype.append = function append(bytes, onprogress) {
+ return bytes;
+ };
+ NOOP.prototype.flush = function flush() {};
+
+ function blobSlice(blob, index, length) {
+ if (index < 0 || length < 0 || index + length > blob.size)
+ throw new RangeError('offset:' + index + ', length:' + length + ', size:' + blob.size);
+ 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) {
+ that.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;
+ try {
+ reader.readAsArrayBuffer(blobSlice(blob, index, length));
+ } catch (e) {
+ onerror(e);
+ }
+ }
+
+ 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);
+ };
+
+ function TextWriter(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) {
+ callback(e.target.result);
+ };
+ 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;
+
+ function BlobWriter(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
+ });
+ 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
+ * @param worker {Worker} web worker for the task.
+ * @param initialMessage {Object} initial message to be sent to the worker. should contain
+ * sn(serial number for distinguishing multiple tasks sent to the worker), and codecClass.
+ * This function may add more properties before sending.
+ */
+ function launchWorkerProcess(worker, initialMessage, reader, writer, offset, size, onprogress, onend, onreaderror, onwriteerror) {
+ var chunkIndex = 0, index, outputSize, sn = initialMessage.sn, crc;
+
+ function onflush() {
+ worker.removeEventListener('message', onmessage, false);
+ onend(outputSize, crc);
+ }
+
+ function onmessage(event) {
+ var message = event.data, data = message.data, err = message.error;
+ if (err) {
+ err.toString = function () { return 'Error: ' + this.message; };
+ onreaderror(err);
+ return;
+ }
+ if (message.sn !== sn)
+ return;
+ if (typeof message.codecTime === 'number')
+ worker.codecTime += message.codecTime; // should be before onflush()
+ if (typeof message.crcTime === 'number')
+ worker.crcTime += message.crcTime;
+
+ switch (message.type) {
+ case 'append':
+ if (data) {
+ outputSize += data.length;
+ writer.writeUint8Array(data, function() {
+ step();
+ }, onwriteerror);
+ } else
+ step();
+ break;
+ case 'flush':
+ crc = message.crc;
+ if (data) {
+ outputSize += data.length;
+ writer.writeUint8Array(data, function() {
+ onflush();
+ }, onwriteerror);
+ } else
+ onflush();
+ break;
+ case 'progress':
+ if (onprogress)
+ onprogress(index + message.loaded, size);
+ break;
+ case 'importScripts': //no need to handle here
+ case 'newTask':
+ case 'echo':
+ break;
+ default:
+ console.warn('zip.js:launchWorkerProcess: unknown message: ', message);
+ }
+ }
+
+ function step() {
+ index = chunkIndex * CHUNK_SIZE;
+ // use `<=` instead of `<`, because `size` may be 0.
+ if (index <= size) {
+ reader.readUint8Array(offset + index, Math.min(CHUNK_SIZE, size - index), function(array) {
+ if (onprogress)
+ onprogress(index, size);
+ var msg = index === 0 ? initialMessage : {sn : sn};
+ msg.type = 'append';
+ msg.data = array;
+
+ // posting a message with transferables will fail on IE10
+ try {
+ worker.postMessage(msg, [array.buffer]);
+ } catch(ex) {
+ worker.postMessage(msg); // retry without transferables
+ }
+ chunkIndex++;
+ }, onreaderror);
+ } else {
+ worker.postMessage({
+ sn: sn,
+ type: 'flush'
+ });
+ }
+ }
+
+ outputSize = 0;
+ worker.addEventListener('message', onmessage, false);
+ step();
+ }
+
+ function launchProcess(process, reader, writer, offset, size, crcType, onprogress, onend, onreaderror, onwriteerror) {
+ var chunkIndex = 0, index, outputSize = 0,
+ crcInput = crcType === 'input',
+ crcOutput = crcType === 'output',
+ crc = new Crc32();
+ 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;
+ try {
+ outputData = process.append(inputData, function(loaded) {
+ if (onprogress)
+ onprogress(index + loaded, size);
+ });
+ } catch (e) {
+ onreaderror(e);
+ return;
+ }
+ if (outputData) {
+ outputSize += outputData.length;
+ writer.writeUint8Array(outputData, function() {
+ chunkIndex++;
+ setTimeout(step, 1);
+ }, onwriteerror);
+ if (crcOutput)
+ crc.append(outputData);
+ } else {
+ chunkIndex++;
+ setTimeout(step, 1);
+ }
+ if (crcInput)
+ crc.append(inputData);
+ if (onprogress)
+ onprogress(index, size);
+ }, onreaderror);
+ else {
+ try {
+ outputData = process.flush();
+ } catch (e) {
+ onreaderror(e);
+ return;
+ }
+ if (outputData) {
+ if (crcOutput)
+ crc.append(outputData);
+ outputSize += outputData.length;
+ writer.writeUint8Array(outputData, function() {
+ onend(outputSize, crc.get());
+ }, onwriteerror);
+ } else
+ onend(outputSize, crc.get());
+ }
+ }
+
+ step();
+ }
+
+ function inflate(worker, sn, reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) {
+ var crcType = computeCrc32 ? 'output' : 'none';
+ if (obj.zip.useWebWorkers) {
+ var initialMessage = {
+ sn: sn,
+ codecClass: 'Inflater',
+ crcType: crcType,
+ };
+ launchWorkerProcess(worker, initialMessage, reader, writer, offset, size, onprogress, onend, onreaderror, onwriteerror);
+ } else
+ launchProcess(new obj.zip.Inflater(), reader, writer, offset, size, crcType, onprogress, onend, onreaderror, onwriteerror);
+ }
+
+ function deflate(worker, sn, reader, writer, level, onend, onprogress, onreaderror, onwriteerror) {
+ var crcType = 'input';
+ if (obj.zip.useWebWorkers) {
+ var initialMessage = {
+ sn: sn,
+ options: {level: level},
+ codecClass: 'Deflater',
+ crcType: crcType,
+ };
+ launchWorkerProcess(worker, initialMessage, reader, writer, 0, reader.size, onprogress, onend, onreaderror, onwriteerror);
+ } else
+ launchProcess(new obj.zip.Deflater(), reader, writer, 0, reader.size, crcType, onprogress, onend, onreaderror, onwriteerror);
+ }
+
+ function copy(worker, sn, reader, writer, offset, size, computeCrc32, onend, onprogress, onreaderror, onwriteerror) {
+ var crcType = 'input';
+ if (obj.zip.useWebWorkers && computeCrc32) {
+ var initialMessage = {
+ sn: sn,
+ codecClass: 'NOOP',
+ crcType: crcType,
+ };
+ launchWorkerProcess(worker, initialMessage, reader, writer, offset, size, onprogress, onend, onreaderror, onwriteerror);
+ } else
+ launchProcess(new NOOP(), reader, writer, offset, size, crcType, onprogress, onend, onreaderror, onwriteerror);
+ }
+
+ // 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, callback, onerror) {
+ var inflateSN = 0;
+
+ function Entry() {
+ }
+
+ Entry.prototype.getData = function(writer, onend, onprogress, checkCrc32) {
+ var that = this;
+
+ 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))
+ onerror(ERR_CRC);
+ else
+ writer.getData(function(data) {
+ onend(data);
+ });
+ }
+
+ function onreaderror(err) {
+ onerror(err || ERR_READ_DATA);
+ }
+
+ function onwriteerror(err) {
+ onerror(err || 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(that._worker, inflateSN++, reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror);
+ else
+ inflate(that._worker, inflateSN++, reader, writer, dataOffset, that.compressedSize, checkCrc32, getWriterData, onprogress, onreaderror, onwriteerror);
+ }, onwriteerror);
+ }, onreaderror);
+ };
+
+ function seekEOCDR(eocdrCallback) {
+ // "End of central directory record" is the last part of a zip archive, and is at least 22 bytes long.
+ // Zip file comment is the last part of EOCDR and has max length of 64KB,
+ // so we only have to search the last 64K + 22 bytes of a archive for EOCDR signature (0x06054b50).
+ var EOCDR_MIN = 22;
+ if (reader.size < EOCDR_MIN) {
+ onerror(ERR_BAD_FORMAT);
+ return;
+ }
+ var ZIP_COMMENT_MAX = 256 * 256, EOCDR_MAX = EOCDR_MIN + ZIP_COMMENT_MAX;
+
+ // In most cases, the EOCDR is EOCDR_MIN bytes long
+ doSeek(EOCDR_MIN, function() {
+ // If not found, try within EOCDR_MAX bytes
+ doSeek(Math.min(EOCDR_MAX, reader.size), function() {
+ onerror(ERR_BAD_FORMAT);
+ });
+ });
+
+ // seek last length bytes of file for EOCDR
+ function doSeek(length, eocdrNotFoundCallback) {
+ reader.readUint8Array(reader.size - length, length, function(bytes) {
+ for (var i = bytes.length - EOCDR_MIN; i >= 0; i--) {
+ if (bytes[i] === 0x50 && bytes[i + 1] === 0x4b && bytes[i + 2] === 0x05 && bytes[i + 3] === 0x06) {
+ eocdrCallback(new DataView(bytes.buffer, i, EOCDR_MIN));
+ return;
+ }
+ }
+ eocdrNotFoundCallback();
+ }, function() {
+ onerror(ERR_READ);
+ });
+ }
+ }
+
+ var zipReader = {
+ getEntries : function(callback) {
+ var worker = this._worker;
+ // look for End of central directory record
+ seekEOCDR(function(dataView) {
+ var datalength, fileslength;
+ datalength = dataView.getUint32(16, true);
+ fileslength = dataView.getUint16(8, true);
+ if (datalength < 0 || datalength >= reader.size) {
+ onerror(ERR_BAD_FORMAT);
+ return;
+ }
+ 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();
+ entry._worker = worker;
+ 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 (this._worker) {
+ this._worker.terminate();
+ this._worker = null;
+ }
+ if (callback)
+ callback();
+ },
+ _worker: null
+ };
+
+ if (!obj.zip.useWebWorkers)
+ callback(zipReader);
+ else {
+ createWorker('inflater',
+ function(worker) {
+ zipReader._worker = worker;
+ callback(zipReader);
+ },
+ function(err) {
+ onerror(err);
+ }
+ );
+ }
+ }
+
+ // 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, callback, onerror, dontDeflate) {
+ var files = {}, filenames = [], datalength = 0;
+ var deflateSN = 0;
+
+ function onwriteerror(err) {
+ onerror(err || ERR_WRITE);
+ }
+
+ function onreaderror(err) {
+ onerror(err || ERR_READ_DATA);
+ }
+
+ var zipWriter = {
+ add : function(name, reader, onend, onprogress, options) {
+ var header, filename, date;
+ var worker = this._worker;
+
+ 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;
+ 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(worker, deflateSN++, reader, writer, 0, reader.size, true, writeFooter, onprogress, onreaderror, onwriteerror);
+ else
+ deflate(worker, deflateSN++, reader, writer, options.level, writeFooter, onprogress, onreaderror, onwriteerror);
+ else
+ writeFooter();
+ }, onwriteerror);
+ }
+
+ if (reader)
+ reader.init(writeFile, onreaderror);
+ else
+ writeFile();
+ },
+ close : function(callback) {
+ if (this._worker) {
+ this._worker.terminate();
+ this._worker = null;
+ }
+
+ 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() {
+ writer.getData(callback);
+ }, onwriteerror);
+ },
+ _worker: null
+ };
+
+ if (!obj.zip.useWebWorkers)
+ callback(zipWriter);
+ else {
+ createWorker('deflater',
+ function(worker) {
+ zipWriter._worker = worker;
+ callback(zipWriter);
+ },
+ function(err) {
+ onerror(err);
+ }
+ );
+ }
+ }
+
+ function resolveURLs(urls) {
+ var a = document.createElement('a');
+ return urls.map(function(url) {
+ a.href = url;
+ return a.href;
+ });
+ }
+
+ var DEFAULT_WORKER_SCRIPTS = {
+ deflater: ['z-worker.js', 'deflate.js'],
+ inflater: ['z-worker.js', 'inflate.js']
+ };
+ function createWorker(type, callback, onerror) {
+ if (obj.zip.workerScripts !== null && obj.zip.workerScriptsPath !== null) {
+ onerror(new Error('Either zip.workerScripts or zip.workerScriptsPath may be set, not both.'));
+ return;
+ }
+ var scripts;
+ if (obj.zip.workerScripts) {
+ scripts = obj.zip.workerScripts[type];
+ if (!Array.isArray(scripts)) {
+ onerror(new Error('zip.workerScripts.' + type + ' is not an array!'));
+ return;
+ }
+ scripts = resolveURLs(scripts);
+ } else {
+ scripts = DEFAULT_WORKER_SCRIPTS[type].slice(0);
+ scripts[0] = (obj.zip.workerScriptsPath || '') + scripts[0];
+ }
+ var worker = new Worker(scripts[0]);
+ // record total consumed time by inflater/deflater/crc32 in this worker
+ worker.codecTime = worker.crcTime = 0;
+ worker.postMessage({ type: 'importScripts', scripts: scripts.slice(1) });
+ worker.addEventListener('message', onmessage);
+ function onmessage(ev) {
+ var msg = ev.data;
+ if (msg.error) {
+ worker.terminate(); // should before onerror(), because onerror() may throw.
+ onerror(msg.error);
+ return;
+ }
+ if (msg.type === 'importScripts') {
+ worker.removeEventListener('message', onmessage);
+ worker.removeEventListener('error', errorHandler);
+ callback(worker);
+ }
+ }
+ // catch entry script loading error and other unhandled errors
+ worker.addEventListener('error', errorHandler);
+ function errorHandler(err) {
+ worker.terminate();
+ onerror(err);
+ }
+ }
+
+ function onerror_default(error) {
+ console.error(error);
+ }
+ obj.zip = {
+ Reader : Reader,
+ Writer : Writer,
+ BlobReader : BlobReader,
+ Data64URIReader : Data64URIReader,
+ TextReader : TextReader,
+ BlobWriter : BlobWriter,
+ Data64URIWriter : Data64URIWriter,
+ TextWriter : TextWriter,
+ createReader : function(reader, callback, onerror) {
+ onerror = onerror || onerror_default;
+
+ reader.init(function() {
+ createZipReader(reader, callback, onerror);
+ }, onerror);
+ },
+ createWriter : function(writer, callback, onerror, dontDeflate) {
+ onerror = onerror || onerror_default;
+ dontDeflate = !!dontDeflate;
+
+ writer.init(function() {
+ createZipWriter(writer, callback, onerror, dontDeflate);
+ }, onerror);
+ },
+ useWebWorkers : true,
+ /**
+ * Directory containing the default worker scripts (z-worker.js, deflate.js, and inflate.js), relative to current base url.
+ * E.g.: zip.workerScripts = './';
+ */
+ workerScriptsPath : null,
+ /**
+ * Advanced option to control which scripts are loaded in the Web worker. If this option is specified, then workerScriptsPath must not be set.
+ * workerScripts.deflater/workerScripts.inflater should be arrays of urls to scripts for deflater/inflater, respectively.
+ * Scripts in the array are executed in order, and the first one should be z-worker.js, which is used to start the worker.
+ * All urls are relative to current base url.
+ * E.g.:
+ * zip.workerScripts = {
+ * deflater: ['z-worker.js', 'deflate.js'],
+ * inflater: ['z-worker.js', 'inflate.js']
+ * };
+ */
+ workerScripts : null,
+ };
+
+})(this);
diff --git a/lib/zlib-asm/codecs.js b/lib/zlib-asm/codecs.js
new file mode 100644
index 0000000..a142014
--- /dev/null
+++ b/lib/zlib-asm/codecs.js
@@ -0,0 +1,49 @@
+/// wrapper for zlib-asm (https://github.com/ukyo/zlib-asm)
+
+/* globals zlib */
+(function(global) {
+ "use strict";
+
+ function Codec(isDeflater, options) {
+ this._isDeflater = isDeflater;
+ if (options && typeof options.level === 'number')
+ this.level = options.level;
+ this._inputLength = 0;
+ this._input = [];
+ }
+ Codec.prototype.append = function append(bytes, onprogress) {
+ this._inputLength += bytes.length;
+ this._input.push(bytes);
+ };
+ Codec.prototype.flush = function flush() {
+ var bytes;
+ var input = this._input;
+ if (input.length === 1)
+ bytes = input[0];
+ else {
+ bytes = new Uint8Array(this._inputLength);
+ for (var i = 0, n = input.length, off = 0; i < n; i++) {
+ var slice = input[i];
+ bytes.set(slice, off);
+ off += slice.length;
+ }
+ }
+ return this._isDeflater ?
+ zlib.rawDeflate(bytes, this.level) :
+ zlib.rawInflate(bytes);
+ };
+
+ function Deflater(options) {
+ Codec.call(this, true, options);
+ }
+ Deflater.prototype = Object.create(Codec.prototype);
+ function Inflater() {
+ Codec.call(this, false);
+ }
+ Inflater.prototype = Object.create(Codec.prototype);
+
+ // 'zip' may not be defined in z-worker and some tests
+ var env = global.zip || global;
+ env.Deflater = env._zlib_asm_Deflater = Deflater;
+ env.Inflater = env._zlib_asm_Inflater = Inflater;
+})(this);
\ No newline at end of file
diff --git a/old/index.html b/old/index.html
new file mode 100644
index 0000000..ee1aa9f
--- /dev/null
+++ b/old/index.html
@@ -0,0 +1,385 @@
+
+
+
+
+
+ 0x40
+
+
+
+
+
+
+
+
+
+ 0x00
+
+
+
+
+
stop
+
play
+
prev
+
next
+
B=0x0000
+
T=0x0000
+
Madeon - Finale
+
Megumi
+
white
+
+ 0x00
+
+
+
+
+
stop
+
play
+
prev
+
next
+
B=0x0000
+
T=0x0000
+
Madeon - Finale
+
Megumi
+
white
+