").append(a.replace(cr,"")).find(e):a)}),this},p.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){p.fn[b]=function(a){return this.on(b,a)}}),p.each(["get","post"],function(a,c){p[c]=function(a,d,e,f){return p.isFunction(d)&&(f=f||e,e=d,d=b),p.ajax({type:c,url:a,data:d,success:e,dataType:f})}}),p.extend({getScript:function(a,c){return p.get(a,b,c,"script")},getJSON:function(a,b,c){return p.get(a,b,c,"json")},ajaxSetup:function(a,b){return b?cB(a,p.ajaxSettings):(b=a,a=p.ajaxSettings),cB(a,b),a},ajaxSettings:{url:ck,isLocal:cn.test(cj[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":cx},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":p.parseJSON,"text xml":p.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:cz(cv),ajaxTransport:cz(cw),ajax:function(a,c){function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeout(h),g=b,e=i||"",x.readyState=a>0?4:0,f&&(u=cC(l,x,f));if(a>=200&&a<300||a===304)l.ifModified&&(w=x.getResponseHeader("Last-Modified"),w&&(p.lastModified[d]=w),w=x.getResponseHeader("Etag"),w&&(p.etag[d]=w)),a===304?(y="notmodified",k=!0):(k=cD(l,u),y=k.state,s=k.data,t=k.error,k=!t);else{t=y;if(!y||a)y="error",a<0&&(a=0)}x.status=a,x.statusText=(c||y)+"",k?o.resolveWith(m,[s,y,x]):o.rejectWith(m,[x,y,t]),x.statusCode(r),r=b,j&&n.trigger("ajax"+(k?"Success":"Error"),[x,l,k?s:t]),q.fireWith(m,[x,y]),j&&(n.trigger("ajaxComplete",[x,l]),--p.active||p.event.trigger("ajaxStop"))}typeof a=="object"&&(c=a,a=b),c=c||{};var d,e,f,g,h,i,j,k,l=p.ajaxSetup({},c),m=l.context||l,n=m!==l&&(m.nodeType||m instanceof p)?p(m):p.event,o=p.Deferred(),q=p.Callbacks("once memory"),r=l.statusCode||{},t={},u={},v=0,w="canceled",x={readyState:0,setRequestHeader:function(a,b){if(!v){var c=a.toLowerCase();a=u[c]=u[c]||a,t[a]=b}return this},getAllResponseHeaders:function(){return v===2?e:null},getResponseHeader:function(a){var c;if(v===2){if(!f){f={};while(c=cm.exec(e))f[c[1].toLowerCase()]=c[2]}c=f[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){return v||(l.mimeType=a),this},abort:function(a){return a=a||w,g&&g.abort(a),y(0,a),this}};o.promise(x),x.success=x.done,x.error=x.fail,x.complete=q.add,x.statusCode=function(a){if(a){var b;if(v<2)for(b in a)r[b]=[r[b],a[b]];else b=a[x.status],x.always(b)}return this},l.url=((a||l.url)+"").replace(cl,"").replace(cp,cj[1]+"//"),l.dataTypes=p.trim(l.dataType||"*").toLowerCase().split(s),l.crossDomain==null&&(i=ct.exec(l.url.toLowerCase())||!1,l.crossDomain=i&&i.join(":")+(i[3]?"":i[1]==="http:"?80:443)!==cj.join(":")+(cj[3]?"":cj[1]==="http:"?80:443)),l.data&&l.processData&&typeof l.data!="string"&&(l.data=p.param(l.data,l.traditional)),cA(cv,l,c,x);if(v===2)return x;j=l.global,l.type=l.type.toUpperCase(),l.hasContent=!co.test(l.type),j&&p.active++===0&&p.event.trigger("ajaxStart");if(!l.hasContent){l.data&&(l.url+=(cq.test(l.url)?"&":"?")+l.data,delete l.data),d=l.url;if(l.cache===!1){var z=p.now(),A=l.url.replace(cs,"$1_="+z);l.url=A+(A===l.url?(cq.test(l.url)?"&":"?")+"_="+z:"")}}(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&x.setRequestHeader("Content-Type",l.contentType),l.ifModified&&(d=d||l.url,p.lastModified[d]&&x.setRequestHeader("If-Modified-Since",p.lastModified[d]),p.etag[d]&&x.setRequestHeader("If-None-Match",p.etag[d])),x.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+(l.dataTypes[0]!=="*"?", "+cx+"; q=0.01":""):l.accepts["*"]);for(k in l.headers)x.setRequestHeader(k,l.headers[k]);if(!l.beforeSend||l.beforeSend.call(m,x,l)!==!1&&v!==2){w="abort";for(k in{success:1,error:1,complete:1})x[k](l[k]);g=cA(cw,l,c,x);if(!g)y(-1,"No Transport");else{x.readyState=1,j&&n.trigger("ajaxSend",[x,l]),l.async&&l.timeout>0&&(h=setTimeout(function(){x.abort("timeout")},l.timeout));try{v=1,g.send(t,y)}catch(B){if(v<2)y(-1,B);else throw B}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var cE=[],cF=/\?/,cG=/(=)\?(?=&|$)|\?\?/,cH=p.now();p.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=cE.pop()||p.expando+"_"+cH++;return this[a]=!0,a}}),p.ajaxPrefilter("json jsonp",function(c,d,e){var f,g,h,i=c.data,j=c.url,k=c.jsonp!==!1,l=k&&cG.test(j),m=k&&!l&&typeof i=="string"&&!(c.contentType||"").indexOf("application/x-www-form-urlencoded")&&cG.test(i);if(c.dataTypes[0]==="jsonp"||l||m)return f=c.jsonpCallback=p.isFunction(c.jsonpCallback)?c.jsonpCallback():c.jsonpCallback,g=a[f],l?c.url=j.replace(cG,"$1"+f):m?c.data=i.replace(cG,"$1"+f):k&&(c.url+=(cF.test(j)?"&":"?")+c.jsonp+"="+f),c.converters["script json"]=function(){return h||p.error(f+" was not called"),h[0]},c.dataTypes[0]="json",a[f]=function(){h=arguments},e.always(function(){a[f]=g,c[f]&&(c.jsonpCallback=d.jsonpCallback,cE.push(f)),h&&p.isFunction(g)&&g(h[0]),h=g=b}),"script"}),p.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){return p.globalEval(a),a}}}),p.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),p.ajaxTransport("script",function(a){if(a.crossDomain){var c,d=e.head||e.getElementsByTagName("head")[0]||e.documentElement;return{send:function(f,g){c=e.createElement("script"),c.async="async",a.scriptCharset&&(c.charset=a.scriptCharset),c.src=a.url,c.onload=c.onreadystatechange=function(a,e){if(e||!c.readyState||/loaded|complete/.test(c.readyState))c.onload=c.onreadystatechange=null,d&&c.parentNode&&d.removeChild(c),c=b,e||g(200,"success")},d.insertBefore(c,d.firstChild)},abort:function(){c&&c.onload(0,1)}}}});var cI,cJ=a.ActiveXObject?function(){for(var a in cI)cI[a](0,1)}:!1,cK=0;p.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&cL()||cM()}:cL,function(a){p.extend(p.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(p.ajaxSettings.xhr()),p.support.ajax&&p.ajaxTransport(function(c){if(!c.crossDomain||p.support.cors){var d;return{send:function(e,f){var g,h,i=c.xhr();c.username?i.open(c.type,c.url,c.async,c.username,c.password):i.open(c.type,c.url,c.async);if(c.xhrFields)for(h in c.xhrFields)i[h]=c.xhrFields[h];c.mimeType&&i.overrideMimeType&&i.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(h in e)i.setRequestHeader(h,e[h])}catch(j){}i.send(c.hasContent&&c.data||null),d=function(a,e){var h,j,k,l,m;try{if(d&&(e||i.readyState===4)){d=b,g&&(i.onreadystatechange=p.noop,cJ&&delete cI[g]);if(e)i.readyState!==4&&i.abort();else{h=i.status,k=i.getAllResponseHeaders(),l={},m=i.responseXML,m&&m.documentElement&&(l.xml=m);try{l.text=i.responseText}catch(a){}try{j=i.statusText}catch(n){j=""}!h&&c.isLocal&&!c.crossDomain?h=l.text?200:404:h===1223&&(h=204)}}}catch(o){e||f(-1,o)}l&&f(h,j,l,k)},c.async?i.readyState===4?setTimeout(d,0):(g=++cK,cJ&&(cI||(cI={},p(a).unload(cJ)),cI[g]=d),i.onreadystatechange=d):d()},abort:function(){d&&d(0,1)}}}});var cN,cO,cP=/^(?:toggle|show|hide)$/,cQ=new RegExp("^(?:([-+])=|)("+q+")([a-z%]*)$","i"),cR=/queueHooks$/,cS=[cY],cT={"*":[function(a,b){var c,d,e=this.createTween(a,b),f=cQ.exec(b),g=e.cur(),h=+g||0,i=1,j=20;if(f){c=+f[2],d=f[3]||(p.cssNumber[a]?"":"px");if(d!=="px"&&h){h=p.css(e.elem,a,!0)||c||1;do i=i||".5",h=h/i,p.style(e.elem,a,h+d);while(i!==(i=e.cur()/g)&&i!==1&&--j)}e.unit=d,e.start=h,e.end=f[1]?h+(f[1]+1)*c:c}return e}]};p.Animation=p.extend(cW,{tweener:function(a,b){p.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");var c,d=0,e=a.length;for(;d
-1,j={},k={},l,m;i?(k=e.position(),l=k.top,m=k.left):(l=parseFloat(g)||0,m=parseFloat(h)||0),p.isFunction(b)&&(b=b.call(a,c,f)),b.top!=null&&(j.top=b.top-f.top+l),b.left!=null&&(j.left=b.left-f.left+m),"using"in b?b.using.call(a,j):e.css(j)}},p.fn.extend({position:function(){if(!this[0])return;var a=this[0],b=this.offsetParent(),c=this.offset(),d=c_.test(b[0].nodeName)?{top:0,left:0}:b.offset();return c.top-=parseFloat(p.css(a,"marginTop"))||0,c.left-=parseFloat(p.css(a,"marginLeft"))||0,d.top+=parseFloat(p.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(p.css(b[0],"borderLeftWidth"))||0,{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||e.body;while(a&&!c_.test(a.nodeName)&&p.css(a,"position")==="static")a=a.offsetParent;return a||e.body})}}),p.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);p.fn[a]=function(e){return p.access(this,function(a,e,f){var g=da(a);if(f===b)return g?c in g?g[c]:g.document.documentElement[e]:a[e];g?g.scrollTo(d?p(g).scrollLeft():f,d?f:p(g).scrollTop()):a[e]=f},a,e,arguments.length,null)}}),p.each({Height:"height",Width:"width"},function(a,c){p.each({padding:"inner"+a,content:c,"":"outer"+a},function(d,e){p.fn[e]=function(e,f){var g=arguments.length&&(d||typeof e!="boolean"),h=d||(e===!0||f===!0?"margin":"border");return p.access(this,function(c,d,e){var f;return p.isWindow(c)?c.document.documentElement["client"+a]:c.nodeType===9?(f=c.documentElement,Math.max(c.body["scroll"+a],f["scroll"+a],c.body["offset"+a],f["offset"+a],f["client"+a])):e===b?p.css(c,d,e,h):p.style(c,d,e,h)},c,g?e:b,g,null)}})}),a.jQuery=a.$=p,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return p})})(window);
\ No newline at end of file
diff --git a/gh-pages/js/libs/jszip-deflate.js b/gh-pages/js/libs/jszip-deflate.js
new file mode 100644
index 0000000..bb1891a
--- /dev/null
+++ b/gh-pages/js/libs/jszip-deflate.js
@@ -0,0 +1,1695 @@
+/*
+ * Port of a script by Masanao Izumo.
+ *
+ * Only changes : wrap all the variables in a function and add the
+ * main function to JSZip (DEFLATE compression method).
+ * Everything else was written by M. Izumo.
+ *
+ * Original code can be found here: http://www.onicos.com/staff/iz/amuse/javascript/expert/deflate.txt
+ */
+
+if(!JSZip)
+{
+ throw "JSZip not defined";
+}
+
+/*
+ * Original:
+ * http://www.onicos.com/staff/iz/amuse/javascript/expert/deflate.txt
+ */
+
+(function(){
+
+/* Copyright (C) 1999 Masanao Izumo
+ * Version: 1.0.1
+ * LastModified: Dec 25 1999
+ */
+
+/* Interface:
+ * data = zip_deflate(src);
+ */
+
+/* constant parameters */
+var zip_WSIZE = 32768; // Sliding Window size
+var zip_STORED_BLOCK = 0;
+var zip_STATIC_TREES = 1;
+var zip_DYN_TREES = 2;
+
+/* for deflate */
+var zip_DEFAULT_LEVEL = 6;
+var zip_FULL_SEARCH = true;
+var zip_INBUFSIZ = 32768; // Input buffer size
+var zip_INBUF_EXTRA = 64; // Extra buffer
+var zip_OUTBUFSIZ = 1024 * 8;
+var zip_window_size = 2 * zip_WSIZE;
+var zip_MIN_MATCH = 3;
+var zip_MAX_MATCH = 258;
+var zip_BITS = 16;
+// for SMALL_MEM
+var zip_LIT_BUFSIZE = 0x2000;
+var zip_HASH_BITS = 13;
+// for MEDIUM_MEM
+// var zip_LIT_BUFSIZE = 0x4000;
+// var zip_HASH_BITS = 14;
+// for BIG_MEM
+// var zip_LIT_BUFSIZE = 0x8000;
+// var zip_HASH_BITS = 15;
+if(zip_LIT_BUFSIZE > zip_INBUFSIZ)
+ alert("error: zip_INBUFSIZ is too small");
+if((zip_WSIZE<<1) > (1< zip_BITS-1)
+ alert("error: zip_HASH_BITS is too large");
+if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258)
+ alert("error: Code too clever");
+var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE;
+var zip_HASH_SIZE = 1 << zip_HASH_BITS;
+var zip_HASH_MASK = zip_HASH_SIZE - 1;
+var zip_WMASK = zip_WSIZE - 1;
+var zip_NIL = 0; // Tail of hash chains
+var zip_TOO_FAR = 4096;
+var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1;
+var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD;
+var zip_SMALLEST = 1;
+var zip_MAX_BITS = 15;
+var zip_MAX_BL_BITS = 7;
+var zip_LENGTH_CODES = 29;
+var zip_LITERALS =256;
+var zip_END_BLOCK = 256;
+var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES;
+var zip_D_CODES = 30;
+var zip_BL_CODES = 19;
+var zip_REP_3_6 = 16;
+var zip_REPZ_3_10 = 17;
+var zip_REPZ_11_138 = 18;
+var zip_HEAP_SIZE = 2 * zip_L_CODES + 1;
+var zip_H_SHIFT = parseInt((zip_HASH_BITS + zip_MIN_MATCH - 1) /
+ zip_MIN_MATCH);
+
+/* variables */
+var zip_free_queue;
+var zip_qhead, zip_qtail;
+var zip_initflag;
+var zip_outbuf = null;
+var zip_outcnt, zip_outoff;
+var zip_complete;
+var zip_window;
+var zip_d_buf;
+var zip_l_buf;
+var zip_prev;
+var zip_bi_buf;
+var zip_bi_valid;
+var zip_block_start;
+var zip_ins_h;
+var zip_hash_head;
+var zip_prev_match;
+var zip_match_available;
+var zip_match_length;
+var zip_prev_length;
+var zip_strstart;
+var zip_match_start;
+var zip_eofile;
+var zip_lookahead;
+var zip_max_chain_length;
+var zip_max_lazy_match;
+var zip_compr_level;
+var zip_good_match;
+var zip_nice_match;
+var zip_dyn_ltree;
+var zip_dyn_dtree;
+var zip_static_ltree;
+var zip_static_dtree;
+var zip_bl_tree;
+var zip_l_desc;
+var zip_d_desc;
+var zip_bl_desc;
+var zip_bl_count;
+var zip_heap;
+var zip_heap_len;
+var zip_heap_max;
+var zip_depth;
+var zip_length_code;
+var zip_dist_code;
+var zip_base_length;
+var zip_base_dist;
+var zip_flag_buf;
+var zip_last_lit;
+var zip_last_dist;
+var zip_last_flags;
+var zip_flags;
+var zip_flag_bit;
+var zip_opt_len;
+var zip_static_len;
+var zip_deflate_data;
+var zip_deflate_pos;
+
+/* objects (deflate) */
+
+var zip_DeflateCT = function() {
+ this.fc = 0; // frequency count or bit string
+ this.dl = 0; // father node in Huffman tree or length of bit string
+}
+
+var zip_DeflateTreeDesc = function() {
+ this.dyn_tree = null; // the dynamic tree
+ this.static_tree = null; // corresponding static tree or NULL
+ this.extra_bits = null; // extra bits for each code or NULL
+ this.extra_base = 0; // base index for extra_bits
+ this.elems = 0; // max number of elements in the tree
+ this.max_length = 0; // max bit length for the codes
+ this.max_code = 0; // largest code with non zero frequency
+}
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+var zip_DeflateConfiguration = function(a, b, c, d) {
+ this.good_length = a; // reduce lazy search above this match length
+ this.max_lazy = b; // do not perform lazy search above this match length
+ this.nice_length = c; // quit search above this match length
+ this.max_chain = d;
+}
+
+var zip_DeflateBuffer = function() {
+ this.next = null;
+ this.len = 0;
+ this.ptr = new Array(zip_OUTBUFSIZ);
+ this.off = 0;
+}
+
+/* constant tables */
+var zip_extra_lbits = new Array(
+ 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);
+var zip_extra_dbits = new Array(
+ 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);
+var zip_extra_blbits = new Array(
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7);
+var zip_bl_order = new Array(
+ 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15);
+var zip_configuration_table = new Array(
+ new zip_DeflateConfiguration(0, 0, 0, 0),
+ new zip_DeflateConfiguration(4, 4, 8, 4),
+ new zip_DeflateConfiguration(4, 5, 16, 8),
+ new zip_DeflateConfiguration(4, 6, 32, 32),
+ new zip_DeflateConfiguration(4, 4, 16, 16),
+ new zip_DeflateConfiguration(8, 16, 32, 32),
+ new zip_DeflateConfiguration(8, 16, 128, 128),
+ new zip_DeflateConfiguration(8, 32, 128, 256),
+ new zip_DeflateConfiguration(32, 128, 258, 1024),
+ new zip_DeflateConfiguration(32, 258, 258, 4096));
+
+
+/* routines (deflate) */
+
+var zip_deflate_start = function(level) {
+ var i;
+
+ if(!level)
+ level = zip_DEFAULT_LEVEL;
+ else if(level < 1)
+ level = 1;
+ else if(level > 9)
+ level = 9;
+
+ zip_compr_level = level;
+ zip_initflag = false;
+ zip_eofile = false;
+ if(zip_outbuf != null)
+ return;
+
+ zip_free_queue = zip_qhead = zip_qtail = null;
+ zip_outbuf = new Array(zip_OUTBUFSIZ);
+ zip_window = new Array(zip_window_size);
+ zip_d_buf = new Array(zip_DIST_BUFSIZE);
+ zip_l_buf = new Array(zip_INBUFSIZ + zip_INBUF_EXTRA);
+ zip_prev = new Array(1 << zip_BITS);
+ zip_dyn_ltree = new Array(zip_HEAP_SIZE);
+ for(i = 0; i < zip_HEAP_SIZE; i++)
+ zip_dyn_ltree[i] = new zip_DeflateCT();
+ zip_dyn_dtree = new Array(2*zip_D_CODES+1);
+ for(i = 0; i < 2*zip_D_CODES+1; i++)
+ zip_dyn_dtree[i] = new zip_DeflateCT();
+ zip_static_ltree = new Array(zip_L_CODES+2);
+ for(i = 0; i < zip_L_CODES+2; i++)
+ zip_static_ltree[i] = new zip_DeflateCT();
+ zip_static_dtree = new Array(zip_D_CODES);
+ for(i = 0; i < zip_D_CODES; i++)
+ zip_static_dtree[i] = new zip_DeflateCT();
+ zip_bl_tree = new Array(2*zip_BL_CODES+1);
+ for(i = 0; i < 2*zip_BL_CODES+1; i++)
+ zip_bl_tree[i] = new zip_DeflateCT();
+ zip_l_desc = new zip_DeflateTreeDesc();
+ zip_d_desc = new zip_DeflateTreeDesc();
+ zip_bl_desc = new zip_DeflateTreeDesc();
+ zip_bl_count = new Array(zip_MAX_BITS+1);
+ zip_heap = new Array(2*zip_L_CODES+1);
+ zip_depth = new Array(2*zip_L_CODES+1);
+ zip_length_code = new Array(zip_MAX_MATCH-zip_MIN_MATCH+1);
+ zip_dist_code = new Array(512);
+ zip_base_length = new Array(zip_LENGTH_CODES);
+ zip_base_dist = new Array(zip_D_CODES);
+ zip_flag_buf = new Array(parseInt(zip_LIT_BUFSIZE / 8));
+}
+
+var zip_deflate_end = function() {
+ zip_free_queue = zip_qhead = zip_qtail = null;
+ zip_outbuf = null;
+ zip_window = null;
+ zip_d_buf = null;
+ zip_l_buf = null;
+ zip_prev = null;
+ zip_dyn_ltree = null;
+ zip_dyn_dtree = null;
+ zip_static_ltree = null;
+ zip_static_dtree = null;
+ zip_bl_tree = null;
+ zip_l_desc = null;
+ zip_d_desc = null;
+ zip_bl_desc = null;
+ zip_bl_count = null;
+ zip_heap = null;
+ zip_depth = null;
+ zip_length_code = null;
+ zip_dist_code = null;
+ zip_base_length = null;
+ zip_base_dist = null;
+ zip_flag_buf = null;
+}
+
+var zip_reuse_queue = function(p) {
+ p.next = zip_free_queue;
+ zip_free_queue = p;
+}
+
+var zip_new_queue = function() {
+ var p;
+
+ if(zip_free_queue != null)
+ {
+ p = zip_free_queue;
+ zip_free_queue = zip_free_queue.next;
+ }
+ else
+ p = new zip_DeflateBuffer();
+ p.next = null;
+ p.len = p.off = 0;
+
+ return p;
+}
+
+var zip_head1 = function(i) {
+ return zip_prev[zip_WSIZE + i];
+}
+
+var zip_head2 = function(i, val) {
+ return zip_prev[zip_WSIZE + i] = val;
+}
+
+/* put_byte is used for the compressed output, put_ubyte for the
+ * uncompressed output. However unlzw() uses window for its
+ * suffix table instead of its output buffer, so it does not use put_ubyte
+ * (to be cleaned up).
+ */
+var zip_put_byte = function(c) {
+ zip_outbuf[zip_outoff + zip_outcnt++] = c;
+ if(zip_outoff + zip_outcnt == zip_OUTBUFSIZ)
+ zip_qoutbuf();
+}
+
+/* Output a 16 bit value, lsb first */
+var zip_put_short = function(w) {
+ w &= 0xffff;
+ if(zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) {
+ zip_outbuf[zip_outoff + zip_outcnt++] = (w & 0xff);
+ zip_outbuf[zip_outoff + zip_outcnt++] = (w >>> 8);
+ } else {
+ zip_put_byte(w & 0xff);
+ zip_put_byte(w >>> 8);
+ }
+}
+
+/* ==========================================================================
+ * Insert string s in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * IN assertion: all calls to to INSERT_STRING are made with consecutive
+ * input characters and the first MIN_MATCH bytes of s are valid
+ * (except for the last MIN_MATCH-1 bytes of the input file).
+ */
+var zip_INSERT_STRING = function() {
+ zip_ins_h = ((zip_ins_h << zip_H_SHIFT)
+ ^ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff))
+ & zip_HASH_MASK;
+ zip_hash_head = zip_head1(zip_ins_h);
+ zip_prev[zip_strstart & zip_WMASK] = zip_hash_head;
+ zip_head2(zip_ins_h, zip_strstart);
+}
+
+/* Send a code of the given tree. c and tree must not have side effects */
+var zip_SEND_CODE = function(c, tree) {
+ zip_send_bits(tree[c].fc, tree[c].dl);
+}
+
+/* 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.
+ */
+var zip_D_CODE = function(dist) {
+ return (dist < 256 ? zip_dist_code[dist]
+ : zip_dist_code[256 + (dist>>7)]) & 0xff;
+}
+
+/* ==========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+var zip_SMALLER = function(tree, n, m) {
+ return tree[n].fc < tree[m].fc ||
+ (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m]);
+}
+
+/* ==========================================================================
+ * read string data
+ */
+var zip_read_buff = function(buff, offset, n) {
+ var i;
+ for(i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++)
+ buff[offset + i] =
+ zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff;
+ return i;
+}
+
+/* ==========================================================================
+ * Initialize the "longest match" routines for a new file
+ */
+var zip_lm_init = function() {
+ var j;
+
+ /* Initialize the hash table. */
+ for(j = 0; j < zip_HASH_SIZE; j++)
+// zip_head2(j, zip_NIL);
+ zip_prev[zip_WSIZE + j] = 0;
+ /* prev will be initialized on the fly */
+
+ /* Set the default configuration parameters:
+ */
+ zip_max_lazy_match = zip_configuration_table[zip_compr_level].max_lazy;
+ zip_good_match = zip_configuration_table[zip_compr_level].good_length;
+ if(!zip_FULL_SEARCH)
+ zip_nice_match = zip_configuration_table[zip_compr_level].nice_length;
+ zip_max_chain_length = zip_configuration_table[zip_compr_level].max_chain;
+
+ zip_strstart = 0;
+ zip_block_start = 0;
+
+ zip_lookahead = zip_read_buff(zip_window, 0, 2 * zip_WSIZE);
+ if(zip_lookahead <= 0) {
+ zip_eofile = true;
+ zip_lookahead = 0;
+ return;
+ }
+ zip_eofile = false;
+ /* Make sure that we always have enough lookahead. This is important
+ * if input comes from a device such as a tty.
+ */
+ while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
+ zip_fill_window();
+
+ /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
+ * not important since only literal bytes will be emitted.
+ */
+ zip_ins_h = 0;
+ for(j = 0; j < zip_MIN_MATCH - 1; j++) {
+// UPDATE_HASH(ins_h, window[j]);
+ zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK;
+ }
+}
+
+/* ==========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ */
+var zip_longest_match = function(cur_match) {
+ var chain_length = zip_max_chain_length; // max hash chain length
+ var scanp = zip_strstart; // current string
+ var matchp; // matched string
+ var len; // length of current match
+ var best_len = zip_prev_length; // best match length so far
+
+ /* Stop when cur_match becomes <= limit. To simplify the code,
+ * we prevent matches with the string of window index 0.
+ */
+ var limit = (zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL);
+
+ var strendp = zip_strstart + zip_MAX_MATCH;
+ var scan_end1 = zip_window[scanp + best_len - 1];
+ var scan_end = zip_window[scanp + best_len];
+
+ /* Do not waste too much time if we already have a good match: */
+ if(zip_prev_length >= zip_good_match)
+ chain_length >>= 2;
+
+// Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");
+
+ do {
+// Assert(cur_match < encoder->strstart, "no future");
+ matchp = cur_match;
+
+ /* Skip to next match if the match length cannot increase
+ * or if the match length is less than 2:
+ */
+ if(zip_window[matchp + best_len] != scan_end ||
+ zip_window[matchp + best_len - 1] != scan_end1 ||
+ zip_window[matchp] != zip_window[scanp] ||
+ zip_window[++matchp] != zip_window[scanp + 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.
+ */
+ scanp += 2;
+ matchp++;
+
+ /* We check for insufficient lookahead only every 8th comparison;
+ * the 256th check will be made at strstart+258.
+ */
+ do {
+ } while(zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ zip_window[++scanp] == zip_window[++matchp] &&
+ scanp < strendp);
+
+ len = zip_MAX_MATCH - (strendp - scanp);
+ scanp = strendp - zip_MAX_MATCH;
+
+ if(len > best_len) {
+ zip_match_start = cur_match;
+ best_len = len;
+ if(zip_FULL_SEARCH) {
+ if(len >= zip_MAX_MATCH) break;
+ } else {
+ if(len >= zip_nice_match) break;
+ }
+
+ scan_end1 = zip_window[scanp + best_len-1];
+ scan_end = zip_window[scanp + best_len];
+ }
+ } while((cur_match = zip_prev[cur_match & zip_WMASK]) > limit
+ && --chain_length != 0);
+
+ return best_len;
+}
+
+/* ==========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead, and sets eofile if end of input file.
+ * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
+ * OUT assertions: at least one byte has been read, or eofile is set;
+ * file reads are performed for at least two bytes (required for the
+ * translate_eol option).
+ */
+var zip_fill_window = function() {
+ var n, m;
+
+ // Amount of free space at the end of the window.
+ var more = zip_window_size - zip_lookahead - zip_strstart;
+
+ /* 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.
+ */
+ if(more == -1) {
+ /* Very unlikely, but possible on 16 bit machine if strstart == 0
+ * and lookahead == 1 (input done one byte at time)
+ */
+ more--;
+ } else if(zip_strstart >= zip_WSIZE + zip_MAX_DIST) {
+ /* By the IN assertion, the window is not empty so we can't confuse
+ * more == 0 with more == 64K on a 16 bit machine.
+ */
+// Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");
+
+// System.arraycopy(window, WSIZE, window, 0, WSIZE);
+ for(n = 0; n < zip_WSIZE; n++)
+ zip_window[n] = zip_window[n + zip_WSIZE];
+
+ zip_match_start -= zip_WSIZE;
+ zip_strstart -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */
+ zip_block_start -= zip_WSIZE;
+
+ for(n = 0; n < zip_HASH_SIZE; n++) {
+ m = zip_head1(n);
+ zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
+ }
+ for(n = 0; n < zip_WSIZE; n++) {
+ /* If n is not on any hash chain, prev[n] is garbage but
+ * its value will never be used.
+ */
+ m = zip_prev[n];
+ zip_prev[n] = (m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
+ }
+ more += zip_WSIZE;
+ }
+ // At this point, more >= 2
+ if(!zip_eofile) {
+ n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more);
+ if(n <= 0)
+ zip_eofile = true;
+ else
+ zip_lookahead += n;
+ }
+}
+
+/* ==========================================================================
+ * Processes a new input file and return its compressed length. This
+ * function does not perform lazy evaluationof 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.
+ */
+var zip_deflate_fast = function() {
+ while(zip_lookahead != 0 && zip_qhead == null) {
+ var flush; // set if current block must be flushed
+
+ /* Insert the string window[strstart .. strstart+2] in the
+ * dictionary, and set hash_head to the head of the hash chain:
+ */
+ zip_INSERT_STRING();
+
+ /* Find the longest match, discarding those <= prev_length.
+ * At this point we have always match_length < MIN_MATCH
+ */
+ if(zip_hash_head != zip_NIL &&
+ zip_strstart - zip_hash_head <= zip_MAX_DIST) {
+ /* 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).
+ */
+ zip_match_length = zip_longest_match(zip_hash_head);
+ /* longest_match() sets match_start */
+ if(zip_match_length > zip_lookahead)
+ zip_match_length = zip_lookahead;
+ }
+ if(zip_match_length >= zip_MIN_MATCH) {
+// check_match(strstart, match_start, match_length);
+
+ flush = zip_ct_tally(zip_strstart - zip_match_start,
+ zip_match_length - zip_MIN_MATCH);
+ zip_lookahead -= zip_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(zip_match_length <= zip_max_lazy_match) {
+ zip_match_length--; // string at strstart already in hash table
+ do {
+ zip_strstart++;
+ zip_INSERT_STRING();
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
+ * these bytes are garbage, but it does not matter since
+ * the next lookahead bytes will be emitted as literals.
+ */
+ } while(--zip_match_length != 0);
+ zip_strstart++;
+ } else {
+ zip_strstart += zip_match_length;
+ zip_match_length = 0;
+ zip_ins_h = zip_window[zip_strstart] & 0xff;
+// UPDATE_HASH(ins_h, window[strstart + 1]);
+ zip_ins_h = ((zip_ins_h< zip_lookahead)
+ zip_match_length = zip_lookahead;
+
+ /* Ignore a length 3 match if it is too distant: */
+ if(zip_match_length == zip_MIN_MATCH &&
+ zip_strstart - zip_match_start > zip_TOO_FAR) {
+ /* If prev_match is also MIN_MATCH, match_start is garbage
+ * but we will ignore the current match anyway.
+ */
+ zip_match_length--;
+ }
+ }
+ /* If there was a match at the previous step and the current
+ * match is not better, output the previous match:
+ */
+ if(zip_prev_length >= zip_MIN_MATCH &&
+ zip_match_length <= zip_prev_length) {
+ var flush; // set if current block must be flushed
+
+// check_match(strstart - 1, prev_match, prev_length);
+ flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match,
+ zip_prev_length - zip_MIN_MATCH);
+
+ /* Insert in hash table all strings up to the end of the match.
+ * strstart-1 and strstart are already inserted.
+ */
+ zip_lookahead -= zip_prev_length - 1;
+ zip_prev_length -= 2;
+ do {
+ zip_strstart++;
+ zip_INSERT_STRING();
+ /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+ * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
+ * these bytes are garbage, but it does not matter since the
+ * next lookahead bytes will always be emitted as literals.
+ */
+ } while(--zip_prev_length != 0);
+ zip_match_available = 0;
+ zip_match_length = zip_MIN_MATCH - 1;
+ zip_strstart++;
+ if(flush) {
+ zip_flush_block(0);
+ zip_block_start = zip_strstart;
+ }
+ } else if(zip_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.
+ */
+ if(zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) {
+ zip_flush_block(0);
+ zip_block_start = zip_strstart;
+ }
+ zip_strstart++;
+ zip_lookahead--;
+ } else {
+ /* There is no previous match to compare with, wait for
+ * the next step to decide.
+ */
+ zip_match_available = 1;
+ zip_strstart++;
+ zip_lookahead--;
+ }
+
+ /* 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.
+ */
+ while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
+ zip_fill_window();
+ }
+}
+
+var zip_init_deflate = function() {
+ if(zip_eofile)
+ return;
+ zip_bi_buf = 0;
+ zip_bi_valid = 0;
+ zip_ct_init();
+ zip_lm_init();
+
+ zip_qhead = null;
+ zip_outcnt = 0;
+ zip_outoff = 0;
+
+ if(zip_compr_level <= 3)
+ {
+ zip_prev_length = zip_MIN_MATCH - 1;
+ zip_match_length = 0;
+ }
+ else
+ {
+ zip_match_length = zip_MIN_MATCH - 1;
+ zip_match_available = 0;
+ }
+
+ zip_complete = false;
+}
+
+/* ==========================================================================
+ * 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.
+ */
+var zip_deflate_internal = function(buff, off, buff_size) {
+ var n;
+
+ if(!zip_initflag)
+ {
+ zip_init_deflate();
+ zip_initflag = true;
+ if(zip_lookahead == 0) { // empty
+ zip_complete = true;
+ return 0;
+ }
+ }
+
+ if((n = zip_qcopy(buff, off, buff_size)) == buff_size)
+ return buff_size;
+
+ if(zip_complete)
+ return n;
+
+ if(zip_compr_level <= 3) // optimized for speed
+ zip_deflate_fast();
+ else
+ zip_deflate_better();
+ if(zip_lookahead == 0) {
+ if(zip_match_available != 0)
+ zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff);
+ zip_flush_block(1);
+ zip_complete = true;
+ }
+ return n + zip_qcopy(buff, n + off, buff_size - n);
+}
+
+var zip_qcopy = function(buff, off, buff_size) {
+ var n, i, j;
+
+ n = 0;
+ while(zip_qhead != null && n < buff_size)
+ {
+ i = buff_size - n;
+ if(i > zip_qhead.len)
+ i = zip_qhead.len;
+// System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i);
+ for(j = 0; j < i; j++)
+ buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j];
+
+ zip_qhead.off += i;
+ zip_qhead.len -= i;
+ n += i;
+ if(zip_qhead.len == 0) {
+ var p;
+ p = zip_qhead;
+ zip_qhead = zip_qhead.next;
+ zip_reuse_queue(p);
+ }
+ }
+
+ if(n == buff_size)
+ return n;
+
+ if(zip_outoff < zip_outcnt) {
+ i = buff_size - n;
+ if(i > zip_outcnt - zip_outoff)
+ i = zip_outcnt - zip_outoff;
+ // System.arraycopy(outbuf, outoff, buff, off + n, i);
+ for(j = 0; j < i; j++)
+ buff[off + n + j] = zip_outbuf[zip_outoff + j];
+ zip_outoff += i;
+ n += i;
+ if(zip_outcnt == zip_outoff)
+ zip_outcnt = zip_outoff = 0;
+ }
+ return n;
+}
+
+/* ==========================================================================
+ * Allocate the match buffer, initialize the various tables and save the
+ * location of the internal file attribute (ascii/binary) and method
+ * (DEFLATE/STORE).
+ */
+var zip_ct_init = function() {
+ var n; // iterates over tree elements
+ var bits; // bit counter
+ var length; // length value
+ var code; // code value
+ var dist; // distance index
+
+ if(zip_static_dtree[0].dl != 0) return; // ct_init already called
+
+ zip_l_desc.dyn_tree = zip_dyn_ltree;
+ zip_l_desc.static_tree = zip_static_ltree;
+ zip_l_desc.extra_bits = zip_extra_lbits;
+ zip_l_desc.extra_base = zip_LITERALS + 1;
+ zip_l_desc.elems = zip_L_CODES;
+ zip_l_desc.max_length = zip_MAX_BITS;
+ zip_l_desc.max_code = 0;
+
+ zip_d_desc.dyn_tree = zip_dyn_dtree;
+ zip_d_desc.static_tree = zip_static_dtree;
+ zip_d_desc.extra_bits = zip_extra_dbits;
+ zip_d_desc.extra_base = 0;
+ zip_d_desc.elems = zip_D_CODES;
+ zip_d_desc.max_length = zip_MAX_BITS;
+ zip_d_desc.max_code = 0;
+
+ zip_bl_desc.dyn_tree = zip_bl_tree;
+ zip_bl_desc.static_tree = null;
+ zip_bl_desc.extra_bits = zip_extra_blbits;
+ zip_bl_desc.extra_base = 0;
+ zip_bl_desc.elems = zip_BL_CODES;
+ zip_bl_desc.max_length = zip_MAX_BL_BITS;
+ zip_bl_desc.max_code = 0;
+
+ // Initialize the mapping length (0..255) -> length code (0..28)
+ length = 0;
+ for(code = 0; code < zip_LENGTH_CODES-1; code++) {
+ zip_base_length[code] = length;
+ for(n = 0; n < (1< dist code (0..29) */
+ dist = 0;
+ for(code = 0 ; code < 16; code++) {
+ zip_base_dist[code] = dist;
+ for(n = 0; n < (1<>= 7; // from now on, all distances are divided by 128
+ for( ; code < zip_D_CODES; code++) {
+ zip_base_dist[code] = dist << 7;
+ for(n = 0; n < (1<<(zip_extra_dbits[code]-7)); n++)
+ zip_dist_code[256 + dist++] = code;
+ }
+ // Assert (dist == 256, "ct_init: 256+dist != 512");
+
+ // Construct the codes of the static literal tree
+ for(bits = 0; bits <= zip_MAX_BITS; bits++)
+ zip_bl_count[bits] = 0;
+ n = 0;
+ while(n <= 143) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
+ while(n <= 255) { zip_static_ltree[n++].dl = 9; zip_bl_count[9]++; }
+ while(n <= 279) { zip_static_ltree[n++].dl = 7; zip_bl_count[7]++; }
+ while(n <= 287) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
+ /* Codes 286 and 287 do not exist, but we must include them in the
+ * tree construction to get a canonical Huffman tree (longest code
+ * all ones)
+ */
+ zip_gen_codes(zip_static_ltree, zip_L_CODES + 1);
+
+ /* The static distance tree is trivial: */
+ for(n = 0; n < zip_D_CODES; n++) {
+ zip_static_dtree[n].dl = 5;
+ zip_static_dtree[n].fc = zip_bi_reverse(n, 5);
+ }
+
+ // Initialize the first block of the first file:
+ zip_init_block();
+}
+
+/* ==========================================================================
+ * Initialize a new block.
+ */
+var zip_init_block = function() {
+ var n; // iterates over tree elements
+
+ // Initialize the trees.
+ for(n = 0; n < zip_L_CODES; n++) zip_dyn_ltree[n].fc = 0;
+ for(n = 0; n < zip_D_CODES; n++) zip_dyn_dtree[n].fc = 0;
+ for(n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0;
+
+ zip_dyn_ltree[zip_END_BLOCK].fc = 1;
+ zip_opt_len = zip_static_len = 0;
+ zip_last_lit = zip_last_dist = zip_last_flags = 0;
+ zip_flags = 0;
+ zip_flag_bit = 1;
+}
+
+/* ==========================================================================
+ * 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).
+ */
+var zip_pqdownheap = function(
+ tree, // the tree to restore
+ k) { // node to move down
+ var v = zip_heap[k];
+ var j = k << 1; // left son of k
+
+ while(j <= zip_heap_len) {
+ // Set j to the smallest of the two sons:
+ if(j < zip_heap_len &&
+ zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j]))
+ j++;
+
+ // Exit if v is smaller than both sons
+ if(zip_SMALLER(tree, v, zip_heap[j]))
+ break;
+
+ // Exchange v with the smallest son
+ zip_heap[k] = zip_heap[j];
+ k = j;
+
+ // And continue down the tree, setting j to the left son of k
+ j <<= 1;
+ }
+ zip_heap[k] = v;
+}
+
+/* ==========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ * above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ * array bl_count contains the frequencies for each bit length.
+ * The length opt_len is updated; static_len is also updated if stree is
+ * not null.
+ */
+var zip_gen_bitlen = function(desc) { // the tree descriptor
+ var tree = desc.dyn_tree;
+ var extra = desc.extra_bits;
+ var base = desc.extra_base;
+ var max_code = desc.max_code;
+ var max_length = desc.max_length;
+ var stree = desc.static_tree;
+ var h; // heap index
+ var n, m; // iterate over the tree elements
+ var bits; // bit length
+ var xbits; // extra bits
+ var f; // frequency
+ var overflow = 0; // number of elements with bit length too large
+
+ for(bits = 0; bits <= zip_MAX_BITS; bits++)
+ zip_bl_count[bits] = 0;
+
+ /* In a first pass, compute the optimal bit lengths (which may
+ * overflow in the case of the bit length tree).
+ */
+ tree[zip_heap[zip_heap_max]].dl = 0; // root of the heap
+
+ for(h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) {
+ n = zip_heap[h];
+ bits = tree[tree[n].dl].dl + 1;
+ if(bits > max_length) {
+ bits = max_length;
+ overflow++;
+ }
+ tree[n].dl = bits;
+ // We overwrite tree[n].dl which is no longer needed
+
+ if(n > max_code)
+ continue; // not a leaf node
+
+ zip_bl_count[bits]++;
+ xbits = 0;
+ if(n >= base)
+ xbits = extra[n - base];
+ f = tree[n].fc;
+ zip_opt_len += f * (bits + xbits);
+ if(stree != null)
+ zip_static_len += f * (stree[n].dl + 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(zip_bl_count[bits] == 0)
+ bits--;
+ zip_bl_count[bits]--; // move one leaf down the tree
+ zip_bl_count[bits + 1] += 2; // move one overflow item as its brother
+ zip_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);
+
+ /* Now recompute all bit lengths, scanning in increasing frequency.
+ * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+ * lengths instead of fixing only the wrong ones. This idea is taken
+ * from 'ar' written by Haruhiko Okumura.)
+ */
+ for(bits = max_length; bits != 0; bits--) {
+ n = zip_bl_count[bits];
+ while(n != 0) {
+ m = zip_heap[--h];
+ if(m > max_code)
+ continue;
+ if(tree[m].dl != bits) {
+ zip_opt_len += (bits - tree[m].dl) * tree[m].fc;
+ tree[m].fc = bits;
+ }
+ n--;
+ }
+ }
+}
+
+ /* ==========================================================================
+ * 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.
+ */
+var zip_gen_codes = function(tree, // the tree to decorate
+ max_code) { // largest code with non zero frequency
+ var next_code = new Array(zip_MAX_BITS+1); // next code value for each bit length
+ var code = 0; // running code value
+ var bits; // bit index
+ var n; // code index
+
+ /* The distribution counts are first used to generate the code values
+ * without bit reversal.
+ */
+ for(bits = 1; bits <= zip_MAX_BITS; bits++) {
+ code = ((code + zip_bl_count[bits-1]) << 1);
+ next_code[bits] = code;
+ }
+
+ /* Check that the bit counts in bl_count are consistent. The last code
+ * must be all ones.
+ */
+// Assert (code + encoder->bl_count[MAX_BITS]-1 == (1<> 1; n >= 1; n--)
+ zip_pqdownheap(tree, n);
+
+ /* Construct the Huffman tree by repeatedly combining the least two
+ * frequent nodes.
+ */
+ do {
+ n = zip_heap[zip_SMALLEST];
+ zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--];
+ zip_pqdownheap(tree, zip_SMALLEST);
+
+ m = zip_heap[zip_SMALLEST]; // m = node of next least frequency
+
+ // keep the nodes sorted by frequency
+ zip_heap[--zip_heap_max] = n;
+ zip_heap[--zip_heap_max] = m;
+
+ // Create a new node father of n and m
+ tree[node].fc = tree[n].fc + tree[m].fc;
+// depth[node] = (char)(MAX(depth[n], depth[m]) + 1);
+ if(zip_depth[n] > zip_depth[m] + 1)
+ zip_depth[node] = zip_depth[n];
+ else
+ zip_depth[node] = zip_depth[m] + 1;
+ tree[n].dl = tree[m].dl = node;
+
+ // and insert the new node in the heap
+ zip_heap[zip_SMALLEST] = node++;
+ zip_pqdownheap(tree, zip_SMALLEST);
+
+ } while(zip_heap_len >= 2);
+
+ zip_heap[--zip_heap_max] = zip_heap[zip_SMALLEST];
+
+ /* At this point, the fields freq and dad are set. We can now
+ * generate the bit lengths.
+ */
+ zip_gen_bitlen(desc);
+
+ // The field len is now set, we can generate the bit codes
+ zip_gen_codes(tree, max_code);
+}
+
+/* ==========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree. Updates opt_len to take into account the repeat
+ * counts. (The contribution of the bit length codes will be added later
+ * during the construction of bl_tree.)
+ */
+var zip_scan_tree = function(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].dl; // 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].dl = 0xffff; // guard
+
+ for(n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[n + 1].dl;
+ if(++count < max_count && curlen == nextlen)
+ continue;
+ else if(count < min_count)
+ zip_bl_tree[curlen].fc += count;
+ else if(curlen != 0) {
+ if(curlen != prevlen)
+ zip_bl_tree[curlen].fc++;
+ zip_bl_tree[zip_REP_3_6].fc++;
+ } else if(count <= 10)
+ zip_bl_tree[zip_REPZ_3_10].fc++;
+ else
+ zip_bl_tree[zip_REPZ_11_138].fc++;
+ 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 a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+var zip_send_tree = function(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].dl; // 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
+
+ /* tree[max_code+1].dl = -1; */ /* guard already set */
+ if(nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ }
+
+ for(n = 0; n <= max_code; n++) {
+ curlen = nextlen;
+ nextlen = tree[n+1].dl;
+ if(++count < max_count && curlen == nextlen) {
+ continue;
+ } else if(count < min_count) {
+ do { zip_SEND_CODE(curlen, zip_bl_tree); } while(--count != 0);
+ } else if(curlen != 0) {
+ if(curlen != prevlen) {
+ zip_SEND_CODE(curlen, zip_bl_tree);
+ count--;
+ }
+ // Assert(count >= 3 && count <= 6, " 3_6?");
+ zip_SEND_CODE(zip_REP_3_6, zip_bl_tree);
+ zip_send_bits(count - 3, 2);
+ } else if(count <= 10) {
+ zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree);
+ zip_send_bits(count-3, 3);
+ } else {
+ zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree);
+ zip_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;
+ }
+ }
+}
+
+/* ==========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+var zip_build_bl_tree = function() {
+ var max_blindex; // index of last bit length code of non zero freq
+
+ // Determine the bit length frequencies for literal and distance trees
+ zip_scan_tree(zip_dyn_ltree, zip_l_desc.max_code);
+ zip_scan_tree(zip_dyn_dtree, zip_d_desc.max_code);
+
+ // Build the bit length tree:
+ zip_build_tree(zip_bl_desc);
+ /* 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 = zip_BL_CODES-1; max_blindex >= 3; max_blindex--) {
+ if(zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break;
+ }
+ /* Update opt_len to include the bit length tree and counts */
+ zip_opt_len += 3*(max_blindex+1) + 5+5+4;
+// Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+// encoder->opt_len, encoder->static_len));
+
+ return max_blindex;
+}
+
+/* ==========================================================================
+ * 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.
+ */
+var zip_send_all_trees = function(lcodes, dcodes, blcodes) { // number of codes for each tree
+ var rank; // index in bl_order
+
+// Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+// Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+// "too many codes");
+// Tracev((stderr, "\nbl counts: "));
+ zip_send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt
+ zip_send_bits(dcodes-1, 5);
+ zip_send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt
+ for(rank = 0; rank < blcodes; rank++) {
+// Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+ zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3);
+ }
+
+ // send the literal tree
+ zip_send_tree(zip_dyn_ltree,lcodes-1);
+
+ // send the distance tree
+ zip_send_tree(zip_dyn_dtree,dcodes-1);
+}
+
+/* ==========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and output the encoded block to the zip file.
+ */
+var zip_flush_block = function(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; // index of last bit length code of non zero freq
+ var stored_len; // length of input block
+
+ stored_len = zip_strstart - zip_block_start;
+ zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items
+
+ // Construct the literal and distance trees
+ zip_build_tree(zip_l_desc);
+// Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
+// encoder->opt_len, encoder->static_len));
+
+ zip_build_tree(zip_d_desc);
+// Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
+// encoder->opt_len, encoder->static_len));
+ /* 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 = zip_build_bl_tree();
+
+ // Determine the best encoding. Compute first the block length in bytes
+ opt_lenb = (zip_opt_len +3+7)>>3;
+ static_lenb = (zip_static_len+3+7)>>3;
+
+// Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
+// opt_lenb, encoder->opt_len,
+// static_lenb, encoder->static_len, stored_len,
+// encoder->last_lit, encoder->last_dist));
+
+ if(static_lenb <= opt_lenb)
+ opt_lenb = static_lenb;
+ if(stored_len + 4 <= opt_lenb // 4: two words for the lengths
+ && zip_block_start >= 0) {
+ var i;
+
+ /* 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.
+ */
+ zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3); /* send block type */
+ zip_bi_windup(); /* align on byte boundary */
+ zip_put_short(stored_len);
+ zip_put_short(~stored_len);
+
+ // copy block
+/*
+ p = &window[block_start];
+ for(i = 0; i < stored_len; i++)
+ put_byte(p[i]);
+*/
+ for(i = 0; i < stored_len; i++)
+ zip_put_byte(zip_window[zip_block_start + i]);
+
+ } else if(static_lenb == opt_lenb) {
+ zip_send_bits((zip_STATIC_TREES<<1)+eof, 3);
+ zip_compress_block(zip_static_ltree, zip_static_dtree);
+ } else {
+ zip_send_bits((zip_DYN_TREES<<1)+eof, 3);
+ zip_send_all_trees(zip_l_desc.max_code+1,
+ zip_d_desc.max_code+1,
+ max_blindex+1);
+ zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
+ }
+
+ zip_init_block();
+
+ if(eof != 0)
+ zip_bi_windup();
+}
+
+/* ==========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+var zip_ct_tally = function(
+ dist, // distance of matched string
+ lc) { // match length-MIN_MATCH or unmatched char (if dist==0)
+ zip_l_buf[zip_last_lit++] = lc;
+ if(dist == 0) {
+ // lc is the unmatched char
+ zip_dyn_ltree[lc].fc++;
+ } else {
+ // Here, lc is the match length - MIN_MATCH
+ dist--; // dist = match distance - 1
+// Assert((ush)dist < (ush)MAX_DIST &&
+// (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+// (ush)D_CODE(dist) < (ush)D_CODES, "ct_tally: bad match");
+
+ zip_dyn_ltree[zip_length_code[lc]+zip_LITERALS+1].fc++;
+ zip_dyn_dtree[zip_D_CODE(dist)].fc++;
+
+ zip_d_buf[zip_last_dist++] = dist;
+ zip_flags |= zip_flag_bit;
+ }
+ zip_flag_bit <<= 1;
+
+ // Output the flags if they fill a byte
+ if((zip_last_lit & 7) == 0) {
+ zip_flag_buf[zip_last_flags++] = zip_flags;
+ zip_flags = 0;
+ zip_flag_bit = 1;
+ }
+ // Try to guess if it is profitable to stop the current block here
+ if(zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) {
+ // Compute an upper bound for the compressed length
+ var out_length = zip_last_lit * 8;
+ var in_length = zip_strstart - zip_block_start;
+ var dcode;
+
+ for(dcode = 0; dcode < zip_D_CODES; dcode++) {
+ out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]);
+ }
+ out_length >>= 3;
+// Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
+// encoder->last_lit, encoder->last_dist, in_length, out_length,
+// 100L - out_length*100L/in_length));
+ if(zip_last_dist < parseInt(zip_last_lit/2) &&
+ out_length < parseInt(in_length/2))
+ return true;
+ }
+ return (zip_last_lit == zip_LIT_BUFSIZE-1 ||
+ zip_last_dist == zip_DIST_BUFSIZE);
+ /* 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
+ */
+var zip_compress_block = function(
+ ltree, // literal tree
+ dtree) { // distance tree
+ 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 dx = 0; // running index in d_buf
+ var fx = 0; // running index in flag_buf
+ var flag = 0; // current flags
+ var code; // the code to send
+ var extra; // number of extra bits to send
+
+ if(zip_last_lit != 0) do {
+ if((lx & 7) == 0)
+ flag = zip_flag_buf[fx++];
+ lc = zip_l_buf[lx++] & 0xff;
+ if((flag & 1) == 0) {
+ zip_SEND_CODE(lc, ltree); /* send a literal byte */
+// Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+ } else {
+ // Here, lc is the match length - MIN_MATCH
+ code = zip_length_code[lc];
+ zip_SEND_CODE(code+zip_LITERALS+1, ltree); // send the length code
+ extra = zip_extra_lbits[code];
+ if(extra != 0) {
+ lc -= zip_base_length[code];
+ zip_send_bits(lc, extra); // send the extra length bits
+ }
+ dist = zip_d_buf[dx++];
+ // Here, dist is the match distance - 1
+ code = zip_D_CODE(dist);
+// Assert (code < D_CODES, "bad d_code");
+
+ zip_SEND_CODE(code, dtree); // send the distance code
+ extra = zip_extra_dbits[code];
+ if(extra != 0) {
+ dist -= zip_base_dist[code];
+ zip_send_bits(dist, extra); // send the extra distance bits
+ }
+ } // literal or match pair ?
+ flag >>= 1;
+ } while(lx < zip_last_lit);
+
+ zip_SEND_CODE(zip_END_BLOCK, ltree);
+}
+
+/* ==========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+var zip_Buf_size = 16; // bit size of bi_buf
+var zip_send_bits = function(
+ value, // value to send
+ length) { // number of bits
+ /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+ * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+ * unused bits in value.
+ */
+ if(zip_bi_valid > zip_Buf_size - length) {
+ zip_bi_buf |= (value << zip_bi_valid);
+ zip_put_short(zip_bi_buf);
+ zip_bi_buf = (value >> (zip_Buf_size - zip_bi_valid));
+ zip_bi_valid += length - zip_Buf_size;
+ } else {
+ zip_bi_buf |= value << zip_bi_valid;
+ zip_bi_valid += length;
+ }
+}
+
+/* ==========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+var zip_bi_reverse = function(
+ 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;
+}
+
+/* ==========================================================================
+ * Write out any remaining bits in an incomplete byte.
+ */
+var zip_bi_windup = function() {
+ if(zip_bi_valid > 8) {
+ zip_put_short(zip_bi_buf);
+ } else if(zip_bi_valid > 0) {
+ zip_put_byte(zip_bi_buf);
+ }
+ zip_bi_buf = 0;
+ zip_bi_valid = 0;
+}
+
+var zip_qoutbuf = function() {
+ if(zip_outcnt != 0) {
+ var q, i;
+ q = zip_new_queue();
+ if(zip_qhead == null)
+ zip_qhead = zip_qtail = q;
+ else
+ zip_qtail = zip_qtail.next = q;
+ q.len = zip_outcnt - zip_outoff;
+// System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len);
+ for(i = 0; i < q.len; i++)
+ q.ptr[i] = zip_outbuf[zip_outoff + i];
+ zip_outcnt = zip_outoff = 0;
+ }
+}
+
+var zip_deflate = function(str, level) {
+ var i, j;
+
+ zip_deflate_data = str;
+ zip_deflate_pos = 0;
+ if(typeof level == "undefined")
+ level = zip_DEFAULT_LEVEL;
+ zip_deflate_start(level);
+
+ var buff = new Array(1024);
+ var aout = [];
+ while((i = zip_deflate_internal(buff, 0, buff.length)) > 0) {
+ var cbuf = new Array(i);
+ for(j = 0; j < i; j++){
+ cbuf[j] = String.fromCharCode(buff[j]);
+ }
+ aout[aout.length] = cbuf.join("");
+ }
+ zip_deflate_data = null; // G.C.
+ return aout.join("");
+}
+
+//
+// end of the script of Masanao Izumo.
+//
+
+// we add the compression method for JSZip
+if(!JSZip.compressions["DEFLATE"]) {
+ JSZip.compressions["DEFLATE"] = {
+ magic : "\x08\x00",
+ compress : zip_deflate
+ }
+} else {
+ JSZip.compressions["DEFLATE"].compress = zip_deflate;
+}
+
+})();
diff --git a/gh-pages/js/libs/jszip.js b/gh-pages/js/libs/jszip.js
new file mode 100644
index 0000000..803f397
--- /dev/null
+++ b/gh-pages/js/libs/jszip.js
@@ -0,0 +1,735 @@
+/**
+
+JSZip - A Javascript class for generating and reading zip files
+
+
+(c) 2009-2012 Stuart Knightley
+Dual licenced under the MIT license or GPLv3. See LICENSE.markdown.
+
+Usage:
+ zip = new JSZip();
+ zip.file("hello.txt", "Hello, World!").add("tempfile", "nothing");
+ zip.folder("images").file("smile.gif", base64Data, {base64: true});
+ zip.file("Xmas.txt", "Ho ho ho !", {date : new Date("December 25, 2007 00:00:01")});
+ zip.remove("tempfile");
+
+ base64zip = zip.generate();
+
+**/
+
+/**
+ * Representation a of zip file in js
+ * @constructor
+ * @param {String=} data the data to load, if any (optional).
+ * @param {Object=} options the options for creating this objects (optional).
+ */
+var JSZip = function(data, options) {
+ // object containing the files :
+ // {
+ // "folder/" : {...},
+ // "folder/data.txt" : {...}
+ // }
+ this.files = {};
+
+ // Where we are in the hierarchy
+ this.root = "";
+
+ if(data) {
+ this.load(data, options);
+ }
+};
+
+JSZip.signature = {
+ LOCAL_FILE_HEADER : "\x50\x4b\x03\x04",
+ CENTRAL_FILE_HEADER : "\x50\x4b\x01\x02",
+ CENTRAL_DIRECTORY_END : "\x50\x4b\x05\x06",
+ ZIP64_CENTRAL_DIRECTORY_LOCATOR : "\x50\x4b\x06\x07",
+ ZIP64_CENTRAL_DIRECTORY_END : "\x50\x4b\x06\x06",
+ DATA_DESCRIPTOR : "\x50\x4b\x07\x08"
+};
+
+// Default properties for a new file
+JSZip.defaults = {
+ base64: false,
+ binary: false,
+ dir: false,
+ date: null
+};
+
+
+JSZip.prototype = (function ()
+{
+ /**
+ * A simple object representing a file in the zip file.
+ * @constructor
+ * @param {string} name the name of the file
+ * @param {string} data the data
+ * @param {Object} options the options of the file
+ */
+ var ZipObject = function (name, data, options) {
+ this.name = name;
+ this.data = data;
+ this.options = options;
+ };
+
+ ZipObject.prototype = {
+ /**
+ * Return the content as UTF8 string.
+ * @return {string} the UTF8 string.
+ */
+ asText : function ()
+ {
+ return this.options.binary ? JSZip.prototype.utf8decode(this.data) : this.data;
+ },
+ /**
+ * Returns the binary content.
+ * @return {string} the content as binary.
+ */
+ asBinary : function ()
+ {
+ return this.options.binary ? this.data : JSZip.prototype.utf8encode(this.data);
+ }
+ };
+
+ /**
+ * Transform an integer into a string in hexadecimal.
+ * @private
+ * @param {number} dec the number to convert.
+ * @param {number} bytes the number of bytes to generate.
+ * @returns {string} the result.
+ */
+ var decToHex = function(dec, bytes) {
+ var hex = "", i;
+ for(i = 0; i < bytes; i++)
+ {
+ hex += String.fromCharCode(dec&0xff);
+ dec=dec>>>8;
+ }
+ return hex;
+ };
+
+ /**
+ * Merge the objects passed as parameters into a new one.
+ * @private
+ * @param {...Object} var_args All objects to merge.
+ * @return {Object} a new object with the data of the others.
+ */
+ var extend = function () {
+ var result = {}, i, attr;
+ for (i = 0; i < arguments.length; i++) // arguments is not enumerable in some browsers
+ {
+ for (attr in arguments[i])
+ {
+ if(typeof result[attr] === "undefined")
+ {
+ result[attr] = arguments[i][attr];
+ }
+ }
+ }
+ return result;
+ };
+
+ /**
+ * Transforms the (incomplete) options from the user into the complete
+ * set of options to create a file.
+ * @private
+ * @param {Object} o the options from the user.
+ * @return {Object} the complete set of options.
+ */
+ var prepareFileAttrs = function (o) {
+ o = o || {};
+ if (o.base64 === true && o.binary == null) {
+ o.binary = true;
+ }
+ o = extend(o, JSZip.defaults);
+ o.date = o.date || new Date();
+
+ return o;
+ };
+
+ /**
+ * Add a file in the current folder.
+ * @private
+ * @param {string} name the name of the file
+ * @param {string} data the data of the file
+ * @param {Object} o the options of the file
+ * @return {Object} the new file.
+ */
+ var fileAdd = function (name, data, o) {
+ // be sure sub folders exist
+ var parent = parentFolder(name);
+ if (parent) {
+ folderAdd.call(this, parent);
+ }
+
+ o = prepareFileAttrs(o);
+
+ return this.files[name] = {name: name, data: data, options:o};
+ };
+
+
+ /**
+ * Find the parent folder of the path.
+ * @private
+ * @param {string} path the path to use
+ * @return {string} the parent folder, or ""
+ */
+ var parentFolder = function (path) {
+ if (path.slice(-1) == '/')
+ {
+ path = path.substring(0, path.length - 1);
+ }
+ var lastSlash = path.lastIndexOf('/');
+ return (lastSlash > 0) ? path.substring(0, lastSlash) : "";
+ };
+
+ /**
+ * Add a (sub) folder in the current folder.
+ * @private
+ * @param {string} name the folder's name
+ * @return {Object} the new folder.
+ */
+ var folderAdd = function (name) {
+ // Check the name ends with a /
+ if (name.slice(-1) != "/") {
+ name += "/"; // IE doesn't like substr(-1)
+ }
+
+ // Does this folder already exist?
+ if (!this.files[name])
+ {
+ // be sure sub folders exist
+ var parent = parentFolder(name);
+ if (parent) {
+ folderAdd.call(this, parent);
+ }
+
+ fileAdd.call(this, name, '', {dir:true});
+ }
+ return this.files[name];
+ };
+
+ /**
+ * Generate the data found in the local header of a zip file.
+ * Do not create it now, as some parts are re-used later.
+ * @private
+ * @param {Object} file the file to use.
+ * @param {string} utfEncodedFileName the file name, utf8 encoded.
+ * @param {string} compressionType the compression to use.
+ * @return {Object} an object containing header and compressedData.
+ */
+ var prepareLocalHeaderData = function(file, utfEncodedFileName, compressionType) {
+ var useUTF8 = utfEncodedFileName !== file.name,
+ data = file.data,
+ o = file.options,
+ dosTime,
+ dosDate;
+
+ // date
+ // @see http://www.delorie.com/djgpp/doc/rbinter/it/52/13.html
+ // @see http://www.delorie.com/djgpp/doc/rbinter/it/65/16.html
+ // @see http://www.delorie.com/djgpp/doc/rbinter/it/66/16.html
+
+ dosTime = o.date.getHours();
+ dosTime = dosTime << 6;
+ dosTime = dosTime | o.date.getMinutes();
+ dosTime = dosTime << 5;
+ dosTime = dosTime | o.date.getSeconds() / 2;
+
+ dosDate = o.date.getFullYear() - 1980;
+ dosDate = dosDate << 4;
+ dosDate = dosDate | (o.date.getMonth() + 1);
+ dosDate = dosDate << 5;
+ dosDate = dosDate | o.date.getDate();
+
+ if (o.base64 === true) {
+ data = JSZipBase64.decode(data);
+ }
+ // decode UTF-8 strings if we are dealing with text data
+ if(o.binary === false) {
+ data = this.utf8encode(data);
+ }
+
+
+ var compression = JSZip.compressions[compressionType];
+ var compressedData = compression.compress(data);
+
+ var header = "";
+
+ // version needed to extract
+ header += "\x0A\x00";
+ // general purpose bit flag
+ // set bit 11 if utf8
+ header += useUTF8 ? "\x00\x08" : "\x00\x00";
+ // compression method
+ header += compression.magic;
+ // last mod file time
+ header += decToHex(dosTime, 2);
+ // last mod file date
+ header += decToHex(dosDate, 2);
+ // crc-32
+ header += decToHex(this.crc32(data), 4);
+ // compressed size
+ header += decToHex(compressedData.length, 4);
+ // uncompressed size
+ header += decToHex(data.length, 4);
+ // file name length
+ header += decToHex(utfEncodedFileName.length, 2);
+ // extra field length
+ header += "\x00\x00";
+
+ return {
+ header:header,
+ compressedData:compressedData
+ };
+ };
+
+
+ // return the actual prototype of JSZip
+ return {
+ /**
+ * Read an existing zip and merge the data in the current JSZip object.
+ * The implementation is in jszip-load.js, don't forget to include it.
+ * @param {string} stream The stream to load
+ * @param {Object} options Options for loading the stream.
+ * options.base64 : is the stream in base64 ? default : false
+ * @return {JSZip} the current JSZip object
+ */
+ load : function (stream, options)
+ {
+ throw new Error("Load method is not defined. Is the file jszip-load.js included ?");
+ },
+
+ /**
+ * Filter nested files/folders with the specified function.
+ * @param {Function} search the predicate to use :
+ * function (relativePath, file) {...}
+ * It takes 2 arguments : the relative path and the file.
+ * @return {Array} An array of matching elements.
+ */
+ filter : function (search)
+ {
+ var result = [], filename, relativePath, file, fileClone;
+ for (filename in this.files)
+ {
+ file = this.files[filename];
+ // return a new object, don't let the user mess with our internal objects :)
+ fileClone = new ZipObject(file.name, file.data, extend(file.options));
+ relativePath = filename.slice(this.root.length, filename.length);
+ if (filename.slice(0, this.root.length) === this.root && // the file is in the current root
+ search(relativePath, fileClone)) // and the file matches the function
+ {
+ result.push(fileClone);
+ }
+ }
+ return result;
+ },
+
+ /**
+ * Add a file to the zip file, or search a file.
+ * @param {string|RegExp} name The name of the file to add (if data is defined),
+ * the name of the file to find (if no data) or a regex to match files.
+ * @param {string} data The file data, either raw or base64 encoded
+ * @param {Object} o File options
+ * @return {JSZip|Object|Array} this JSZip object (when adding a file),
+ * a file (when searching by string) or an array of files (when searching by regex).
+ */
+ file : function(name, data, o)
+ {
+ if (arguments.length === 1)
+ {
+ if (name instanceof RegExp)
+ {
+ var regexp = name;
+ return this.filter(function(relativePath, file) {
+ return !file.options.dir && regexp.test(relativePath);
+ });
+ }
+ else // text
+ {
+ return this.filter(function (relativePath, file) {
+ return !file.options.dir && relativePath === name;
+ })[0]||null;
+ }
+ }
+ else // more than one argument : we have data !
+ {
+ name = this.root+name;
+ fileAdd.call(this, name, data, o);
+ }
+ return this;
+ },
+
+ /**
+ * Add a directory to the zip file, or search.
+ * @param {String|RegExp} arg The name of the directory to add, or a regex to search folders.
+ * @return {JSZip} an object with the new directory as the root, or an array containing matching folders.
+ */
+ folder : function(arg)
+ {
+ if (!arg)
+ {
+ throw new Error("folder : wrong argument");
+ }
+
+ if (arg instanceof RegExp)
+ {
+ return this.filter(function(relativePath, file) {
+ return file.options.dir && arg.test(relativePath);
+ });
+ }
+
+ // else, name is a new folder
+ var name = this.root + arg;
+ var newFolder = folderAdd.call(this, name);
+
+ // Allow chaining by returning a new object with this folder as the root
+ var ret = this.clone();
+ ret.root = newFolder.name;
+ return ret;
+ },
+
+ /**
+ * Delete a file, or a directory and all sub-files, from the zip
+ * @param {string} name the name of the file to delete
+ * @return {JSZip} this JSZip object
+ */
+ remove : function(name)
+ {
+ name = this.root + name;
+ var file = this.files[name];
+ if (!file)
+ {
+ // Look for any folders
+ if (name.slice(-1) != "/") {
+ name += "/";
+ }
+ file = this.files[name];
+ }
+
+ if (file)
+ {
+ if (!file.options.dir)
+ {
+ // file
+ delete this.files[name];
+ }
+ else
+ {
+ // folder
+ var kids = this.filter(function (relativePath, file) {
+ return file.name.slice(0, name.length) === name;
+ });
+ for (var i = 0; i < kids.length; i++)
+ {
+ delete this.files[kids[i].name];
+ }
+ }
+ }
+
+ return this;
+ },
+
+ /**
+ * Generate the complete zip file
+ * @param {Object} options the options to generate the zip file :
+ * - base64, true to generate base64.
+ * - compression, "STORE" by default.
+ * @return {string} the zip file
+ */
+ generate : function(options)
+ {
+ options = extend(options || {}, {
+ base64 : true,
+ compression : "STORE"
+ });
+ var compression = options.compression.toUpperCase();
+
+ // The central directory, and files data
+ var directory = [], files = [], fileOffset = 0;
+
+ if (!JSZip.compressions[compression]) {
+ throw compression + " is not a valid compression method !";
+ }
+
+ for (var name in this.files)
+ {
+ if( !this.files.hasOwnProperty(name) ) { continue; }
+
+ var file = this.files[name];
+
+ var utfEncodedFileName = this.utf8encode(file.name);
+
+ var fileRecord = "",
+ dirRecord = "",
+ data = prepareLocalHeaderData.call(this, file, utfEncodedFileName, compression);
+ fileRecord = JSZip.signature.LOCAL_FILE_HEADER + data.header + utfEncodedFileName + data.compressedData;
+
+ dirRecord = JSZip.signature.CENTRAL_FILE_HEADER +
+ // version made by (00: DOS)
+ "\x14\x00" +
+ // file header (common to file and central directory)
+ data.header +
+ // file comment length
+ "\x00\x00" +
+ // disk number start
+ "\x00\x00" +
+ // internal file attributes TODO
+ "\x00\x00" +
+ // external file attributes
+ (this.files[name].dir===true?"\x10\x00\x00\x00":"\x00\x00\x00\x00")+
+ // relative offset of local header
+ decToHex(fileOffset, 4) +
+ // file name
+ utfEncodedFileName;
+
+ fileOffset += fileRecord.length;
+
+ files.push(fileRecord);
+ directory.push(dirRecord);
+ }
+
+ var fileData = files.join("");
+ var dirData = directory.join("");
+
+ var dirEnd = "";
+
+ // end of central dir signature
+ dirEnd = JSZip.signature.CENTRAL_DIRECTORY_END +
+ // number of this disk
+ "\x00\x00" +
+ // number of the disk with the start of the central directory
+ "\x00\x00" +
+ // total number of entries in the central directory on this disk
+ decToHex(files.length, 2) +
+ // total number of entries in the central directory
+ decToHex(files.length, 2) +
+ // size of the central directory 4 bytes
+ decToHex(dirData.length, 4) +
+ // offset of start of central directory with respect to the starting disk number
+ decToHex(fileData.length, 4) +
+ // .ZIP file comment length
+ "\x00\x00";
+
+ var zip = fileData + dirData + dirEnd;
+ return (options.base64) ? JSZipBase64.encode(zip) : zip;
+ },
+
+ /**
+ *
+ * Javascript crc32
+ * http://www.webtoolkit.info/
+ *
+ */
+ crc32 : function(str, crc)
+ {
+
+ if (str === "" || typeof str === "undefined") {
+ return 0;
+ }
+
+ var table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
+
+ if (typeof(crc) == "undefined") { crc = 0; }
+ var x = 0;
+ var y = 0;
+
+ crc = crc ^ (-1);
+ for( var i = 0, iTop = str.length; i < iTop; i++ ) {
+ y = ( crc ^ str.charCodeAt( i ) ) & 0xFF;
+ x = "0x" + table.substr( y * 9, 8 );
+ crc = ( crc >>> 8 ) ^ x;
+ }
+
+ return crc ^ (-1);
+
+ },
+
+ // Inspired by http://my.opera.com/GreyWyvern/blog/show.dml/1725165
+ clone : function()
+ {
+ var newObj = new JSZip();
+ for (var i in this)
+ {
+ if (typeof this[i] !== "function")
+ {
+ newObj[i] = this[i];
+ }
+ }
+ return newObj;
+ },
+
+
+ /**
+ * http://www.webtoolkit.info/javascript-utf8.html
+ */
+ utf8encode : function (string) {
+ string = string.replace(/\r\n/g,"\n");
+ var utftext = "";
+
+ for (var n = 0; n < string.length; n++) {
+
+ var c = string.charCodeAt(n);
+
+ if (c < 128) {
+ utftext += String.fromCharCode(c);
+ }
+ else if((c > 127) && (c < 2048)) {
+ utftext += String.fromCharCode((c >> 6) | 192);
+ utftext += String.fromCharCode((c & 63) | 128);
+ }
+ else {
+ utftext += String.fromCharCode((c >> 12) | 224);
+ utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+ utftext += String.fromCharCode((c & 63) | 128);
+ }
+
+ }
+
+ return utftext;
+ },
+
+ /**
+ * http://www.webtoolkit.info/javascript-utf8.html
+ */
+ utf8decode : function (utftext) {
+ var string = "";
+ var i = 0;
+ var c = 0, c1 = 0, c2 = 0, c3 = 0;
+
+ while ( i < utftext.length ) {
+
+ c = utftext.charCodeAt(i);
+
+ if (c < 128) {
+ string += String.fromCharCode(c);
+ i++;
+ }
+ else if((c > 191) && (c < 224)) {
+ c2 = utftext.charCodeAt(i+1);
+ string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+ i += 2;
+ }
+ else {
+ c2 = utftext.charCodeAt(i+1);
+ c3 = utftext.charCodeAt(i+2);
+ string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+ i += 3;
+ }
+
+ }
+
+ return string;
+ }
+ };
+}());
+
+/*
+ * Compression methods
+ * This object is filled in as follow :
+ * name : {
+ * magic // the 2 bytes indentifying the compression method
+ * compress // function, take the uncompressed content and return it compressed.
+ * uncompress // function, take the compressed content and return it uncompressed.
+ * }
+ *
+ * STORE is the default compression method, so it's included in this file.
+ * Other methods should go to separated files : the user wants modularity.
+ */
+JSZip.compressions = {
+ "STORE" : {
+ magic : "\x00\x00",
+ compress : function (content)
+ {
+ return content; // no compression
+ },
+ uncompress : function (content)
+ {
+ return content; // no compression
+ }
+ }
+};
+
+/**
+ *
+ * Base64 encode / decode
+ * http://www.webtoolkit.info/
+ *
+ * Hacked so that it doesn't utf8 en/decode everything
+ **/
+var JSZipBase64 = (function() {
+ // private property
+ var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+ return {
+ // public method for encoding
+ encode : function(input, utf8) {
+ var output = "";
+ var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+ var i = 0;
+
+ while (i < input.length) {
+
+ chr1 = input.charCodeAt(i++);
+ chr2 = input.charCodeAt(i++);
+ chr3 = input.charCodeAt(i++);
+
+ enc1 = chr1 >> 2;
+ enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+ enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+ enc4 = chr3 & 63;
+
+ if (isNaN(chr2)) {
+ enc3 = enc4 = 64;
+ } else if (isNaN(chr3)) {
+ enc4 = 64;
+ }
+
+ output = output +
+ _keyStr.charAt(enc1) + _keyStr.charAt(enc2) +
+ _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+
+ }
+
+ return output;
+ },
+
+ // public method for decoding
+ decode : function(input, utf8) {
+ var output = "";
+ var chr1, chr2, chr3;
+ var enc1, enc2, enc3, enc4;
+ var i = 0;
+
+ input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+ while (i < input.length) {
+
+ enc1 = _keyStr.indexOf(input.charAt(i++));
+ enc2 = _keyStr.indexOf(input.charAt(i++));
+ enc3 = _keyStr.indexOf(input.charAt(i++));
+ enc4 = _keyStr.indexOf(input.charAt(i++));
+
+ chr1 = (enc1 << 2) | (enc2 >> 4);
+ chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+ chr3 = ((enc3 & 3) << 6) | enc4;
+
+ output = output + String.fromCharCode(chr1);
+
+ if (enc3 != 64) {
+ output = output + String.fromCharCode(chr2);
+ }
+ if (enc4 != 64) {
+ output = output + String.fromCharCode(chr3);
+ }
+
+ }
+
+ return output;
+
+ }
+ };
+}());
+
+// enforcing Stuk's coding style
+// vim: set shiftwidth=3 softtabstop=3:
diff --git a/gh-pages/js/libs/store+json2.min.js b/gh-pages/js/libs/store+json2.min.js
new file mode 100644
index 0000000..ec45d4e
--- /dev/null
+++ b/gh-pages/js/libs/store+json2.min.js
@@ -0,0 +1,2 @@
+/* Copyright (c) 2010-2012 Marcus Westin */
+this.JSON||(this.JSON={}),function(){function f(a){return a<10?"0"+a:a}function quote(a){return escapable.lastIndex=0,escapable.test(a)?'"'+a.replace(escapable,function(a){var b=meta[a];return typeof b=="string"?b:"\\u"+("0000"+a.charCodeAt(0).toString(16)).slice(-4)})+'"':'"'+a+'"'}function str(a,b){var c,d,e,f,g=gap,h,i=b[a];i&&typeof i=="object"&&typeof i.toJSON=="function"&&(i=i.toJSON(a)),typeof rep=="function"&&(i=rep.call(b,a,i));switch(typeof i){case"string":return quote(i);case"number":return isFinite(i)?String(i):"null";case"boolean":case"null":return String(i);case"object":if(!i)return"null";gap+=indent,h=[];if(Object.prototype.toString.apply(i)==="[object Array]"){f=i.length;for(c=0;cdocument.w=window