From c6b4c646177ff0a98ca97c6bd43a43cadcdc8497 Mon Sep 17 00:00:00 2001 From: Yuta Imaya Date: Fri, 7 Mar 2014 17:33:18 +0900 Subject: [PATCH 01/21] change build tool (ant -> grunt), implant source map file --- Gruntfile.js | 148 ++ README.en.md | 21 +- README.md | 22 +- bin/crc32.dev.min.js | 8 + bin/crc32.min.js | 2 +- bin/deflate.dev.min.js | 26 + bin/deflate.min.js | 2 +- bin/deflate.min.js.map | 8 - bin/gunzip.dev.min.js | 27 + bin/gunzip.min.js | 4 +- bin/gunzip.min.js.map | 8 - bin/gzip.dev.min.js | 33 + bin/gzip.min.js | 2 +- bin/gzip.min.js.map | 8 - bin/inflate.dev.min.js | 16 + bin/inflate.min.js | 2 +- bin/inflate.min.js.map | 8 - bin/inflate_stream.dev.min.js | 14 + bin/inflate_stream.min.js | 2 +- bin/inflate_stream.min.js.map | 8 - bin/node-zlib.dev.js | 54 + bin/node-zlib.js | 2 +- bin/node-zlib.js.map | 8 - bin/rawdeflate.dev.min.js | 24 + bin/rawdeflate.min.js | 2 +- bin/rawdeflate.min.js.map | 8 - bin/rawinflate.dev.min.js | 15 + bin/rawinflate.min.js | 2 +- bin/rawinflate.min.js.map | 8 - bin/unzip.dev.min.js | 32 + bin/unzip.min.js | 2 +- bin/unzip.min.js.map | 8 - bin/zip.dev.min.js | 38 + bin/zip.min.js | 2 +- bin/zip.min.js.map | 8 - bin/zlib.dev.min.js | 40 + bin/zlib.min.js | 2 +- bin/zlib.min.js.map | 8 - bin/zlib.pretty.dev.js | 3744 +++++++++++++++++++++++++++++++++ bin/zlib.pretty.js | 3743 ++++++++++++++++++++++++++++++++ bin/zlib_and_gzip.dev.min.js | 52 + bin/zlib_and_gzip.min.js | 8 +- bin/zlib_and_gzip.min.js.map | 8 - build.json | 129 ++ package.json | 4 +- 45 files changed, 8181 insertions(+), 139 deletions(-) create mode 100644 Gruntfile.js create mode 100644 bin/crc32.dev.min.js create mode 100644 bin/deflate.dev.min.js delete mode 100644 bin/deflate.min.js.map create mode 100644 bin/gunzip.dev.min.js delete mode 100644 bin/gunzip.min.js.map create mode 100644 bin/gzip.dev.min.js delete mode 100644 bin/gzip.min.js.map create mode 100644 bin/inflate.dev.min.js delete mode 100644 bin/inflate.min.js.map create mode 100644 bin/inflate_stream.dev.min.js delete mode 100644 bin/inflate_stream.min.js.map create mode 100644 bin/node-zlib.dev.js delete mode 100644 bin/node-zlib.js.map create mode 100644 bin/rawdeflate.dev.min.js delete mode 100644 bin/rawdeflate.min.js.map create mode 100644 bin/rawinflate.dev.min.js delete mode 100644 bin/rawinflate.min.js.map create mode 100644 bin/unzip.dev.min.js delete mode 100644 bin/unzip.min.js.map create mode 100644 bin/zip.dev.min.js delete mode 100644 bin/zip.min.js.map create mode 100644 bin/zlib.dev.min.js delete mode 100644 bin/zlib.min.js.map create mode 100644 bin/zlib.pretty.dev.js create mode 100644 bin/zlib.pretty.js create mode 100644 bin/zlib_and_gzip.dev.min.js delete mode 100644 bin/zlib_and_gzip.min.js.map create mode 100644 build.json diff --git a/Gruntfile.js b/Gruntfile.js new file mode 100644 index 0000000..a2983da --- /dev/null +++ b/Gruntfile.js @@ -0,0 +1,148 @@ +module.exports = function(grunt) { + grunt.loadNpmTasks('grunt-closure-tools'); + grunt.loadNpmTasks('grunt-contrib-concat'); + + var license = grunt.file.read('LICENSE_min'); + var basefiles = [ + 'closure-primitives/base.js', + 'define/typedarray/hybrid.js', + 'src/*.js' + ]; + var config = grunt.file.readJSON("build.json"); + var targets = Object.keys(config); + + grunt.initConfig({ + closureDepsWriter: { + options: { + depswriter: 'closure-primitives/depswriter.py', + root_with_prefix: ['"src ../src"'] + }, + deps: { + dest: 'closure-primitives/deps.js' + } + }, + closureCompiler: mergeObject( + { + options: { + compilerFile: 'vendor/google-closure-compiler/compiler.jar', + checkModified: false, + compilerOpts: { + compilation_level: 'PERFORMANCE_OPTIMIZATIONS', + language_in: 'ECMASCRIPT5_STRICT', + source_map_format: "V3", + manage_closure_dependencies: true, + summary_detail_level: 3, + warning_level: 'VERBOSE', + jscomp_error: [ + 'accessControls', + 'checkTypes', + 'checkVars', + 'const', + 'constantProperty', + 'duplicate', + 'visibility' + ], + output_wrapper: + '"' + license + '(function() {%output%}).call(this);"' + } + } + }, (function() { + var result = {}; + + targets.forEach(function(target) { + result[target] = createClosureCompilerSetting(target); + }); + + return result; + })() + ), + 'concat': mergeObject( + { + options: { + process: concatProcess + } + }, (function() { + var result = {}; + + targets.forEach(function(target) { + result[target] = createConcatSettings(target); + }); + + return result; + })() + ) + }); + + // create compile settings + function createClosureCompilerSetting(target) { + return { + src: basefiles.concat(config[target].src), + dest: config[target].dest, + TEMPcompilerOpts: mergeObject( + { + create_source_map: config[target].map + }, + config[target].compilerOpts || {} + ) + } + } + + // create concat settings + function createConcatSettings(target) { + return { + src: config[target].dest, + dest: config[target].dev + } + } + + // concat sourcemaps + function concatProcess(src, filepath) { + var mapfile = filepath + ".map"; + + var result = + src + '//# sourceMappingURL=data:application/json;base64,' + + new Buffer(updateSourceMaps(mapfile)).toString('base64'); + grunt.file.delete(mapfile); + + return result; + } + + // update sourcemaps + function updateSourceMaps(path) { + var mapObject = grunt.file.readJSON(path); + var contents = []; + + /* + // source data-url version + mapObject.sources.forEach(function(sourcePath, i) { + mapObject.sources[i] = 'data:text/plain;charset=utf-8;base64,' + + new Buffer(grunt.file.read(sourcePath, {encoding: null}).toString('base64')) + }); + */ + + // sourceContent version + mapObject.sources.forEach(function(sourcePath) { + contents.push(grunt.file.read(sourcePath, {encoding: null}).toString()) + }); + + mapObject.sourcesContent = contents; + + return JSON.stringify(mapObject); + } + + // merge object + function mergeObject(dst, src) { + Object.keys(src).forEach(function(key) { + dst[key] = src[key]; + }); + + return dst; + } + + grunt.registerTask("default", targets); + grunt.registerTask("all", targets); + grunt.registerTask("deps", ["closureDepsWriter:deps"]); + targets.forEach(function(target) { + grunt.registerTask(target, ["closureCompiler:" + target, "concat:" + target]); + }); +}; \ No newline at end of file diff --git a/README.en.md b/README.en.md index 5559dd5..8ec8cbb 100644 --- a/README.en.md +++ b/README.en.md @@ -218,16 +218,14 @@ see unit tests. If you want to know the code before compile, SourceMaps and PrettyPrint can be used. -### SourceMaps +### Source Map -If you want to enable the SourceMaps if, you can use the `src` directory and *.min.js.map. +If you want to use the Source Map, use `dev` version. - - inflate.min.js - - inflate.min.js.map - - [src] - - (source files) +For example, you want to use Inflate with Source Map. -`[src]` is zlib.js source code directory. + - inflate.min.js // release version + - inflate.dev.min.js // development version <- use this ### Pretty Print @@ -238,20 +236,19 @@ If you want to enable the SourceMaps if, you can use the `src` directory and *.m How to build ------------ -Build using Ant and Closure Compiler. +Build using Grunt and Closure Compiler. ### Requirement -- Ant 1.8+ -- JRE 1.6+ +- Grunt - Python ### Build -Use "ant" command. +Use "grunt" command. ``` -$ ant [target] +$ grunt [target] ``` #### Build target diff --git a/README.md b/README.md index a81f993..f0ca4c5 100644 --- a/README.md +++ b/README.md @@ -237,16 +237,13 @@ zlib.js では JavaScript ファイルを minify された形で提供してい そういった時のために SourceMaps ファイルや Pretty Print されたファイルも提供しています。 -### SourceMaps +### Source Map -SourceMaps を有効にするには以下のように対象となるファイルに `.map` を付けたファイルと、変換前のソースコードである `src` ディレクトリを配置します。 +Source Map を使いたい場合はファイル名に `dev` のついたバージョンを使います。 +例えば Source Map を有効にした Inflate を使いたい場合は以下になります。 - - inflate.min.js - - inflate.min.js.map - - [src] - - (source files) - -なお、ここに書いてある `[src]` は zlib.js のリポジトリの `src` ディレクトリをコピーしてください。 + - inflate.min.js // リリースバージョン + - inflate.dev.min.js // 開発バージョン（これを使う） ### Pretty Print @@ -259,20 +256,19 @@ SourceMaps とは異なりますが、minify の変数名の短縮のみ避け How to build ------------ -ビルドは Ant と Closure Compiler を使用して行います。 +ビルドは Grunt と Closure Compiler を使用して行います。 ### 必要な環境 -- Ant 1.8+ -- JRE 1.6+ +- Grunt - Python ### ビルド -Ant を使ってビルドを行います。 +Grunt を使ってビルドを行います。 ``` -$ ant [target] +$ grunt [target] ``` #### ビルドターゲット diff --git a/bin/crc32.dev.min.js b/bin/crc32.dev.min.js new file mode 100644 index 0000000..39b0fb1 --- /dev/null +++ b/bin/crc32.dev.min.js @@ -0,0 +1,8 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var f=this;function h(c,a){var b=c.split("."),e=f;!(b[0]in e)&&e.execScript&&e.execScript("var "+b[0]);for(var d;b.length&&(d=b.shift());)!b.length&&void 0!==a?e[d]=a:e=e[d]?e[d]:e[d]={}};var l={c:function(c,a,b){return l.update(c,0,a,b)},update:function(c,a,b,e){var d=l.a,g="number"===typeof b?b:b=0,k="number"===typeof e?e:c.length;a^=4294967295;for(g=k&7;g--;++b)a=a>>>8^d[(a^c[b])&255];for(g=k>>3;g--;b+=8)a=a>>>8^d[(a^c[b])&255],a=a>>>8^d[(a^c[b+1])&255],a=a>>>8^d[(a^c[b+2])&255],a=a>>>8^d[(a^c[b+3])&255],a=a>>>8^d[(a^c[b+4])&255],a=a>>>8^d[(a^c[b+5])&255],a=a>>>8^d[(a^c[b+6])&255],a=a>>>8^d[(a^c[b+7])&255];return(a^4294967295)>>>0},d:function(c,a){return(l.a[(c^a)&255]^c>>>8)>>> +0},b:[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117]};l.a="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView?new Uint32Array(l.b):l.b;h("Zlib.CRC32",l);h("Zlib.CRC32.calc",l.c);h("Zlib.CRC32.update",l.update);}).call(this); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin/crc32.min.js","lineCount":7,"mappings":"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","sources":["closure-primitives/base.js","src/crc32.js","define/typedarray/hybrid.js","export/crc32.js"],"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","undefined","Zlib.CRC32","Zlib.CRC32.calc","data","pos","Zlib.CRC32.update","update","crc","table","Zlib.CRC32.Table","Table","i","il","Zlib.CRC32.single","num","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.CRC32.Table_","Table_","publicPath","calc"],"sourcesContent":["// Copyright 2006 The Closure Library Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/**\n * @fileoverview Bootstrap for the Google JS Library (Closure).\n *\n * In uncompiled mode base.js will write out Closure's deps file, unless the\n * global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to\n * include their own deps file(s) from different locations.\n *\n */\n\n\n/**\n * @define {boolean} Overridden to true by the compiler when --closure_pass\n *     or --mark_as_compiled is specified.\n */\nvar COMPILED = false;\n\n\n/**\n * Base namespace for the Closure library.  Checks to see goog is\n * already defined in the current scope before assigning to prevent\n * clobbering if base.js is loaded more than once.\n *\n * @const\n */\nvar goog = goog || {}; // Identifies this file as the Closure base.\n\n\n/**\n * Reference to the global context.  In most cases this will be 'window'.\n */\ngoog.global = this;\n\n\n/**\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\n * that should not be included in a production js_binary can be easily stripped\n * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most\n * toString() methods should be declared inside an \"if (goog.DEBUG)\" conditional\n * because they are generally used for debugging purposes and it is difficult\n * for the JSCompiler to statically determine whether they are used.\n */\ngoog.DEBUG = true;\n\n\n/**\n * @define {string} LOCALE defines the locale being used for compilation. It is\n * used to select locale specific data to be compiled in js binary. BUILD rule\n * can specify this value by \"--define goog.LOCALE=<locale_name>\" as JSCompiler\n * option.\n *\n * Take into account that the locale code format is important. You should use\n * the canonical Unicode format with hyphen as a delimiter. Language must be\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\n *\n * See more info about locale codes here:\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\n *\n * For language codes you should use values defined by ISO 693-1. See it here\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\n * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.\n */\ngoog.LOCALE = 'en';  // default to en\n\n\n/**\n * Creates object stubs for a namespace.  The presence of one or more\n * goog.provide() calls indicate that the file defines the given\n * objects/namespaces.  Build tools also scan for provide/require statements\n * to discern dependencies, build dependency files (see deps.js), etc.\n * @see goog.require\n * @param {string} name Namespace provided by this file in the form\n *     \"goog.package.part\".\n */\ngoog.provide = function(name) {\n  if (!COMPILED) {\n    // Ensure that the same namespace isn't provided twice. This is intended\n    // to teach new developers that 'goog.provide' is effectively a variable\n    // declaration. And when JSCompiler transforms goog.provide into a real\n    // variable declaration, the compiled JS should work the same as the raw\n    // JS--even when the raw JS uses goog.provide incorrectly.\n    if (goog.isProvided_(name)) {\n      throw Error('Namespace \"' + name + '\" already declared.');\n    }\n    delete goog.implicitNamespaces_[name];\n\n    var namespace = name;\n    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\n      if (goog.getObjectByName(namespace)) {\n        break;\n      }\n      goog.implicitNamespaces_[namespace] = true;\n    }\n  }\n\n  goog.exportPath_(name);\n};\n\n\n/**\n * Marks that the current file should only be used for testing, and never for\n * live code in production.\n * @param {string=} opt_message Optional message to add to the error that's\n *     raised when used in production code.\n */\ngoog.setTestOnly = function(opt_message) {\n  if (COMPILED && !goog.DEBUG) {\n    opt_message = opt_message || '';\n    throw Error('Importing test-only code into non-debug environment' +\n                opt_message ? ': ' + opt_message : '.');\n  }\n};\n\n\nif (!COMPILED) {\n\n  /**\n   * Check if the given name has been goog.provided. This will return false for\n   * names that are available only as implicit namespaces.\n   * @param {string} name name of the object to look for.\n   * @return {boolean} Whether the name has been provided.\n   * @private\n   */\n  goog.isProvided_ = function(name) {\n    return !goog.implicitNamespaces_[name] && !!goog.getObjectByName(name);\n  };\n\n  /**\n   * Namespaces implicitly defined by goog.provide. For example,\n   * goog.provide('goog.events.Event') implicitly declares\n   * that 'goog' and 'goog.events' must be namespaces.\n   *\n   * @type {Object}\n   * @private\n   */\n  goog.implicitNamespaces_ = {};\n}\n\n\n/**\n * Builds an object structure for the provided namespace path,\n * ensuring that names that already exist are not overwritten. For\n * example:\n * \"a.b.c\" -> a = {};a.b={};a.b.c={};\n * Used by goog.provide and goog.exportSymbol.\n * @param {string} name name of the object that this file defines.\n * @param {*=} opt_object the object to expose at the end of the path.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n * @private\n */\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  var parts = name.split('.');\n  var cur = opt_objectToExportTo || goog.global;\n\n  // Internet Explorer exhibits strange behavior when throwing errors from\n  // methods externed in this manner.  See the testExportSymbolExceptions in\n  // base_test.html for an example.\n  if (!(parts[0] in cur) && cur.execScript) {\n    cur.execScript('var ' + parts[0]);\n  }\n\n  // Certain browsers cannot parse code in the form for((a in b); c;);\n  // This pattern is produced by the JSCompiler when it collapses the\n  // statement above into the conditional loop below. To prevent this from\n  // happening, use a for-loop and reserve the init logic as below.\n\n  // Parentheses added to eliminate strict JS warning in Firefox.\n  for (var part; parts.length && (part = parts.shift());) {\n    if (!parts.length && goog.isDef(opt_object)) {\n      // last part and we have an object; use it\n      cur[part] = opt_object;\n    } else if (cur[part]) {\n      cur = cur[part];\n    } else {\n      cur = cur[part] = {};\n    }\n  }\n};\n\n\n/**\n * Returns an object based on its fully qualified external name.  If you are\n * using a compilation pass that renames property names beware that using this\n * function will not find renamed properties.\n *\n * @param {string} name The fully qualified name.\n * @param {Object=} opt_obj The object within which to look; default is\n *     |goog.global|.\n * @return {?} The value (object or primitive) or, if not found, null.\n */\ngoog.getObjectByName = function(name, opt_obj) {\n  var parts = name.split('.');\n  var cur = opt_obj || goog.global;\n  for (var part; part = parts.shift(); ) {\n    if (goog.isDefAndNotNull(cur[part])) {\n      cur = cur[part];\n    } else {\n      return null;\n    }\n  }\n  return cur;\n};\n\n\n/**\n * Globalizes a whole namespace, such as goog or goog.lang.\n *\n * @param {Object} obj The namespace to globalize.\n * @param {Object=} opt_global The object to add the properties to.\n * @deprecated Properties may be explicitly exported to the global scope, but\n *     this should no longer be done in bulk.\n */\ngoog.globalize = function(obj, opt_global) {\n  var global = opt_global || goog.global;\n  for (var x in obj) {\n    global[x] = obj[x];\n  }\n};\n\n\n/**\n * Adds a dependency from a file to the files it requires.\n * @param {string} relPath The path to the js file.\n * @param {Array} provides An array of strings with the names of the objects\n *                         this file provides.\n * @param {Array} requires An array of strings with the names of the objects\n *                         this file requires.\n */\ngoog.addDependency = function(relPath, provides, requires) {\n  if (!COMPILED) {\n    var provide, require;\n    var path = relPath.replace(/\\\\/g, '/');\n    var deps = goog.dependencies_;\n    for (var i = 0; provide = provides[i]; i++) {\n      deps.nameToPath[provide] = path;\n      if (!(path in deps.pathToNames)) {\n        deps.pathToNames[path] = {};\n      }\n      deps.pathToNames[path][provide] = true;\n    }\n    for (var j = 0; require = requires[j]; j++) {\n      if (!(path in deps.requires)) {\n        deps.requires[path] = {};\n      }\n      deps.requires[path][require] = true;\n    }\n  }\n};\n\n\n\n\n// NOTE(nnaze): The debug DOM loader was included in base.js as an orignal\n// way to do \"debug-mode\" development.  The dependency system can sometimes\n// be confusing, as can the debug DOM loader's asyncronous nature.\n//\n// With the DOM loader, a call to goog.require() is not blocking -- the\n// script will not load until some point after the current script.  If a\n// namespace is needed at runtime, it needs to be defined in a previous\n// script, or loaded via require() with its registered dependencies.\n// User-defined namespaces may need their own deps file.  See http://go/js_deps,\n// http://go/genjsdeps, or, externally, DepsWriter.\n// http://code.google.com/closure/library/docs/depswriter.html\n//\n// Because of legacy clients, the DOM loader can't be easily removed from\n// base.js.  Work is being done to make it disableable or replaceable for\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\n// for example). See bootstrap/ for more information.\n\n\n/**\n * @define {boolean} Whether to enable the debug loader.\n *\n * If enabled, a call to goog.require() will attempt to load the namespace by\n * appending a script tag to the DOM (if the namespace has been registered).\n *\n * If disabled, goog.require() will simply assert that the namespace has been\n * provided (and depend on the fact that some outside tool correctly ordered\n * the script).\n */\ngoog.ENABLE_DEBUG_LOADER = true;\n\n\n/**\n * Implements a system for the dynamic resolution of dependencies\n * that works in parallel with the BUILD system. Note that all calls\n * to goog.require will be stripped by the JSCompiler when the\n * --closure_pass option is used.\n * @see goog.provide\n * @param {string} name Namespace to include (as was given in goog.provide())\n *     in the form \"goog.package.part\".\n */\ngoog.require = function(name) {\n\n  // if the object already exists we do not need do do anything\n  // TODO(arv): If we start to support require based on file name this has\n  //            to change\n  // TODO(arv): If we allow goog.foo.* this has to change\n  // TODO(arv): If we implement dynamic load after page load we should probably\n  //            not remove this code for the compiled output\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      return;\n    }\n\n    if (goog.ENABLE_DEBUG_LOADER) {\n      var path = goog.getPathFromDeps_(name);\n      if (path) {\n        goog.included_[path] = true;\n        goog.writeScripts_();\n        return;\n      }\n    }\n\n    var errorMessage = 'goog.require could not find: ' + name;\n    if (goog.global.console) {\n      goog.global.console['error'](errorMessage);\n    }\n\n\n      throw Error(errorMessage);\n\n  }\n};\n\n\n/**\n * Path for included scripts\n * @type {string}\n */\ngoog.basePath = '';\n\n\n/**\n * A hook for overriding the base path.\n * @type {string|undefined}\n */\ngoog.global.CLOSURE_BASE_PATH;\n\n\n/**\n * Whether to write out Closure's deps file. By default,\n * the deps are written.\n * @type {boolean|undefined}\n */\ngoog.global.CLOSURE_NO_DEPS;\n\n\n/**\n * A function to import a single script. This is meant to be overridden when\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\n * in the global scope so that it can be set before base.js is loaded, which\n * allows deps.js to be imported properly.\n *\n * The function is passed the script source, which is a relative URI. It should\n * return true if the script was imported, false otherwise.\n */\ngoog.global.CLOSURE_IMPORT_SCRIPT;\n\n\n/**\n * Null function used for default values of callbacks, etc.\n * @return {void} Nothing.\n */\ngoog.nullFunction = function() {};\n\n\n/**\n * The identity function. Returns its first argument.\n *\n * @param {*=} opt_returnValue The single value that will be returned.\n * @param {...*} var_args Optional trailing arguments. These are ignored.\n * @return {?} The first argument. We can't know the type -- just pass it along\n *      without type.\n * @deprecated Use goog.functions.identity instead.\n */\ngoog.identityFunction = function(opt_returnValue, var_args) {\n  return opt_returnValue;\n};\n\n\n/**\n * When defining a class Foo with an abstract method bar(), you can do:\n *\n * Foo.prototype.bar = goog.abstractMethod\n *\n * Now if a subclass of Foo fails to override bar(), an error\n * will be thrown when bar() is invoked.\n *\n * Note: This does not take the name of the function to override as\n * an argument because that would make it more difficult to obfuscate\n * our JavaScript code.\n *\n * @type {!Function}\n * @throws {Error} when invoked to indicate the method should be\n *   overridden.\n */\ngoog.abstractMethod = function() {\n  throw Error('unimplemented abstract method');\n};\n\n\n/**\n * Adds a {@code getInstance} static method that always return the same instance\n * object.\n * @param {!Function} ctor The constructor for the class to add the static\n *     method to.\n */\ngoog.addSingletonGetter = function(ctor) {\n  ctor.getInstance = function() {\n    if (ctor.instance_) {\n      return ctor.instance_;\n    }\n    if (goog.DEBUG) {\n      // NOTE: JSCompiler can't optimize away Array#push.\n      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n    }\n    return ctor.instance_ = new ctor;\n  };\n};\n\n\n/**\n * All singleton classes that have been instantiated, for testing. Don't read\n * it directly, use the {@code goog.testing.singleton} module. The compiler\n * removes this variable if unused.\n * @type {!Array.<!Function>}\n * @private\n */\ngoog.instantiatedSingletons_ = [];\n\n\nif (!COMPILED && goog.ENABLE_DEBUG_LOADER) {\n  /**\n   * Object used to keep track of urls that have already been added. This\n   * record allows the prevention of circular dependencies.\n   * @type {Object}\n   * @private\n   */\n  goog.included_ = {};\n\n\n  /**\n   * This object is used to keep track of dependencies and other data that is\n   * used for loading scripts\n   * @private\n   * @type {Object}\n   */\n  goog.dependencies_ = {\n    pathToNames: {}, // 1 to many\n    nameToPath: {}, // 1 to 1\n    requires: {}, // 1 to many\n    // used when resolving dependencies to prevent us from\n    // visiting the file twice\n    visited: {},\n    written: {} // used to keep track of script files we have written\n  };\n\n\n  /**\n   * Tries to detect whether is in the context of an HTML document.\n   * @return {boolean} True if it looks like HTML document.\n   * @private\n   */\n  goog.inHtmlDocument_ = function() {\n    var doc = goog.global.document;\n    return typeof doc != 'undefined' &&\n           'write' in doc;  // XULDocument misses write.\n  };\n\n\n  /**\n   * Tries to detect the base path of the base.js script that bootstraps Closure\n   * @private\n   */\n  goog.findBasePath_ = function() {\n    if (goog.global.CLOSURE_BASE_PATH) {\n      goog.basePath = goog.global.CLOSURE_BASE_PATH;\n      return;\n    } else if (!goog.inHtmlDocument_()) {\n      return;\n    }\n    var doc = goog.global.document;\n    var scripts = doc.getElementsByTagName('script');\n    // Search backwards since the current script is in almost all cases the one\n    // that has base.js.\n    for (var i = scripts.length - 1; i >= 0; --i) {\n      var src = scripts[i].src;\n      var qmark = src.lastIndexOf('?');\n      var l = qmark == -1 ? src.length : qmark;\n      if (src.substr(l - 7, 7) == 'base.js') {\n        goog.basePath = src.substr(0, l - 7);\n        return;\n      }\n    }\n  };\n\n\n  /**\n   * Imports a script if, and only if, that script hasn't already been imported.\n   * (Must be called at execution time)\n   * @param {string} src Script source.\n   * @private\n   */\n  goog.importScript_ = function(src) {\n    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||\n        goog.writeScriptTag_;\n    if (!goog.dependencies_.written[src] && importScript(src)) {\n      goog.dependencies_.written[src] = true;\n    }\n  };\n\n\n  /**\n   * The default implementation of the import function. Writes a script tag to\n   * import the script.\n   *\n   * @param {string} src The script source.\n   * @return {boolean} True if the script was imported, false otherwise.\n   * @private\n   */\n  goog.writeScriptTag_ = function(src) {\n    if (goog.inHtmlDocument_()) {\n      var doc = goog.global.document;\n      doc.write(\n          '<script type=\"text/javascript\" src=\"' + src + '\"></' + 'script>');\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n\n  /**\n   * Resolves dependencies based on the dependencies added using addDependency\n   * and calls importScript_ in the correct order.\n   * @private\n   */\n  goog.writeScripts_ = function() {\n    // the scripts we need to write this time\n    var scripts = [];\n    var seenScript = {};\n    var deps = goog.dependencies_;\n\n    function visitNode(path) {\n      if (path in deps.written) {\n        return;\n      }\n\n      // we have already visited this one. We can get here if we have cyclic\n      // dependencies\n      if (path in deps.visited) {\n        if (!(path in seenScript)) {\n          seenScript[path] = true;\n          scripts.push(path);\n        }\n        return;\n      }\n\n      deps.visited[path] = true;\n\n      if (path in deps.requires) {\n        for (var requireName in deps.requires[path]) {\n          // If the required name is defined, we assume that it was already\n          // bootstrapped by other means.\n          if (!goog.isProvided_(requireName)) {\n            if (requireName in deps.nameToPath) {\n              visitNode(deps.nameToPath[requireName]);\n            } else {\n              throw Error('Undefined nameToPath for ' + requireName);\n            }\n          }\n        }\n      }\n\n      if (!(path in seenScript)) {\n        seenScript[path] = true;\n        scripts.push(path);\n      }\n    }\n\n    for (var path in goog.included_) {\n      if (!deps.written[path]) {\n        visitNode(path);\n      }\n    }\n\n    for (var i = 0; i < scripts.length; i++) {\n      if (scripts[i]) {\n        goog.importScript_(goog.basePath + scripts[i]);\n      } else {\n        throw Error('Undefined script input');\n      }\n    }\n  };\n\n\n  /**\n   * Looks at the dependency rules and tries to determine the script file that\n   * fulfills a particular rule.\n   * @param {string} rule In the form goog.namespace.Class or project.script.\n   * @return {?string} Url corresponding to the rule, or null.\n   * @private\n   */\n  goog.getPathFromDeps_ = function(rule) {\n    if (rule in goog.dependencies_.nameToPath) {\n      return goog.dependencies_.nameToPath[rule];\n    } else {\n      return null;\n    }\n  };\n\n  goog.findBasePath_();\n\n  // Allow projects to manage the deps files themselves.\n  if (!goog.global.CLOSURE_NO_DEPS) {\n    goog.importScript_(goog.basePath + 'deps.js');\n  }\n}\n\n\n\n//==============================================================================\n// Language Enhancements\n//==============================================================================\n\n\n/**\n * This is a \"fixed\" version of the typeof operator.  It differs from the typeof\n * operator in such a way that null returns 'null' and arrays return 'array'.\n * @param {*} value The value to get the type of.\n * @return {string} The name of the type.\n */\ngoog.typeOf = function(value) {\n  var s = typeof value;\n  if (s == 'object') {\n    if (value) {\n      // Check these first, so we can avoid calling Object.prototype.toString if\n      // possible.\n      //\n      // IE improperly marshals tyepof across execution contexts, but a\n      // cross-context object will still return false for \"instanceof Object\".\n      if (value instanceof Array) {\n        return 'array';\n      } else if (value instanceof Object) {\n        return s;\n      }\n\n      // HACK: In order to use an Object prototype method on the arbitrary\n      //   value, the compiler requires the value be cast to type Object,\n      //   even though the ECMA spec explicitly allows it.\n      var className = Object.prototype.toString.call(\n          /** @type {Object} */ (value));\n      // In Firefox 3.6, attempting to access iframe window objects' length\n      // property throws an NS_ERROR_FAILURE, so we need to special-case it\n      // here.\n      if (className == '[object Window]') {\n        return 'object';\n      }\n\n      // We cannot always use constructor == Array or instanceof Array because\n      // different frames have different Array objects. In IE6, if the iframe\n      // where the array was created is destroyed, the array loses its\n      // prototype. Then dereferencing val.splice here throws an exception, so\n      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'\n      // so that will work. In this case, this function will return false and\n      // most array functions will still work because the array is still\n      // array-like (supports length and []) even though it has lost its\n      // prototype.\n      // Mark Miller noticed that Object.prototype.toString\n      // allows access to the unforgeable [[Class]] property.\n      //  15.2.4.2 Object.prototype.toString ( )\n      //  When the toString method is called, the following steps are taken:\n      //      1. Get the [[Class]] property of this object.\n      //      2. Compute a string value by concatenating the three strings\n      //         \"[object \", Result(1), and \"]\".\n      //      3. Return Result(2).\n      // and this behavior survives the destruction of the execution context.\n      if ((className == '[object Array]' ||\n           // In IE all non value types are wrapped as objects across window\n           // boundaries (not iframe though) so we have to do object detection\n           // for this edge case\n           typeof value.length == 'number' &&\n           typeof value.splice != 'undefined' &&\n           typeof value.propertyIsEnumerable != 'undefined' &&\n           !value.propertyIsEnumerable('splice')\n\n          )) {\n        return 'array';\n      }\n      // HACK: There is still an array case that fails.\n      //     function ArrayImpostor() {}\n      //     ArrayImpostor.prototype = [];\n      //     var impostor = new ArrayImpostor;\n      // this can be fixed by getting rid of the fast path\n      // (value instanceof Array) and solely relying on\n      // (value && Object.prototype.toString.vall(value) === '[object Array]')\n      // but that would require many more function calls and is not warranted\n      // unless closure code is receiving objects from untrusted sources.\n\n      // IE in cross-window calls does not correctly marshal the function type\n      // (it appears just as an object) so we cannot use just typeof val ==\n      // 'function'. However, if the object has a call property, it is a\n      // function.\n      if ((className == '[object Function]' ||\n          typeof value.call != 'undefined' &&\n          typeof value.propertyIsEnumerable != 'undefined' &&\n          !value.propertyIsEnumerable('call'))) {\n        return 'function';\n      }\n\n\n    } else {\n      return 'null';\n    }\n\n  } else if (s == 'function' && typeof value.call == 'undefined') {\n    // In Safari typeof nodeList returns 'function', and on Firefox\n    // typeof behaves similarly for HTML{Applet,Embed,Object}Elements\n    // and RegExps.  We would like to return object for those and we can\n    // detect an invalid function by making sure that the function\n    // object has a call method.\n    return 'object';\n  }\n  return s;\n};\n\n\n/**\n * Returns true if the specified value is not |undefined|.\n * WARNING: Do not use this to test if an object has a property. Use the in\n * operator instead.  Additionally, this function assumes that the global\n * undefined variable has not been redefined.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined.\n */\ngoog.isDef = function(val) {\n  return val !== undefined;\n};\n\n\n/**\n * Returns true if the specified value is |null|\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is null.\n */\ngoog.isNull = function(val) {\n  return val === null;\n};\n\n\n/**\n * Returns true if the specified value is defined and not null\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined and not null.\n */\ngoog.isDefAndNotNull = function(val) {\n  // Note that undefined == null.\n  return val != null;\n};\n\n\n/**\n * Returns true if the specified value is an array\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArray = function(val) {\n  return goog.typeOf(val) == 'array';\n};\n\n\n/**\n * Returns true if the object looks like an array. To qualify as array like\n * the value needs to be either a NodeList or an object with a Number length\n * property.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArrayLike = function(val) {\n  var type = goog.typeOf(val);\n  return type == 'array' || type == 'object' && typeof val.length == 'number';\n};\n\n\n/**\n * Returns true if the object looks like a Date. To qualify as Date-like\n * the value needs to be an object and have a getFullYear() function.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a like a Date.\n */\ngoog.isDateLike = function(val) {\n  return goog.isObject(val) && typeof val.getFullYear == 'function';\n};\n\n\n/**\n * Returns true if the specified value is a string\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a string.\n */\ngoog.isString = function(val) {\n  return typeof val == 'string';\n};\n\n\n/**\n * Returns true if the specified value is a boolean\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is boolean.\n */\ngoog.isBoolean = function(val) {\n  return typeof val == 'boolean';\n};\n\n\n/**\n * Returns true if the specified value is a number\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a number.\n */\ngoog.isNumber = function(val) {\n  return typeof val == 'number';\n};\n\n\n/**\n * Returns true if the specified value is a function\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a function.\n */\ngoog.isFunction = function(val) {\n  return goog.typeOf(val) == 'function';\n};\n\n\n/**\n * Returns true if the specified value is an object.  This includes arrays\n * and functions.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an object.\n */\ngoog.isObject = function(val) {\n  var type = typeof val;\n  return type == 'object' && val != null || type == 'function';\n  // return Object(val) === val also works, but is slower, especially if val is\n  // not an object.\n};\n\n\n/**\n * Gets a unique ID for an object. This mutates the object so that further\n * calls with the same object as a parameter returns the same value. The unique\n * ID is guaranteed to be unique across the current session amongst objects that\n * are passed into {@code getUid}. There is no guarantee that the ID is unique\n * or consistent across sessions. It is unsafe to generate unique ID for\n * function prototypes.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {number} The unique ID for the object.\n */\ngoog.getUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // In Opera window.hasOwnProperty exists but always returns false so we avoid\n  // using it. As a consequence the unique ID generated for BaseClass.prototype\n  // and SubClass.prototype will be the same.\n  return obj[goog.UID_PROPERTY_] ||\n      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n\n\n/**\n * Removes the unique ID from an object. This is useful if the object was\n * previously mutated using {@code goog.getUid} in which case the mutation is\n * undone.\n * @param {Object} obj The object to remove the unique ID field from.\n */\ngoog.removeUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // DOM nodes in IE are not instance of Object and throws exception\n  // for delete. Instead we try to use removeAttribute\n  if ('removeAttribute' in obj) {\n    obj.removeAttribute(goog.UID_PROPERTY_);\n  }\n  /** @preserveTry */\n  try {\n    delete obj[goog.UID_PROPERTY_];\n  } catch (ex) {\n  }\n};\n\n\n/**\n * Name for unique ID property. Initialized in a way to help avoid collisions\n * with other closure javascript on the same page.\n * @type {string}\n * @private\n */\ngoog.UID_PROPERTY_ = 'closure_uid_' +\n    Math.floor(Math.random() * 2147483648).toString(36);\n\n\n/**\n * Counter for UID.\n * @type {number}\n * @private\n */\ngoog.uidCounter_ = 0;\n\n\n/**\n * Adds a hash code field to an object. The hash code is unique for the\n * given object.\n * @param {Object} obj The object to get the hash code for.\n * @return {number} The hash code for the object.\n * @deprecated Use goog.getUid instead.\n */\ngoog.getHashCode = goog.getUid;\n\n\n/**\n * Removes the hash code field from an object.\n * @param {Object} obj The object to remove the field from.\n * @deprecated Use goog.removeUid instead.\n */\ngoog.removeHashCode = goog.removeUid;\n\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n *\n * WARNINGS:\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\n * refer to themselves will cause infinite recursion.\n *\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\n * UIDs created by <code>getUid</code> into cloned results.\n *\n * @param {*} obj The value to clone.\n * @return {*} A clone of the input value.\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n  var type = goog.typeOf(obj);\n  if (type == 'object' || type == 'array') {\n    if (obj.clone) {\n      return obj.clone();\n    }\n    var clone = type == 'array' ? [] : {};\n    for (var key in obj) {\n      clone[key] = goog.cloneObject(obj[key]);\n    }\n    return clone;\n  }\n\n  return obj;\n};\n\n\n/**\n * Forward declaration for the clone method. This is necessary until the\n * compiler can better support duck-typing constructs as used in\n * goog.cloneObject.\n *\n * TODO(brenneman): Remove once the JSCompiler can infer that the check for\n * proto.clone is safe in goog.cloneObject.\n *\n * @type {Function}\n */\nObject.prototype.clone;\n\n\n/**\n * A native implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n * @suppress {deprecated} The compiler thinks that Function.prototype.bind\n *     is deprecated because some people have declared a pure-JS version.\n *     Only the pure-JS version is truly deprecated.\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\n};\n\n\n/**\n * A pure-JS implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n  if (!fn) {\n    throw new Error();\n  }\n\n  if (arguments.length > 2) {\n    var boundArgs = Array.prototype.slice.call(arguments, 2);\n    return function() {\n      // Prepend the bound arguments to the current arguments.\n      var newArgs = Array.prototype.slice.call(arguments);\n      Array.prototype.unshift.apply(newArgs, boundArgs);\n      return fn.apply(selfObj, newArgs);\n    };\n\n  } else {\n    return function() {\n      return fn.apply(selfObj, arguments);\n    };\n  }\n};\n\n\n/**\n * Partially applies this function to a particular 'this object' and zero or\n * more arguments. The result is a new function with some arguments of the first\n * function pre-filled and the value of |this| 'pre-specified'.<br><br>\n *\n * Remaining arguments specified at call-time are appended to the pre-\n * specified ones.<br><br>\n *\n * Also see: {@link #partial}.<br><br>\n *\n * Usage:\n * <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');\n * barMethBound('arg3', 'arg4');</pre>\n *\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @suppress {deprecated} See above.\n */\ngoog.bind = function(fn, selfObj, var_args) {\n  // TODO(nicksantos): narrow the type signature.\n  if (Function.prototype.bind &&\n      // NOTE(nicksantos): Somebody pulled base.js into the default\n      // Chrome extension environment. This means that for Chrome extensions,\n      // they get the implementation of Function.prototype.bind that\n      // calls goog.bind instead of the native one. Even worse, we don't want\n      // to introduce a circular dependency between goog.bind and\n      // Function.prototype.bind, so we have to hack this to make sure it\n      // works correctly.\n      Function.prototype.bind.toString().indexOf('native code') != -1) {\n    goog.bind = goog.bindNative_;\n  } else {\n    goog.bind = goog.bindJs_;\n  }\n  return goog.bind.apply(null, arguments);\n};\n\n\n/**\n * Like bind(), except that a 'this object' is not required. Useful when the\n * target function is already bound.\n *\n * Usage:\n * var g = partial(f, arg1, arg2);\n * g(arg3, arg4);\n *\n * @param {Function} fn A function to partially apply.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to fn.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n */\ngoog.partial = function(fn, var_args) {\n  var args = Array.prototype.slice.call(arguments, 1);\n  return function() {\n    // Prepend the bound arguments to the current arguments.\n    var newArgs = Array.prototype.slice.call(arguments);\n    newArgs.unshift.apply(newArgs, args);\n    return fn.apply(this, newArgs);\n  };\n};\n\n\n/**\n * Copies all the members of a source object to a target object. This method\n * does not work on all browsers for all objects that contain keys such as\n * toString or hasOwnProperty. Use goog.object.extend for this purpose.\n * @param {Object} target Target.\n * @param {Object} source Source.\n */\ngoog.mixin = function(target, source) {\n  for (var x in source) {\n    target[x] = source[x];\n  }\n\n  // For IE7 or lower, the for-in-loop does not contain any properties that are\n  // not enumerable on the prototype object (for example, isPrototypeOf from\n  // Object.prototype) but also it will not include 'replace' on objects that\n  // extend String and change 'replace' (not that it is common for anyone to\n  // extend anything except Object).\n};\n\n\n/**\n * @return {number} An integer value representing the number of milliseconds\n *     between midnight, January 1, 1970 and the current time.\n */\ngoog.now = Date.now || (function() {\n  // Unary plus operator converts its operand to a number which in the case of\n  // a date is done by calling getTime().\n  return +new Date();\n});\n\n\n/**\n * Evals javascript in the global scope.  In IE this uses execScript, other\n * browsers use goog.global.eval. If goog.global.eval does not evaluate in the\n * global scope (for example, in Safari), appends a script tag instead.\n * Throws an exception if neither execScript or eval is defined.\n * @param {string} script JavaScript string.\n */\ngoog.globalEval = function(script) {\n  if (goog.global.execScript) {\n    goog.global.execScript(script, 'JavaScript');\n  } else if (goog.global.eval) {\n    // Test to see if eval works\n    if (goog.evalWorksForGlobals_ == null) {\n      goog.global.eval('var _et_ = 1;');\n      if (typeof goog.global['_et_'] != 'undefined') {\n        delete goog.global['_et_'];\n        goog.evalWorksForGlobals_ = true;\n      } else {\n        goog.evalWorksForGlobals_ = false;\n      }\n    }\n\n    if (goog.evalWorksForGlobals_) {\n      goog.global.eval(script);\n    } else {\n      var doc = goog.global.document;\n      var scriptElt = doc.createElement('script');\n      scriptElt.type = 'text/javascript';\n      scriptElt.defer = false;\n      // Note(user): can't use .innerHTML since \"t('<test>')\" will fail and\n      // .text doesn't work in Safari 2.  Therefore we append a text node.\n      scriptElt.appendChild(doc.createTextNode(script));\n      doc.body.appendChild(scriptElt);\n      doc.body.removeChild(scriptElt);\n    }\n  } else {\n    throw Error('goog.globalEval not available');\n  }\n};\n\n\n/**\n * Indicates whether or not we can call 'eval' directly to eval code in the\n * global scope. Set to a Boolean by the first call to goog.globalEval (which\n * empirically tests whether eval works for globals). @see goog.globalEval\n * @type {?boolean}\n * @private\n */\ngoog.evalWorksForGlobals_ = null;\n\n\n/**\n * Optional map of CSS class names to obfuscated names used with\n * goog.getCssName().\n * @type {Object|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMapping_;\n\n\n/**\n * Optional obfuscation style for CSS class names. Should be set to either\n * 'BY_WHOLE' or 'BY_PART' if defined.\n * @type {string|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMappingStyle_;\n\n\n/**\n * Handles strings that are intended to be used as CSS class names.\n *\n * This function works in tandem with @see goog.setCssNameMapping.\n *\n * Without any mapping set, the arguments are simple joined with a\n * hyphen and passed through unaltered.\n *\n * When there is a mapping, there are two possible styles in which\n * these mappings are used. In the BY_PART style, each part (i.e. in\n * between hyphens) of the passed in css name is rewritten according\n * to the map. In the BY_WHOLE style, the full css name is looked up in\n * the map directly. If a rewrite is not specified by the map, the\n * compiler will output a warning.\n *\n * When the mapping is passed to the compiler, it will replace calls\n * to goog.getCssName with the strings from the mapping, e.g.\n *     var x = goog.getCssName('foo');\n *     var y = goog.getCssName(this.baseClass, 'active');\n *  becomes:\n *     var x= 'foo';\n *     var y = this.baseClass + '-active';\n *\n * If one argument is passed it will be processed, if two are passed\n * only the modifier will be processed, as it is assumed the first\n * argument was generated as a result of calling goog.getCssName.\n *\n * @param {string} className The class name.\n * @param {string=} opt_modifier A modifier to be appended to the class name.\n * @return {string} The class name or the concatenation of the class name and\n *     the modifier.\n */\ngoog.getCssName = function(className, opt_modifier) {\n  var getMapping = function(cssName) {\n    return goog.cssNameMapping_[cssName] || cssName;\n  };\n\n  var renameByParts = function(cssName) {\n    // Remap all the parts individually.\n    var parts = cssName.split('-');\n    var mapped = [];\n    for (var i = 0; i < parts.length; i++) {\n      mapped.push(getMapping(parts[i]));\n    }\n    return mapped.join('-');\n  };\n\n  var rename;\n  if (goog.cssNameMapping_) {\n    rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?\n        getMapping : renameByParts;\n  } else {\n    rename = function(a) {\n      return a;\n    };\n  }\n\n  if (opt_modifier) {\n    return className + '-' + rename(opt_modifier);\n  } else {\n    return rename(className);\n  }\n};\n\n\n/**\n * Sets the map to check when returning a value from goog.getCssName(). Example:\n * <pre>\n * goog.setCssNameMapping({\n *   \"goog\": \"a\",\n *   \"disabled\": \"b\",\n * });\n *\n * var x = goog.getCssName('goog');\n * // The following evaluates to: \"a a-b\".\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\n * </pre>\n * When declared as a map of string literals to string literals, the JSCompiler\n * will replace all calls to goog.getCssName() using the supplied map if the\n * --closure_pass flag is set.\n *\n * @param {!Object} mapping A map of strings to strings where keys are possible\n *     arguments to goog.getCssName() and values are the corresponding values\n *     that should be returned.\n * @param {string=} opt_style The style of css name mapping. There are two valid\n *     options: 'BY_PART', and 'BY_WHOLE'.\n * @see goog.getCssName for a description.\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n  goog.cssNameMapping_ = mapping;\n  goog.cssNameMappingStyle_ = opt_style;\n};\n\n\n/**\n * To use CSS renaming in compiled mode, one of the input files should have a\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\n * mode, JavaScript code should be loaded before this base.js file that declares\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\n * are made in uncompiled mode.\n *\n * A hook for overriding the CSS name mapping.\n * @type {Object|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\n\n\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n  // This does not call goog.setCssNameMapping() because the JSCompiler\n  // requires that goog.setCssNameMapping() be called with an object literal.\n  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n\n\n/**\n * Abstract implementation of goog.getMsg for use with localized messages.\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {Object=} opt_values Map of place holder name to value.\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values) {\n  var values = opt_values || {};\n  for (var key in values) {\n    var value = ('' + values[key]).replace(/\\$/g, '$$$$');\n    str = str.replace(new RegExp('\\\\{\\\\$' + key + '\\\\}', 'gi'), value);\n  }\n  return str;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated,\n * unless they are exported in turn via this function or\n * goog.exportProperty\n *\n * <p>Also handy for making public items that are defined in anonymous\n * closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction',\n *                       Foo.staticFunction);\n *     public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n *                       Foo.prototype.myMethod);\n *     new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n */\ngoog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {\n  goog.exportPath_(publicPath, object, opt_objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n  object[publicName] = symbol;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * <pre>\n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { }\n *\n * function ChildClass(a, b, c) {\n *   goog.base(this, a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // works\n * </pre>\n *\n * In addition, a superclass' implementation of a method can be invoked\n * as follows:\n *\n * <pre>\n * ChildClass.prototype.foo = function(a) {\n *   ChildClass.superClass_.foo.call(this, a);\n *   // other code\n * };\n * </pre>\n *\n * @param {Function} childCtor Child class.\n * @param {Function} parentCtor Parent class.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n  /** @constructor */\n  function tempCtor() {};\n  tempCtor.prototype = parentCtor.prototype;\n  childCtor.superClass_ = parentCtor.prototype;\n  childCtor.prototype = new tempCtor();\n  childCtor.prototype.constructor = childCtor;\n};\n\n\n/**\n * Call up to the superclass.\n *\n * If this is called from a constructor, then this calls the superclass\n * contructor with arguments 1-N.\n *\n * If this is called from a prototype method, then you must pass\n * the name of the method as the second argument to this function. If\n * you do not, you will get a runtime error. This calls the superclass'\n * method with arguments 2-N.\n *\n * This function only works if you use goog.inherits to express\n * inheritance relationships between your classes.\n *\n * This function is a compiler primitive. At compile-time, the\n * compiler will do macro expansion to remove a lot of\n * the extra overhead that this function introduces. The compiler\n * will also enforce a lot of the assumptions that this function\n * makes, and treat it as a compiler error if you break them.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {*=} opt_methodName The method name if calling a super method.\n * @param {...*} var_args The rest of the arguments.\n * @return {*} The return value of the superclass method.\n */\ngoog.base = function(me, opt_methodName, var_args) {\n  var caller = arguments.callee.caller;\n  if (caller.superClass_) {\n    // This is a constructor. Call the superclass constructor.\n    return caller.superClass_.constructor.apply(\n        me, Array.prototype.slice.call(arguments, 1));\n  }\n\n  var args = Array.prototype.slice.call(arguments, 2);\n  var foundCaller = false;\n  for (var ctor = me.constructor;\n       ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {\n    if (ctor.prototype[opt_methodName] === caller) {\n      foundCaller = true;\n    } else if (foundCaller) {\n      return ctor.prototype[opt_methodName].apply(me, args);\n    }\n  }\n\n  // If we did not find the caller in the prototype chain,\n  // then one of two things happened:\n  // 1) The caller is an instance method.\n  // 2) This method was not called by the right caller.\n  if (me[opt_methodName] === caller) {\n    return me.constructor.prototype[opt_methodName].apply(me, args);\n  } else {\n    throw Error(\n        'goog.base called from a method of one name ' +\n        'to a method of a different name');\n  }\n};\n\n\n/**\n * Allow for aliasing within scope functions.  This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the\n * aliases applied.  In uncompiled code the function is simply run since the\n * aliases as written are valid JavaScript.\n * @param {function()} fn Function to call.  This function can contain aliases\n *     to namespaces (e.g. \"var dom = goog.dom\") or classes\n *    (e.g. \"var Timer = goog.Timer\").\n */\ngoog.scope = function(fn) {\n  fn.call(goog.global);\n};\n\n\n","/**\n * @fileoverview CRC32 実装.\n */\ngoog.provide('Zlib.CRC32');\n\ngoog.require('USE_TYPEDARRAY');\n\n/** @define {boolean} */\nvar ZLIB_CRC32_COMPACT = false;\n\ngoog.scope(function() {\n\n/**\n * CRC32 ハッシュ値を取得\n * @param {!(Array.<number>|Uint8Array)} data data byte array.\n * @param {number=} pos data position.\n * @param {number=} length data length.\n * @return {number} CRC32.\n */\nZlib.CRC32.calc = function(data, pos, length) {\n  return Zlib.CRC32.update(data, 0, pos, length);\n};\n\n/**\n * CRC32ハッシュ値を更新\n * @param {!(Array.<number>|Uint8Array)} data data byte array.\n * @param {number} crc CRC32.\n * @param {number=} pos data position.\n * @param {number=} length data length.\n * @return {number} CRC32.\n */\nZlib.CRC32.update = function(data, crc, pos, length) {\n  var table = Zlib.CRC32.Table;\n  var i = (typeof pos === 'number') ? pos : (pos = 0);\n  var il = (typeof length === 'number') ? length : data.length;\n\n  crc ^= 0xffffffff;\n\n  // loop unrolling for performance\n  for (i = il & 7; i--; ++pos) {\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos]) & 0xff];\n  }\n  for (i = il >> 3; i--; pos += 8) {\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos    ]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 1]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 2]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 3]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 4]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 5]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 6]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 7]) & 0xff];\n  }\n\n  return (crc ^ 0xffffffff) >>> 0;\n};\n\n/**\n * @param {number} num\n * @param {number} crc\n * @returns {number}\n */\nZlib.CRC32.single = function(num, crc) {\n  return (Zlib.CRC32.Table[(num ^ crc) & 0xff] ^ (num >>> 8)) >>> 0;\n};\n\n/**\n * @type {Array.<number>}\n * @const\n * @private\n */\nZlib.CRC32.Table_ = [\n  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,\n  0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,\n  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,\n  0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\n  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,\n  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,\n  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,\n  0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\n  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,\n  0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,\n  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,\n  0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\n  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,\n  0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,\n  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,\n  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\n  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,\n  0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,\n  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,\n  0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\n  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,\n  0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,\n  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,\n  0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\n  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,\n  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,\n  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,\n  0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\n  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,\n  0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,\n  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,\n  0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\n  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,\n  0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,\n  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,\n  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\n  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,\n  0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,\n  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,\n  0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\n  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,\n  0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,\n  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d\n];\n\n/**\n * @type {!(Array.<number>|Uint32Array)} CRC-32 Table.\n * @const\n */\nZlib.CRC32.Table = ZLIB_CRC32_COMPACT ? (function() {\n  /** @type {!(Array.<number>|Uint32Array)} */\n  var table = new (USE_TYPEDARRAY ? Uint32Array : Array)(256);\n  /** @type {number} */\n  var c;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var j;\n\n  for (i = 0; i < 256; ++i) {\n    c = i;\n    for (j = 0; j < 8; ++j) {\n      c = (c & 1) ? (0xedB88320 ^ (c >>> 1)) : (c >>> 1);\n    }\n    table[i] = c >>> 0;\n  }\n\n  return table;\n})() : USE_TYPEDARRAY ? new Uint32Array(Zlib.CRC32.Table_) : Zlib.CRC32.Table_;\n\n});\n","/**\n * defines\n */\n\ngoog.provide('USE_TYPEDARRAY');\n\n// Safari が typeof Uint8Array === 'object' になるため、\n// 未定義か否かで Typed Array の使用を決定する\n\n/** @const {boolean} use typed array flag. */\nvar USE_TYPEDARRAY =\n  (typeof Uint8Array !== 'undefined') &&\n  (typeof Uint16Array !== 'undefined') &&\n  (typeof Uint32Array !== 'undefined') &&\n  (typeof DataView !== 'undefined');\n","goog.require('Zlib.CRC32');\n\ngoog.exportSymbol('Zlib.CRC32', Zlib.CRC32);\ngoog.exportSymbol('Zlib.CRC32.calc', Zlib.CRC32.calc);\ngoog.exportSymbol('Zlib.CRC32.update', Zlib.CRC32.update);"]} \ No newline at end of file diff --git a/bin/crc32.min.js b/bin/crc32.min.js index 865e57e..a977cf1 100644 --- a/bin/crc32.min.js +++ b/bin/crc32.min.js @@ -4,4 +4,4 @@ 2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, 2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, 3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, -936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117]};l.a="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array?new Uint32Array(l.b):l.b;h("Zlib.CRC32",l);h("Zlib.CRC32.calc",l.c);h("Zlib.CRC32.update",l.update);}).call(this); //@ sourceMappingURL=crc32.min.js.map +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117]};l.a="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView?new Uint32Array(l.b):l.b;h("Zlib.CRC32",l);h("Zlib.CRC32.calc",l.c);h("Zlib.CRC32.update",l.update);}).call(this); diff --git a/bin/deflate.dev.min.js b/bin/deflate.dev.min.js new file mode 100644 index 0000000..f816b4d --- /dev/null +++ b/bin/deflate.dev.min.js @@ -0,0 +1,26 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var n=void 0,w=!0,aa=this;function ba(f,d){var c=f.split("."),e=aa;!(c[0]in e)&&e.execScript&&e.execScript("var "+c[0]);for(var b;c.length&&(b=c.shift());)!c.length&&d!==n?e[b]=d:e=e[b]?e[b]:e[b]={}};var C="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function K(f,d){this.index="number"===typeof d?d:0;this.e=0;this.buffer=f instanceof(C?Uint8Array:Array)?f:new (C?Uint8Array:Array)(32768);if(2*this.buffer.length<=this.index)throw Error("invalid index");this.buffer.length<=this.index&&ca(this)}function ca(f){var d=f.buffer,c,e=d.length,b=new (C?Uint8Array:Array)(e<<1);if(C)b.set(d);else for(c=0;c>>8&255]<<16|L[f>>>16&255]<<8|L[f>>>24&255])>>32-d:L[f]>>8-d);if(8>d+a)g=g<>d-m-1&1,8===++a&&(a=0,e[b++]=L[g],g=0,b===e.length&&(e=ca(this)));e[b]=g;this.buffer=e;this.e=a;this.index=b};K.prototype.finish=function(){var f=this.buffer,d=this.index,c;0M;++M){for(var N=M,S=N,ea=7,N=N>>>1;N;N>>>=1)S<<=1,S|=N&1,--ea;da[M]=(S<>>0}var L=da;function ia(f){this.buffer=new (C?Uint16Array:Array)(2*f);this.length=0}ia.prototype.getParent=function(f){return 2*((f-2)/4|0)};ia.prototype.push=function(f,d){var c,e,b=this.buffer,a;c=this.length;b[this.length++]=d;for(b[this.length++]=f;0b[e])a=b[c],b[c]=b[e],b[e]=a,a=b[c+1],b[c+1]=b[e+1],b[e+1]=a,c=e;else break;return this.length}; +ia.prototype.pop=function(){var f,d,c=this.buffer,e,b,a;d=c[0];f=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(a=0;;){b=2*a+2;if(b>=this.length)break;b+2c[b]&&(b+=2);if(c[b]>c[a])e=c[a],c[a]=c[b],c[b]=e,e=c[a+1],c[a+1]=c[b+1],c[b+1]=e;else break;a=b}return{index:f,value:d,length:this.length}};function ka(f,d){this.d=la;this.i=0;this.input=C&&f instanceof Array?new Uint8Array(f):f;this.c=0;d&&(d.lazy&&(this.i=d.lazy),"number"===typeof d.compressionType&&(this.d=d.compressionType),d.outputBuffer&&(this.a=C&&d.outputBuffer instanceof Array?new Uint8Array(d.outputBuffer):d.outputBuffer),"number"===typeof d.outputIndex&&(this.c=d.outputIndex));this.a||(this.a=new (C?Uint8Array:Array)(32768))}var la=2,na={NONE:0,h:1,g:la,n:3},T=[],U; +for(U=0;288>U;U++)switch(w){case 143>=U:T.push([U+48,8]);break;case 255>=U:T.push([U-144+400,9]);break;case 279>=U:T.push([U-256+0,7]);break;case 287>=U:T.push([U-280+192,8]);break;default:throw"invalid literal: "+U;} +ka.prototype.f=function(){var f,d,c,e,b=this.input;switch(this.d){case 0:c=0;for(e=b.length;c>>8&255;l[h++]=p&255;l[h++]=p>>>8&255;if(C)l.set(a,h),h+=a.length,l=l.subarray(0,h);else{t=0;for(u=a.length;tv)for(;0v?v:138,A>v-3&&A=A?(E[D++]=17,E[D++]=A-3,H[17]++):(E[D++]=18,E[D++]=A-11,H[18]++),v-=A;else if(E[D++]=F[r],H[F[r]]++,v--,3>v)for(;0v?v:6,A>v-3&&Ay;y++)ja[y]=ga[La[y]];for(Q=19;4=b:return[265,b-11,1];case 14>=b:return[266,b-13,1];case 16>=b:return[267,b-15,1];case 18>=b:return[268,b-17,1];case 22>=b:return[269,b-19,2];case 26>=b:return[270,b-23,2];case 30>=b:return[271,b-27,2];case 34>=b:return[272, +b-31,2];case 42>=b:return[273,b-35,3];case 50>=b:return[274,b-43,3];case 58>=b:return[275,b-51,3];case 66>=b:return[276,b-59,3];case 82>=b:return[277,b-67,4];case 98>=b:return[278,b-83,4];case 114>=b:return[279,b-99,4];case 130>=b:return[280,b-115,4];case 162>=b:return[281,b-131,5];case 194>=b:return[282,b-163,5];case 226>=b:return[283,b-195,5];case 257>=b:return[284,b-227,5];case 258===b:return[285,b-258,0];default:throw"invalid length: "+b;}}var d=[],c,e;for(c=3;258>=c;c++)e=f(c),d[c]=e[2]<<24| +e[1]<<16|e[0];return d}(),Ha=C?new Uint32Array(sa):sa; +function oa(f,d){function c(b,c){var a=b.k,d=[],e=0,f;f=Ha[b.length];d[e++]=f&65535;d[e++]=f>>16&255;d[e++]=f>>24;var g;switch(w){case 1===a:g=[0,a-1,0];break;case 2===a:g=[1,a-2,0];break;case 3===a:g=[2,a-3,0];break;case 4===a:g=[3,a-4,0];break;case 6>=a:g=[4,a-5,1];break;case 8>=a:g=[5,a-7,1];break;case 12>=a:g=[6,a-9,2];break;case 16>=a:g=[7,a-13,2];break;case 24>=a:g=[8,a-17,3];break;case 32>=a:g=[9,a-25,3];break;case 48>=a:g=[10,a-33,4];break;case 64>=a:g=[11,a-49,4];break;case 96>=a:g=[12,a- +65,5];break;case 128>=a:g=[13,a-97,5];break;case 192>=a:g=[14,a-129,6];break;case 256>=a:g=[15,a-193,6];break;case 384>=a:g=[16,a-257,7];break;case 512>=a:g=[17,a-385,7];break;case 768>=a:g=[18,a-513,8];break;case 1024>=a:g=[19,a-769,8];break;case 1536>=a:g=[20,a-1025,9];break;case 2048>=a:g=[21,a-1537,9];break;case 3072>=a:g=[22,a-2049,10];break;case 4096>=a:g=[23,a-3073,10];break;case 6144>=a:g=[24,a-4097,11];break;case 8192>=a:g=[25,a-6145,11];break;case 12288>=a:g=[26,a-8193,12];break;case 16384>= +a:g=[27,a-12289,12];break;case 24576>=a:g=[28,a-16385,13];break;case 32768>=a:g=[29,a-24577,13];break;default:throw"invalid distance";}f=g;d[e++]=f[0];d[e++]=f[1];d[e++]=f[2];var k,m;k=0;for(m=d.length;k=a;)s[a++]=0;for(a=0;29>=a;)x[a++]=0}s[256]=1;e=0;for(b=d.length;e=b){u&&c(u,-1);a=0;for(g=b-e;ag&&d+ga&&(b=e,a=g);if(258===g)break}return new ra(a,d-b)} +function pa(f,d){var c=f.length,e=new ia(572),b=new (C?Uint8Array:Array)(c),a,g,m,k,p;if(!C)for(k=0;k2*b[h-1]+a[h]&&(b[h]=2*b[h-1]+a[h]),m[h]=Array(b[h]),k[h]=Array(b[h]);for(l=0;lf[l]?(m[h][q]=s,k[h][q]=d,x+=2):(m[h][q]=f[l],k[h][q]=l,++l);p[h]=0;1===a[h]&&e(h)}return g} +function qa(f){var d=new (C?Uint16Array:Array)(f.length),c=[],e=[],b=0,a,g,m,k;a=0;for(g=f.length;a>>=1}return d};function Ka(f,d){this.input=f;this.a=new (C?Uint8Array:Array)(32768);this.d=V.g;var c={},e;if((d||!(d={}))&&"number"===typeof d.compressionType)this.d=d.compressionType;for(e in d)c[e]=d[e];c.outputBuffer=this.a;this.j=new ka(this.input,c)}var V=na; +Ka.prototype.f=function(){var f,d,c,e,b,a,g=0;a=this.a;switch(8){case 8:f=Math.LOG2E*Math.log(32768)-8;break;default:throw Error("invalid compression method");}d=f<<4|8;a[g++]=d;switch(8){case 8:switch(this.d){case V.NONE:e=0;break;case V.h:e=1;break;case V.g:e=2;break;default:throw Error("unsupported compression type");}break;default:throw Error("invalid compression method");}c=e<<6|0;a[g++]=c|31-(256*d+c)%31;var m=this.input;if("string"===typeof m){var k=m.split(""),p,t;p=0;for(t=k.length;p>>0;m=k}for(var u=1,l=0,h=m.length,q,s=0;0>>0;this.j.c=g;a=this.j.f();g=a.length;C&&(a=new Uint8Array(a.buffer),a.length<=g+4&&(this.a=new Uint8Array(a.length+4),this.a.set(a),a=this.a),a=a.subarray(0,g+4));a[g++]=b>>24&255;a[g++]=b>>16&255;a[g++]=b>>8&255;a[g++]=b&255;return a};ba("Zlib.Deflate",Ka);ba("Zlib.Deflate.compress",function(f,d){return(new Ka(f,d)).f()});ba("Zlib.Deflate.prototype.compress",Ka.prototype.f);var Ma={NONE:V.NONE,FIXED:V.h,DYNAMIC:V.g},Na,Oa,W,Pa;if(Object.keys)Na=Object.keys(Ma);else for(Oa in Na=[],W=0,Ma)Na[W++]=Oa;W=0;for(Pa=Na.length;Wf[l]?(m[h][q]=s,k[h][q]=d,x+=2):(m[h][q]=f[l],k[h][q]=l,++l);p[h]=0;1===a[h]&&e(h)}return g} function qa(f){var d=new (C?Uint16Array:Array)(f.length),c=[],e=[],b=0,a,g,m,k;a=0;for(g=f.length;a>>=1}return d};function Ka(f,d){this.input=f;this.a=new (C?Uint8Array:Array)(32768);this.d=V.g;var c={},e;if((d||!(d={}))&&"number"===typeof d.compressionType)this.d=d.compressionType;for(e in d)c[e]=d[e];c.outputBuffer=this.a;this.j=new ka(this.input,c)}var V=na; Ka.prototype.f=function(){var f,d,c,e,b,a,g=0;a=this.a;switch(8){case 8:f=Math.LOG2E*Math.log(32768)-8;break;default:throw Error("invalid compression method");}d=f<<4|8;a[g++]=d;switch(8){case 8:switch(this.d){case V.NONE:e=0;break;case V.h:e=1;break;case V.g:e=2;break;default:throw Error("unsupported compression type");}break;default:throw Error("invalid compression method");}c=e<<6|0;a[g++]=c|31-(256*d+c)%31;var m=this.input;if("string"===typeof m){var k=m.split(""),p,t;p=0;for(t=k.length;p>>0;m=k}for(var u=1,l=0,h=m.length,q,s=0;0>>0;this.j.c=g;a=this.j.f();g=a.length;C&&(a=new Uint8Array(a.buffer),a.length<=g+4&&(this.a=new Uint8Array(a.length+4),this.a.set(a),a=this.a),a=a.subarray(0,g+4));a[g++]=b>>24&255;a[g++]=b>>16&255;a[g++]=b>>8&255;a[g++]=b&255;return a};ba("Zlib.Deflate",Ka);ba("Zlib.Deflate.compress",function(f,d){return(new Ka(f,d)).f()});ba("Zlib.Deflate.prototype.compress",Ka.prototype.f);var Ma={NONE:V.NONE,FIXED:V.h,DYNAMIC:V.g},Na,Oa,W,Pa;if(Object.keys)Na=Object.keys(Ma);else for(Oa in Na=[],W=0,Ma)Na[W++]=Oa;W=0;for(Pa=Na.length;W>>0;m=k}for(var u=1,l=0,h=m.length,q,s=0;0>>0;this.j.c=g;a=this.j.f();g=a.length;C&&(a=new Uint8Array(a.buffer),a.length<=g+4&&(this.a=new Uint8Array(a.length+4),this.a.set(a),a=this.a),a=a.subarray(0,g+4));a[g++]=b>>24&255;a[g++]=b>>16&255;a[g++]=b>>8&255;a[g++]=b&255;return a};ba("Zlib.Deflate",Ka);ba("Zlib.Deflate.compress",function(f,d){return(new Ka(f,d)).f()});ba("Zlib.Deflate.prototype.compress",Ka.prototype.f);var Ma={NONE:V.NONE,FIXED:V.h,DYNAMIC:V.g},Na,Oa,W,Pa;if(Object.keys)Na=Object.keys(Ma);else for(Oa in Na=[],W=0,Ma)Na[W++]=Oa;W=0;for(Pa=Na.length;Wv;++v)for(var w=v,ba=7,w=w>>>1;w;w>>>=1)--ba;function x(e,c,d){var b,a="number"===typeof c?c:c=0,f="number"===typeof d?d:e.length;b=-1;for(a=f&7;a--;++c)b=b>>>8^z[(b^e[c])&255];for(a=f>>3;a--;c+=8)b=b>>>8^z[(b^e[c])&255],b=b>>>8^z[(b^e[c+1])&255],b=b>>>8^z[(b^e[c+2])&255],b=b>>>8^z[(b^e[c+3])&255],b=b>>>8^z[(b^e[c+4])&255],b=b>>>8^z[(b^e[c+5])&255],b=b>>>8^z[(b^e[c+6])&255],b=b>>>8^z[(b^e[c+7])&255];return(b^4294967295)>>>0} +var A=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],z=u?new Uint32Array(A):A;function B(){}B.prototype.getName=function(){return this.name};B.prototype.getData=function(){return this.data};B.prototype.H=function(){return this.I};function D(e){var c=e.length,d=0,b=Number.POSITIVE_INFINITY,a,f,g,k,m,p,t,h,l,y;for(h=0;hd&&(d=e[h]),e[h]>=1;y=g<<16|h;for(l=p;lF;F++)switch(!0){case 143>=F:E.push([F+48,8]);break;case 255>=F:E.push([F-144+400,9]);break;case 279>=F:E.push([F-256+0,7]);break;case 287>=F:E.push([F-280+192,8]);break;default:n("invalid literal: "+F)} +var ca=function(){function e(a){switch(!0){case 3===a:return[257,a-3,0];case 4===a:return[258,a-4,0];case 5===a:return[259,a-5,0];case 6===a:return[260,a-6,0];case 7===a:return[261,a-7,0];case 8===a:return[262,a-8,0];case 9===a:return[263,a-9,0];case 10===a:return[264,a-10,0];case 12>=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:n("invalid length: "+a)}}var c=[],d,b;for(d=3;258>=d;d++)b=e(d),c[d]=b[2]<<24|b[1]<< +16|b[0];return c}();u&&new Uint32Array(ca);function G(e,c){this.i=[];this.j=32768;this.d=this.f=this.c=this.n=0;this.input=u?new Uint8Array(e):e;this.o=!1;this.k=H;this.z=!1;if(c||!(c={}))c.index&&(this.c=c.index),c.bufferSize&&(this.j=c.bufferSize),c.bufferType&&(this.k=c.bufferType),c.resize&&(this.z=c.resize);switch(this.k){case I:this.a=32768;this.b=new (u?Uint8Array:Array)(32768+this.j+258);break;case H:this.a=0;this.b=new (u?Uint8Array:Array)(this.j);this.e=this.F;this.q=this.B;this.l=this.D;break;default:n(Error("invalid inflate mode"))}} +var I=0,H=1; +G.prototype.g=function(){for(;!this.o;){var e=J(this,3);e&1&&(this.o=!0);e>>>=1;switch(e){case 0:var c=this.input,d=this.c,b=this.b,a=this.a,f=c.length,g=q,k=q,m=b.length,p=q;this.d=this.f=0;d+1>=f&&n(Error("invalid uncompressed block header: LEN"));g=c[d++]|c[d++]<<8;d+1>=f&&n(Error("invalid uncompressed block header: NLEN"));k=c[d++]|c[d++]<<8;g===~k&&n(Error("invalid uncompressed block header: length verify"));d+g>c.length&&n(Error("input buffer is broken"));switch(this.k){case I:for(;a+g>b.length;){p= +m-a;g-=p;if(u)b.set(c.subarray(d,d+p),a),a+=p,d+=p;else for(;p--;)b[a++]=c[d++];this.a=a;b=this.e();a=this.a}break;case H:for(;a+g>b.length;)b=this.e({t:2});break;default:n(Error("invalid inflate mode"))}if(u)b.set(c.subarray(d,d+g),a),a+=g,d+=g;else for(;g--;)b[a++]=c[d++];this.c=d;this.a=a;this.b=b;break;case 1:this.l(da,ea);break;case 2:fa(this);break;default:n(Error("unknown BTYPE: "+e))}}return this.q()}; +var K=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],L=u?new Uint16Array(K):K,N=[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,258,258],O=u?new Uint16Array(N):N,P=[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,0,0],Q=u?new Uint8Array(P):P,R=[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],ga=u?new Uint16Array(R):R,ha=[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],U=u?new Uint8Array(ha):ha,V=new (u?Uint8Array:Array)(288),W,ia;W=0;for(ia=V.length;W=W?8:255>=W?9:279>=W?7:8;var da=D(V),X=new (u?Uint8Array:Array)(30),Y,ja;Y=0;for(ja=X.length;Y=g&&n(Error("input buffer is broken")),d|=a[f++]<>>c;e.d=b-c;e.c=f;return k} +function Z(e,c){for(var d=e.f,b=e.d,a=e.input,f=e.c,g=a.length,k=c[0],m=c[1],p,t;b=g);)d|=a[f++]<>>16;e.f=d>>t;e.d=b-t;e.c=f;return p&65535} +function fa(e){function c(a,c,b){var d,e=this.w,f,g;for(g=0;gf)b>=a&&(this.a=b,d=this.e(),b=this.a),d[b++]=f;else{g=f-257;m=O[g];0=a&&(this.a=b,d=this.e(),b=this.a);for(;m--;)d[b]=d[b++-k]}for(;8<=this.d;)this.d-=8,this.c--;this.a=b}; +G.prototype.D=function(e,c){var d=this.b,b=this.a;this.r=e;for(var a=d.length,f,g,k,m;256!==(f=Z(this,e));)if(256>f)b>=a&&(d=this.e(),a=d.length),d[b++]=f;else{g=f-257;m=O[g];0a&&(d=this.e(),a=d.length);for(;m--;)d[b]=d[b++-k]}for(;8<=this.d;)this.d-=8,this.c--;this.a=b}; +G.prototype.e=function(){var e=new (u?Uint8Array:Array)(this.a-32768),c=this.a-32768,d,b,a=this.b;if(u)e.set(a.subarray(32768,e.length));else{d=0;for(b=e.length;dd;++d)a[d]=a[c+d];this.a=32768;return a}; +G.prototype.F=function(e){var c,d=this.input.length/this.c+1|0,b,a,f,g=this.input,k=this.b;e&&("number"===typeof e.t&&(d=e.t),"number"===typeof e.A&&(d+=e.A));2>d?(b=(g.length-this.c)/this.r[2],f=258*(b/2)|0,a=fc&&(this.b.length=c),e=this.b);return this.buffer=e};function $(e){this.input=e;this.c=0;this.m=[];this.s=!1}$.prototype.G=function(){this.s||this.g();return this.m.slice()}; +$.prototype.g=function(){for(var e=this.input.length;this.c>>0;x(a,q,q)!==t&&n(Error("invalid CRC-32 checksum: 0x"+x(a,q,q).toString(16)+" / 0x"+t.toString(16)));c.M= +d=(h[l++]|h[l++]<<8|h[l++]<<16|h[l++]<<24)>>>0;(a.length&4294967295)!==d&&n(Error("invalid input size: "+(a.length&4294967295)+" / "+d));this.m.push(c);this.c=l}this.s=!0;var y=this.m,s,M,S=0,T=0,C;s=0;for(M=y.length;sd&&(d=e[h]),e[h]>=1;y=g<<16|h;for(l=p;lF;F++)switch(!0){case 143>=F:E.push([F+48,8]);break;case 255>=F:E.push([F-144+400,9]);break;case 279>=F:E.push([F-256+0,7]);break;case 287>=F:E.push([F-280+192,8]);break;default:n("invalid literal: "+F)} +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],z=u?new Uint32Array(A):A;function B(){}B.prototype.getName=function(){return this.name};B.prototype.getData=function(){return this.data};B.prototype.H=function(){return this.I};function D(e){var c=e.length,d=0,b=Number.POSITIVE_INFINITY,a,f,g,k,m,p,t,h,l,y;for(h=0;hd&&(d=e[h]),e[h]>=1;y=g<<16|h;for(l=p;lF;F++)switch(!0){case 143>=F:E.push([F+48,8]);break;case 255>=F:E.push([F-144+400,9]);break;case 279>=F:E.push([F-256+0,7]);break;case 287>=F:E.push([F-280+192,8]);break;default:n("invalid literal: "+F)} var ca=function(){function e(a){switch(!0){case 3===a:return[257,a-3,0];case 4===a:return[258,a-4,0];case 5===a:return[259,a-5,0];case 6===a:return[260,a-6,0];case 7===a:return[261,a-7,0];case 8===a:return[262,a-8,0];case 9===a:return[263,a-9,0];case 10===a:return[264,a-10,0];case 12>=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:n("invalid length: "+a)}}var c=[],d,b;for(d=3;258>=d;d++)b=e(d),c[d]=b[2]<<24|b[1]<< 16|b[0];return c}();u&&new Uint32Array(ca);function G(e,c){this.i=[];this.j=32768;this.d=this.f=this.c=this.n=0;this.input=u?new Uint8Array(e):e;this.o=!1;this.k=H;this.z=!1;if(c||!(c={}))c.index&&(this.c=c.index),c.bufferSize&&(this.j=c.bufferSize),c.bufferType&&(this.k=c.bufferType),c.resize&&(this.z=c.resize);switch(this.k){case I:this.a=32768;this.b=new (u?Uint8Array:Array)(32768+this.j+258);break;case H:this.a=0;this.b=new (u?Uint8Array:Array)(this.j);this.e=this.F;this.q=this.B;this.l=this.D;break;default:n(Error("invalid inflate mode"))}} @@ -23,4 +23,4 @@ G.prototype.q=function(){var e=0,c=this.b,d=this.i,b,a=new (u?Uint8Array:Array)( G.prototype.B=function(){var e,c=this.a;u?this.z?(e=new Uint8Array(c),e.set(this.b.subarray(0,c))):e=this.b.subarray(0,c):(this.b.length>c&&(this.b.length=c),e=this.b);return this.buffer=e};function $(e){this.input=e;this.c=0;this.m=[];this.s=!1}$.prototype.G=function(){this.s||this.g();return this.m.slice()}; $.prototype.g=function(){for(var e=this.input.length;this.c>>0;x(a,q,q)!==t&&n(Error("invalid CRC-32 checksum: 0x"+x(a,q,q).toString(16)+" / 0x"+t.toString(16)));c.M= -d=(h[l++]|h[l++]<<8|h[l++]<<16|h[l++]<<24)>>>0;(a.length&4294967295)!==d&&n(Error("invalid input size: "+(a.length&4294967295)+" / "+d));this.m.push(c);this.c=l}this.s=!0;var y=this.m,s,M,S=0,T=0,C;s=0;for(M=y.length;s>>0;(a.length&4294967295)!==d&&n(Error("invalid input size: "+(a.length&4294967295)+" / "+d));this.m.push(c);this.c=l}this.s=!0;var y=this.m,s,M,S=0,T=0,C;s=0;for(M=y.length;s>>8&255]<<16|H[f>>>16&255]<<8|H[f>>>24&255])>>32-e:H[f]>>8-e);if(8>e+g)l=l<>e-m-1&1,8===++g&&(g=0,a[b++]=H[l],l=0,b===a.length&&(a=ga(this)));a[b]=l;this.buffer=a;this.f=g;this.index=b};F.prototype.finish=function(){var f=this.buffer,e=this.index,c;0M;++M){for(var N=M,S=N,ja=7,N=N>>>1;N;N>>>=1)S<<=1,S|=N&1,--ja;ia[M]=(S<>>0}var H=ia;function ka(f,e,c){var a,b="number"===typeof e?e:e=0,g="number"===typeof c?c:f.length;a=-1;for(b=g&7;b--;++e)a=a>>>8^T[(a^f[e])&255];for(b=g>>3;b--;e+=8)a=a>>>8^T[(a^f[e])&255],a=a>>>8^T[(a^f[e+1])&255],a=a>>>8^T[(a^f[e+2])&255],a=a>>>8^T[(a^f[e+3])&255],a=a>>>8^T[(a^f[e+4])&255],a=a>>>8^T[(a^f[e+5])&255],a=a>>>8^T[(a^f[e+6])&255],a=a>>>8^T[(a^f[e+7])&255];return(a^4294967295)>>>0} +var la=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],T=C?new Uint32Array(la):la;function U(f){this.buffer=new (C?Uint16Array:Array)(2*f);this.length=0}U.prototype.getParent=function(f){return 2*((f-2)/4|0)};U.prototype.push=function(f,e){var c,a,b=this.buffer,g;c=this.length;b[this.length++]=e;for(b[this.length++]=f;0b[a])g=b[c],b[c]=b[a],b[a]=g,g=b[c+1],b[c+1]=b[a+1],b[a+1]=g,c=a;else break;return this.length}; +U.prototype.pop=function(){var f,e,c=this.buffer,a,b,g;e=c[0];f=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(g=0;;){b=2*g+2;if(b>=this.length)break;b+2c[b]&&(b+=2);if(c[b]>c[g])a=c[g],c[g]=c[b],c[b]=a,a=c[g+1],c[g+1]=c[b+1],c[b+1]=a;else break;g=b}return{index:f,value:e,length:this.length}};function ma(f,e){this.h=na;this.j=0;this.input=C&&f instanceof Array?new Uint8Array(f):f;this.c=0;e&&(e.lazy&&(this.j=e.lazy),"number"===typeof e.compressionType&&(this.h=e.compressionType),e.outputBuffer&&(this.a=C&&e.outputBuffer instanceof Array?new Uint8Array(e.outputBuffer):e.outputBuffer),"number"===typeof e.outputIndex&&(this.c=e.outputIndex));this.a||(this.a=new (C?Uint8Array:Array)(32768))}var na=2,V=[],$; +for($=0;288>$;$++)switch(v){case 143>=$:V.push([$+48,8]);break;case 255>=$:V.push([$-144+400,9]);break;case 279>=$:V.push([$-256+0,7]);break;case 287>=$:V.push([$-280+192,8]);break;default:throw"invalid literal: "+$;} +ma.prototype.g=function(){var f,e,c,a,b=this.input;switch(this.h){case 0:c=0;for(a=b.length;c>>8&255;n[k++]=h&255;n[k++]=h>>>8&255;if(C)n.set(g,k),k+=g.length,n=n.subarray(0,k);else{s=0;for(x=g.length;st)for(;0t?t:138,A>t-3&&A=A?(E[D++]=17,E[D++]=A-3,J[17]++):(E[D++]=18,E[D++]=A-11,J[18]++),t-=A;else if(E[D++]=G[r],J[G[r]]++,t--,3>t)for(;0t?t:6,A>t-3&&Ay;y++)ea[y]=ba[Ha[y]];for(Q=19;4=b:return[265,b-11,1];case 14>=b:return[266,b-13,1];case 16>=b:return[267,b-15,1];case 18>=b:return[268,b-17,1];case 22>=b:return[269,b-19,2];case 26>=b:return[270,b-23,2];case 30>=b:return[271,b-27,2];case 34>=b:return[272, +b-31,2];case 42>=b:return[273,b-35,3];case 50>=b:return[274,b-43,3];case 58>=b:return[275,b-51,3];case 66>=b:return[276,b-59,3];case 82>=b:return[277,b-67,4];case 98>=b:return[278,b-83,4];case 114>=b:return[279,b-99,4];case 130>=b:return[280,b-115,4];case 162>=b:return[281,b-131,5];case 194>=b:return[282,b-163,5];case 226>=b:return[283,b-195,5];case 257>=b:return[284,b-227,5];case 258===b:return[285,b-258,0];default:throw"invalid length: "+b;}}var e=[],c,a;for(c=3;258>=c;c++)a=f(c),e[c]=a[2]<<24| +a[1]<<16|a[0];return e}(),Ia=C?new Uint32Array(Ga):Ga; +function oa(f,e){function c(b,e){var a=b.k,c=[],g=0,f;f=Ia[b.length];c[g++]=f&65535;c[g++]=f>>16&255;c[g++]=f>>24;var d;switch(v){case 1===a:d=[0,a-1,0];break;case 2===a:d=[1,a-2,0];break;case 3===a:d=[2,a-3,0];break;case 4===a:d=[3,a-4,0];break;case 6>=a:d=[4,a-5,1];break;case 8>=a:d=[5,a-7,1];break;case 12>=a:d=[6,a-9,2];break;case 16>=a:d=[7,a-13,2];break;case 24>=a:d=[8,a-17,3];break;case 32>=a:d=[9,a-25,3];break;case 48>=a:d=[10,a-33,4];break;case 64>=a:d=[11,a-49,4];break;case 96>=a:d=[12,a- +65,5];break;case 128>=a:d=[13,a-97,5];break;case 192>=a:d=[14,a-129,6];break;case 256>=a:d=[15,a-193,6];break;case 384>=a:d=[16,a-257,7];break;case 512>=a:d=[17,a-385,7];break;case 768>=a:d=[18,a-513,8];break;case 1024>=a:d=[19,a-769,8];break;case 1536>=a:d=[20,a-1025,9];break;case 2048>=a:d=[21,a-1537,9];break;case 3072>=a:d=[22,a-2049,10];break;case 4096>=a:d=[23,a-3073,10];break;case 6144>=a:d=[24,a-4097,11];break;case 8192>=a:d=[25,a-6145,11];break;case 12288>=a:d=[26,a-8193,12];break;case 16384>= +a:d=[27,a-12289,12];break;case 24576>=a:d=[28,a-16385,13];break;case 32768>=a:d=[29,a-24577,13];break;default:throw"invalid distance";}f=d;c[g++]=f[0];c[g++]=f[1];c[g++]=f[2];var h,l;h=0;for(l=c.length;h=g;)u[g++]=0;for(g=0;29>=g;)w[g++]=0}u[256]=1;a=0;for(b=e.length;a=b){x&&c(x,-1);g=0;for(l=b-a;gl&&e+lg&&(b=a,g=l);if(258===l)break}return new Fa(g,e-b)} +function pa(f,e){var c=f.length,a=new U(572),b=new (C?Uint8Array:Array)(c),g,l,m,d,h;if(!C)for(d=0;d2*b[k-1]+g[k]&&(b[k]=2*b[k-1]+g[k]),m[k]=Array(b[k]),d[k]=Array(b[k]);for(n=0;nf[n]?(m[k][q]=u,d[k][q]=e,w+=2):(m[k][q]=f[n],d[k][q]=n,++n);h[k]=0;1===g[k]&&a(k)}return l} +function qa(f){var e=new (C?Uint16Array:Array)(f.length),c=[],a=[],b=0,g,l,m,d;g=0;for(l=f.length;g>>=1}return e};function La(f,e){this.input=f;this.c=this.i=0;this.d={};e&&(e.flags&&(this.d=e.flags),"string"===typeof e.filename&&(this.filename=e.filename),"string"===typeof e.comment&&(this.l=e.comment),e.deflateOptions&&(this.e=e.deflateOptions));this.e||(this.e={})} +La.prototype.g=function(){var f,e,c,a,b,g,l,m,d=new (C?Uint8Array:Array)(32768),h=0,s=this.input,x=this.i,n=this.filename,k=this.l;d[h++]=31;d[h++]=139;d[h++]=8;f=0;this.d.fname&&(f|=Ma);this.d.fcomment&&(f|=Na);this.d.fhcrc&&(f|=Oa);d[h++]=f;e=(Date.now?Date.now():+new Date)/1E3|0;d[h++]=e&255;d[h++]=e>>>8&255;d[h++]=e>>>16&255;d[h++]=e>>>24&255;d[h++]=0;d[h++]=Pa;if(this.d.fname!==p){l=0;for(m=n.length;l>>8&255),d[h++]=g&255;d[h++]=0}if(this.d.comment){l= +0;for(m=k.length;l>>8&255),d[h++]=g&255;d[h++]=0}this.d.fhcrc&&(c=ka(d,0,h)&65535,d[h++]=c&255,d[h++]=c>>>8&255);this.e.outputBuffer=d;this.e.outputIndex=h;b=new ma(s,this.e);d=b.g();h=b.c;C&&(h+8>d.buffer.byteLength?(this.a=new Uint8Array(h+8),this.a.set(new Uint8Array(d.buffer)),d=this.a):d=new Uint8Array(d.buffer));a=ka(s,p,p);d[h++]=a&255;d[h++]=a>>>8&255;d[h++]=a>>>16&255;d[h++]=a>>>24&255;m=s.length;d[h++]=m&255;d[h++]=m>>>8&255;d[h++]=m>>>16&255;d[h++]= +m>>>24&255;this.i=x;C&&h>>8&255]<<16|H[f>>>16&255]<<8|H[f>>>24&255])>>32-e:H[f]>>8-e);if(8>e+g)l=l<>e-m-1&1,8===++g&&(g=0,a[b++]=H[l],l=0,b===a.length&&(a=ga(this)));a[b]=l;this.buffer=a;this.f=g;this.index=b};F.prototype.finish=function(){var f=this.buffer,e=this.index,c;0M;++M){for(var N=M,S=N,ja=7,N=N>>>1;N;N>>>=1)S<<=1,S|=N&1,--ja;ia[M]=(S<>>0}var H=ia;function ka(f,e,c){var a,b="number"===typeof e?e:e=0,g="number"===typeof c?c:f.length;a=-1;for(b=g&7;b--;++e)a=a>>>8^T[(a^f[e])&255];for(b=g>>3;b--;e+=8)a=a>>>8^T[(a^f[e])&255],a=a>>>8^T[(a^f[e+1])&255],a=a>>>8^T[(a^f[e+2])&255],a=a>>>8^T[(a^f[e+3])&255],a=a>>>8^T[(a^f[e+4])&255],a=a>>>8^T[(a^f[e+5])&255],a=a>>>8^T[(a^f[e+6])&255],a=a>>>8^T[(a^f[e+7])&255];return(a^4294967295)>>>0} var la=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, diff --git a/bin/gzip.min.js.map b/bin/gzip.min.js.map deleted file mode 100644 index c276e5c..0000000 --- a/bin/gzip.min.js.map +++ /dev/null @@ -1,8 +0,0 @@ -{ -"version":3, -"file":"./gzip.min.js", -"lineCount":32, -"mappings":"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", -"sources":["../closure-primitives/base.js","../define/typedarray/hybrid.js","../src/bitstream.js","../src/crc32.js","../src/heap.js","../src/rawdeflate.js","../src/gzip.js","../export/gzip.js"], -"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","JSCompiler_alias_VOID","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.BitStream","buffer","bufferPosition","index","bitindex","Array","Zlib.BitStream.DefaultBlockSize","Error","expandBuffer","Zlib.BitStream.prototype.expandBuffer","oldbuf","i","il","set","prototype","writeBits","Zlib.BitStream.prototype.writeBits","number","n","reverse","current","Zlib.BitStream.ReverseTable","finish","Zlib.BitStream.prototype.finish","output","subarray","table","r","s","Zlib.CRC32.update","data","pos","crc","Zlib.CRC32.Table","Zlib.CRC32.Table_","Zlib.Heap","getParent","Zlib.Heap.prototype.getParent","push","Zlib.Heap.prototype.push","value","parent","heap","swap","pop","Zlib.Heap.prototype.pop","Zlib.RawDeflate","input","opt_params","compressionType","Zlib.RawDeflate.CompressionType.DYNAMIC","lazy","op","DYNAMIC","JSCompiler_alias_TRUE","compress","Zlib.RawDeflate.prototype.compress","blockArray","position","NONE","slice","bfinal","len","nlen","makeNocompressBlock","isFinalBlock","FIXED","stream","makeFixedHuffmanBlock","lz77","literal","dataArray","apply","makeDynamicHuffmanBlock","btype","hlit","hdist","hclen","hclenOrder","litLenLengths","litLenCodes","distLengths","distCodes","treeLengths","transLengths","treeCodes","code","bitlen","getLengths_","freqsLitLen","getCodesFromLengths_","freqsDist","src","j","runLength","l","result","nResult","rpt","freqs","codes","litLen","dist","Zlib.RawDeflate.Lz77Match","backwardDistance","c","Zlib.RawDeflate.Lz77Match.LengthCodeTable","Zlib.RawDeflate.prototype.lz77","writeMatch","match","offset","codeArray","lz77buf","skipLength","prevMatch","matchKey","matchList","longestMatch","tmp","Zlib.RawDeflate.Lz77MinLength","Zlib.RawDeflate.WindowSize","searchLongestMatch_","Zlib.RawDeflate.prototype.searchLongestMatch_","currentMatch","matchMax","matchLength","dl","Zlib.RawDeflate.Lz77MaxLength","Zlib.RawDeflate.prototype.getLengths_","limit","nSymbols","nodes","values","codeLength","reversePackageMerge_","Zlib.RawDeflate.prototype.reversePackageMerge_","symbols","takePackage","x","type","currentPosition","minimumCost","flag","excess","half","t","weight","next","Zlib.RawDeflate.prototype.getCodesFromLengths_","lengths","count","startCode","m","Zlib.RawDeflate.MaxCodeLength","Zlib.Gzip","ip","flags","filename","comment","deflateOptions","Zlib.Gzip.prototype.compress","flg","mtime","crc16","crc32","rawdeflate","Zlib.Gzip.DefaultBufferSize","Zlib.Gzip.FlagsMask.FNAME","Zlib.Gzip.FlagsMask.FCOMMENT","Zlib.Gzip.FlagsMask.FHCRC","Date","now","Zlib.Gzip.OperatingSystem.UNKNOWN","charCodeAt","byteLength","UNKNOWN","FHCRC","FNAME","FCOMMENT","publicPath"] -} diff --git a/bin/inflate.dev.min.js b/bin/inflate.dev.min.js new file mode 100644 index 0000000..3a310ea --- /dev/null +++ b/bin/inflate.dev.min.js @@ -0,0 +1,16 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var m=this;function q(c,d){var a=c.split("."),b=m;!(a[0]in b)&&b.execScript&&b.execScript("var "+a[0]);for(var e;a.length&&(e=a.shift());)!a.length&&void 0!==d?b[e]=d:b=b[e]?b[e]:b[e]={}};var s="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function t(c){var d=c.length,a=0,b=Number.POSITIVE_INFINITY,e,f,g,h,k,l,p,n,r,K;for(n=0;na&&(a=c[n]),c[n]>=1;K=g<<16|n;for(r=l;r>>=1;switch(c){case 0:var d=this.input,a=this.a,b=this.c,e=this.b,f=d.length,g=void 0,h=void 0,k=b.length,l=void 0;this.d=this.f=0;if(a+1>=f)throw Error("invalid uncompressed block header: LEN");g=d[a++]|d[a++]<<8;if(a+1>=f)throw Error("invalid uncompressed block header: NLEN");h=d[a++]|d[a++]<<8;if(g===~h)throw Error("invalid uncompressed block header: length verify");if(a+g>d.length)throw Error("input buffer is broken");switch(this.i){case w:for(;e+ +g>b.length;){l=k-e;g-=l;if(s)b.set(d.subarray(a,a+l),e),e+=l,a+=l;else for(;l--;)b[e++]=d[a++];this.b=e;b=this.e();e=this.b}break;case v:for(;e+g>b.length;)b=this.e({p:2});break;default:throw Error("invalid inflate mode");}if(s)b.set(d.subarray(a,a+g),e),e+=g,a+=g;else for(;g--;)b[e++]=d[a++];this.a=a;this.b=e;this.c=b;break;case 1:this.j(z,A);break;case 2:B(this);break;default:throw Error("unknown BTYPE: "+c);}}return this.n()}; +var C=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],D=s?new Uint16Array(C):C,E=[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,258,258],F=s?new Uint16Array(E):E,G=[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,0,0],H=s?new Uint8Array(G):G,I=[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],J=s?new Uint16Array(I):I,L=[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],M=s?new Uint8Array(L):L,N=new (s?Uint8Array:Array)(288),O,P;O=0;for(P=N.length;O=O?8:255>=O?9:279>=O?7:8;var z=t(N),Q=new (s?Uint8Array:Array)(30),R,S;R=0;for(S=Q.length;R=g)throw Error("input buffer is broken");a|=e[f++]<>>d;c.d=b-d;c.a=f;return h} +function T(c,d){for(var a=c.f,b=c.d,e=c.input,f=c.a,g=e.length,h=d[0],k=d[1],l,p;b=g);)a|=e[f++]<>>16;c.f=a>>p;c.d=b-p;c.a=f;return l&65535} +function B(c){function d(a,c,b){var d,e=this.q,f,g;for(g=0;gf)b>=e&&(this.b=b,a=this.e(),b=this.b),a[b++]=f;else{g=f-257;k=F[g];0=e&&(this.b=b,a=this.e(),b=this.b);for(;k--;)a[b]=a[b++-h]}for(;8<=this.d;)this.d-=8,this.a--;this.b=b}; +u.prototype.z=function(c,d){var a=this.c,b=this.b;this.o=c;for(var e=a.length,f,g,h,k;256!==(f=T(this,c));)if(256>f)b>=e&&(a=this.e(),e=a.length),a[b++]=f;else{g=f-257;k=F[g];0e&&(a=this.e(),e=a.length);for(;k--;)a[b]=a[b++-h]}for(;8<=this.d;)this.d-=8,this.a--;this.b=b}; +u.prototype.e=function(){var c=new (s?Uint8Array:Array)(this.b-32768),d=this.b-32768,a,b,e=this.c;if(s)c.set(e.subarray(32768,c.length));else{a=0;for(b=c.length;aa;++a)e[a]=e[d+a];this.b=32768;return e}; +u.prototype.A=function(c){var d,a=this.input.length/this.a+1|0,b,e,f,g=this.input,h=this.c;c&&("number"===typeof c.p&&(a=c.p),"number"===typeof c.v&&(a+=c.v));2>a?(b=(g.length-this.a)/this.o[2],f=258*(b/2)|0,e=fd&&(this.c.length=d),c=this.c);return this.buffer=c};function U(c,d){var a,b;this.input=c;this.a=0;if(d||!(d={}))d.index&&(this.a=d.index),d.verify&&(this.B=d.verify);a=c[this.a++];b=c[this.a++];switch(a&15){case V:this.method=V;break;default:throw Error("unsupported compression method");}if(0!==((a<<8)+b)%31)throw Error("invalid fcheck flag:"+((a<<8)+b)%31);if(b&32)throw Error("fdict flag is not supported");this.r=new u(c,{index:this.a,bufferSize:d.bufferSize,bufferType:d.bufferType,resize:d.resize})} +U.prototype.k=function(){var c=this.input,d,a;d=this.r.k();this.a=this.r.a;if(this.B){a=(c[this.a++]<<24|c[this.a++]<<16|c[this.a++]<<8|c[this.a++])>>>0;var b=d;if("string"===typeof b){var e=b.split(""),f,g;f=0;for(g=e.length;f>>0;b=e}for(var h=1,k=0,l=b.length,p,n=0;0>>0)throw Error("invalid adler-32 checksum");}return d};var V=8;q("Zlib.Inflate",U);q("Zlib.Inflate.prototype.decompress",U.prototype.k);var W={ADAPTIVE:x.t,BLOCK:x.u},X,Y,Z,$;if(Object.keys)X=Object.keys(W);else for(Y in X=[],Z=0,W)X[Z++]=Y;Z=0;for($=X.length;Z<$;++Z)Y=X[Z],q("Zlib.Inflate.BufferType."+Y,W[Y]);}).call(this); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin/inflate.min.js","lineCount":15,"mappings":"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","sources":["closure-primitives/base.js","define/typedarray/hybrid.js","src/huffman.js","src/rawinflate.js","src/inflate.js","src/adler32.js","src/util.js","src/zlib.js","export/inflate.js","src/export_object.js"],"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","undefined","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","i","j","value","Array","Zlib.RawInflate","input","opt_params","blocks","bufferSize","ZLIB_RAW_INFLATE_BUFFER_SIZE","bitsbuflen","bitsbuf","ip","totalpos","bfinal","bufferType","Zlib.RawInflate.BufferType.ADAPTIVE","resize","Zlib.RawInflate.BufferType.BLOCK","op","Zlib.RawInflate.MaxBackwardLength","output","Zlib.RawInflate.MaxCopyLength","expandBuffer","expandBufferAdaptive","concatBuffer","concatBufferDynamic","decodeHuffman","decodeHuffmanAdaptive","Error","BLOCK","ADAPTIVE","Zlib.RawInflate.BufferType","prototype","decompress","Zlib.RawInflate.prototype.decompress","hdr","readBits","parseBlock","inputLength","len","nlen","olength","preCopy","set","subarray","Zlib.RawInflate.FixedLiteralLengthTable","Zlib.RawInflate.FixedDistanceTable","parseDynamicHuffmanBlock","Zlib.RawInflate.Order","Zlib.RawInflate.LengthCodeTable","Zlib.RawInflate.LengthExtraTable","Zlib.RawInflate.DistCodeTable","Zlib.RawInflate.DistExtraTable","il","Zlib.RawInflate.prototype.readBits","octet","Zlib.RawInflate.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflate.prototype.parseDynamicHuffmanBlock","decode","num","prev","repeat","readCodeByTable","hlit","hdist","hclen","codeLengths","Zlib.RawInflate.Order.length","codeLengthsTable","litlenLengths","distLengths","call","Zlib.RawInflate.prototype.decodeHuffman","litlen","dist","currentLitlenTable","ti","codeDist","Zlib.RawInflate.prototype.decodeHuffmanAdaptive","Zlib.RawInflate.prototype.expandBuffer","buffer","backward","push","Zlib.RawInflate.prototype.expandBufferAdaptive","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","Zlib.RawInflate.prototype.concatBuffer","pos","block","jl","slice","Zlib.RawInflate.prototype.concatBufferDynamic","Zlib.Inflate","cmf","flg","verify","Zlib.CompressionMethod.DEFLATE","method","rawinflate","Zlib.Inflate.prototype.decompress","adler32","array","tmp","charCodeAt","s1","s2","tlen","Zlib.Adler32.OptimizationParameter","DEFLATE","publicPath","keys","key","Object","exportKeyValue","object"],"sourcesContent":["// Copyright 2006 The Closure Library Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/**\n * @fileoverview Bootstrap for the Google JS Library (Closure).\n *\n * In uncompiled mode base.js will write out Closure's deps file, unless the\n * global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to\n * include their own deps file(s) from different locations.\n *\n */\n\n\n/**\n * @define {boolean} Overridden to true by the compiler when --closure_pass\n *     or --mark_as_compiled is specified.\n */\nvar COMPILED = false;\n\n\n/**\n * Base namespace for the Closure library.  Checks to see goog is\n * already defined in the current scope before assigning to prevent\n * clobbering if base.js is loaded more than once.\n *\n * @const\n */\nvar goog = goog || {}; // Identifies this file as the Closure base.\n\n\n/**\n * Reference to the global context.  In most cases this will be 'window'.\n */\ngoog.global = this;\n\n\n/**\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\n * that should not be included in a production js_binary can be easily stripped\n * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most\n * toString() methods should be declared inside an \"if (goog.DEBUG)\" conditional\n * because they are generally used for debugging purposes and it is difficult\n * for the JSCompiler to statically determine whether they are used.\n */\ngoog.DEBUG = true;\n\n\n/**\n * @define {string} LOCALE defines the locale being used for compilation. It is\n * used to select locale specific data to be compiled in js binary. BUILD rule\n * can specify this value by \"--define goog.LOCALE=<locale_name>\" as JSCompiler\n * option.\n *\n * Take into account that the locale code format is important. You should use\n * the canonical Unicode format with hyphen as a delimiter. Language must be\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\n *\n * See more info about locale codes here:\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\n *\n * For language codes you should use values defined by ISO 693-1. See it here\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\n * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.\n */\ngoog.LOCALE = 'en';  // default to en\n\n\n/**\n * Creates object stubs for a namespace.  The presence of one or more\n * goog.provide() calls indicate that the file defines the given\n * objects/namespaces.  Build tools also scan for provide/require statements\n * to discern dependencies, build dependency files (see deps.js), etc.\n * @see goog.require\n * @param {string} name Namespace provided by this file in the form\n *     \"goog.package.part\".\n */\ngoog.provide = function(name) {\n  if (!COMPILED) {\n    // Ensure that the same namespace isn't provided twice. This is intended\n    // to teach new developers that 'goog.provide' is effectively a variable\n    // declaration. And when JSCompiler transforms goog.provide into a real\n    // variable declaration, the compiled JS should work the same as the raw\n    // JS--even when the raw JS uses goog.provide incorrectly.\n    if (goog.isProvided_(name)) {\n      throw Error('Namespace \"' + name + '\" already declared.');\n    }\n    delete goog.implicitNamespaces_[name];\n\n    var namespace = name;\n    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\n      if (goog.getObjectByName(namespace)) {\n        break;\n      }\n      goog.implicitNamespaces_[namespace] = true;\n    }\n  }\n\n  goog.exportPath_(name);\n};\n\n\n/**\n * Marks that the current file should only be used for testing, and never for\n * live code in production.\n * @param {string=} opt_message Optional message to add to the error that's\n *     raised when used in production code.\n */\ngoog.setTestOnly = function(opt_message) {\n  if (COMPILED && !goog.DEBUG) {\n    opt_message = opt_message || '';\n    throw Error('Importing test-only code into non-debug environment' +\n                opt_message ? ': ' + opt_message : '.');\n  }\n};\n\n\nif (!COMPILED) {\n\n  /**\n   * Check if the given name has been goog.provided. This will return false for\n   * names that are available only as implicit namespaces.\n   * @param {string} name name of the object to look for.\n   * @return {boolean} Whether the name has been provided.\n   * @private\n   */\n  goog.isProvided_ = function(name) {\n    return !goog.implicitNamespaces_[name] && !!goog.getObjectByName(name);\n  };\n\n  /**\n   * Namespaces implicitly defined by goog.provide. For example,\n   * goog.provide('goog.events.Event') implicitly declares\n   * that 'goog' and 'goog.events' must be namespaces.\n   *\n   * @type {Object}\n   * @private\n   */\n  goog.implicitNamespaces_ = {};\n}\n\n\n/**\n * Builds an object structure for the provided namespace path,\n * ensuring that names that already exist are not overwritten. For\n * example:\n * \"a.b.c\" -> a = {};a.b={};a.b.c={};\n * Used by goog.provide and goog.exportSymbol.\n * @param {string} name name of the object that this file defines.\n * @param {*=} opt_object the object to expose at the end of the path.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n * @private\n */\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  var parts = name.split('.');\n  var cur = opt_objectToExportTo || goog.global;\n\n  // Internet Explorer exhibits strange behavior when throwing errors from\n  // methods externed in this manner.  See the testExportSymbolExceptions in\n  // base_test.html for an example.\n  if (!(parts[0] in cur) && cur.execScript) {\n    cur.execScript('var ' + parts[0]);\n  }\n\n  // Certain browsers cannot parse code in the form for((a in b); c;);\n  // This pattern is produced by the JSCompiler when it collapses the\n  // statement above into the conditional loop below. To prevent this from\n  // happening, use a for-loop and reserve the init logic as below.\n\n  // Parentheses added to eliminate strict JS warning in Firefox.\n  for (var part; parts.length && (part = parts.shift());) {\n    if (!parts.length && goog.isDef(opt_object)) {\n      // last part and we have an object; use it\n      cur[part] = opt_object;\n    } else if (cur[part]) {\n      cur = cur[part];\n    } else {\n      cur = cur[part] = {};\n    }\n  }\n};\n\n\n/**\n * Returns an object based on its fully qualified external name.  If you are\n * using a compilation pass that renames property names beware that using this\n * function will not find renamed properties.\n *\n * @param {string} name The fully qualified name.\n * @param {Object=} opt_obj The object within which to look; default is\n *     |goog.global|.\n * @return {?} The value (object or primitive) or, if not found, null.\n */\ngoog.getObjectByName = function(name, opt_obj) {\n  var parts = name.split('.');\n  var cur = opt_obj || goog.global;\n  for (var part; part = parts.shift(); ) {\n    if (goog.isDefAndNotNull(cur[part])) {\n      cur = cur[part];\n    } else {\n      return null;\n    }\n  }\n  return cur;\n};\n\n\n/**\n * Globalizes a whole namespace, such as goog or goog.lang.\n *\n * @param {Object} obj The namespace to globalize.\n * @param {Object=} opt_global The object to add the properties to.\n * @deprecated Properties may be explicitly exported to the global scope, but\n *     this should no longer be done in bulk.\n */\ngoog.globalize = function(obj, opt_global) {\n  var global = opt_global || goog.global;\n  for (var x in obj) {\n    global[x] = obj[x];\n  }\n};\n\n\n/**\n * Adds a dependency from a file to the files it requires.\n * @param {string} relPath The path to the js file.\n * @param {Array} provides An array of strings with the names of the objects\n *                         this file provides.\n * @param {Array} requires An array of strings with the names of the objects\n *                         this file requires.\n */\ngoog.addDependency = function(relPath, provides, requires) {\n  if (!COMPILED) {\n    var provide, require;\n    var path = relPath.replace(/\\\\/g, '/');\n    var deps = goog.dependencies_;\n    for (var i = 0; provide = provides[i]; i++) {\n      deps.nameToPath[provide] = path;\n      if (!(path in deps.pathToNames)) {\n        deps.pathToNames[path] = {};\n      }\n      deps.pathToNames[path][provide] = true;\n    }\n    for (var j = 0; require = requires[j]; j++) {\n      if (!(path in deps.requires)) {\n        deps.requires[path] = {};\n      }\n      deps.requires[path][require] = true;\n    }\n  }\n};\n\n\n\n\n// NOTE(nnaze): The debug DOM loader was included in base.js as an orignal\n// way to do \"debug-mode\" development.  The dependency system can sometimes\n// be confusing, as can the debug DOM loader's asyncronous nature.\n//\n// With the DOM loader, a call to goog.require() is not blocking -- the\n// script will not load until some point after the current script.  If a\n// namespace is needed at runtime, it needs to be defined in a previous\n// script, or loaded via require() with its registered dependencies.\n// User-defined namespaces may need their own deps file.  See http://go/js_deps,\n// http://go/genjsdeps, or, externally, DepsWriter.\n// http://code.google.com/closure/library/docs/depswriter.html\n//\n// Because of legacy clients, the DOM loader can't be easily removed from\n// base.js.  Work is being done to make it disableable or replaceable for\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\n// for example). See bootstrap/ for more information.\n\n\n/**\n * @define {boolean} Whether to enable the debug loader.\n *\n * If enabled, a call to goog.require() will attempt to load the namespace by\n * appending a script tag to the DOM (if the namespace has been registered).\n *\n * If disabled, goog.require() will simply assert that the namespace has been\n * provided (and depend on the fact that some outside tool correctly ordered\n * the script).\n */\ngoog.ENABLE_DEBUG_LOADER = true;\n\n\n/**\n * Implements a system for the dynamic resolution of dependencies\n * that works in parallel with the BUILD system. Note that all calls\n * to goog.require will be stripped by the JSCompiler when the\n * --closure_pass option is used.\n * @see goog.provide\n * @param {string} name Namespace to include (as was given in goog.provide())\n *     in the form \"goog.package.part\".\n */\ngoog.require = function(name) {\n\n  // if the object already exists we do not need do do anything\n  // TODO(arv): If we start to support require based on file name this has\n  //            to change\n  // TODO(arv): If we allow goog.foo.* this has to change\n  // TODO(arv): If we implement dynamic load after page load we should probably\n  //            not remove this code for the compiled output\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      return;\n    }\n\n    if (goog.ENABLE_DEBUG_LOADER) {\n      var path = goog.getPathFromDeps_(name);\n      if (path) {\n        goog.included_[path] = true;\n        goog.writeScripts_();\n        return;\n      }\n    }\n\n    var errorMessage = 'goog.require could not find: ' + name;\n    if (goog.global.console) {\n      goog.global.console['error'](errorMessage);\n    }\n\n\n      throw Error(errorMessage);\n\n  }\n};\n\n\n/**\n * Path for included scripts\n * @type {string}\n */\ngoog.basePath = '';\n\n\n/**\n * A hook for overriding the base path.\n * @type {string|undefined}\n */\ngoog.global.CLOSURE_BASE_PATH;\n\n\n/**\n * Whether to write out Closure's deps file. By default,\n * the deps are written.\n * @type {boolean|undefined}\n */\ngoog.global.CLOSURE_NO_DEPS;\n\n\n/**\n * A function to import a single script. This is meant to be overridden when\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\n * in the global scope so that it can be set before base.js is loaded, which\n * allows deps.js to be imported properly.\n *\n * The function is passed the script source, which is a relative URI. It should\n * return true if the script was imported, false otherwise.\n */\ngoog.global.CLOSURE_IMPORT_SCRIPT;\n\n\n/**\n * Null function used for default values of callbacks, etc.\n * @return {void} Nothing.\n */\ngoog.nullFunction = function() {};\n\n\n/**\n * The identity function. Returns its first argument.\n *\n * @param {*=} opt_returnValue The single value that will be returned.\n * @param {...*} var_args Optional trailing arguments. These are ignored.\n * @return {?} The first argument. We can't know the type -- just pass it along\n *      without type.\n * @deprecated Use goog.functions.identity instead.\n */\ngoog.identityFunction = function(opt_returnValue, var_args) {\n  return opt_returnValue;\n};\n\n\n/**\n * When defining a class Foo with an abstract method bar(), you can do:\n *\n * Foo.prototype.bar = goog.abstractMethod\n *\n * Now if a subclass of Foo fails to override bar(), an error\n * will be thrown when bar() is invoked.\n *\n * Note: This does not take the name of the function to override as\n * an argument because that would make it more difficult to obfuscate\n * our JavaScript code.\n *\n * @type {!Function}\n * @throws {Error} when invoked to indicate the method should be\n *   overridden.\n */\ngoog.abstractMethod = function() {\n  throw Error('unimplemented abstract method');\n};\n\n\n/**\n * Adds a {@code getInstance} static method that always return the same instance\n * object.\n * @param {!Function} ctor The constructor for the class to add the static\n *     method to.\n */\ngoog.addSingletonGetter = function(ctor) {\n  ctor.getInstance = function() {\n    if (ctor.instance_) {\n      return ctor.instance_;\n    }\n    if (goog.DEBUG) {\n      // NOTE: JSCompiler can't optimize away Array#push.\n      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n    }\n    return ctor.instance_ = new ctor;\n  };\n};\n\n\n/**\n * All singleton classes that have been instantiated, for testing. Don't read\n * it directly, use the {@code goog.testing.singleton} module. The compiler\n * removes this variable if unused.\n * @type {!Array.<!Function>}\n * @private\n */\ngoog.instantiatedSingletons_ = [];\n\n\nif (!COMPILED && goog.ENABLE_DEBUG_LOADER) {\n  /**\n   * Object used to keep track of urls that have already been added. This\n   * record allows the prevention of circular dependencies.\n   * @type {Object}\n   * @private\n   */\n  goog.included_ = {};\n\n\n  /**\n   * This object is used to keep track of dependencies and other data that is\n   * used for loading scripts\n   * @private\n   * @type {Object}\n   */\n  goog.dependencies_ = {\n    pathToNames: {}, // 1 to many\n    nameToPath: {}, // 1 to 1\n    requires: {}, // 1 to many\n    // used when resolving dependencies to prevent us from\n    // visiting the file twice\n    visited: {},\n    written: {} // used to keep track of script files we have written\n  };\n\n\n  /**\n   * Tries to detect whether is in the context of an HTML document.\n   * @return {boolean} True if it looks like HTML document.\n   * @private\n   */\n  goog.inHtmlDocument_ = function() {\n    var doc = goog.global.document;\n    return typeof doc != 'undefined' &&\n           'write' in doc;  // XULDocument misses write.\n  };\n\n\n  /**\n   * Tries to detect the base path of the base.js script that bootstraps Closure\n   * @private\n   */\n  goog.findBasePath_ = function() {\n    if (goog.global.CLOSURE_BASE_PATH) {\n      goog.basePath = goog.global.CLOSURE_BASE_PATH;\n      return;\n    } else if (!goog.inHtmlDocument_()) {\n      return;\n    }\n    var doc = goog.global.document;\n    var scripts = doc.getElementsByTagName('script');\n    // Search backwards since the current script is in almost all cases the one\n    // that has base.js.\n    for (var i = scripts.length - 1; i >= 0; --i) {\n      var src = scripts[i].src;\n      var qmark = src.lastIndexOf('?');\n      var l = qmark == -1 ? src.length : qmark;\n      if (src.substr(l - 7, 7) == 'base.js') {\n        goog.basePath = src.substr(0, l - 7);\n        return;\n      }\n    }\n  };\n\n\n  /**\n   * Imports a script if, and only if, that script hasn't already been imported.\n   * (Must be called at execution time)\n   * @param {string} src Script source.\n   * @private\n   */\n  goog.importScript_ = function(src) {\n    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||\n        goog.writeScriptTag_;\n    if (!goog.dependencies_.written[src] && importScript(src)) {\n      goog.dependencies_.written[src] = true;\n    }\n  };\n\n\n  /**\n   * The default implementation of the import function. Writes a script tag to\n   * import the script.\n   *\n   * @param {string} src The script source.\n   * @return {boolean} True if the script was imported, false otherwise.\n   * @private\n   */\n  goog.writeScriptTag_ = function(src) {\n    if (goog.inHtmlDocument_()) {\n      var doc = goog.global.document;\n      doc.write(\n          '<script type=\"text/javascript\" src=\"' + src + '\"></' + 'script>');\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n\n  /**\n   * Resolves dependencies based on the dependencies added using addDependency\n   * and calls importScript_ in the correct order.\n   * @private\n   */\n  goog.writeScripts_ = function() {\n    // the scripts we need to write this time\n    var scripts = [];\n    var seenScript = {};\n    var deps = goog.dependencies_;\n\n    function visitNode(path) {\n      if (path in deps.written) {\n        return;\n      }\n\n      // we have already visited this one. We can get here if we have cyclic\n      // dependencies\n      if (path in deps.visited) {\n        if (!(path in seenScript)) {\n          seenScript[path] = true;\n          scripts.push(path);\n        }\n        return;\n      }\n\n      deps.visited[path] = true;\n\n      if (path in deps.requires) {\n        for (var requireName in deps.requires[path]) {\n          // If the required name is defined, we assume that it was already\n          // bootstrapped by other means.\n          if (!goog.isProvided_(requireName)) {\n            if (requireName in deps.nameToPath) {\n              visitNode(deps.nameToPath[requireName]);\n            } else {\n              throw Error('Undefined nameToPath for ' + requireName);\n            }\n          }\n        }\n      }\n\n      if (!(path in seenScript)) {\n        seenScript[path] = true;\n        scripts.push(path);\n      }\n    }\n\n    for (var path in goog.included_) {\n      if (!deps.written[path]) {\n        visitNode(path);\n      }\n    }\n\n    for (var i = 0; i < scripts.length; i++) {\n      if (scripts[i]) {\n        goog.importScript_(goog.basePath + scripts[i]);\n      } else {\n        throw Error('Undefined script input');\n      }\n    }\n  };\n\n\n  /**\n   * Looks at the dependency rules and tries to determine the script file that\n   * fulfills a particular rule.\n   * @param {string} rule In the form goog.namespace.Class or project.script.\n   * @return {?string} Url corresponding to the rule, or null.\n   * @private\n   */\n  goog.getPathFromDeps_ = function(rule) {\n    if (rule in goog.dependencies_.nameToPath) {\n      return goog.dependencies_.nameToPath[rule];\n    } else {\n      return null;\n    }\n  };\n\n  goog.findBasePath_();\n\n  // Allow projects to manage the deps files themselves.\n  if (!goog.global.CLOSURE_NO_DEPS) {\n    goog.importScript_(goog.basePath + 'deps.js');\n  }\n}\n\n\n\n//==============================================================================\n// Language Enhancements\n//==============================================================================\n\n\n/**\n * This is a \"fixed\" version of the typeof operator.  It differs from the typeof\n * operator in such a way that null returns 'null' and arrays return 'array'.\n * @param {*} value The value to get the type of.\n * @return {string} The name of the type.\n */\ngoog.typeOf = function(value) {\n  var s = typeof value;\n  if (s == 'object') {\n    if (value) {\n      // Check these first, so we can avoid calling Object.prototype.toString if\n      // possible.\n      //\n      // IE improperly marshals tyepof across execution contexts, but a\n      // cross-context object will still return false for \"instanceof Object\".\n      if (value instanceof Array) {\n        return 'array';\n      } else if (value instanceof Object) {\n        return s;\n      }\n\n      // HACK: In order to use an Object prototype method on the arbitrary\n      //   value, the compiler requires the value be cast to type Object,\n      //   even though the ECMA spec explicitly allows it.\n      var className = Object.prototype.toString.call(\n          /** @type {Object} */ (value));\n      // In Firefox 3.6, attempting to access iframe window objects' length\n      // property throws an NS_ERROR_FAILURE, so we need to special-case it\n      // here.\n      if (className == '[object Window]') {\n        return 'object';\n      }\n\n      // We cannot always use constructor == Array or instanceof Array because\n      // different frames have different Array objects. In IE6, if the iframe\n      // where the array was created is destroyed, the array loses its\n      // prototype. Then dereferencing val.splice here throws an exception, so\n      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'\n      // so that will work. In this case, this function will return false and\n      // most array functions will still work because the array is still\n      // array-like (supports length and []) even though it has lost its\n      // prototype.\n      // Mark Miller noticed that Object.prototype.toString\n      // allows access to the unforgeable [[Class]] property.\n      //  15.2.4.2 Object.prototype.toString ( )\n      //  When the toString method is called, the following steps are taken:\n      //      1. Get the [[Class]] property of this object.\n      //      2. Compute a string value by concatenating the three strings\n      //         \"[object \", Result(1), and \"]\".\n      //      3. Return Result(2).\n      // and this behavior survives the destruction of the execution context.\n      if ((className == '[object Array]' ||\n           // In IE all non value types are wrapped as objects across window\n           // boundaries (not iframe though) so we have to do object detection\n           // for this edge case\n           typeof value.length == 'number' &&\n           typeof value.splice != 'undefined' &&\n           typeof value.propertyIsEnumerable != 'undefined' &&\n           !value.propertyIsEnumerable('splice')\n\n          )) {\n        return 'array';\n      }\n      // HACK: There is still an array case that fails.\n      //     function ArrayImpostor() {}\n      //     ArrayImpostor.prototype = [];\n      //     var impostor = new ArrayImpostor;\n      // this can be fixed by getting rid of the fast path\n      // (value instanceof Array) and solely relying on\n      // (value && Object.prototype.toString.vall(value) === '[object Array]')\n      // but that would require many more function calls and is not warranted\n      // unless closure code is receiving objects from untrusted sources.\n\n      // IE in cross-window calls does not correctly marshal the function type\n      // (it appears just as an object) so we cannot use just typeof val ==\n      // 'function'. However, if the object has a call property, it is a\n      // function.\n      if ((className == '[object Function]' ||\n          typeof value.call != 'undefined' &&\n          typeof value.propertyIsEnumerable != 'undefined' &&\n          !value.propertyIsEnumerable('call'))) {\n        return 'function';\n      }\n\n\n    } else {\n      return 'null';\n    }\n\n  } else if (s == 'function' && typeof value.call == 'undefined') {\n    // In Safari typeof nodeList returns 'function', and on Firefox\n    // typeof behaves similarly for HTML{Applet,Embed,Object}Elements\n    // and RegExps.  We would like to return object for those and we can\n    // detect an invalid function by making sure that the function\n    // object has a call method.\n    return 'object';\n  }\n  return s;\n};\n\n\n/**\n * Returns true if the specified value is not |undefined|.\n * WARNING: Do not use this to test if an object has a property. Use the in\n * operator instead.  Additionally, this function assumes that the global\n * undefined variable has not been redefined.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined.\n */\ngoog.isDef = function(val) {\n  return val !== undefined;\n};\n\n\n/**\n * Returns true if the specified value is |null|\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is null.\n */\ngoog.isNull = function(val) {\n  return val === null;\n};\n\n\n/**\n * Returns true if the specified value is defined and not null\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined and not null.\n */\ngoog.isDefAndNotNull = function(val) {\n  // Note that undefined == null.\n  return val != null;\n};\n\n\n/**\n * Returns true if the specified value is an array\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArray = function(val) {\n  return goog.typeOf(val) == 'array';\n};\n\n\n/**\n * Returns true if the object looks like an array. To qualify as array like\n * the value needs to be either a NodeList or an object with a Number length\n * property.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArrayLike = function(val) {\n  var type = goog.typeOf(val);\n  return type == 'array' || type == 'object' && typeof val.length == 'number';\n};\n\n\n/**\n * Returns true if the object looks like a Date. To qualify as Date-like\n * the value needs to be an object and have a getFullYear() function.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a like a Date.\n */\ngoog.isDateLike = function(val) {\n  return goog.isObject(val) && typeof val.getFullYear == 'function';\n};\n\n\n/**\n * Returns true if the specified value is a string\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a string.\n */\ngoog.isString = function(val) {\n  return typeof val == 'string';\n};\n\n\n/**\n * Returns true if the specified value is a boolean\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is boolean.\n */\ngoog.isBoolean = function(val) {\n  return typeof val == 'boolean';\n};\n\n\n/**\n * Returns true if the specified value is a number\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a number.\n */\ngoog.isNumber = function(val) {\n  return typeof val == 'number';\n};\n\n\n/**\n * Returns true if the specified value is a function\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a function.\n */\ngoog.isFunction = function(val) {\n  return goog.typeOf(val) == 'function';\n};\n\n\n/**\n * Returns true if the specified value is an object.  This includes arrays\n * and functions.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an object.\n */\ngoog.isObject = function(val) {\n  var type = typeof val;\n  return type == 'object' && val != null || type == 'function';\n  // return Object(val) === val also works, but is slower, especially if val is\n  // not an object.\n};\n\n\n/**\n * Gets a unique ID for an object. This mutates the object so that further\n * calls with the same object as a parameter returns the same value. The unique\n * ID is guaranteed to be unique across the current session amongst objects that\n * are passed into {@code getUid}. There is no guarantee that the ID is unique\n * or consistent across sessions. It is unsafe to generate unique ID for\n * function prototypes.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {number} The unique ID for the object.\n */\ngoog.getUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // In Opera window.hasOwnProperty exists but always returns false so we avoid\n  // using it. As a consequence the unique ID generated for BaseClass.prototype\n  // and SubClass.prototype will be the same.\n  return obj[goog.UID_PROPERTY_] ||\n      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n\n\n/**\n * Removes the unique ID from an object. This is useful if the object was\n * previously mutated using {@code goog.getUid} in which case the mutation is\n * undone.\n * @param {Object} obj The object to remove the unique ID field from.\n */\ngoog.removeUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // DOM nodes in IE are not instance of Object and throws exception\n  // for delete. Instead we try to use removeAttribute\n  if ('removeAttribute' in obj) {\n    obj.removeAttribute(goog.UID_PROPERTY_);\n  }\n  /** @preserveTry */\n  try {\n    delete obj[goog.UID_PROPERTY_];\n  } catch (ex) {\n  }\n};\n\n\n/**\n * Name for unique ID property. Initialized in a way to help avoid collisions\n * with other closure javascript on the same page.\n * @type {string}\n * @private\n */\ngoog.UID_PROPERTY_ = 'closure_uid_' +\n    Math.floor(Math.random() * 2147483648).toString(36);\n\n\n/**\n * Counter for UID.\n * @type {number}\n * @private\n */\ngoog.uidCounter_ = 0;\n\n\n/**\n * Adds a hash code field to an object. The hash code is unique for the\n * given object.\n * @param {Object} obj The object to get the hash code for.\n * @return {number} The hash code for the object.\n * @deprecated Use goog.getUid instead.\n */\ngoog.getHashCode = goog.getUid;\n\n\n/**\n * Removes the hash code field from an object.\n * @param {Object} obj The object to remove the field from.\n * @deprecated Use goog.removeUid instead.\n */\ngoog.removeHashCode = goog.removeUid;\n\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n *\n * WARNINGS:\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\n * refer to themselves will cause infinite recursion.\n *\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\n * UIDs created by <code>getUid</code> into cloned results.\n *\n * @param {*} obj The value to clone.\n * @return {*} A clone of the input value.\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n  var type = goog.typeOf(obj);\n  if (type == 'object' || type == 'array') {\n    if (obj.clone) {\n      return obj.clone();\n    }\n    var clone = type == 'array' ? [] : {};\n    for (var key in obj) {\n      clone[key] = goog.cloneObject(obj[key]);\n    }\n    return clone;\n  }\n\n  return obj;\n};\n\n\n/**\n * Forward declaration for the clone method. This is necessary until the\n * compiler can better support duck-typing constructs as used in\n * goog.cloneObject.\n *\n * TODO(brenneman): Remove once the JSCompiler can infer that the check for\n * proto.clone is safe in goog.cloneObject.\n *\n * @type {Function}\n */\nObject.prototype.clone;\n\n\n/**\n * A native implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n * @suppress {deprecated} The compiler thinks that Function.prototype.bind\n *     is deprecated because some people have declared a pure-JS version.\n *     Only the pure-JS version is truly deprecated.\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\n};\n\n\n/**\n * A pure-JS implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n  if (!fn) {\n    throw new Error();\n  }\n\n  if (arguments.length > 2) {\n    var boundArgs = Array.prototype.slice.call(arguments, 2);\n    return function() {\n      // Prepend the bound arguments to the current arguments.\n      var newArgs = Array.prototype.slice.call(arguments);\n      Array.prototype.unshift.apply(newArgs, boundArgs);\n      return fn.apply(selfObj, newArgs);\n    };\n\n  } else {\n    return function() {\n      return fn.apply(selfObj, arguments);\n    };\n  }\n};\n\n\n/**\n * Partially applies this function to a particular 'this object' and zero or\n * more arguments. The result is a new function with some arguments of the first\n * function pre-filled and the value of |this| 'pre-specified'.<br><br>\n *\n * Remaining arguments specified at call-time are appended to the pre-\n * specified ones.<br><br>\n *\n * Also see: {@link #partial}.<br><br>\n *\n * Usage:\n * <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');\n * barMethBound('arg3', 'arg4');</pre>\n *\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @suppress {deprecated} See above.\n */\ngoog.bind = function(fn, selfObj, var_args) {\n  // TODO(nicksantos): narrow the type signature.\n  if (Function.prototype.bind &&\n      // NOTE(nicksantos): Somebody pulled base.js into the default\n      // Chrome extension environment. This means that for Chrome extensions,\n      // they get the implementation of Function.prototype.bind that\n      // calls goog.bind instead of the native one. Even worse, we don't want\n      // to introduce a circular dependency between goog.bind and\n      // Function.prototype.bind, so we have to hack this to make sure it\n      // works correctly.\n      Function.prototype.bind.toString().indexOf('native code') != -1) {\n    goog.bind = goog.bindNative_;\n  } else {\n    goog.bind = goog.bindJs_;\n  }\n  return goog.bind.apply(null, arguments);\n};\n\n\n/**\n * Like bind(), except that a 'this object' is not required. Useful when the\n * target function is already bound.\n *\n * Usage:\n * var g = partial(f, arg1, arg2);\n * g(arg3, arg4);\n *\n * @param {Function} fn A function to partially apply.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to fn.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n */\ngoog.partial = function(fn, var_args) {\n  var args = Array.prototype.slice.call(arguments, 1);\n  return function() {\n    // Prepend the bound arguments to the current arguments.\n    var newArgs = Array.prototype.slice.call(arguments);\n    newArgs.unshift.apply(newArgs, args);\n    return fn.apply(this, newArgs);\n  };\n};\n\n\n/**\n * Copies all the members of a source object to a target object. This method\n * does not work on all browsers for all objects that contain keys such as\n * toString or hasOwnProperty. Use goog.object.extend for this purpose.\n * @param {Object} target Target.\n * @param {Object} source Source.\n */\ngoog.mixin = function(target, source) {\n  for (var x in source) {\n    target[x] = source[x];\n  }\n\n  // For IE7 or lower, the for-in-loop does not contain any properties that are\n  // not enumerable on the prototype object (for example, isPrototypeOf from\n  // Object.prototype) but also it will not include 'replace' on objects that\n  // extend String and change 'replace' (not that it is common for anyone to\n  // extend anything except Object).\n};\n\n\n/**\n * @return {number} An integer value representing the number of milliseconds\n *     between midnight, January 1, 1970 and the current time.\n */\ngoog.now = Date.now || (function() {\n  // Unary plus operator converts its operand to a number which in the case of\n  // a date is done by calling getTime().\n  return +new Date();\n});\n\n\n/**\n * Evals javascript in the global scope.  In IE this uses execScript, other\n * browsers use goog.global.eval. If goog.global.eval does not evaluate in the\n * global scope (for example, in Safari), appends a script tag instead.\n * Throws an exception if neither execScript or eval is defined.\n * @param {string} script JavaScript string.\n */\ngoog.globalEval = function(script) {\n  if (goog.global.execScript) {\n    goog.global.execScript(script, 'JavaScript');\n  } else if (goog.global.eval) {\n    // Test to see if eval works\n    if (goog.evalWorksForGlobals_ == null) {\n      goog.global.eval('var _et_ = 1;');\n      if (typeof goog.global['_et_'] != 'undefined') {\n        delete goog.global['_et_'];\n        goog.evalWorksForGlobals_ = true;\n      } else {\n        goog.evalWorksForGlobals_ = false;\n      }\n    }\n\n    if (goog.evalWorksForGlobals_) {\n      goog.global.eval(script);\n    } else {\n      var doc = goog.global.document;\n      var scriptElt = doc.createElement('script');\n      scriptElt.type = 'text/javascript';\n      scriptElt.defer = false;\n      // Note(user): can't use .innerHTML since \"t('<test>')\" will fail and\n      // .text doesn't work in Safari 2.  Therefore we append a text node.\n      scriptElt.appendChild(doc.createTextNode(script));\n      doc.body.appendChild(scriptElt);\n      doc.body.removeChild(scriptElt);\n    }\n  } else {\n    throw Error('goog.globalEval not available');\n  }\n};\n\n\n/**\n * Indicates whether or not we can call 'eval' directly to eval code in the\n * global scope. Set to a Boolean by the first call to goog.globalEval (which\n * empirically tests whether eval works for globals). @see goog.globalEval\n * @type {?boolean}\n * @private\n */\ngoog.evalWorksForGlobals_ = null;\n\n\n/**\n * Optional map of CSS class names to obfuscated names used with\n * goog.getCssName().\n * @type {Object|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMapping_;\n\n\n/**\n * Optional obfuscation style for CSS class names. Should be set to either\n * 'BY_WHOLE' or 'BY_PART' if defined.\n * @type {string|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMappingStyle_;\n\n\n/**\n * Handles strings that are intended to be used as CSS class names.\n *\n * This function works in tandem with @see goog.setCssNameMapping.\n *\n * Without any mapping set, the arguments are simple joined with a\n * hyphen and passed through unaltered.\n *\n * When there is a mapping, there are two possible styles in which\n * these mappings are used. In the BY_PART style, each part (i.e. in\n * between hyphens) of the passed in css name is rewritten according\n * to the map. In the BY_WHOLE style, the full css name is looked up in\n * the map directly. If a rewrite is not specified by the map, the\n * compiler will output a warning.\n *\n * When the mapping is passed to the compiler, it will replace calls\n * to goog.getCssName with the strings from the mapping, e.g.\n *     var x = goog.getCssName('foo');\n *     var y = goog.getCssName(this.baseClass, 'active');\n *  becomes:\n *     var x= 'foo';\n *     var y = this.baseClass + '-active';\n *\n * If one argument is passed it will be processed, if two are passed\n * only the modifier will be processed, as it is assumed the first\n * argument was generated as a result of calling goog.getCssName.\n *\n * @param {string} className The class name.\n * @param {string=} opt_modifier A modifier to be appended to the class name.\n * @return {string} The class name or the concatenation of the class name and\n *     the modifier.\n */\ngoog.getCssName = function(className, opt_modifier) {\n  var getMapping = function(cssName) {\n    return goog.cssNameMapping_[cssName] || cssName;\n  };\n\n  var renameByParts = function(cssName) {\n    // Remap all the parts individually.\n    var parts = cssName.split('-');\n    var mapped = [];\n    for (var i = 0; i < parts.length; i++) {\n      mapped.push(getMapping(parts[i]));\n    }\n    return mapped.join('-');\n  };\n\n  var rename;\n  if (goog.cssNameMapping_) {\n    rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?\n        getMapping : renameByParts;\n  } else {\n    rename = function(a) {\n      return a;\n    };\n  }\n\n  if (opt_modifier) {\n    return className + '-' + rename(opt_modifier);\n  } else {\n    return rename(className);\n  }\n};\n\n\n/**\n * Sets the map to check when returning a value from goog.getCssName(). Example:\n * <pre>\n * goog.setCssNameMapping({\n *   \"goog\": \"a\",\n *   \"disabled\": \"b\",\n * });\n *\n * var x = goog.getCssName('goog');\n * // The following evaluates to: \"a a-b\".\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\n * </pre>\n * When declared as a map of string literals to string literals, the JSCompiler\n * will replace all calls to goog.getCssName() using the supplied map if the\n * --closure_pass flag is set.\n *\n * @param {!Object} mapping A map of strings to strings where keys are possible\n *     arguments to goog.getCssName() and values are the corresponding values\n *     that should be returned.\n * @param {string=} opt_style The style of css name mapping. There are two valid\n *     options: 'BY_PART', and 'BY_WHOLE'.\n * @see goog.getCssName for a description.\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n  goog.cssNameMapping_ = mapping;\n  goog.cssNameMappingStyle_ = opt_style;\n};\n\n\n/**\n * To use CSS renaming in compiled mode, one of the input files should have a\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\n * mode, JavaScript code should be loaded before this base.js file that declares\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\n * are made in uncompiled mode.\n *\n * A hook for overriding the CSS name mapping.\n * @type {Object|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\n\n\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n  // This does not call goog.setCssNameMapping() because the JSCompiler\n  // requires that goog.setCssNameMapping() be called with an object literal.\n  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n\n\n/**\n * Abstract implementation of goog.getMsg for use with localized messages.\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {Object=} opt_values Map of place holder name to value.\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values) {\n  var values = opt_values || {};\n  for (var key in values) {\n    var value = ('' + values[key]).replace(/\\$/g, '$$$$');\n    str = str.replace(new RegExp('\\\\{\\\\$' + key + '\\\\}', 'gi'), value);\n  }\n  return str;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated,\n * unless they are exported in turn via this function or\n * goog.exportProperty\n *\n * <p>Also handy for making public items that are defined in anonymous\n * closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction',\n *                       Foo.staticFunction);\n *     public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n *                       Foo.prototype.myMethod);\n *     new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n */\ngoog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {\n  goog.exportPath_(publicPath, object, opt_objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n  object[publicName] = symbol;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * <pre>\n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { }\n *\n * function ChildClass(a, b, c) {\n *   goog.base(this, a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // works\n * </pre>\n *\n * In addition, a superclass' implementation of a method can be invoked\n * as follows:\n *\n * <pre>\n * ChildClass.prototype.foo = function(a) {\n *   ChildClass.superClass_.foo.call(this, a);\n *   // other code\n * };\n * </pre>\n *\n * @param {Function} childCtor Child class.\n * @param {Function} parentCtor Parent class.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n  /** @constructor */\n  function tempCtor() {};\n  tempCtor.prototype = parentCtor.prototype;\n  childCtor.superClass_ = parentCtor.prototype;\n  childCtor.prototype = new tempCtor();\n  childCtor.prototype.constructor = childCtor;\n};\n\n\n/**\n * Call up to the superclass.\n *\n * If this is called from a constructor, then this calls the superclass\n * contructor with arguments 1-N.\n *\n * If this is called from a prototype method, then you must pass\n * the name of the method as the second argument to this function. If\n * you do not, you will get a runtime error. This calls the superclass'\n * method with arguments 2-N.\n *\n * This function only works if you use goog.inherits to express\n * inheritance relationships between your classes.\n *\n * This function is a compiler primitive. At compile-time, the\n * compiler will do macro expansion to remove a lot of\n * the extra overhead that this function introduces. The compiler\n * will also enforce a lot of the assumptions that this function\n * makes, and treat it as a compiler error if you break them.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {*=} opt_methodName The method name if calling a super method.\n * @param {...*} var_args The rest of the arguments.\n * @return {*} The return value of the superclass method.\n */\ngoog.base = function(me, opt_methodName, var_args) {\n  var caller = arguments.callee.caller;\n  if (caller.superClass_) {\n    // This is a constructor. Call the superclass constructor.\n    return caller.superClass_.constructor.apply(\n        me, Array.prototype.slice.call(arguments, 1));\n  }\n\n  var args = Array.prototype.slice.call(arguments, 2);\n  var foundCaller = false;\n  for (var ctor = me.constructor;\n       ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {\n    if (ctor.prototype[opt_methodName] === caller) {\n      foundCaller = true;\n    } else if (foundCaller) {\n      return ctor.prototype[opt_methodName].apply(me, args);\n    }\n  }\n\n  // If we did not find the caller in the prototype chain,\n  // then one of two things happened:\n  // 1) The caller is an instance method.\n  // 2) This method was not called by the right caller.\n  if (me[opt_methodName] === caller) {\n    return me.constructor.prototype[opt_methodName].apply(me, args);\n  } else {\n    throw Error(\n        'goog.base called from a method of one name ' +\n        'to a method of a different name');\n  }\n};\n\n\n/**\n * Allow for aliasing within scope functions.  This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the\n * aliases applied.  In uncompiled code the function is simply run since the\n * aliases as written are valid JavaScript.\n * @param {function()} fn Function to call.  This function can contain aliases\n *     to namespaces (e.g. \"var dom = goog.dom\") or classes\n *    (e.g. \"var Timer = goog.Timer\").\n */\ngoog.scope = function(fn) {\n  fn.call(goog.global);\n};\n\n\n","/**\n * defines\n */\n\ngoog.provide('USE_TYPEDARRAY');\n\n// Safari が typeof Uint8Array === 'object' になるため、\n// 未定義か否かで Typed Array の使用を決定する\n\n/** @const {boolean} use typed array flag. */\nvar USE_TYPEDARRAY =\n  (typeof Uint8Array !== 'undefined') &&\n  (typeof Uint16Array !== 'undefined') &&\n  (typeof Uint32Array !== 'undefined') &&\n  (typeof DataView !== 'undefined');\n","goog.provide('Zlib.Huffman');\n\ngoog.require('USE_TYPEDARRAY');\n\ngoog.scope(function() {\n\n/**\n * build huffman table from length list.\n * @param {!(Array.<number>|Uint8Array)} lengths length list.\n * @return {!Array} huffman table.\n */\nZlib.Huffman.buildHuffmanTable = function(lengths) {\n  /** @type {number} length list size. */\n  var listSize = lengths.length;\n  /** @type {number} max code length for table size. */\n  var maxCodeLength = 0;\n  /** @type {number} min code length for table size. */\n  var minCodeLength = Number.POSITIVE_INFINITY;\n  /** @type {number} table size. */\n  var size;\n  /** @type {!(Array|Uint8Array)} huffman code table. */\n  var table;\n  /** @type {number} bit length. */\n  var bitLength;\n  /** @type {number} huffman code. */\n  var code;\n  /**\n   * サイズが 2^maxlength 個のテーブルを埋めるためのスキップ長.\n   * @type {number} skip length for table filling.\n   */\n  var skip;\n  /** @type {number} reversed code. */\n  var reversed;\n  /** @type {number} reverse temp. */\n  var rtemp;\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limit. */\n  var il;\n  /** @type {number} loop counter. */\n  var j;\n  /** @type {number} table value. */\n  var value;\n\n  // Math.max は遅いので最長の値は for-loop で取得する\n  for (i = 0, il = listSize; i < il; ++i) {\n    if (lengths[i] > maxCodeLength) {\n      maxCodeLength = lengths[i];\n    }\n    if (lengths[i] < minCodeLength) {\n      minCodeLength = lengths[i];\n    }\n  }\n\n  size = 1 << maxCodeLength;\n  table = new (USE_TYPEDARRAY ? Uint32Array : Array)(size);\n\n  // ビット長の短い順からハフマン符号を割り当てる\n  for (bitLength = 1, code = 0, skip = 2; bitLength <= maxCodeLength;) {\n    for (i = 0; i < listSize; ++i) {\n      if (lengths[i] === bitLength) {\n        // ビットオーダーが逆になるためビット長分並びを反転する\n        for (reversed = 0, rtemp = code, j = 0; j < bitLength; ++j) {\n          reversed = (reversed << 1) | (rtemp & 1);\n          rtemp >>= 1;\n        }\n\n        // 最大ビット長をもとにテーブルを作るため、\n        // 最大ビット長以外では 0 / 1 どちらでも良い箇所ができる\n        // そのどちらでも良い場所は同じ値で埋めることで\n        // 本来のビット長以上のビット数取得しても問題が起こらないようにする\n        value = (bitLength << 16) | i;\n        for (j = reversed; j < size; j += skip) {\n          table[j] = value;\n        }\n\n        ++code;\n      }\n    }\n\n    // 次のビット長へ\n    ++bitLength;\n    code <<= 1;\n    skip <<= 1;\n  }\n\n  return [table, maxCodeLength, minCodeLength];\n};\n\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.RawInflate');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.Huffman');\n\n//-----------------------------------------------------------------------------\n\n/** @define {number} buffer block size. */\nvar ZLIB_RAW_INFLATE_BUFFER_SIZE = 0x8000; // [ 0x8000 >= ZLIB_BUFFER_BLOCK_SIZE ]\n\n//-----------------------------------------------------------------------------\n\ngoog.scope(function() {\n\nvar buildHuffmanTable = Zlib.Huffman.buildHuffmanTable;\n\n/**\n * @constructor\n * @param {!(Uint8Array|Array.<number>)} input input buffer.\n * @param {Object} opt_params option parameter.\n *\n * opt_params は以下のプロパティを指定する事ができます。\n *   - index: input buffer の deflate コンテナの開始位置.\n *   - blockSize: バッファのブロックサイズ.\n *   - bufferType: Zlib.RawInflate.BufferType の値によってバッファの管理方法を指定する.\n *   - resize: 確保したバッファが実際の大きさより大きかった場合に切り詰める.\n */\nZlib.RawInflate = function(input, opt_params) {\n  /** @type {!(Array.<number>|Uint8Array)} inflated buffer */\n  this.buffer;\n  /** @type {!Array.<(Array.<number>|Uint8Array)>} */\n  this.blocks = [];\n  /** @type {number} block size. */\n  this.bufferSize = ZLIB_RAW_INFLATE_BUFFER_SIZE;\n  /** @type {!number} total output buffer pointer. */\n  this.totalpos = 0;\n  /** @type {!number} input buffer pointer. */\n  this.ip = 0;\n  /** @type {!number} bit stream reader buffer. */\n  this.bitsbuf = 0;\n  /** @type {!number} bit stream reader buffer size. */\n  this.bitsbuflen = 0;\n  /** @type {!(Array.<number>|Uint8Array)} input buffer. */\n  this.input = USE_TYPEDARRAY ? new Uint8Array(input) : input;\n  /** @type {!(Uint8Array|Array.<number>)} output buffer. */\n  this.output;\n  /** @type {!number} output buffer pointer. */\n  this.op;\n  /** @type {boolean} is final block flag. */\n  this.bfinal = false;\n  /** @type {Zlib.RawInflate.BufferType} buffer management. */\n  this.bufferType = Zlib.RawInflate.BufferType.ADAPTIVE;\n  /** @type {boolean} resize flag for memory size optimization. */\n  this.resize = false;\n  /** @type {number} previous RLE value */\n  this.prev;\n\n  // option parameters\n  if (opt_params || !(opt_params = {})) {\n    if (opt_params['index']) {\n      this.ip = opt_params['index'];\n    }\n    if (opt_params['bufferSize']) {\n      this.bufferSize = opt_params['bufferSize'];\n    }\n    if (opt_params['bufferType']) {\n      this.bufferType = opt_params['bufferType'];\n    }\n    if (opt_params['resize']) {\n      this.resize = opt_params['resize'];\n    }\n  }\n\n  // initialize\n  switch (this.bufferType) {\n    case Zlib.RawInflate.BufferType.BLOCK:\n      this.op = Zlib.RawInflate.MaxBackwardLength;\n      this.output =\n        new (USE_TYPEDARRAY ? Uint8Array : Array)(\n          Zlib.RawInflate.MaxBackwardLength +\n          this.bufferSize +\n          Zlib.RawInflate.MaxCopyLength\n        );\n      break;\n    case Zlib.RawInflate.BufferType.ADAPTIVE:\n      this.op = 0;\n      this.output = new (USE_TYPEDARRAY ? Uint8Array : Array)(this.bufferSize);\n      this.expandBuffer = this.expandBufferAdaptive;\n      this.concatBuffer = this.concatBufferDynamic;\n      this.decodeHuffman = this.decodeHuffmanAdaptive;\n      break;\n    default:\n      throw new Error('invalid inflate mode');\n  }\n};\n\n/**\n * @enum {number}\n */\nZlib.RawInflate.BufferType = {\n  BLOCK: 0,\n  ADAPTIVE: 1\n};\n\n/**\n * decompress.\n * @return {!(Uint8Array|Array.<number>)} inflated buffer.\n */\nZlib.RawInflate.prototype.decompress = function() {\n  while (!this.bfinal) {\n    this.parseBlock();\n  }\n\n  return this.concatBuffer();\n};\n\n/**\n * @const\n * @type {number} max backward length for LZ77.\n */\nZlib.RawInflate.MaxBackwardLength = 32768;\n\n/**\n * @const\n * @type {number} max copy length for LZ77.\n */\nZlib.RawInflate.MaxCopyLength = 258;\n\n/**\n * huffman order\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.Order = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n\n/**\n * huffman length code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflate.LengthCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b,\n  0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b,\n  0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3,\n  0x00e3, 0x0102, 0x0102, 0x0102\n]);\n\n/**\n * huffman length extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.LengthExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  5, 5, 0, 0, 0\n]);\n\n/**\n * huffman dist code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflate.DistCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011,\n  0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181,\n  0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001,\n  0x3001, 0x4001, 0x6001\n]);\n\n/**\n * huffman dist extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.DistExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  11, 12, 12, 13, 13\n]);\n\n/**\n * fixed huffman length code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflate.FixedLiteralLengthTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(288);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] =\n      (i <= 143) ? 8 :\n      (i <= 255) ? 9 :\n      (i <= 279) ? 7 :\n      8;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * fixed huffman distance code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflate.FixedDistanceTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(30);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] = 5;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * parse deflated block.\n */\nZlib.RawInflate.prototype.parseBlock = function() {\n  /** @type {number} header */\n  var hdr = this.readBits(3);\n\n  // BFINAL\n  if (hdr & 0x1) {\n    this.bfinal = true;\n  }\n\n  // BTYPE\n  hdr >>>= 1;\n  switch (hdr) {\n    // uncompressed\n    case 0:\n      this.parseUncompressedBlock();\n      break;\n    // fixed huffman\n    case 1:\n      this.parseFixedHuffmanBlock();\n      break;\n    // dynamic huffman\n    case 2:\n      this.parseDynamicHuffmanBlock();\n      break;\n    // reserved or other\n    default:\n      throw new Error('unknown BTYPE: ' + hdr);\n  }\n};\n\n/**\n * read inflate bits\n * @param {number} length bits length.\n * @return {number} read bits.\n */\nZlib.RawInflate.prototype.readBits = function(length) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {number} input and output byte. */\n  var octet;\n\n  // not enough buffer\n  while (bitsbuflen < length) {\n    // input byte\n    if (ip >= inputLength) {\n      throw new Error('input buffer is broken');\n    }\n\n    // concat octet\n    bitsbuf |= input[ip++] << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // output byte\n  octet = bitsbuf & /* MASK */ ((1 << length) - 1);\n  bitsbuf >>>= length;\n  bitsbuflen -= length;\n\n  this.bitsbuf = bitsbuf;\n  this.bitsbuflen = bitsbuflen;\n  this.ip = ip;\n\n  return octet;\n};\n\n/**\n * read huffman code using table\n * @param {Array} table huffman code table.\n * @return {number} huffman code.\n */\nZlib.RawInflate.prototype.readCodeByTable = function(table) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {!(Array.<number>|Uint8Array)} huffman code table */\n  var codeTable = table[0];\n  /** @type {number} */\n  var maxCodeLength = table[1];\n  /** @type {number} code length & code (16bit, 16bit) */\n  var codeWithLength;\n  /** @type {number} code bits length */\n  var codeLength;\n\n  // not enough buffer\n  while (bitsbuflen < maxCodeLength) {\n    if (ip >= inputLength) {\n      break;\n    }\n    bitsbuf |= input[ip++] << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // read max length\n  codeWithLength = codeTable[bitsbuf & ((1 << maxCodeLength) - 1)];\n  codeLength = codeWithLength >>> 16;\n\n  this.bitsbuf = bitsbuf >> codeLength;\n  this.bitsbuflen = bitsbuflen - codeLength;\n  this.ip = ip;\n\n  return codeWithLength & 0xffff;\n};\n\n/**\n * parse uncompressed block.\n */\nZlib.RawInflate.prototype.parseUncompressedBlock = function() {\n  var input = this.input;\n  var ip = this.ip;\n  var output = this.output;\n  var op = this.op;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {number} block length */\n  var len;\n  /** @type {number} number for check block length */\n  var nlen;\n  /** @type {number} output buffer length */\n  var olength = output.length;\n  /** @type {number} copy counter */\n  var preCopy;\n\n  // skip buffered header bits\n  this.bitsbuf = 0;\n  this.bitsbuflen = 0;\n\n  // len\n  if (ip + 1 >= inputLength) {\n    throw new Error('invalid uncompressed block header: LEN');\n  }\n  len = input[ip++] | (input[ip++] << 8);\n\n  // nlen\n  if (ip + 1 >= inputLength) {\n    throw new Error('invalid uncompressed block header: NLEN');\n  }\n  nlen = input[ip++] | (input[ip++] << 8);\n\n  // check len & nlen\n  if (len === ~nlen) {\n    throw new Error('invalid uncompressed block header: length verify');\n  }\n\n  // check size\n  if (ip + len > input.length) { throw new Error('input buffer is broken'); }\n\n  // expand buffer\n  switch (this.bufferType) {\n    case Zlib.RawInflate.BufferType.BLOCK:\n      // pre copy\n      while (op + len > output.length) {\n        preCopy = olength - op;\n        len -= preCopy;\n        if (USE_TYPEDARRAY) {\n          output.set(input.subarray(ip, ip + preCopy), op);\n          op += preCopy;\n          ip += preCopy;\n        } else {\n          while (preCopy--) {\n            output[op++] = input[ip++];\n          }\n        }\n        this.op = op;\n        output = this.expandBuffer();\n        op = this.op;\n      }\n      break;\n    case Zlib.RawInflate.BufferType.ADAPTIVE:\n      while (op + len > output.length) {\n        output = this.expandBuffer({fixRatio: 2});\n      }\n      break;\n    default:\n      throw new Error('invalid inflate mode');\n  }\n\n  // copy\n  if (USE_TYPEDARRAY) {\n    output.set(input.subarray(ip, ip + len), op);\n    op += len;\n    ip += len;\n  } else {\n    while (len--) {\n      output[op++] = input[ip++];\n    }\n  }\n\n  this.ip = ip;\n  this.op = op;\n  this.output = output;\n};\n\n/**\n * parse fixed huffman block.\n */\nZlib.RawInflate.prototype.parseFixedHuffmanBlock = function() {\n  this.decodeHuffman(\n    Zlib.RawInflate.FixedLiteralLengthTable,\n    Zlib.RawInflate.FixedDistanceTable\n  );\n};\n\n/**\n * parse dynamic huffman block.\n */\nZlib.RawInflate.prototype.parseDynamicHuffmanBlock = function() {\n  /** @type {number} number of literal and length codes. */\n  var hlit = this.readBits(5) + 257;\n  /** @type {number} number of distance codes. */\n  var hdist = this.readBits(5) + 1;\n  /** @type {number} number of code lengths. */\n  var hclen = this.readBits(4) + 4;\n  /** @type {!(Uint8Array|Array.<number>)} code lengths. */\n  var codeLengths =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.RawInflate.Order.length);\n  /** @type {!Array} code lengths table. */\n  var codeLengthsTable;\n  /** @type {!(Uint8Array|Array.<number>)} literal and length code lengths. */\n  var litlenLengths;\n  /** @type {!(Uint8Array|Array.<number>)} distance code lengths. */\n  var distLengths;\n  /** @type {number} loop counter. */\n  var i;\n\n  // decode code lengths\n  for (i = 0; i < hclen; ++i) {\n    codeLengths[Zlib.RawInflate.Order[i]] = this.readBits(3);\n  }\n  if (!USE_TYPEDARRAY) {\n    for (i = hclen, hclen = codeLengths.length; i < hclen; ++i) {\n      codeLengths[Zlib.RawInflate.Order[i]] = 0;\n    }\n  }\n  codeLengthsTable = buildHuffmanTable(codeLengths);\n\n  /**\n   * decode function\n   * @param {number} num number of lengths.\n   * @param {!Array} table code lengths table.\n   * @param {!(Uint8Array|Array.<number>)} lengths code lengths buffer.\n   * @return {!(Uint8Array|Array.<number>)} code lengths buffer.\n   */\n  function decode(num, table, lengths) {\n    /** @type {number} */\n    var code;\n    /** @type {number} */\n    var prev = this.prev;\n    /** @type {number} */\n    var repeat;\n    /** @type {number} */\n    var i;\n\n    for (i = 0; i < num;) {\n      code = this.readCodeByTable(table);\n      switch (code) {\n        case 16:\n          repeat = 3 + this.readBits(2);\n          while (repeat--) { lengths[i++] = prev; }\n          break;\n        case 17:\n          repeat = 3 + this.readBits(3);\n          while (repeat--) { lengths[i++] = 0; }\n          prev = 0;\n          break;\n        case 18:\n          repeat = 11 + this.readBits(7);\n          while (repeat--) { lengths[i++] = 0; }\n          prev = 0;\n          break;\n        default:\n          lengths[i++] = code;\n          prev = code;\n          break;\n      }\n    }\n\n    this.prev = prev;\n\n    return lengths;\n  }\n\n  // literal and length code\n  litlenLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hlit);\n\n  // distance code\n  distLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hdist);\n\n  this.prev = 0;\n  this.decodeHuffman(\n    buildHuffmanTable(decode.call(this, hlit, codeLengthsTable, litlenLengths)),\n    buildHuffmanTable(decode.call(this, hdist, codeLengthsTable, distLengths))\n  );\n};\n\n/**\n * decode huffman code\n * @param {!Array} litlen literal and length code table.\n * @param {!Array} dist distination code table.\n */\nZlib.RawInflate.prototype.decodeHuffman = function(litlen, dist) {\n  var output = this.output;\n  var op = this.op;\n\n  this.currentLitlenTable = litlen;\n\n  /** @type {number} output position limit. */\n  var olength = output.length - Zlib.RawInflate.MaxCopyLength;\n  /** @type {number} huffman code. */\n  var code;\n  /** @type {number} table index. */\n  var ti;\n  /** @type {number} huffman code distination. */\n  var codeDist;\n  /** @type {number} huffman code length. */\n  var codeLength;\n\n  while ((code = this.readCodeByTable(litlen)) !== 256) {\n    // literal\n    if (code < 256) {\n      if (op >= olength) {\n        this.op = op;\n        output = this.expandBuffer();\n        op = this.op;\n      }\n      output[op++] = code;\n\n      continue;\n    }\n\n    // length code\n    ti = code - 257;\n    codeLength = Zlib.RawInflate.LengthCodeTable[ti];\n    if (Zlib.RawInflate.LengthExtraTable[ti] > 0) {\n      codeLength += this.readBits(Zlib.RawInflate.LengthExtraTable[ti]);\n    }\n\n    // dist code\n    code = this.readCodeByTable(dist);\n    codeDist = Zlib.RawInflate.DistCodeTable[code];\n    if (Zlib.RawInflate.DistExtraTable[code] > 0) {\n      codeDist += this.readBits(Zlib.RawInflate.DistExtraTable[code]);\n    }\n\n    // lz77 decode\n    if (op >= olength) {\n      this.op = op;\n      output = this.expandBuffer();\n      op = this.op;\n    }\n    while (codeLength--) {\n      output[op] = output[(op++) - codeDist];\n    }\n  }\n\n  while (this.bitsbuflen >= 8) {\n    this.bitsbuflen -= 8;\n    this.ip--;\n  }\n  this.op = op;\n};\n\n/**\n * decode huffman code (adaptive)\n * @param {!Array} litlen literal and length code table.\n * @param {!Array} dist distination code table.\n */\nZlib.RawInflate.prototype.decodeHuffmanAdaptive = function(litlen, dist) {\n  var output = this.output;\n  var op = this.op;\n\n  this.currentLitlenTable = litlen;\n\n  /** @type {number} output position limit. */\n  var olength = output.length;\n  /** @type {number} huffman code. */\n  var code;\n  /** @type {number} table index. */\n  var ti;\n  /** @type {number} huffman code distination. */\n  var codeDist;\n  /** @type {number} huffman code length. */\n  var codeLength;\n\n  while ((code = this.readCodeByTable(litlen)) !== 256) {\n    // literal\n    if (code < 256) {\n      if (op >= olength) {\n        output = this.expandBuffer();\n        olength = output.length;\n      }\n      output[op++] = code;\n\n      continue;\n    }\n\n    // length code\n    ti = code - 257;\n    codeLength = Zlib.RawInflate.LengthCodeTable[ti];\n    if (Zlib.RawInflate.LengthExtraTable[ti] > 0) {\n      codeLength += this.readBits(Zlib.RawInflate.LengthExtraTable[ti]);\n    }\n\n    // dist code\n    code = this.readCodeByTable(dist);\n    codeDist = Zlib.RawInflate.DistCodeTable[code];\n    if (Zlib.RawInflate.DistExtraTable[code] > 0) {\n      codeDist += this.readBits(Zlib.RawInflate.DistExtraTable[code]);\n    }\n\n    // lz77 decode\n    if (op + codeLength > olength) {\n      output = this.expandBuffer();\n      olength = output.length;\n    }\n    while (codeLength--) {\n      output[op] = output[(op++) - codeDist];\n    }\n  }\n\n  while (this.bitsbuflen >= 8) {\n    this.bitsbuflen -= 8;\n    this.ip--;\n  }\n  this.op = op;\n};\n\n/**\n * expand output buffer.\n * @param {Object=} opt_param option parameters.\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.expandBuffer = function(opt_param) {\n  /** @type {!(Array.<number>|Uint8Array)} store buffer. */\n  var buffer =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(\n        this.op - Zlib.RawInflate.MaxBackwardLength\n    );\n  /** @type {number} backward base point */\n  var backward = this.op - Zlib.RawInflate.MaxBackwardLength;\n  /** @type {number} copy index. */\n  var i;\n  /** @type {number} copy limit */\n  var il;\n\n  var output = this.output;\n\n  // copy to output buffer\n  if (USE_TYPEDARRAY) {\n    buffer.set(output.subarray(Zlib.RawInflate.MaxBackwardLength, buffer.length));\n  } else {\n    for (i = 0, il = buffer.length; i < il; ++i) {\n      buffer[i] = output[i + Zlib.RawInflate.MaxBackwardLength];\n    }\n  }\n\n  this.blocks.push(buffer);\n  this.totalpos += buffer.length;\n\n  // copy to backward buffer\n  if (USE_TYPEDARRAY) {\n    output.set(\n      output.subarray(backward, backward + Zlib.RawInflate.MaxBackwardLength)\n    );\n  } else {\n    for (i = 0; i < Zlib.RawInflate.MaxBackwardLength; ++i) {\n      output[i] = output[backward + i];\n    }\n  }\n\n  this.op = Zlib.RawInflate.MaxBackwardLength;\n\n  return output;\n};\n\n/**\n * expand output buffer. (adaptive)\n * @param {Object=} opt_param option parameters.\n * @return {!(Array.<number>|Uint8Array)} output buffer pointer.\n */\nZlib.RawInflate.prototype.expandBufferAdaptive = function(opt_param) {\n  /** @type {!(Array.<number>|Uint8Array)} store buffer. */\n  var buffer;\n  /** @type {number} expantion ratio. */\n  var ratio = (this.input.length / this.ip + 1) | 0;\n  /** @type {number} maximum number of huffman code. */\n  var maxHuffCode;\n  /** @type {number} new output buffer size. */\n  var newSize;\n  /** @type {number} max inflate size. */\n  var maxInflateSize;\n\n  var input = this.input;\n  var output = this.output;\n\n  if (opt_param) {\n    if (typeof opt_param.fixRatio === 'number') {\n      ratio = opt_param.fixRatio;\n    }\n    if (typeof opt_param.addRatio === 'number') {\n      ratio += opt_param.addRatio;\n    }\n  }\n\n  // calculate new buffer size\n  if (ratio < 2) {\n    maxHuffCode =\n      (input.length - this.ip) / this.currentLitlenTable[2];\n    maxInflateSize = (maxHuffCode / 2 * 258) | 0;\n    newSize = maxInflateSize < output.length ?\n      output.length + maxInflateSize :\n      output.length << 1;\n  } else {\n    newSize = output.length * ratio;\n  }\n\n  // buffer expantion\n  if (USE_TYPEDARRAY) {\n    buffer = new Uint8Array(newSize);\n    buffer.set(output);\n  } else {\n    buffer = output;\n  }\n\n  this.output = buffer;\n\n  return this.output;\n};\n\n/**\n * concat output buffer.\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.concatBuffer = function() {\n  /** @type {number} buffer pointer. */\n  var pos = 0;\n  /** @type {number} buffer pointer. */\n  var limit = this.totalpos + (this.op - Zlib.RawInflate.MaxBackwardLength);\n  /** @type {!(Array.<number>|Uint8Array)} output block array. */\n  var output = this.output;\n  /** @type {!Array} blocks array. */\n  var blocks = this.blocks;\n  /** @type {!(Array.<number>|Uint8Array)} output block array. */\n  var block;\n  /** @type {!(Array.<number>|Uint8Array)} output buffer. */\n  var buffer = new (USE_TYPEDARRAY ? Uint8Array : Array)(limit);\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limiter. */\n  var il;\n  /** @type {number} loop counter. */\n  var j;\n  /** @type {number} loop limiter. */\n  var jl;\n\n  // single buffer\n  if (blocks.length === 0) {\n    return USE_TYPEDARRAY ?\n      this.output.subarray(Zlib.RawInflate.MaxBackwardLength, this.op) :\n      this.output.slice(Zlib.RawInflate.MaxBackwardLength, this.op);\n  }\n\n  // copy to buffer\n  for (i = 0, il = blocks.length; i < il; ++i) {\n    block = blocks[i];\n    for (j = 0, jl = block.length; j < jl; ++j) {\n      buffer[pos++] = block[j];\n    }\n  }\n\n  // current buffer\n  for (i = Zlib.RawInflate.MaxBackwardLength, il = this.op; i < il; ++i) {\n    buffer[pos++] = output[i];\n  }\n\n  this.blocks = [];\n  this.buffer = buffer;\n\n  return this.buffer;\n};\n\n/**\n * concat output buffer. (dynamic)\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.concatBufferDynamic = function() {\n  /** @type {Array.<number>|Uint8Array} output buffer. */\n  var buffer;\n  var op = this.op;\n\n  if (USE_TYPEDARRAY) {\n    if (this.resize) {\n      buffer = new Uint8Array(op);\n      buffer.set(this.output.subarray(0, op));\n    } else {\n      buffer = this.output.subarray(0, op);\n    }\n  } else {\n    if (this.output.length > op) {\n      this.output.length = op;\n    }\n    buffer = this.output;\n  }\n\n  this.buffer = buffer;\n\n  return this.buffer;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.Inflate');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.Adler32');\ngoog.require('Zlib.RawInflate');\n\ngoog.scope(function() {\n\n/**\n * @constructor\n * @param {!(Uint8Array|Array)} input deflated buffer.\n * @param {Object=} opt_params option parameters.\n *\n * opt_params は以下のプロパティを指定する事ができます。\n *   - index: input buffer の deflate コンテナの開始位置.\n *   - blockSize: バッファのブロックサイズ.\n *   - verify: 伸張が終わった後 adler-32 checksum の検証を行うか.\n *   - bufferType: Zlib.Inflate.BufferType の値によってバッファの管理方法を指定する.\n *       Zlib.Inflate.BufferType は Zlib.RawInflate.BufferType のエイリアス.\n */\nZlib.Inflate = function(input, opt_params) {\n  /** @type {number} */\n  var bufferSize;\n  /** @type {Zlib.Inflate.BufferType} */\n  var bufferType;\n  /** @type {number} */\n  var cmf;\n  /** @type {number} */\n  var flg;\n\n  /** @type {!(Uint8Array|Array)} */\n  this.input = input;\n  /** @type {number} */\n  this.ip = 0;\n  /** @type {Zlib.RawInflate} */\n  this.rawinflate;\n  /** @type {(boolean|undefined)} verify flag. */\n  this.verify;\n\n  // option parameters\n  if (opt_params || !(opt_params = {})) {\n    if (opt_params['index']) {\n      this.ip = opt_params['index'];\n    }\n    if (opt_params['verify']) {\n      this.verify = opt_params['verify'];\n    }\n  }\n\n  // Compression Method and Flags\n  cmf = input[this.ip++];\n  flg = input[this.ip++];\n\n  // compression method\n  switch (cmf & 0x0f) {\n    case Zlib.CompressionMethod.DEFLATE:\n      this.method = Zlib.CompressionMethod.DEFLATE;\n      break;\n    default:\n      throw new Error('unsupported compression method');\n  }\n\n  // fcheck\n  if (((cmf << 8) + flg) % 31 !== 0) {\n    throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);\n  }\n\n  // fdict (not supported)\n  if (flg & 0x20) {\n    throw new Error('fdict flag is not supported');\n  }\n\n  // RawInflate\n  this.rawinflate = new Zlib.RawInflate(input, {\n    'index': this.ip,\n    'bufferSize': opt_params['bufferSize'],\n    'bufferType': opt_params['bufferType'],\n    'resize': opt_params['resize']\n  });\n}\n\n/**\n * @enum {number}\n */\nZlib.Inflate.BufferType = Zlib.RawInflate.BufferType;\n\n/**\n * decompress.\n * @return {!(Uint8Array|Array)} inflated buffer.\n */\nZlib.Inflate.prototype.decompress = function() {\n  /** @type {!(Array|Uint8Array)} input buffer. */\n  var input = this.input;\n  /** @type {!(Uint8Array|Array)} inflated buffer. */\n  var buffer;\n  /** @type {number} adler-32 checksum */\n  var adler32;\n\n  buffer = this.rawinflate.decompress();\n  this.ip = this.rawinflate.ip;\n\n  // verify adler-32\n  if (this.verify) {\n    adler32 = (\n      input[this.ip++] << 24 | input[this.ip++] << 16 |\n      input[this.ip++] << 8 | input[this.ip++]\n    ) >>> 0;\n\n    if (adler32 !== Zlib.Adler32(buffer)) {\n      throw new Error('invalid adler-32 checksum');\n    }\n  }\n\n  return buffer;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview Adler32 checksum 実装.\n */\ngoog.provide('Zlib.Adler32');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.Util');\n\ngoog.scope(function() {\n\n/**\n * Adler32 ハッシュ値の作成\n * @param {!(Array|Uint8Array|string)} array 算出に使用する byte array.\n * @return {number} Adler32 ハッシュ値.\n */\nZlib.Adler32 = function(array) {\n  if (typeof(array) === 'string') {\n    array = Zlib.Util.stringToByteArray(array);\n  }\n  return Zlib.Adler32.update(1, array);\n};\n\n/**\n * Adler32 ハッシュ値の更新\n * @param {number} adler 現在のハッシュ値.\n * @param {!(Array|Uint8Array)} array 更新に使用する byte array.\n * @return {number} Adler32 ハッシュ値.\n */\nZlib.Adler32.update = function(adler, array) {\n  /** @type {number} */\n  var s1 = adler & 0xffff;\n  /** @type {number} */\n  var s2 = (adler >>> 16) & 0xffff;\n  /** @type {number} array length */\n  var len = array.length;\n  /** @type {number} loop length (don't overflow) */\n  var tlen;\n  /** @type {number} array index */\n  var i = 0;\n\n  while (len > 0) {\n    tlen = len > Zlib.Adler32.OptimizationParameter ?\n      Zlib.Adler32.OptimizationParameter : len;\n    len -= tlen;\n    do {\n      s1 += array[i++];\n      s2 += s1;\n    } while (--tlen);\n\n    s1 %= 65521;\n    s2 %= 65521;\n  }\n\n  return ((s2 << 16) | s1) >>> 0;\n};\n\n/**\n * Adler32 最適化パラメータ\n * 現状では 1024 程度が最適.\n * @see http://jsperf.com/adler-32-simple-vs-optimized/3\n * @define {number}\n */\nZlib.Adler32.OptimizationParameter = 1024;\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview 雑多な関数群をまとめたモジュール実装.\n */\ngoog.provide('Zlib.Util');\n\ngoog.scope(function() {\n\n/**\n * Byte String から Byte Array に変換.\n * @param {!string} str byte string.\n * @return {!Array.<number>} byte array.\n */\nZlib.Util.stringToByteArray = function(str) {\n  /** @type {!Array.<(string|number)>} */\n  var tmp = str.split('');\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var il;\n\n  for (i = 0, il = tmp.length; i < il; i++) {\n    tmp[i] = (tmp[i].charCodeAt(0) & 0xff) >>> 0;\n  }\n\n  return tmp;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview Zlib namespace. Zlib の仕様に準拠した圧縮は Zlib.Deflate で実装\n * されている. これは Inflate との共存を考慮している為.\n */\n\ngoog.provide('Zlib');\n\n//-----------------------------------------------------------------------------\n\ngoog.scope(function() {\n\n/**\n * Compression Method\n * @enum {number}\n */\nZlib.CompressionMethod = {\n  DEFLATE: 8,\n  RESERVED: 15\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.require('Zlib.Inflate');\ngoog.require('Zlib.exportObject');\n\ngoog.exportSymbol('Zlib.Inflate', Zlib.Inflate);\ngoog.exportSymbol(\n  'Zlib.Inflate.prototype.decompress',\n  Zlib.Inflate.prototype.decompress\n);\nZlib.exportObject('Zlib.Inflate.BufferType', {\n  'ADAPTIVE': Zlib.Inflate.BufferType.ADAPTIVE,\n  'BLOCK': Zlib.Inflate.BufferType.BLOCK\n});\n","goog.provide('Zlib.exportObject');\n\ngoog.require('Zlib');\n\ngoog.scope(function() {\n\nZlib.exportObject = function(enumString, exportKeyValue) {\n  /** @type {Array.<string>} */\n  var keys;\n  /** @type {string} */\n  var key;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var il;\n\n  if (Object.keys) {\n    keys = Object.keys(exportKeyValue);\n  } else {\n    keys = [];\n    i = 0;\n    for (key in exportKeyValue) {\n      keys[i++] = key;\n    }\n  }\n\n  for (i = 0, il = keys.length; i < il; ++i) {\n    key = keys[i];\n    goog.exportSymbol(enumString + '.' + key, exportKeyValue[key])\n  }\n};\n\n});"]} \ No newline at end of file diff --git a/bin/inflate.min.js b/bin/inflate.min.js index 3f0e3be..74f06cd 100644 --- a/bin/inflate.min.js +++ b/bin/inflate.min.js @@ -12,4 +12,4 @@ u.prototype.e=function(){var c=new (s?Uint8Array:Array)(this.b-32768),d=this.b-3 u.prototype.A=function(c){var d,a=this.input.length/this.a+1|0,b,e,f,g=this.input,h=this.c;c&&("number"===typeof c.p&&(a=c.p),"number"===typeof c.v&&(a+=c.v));2>a?(b=(g.length-this.a)/this.o[2],f=258*(b/2)|0,e=fd&&(this.c.length=d),c=this.c);return this.buffer=c};function U(c,d){var a,b;this.input=c;this.a=0;if(d||!(d={}))d.index&&(this.a=d.index),d.verify&&(this.B=d.verify);a=c[this.a++];b=c[this.a++];switch(a&15){case V:this.method=V;break;default:throw Error("unsupported compression method");}if(0!==((a<<8)+b)%31)throw Error("invalid fcheck flag:"+((a<<8)+b)%31);if(b&32)throw Error("fdict flag is not supported");this.r=new u(c,{index:this.a,bufferSize:d.bufferSize,bufferType:d.bufferType,resize:d.resize})} -U.prototype.k=function(){var c=this.input,d,a;d=this.r.k();this.a=this.r.a;if(this.B){a=(c[this.a++]<<24|c[this.a++]<<16|c[this.a++]<<8|c[this.a++])>>>0;var b=d;if("string"===typeof b){var e=b.split(""),f,g;f=0;for(g=e.length;f>>0;b=e}for(var h=1,k=0,l=b.length,p,n=0;0>>0)throw Error("invalid adler-32 checksum");}return d};var V=8;q("Zlib.Inflate",U);q("Zlib.Inflate.prototype.decompress",U.prototype.k);var W={ADAPTIVE:x.t,BLOCK:x.u},X,Y,Z,$;if(Object.keys)X=Object.keys(W);else for(Y in X=[],Z=0,W)X[Z++]=Y;Z=0;for($=X.length;Z<$;++Z)Y=X[Z],q("Zlib.Inflate.BufferType."+Y,W[Y]);}).call(this); //@ sourceMappingURL=inflate.min.js.map +U.prototype.k=function(){var c=this.input,d,a;d=this.r.k();this.a=this.r.a;if(this.B){a=(c[this.a++]<<24|c[this.a++]<<16|c[this.a++]<<8|c[this.a++])>>>0;var b=d;if("string"===typeof b){var e=b.split(""),f,g;f=0;for(g=e.length;f>>0;b=e}for(var h=1,k=0,l=b.length,p,n=0;0>>0)throw Error("invalid adler-32 checksum");}return d};var V=8;q("Zlib.Inflate",U);q("Zlib.Inflate.prototype.decompress",U.prototype.k);var W={ADAPTIVE:x.t,BLOCK:x.u},X,Y,Z,$;if(Object.keys)X=Object.keys(W);else for(Y in X=[],Z=0,W)X[Z++]=Y;Z=0;for($=X.length;Z<$;++Z)Y=X[Z],q("Zlib.Inflate.BufferType."+Y,W[Y]);}).call(this); diff --git a/bin/inflate.min.js.map b/bin/inflate.min.js.map deleted file mode 100644 index 42a5cec..0000000 --- a/bin/inflate.min.js.map +++ /dev/null @@ -1,8 +0,0 @@ -{ -"version":3, -"file":"./inflate.min.js", -"lineCount":15, -"mappings":"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", -"sources":["../closure-primitives/base.js","../define/typedarray/hybrid.js","../src/huffman.js","../src/rawinflate.js","../src/inflate.js","../src/adler32.js","../src/util.js","../src/zlib.js","../export/inflate.js","../src/export_object.js"], -"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","undefined","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","i","j","value","Array","Zlib.RawInflate","input","opt_params","blocks","bufferSize","ZLIB_RAW_INFLATE_BUFFER_SIZE","bitsbuflen","bitsbuf","ip","totalpos","bfinal","bufferType","Zlib.RawInflate.BufferType.ADAPTIVE","resize","Zlib.RawInflate.BufferType.BLOCK","op","Zlib.RawInflate.MaxBackwardLength","output","Zlib.RawInflate.MaxCopyLength","expandBuffer","expandBufferAdaptive","concatBuffer","concatBufferDynamic","decodeHuffman","decodeHuffmanAdaptive","Error","BLOCK","ADAPTIVE","Zlib.RawInflate.BufferType","prototype","decompress","Zlib.RawInflate.prototype.decompress","hdr","readBits","parseBlock","inputLength","len","nlen","olength","preCopy","set","subarray","Zlib.RawInflate.FixedLiteralLengthTable","Zlib.RawInflate.FixedDistanceTable","parseDynamicHuffmanBlock","Zlib.RawInflate.Order","Zlib.RawInflate.LengthCodeTable","Zlib.RawInflate.LengthExtraTable","Zlib.RawInflate.DistCodeTable","Zlib.RawInflate.DistExtraTable","il","Zlib.RawInflate.prototype.readBits","octet","Zlib.RawInflate.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflate.prototype.parseDynamicHuffmanBlock","decode","num","prev","repeat","readCodeByTable","hlit","hdist","hclen","codeLengths","Zlib.RawInflate.Order.length","codeLengthsTable","litlenLengths","distLengths","call","Zlib.RawInflate.prototype.decodeHuffman","litlen","dist","currentLitlenTable","ti","codeDist","Zlib.RawInflate.prototype.decodeHuffmanAdaptive","Zlib.RawInflate.prototype.expandBuffer","buffer","backward","push","Zlib.RawInflate.prototype.expandBufferAdaptive","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","Zlib.RawInflate.prototype.concatBuffer","pos","block","jl","slice","Zlib.RawInflate.prototype.concatBufferDynamic","Zlib.Inflate","cmf","flg","verify","Zlib.CompressionMethod.DEFLATE","method","rawinflate","Zlib.Inflate.prototype.decompress","adler32","array","tmp","charCodeAt","s1","s2","tlen","Zlib.Adler32.OptimizationParameter","DEFLATE","publicPath","keys","key","Object","exportKeyValue","object"] -} diff --git a/bin/inflate_stream.dev.min.js b/bin/inflate_stream.dev.min.js new file mode 100644 index 0000000..fc787f5 --- /dev/null +++ b/bin/inflate_stream.dev.min.js @@ -0,0 +1,14 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var m=void 0,p=!0,s=this;function t(a,d){var b=a.split("."),c=s;!(b[0]in c)&&c.execScript&&c.execScript("var "+b[0]);for(var e;b.length&&(e=b.shift());)!b.length&&d!==m?c[e]=d:c=c[e]?c[e]:c[e]={}};var u="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function v(a){var d=a.length,b=0,c=Number.POSITIVE_INFINITY,e,g,f,l,h,k,n,q,r,w;for(q=0;qb&&(b=a[q]),a[q]>=1;w=f<<16|q;for(r=k;r(e=D(this,3)))E(this),c=-1;else{e&1&&(this.l=p);e>>>=1;switch(e){case 0:this.h=0;break;case 1:this.h=1;break;case 2:this.h=2;break;default:throw Error("unknown BTYPE: "+e);}this.status=2;c=m}0>c&&(b=p);break;case 2:case 3:switch(this.h){case 0:var g;var f=m,l=m,h=this.input,k=this.a;this.status=3;if(k+4>=h.length)g=-1;else{f=h[k++]|h[k++]<< +8;l=h[k++]|h[k++]<<8;if(f===~l)throw Error("invalid uncompressed block header: length verify");this.d=this.e=0;this.a=k;this.m=f;this.status=4;g=m}0>g&&(b=p);break;case 1:this.status=3;this.k=F;this.n=G;this.status=4;break;case 2:0>I(this)&&(b=p)}break;case 4:case 5:switch(this.h){case 0:var n;a:{var q=this.input,r=this.a,w=this.c,B=this.b,H=this.m;for(this.status=5;H--;){B===w.length&&(w=J(this,{o:2}));if(r>=q.length){this.a=r;this.b=B;this.m=H+1;n=-1;break a}w[B++]=q[r++]}0>H&&(this.status=6);this.a= +r;this.b=B;n=0}0>n&&(b=p);break;case 1:case 2:0>K(this)&&(b=p)}break;case 6:this.l?b=p:this.status=A}var z,x=this.b;this.v?u?(z=new Uint8Array(x),z.set(this.c.subarray(this.g,x))):z=this.c.slice(this.g,x):z=u?this.c.subarray(this.g,x):this.c.slice(this.g,x);this.buffer=z;this.g=x;return this.buffer}; +var L=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],M=u?new Uint16Array(L):L,N=[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,258,258],aa=u?new Uint16Array(N):N,O=[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,0,0],P=u?new Uint8Array(O):O,Q=[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],ba=u?new Uint16Array(Q):Q,R=[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],S=u?new Uint8Array(R):R,T=new (u?Uint8Array:Array)(288),U,V;U=0;for(V=T.length;U=U?8:255>=U?9:279>=U?7:8;var F=v(T),W=new (u?Uint8Array:Array)(30),X,Y;X=0;for(Y=W.length;X>>d;a.d=c-d;a.a=g;return f} +function Z(a,d){for(var b=a.e,c=a.d,e=a.input,g=a.a,f=d[0],l=d[1],h,k,n;c>>16;a.e=b>>n;a.d=c-n;a.a=g;return k&65535}function C(a){a.u=a.a;a.s=a.d;a.r=a.e}function E(a){a.a=a.u;a.d=a.s;a.e=a.r} +function I(a){function d(){function a(b,c,d){var e,f=this.p,g,h,k;for(h=0;he)throw Error("not enough input");switch(e){case 16:if(0>(k=D(this,2)))throw Error("not enough input");for(g=3+k;g--;)d[h++]=f;break;case 17:if(0>(k=D(this,3)))throw Error("not enough input");for(g=3+k;g--;)d[h++]=0;f=0;break;case 18:if(0>(k=D(this,7)))throw Error("not enough input");for(g=11+k;g--;)d[h++]=0;f=0;break;default:f=d[h++]=e}}this.p=f;return d}var d;for(k=0;k(d=D(this,3)))throw Error("not enough input"); +g[M[k]]=d}f=v(g);l=new (u?Uint8Array:Array)(b);h=new (u?Uint8Array:Array)(c);this.p=0;this.k=v(a.call(this,b,f,l));this.n=v(a.call(this,c,f,h))}var b,c,e,g=new (u?Uint8Array:Array)(M.length),f,l,h,k=0;a.status=3;C(a);b=D(a,5)+257;c=D(a,5)+1;e=D(a,4)+4;if(0>b||0>c||0>e)return E(a),-1;try{d.call(a)}catch(n){return E(a),-1}a.status=4;return 0} +function K(a){var d=a.c,b=a.b,c,e,g,f,l=a.k,h=a.n,k=d.length,n;for(a.status=5;;){C(a);c=Z(a,l);if(0>c)return a.b=b,E(a),-1;if(256===c)break;if(256>c)b===k&&(d=J(a),k=d.length),d[b++]=c;else{e=c-257;f=aa[e];if(0n)return a.b=b,E(a),-1;f+=n}c=Z(a,h);if(0>c)return a.b=b,E(a),-1;g=ba[c];if(0n)return a.b=b,E(a),-1;g+=n}b+f>=k&&(d=J(a),k=d.length);for(;f--;)d[b]=d[b++-g];if(a.a===a.input.length)return a.b=b,-1}}for(;8<=a.d;)a.d-=8,a.a--;a.b=b;a.status=6} +function J(a,d){var b,c=a.input.length/a.a+1|0,e,g,f,l=a.input,h=a.c;d&&("number"===typeof d.o&&(c=d.o),"number"===typeof d.q&&(c+=d.q));2>c?(e=(l.length-a.a)/a.k[2],f=258*(e/2)|0,g=fe}if(c)return new (u?Uint8Array:Array);d=this.f.i(this.input,this.a);0!==this.f.a&&(this.input=u?this.input.subarray(this.f.a):this.input.slice(this.f.a),this.a=0);return d};$.prototype.j=function(){return this.f.j()};t("Zlib.InflateStream",$);t("Zlib.InflateStream.prototype.decompress",$.prototype.i);t("Zlib.InflateStream.prototype.getBytes",$.prototype.j);}).call(this); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin/inflate_stream.min.js","lineCount":13,"mappings":"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","sources":["closure-primitives/base.js","define/typedarray/hybrid.js","src/huffman.js","src/rawinflate_stream.js","src/inflate_stream.js","src/zlib.js","export/inflate_stream.js"],"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","JSCompiler_alias_VOID","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","i","j","value","Array","Zlib.RawInflateStream","input","ip","opt_buffersize","blocks","bufferSize","ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE","totalpos","bitsbuflen","bitsbuf","output","op","resize","bfinal","sp","status","Zlib.RawInflateStream.Status.INITIALIZED","INITIALIZED","prototype","decompress","Zlib.RawInflateStream.prototype.decompress","newInput","stop","BLOCK_HEADER_START","hdr","readBlockHeader","save_","readBits","restore_","JSCompiler_alias_TRUE","currentBlockType","UNCOMPRESSED","FIXED","DYNAMIC","Error","BLOCK_HEADER_END","BLOCK_BODY_START","len","nlen","readUncompressedBlockHeader","blockLength","BLOCK_BODY_END","parseFixedHuffmanBlock","litlenTable","Zlib.RawInflateStream.FixedLiteralLengthTable","distTable","Zlib.RawInflateStream.FixedDistanceTable","parseDynamicHuffmanBlock","DECODE_BLOCK_START","parseUncompressedBlock","expandBuffer","DECODE_BLOCK_END","decodeHuffman","buffer","concatBuffer","set","subarray","slice","Zlib.RawInflateStream.Order","Zlib.RawInflateStream.LengthCodeTable","Zlib.RawInflateStream.LengthExtraTable","Zlib.RawInflateStream.DistCodeTable","Zlib.RawInflateStream.DistExtraTable","il","Zlib.RawInflateStream.prototype.readBits","octet","Zlib.RawInflateStream.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflateStream.prototype.save_","ip_","bitsbuflen_","bitsbuf_","Zlib.RawInflateStream.prototype.restore_","Zlib.RawInflateStream.prototype.parseDynamicHuffmanBlock","parseDynamicHuffmanBlockImpl","decode","num","prev","repeat","bits","readCodeByTable","hclen","codeLengths","codeLengthsTable","litlenLengths","hlit","distLengths","hdist","call","Zlib.RawInflateStream.Order.length","e","Zlib.RawInflateStream.prototype.decodeHuffman","ti","codeDist","litlen","dist","olength","Zlib.RawInflateStream.prototype.expandBuffer","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","getBytes","Zlib.RawInflateStream.prototype.getBytes","Zlib.InflateStream","rawinflate","Zlib.InflateStream.prototype.decompress","tmp","concat","cmf","flg","DEFLATE","method","Zlib.InflateStream.prototype.getBytes","publicPath"],"sourcesContent":["// Copyright 2006 The Closure Library Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/**\n * @fileoverview Bootstrap for the Google JS Library (Closure).\n *\n * In uncompiled mode base.js will write out Closure's deps file, unless the\n * global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to\n * include their own deps file(s) from different locations.\n *\n */\n\n\n/**\n * @define {boolean} Overridden to true by the compiler when --closure_pass\n *     or --mark_as_compiled is specified.\n */\nvar COMPILED = false;\n\n\n/**\n * Base namespace for the Closure library.  Checks to see goog is\n * already defined in the current scope before assigning to prevent\n * clobbering if base.js is loaded more than once.\n *\n * @const\n */\nvar goog = goog || {}; // Identifies this file as the Closure base.\n\n\n/**\n * Reference to the global context.  In most cases this will be 'window'.\n */\ngoog.global = this;\n\n\n/**\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\n * that should not be included in a production js_binary can be easily stripped\n * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most\n * toString() methods should be declared inside an \"if (goog.DEBUG)\" conditional\n * because they are generally used for debugging purposes and it is difficult\n * for the JSCompiler to statically determine whether they are used.\n */\ngoog.DEBUG = true;\n\n\n/**\n * @define {string} LOCALE defines the locale being used for compilation. It is\n * used to select locale specific data to be compiled in js binary. BUILD rule\n * can specify this value by \"--define goog.LOCALE=<locale_name>\" as JSCompiler\n * option.\n *\n * Take into account that the locale code format is important. You should use\n * the canonical Unicode format with hyphen as a delimiter. Language must be\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\n *\n * See more info about locale codes here:\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\n *\n * For language codes you should use values defined by ISO 693-1. See it here\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\n * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.\n */\ngoog.LOCALE = 'en';  // default to en\n\n\n/**\n * Creates object stubs for a namespace.  The presence of one or more\n * goog.provide() calls indicate that the file defines the given\n * objects/namespaces.  Build tools also scan for provide/require statements\n * to discern dependencies, build dependency files (see deps.js), etc.\n * @see goog.require\n * @param {string} name Namespace provided by this file in the form\n *     \"goog.package.part\".\n */\ngoog.provide = function(name) {\n  if (!COMPILED) {\n    // Ensure that the same namespace isn't provided twice. This is intended\n    // to teach new developers that 'goog.provide' is effectively a variable\n    // declaration. And when JSCompiler transforms goog.provide into a real\n    // variable declaration, the compiled JS should work the same as the raw\n    // JS--even when the raw JS uses goog.provide incorrectly.\n    if (goog.isProvided_(name)) {\n      throw Error('Namespace \"' + name + '\" already declared.');\n    }\n    delete goog.implicitNamespaces_[name];\n\n    var namespace = name;\n    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\n      if (goog.getObjectByName(namespace)) {\n        break;\n      }\n      goog.implicitNamespaces_[namespace] = true;\n    }\n  }\n\n  goog.exportPath_(name);\n};\n\n\n/**\n * Marks that the current file should only be used for testing, and never for\n * live code in production.\n * @param {string=} opt_message Optional message to add to the error that's\n *     raised when used in production code.\n */\ngoog.setTestOnly = function(opt_message) {\n  if (COMPILED && !goog.DEBUG) {\n    opt_message = opt_message || '';\n    throw Error('Importing test-only code into non-debug environment' +\n                opt_message ? ': ' + opt_message : '.');\n  }\n};\n\n\nif (!COMPILED) {\n\n  /**\n   * Check if the given name has been goog.provided. This will return false for\n   * names that are available only as implicit namespaces.\n   * @param {string} name name of the object to look for.\n   * @return {boolean} Whether the name has been provided.\n   * @private\n   */\n  goog.isProvided_ = function(name) {\n    return !goog.implicitNamespaces_[name] && !!goog.getObjectByName(name);\n  };\n\n  /**\n   * Namespaces implicitly defined by goog.provide. For example,\n   * goog.provide('goog.events.Event') implicitly declares\n   * that 'goog' and 'goog.events' must be namespaces.\n   *\n   * @type {Object}\n   * @private\n   */\n  goog.implicitNamespaces_ = {};\n}\n\n\n/**\n * Builds an object structure for the provided namespace path,\n * ensuring that names that already exist are not overwritten. For\n * example:\n * \"a.b.c\" -> a = {};a.b={};a.b.c={};\n * Used by goog.provide and goog.exportSymbol.\n * @param {string} name name of the object that this file defines.\n * @param {*=} opt_object the object to expose at the end of the path.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n * @private\n */\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  var parts = name.split('.');\n  var cur = opt_objectToExportTo || goog.global;\n\n  // Internet Explorer exhibits strange behavior when throwing errors from\n  // methods externed in this manner.  See the testExportSymbolExceptions in\n  // base_test.html for an example.\n  if (!(parts[0] in cur) && cur.execScript) {\n    cur.execScript('var ' + parts[0]);\n  }\n\n  // Certain browsers cannot parse code in the form for((a in b); c;);\n  // This pattern is produced by the JSCompiler when it collapses the\n  // statement above into the conditional loop below. To prevent this from\n  // happening, use a for-loop and reserve the init logic as below.\n\n  // Parentheses added to eliminate strict JS warning in Firefox.\n  for (var part; parts.length && (part = parts.shift());) {\n    if (!parts.length && goog.isDef(opt_object)) {\n      // last part and we have an object; use it\n      cur[part] = opt_object;\n    } else if (cur[part]) {\n      cur = cur[part];\n    } else {\n      cur = cur[part] = {};\n    }\n  }\n};\n\n\n/**\n * Returns an object based on its fully qualified external name.  If you are\n * using a compilation pass that renames property names beware that using this\n * function will not find renamed properties.\n *\n * @param {string} name The fully qualified name.\n * @param {Object=} opt_obj The object within which to look; default is\n *     |goog.global|.\n * @return {?} The value (object or primitive) or, if not found, null.\n */\ngoog.getObjectByName = function(name, opt_obj) {\n  var parts = name.split('.');\n  var cur = opt_obj || goog.global;\n  for (var part; part = parts.shift(); ) {\n    if (goog.isDefAndNotNull(cur[part])) {\n      cur = cur[part];\n    } else {\n      return null;\n    }\n  }\n  return cur;\n};\n\n\n/**\n * Globalizes a whole namespace, such as goog or goog.lang.\n *\n * @param {Object} obj The namespace to globalize.\n * @param {Object=} opt_global The object to add the properties to.\n * @deprecated Properties may be explicitly exported to the global scope, but\n *     this should no longer be done in bulk.\n */\ngoog.globalize = function(obj, opt_global) {\n  var global = opt_global || goog.global;\n  for (var x in obj) {\n    global[x] = obj[x];\n  }\n};\n\n\n/**\n * Adds a dependency from a file to the files it requires.\n * @param {string} relPath The path to the js file.\n * @param {Array} provides An array of strings with the names of the objects\n *                         this file provides.\n * @param {Array} requires An array of strings with the names of the objects\n *                         this file requires.\n */\ngoog.addDependency = function(relPath, provides, requires) {\n  if (!COMPILED) {\n    var provide, require;\n    var path = relPath.replace(/\\\\/g, '/');\n    var deps = goog.dependencies_;\n    for (var i = 0; provide = provides[i]; i++) {\n      deps.nameToPath[provide] = path;\n      if (!(path in deps.pathToNames)) {\n        deps.pathToNames[path] = {};\n      }\n      deps.pathToNames[path][provide] = true;\n    }\n    for (var j = 0; require = requires[j]; j++) {\n      if (!(path in deps.requires)) {\n        deps.requires[path] = {};\n      }\n      deps.requires[path][require] = true;\n    }\n  }\n};\n\n\n\n\n// NOTE(nnaze): The debug DOM loader was included in base.js as an orignal\n// way to do \"debug-mode\" development.  The dependency system can sometimes\n// be confusing, as can the debug DOM loader's asyncronous nature.\n//\n// With the DOM loader, a call to goog.require() is not blocking -- the\n// script will not load until some point after the current script.  If a\n// namespace is needed at runtime, it needs to be defined in a previous\n// script, or loaded via require() with its registered dependencies.\n// User-defined namespaces may need their own deps file.  See http://go/js_deps,\n// http://go/genjsdeps, or, externally, DepsWriter.\n// http://code.google.com/closure/library/docs/depswriter.html\n//\n// Because of legacy clients, the DOM loader can't be easily removed from\n// base.js.  Work is being done to make it disableable or replaceable for\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\n// for example). See bootstrap/ for more information.\n\n\n/**\n * @define {boolean} Whether to enable the debug loader.\n *\n * If enabled, a call to goog.require() will attempt to load the namespace by\n * appending a script tag to the DOM (if the namespace has been registered).\n *\n * If disabled, goog.require() will simply assert that the namespace has been\n * provided (and depend on the fact that some outside tool correctly ordered\n * the script).\n */\ngoog.ENABLE_DEBUG_LOADER = true;\n\n\n/**\n * Implements a system for the dynamic resolution of dependencies\n * that works in parallel with the BUILD system. Note that all calls\n * to goog.require will be stripped by the JSCompiler when the\n * --closure_pass option is used.\n * @see goog.provide\n * @param {string} name Namespace to include (as was given in goog.provide())\n *     in the form \"goog.package.part\".\n */\ngoog.require = function(name) {\n\n  // if the object already exists we do not need do do anything\n  // TODO(arv): If we start to support require based on file name this has\n  //            to change\n  // TODO(arv): If we allow goog.foo.* this has to change\n  // TODO(arv): If we implement dynamic load after page load we should probably\n  //            not remove this code for the compiled output\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      return;\n    }\n\n    if (goog.ENABLE_DEBUG_LOADER) {\n      var path = goog.getPathFromDeps_(name);\n      if (path) {\n        goog.included_[path] = true;\n        goog.writeScripts_();\n        return;\n      }\n    }\n\n    var errorMessage = 'goog.require could not find: ' + name;\n    if (goog.global.console) {\n      goog.global.console['error'](errorMessage);\n    }\n\n\n      throw Error(errorMessage);\n\n  }\n};\n\n\n/**\n * Path for included scripts\n * @type {string}\n */\ngoog.basePath = '';\n\n\n/**\n * A hook for overriding the base path.\n * @type {string|undefined}\n */\ngoog.global.CLOSURE_BASE_PATH;\n\n\n/**\n * Whether to write out Closure's deps file. By default,\n * the deps are written.\n * @type {boolean|undefined}\n */\ngoog.global.CLOSURE_NO_DEPS;\n\n\n/**\n * A function to import a single script. This is meant to be overridden when\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\n * in the global scope so that it can be set before base.js is loaded, which\n * allows deps.js to be imported properly.\n *\n * The function is passed the script source, which is a relative URI. It should\n * return true if the script was imported, false otherwise.\n */\ngoog.global.CLOSURE_IMPORT_SCRIPT;\n\n\n/**\n * Null function used for default values of callbacks, etc.\n * @return {void} Nothing.\n */\ngoog.nullFunction = function() {};\n\n\n/**\n * The identity function. Returns its first argument.\n *\n * @param {*=} opt_returnValue The single value that will be returned.\n * @param {...*} var_args Optional trailing arguments. These are ignored.\n * @return {?} The first argument. We can't know the type -- just pass it along\n *      without type.\n * @deprecated Use goog.functions.identity instead.\n */\ngoog.identityFunction = function(opt_returnValue, var_args) {\n  return opt_returnValue;\n};\n\n\n/**\n * When defining a class Foo with an abstract method bar(), you can do:\n *\n * Foo.prototype.bar = goog.abstractMethod\n *\n * Now if a subclass of Foo fails to override bar(), an error\n * will be thrown when bar() is invoked.\n *\n * Note: This does not take the name of the function to override as\n * an argument because that would make it more difficult to obfuscate\n * our JavaScript code.\n *\n * @type {!Function}\n * @throws {Error} when invoked to indicate the method should be\n *   overridden.\n */\ngoog.abstractMethod = function() {\n  throw Error('unimplemented abstract method');\n};\n\n\n/**\n * Adds a {@code getInstance} static method that always return the same instance\n * object.\n * @param {!Function} ctor The constructor for the class to add the static\n *     method to.\n */\ngoog.addSingletonGetter = function(ctor) {\n  ctor.getInstance = function() {\n    if (ctor.instance_) {\n      return ctor.instance_;\n    }\n    if (goog.DEBUG) {\n      // NOTE: JSCompiler can't optimize away Array#push.\n      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n    }\n    return ctor.instance_ = new ctor;\n  };\n};\n\n\n/**\n * All singleton classes that have been instantiated, for testing. Don't read\n * it directly, use the {@code goog.testing.singleton} module. The compiler\n * removes this variable if unused.\n * @type {!Array.<!Function>}\n * @private\n */\ngoog.instantiatedSingletons_ = [];\n\n\nif (!COMPILED && goog.ENABLE_DEBUG_LOADER) {\n  /**\n   * Object used to keep track of urls that have already been added. This\n   * record allows the prevention of circular dependencies.\n   * @type {Object}\n   * @private\n   */\n  goog.included_ = {};\n\n\n  /**\n   * This object is used to keep track of dependencies and other data that is\n   * used for loading scripts\n   * @private\n   * @type {Object}\n   */\n  goog.dependencies_ = {\n    pathToNames: {}, // 1 to many\n    nameToPath: {}, // 1 to 1\n    requires: {}, // 1 to many\n    // used when resolving dependencies to prevent us from\n    // visiting the file twice\n    visited: {},\n    written: {} // used to keep track of script files we have written\n  };\n\n\n  /**\n   * Tries to detect whether is in the context of an HTML document.\n   * @return {boolean} True if it looks like HTML document.\n   * @private\n   */\n  goog.inHtmlDocument_ = function() {\n    var doc = goog.global.document;\n    return typeof doc != 'undefined' &&\n           'write' in doc;  // XULDocument misses write.\n  };\n\n\n  /**\n   * Tries to detect the base path of the base.js script that bootstraps Closure\n   * @private\n   */\n  goog.findBasePath_ = function() {\n    if (goog.global.CLOSURE_BASE_PATH) {\n      goog.basePath = goog.global.CLOSURE_BASE_PATH;\n      return;\n    } else if (!goog.inHtmlDocument_()) {\n      return;\n    }\n    var doc = goog.global.document;\n    var scripts = doc.getElementsByTagName('script');\n    // Search backwards since the current script is in almost all cases the one\n    // that has base.js.\n    for (var i = scripts.length - 1; i >= 0; --i) {\n      var src = scripts[i].src;\n      var qmark = src.lastIndexOf('?');\n      var l = qmark == -1 ? src.length : qmark;\n      if (src.substr(l - 7, 7) == 'base.js') {\n        goog.basePath = src.substr(0, l - 7);\n        return;\n      }\n    }\n  };\n\n\n  /**\n   * Imports a script if, and only if, that script hasn't already been imported.\n   * (Must be called at execution time)\n   * @param {string} src Script source.\n   * @private\n   */\n  goog.importScript_ = function(src) {\n    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||\n        goog.writeScriptTag_;\n    if (!goog.dependencies_.written[src] && importScript(src)) {\n      goog.dependencies_.written[src] = true;\n    }\n  };\n\n\n  /**\n   * The default implementation of the import function. Writes a script tag to\n   * import the script.\n   *\n   * @param {string} src The script source.\n   * @return {boolean} True if the script was imported, false otherwise.\n   * @private\n   */\n  goog.writeScriptTag_ = function(src) {\n    if (goog.inHtmlDocument_()) {\n      var doc = goog.global.document;\n      doc.write(\n          '<script type=\"text/javascript\" src=\"' + src + '\"></' + 'script>');\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n\n  /**\n   * Resolves dependencies based on the dependencies added using addDependency\n   * and calls importScript_ in the correct order.\n   * @private\n   */\n  goog.writeScripts_ = function() {\n    // the scripts we need to write this time\n    var scripts = [];\n    var seenScript = {};\n    var deps = goog.dependencies_;\n\n    function visitNode(path) {\n      if (path in deps.written) {\n        return;\n      }\n\n      // we have already visited this one. We can get here if we have cyclic\n      // dependencies\n      if (path in deps.visited) {\n        if (!(path in seenScript)) {\n          seenScript[path] = true;\n          scripts.push(path);\n        }\n        return;\n      }\n\n      deps.visited[path] = true;\n\n      if (path in deps.requires) {\n        for (var requireName in deps.requires[path]) {\n          // If the required name is defined, we assume that it was already\n          // bootstrapped by other means.\n          if (!goog.isProvided_(requireName)) {\n            if (requireName in deps.nameToPath) {\n              visitNode(deps.nameToPath[requireName]);\n            } else {\n              throw Error('Undefined nameToPath for ' + requireName);\n            }\n          }\n        }\n      }\n\n      if (!(path in seenScript)) {\n        seenScript[path] = true;\n        scripts.push(path);\n      }\n    }\n\n    for (var path in goog.included_) {\n      if (!deps.written[path]) {\n        visitNode(path);\n      }\n    }\n\n    for (var i = 0; i < scripts.length; i++) {\n      if (scripts[i]) {\n        goog.importScript_(goog.basePath + scripts[i]);\n      } else {\n        throw Error('Undefined script input');\n      }\n    }\n  };\n\n\n  /**\n   * Looks at the dependency rules and tries to determine the script file that\n   * fulfills a particular rule.\n   * @param {string} rule In the form goog.namespace.Class or project.script.\n   * @return {?string} Url corresponding to the rule, or null.\n   * @private\n   */\n  goog.getPathFromDeps_ = function(rule) {\n    if (rule in goog.dependencies_.nameToPath) {\n      return goog.dependencies_.nameToPath[rule];\n    } else {\n      return null;\n    }\n  };\n\n  goog.findBasePath_();\n\n  // Allow projects to manage the deps files themselves.\n  if (!goog.global.CLOSURE_NO_DEPS) {\n    goog.importScript_(goog.basePath + 'deps.js');\n  }\n}\n\n\n\n//==============================================================================\n// Language Enhancements\n//==============================================================================\n\n\n/**\n * This is a \"fixed\" version of the typeof operator.  It differs from the typeof\n * operator in such a way that null returns 'null' and arrays return 'array'.\n * @param {*} value The value to get the type of.\n * @return {string} The name of the type.\n */\ngoog.typeOf = function(value) {\n  var s = typeof value;\n  if (s == 'object') {\n    if (value) {\n      // Check these first, so we can avoid calling Object.prototype.toString if\n      // possible.\n      //\n      // IE improperly marshals tyepof across execution contexts, but a\n      // cross-context object will still return false for \"instanceof Object\".\n      if (value instanceof Array) {\n        return 'array';\n      } else if (value instanceof Object) {\n        return s;\n      }\n\n      // HACK: In order to use an Object prototype method on the arbitrary\n      //   value, the compiler requires the value be cast to type Object,\n      //   even though the ECMA spec explicitly allows it.\n      var className = Object.prototype.toString.call(\n          /** @type {Object} */ (value));\n      // In Firefox 3.6, attempting to access iframe window objects' length\n      // property throws an NS_ERROR_FAILURE, so we need to special-case it\n      // here.\n      if (className == '[object Window]') {\n        return 'object';\n      }\n\n      // We cannot always use constructor == Array or instanceof Array because\n      // different frames have different Array objects. In IE6, if the iframe\n      // where the array was created is destroyed, the array loses its\n      // prototype. Then dereferencing val.splice here throws an exception, so\n      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'\n      // so that will work. In this case, this function will return false and\n      // most array functions will still work because the array is still\n      // array-like (supports length and []) even though it has lost its\n      // prototype.\n      // Mark Miller noticed that Object.prototype.toString\n      // allows access to the unforgeable [[Class]] property.\n      //  15.2.4.2 Object.prototype.toString ( )\n      //  When the toString method is called, the following steps are taken:\n      //      1. Get the [[Class]] property of this object.\n      //      2. Compute a string value by concatenating the three strings\n      //         \"[object \", Result(1), and \"]\".\n      //      3. Return Result(2).\n      // and this behavior survives the destruction of the execution context.\n      if ((className == '[object Array]' ||\n           // In IE all non value types are wrapped as objects across window\n           // boundaries (not iframe though) so we have to do object detection\n           // for this edge case\n           typeof value.length == 'number' &&\n           typeof value.splice != 'undefined' &&\n           typeof value.propertyIsEnumerable != 'undefined' &&\n           !value.propertyIsEnumerable('splice')\n\n          )) {\n        return 'array';\n      }\n      // HACK: There is still an array case that fails.\n      //     function ArrayImpostor() {}\n      //     ArrayImpostor.prototype = [];\n      //     var impostor = new ArrayImpostor;\n      // this can be fixed by getting rid of the fast path\n      // (value instanceof Array) and solely relying on\n      // (value && Object.prototype.toString.vall(value) === '[object Array]')\n      // but that would require many more function calls and is not warranted\n      // unless closure code is receiving objects from untrusted sources.\n\n      // IE in cross-window calls does not correctly marshal the function type\n      // (it appears just as an object) so we cannot use just typeof val ==\n      // 'function'. However, if the object has a call property, it is a\n      // function.\n      if ((className == '[object Function]' ||\n          typeof value.call != 'undefined' &&\n          typeof value.propertyIsEnumerable != 'undefined' &&\n          !value.propertyIsEnumerable('call'))) {\n        return 'function';\n      }\n\n\n    } else {\n      return 'null';\n    }\n\n  } else if (s == 'function' && typeof value.call == 'undefined') {\n    // In Safari typeof nodeList returns 'function', and on Firefox\n    // typeof behaves similarly for HTML{Applet,Embed,Object}Elements\n    // and RegExps.  We would like to return object for those and we can\n    // detect an invalid function by making sure that the function\n    // object has a call method.\n    return 'object';\n  }\n  return s;\n};\n\n\n/**\n * Returns true if the specified value is not |undefined|.\n * WARNING: Do not use this to test if an object has a property. Use the in\n * operator instead.  Additionally, this function assumes that the global\n * undefined variable has not been redefined.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined.\n */\ngoog.isDef = function(val) {\n  return val !== undefined;\n};\n\n\n/**\n * Returns true if the specified value is |null|\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is null.\n */\ngoog.isNull = function(val) {\n  return val === null;\n};\n\n\n/**\n * Returns true if the specified value is defined and not null\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined and not null.\n */\ngoog.isDefAndNotNull = function(val) {\n  // Note that undefined == null.\n  return val != null;\n};\n\n\n/**\n * Returns true if the specified value is an array\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArray = function(val) {\n  return goog.typeOf(val) == 'array';\n};\n\n\n/**\n * Returns true if the object looks like an array. To qualify as array like\n * the value needs to be either a NodeList or an object with a Number length\n * property.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArrayLike = function(val) {\n  var type = goog.typeOf(val);\n  return type == 'array' || type == 'object' && typeof val.length == 'number';\n};\n\n\n/**\n * Returns true if the object looks like a Date. To qualify as Date-like\n * the value needs to be an object and have a getFullYear() function.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a like a Date.\n */\ngoog.isDateLike = function(val) {\n  return goog.isObject(val) && typeof val.getFullYear == 'function';\n};\n\n\n/**\n * Returns true if the specified value is a string\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a string.\n */\ngoog.isString = function(val) {\n  return typeof val == 'string';\n};\n\n\n/**\n * Returns true if the specified value is a boolean\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is boolean.\n */\ngoog.isBoolean = function(val) {\n  return typeof val == 'boolean';\n};\n\n\n/**\n * Returns true if the specified value is a number\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a number.\n */\ngoog.isNumber = function(val) {\n  return typeof val == 'number';\n};\n\n\n/**\n * Returns true if the specified value is a function\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a function.\n */\ngoog.isFunction = function(val) {\n  return goog.typeOf(val) == 'function';\n};\n\n\n/**\n * Returns true if the specified value is an object.  This includes arrays\n * and functions.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an object.\n */\ngoog.isObject = function(val) {\n  var type = typeof val;\n  return type == 'object' && val != null || type == 'function';\n  // return Object(val) === val also works, but is slower, especially if val is\n  // not an object.\n};\n\n\n/**\n * Gets a unique ID for an object. This mutates the object so that further\n * calls with the same object as a parameter returns the same value. The unique\n * ID is guaranteed to be unique across the current session amongst objects that\n * are passed into {@code getUid}. There is no guarantee that the ID is unique\n * or consistent across sessions. It is unsafe to generate unique ID for\n * function prototypes.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {number} The unique ID for the object.\n */\ngoog.getUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // In Opera window.hasOwnProperty exists but always returns false so we avoid\n  // using it. As a consequence the unique ID generated for BaseClass.prototype\n  // and SubClass.prototype will be the same.\n  return obj[goog.UID_PROPERTY_] ||\n      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n\n\n/**\n * Removes the unique ID from an object. This is useful if the object was\n * previously mutated using {@code goog.getUid} in which case the mutation is\n * undone.\n * @param {Object} obj The object to remove the unique ID field from.\n */\ngoog.removeUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // DOM nodes in IE are not instance of Object and throws exception\n  // for delete. Instead we try to use removeAttribute\n  if ('removeAttribute' in obj) {\n    obj.removeAttribute(goog.UID_PROPERTY_);\n  }\n  /** @preserveTry */\n  try {\n    delete obj[goog.UID_PROPERTY_];\n  } catch (ex) {\n  }\n};\n\n\n/**\n * Name for unique ID property. Initialized in a way to help avoid collisions\n * with other closure javascript on the same page.\n * @type {string}\n * @private\n */\ngoog.UID_PROPERTY_ = 'closure_uid_' +\n    Math.floor(Math.random() * 2147483648).toString(36);\n\n\n/**\n * Counter for UID.\n * @type {number}\n * @private\n */\ngoog.uidCounter_ = 0;\n\n\n/**\n * Adds a hash code field to an object. The hash code is unique for the\n * given object.\n * @param {Object} obj The object to get the hash code for.\n * @return {number} The hash code for the object.\n * @deprecated Use goog.getUid instead.\n */\ngoog.getHashCode = goog.getUid;\n\n\n/**\n * Removes the hash code field from an object.\n * @param {Object} obj The object to remove the field from.\n * @deprecated Use goog.removeUid instead.\n */\ngoog.removeHashCode = goog.removeUid;\n\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n *\n * WARNINGS:\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\n * refer to themselves will cause infinite recursion.\n *\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\n * UIDs created by <code>getUid</code> into cloned results.\n *\n * @param {*} obj The value to clone.\n * @return {*} A clone of the input value.\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n  var type = goog.typeOf(obj);\n  if (type == 'object' || type == 'array') {\n    if (obj.clone) {\n      return obj.clone();\n    }\n    var clone = type == 'array' ? [] : {};\n    for (var key in obj) {\n      clone[key] = goog.cloneObject(obj[key]);\n    }\n    return clone;\n  }\n\n  return obj;\n};\n\n\n/**\n * Forward declaration for the clone method. This is necessary until the\n * compiler can better support duck-typing constructs as used in\n * goog.cloneObject.\n *\n * TODO(brenneman): Remove once the JSCompiler can infer that the check for\n * proto.clone is safe in goog.cloneObject.\n *\n * @type {Function}\n */\nObject.prototype.clone;\n\n\n/**\n * A native implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n * @suppress {deprecated} The compiler thinks that Function.prototype.bind\n *     is deprecated because some people have declared a pure-JS version.\n *     Only the pure-JS version is truly deprecated.\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\n};\n\n\n/**\n * A pure-JS implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n  if (!fn) {\n    throw new Error();\n  }\n\n  if (arguments.length > 2) {\n    var boundArgs = Array.prototype.slice.call(arguments, 2);\n    return function() {\n      // Prepend the bound arguments to the current arguments.\n      var newArgs = Array.prototype.slice.call(arguments);\n      Array.prototype.unshift.apply(newArgs, boundArgs);\n      return fn.apply(selfObj, newArgs);\n    };\n\n  } else {\n    return function() {\n      return fn.apply(selfObj, arguments);\n    };\n  }\n};\n\n\n/**\n * Partially applies this function to a particular 'this object' and zero or\n * more arguments. The result is a new function with some arguments of the first\n * function pre-filled and the value of |this| 'pre-specified'.<br><br>\n *\n * Remaining arguments specified at call-time are appended to the pre-\n * specified ones.<br><br>\n *\n * Also see: {@link #partial}.<br><br>\n *\n * Usage:\n * <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');\n * barMethBound('arg3', 'arg4');</pre>\n *\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @suppress {deprecated} See above.\n */\ngoog.bind = function(fn, selfObj, var_args) {\n  // TODO(nicksantos): narrow the type signature.\n  if (Function.prototype.bind &&\n      // NOTE(nicksantos): Somebody pulled base.js into the default\n      // Chrome extension environment. This means that for Chrome extensions,\n      // they get the implementation of Function.prototype.bind that\n      // calls goog.bind instead of the native one. Even worse, we don't want\n      // to introduce a circular dependency between goog.bind and\n      // Function.prototype.bind, so we have to hack this to make sure it\n      // works correctly.\n      Function.prototype.bind.toString().indexOf('native code') != -1) {\n    goog.bind = goog.bindNative_;\n  } else {\n    goog.bind = goog.bindJs_;\n  }\n  return goog.bind.apply(null, arguments);\n};\n\n\n/**\n * Like bind(), except that a 'this object' is not required. Useful when the\n * target function is already bound.\n *\n * Usage:\n * var g = partial(f, arg1, arg2);\n * g(arg3, arg4);\n *\n * @param {Function} fn A function to partially apply.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to fn.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n */\ngoog.partial = function(fn, var_args) {\n  var args = Array.prototype.slice.call(arguments, 1);\n  return function() {\n    // Prepend the bound arguments to the current arguments.\n    var newArgs = Array.prototype.slice.call(arguments);\n    newArgs.unshift.apply(newArgs, args);\n    return fn.apply(this, newArgs);\n  };\n};\n\n\n/**\n * Copies all the members of a source object to a target object. This method\n * does not work on all browsers for all objects that contain keys such as\n * toString or hasOwnProperty. Use goog.object.extend for this purpose.\n * @param {Object} target Target.\n * @param {Object} source Source.\n */\ngoog.mixin = function(target, source) {\n  for (var x in source) {\n    target[x] = source[x];\n  }\n\n  // For IE7 or lower, the for-in-loop does not contain any properties that are\n  // not enumerable on the prototype object (for example, isPrototypeOf from\n  // Object.prototype) but also it will not include 'replace' on objects that\n  // extend String and change 'replace' (not that it is common for anyone to\n  // extend anything except Object).\n};\n\n\n/**\n * @return {number} An integer value representing the number of milliseconds\n *     between midnight, January 1, 1970 and the current time.\n */\ngoog.now = Date.now || (function() {\n  // Unary plus operator converts its operand to a number which in the case of\n  // a date is done by calling getTime().\n  return +new Date();\n});\n\n\n/**\n * Evals javascript in the global scope.  In IE this uses execScript, other\n * browsers use goog.global.eval. If goog.global.eval does not evaluate in the\n * global scope (for example, in Safari), appends a script tag instead.\n * Throws an exception if neither execScript or eval is defined.\n * @param {string} script JavaScript string.\n */\ngoog.globalEval = function(script) {\n  if (goog.global.execScript) {\n    goog.global.execScript(script, 'JavaScript');\n  } else if (goog.global.eval) {\n    // Test to see if eval works\n    if (goog.evalWorksForGlobals_ == null) {\n      goog.global.eval('var _et_ = 1;');\n      if (typeof goog.global['_et_'] != 'undefined') {\n        delete goog.global['_et_'];\n        goog.evalWorksForGlobals_ = true;\n      } else {\n        goog.evalWorksForGlobals_ = false;\n      }\n    }\n\n    if (goog.evalWorksForGlobals_) {\n      goog.global.eval(script);\n    } else {\n      var doc = goog.global.document;\n      var scriptElt = doc.createElement('script');\n      scriptElt.type = 'text/javascript';\n      scriptElt.defer = false;\n      // Note(user): can't use .innerHTML since \"t('<test>')\" will fail and\n      // .text doesn't work in Safari 2.  Therefore we append a text node.\n      scriptElt.appendChild(doc.createTextNode(script));\n      doc.body.appendChild(scriptElt);\n      doc.body.removeChild(scriptElt);\n    }\n  } else {\n    throw Error('goog.globalEval not available');\n  }\n};\n\n\n/**\n * Indicates whether or not we can call 'eval' directly to eval code in the\n * global scope. Set to a Boolean by the first call to goog.globalEval (which\n * empirically tests whether eval works for globals). @see goog.globalEval\n * @type {?boolean}\n * @private\n */\ngoog.evalWorksForGlobals_ = null;\n\n\n/**\n * Optional map of CSS class names to obfuscated names used with\n * goog.getCssName().\n * @type {Object|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMapping_;\n\n\n/**\n * Optional obfuscation style for CSS class names. Should be set to either\n * 'BY_WHOLE' or 'BY_PART' if defined.\n * @type {string|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMappingStyle_;\n\n\n/**\n * Handles strings that are intended to be used as CSS class names.\n *\n * This function works in tandem with @see goog.setCssNameMapping.\n *\n * Without any mapping set, the arguments are simple joined with a\n * hyphen and passed through unaltered.\n *\n * When there is a mapping, there are two possible styles in which\n * these mappings are used. In the BY_PART style, each part (i.e. in\n * between hyphens) of the passed in css name is rewritten according\n * to the map. In the BY_WHOLE style, the full css name is looked up in\n * the map directly. If a rewrite is not specified by the map, the\n * compiler will output a warning.\n *\n * When the mapping is passed to the compiler, it will replace calls\n * to goog.getCssName with the strings from the mapping, e.g.\n *     var x = goog.getCssName('foo');\n *     var y = goog.getCssName(this.baseClass, 'active');\n *  becomes:\n *     var x= 'foo';\n *     var y = this.baseClass + '-active';\n *\n * If one argument is passed it will be processed, if two are passed\n * only the modifier will be processed, as it is assumed the first\n * argument was generated as a result of calling goog.getCssName.\n *\n * @param {string} className The class name.\n * @param {string=} opt_modifier A modifier to be appended to the class name.\n * @return {string} The class name or the concatenation of the class name and\n *     the modifier.\n */\ngoog.getCssName = function(className, opt_modifier) {\n  var getMapping = function(cssName) {\n    return goog.cssNameMapping_[cssName] || cssName;\n  };\n\n  var renameByParts = function(cssName) {\n    // Remap all the parts individually.\n    var parts = cssName.split('-');\n    var mapped = [];\n    for (var i = 0; i < parts.length; i++) {\n      mapped.push(getMapping(parts[i]));\n    }\n    return mapped.join('-');\n  };\n\n  var rename;\n  if (goog.cssNameMapping_) {\n    rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?\n        getMapping : renameByParts;\n  } else {\n    rename = function(a) {\n      return a;\n    };\n  }\n\n  if (opt_modifier) {\n    return className + '-' + rename(opt_modifier);\n  } else {\n    return rename(className);\n  }\n};\n\n\n/**\n * Sets the map to check when returning a value from goog.getCssName(). Example:\n * <pre>\n * goog.setCssNameMapping({\n *   \"goog\": \"a\",\n *   \"disabled\": \"b\",\n * });\n *\n * var x = goog.getCssName('goog');\n * // The following evaluates to: \"a a-b\".\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\n * </pre>\n * When declared as a map of string literals to string literals, the JSCompiler\n * will replace all calls to goog.getCssName() using the supplied map if the\n * --closure_pass flag is set.\n *\n * @param {!Object} mapping A map of strings to strings where keys are possible\n *     arguments to goog.getCssName() and values are the corresponding values\n *     that should be returned.\n * @param {string=} opt_style The style of css name mapping. There are two valid\n *     options: 'BY_PART', and 'BY_WHOLE'.\n * @see goog.getCssName for a description.\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n  goog.cssNameMapping_ = mapping;\n  goog.cssNameMappingStyle_ = opt_style;\n};\n\n\n/**\n * To use CSS renaming in compiled mode, one of the input files should have a\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\n * mode, JavaScript code should be loaded before this base.js file that declares\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\n * are made in uncompiled mode.\n *\n * A hook for overriding the CSS name mapping.\n * @type {Object|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\n\n\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n  // This does not call goog.setCssNameMapping() because the JSCompiler\n  // requires that goog.setCssNameMapping() be called with an object literal.\n  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n\n\n/**\n * Abstract implementation of goog.getMsg for use with localized messages.\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {Object=} opt_values Map of place holder name to value.\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values) {\n  var values = opt_values || {};\n  for (var key in values) {\n    var value = ('' + values[key]).replace(/\\$/g, '$$$$');\n    str = str.replace(new RegExp('\\\\{\\\\$' + key + '\\\\}', 'gi'), value);\n  }\n  return str;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated,\n * unless they are exported in turn via this function or\n * goog.exportProperty\n *\n * <p>Also handy for making public items that are defined in anonymous\n * closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction',\n *                       Foo.staticFunction);\n *     public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n *                       Foo.prototype.myMethod);\n *     new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n */\ngoog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {\n  goog.exportPath_(publicPath, object, opt_objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n  object[publicName] = symbol;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * <pre>\n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { }\n *\n * function ChildClass(a, b, c) {\n *   goog.base(this, a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // works\n * </pre>\n *\n * In addition, a superclass' implementation of a method can be invoked\n * as follows:\n *\n * <pre>\n * ChildClass.prototype.foo = function(a) {\n *   ChildClass.superClass_.foo.call(this, a);\n *   // other code\n * };\n * </pre>\n *\n * @param {Function} childCtor Child class.\n * @param {Function} parentCtor Parent class.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n  /** @constructor */\n  function tempCtor() {};\n  tempCtor.prototype = parentCtor.prototype;\n  childCtor.superClass_ = parentCtor.prototype;\n  childCtor.prototype = new tempCtor();\n  childCtor.prototype.constructor = childCtor;\n};\n\n\n/**\n * Call up to the superclass.\n *\n * If this is called from a constructor, then this calls the superclass\n * contructor with arguments 1-N.\n *\n * If this is called from a prototype method, then you must pass\n * the name of the method as the second argument to this function. If\n * you do not, you will get a runtime error. This calls the superclass'\n * method with arguments 2-N.\n *\n * This function only works if you use goog.inherits to express\n * inheritance relationships between your classes.\n *\n * This function is a compiler primitive. At compile-time, the\n * compiler will do macro expansion to remove a lot of\n * the extra overhead that this function introduces. The compiler\n * will also enforce a lot of the assumptions that this function\n * makes, and treat it as a compiler error if you break them.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {*=} opt_methodName The method name if calling a super method.\n * @param {...*} var_args The rest of the arguments.\n * @return {*} The return value of the superclass method.\n */\ngoog.base = function(me, opt_methodName, var_args) {\n  var caller = arguments.callee.caller;\n  if (caller.superClass_) {\n    // This is a constructor. Call the superclass constructor.\n    return caller.superClass_.constructor.apply(\n        me, Array.prototype.slice.call(arguments, 1));\n  }\n\n  var args = Array.prototype.slice.call(arguments, 2);\n  var foundCaller = false;\n  for (var ctor = me.constructor;\n       ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {\n    if (ctor.prototype[opt_methodName] === caller) {\n      foundCaller = true;\n    } else if (foundCaller) {\n      return ctor.prototype[opt_methodName].apply(me, args);\n    }\n  }\n\n  // If we did not find the caller in the prototype chain,\n  // then one of two things happened:\n  // 1) The caller is an instance method.\n  // 2) This method was not called by the right caller.\n  if (me[opt_methodName] === caller) {\n    return me.constructor.prototype[opt_methodName].apply(me, args);\n  } else {\n    throw Error(\n        'goog.base called from a method of one name ' +\n        'to a method of a different name');\n  }\n};\n\n\n/**\n * Allow for aliasing within scope functions.  This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the\n * aliases applied.  In uncompiled code the function is simply run since the\n * aliases as written are valid JavaScript.\n * @param {function()} fn Function to call.  This function can contain aliases\n *     to namespaces (e.g. \"var dom = goog.dom\") or classes\n *    (e.g. \"var Timer = goog.Timer\").\n */\ngoog.scope = function(fn) {\n  fn.call(goog.global);\n};\n\n\n","/**\n * defines\n */\n\ngoog.provide('USE_TYPEDARRAY');\n\n// Safari が typeof Uint8Array === 'object' になるため、\n// 未定義か否かで Typed Array の使用を決定する\n\n/** @const {boolean} use typed array flag. */\nvar USE_TYPEDARRAY =\n  (typeof Uint8Array !== 'undefined') &&\n  (typeof Uint16Array !== 'undefined') &&\n  (typeof Uint32Array !== 'undefined') &&\n  (typeof DataView !== 'undefined');\n","goog.provide('Zlib.Huffman');\n\ngoog.require('USE_TYPEDARRAY');\n\ngoog.scope(function() {\n\n/**\n * build huffman table from length list.\n * @param {!(Array.<number>|Uint8Array)} lengths length list.\n * @return {!Array} huffman table.\n */\nZlib.Huffman.buildHuffmanTable = function(lengths) {\n  /** @type {number} length list size. */\n  var listSize = lengths.length;\n  /** @type {number} max code length for table size. */\n  var maxCodeLength = 0;\n  /** @type {number} min code length for table size. */\n  var minCodeLength = Number.POSITIVE_INFINITY;\n  /** @type {number} table size. */\n  var size;\n  /** @type {!(Array|Uint8Array)} huffman code table. */\n  var table;\n  /** @type {number} bit length. */\n  var bitLength;\n  /** @type {number} huffman code. */\n  var code;\n  /**\n   * サイズが 2^maxlength 個のテーブルを埋めるためのスキップ長.\n   * @type {number} skip length for table filling.\n   */\n  var skip;\n  /** @type {number} reversed code. */\n  var reversed;\n  /** @type {number} reverse temp. */\n  var rtemp;\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limit. */\n  var il;\n  /** @type {number} loop counter. */\n  var j;\n  /** @type {number} table value. */\n  var value;\n\n  // Math.max は遅いので最長の値は for-loop で取得する\n  for (i = 0, il = listSize; i < il; ++i) {\n    if (lengths[i] > maxCodeLength) {\n      maxCodeLength = lengths[i];\n    }\n    if (lengths[i] < minCodeLength) {\n      minCodeLength = lengths[i];\n    }\n  }\n\n  size = 1 << maxCodeLength;\n  table = new (USE_TYPEDARRAY ? Uint32Array : Array)(size);\n\n  // ビット長の短い順からハフマン符号を割り当てる\n  for (bitLength = 1, code = 0, skip = 2; bitLength <= maxCodeLength;) {\n    for (i = 0; i < listSize; ++i) {\n      if (lengths[i] === bitLength) {\n        // ビットオーダーが逆になるためビット長分並びを反転する\n        for (reversed = 0, rtemp = code, j = 0; j < bitLength; ++j) {\n          reversed = (reversed << 1) | (rtemp & 1);\n          rtemp >>= 1;\n        }\n\n        // 最大ビット長をもとにテーブルを作るため、\n        // 最大ビット長以外では 0 / 1 どちらでも良い箇所ができる\n        // そのどちらでも良い場所は同じ値で埋めることで\n        // 本来のビット長以上のビット数取得しても問題が起こらないようにする\n        value = (bitLength << 16) | i;\n        for (j = reversed; j < size; j += skip) {\n          table[j] = value;\n        }\n\n        ++code;\n      }\n    }\n\n    // 次のビット長へ\n    ++bitLength;\n    code <<= 1;\n    skip <<= 1;\n  }\n\n  return [table, maxCodeLength, minCodeLength];\n};\n\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.RawInflateStream');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.Huffman');\n\n//-----------------------------------------------------------------------------\n\n/** @define {number} buffer block size. */\nvar ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE = 0x8000;\n\n//-----------------------------------------------------------------------------\n\ngoog.scope(function() {\n\nvar buildHuffmanTable = Zlib.Huffman.buildHuffmanTable;\n\n/**\n * @param {!(Uint8Array|Array.<number>)} input input buffer.\n * @param {number} ip input buffer pointer.\n * @param {number=} opt_buffersize buffer block size.\n * @constructor\n */\nZlib.RawInflateStream = function(input, ip, opt_buffersize) {\n  /** @type {!(Array|Uint8Array)} inflated buffer */\n  this.buffer;\n  /** @type {!Array.<(Array|Uint8Array)>} */\n  this.blocks = [];\n  /** @type {number} block size. */\n  this.bufferSize =\n    opt_buffersize ? opt_buffersize : ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE;\n  /** @type {!number} total output buffer pointer. */\n  this.totalpos = 0;\n  /** @type {!number} input buffer pointer. */\n  this.ip = ip === void 0 ? 0 : ip;\n  /** @type {!number} bit stream reader buffer. */\n  this.bitsbuf = 0;\n  /** @type {!number} bit stream reader buffer size. */\n  this.bitsbuflen = 0;\n  /** @type {!(Array|Uint8Array)} input buffer. */\n  this.input = USE_TYPEDARRAY ? new Uint8Array(input) : input;\n  /** @type {!(Uint8Array|Array)} output buffer. */\n  this.output = new (USE_TYPEDARRAY ? Uint8Array : Array)(this.bufferSize);\n  /** @type {!number} output buffer pointer. */\n  this.op = 0;\n  /** @type {boolean} is final block flag. */\n  this.bfinal = false;\n  /** @type {number} uncompressed block length. */\n  this.blockLength;\n  /** @type {boolean} resize flag for memory size optimization. */\n  this.resize = false;\n  /** @type {Array} */\n  this.litlenTable;\n  /** @type {Array} */\n  this.distTable;\n  /** @type {number} */\n  this.sp = 0; // stream pointer\n  /** @type {Zlib.RawInflateStream.Status} */\n  this.status = Zlib.RawInflateStream.Status.INITIALIZED;\n  /** @type {number} previous RLE value */\n  this.prev;\n\n  //\n  // backup\n  //\n  /** @type {!number} */\n  this.ip_;\n  /** @type {!number} */\n  this.bitsbuflen_;\n  /** @type {!number} */\n  this.bitsbuf_;\n};\n\n/**\n * @enum {number}\n */\nZlib.RawInflateStream.BlockType = {\n  UNCOMPRESSED: 0,\n  FIXED: 1,\n  DYNAMIC: 2\n};\n\n/**\n * @enum {number}\n */\nZlib.RawInflateStream.Status = {\n  INITIALIZED: 0,\n  BLOCK_HEADER_START: 1,\n  BLOCK_HEADER_END: 2,\n  BLOCK_BODY_START: 3,\n  BLOCK_BODY_END: 4,\n  DECODE_BLOCK_START: 5,\n  DECODE_BLOCK_END: 6\n};\n\n/**\n * decompress.\n * @return {!(Uint8Array|Array)} inflated buffer.\n */\nZlib.RawInflateStream.prototype.decompress = function(newInput, ip) {\n  /** @type {boolean} */\n  var stop = false;\n\n  if (newInput !== void 0) {\n    this.input = newInput;\n  }\n\n  if (ip !== void 0) {\n    this.ip = ip;\n  }\n\n  // decompress\n  while (!stop) {\n    switch (this.status) {\n      // block header\n      case Zlib.RawInflateStream.Status.INITIALIZED:\n      case Zlib.RawInflateStream.Status.BLOCK_HEADER_START:\n        if (this.readBlockHeader() < 0) {\n          stop = true;\n        }\n        break;\n      // block body\n      case Zlib.RawInflateStream.Status.BLOCK_HEADER_END: /* FALLTHROUGH */\n      case Zlib.RawInflateStream.Status.BLOCK_BODY_START:\n        switch(this.currentBlockType) {\n          case Zlib.RawInflateStream.BlockType.UNCOMPRESSED:\n            if (this.readUncompressedBlockHeader() < 0) {\n              stop = true;\n            }\n            break;\n          case Zlib.RawInflateStream.BlockType.FIXED:\n            if (this.parseFixedHuffmanBlock() < 0) {\n              stop = true;\n            }\n            break;\n          case Zlib.RawInflateStream.BlockType.DYNAMIC:\n            if (this.parseDynamicHuffmanBlock() < 0) {\n              stop = true;\n            }\n            break;\n        }\n        break;\n      // decode data\n      case Zlib.RawInflateStream.Status.BLOCK_BODY_END:\n      case Zlib.RawInflateStream.Status.DECODE_BLOCK_START:\n        switch(this.currentBlockType) {\n          case Zlib.RawInflateStream.BlockType.UNCOMPRESSED:\n            if (this.parseUncompressedBlock() < 0) {\n              stop = true;\n            }\n            break;\n          case Zlib.RawInflateStream.BlockType.FIXED: /* FALLTHROUGH */\n          case Zlib.RawInflateStream.BlockType.DYNAMIC:\n            if (this.decodeHuffman() < 0) {\n              stop = true;\n            }\n            break;\n        }\n        break;\n      case Zlib.RawInflateStream.Status.DECODE_BLOCK_END:\n        if (this.bfinal) {\n          stop = true;\n        } else {\n          this.status = Zlib.RawInflateStream.Status.INITIALIZED;\n        }\n        break;\n    }\n  }\n\n  return this.concatBuffer();\n};\n\n/**\n * @const\n * @type {number} max backward length for LZ77.\n */\nZlib.RawInflateStream.MaxBackwardLength = 32768;\n\n/**\n * @const\n * @type {number} max copy length for LZ77.\n */\nZlib.RawInflateStream.MaxCopyLength = 258;\n\n/**\n * huffman order\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflateStream.Order = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n\n/**\n * huffman length code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflateStream.LengthCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b,\n  0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b,\n  0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3,\n  0x00e3, 0x0102, 0x0102, 0x0102\n]);\n\n/**\n * huffman length extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflateStream.LengthExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  5, 5, 0, 0, 0\n]);\n\n/**\n * huffman dist code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflateStream.DistCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011,\n  0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181,\n  0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001,\n  0x3001, 0x4001, 0x6001\n]);\n\n/**\n * huffman dist extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflateStream.DistExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  11, 12, 12, 13, 13\n]);\n\n/**\n * fixed huffman length code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflateStream.FixedLiteralLengthTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(288);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] =\n      (i <= 143) ? 8 :\n      (i <= 255) ? 9 :\n      (i <= 279) ? 7 :\n      8;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * fixed huffman distance code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflateStream.FixedDistanceTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(30);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] = 5;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * parse deflated block.\n */\nZlib.RawInflateStream.prototype.readBlockHeader = function() {\n  /** @type {number} header */\n  var hdr;\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_HEADER_START;\n\n  this.save_();\n  if ((hdr = this.readBits(3)) < 0) {\n    this.restore_();\n    return -1;\n  }\n\n  // BFINAL\n  if (hdr & 0x1) {\n    this.bfinal = true;\n  }\n\n  // BTYPE\n  hdr >>>= 1;\n  switch (hdr) {\n    case 0: // uncompressed\n      this.currentBlockType = Zlib.RawInflateStream.BlockType.UNCOMPRESSED;\n      break;\n    case 1: // fixed huffman\n      this.currentBlockType = Zlib.RawInflateStream.BlockType.FIXED;\n      break;\n    case 2: // dynamic huffman\n      this.currentBlockType = Zlib.RawInflateStream.BlockType.DYNAMIC;\n      break;\n    default: // reserved or other\n      throw new Error('unknown BTYPE: ' + hdr);\n  }\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_HEADER_END;\n};\n\n/**\n * read inflate bits\n * @param {number} length bits length.\n * @return {number} read bits.\n */\nZlib.RawInflateStream.prototype.readBits = function(length) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {number} input and output byte. */\n  var octet;\n\n  // not enough buffer\n  while (bitsbuflen < length) {\n    // input byte\n    if (input.length <= ip) {\n      return -1;\n    }\n    octet = input[ip++];\n\n    // concat octet\n    bitsbuf |= octet << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // output byte\n  octet = bitsbuf & /* MASK */ ((1 << length) - 1);\n  bitsbuf >>>= length;\n  bitsbuflen -= length;\n\n  this.bitsbuf = bitsbuf;\n  this.bitsbuflen = bitsbuflen;\n  this.ip = ip;\n\n  return octet;\n};\n\n/**\n * read huffman code using table\n * @param {Array} table huffman code table.\n * @return {number} huffman code.\n */\nZlib.RawInflateStream.prototype.readCodeByTable = function(table) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {!(Array|Uint8Array)} huffman code table */\n  var codeTable = table[0];\n  /** @type {number} */\n  var maxCodeLength = table[1];\n  /** @type {number} input byte */\n  var octet;\n  /** @type {number} code length & code (16bit, 16bit) */\n  var codeWithLength;\n  /** @type {number} code bits length */\n  var codeLength;\n\n  // not enough buffer\n  while (bitsbuflen < maxCodeLength) {\n    if (input.length <= ip) {\n      return -1;\n    }\n    octet = input[ip++];\n    bitsbuf |= octet << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // read max length\n  codeWithLength = codeTable[bitsbuf & ((1 << maxCodeLength) - 1)];\n  codeLength = codeWithLength >>> 16;\n\n  this.bitsbuf = bitsbuf >> codeLength;\n  this.bitsbuflen = bitsbuflen - codeLength;\n  this.ip = ip;\n\n  return codeWithLength & 0xffff;\n};\n\n/**\n * read uncompressed block header\n */\nZlib.RawInflateStream.prototype.readUncompressedBlockHeader = function() {\n  /** @type {number} block length */\n  var len;\n  /** @type {number} number for check block length */\n  var nlen;\n\n  var input = this.input;\n  var ip = this.ip;\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;\n\n  if (ip + 4 >= input.length) {\n    return -1;\n  }\n\n  len = input[ip++] | (input[ip++] << 8);\n  nlen = input[ip++] | (input[ip++] << 8);\n\n  // check len & nlen\n  if (len === ~nlen) {\n    throw new Error('invalid uncompressed block header: length verify');\n  }\n\n  // skip buffered header bits\n  this.bitsbuf = 0;\n  this.bitsbuflen = 0;\n\n  this.ip = ip;\n  this.blockLength = len;\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;\n}\n\n/**\n * parse uncompressed block.\n */\nZlib.RawInflateStream.prototype.parseUncompressedBlock = function() {\n  var input = this.input;\n  var ip = this.ip;\n  var output = this.output;\n  var op = this.op;\n  var len = this.blockLength;\n\n  this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_START;\n\n  // copy\n  // XXX: とりあえず素直にコピー\n  while (len--) {\n    if (op === output.length) {\n      output = this.expandBuffer({fixRatio: 2});\n    }\n\n    // not enough input buffer\n    if (ip >= input.length) {\n      this.ip = ip;\n      this.op = op;\n      this.blockLength = len + 1; // コピーしてないので戻す\n      return -1;\n    }\n\n    output[op++] = input[ip++];\n  }\n\n  if (len < 0) {\n    this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_END;\n  }\n\n  this.ip = ip;\n  this.op = op;\n\n  return 0;\n};\n\n/**\n * parse fixed huffman block.\n */\nZlib.RawInflateStream.prototype.parseFixedHuffmanBlock = function() {\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;\n\n  this.litlenTable = Zlib.RawInflateStream.FixedLiteralLengthTable;\n  this.distTable = Zlib.RawInflateStream.FixedDistanceTable;\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;\n\n  return 0;\n};\n\n/**\n * オブジェクトのコンテキストを別のプロパティに退避する.\n * @private\n */\nZlib.RawInflateStream.prototype.save_ = function() {\n  this.ip_ = this.ip;\n  this.bitsbuflen_ = this.bitsbuflen;\n  this.bitsbuf_ = this.bitsbuf;\n};\n\n/**\n * 別のプロパティに退避したコンテキストを復元する.\n * @private\n */\nZlib.RawInflateStream.prototype.restore_ = function() {\n  this.ip = this.ip_;\n  this.bitsbuflen = this.bitsbuflen_;\n  this.bitsbuf = this.bitsbuf_;\n};\n\n/**\n * parse dynamic huffman block.\n */\nZlib.RawInflateStream.prototype.parseDynamicHuffmanBlock = function() {\n  /** @type {number} number of literal and length codes. */\n  var hlit;\n  /** @type {number} number of distance codes. */\n  var hdist;\n  /** @type {number} number of code lengths. */\n  var hclen;\n  /** @type {!(Uint8Array|Array)} code lengths. */\n  var codeLengths =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.RawInflateStream.Order.length);\n  /** @type {!Array} code lengths table. */\n  var codeLengthsTable;\n  /** @type {!(Uint32Array|Array)} literal and length code lengths. */\n  var litlenLengths;\n  /** @type {!(Uint32Array|Array)} distance code lengths. */\n  var distLengths;\n  /** @type {number} loop counter. */\n  var i = 0;\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_START;\n\n  this.save_();\n  hlit = this.readBits(5) + 257;\n  hdist = this.readBits(5) + 1;\n  hclen = this.readBits(4) + 4;\n  if (hlit < 0 || hdist < 0 || hclen < 0) {\n    this.restore_();\n    return -1;\n  }\n\n  try {\n    parseDynamicHuffmanBlockImpl.call(this);\n  } catch(e) {\n    this.restore_();\n    return -1;\n  }\n\n  function parseDynamicHuffmanBlockImpl() {\n    /** @type {number} */\n    var bits;\n\n    // decode code lengths\n    for (i = 0; i < hclen; ++i) {\n      if ((bits = this.readBits(3)) < 0) {\n        throw new Error('not enough input');\n      }\n      codeLengths[Zlib.RawInflateStream.Order[i]] = bits;\n    }\n    codeLengthsTable = buildHuffmanTable(codeLengths);\n\n    // decode function\n    function decode(num, table, lengths) {\n      var code;\n      var prev = this.prev;\n      var repeat;\n      var i;\n      var bits;\n\n      for (i = 0; i < num;) {\n        code = this.readCodeByTable(table);\n        if (code < 0) {\n          throw new Error('not enough input');\n        }\n        switch (code) {\n          case 16:\n            if ((bits = this.readBits(2)) < 0) {\n              throw new Error('not enough input');\n            }\n            repeat = 3 + bits;\n            while (repeat--) { lengths[i++] = prev; }\n            break;\n          case 17:\n            if ((bits = this.readBits(3)) < 0) {\n              throw new Error('not enough input');\n            }\n            repeat = 3 + bits;\n            while (repeat--) { lengths[i++] = 0; }\n            prev = 0;\n            break;\n          case 18:\n            if ((bits = this.readBits(7)) < 0) {\n              throw new Error('not enough input');\n            }\n            repeat = 11 + bits;\n            while (repeat--) { lengths[i++] = 0; }\n            prev = 0;\n            break;\n          default:\n            lengths[i++] = code;\n            prev = code;\n            break;\n        }\n      }\n\n      this.prev = prev;\n\n      return lengths;\n    }\n\n    // literal and length code\n    litlenLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hlit);\n\n    // distance code\n    distLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hdist);\n\n    this.prev = 0;\n    this.litlenTable = buildHuffmanTable(decode.call(this, hlit, codeLengthsTable, litlenLengths));\n    this.distTable = buildHuffmanTable(decode.call(this, hdist, codeLengthsTable, distLengths));\n  }\n\n  this.status = Zlib.RawInflateStream.Status.BLOCK_BODY_END;\n\n  return 0;\n};\n\n/**\n * decode huffman code (dynamic)\n * @return {(number|undefined)} -1 is error.\n */\nZlib.RawInflateStream.prototype.decodeHuffman = function() {\n  var output = this.output;\n  var op = this.op;\n\n  /** @type {number} huffman code. */\n  var code;\n  /** @type {number} table index. */\n  var ti;\n  /** @type {number} huffman code distination. */\n  var codeDist;\n  /** @type {number} huffman code length. */\n  var codeLength;\n\n  var litlen = this.litlenTable;\n  var dist = this.distTable;\n\n  var olength = output.length;\n  var bits;\n\n  this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_START;\n\n  while (true) {\n    this.save_();\n\n    code = this.readCodeByTable(litlen);\n    if (code < 0) {\n      this.op = op;\n      this.restore_();\n      return -1;\n    }\n\n    if (code === 256) {\n      break;\n    }\n\n    // literal\n    if (code < 256) {\n      if (op === olength) {\n        output = this.expandBuffer();\n        olength = output.length;\n      }\n      output[op++] = code;\n\n      continue;\n    }\n\n    // length code\n    ti = code - 257;\n    codeLength = Zlib.RawInflateStream.LengthCodeTable[ti];\n    if (Zlib.RawInflateStream.LengthExtraTable[ti] > 0) {\n      bits = this.readBits(Zlib.RawInflateStream.LengthExtraTable[ti]);\n      if (bits < 0) {\n        this.op = op;\n        this.restore_();\n        return -1;\n      }\n      codeLength += bits;\n    }\n\n    // dist code\n    code = this.readCodeByTable(dist);\n    if (code < 0) {\n      this.op = op;\n      this.restore_();\n      return -1;\n    }\n    codeDist = Zlib.RawInflateStream.DistCodeTable[code];\n    if (Zlib.RawInflateStream.DistExtraTable[code] > 0) {\n      bits = this.readBits(Zlib.RawInflateStream.DistExtraTable[code]);\n      if (bits < 0) {\n        this.op = op;\n        this.restore_();\n        return -1;\n      }\n      codeDist += bits;\n    }\n\n    // lz77 decode\n    if (op + codeLength >= olength) {\n      output = this.expandBuffer();\n      olength = output.length;\n    }\n\n    while (codeLength--) {\n      output[op] = output[(op++) - codeDist];\n    }\n\n    // break\n    if (this.ip === this.input.length) {\n      this.op = op;\n      return -1;\n    }\n  }\n\n  while (this.bitsbuflen >= 8) {\n    this.bitsbuflen -= 8;\n    this.ip--;\n  }\n\n  this.op = op;\n  this.status = Zlib.RawInflateStream.Status.DECODE_BLOCK_END;\n};\n\n/**\n * expand output buffer. (dynamic)\n * @param {Object=} opt_param option parameters.\n * @return {!(Array|Uint8Array)} output buffer pointer.\n */\nZlib.RawInflateStream.prototype.expandBuffer = function(opt_param) {\n  /** @type {!(Array|Uint8Array)} store buffer. */\n  var buffer;\n  /** @type {number} expantion ratio. */\n  var ratio = (this.input.length / this.ip + 1) | 0;\n  /** @type {number} maximum number of huffman code. */\n  var maxHuffCode;\n  /** @type {number} new output buffer size. */\n  var newSize;\n  /** @type {number} max inflate size. */\n  var maxInflateSize;\n\n  var input = this.input;\n  var output = this.output;\n\n  if (opt_param) {\n    if (typeof opt_param.fixRatio === 'number') {\n      ratio = opt_param.fixRatio;\n    }\n    if (typeof opt_param.addRatio === 'number') {\n      ratio += opt_param.addRatio;\n    }\n  }\n\n  // calculate new buffer size\n  if (ratio < 2) {\n    maxHuffCode =\n      (input.length - this.ip) / this.litlenTable[2];\n    maxInflateSize = (maxHuffCode / 2 * 258) | 0;\n    newSize = maxInflateSize < output.length ?\n      output.length + maxInflateSize :\n      output.length << 1;\n  } else {\n    newSize = output.length * ratio;\n  }\n\n  // buffer expantion\n  if (USE_TYPEDARRAY) {\n    buffer = new Uint8Array(newSize);\n    buffer.set(output);\n  } else {\n    buffer = output;\n  }\n\n  this.output = buffer;\n\n  return this.output;\n};\n\n/**\n * concat output buffer. (dynamic)\n * @return {!(Array|Uint8Array)} output buffer.\n */\nZlib.RawInflateStream.prototype.concatBuffer = function() {\n  /** @type {!(Array|Uint8Array)} output buffer. */\n  var buffer;\n\n  var resize = this.resize;\n\n  var op = this.op;\n\n  if (resize) {\n    if (USE_TYPEDARRAY) {\n      buffer = new Uint8Array(op);\n      buffer.set(this.output.subarray(this.sp, op));\n    } else {\n      buffer = this.output.slice(this.sp, op);\n    }\n  } else {\n    buffer =\n      USE_TYPEDARRAY ? this.output.subarray(this.sp, op) : this.output.slice(this.sp, op);\n  }\n\n\n  this.buffer = buffer;\n  this.sp = op;\n\n  return this.buffer;\n};\n\n/**\n * @return {!(Array|Uint8Array)} current output buffer.\n */\nZlib.RawInflateStream.prototype.getBytes = function() {\n  return USE_TYPEDARRAY ?\n    this.output.subarray(0, this.op) : this.output.slice(0, this.op);\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.InflateStream');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib');\n//goog.require('Zlib.Adler32');\ngoog.require('Zlib.RawInflateStream');\n\ngoog.scope(function() {\n\n/**\n * @param {!(Uint8Array|Array)} input deflated buffer.\n * @constructor\n */\nZlib.InflateStream = function(input) {\n  /** @type {!(Uint8Array|Array)} */\n  this.input = input === void 0 ? new (USE_TYPEDARRAY ? Uint8Array : Array)() : input;\n  /** @type {number} */\n  this.ip = 0;\n  /** @type {Zlib.RawInflateStream} */\n  this.rawinflate = new Zlib.RawInflateStream(this.input, this.ip);\n  /** @type {Zlib.CompressionMethod} */\n  this.method;\n  /** @type {!(Array|Uint8Array)} */\n  this.output = this.rawinflate.output;\n};\n\n/**\n * decompress.\n * @return {!(Uint8Array|Array)} inflated buffer.\n */\nZlib.InflateStream.prototype.decompress = function(input) {\n  /** @type {!(Uint8Array|Array)} inflated buffer. */\n  var buffer;\n  /** @type {number} adler-32 checksum */\n  var adler32;\n\n  // 新しい入力を入力バッファに結合する\n  // XXX Array, Uint8Array のチェックを行うか確認する\n  if (input !== void 0) {\n    if (USE_TYPEDARRAY) {\n      var tmp = new Uint8Array(this.input.length + input.length);\n      tmp.set(this.input, 0);\n      tmp.set(input, this.input.length);\n      this.input = tmp;\n    } else {\n      this.input = this.input.concat(input);\n    }\n  }\n\n  if (this.method === void 0) {\n    if(this.readHeader() < 0) {\n      return new (USE_TYPEDARRAY ? Uint8Array : Array)();\n    }\n  }\n\n  buffer = this.rawinflate.decompress(this.input, this.ip);\n  if (this.rawinflate.ip !== 0) {\n    this.input = USE_TYPEDARRAY ?\n      this.input.subarray(this.rawinflate.ip) :\n      this.input.slice(this.rawinflate.ip);\n    this.ip = 0;\n  }\n\n  // verify adler-32\n  /*\n  if (this.verify) {\n    adler32 =\n      input[this.ip++] << 24 | input[this.ip++] << 16 |\n      input[this.ip++] << 8 | input[this.ip++];\n\n    if (adler32 !== Zlib.Adler32(buffer)) {\n      throw new Error('invalid adler-32 checksum');\n    }\n  }\n  */\n\n  return buffer;\n};\n\n/**\n * @return {!(Uint8Array|Array)} current output buffer.\n */\nZlib.InflateStream.prototype.getBytes = function() {\n  return this.rawinflate.getBytes();\n};\n\nZlib.InflateStream.prototype.readHeader = function() {\n  var ip = this.ip;\n  var input = this.input;\n\n  // Compression Method and Flags\n  var cmf = input[ip++];\n  var flg = input[ip++];\n\n  if (cmf === void 0 || flg === void 0) {\n    return -1;\n  }\n\n  // compression method\n  switch (cmf & 0x0f) {\n    case Zlib.CompressionMethod.DEFLATE:\n      this.method = Zlib.CompressionMethod.DEFLATE;\n      break;\n    default:\n      throw new Error('unsupported compression method');\n  }\n\n  // fcheck\n  if (((cmf << 8) + flg) % 31 !== 0) {\n    throw new Error('invalid fcheck flag:' + ((cmf << 8) + flg) % 31);\n  }\n\n  // fdict (not supported)\n  if (flg & 0x20) {\n    throw new Error('fdict flag is not supported');\n  }\n\n  this.ip = ip;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview Zlib namespace. Zlib の仕様に準拠した圧縮は Zlib.Deflate で実装\n * されている. これは Inflate との共存を考慮している為.\n */\n\ngoog.provide('Zlib');\n\n//-----------------------------------------------------------------------------\n\ngoog.scope(function() {\n\n/**\n * Compression Method\n * @enum {number}\n */\nZlib.CompressionMethod = {\n  DEFLATE: 8,\n  RESERVED: 15\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.require('Zlib.InflateStream');\n\ngoog.exportSymbol('Zlib.InflateStream', Zlib.InflateStream);\ngoog.exportSymbol(\n  'Zlib.InflateStream.prototype.decompress',\n  Zlib.InflateStream.prototype.decompress\n);\ngoog.exportSymbol(\n  'Zlib.InflateStream.prototype.getBytes',\n  Zlib.InflateStream.prototype.getBytes\n);"]} \ No newline at end of file diff --git a/bin/inflate_stream.min.js b/bin/inflate_stream.min.js index 851c7ab..5689138 100644 --- a/bin/inflate_stream.min.js +++ b/bin/inflate_stream.min.js @@ -10,4 +10,4 @@ g[M[k]]=d}f=v(g);l=new (u?Uint8Array:Array)(b);h=new (u?Uint8Array:Array)(c);thi function K(a){var d=a.c,b=a.b,c,e,g,f,l=a.k,h=a.n,k=d.length,n;for(a.status=5;;){C(a);c=Z(a,l);if(0>c)return a.b=b,E(a),-1;if(256===c)break;if(256>c)b===k&&(d=J(a),k=d.length),d[b++]=c;else{e=c-257;f=aa[e];if(0n)return a.b=b,E(a),-1;f+=n}c=Z(a,h);if(0>c)return a.b=b,E(a),-1;g=ba[c];if(0n)return a.b=b,E(a),-1;g+=n}b+f>=k&&(d=J(a),k=d.length);for(;f--;)d[b]=d[b++-g];if(a.a===a.input.length)return a.b=b,-1}}for(;8<=a.d;)a.d-=8,a.a--;a.b=b;a.status=6} function J(a,d){var b,c=a.input.length/a.a+1|0,e,g,f,l=a.input,h=a.c;d&&("number"===typeof d.o&&(c=d.o),"number"===typeof d.q&&(c+=d.q));2>c?(e=(l.length-a.a)/a.k[2],f=258*(e/2)|0,g=fe}if(c)return new (u?Uint8Array:Array);d=this.f.i(this.input,this.a);0!==this.f.a&&(this.input=u?this.input.subarray(this.f.a):this.input.slice(this.f.a),this.a=0);return d};$.prototype.j=function(){return this.f.j()};t("Zlib.InflateStream",$);t("Zlib.InflateStream.prototype.decompress",$.prototype.i);t("Zlib.InflateStream.prototype.getBytes",$.prototype.j);}).call(this); //@ sourceMappingURL=inflate_stream.min.js.map +this.a=g;e=m}c=0>e}if(c)return new (u?Uint8Array:Array);d=this.f.i(this.input,this.a);0!==this.f.a&&(this.input=u?this.input.subarray(this.f.a):this.input.slice(this.f.a),this.a=0);return d};$.prototype.j=function(){return this.f.j()};t("Zlib.InflateStream",$);t("Zlib.InflateStream.prototype.decompress",$.prototype.i);t("Zlib.InflateStream.prototype.getBytes",$.prototype.j);}).call(this); diff --git a/bin/inflate_stream.min.js.map b/bin/inflate_stream.min.js.map deleted file mode 100644 index b8b0765..0000000 --- a/bin/inflate_stream.min.js.map +++ /dev/null @@ -1,8 +0,0 @@ -{ -"version":3, -"file":"./inflate_stream.min.js", -"lineCount":13, -"mappings":"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", -"sources":["../closure-primitives/base.js","../define/typedarray/hybrid.js","../src/huffman.js","../src/rawinflate_stream.js","../src/inflate_stream.js","../src/zlib.js","../export/inflate_stream.js"], -"names":["goog.global","goog.exportPath_","name","opt_object","parts","split","cur","execScript","part","length","shift","JSCompiler_alias_VOID","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","i","j","value","Array","Zlib.RawInflateStream","input","ip","opt_buffersize","blocks","bufferSize","ZLIB_STREAM_RAW_INFLATE_BUFFER_SIZE","totalpos","bitsbuflen","bitsbuf","output","op","resize","bfinal","sp","status","Zlib.RawInflateStream.Status.INITIALIZED","INITIALIZED","prototype","decompress","Zlib.RawInflateStream.prototype.decompress","newInput","stop","BLOCK_HEADER_START","hdr","readBlockHeader","save_","readBits","restore_","JSCompiler_alias_TRUE","currentBlockType","UNCOMPRESSED","FIXED","DYNAMIC","Error","BLOCK_HEADER_END","BLOCK_BODY_START","len","nlen","readUncompressedBlockHeader","blockLength","BLOCK_BODY_END","parseFixedHuffmanBlock","litlenTable","Zlib.RawInflateStream.FixedLiteralLengthTable","distTable","Zlib.RawInflateStream.FixedDistanceTable","parseDynamicHuffmanBlock","DECODE_BLOCK_START","parseUncompressedBlock","expandBuffer","DECODE_BLOCK_END","decodeHuffman","buffer","concatBuffer","set","subarray","slice","Zlib.RawInflateStream.Order","Zlib.RawInflateStream.LengthCodeTable","Zlib.RawInflateStream.LengthExtraTable","Zlib.RawInflateStream.DistCodeTable","Zlib.RawInflateStream.DistExtraTable","il","Zlib.RawInflateStream.prototype.readBits","octet","Zlib.RawInflateStream.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflateStream.prototype.save_","ip_","bitsbuflen_","bitsbuf_","Zlib.RawInflateStream.prototype.restore_","Zlib.RawInflateStream.prototype.parseDynamicHuffmanBlock","parseDynamicHuffmanBlockImpl","decode","num","prev","repeat","bits","readCodeByTable","hclen","codeLengths","codeLengthsTable","litlenLengths","hlit","distLengths","hdist","call","Zlib.RawInflateStream.Order.length","e","Zlib.RawInflateStream.prototype.decodeHuffman","ti","codeDist","litlen","dist","olength","Zlib.RawInflateStream.prototype.expandBuffer","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","getBytes","Zlib.RawInflateStream.prototype.getBytes","Zlib.InflateStream","rawinflate","Zlib.InflateStream.prototype.decompress","tmp","concat","cmf","flg","DEFLATE","method","Zlib.InflateStream.prototype.getBytes","publicPath"] -} diff --git a/bin/node-zlib.dev.js b/bin/node-zlib.dev.js new file mode 100644 index 0000000..76f8859 --- /dev/null +++ b/bin/node-zlib.dev.js @@ -0,0 +1,54 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';function q(b){throw b;}var t=void 0,v=!0;var A="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function E(b,a){this.index="number"===typeof a?a:0;this.m=0;this.buffer=b instanceof(A?Uint8Array:Array)?b:new (A?Uint8Array:Array)(32768);2*this.buffer.length<=this.index&&q(Error("invalid index"));this.buffer.length<=this.index&&this.f()}E.prototype.f=function(){var b=this.buffer,a,c=b.length,d=new (A?Uint8Array:Array)(c<<1);if(A)d.set(b);else for(a=0;a>>8&255]<<16|G[b>>>16&255]<<8|G[b>>>24&255])>>32-a:G[b]>>8-a);if(8>a+f)g=g<>a-k-1&1,8===++f&&(f=0,d[e++]=G[g],g=0,e===d.length&&(d=this.f()));d[e]=g;this.buffer=d;this.m=f;this.index=e};E.prototype.finish=function(){var b=this.buffer,a=this.index,c;0J;++J){for(var N=J,Q=N,ba=7,N=N>>>1;N;N>>>=1)Q<<=1,Q|=N&1,--ba;aa[J]=(Q<>>0}var G=aa;function R(b,a,c){var d,e="number"===typeof a?a:a=0,f="number"===typeof c?c:b.length;d=-1;for(e=f&7;e--;++a)d=d>>>8^S[(d^b[a])&255];for(e=f>>3;e--;a+=8)d=d>>>8^S[(d^b[a])&255],d=d>>>8^S[(d^b[a+1])&255],d=d>>>8^S[(d^b[a+2])&255],d=d>>>8^S[(d^b[a+3])&255],d=d>>>8^S[(d^b[a+4])&255],d=d>>>8^S[(d^b[a+5])&255],d=d>>>8^S[(d^b[a+6])&255],d=d>>>8^S[(d^b[a+7])&255];return(d^4294967295)>>>0} +var ga=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],S=A?new Uint32Array(ga):ga;function ha(){};function ia(b){this.buffer=new (A?Uint16Array:Array)(2*b);this.length=0}ia.prototype.getParent=function(b){return 2*((b-2)/4|0)};ia.prototype.push=function(b,a){var c,d,e=this.buffer,f;c=this.length;e[this.length++]=a;for(e[this.length++]=b;0e[d])f=e[c],e[c]=e[d],e[d]=f,f=e[c+1],e[c+1]=e[d+1],e[d+1]=f,c=d;else break;return this.length}; +ia.prototype.pop=function(){var b,a,c=this.buffer,d,e,f;a=c[0];b=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(f=0;;){e=2*f+2;if(e>=this.length)break;e+2c[e]&&(e+=2);if(c[e]>c[f])d=c[f],c[f]=c[e],c[e]=d,d=c[f+1],c[f+1]=c[e+1],c[e+1]=d;else break;f=e}return{index:b,value:a,length:this.length}};function ja(b){var a=b.length,c=0,d=Number.POSITIVE_INFINITY,e,f,g,k,h,l,s,p,m,n;for(p=0;pc&&(c=b[p]),b[p]>=1;n=g<<16|p;for(m=l;mT;T++)switch(v){case 143>=T:pa.push([T+48,8]);break;case 255>=T:pa.push([T-144+400,9]);break;case 279>=T:pa.push([T-256+0,7]);break;case 287>=T:pa.push([T-280+192,8]);break;default:q("invalid literal: "+T)} +ma.prototype.h=function(){var b,a,c,d,e=this.input;switch(this.k){case 0:c=0;for(d=e.length;c>>8&255;m[n++]=l&255;m[n++]=l>>>8&255;if(A)m.set(f,n),n+=f.length,m=m.subarray(0,n);else{s=0;for(p=f.length;sz)for(;0< +z--;)H[F++]=0,L[0]++;else for(;0z?z:138,C>z-3&&C=C?(H[F++]=17,H[F++]=C-3,L[17]++):(H[F++]=18,H[F++]=C-11,L[18]++),z-=C;else if(H[F++]=I[w],L[I[w]]++,z--,3>z)for(;0z?z:6,C>z-3&&CB;B++)sa[B]=ka[qb[B]];for(W=19;4=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:q("invalid length: "+a)}}var a=[],c,d;for(c=3;258>=c;c++)d=b(c),a[c]=d[2]<<24|d[1]<< +16|d[0];return a}(),xa=A?new Uint32Array(wa):wa; +function qa(b,a){function c(a,c){var b=a.O,d=[],f=0,e;e=xa[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(v){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b- +65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>= +b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:q("invalid distance")}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var h,k;h=0;for(k=d.length;h=f;)u[f++]=0;for(f=0;29>=f;)x[f++]=0}u[256]=1;d=0;for(e=a.length;d=e){p&&c(p,-1);f=0;for(g=e-d;fg&&a+gf&&(e=d,f=g);if(258===g)break}return new ua(f,a-e)} +function ra(b,a){var c=b.length,d=new ia(572),e=new (A?Uint8Array:Array)(c),f,g,k,h,l;if(!A)for(h=0;h2*e[n-1]+f[n]&&(e[n]=2*e[n-1]+f[n]),k[n]=Array(e[n]),h[n]=Array(e[n]);for(m=0;mb[m]?(k[n][r]=u,h[n][r]=a,x+=2):(k[n][r]=b[m],h[n][r]=m,++m);l[n]=0;1===f[n]&&d(n)}return g} +function ta(b){var a=new (A?Uint16Array:Array)(b.length),c=[],d=[],e=0,f,g,k,h;f=0;for(g=b.length;f>>=1}return a};function Aa(b,a){this.input=b;this.b=this.c=0;this.g={};a&&(a.flags&&(this.g=a.flags),"string"===typeof a.filename&&(this.filename=a.filename),"string"===typeof a.comment&&(this.w=a.comment),a.deflateOptions&&(this.l=a.deflateOptions));this.l||(this.l={})} +Aa.prototype.h=function(){var b,a,c,d,e,f,g,k,h=new (A?Uint8Array:Array)(32768),l=0,s=this.input,p=this.c,m=this.filename,n=this.w;h[l++]=31;h[l++]=139;h[l++]=8;b=0;this.g.fname&&(b|=Ba);this.g.fcomment&&(b|=Ca);this.g.fhcrc&&(b|=Da);h[l++]=b;a=(Date.now?Date.now():+new Date)/1E3|0;h[l++]=a&255;h[l++]=a>>>8&255;h[l++]=a>>>16&255;h[l++]=a>>>24&255;h[l++]=0;h[l++]=Sa;if(this.g.fname!==t){g=0;for(k=m.length;g>>8&255),h[l++]=f&255;h[l++]=0}if(this.g.comment){g= +0;for(k=n.length;g>>8&255),h[l++]=f&255;h[l++]=0}this.g.fhcrc&&(c=R(h,0,l)&65535,h[l++]=c&255,h[l++]=c>>>8&255);this.l.outputBuffer=h;this.l.outputIndex=l;e=new ma(s,this.l);h=e.h();l=e.b;A&&(l+8>h.buffer.byteLength?(this.a=new Uint8Array(l+8),this.a.set(new Uint8Array(h.buffer)),h=this.a):h=new Uint8Array(h.buffer));d=R(s,t,t);h[l++]=d&255;h[l++]=d>>>8&255;h[l++]=d>>>16&255;h[l++]=d>>>24&255;k=s.length;h[l++]=k&255;h[l++]=k>>>8&255;h[l++]=k>>>16&255;h[l++]= +k>>>24&255;this.c=p;A&&l>>=1;switch(b){case 0:var a=this.input,c=this.c,d=this.a,e=this.b,f=a.length,g=t,k=t,h=d.length,l=t;this.e=this.j=0;c+1>=f&&q(Error("invalid uncompressed block header: LEN"));g=a[c++]|a[c++]<<8;c+1>=f&&q(Error("invalid uncompressed block header: NLEN"));k=a[c++]|a[c++]<<8;g===~k&&q(Error("invalid uncompressed block header: length verify"));c+g>a.length&&q(Error("input buffer is broken"));switch(this.q){case Ua:for(;e+g>d.length;){l= +h-e;g-=l;if(A)d.set(a.subarray(c,c+l),e),e+=l,c+=l;else for(;l--;)d[e++]=a[c++];this.b=e;d=this.f();e=this.b}break;case Ta:for(;e+g>d.length;)d=this.f({B:2});break;default:q(Error("invalid inflate mode"))}if(A)d.set(a.subarray(c,c+g),e),e+=g,c+=g;else for(;g--;)d[e++]=a[c++];this.c=c;this.b=e;this.a=d;break;case 1:this.r(Va,Wa);break;case 2:Xa(this);break;default:q(Error("unknown BTYPE: "+b))}}return this.z()}; +var Ya=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],Za=A?new Uint16Array(Ya):Ya,$a=[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,258,258],ab=A?new Uint16Array($a):$a,bb=[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,0,0],cb=A?new Uint8Array(bb):bb,db=[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],eb=A?new Uint16Array(db):db,fb=[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],gb=A?new Uint8Array(fb):fb,hb=new (A?Uint8Array:Array)(288),$,ib;$=0;for(ib=hb.length;$=$?8:255>=$?9:279>=$?7:8;var Va=ja(hb),jb=new (A?Uint8Array:Array)(30),kb,lb;kb=0;for(lb=jb.length;kb=g&&q(Error("input buffer is broken")),c|=e[f++]<>>a;b.e=d-a;b.c=f;return k} +function mb(b,a){for(var c=b.j,d=b.e,e=b.input,f=b.c,g=e.length,k=a[0],h=a[1],l,s;d=g);)c|=e[f++]<>>16;b.j=c>>s;b.e=d-s;b.c=f;return l&65535} +function Xa(b){function a(a,b,c){var d,e=this.I,f,g;for(g=0;gf)d>=e&&(this.b=d,c=this.f(),d=this.b),c[d++]=f;else{g=f-257;h=ab[g];0=e&&(this.b=d,c=this.f(),d=this.b);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.R=function(b,a){var c=this.a,d=this.b;this.A=b;for(var e=c.length,f,g,k,h;256!==(f=mb(this,b));)if(256>f)d>=e&&(c=this.f(),e=c.length),c[d++]=f;else{g=f-257;h=ab[g];0e&&(c=this.f(),e=c.length);for(;h--;)c[d]=c[d++-k]}for(;8<=this.e;)this.e-=8,this.c--;this.b=d}; +Y.prototype.f=function(){var b=new (A?Uint8Array:Array)(this.b-32768),a=this.b-32768,c,d,e=this.a;if(A)b.set(e.subarray(32768,b.length));else{c=0;for(d=b.length;cc;++c)e[c]=e[a+c];this.b=32768;return e}; +Y.prototype.T=function(b){var a,c=this.input.length/this.c+1|0,d,e,f,g=this.input,k=this.a;b&&("number"===typeof b.B&&(c=b.B),"number"===typeof b.N&&(c+=b.N));2>c?(d=(g.length-this.c)/this.A[2],f=258*(d/2)|0,e=fa&&(this.a.length=a),b=this.a);return this.buffer=b};function nb(b){this.input=b;this.c=0;this.G=[];this.S=!1} +nb.prototype.i=function(){for(var b=this.input.length;this.c>>0;R(e,t,t)!==s&&q(Error("invalid CRC-32 checksum: 0x"+R(e,t,t).toString(16)+" / 0x"+ +s.toString(16)));a.$=c=(p[m++]|p[m++]<<8|p[m++]<<16|p[m++]<<24)>>>0;(e.length&4294967295)!==c&&q(Error("invalid input size: "+(e.length&4294967295)+" / "+c));this.G.push(a);this.c=m}this.S=v;var n=this.G,r,u,x=0,O=0,y;r=0;for(u=n.length;r>>0;b=a}for(var e=1,f=0,g=b.length,k,h=0;0>>0};function pb(b,a){var c,d;this.input=b;this.c=0;if(a||!(a={}))a.index&&(this.c=a.index),a.verify&&(this.W=a.verify);c=b[this.c++];d=b[this.c++];switch(c&15){case rb:this.method=rb;break;default:q(Error("unsupported compression method"))}0!==((c<<8)+d)%31&&q(Error("invalid fcheck flag:"+((c<<8)+d)%31));d&32&&q(Error("fdict flag is not supported"));this.K=new Y(b,{index:this.c,bufferSize:a.bufferSize,bufferType:a.bufferType,resize:a.resize})} +pb.prototype.i=function(){var b=this.input,a,c;a=this.K.i();this.c=this.K.c;this.W&&(c=(b[this.c++]<<24|b[this.c++]<<16|b[this.c++]<<8|b[this.c++])>>>0,c!==ob(a)&&q(Error("invalid adler-32 checksum")));return a};var rb=8;function sb(b,a){this.input=b;this.a=new (A?Uint8Array:Array)(32768);this.k=tb.t;var c={},d;if((a||!(a={}))&&"number"===typeof a.compressionType)this.k=a.compressionType;for(d in a)c[d]=a[d];c.outputBuffer=this.a;this.J=new ma(this.input,c)}var tb=oa; +sb.prototype.h=function(){var b,a,c,d,e,f,g,k=0;g=this.a;b=rb;switch(b){case rb:a=Math.LOG2E*Math.log(32768)-8;break;default:q(Error("invalid compression method"))}c=a<<4|b;g[k++]=c;switch(b){case rb:switch(this.k){case tb.NONE:e=0;break;case tb.M:e=1;break;case tb.t:e=2;break;default:q(Error("unsupported compression type"))}break;default:q(Error("invalid compression method"))}d=e<<6|0;g[k++]=d|31-(256*c+d)%31;f=ob(this.input);this.J.b=k;g=this.J.h();k=g.length;A&&(g=new Uint8Array(g.buffer),g.length<= +k+4&&(this.a=new Uint8Array(g.length+4),this.a.set(g),g=this.a),g=g.subarray(0,k+4));g[k++]=f>>24&255;g[k++]=f>>16&255;g[k++]=f>>8&255;g[k++]=f&255;return g};exports.deflate=ub;exports.deflateSync=vb;exports.inflate=wb;exports.inflateSync=xb;exports.gzip=yb;exports.gzipSync=zb;exports.gunzip=Ab;exports.gunzipSync=Bb;function ub(b,a,c){process.nextTick(function(){var d,e;try{e=vb(b,c)}catch(f){d=f}a(d,e)})}function vb(b,a){var c;c=(new sb(b)).h();a||(a={});return a.H?c:Cb(c)}function wb(b,a,c){process.nextTick(function(){var d,e;try{e=xb(b,c)}catch(f){d=f}a(d,e)})} +function xb(b,a){var c;b.subarray=b.slice;c=(new pb(b)).i();a||(a={});return a.noBuffer?c:Cb(c)}function yb(b,a,c){process.nextTick(function(){var d,e;try{e=zb(b,c)}catch(f){d=f}a(d,e)})}function zb(b,a){var c;b.subarray=b.slice;c=(new Aa(b)).h();a||(a={});return a.H?c:Cb(c)}function Ab(b,a,c){process.nextTick(function(){var d,e;try{e=Bb(b,c)}catch(f){d=f}a(d,e)})}function Bb(b,a){var c;b.subarray=b.slice;c=(new nb(b)).i();a||(a={});return a.H?c:Cb(c)} +function Cb(b){var a=new Buffer(b.length),c,d;c=0;for(d=b.length;c>24&255;g[k++]=f>>16&255;g[k++]=f>>8&255;g[k++]=f&255;return g};exports.deflate=ub;exports.deflateSync=vb;exports.inflate=wb;exports.inflateSync=xb;exports.gzip=yb;exports.gzipSync=zb;exports.gunzip=Ab;exports.gunzipSync=Bb;function ub(b,a,c){process.nextTick(function(){var d,e;try{e=vb(b,c)}catch(f){d=f}a(d,e)})}function vb(b,a){var c;c=(new sb(b)).h();a||(a={});return a.H?c:Cb(c)}function wb(b,a,c){process.nextTick(function(){var d,e;try{e=xb(b,c)}catch(f){d=f}a(d,e)})} function xb(b,a){var c;b.subarray=b.slice;c=(new pb(b)).i();a||(a={});return a.noBuffer?c:Cb(c)}function yb(b,a,c){process.nextTick(function(){var d,e;try{e=zb(b,c)}catch(f){d=f}a(d,e)})}function zb(b,a){var c;b.subarray=b.slice;c=(new Aa(b)).h();a||(a={});return a.H?c:Cb(c)}function Ab(b,a,c){process.nextTick(function(){var d,e;try{e=Bb(b,c)}catch(f){d=f}a(d,e)})}function Bb(b,a){var c;b.subarray=b.slice;c=(new nb(b)).i();a||(a={});return a.H?c:Cb(c)} -function Cb(b){var a=new Buffer(b.length),c,d;c=0;for(d=b.length;c>>8&255]<<16|L[e>>>16&255]<<8|L[e>>>24&255])>>32-d:L[e]>>8-d);if(8>d+b)k=k<>d-m-1&1,8===++b&&(b=0,f[a++]=L[k],k=0,a===f.length&&(f=ca(this)));f[a]=k;this.buffer=f;this.d=b;this.index=a};K.prototype.finish=function(){var e=this.buffer,d=this.index,c;0M;++M){for(var R=M,S=R,ha=7,R=R>>>1;R;R>>>=1)S<<=1,S|=R&1,--ha;ga[M]=(S<>>0}var L=ga;function ja(e){this.buffer=new (C?Uint16Array:Array)(2*e);this.length=0}ja.prototype.getParent=function(e){return 2*((e-2)/4|0)};ja.prototype.push=function(e,d){var c,f,a=this.buffer,b;c=this.length;a[this.length++]=d;for(a[this.length++]=e;0a[f])b=a[c],a[c]=a[f],a[f]=b,b=a[c+1],a[c+1]=a[f+1],a[f+1]=b,c=f;else break;return this.length}; +ja.prototype.pop=function(){var e,d,c=this.buffer,f,a,b;d=c[0];e=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(b=0;;){a=2*b+2;if(a>=this.length)break;a+2c[a]&&(a+=2);if(c[a]>c[b])f=c[b],c[b]=c[a],c[a]=f,f=c[b+1],c[b+1]=c[a+1],c[a+1]=f;else break;b=a}return{index:e,value:d,length:this.length}};function ka(e,d){this.e=ma;this.f=0;this.input=C&&e instanceof Array?new Uint8Array(e):e;this.c=0;d&&(d.lazy&&(this.f=d.lazy),"number"===typeof d.compressionType&&(this.e=d.compressionType),d.outputBuffer&&(this.b=C&&d.outputBuffer instanceof Array?new Uint8Array(d.outputBuffer):d.outputBuffer),"number"===typeof d.outputIndex&&(this.c=d.outputIndex));this.b||(this.b=new (C?Uint8Array:Array)(32768))}var ma=2,T=[],U; +for(U=0;288>U;U++)switch(u){case 143>=U:T.push([U+48,8]);break;case 255>=U:T.push([U-144+400,9]);break;case 279>=U:T.push([U-256+0,7]);break;case 287>=U:T.push([U-280+192,8]);break;default:throw"invalid literal: "+U;} +ka.prototype.h=function(){var e,d,c,f,a=this.input;switch(this.e){case 0:c=0;for(f=a.length;c>>8&255;l[h++]=p&255;l[h++]=p>>>8&255;if(C)l.set(b,h),h+=b.length,l=l.subarray(0,h);else{v=0;for(x=b.length;vs)for(;0s?s:138,A>s-3&&A=A?(E[D++]=17,E[D++]=A-3,H[17]++):(E[D++]=18,E[D++]=A-11,H[18]++),s-=A;else if(E[D++]=F[r],H[F[r]]++,s--,3>s)for(;0s?s:6,A>s-3&&Ay;y++)ia[y]=ea[Ia[y]];for(P=19;4=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:throw"invalid length: "+a;}}var d=[],c,f;for(c=3;258>=c;c++)f=e(c),d[c]=f[2]<<24| +f[1]<<16|f[0];return d}(),Ga=C?new Uint32Array(Fa):Fa; +function na(e,d){function c(a,c){var b=a.g,d=[],f=0,e;e=Ga[a.length];d[f++]=e&65535;d[f++]=e>>16&255;d[f++]=e>>24;var g;switch(u){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b- +65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>= +b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:throw"invalid distance";}e=g;d[f++]=e[0];d[f++]=e[1];d[f++]=e[2];var k,m;k=0;for(m=d.length;k=b;)t[b++]=0;for(b=0;29>=b;)w[b++]=0}t[256]=1;f=0;for(a=d.length;f=a){x&&c(x,-1);b=0;for(k=a-f;bk&&d+kb&&(a=f,b=k);if(258===k)break}return new qa(b,d-a)} +function oa(e,d){var c=e.length,f=new ja(572),a=new (C?Uint8Array:Array)(c),b,k,m,g,p;if(!C)for(g=0;g2*a[h-1]+b[h]&&(a[h]=2*a[h-1]+b[h]),m[h]=Array(a[h]),g[h]=Array(a[h]);for(l=0;le[l]?(m[h][q]=t,g[h][q]=d,w+=2):(m[h][q]=e[l],g[h][q]=l,++l);p[h]=0;1===b[h]&&f(h)}return k} +function pa(e){var d=new (C?Uint16Array:Array)(e.length),c=[],f=[],a=0,b,k,m,g;b=0;for(k=e.length;b>>=1}return d};ba("Zlib.RawDeflate",ka);ba("Zlib.RawDeflate.prototype.compress",ka.prototype.h);var Ka={NONE:0,FIXED:1,DYNAMIC:ma},V,La,$,Ma;if(Object.keys)V=Object.keys(Ka);else for(La in V=[],$=0,Ka)V[$++]=La;$=0;for(Ma=V.length;$2*a[h-1]+b[h]&&(a[h]=2*a[h-1]+b[h]),m[h]=Array(a[h]),g[h]=Array(a[h]);for(l=0;le[l]?(m[h][q]=t,g[h][q]=d,w+=2):(m[h][q]=e[l],g[h][q]=l,++l);p[h]=0;1===b[h]&&f(h)}return k} -function pa(e){var d=new (C?Uint16Array:Array)(e.length),c=[],f=[],a=0,b,k,m,g;b=0;for(k=e.length;b>>=1}return d};ba("Zlib.RawDeflate",ka);ba("Zlib.RawDeflate.prototype.compress",ka.prototype.h);var Ka={NONE:0,FIXED:1,DYNAMIC:ma},V,La,$,Ma;if(Object.keys)V=Object.keys(Ka);else for(La in V=[],$=0,Ka)V[$++]=La;$=0;for(Ma=V.length;$>>=1}return d};ba("Zlib.RawDeflate",ka);ba("Zlib.RawDeflate.prototype.compress",ka.prototype.h);var Ka={NONE:0,FIXED:1,DYNAMIC:ma},V,La,$,Ma;if(Object.keys)V=Object.keys(Ka);else for(La in V=[],$=0,Ka)V[$++]=La;$=0;for(Ma=V.length;$a&&(a=b[n]),b[n]>=1;J=g<<16|n;for(s=m;s>>=1;switch(b){case 0:var e=this.input,a=this.d,c=this.b,d=this.a,f=e.length,g=void 0,h=void 0,k=c.length,m=void 0;this.c=this.f=0;if(a+1>=f)throw Error("invalid uncompressed block header: LEN");g=e[a++]|e[a++]<<8;if(a+1>=f)throw Error("invalid uncompressed block header: NLEN");h=e[a++]|e[a++]<<8;if(g===~h)throw Error("invalid uncompressed block header: length verify");if(a+g>e.length)throw Error("input buffer is broken");switch(this.i){case w:for(;d+ +g>c.length;){m=k-d;g-=m;if(q)c.set(e.subarray(a,a+m),d),d+=m,a+=m;else for(;m--;)c[d++]=e[a++];this.a=d;c=this.e();d=this.a}break;case v:for(;d+g>c.length;)c=this.e({o:2});break;default:throw Error("invalid inflate mode");}if(q)c.set(e.subarray(a,a+g),d),d+=g,a+=g;else for(;g--;)c[d++]=e[a++];this.d=a;this.a=d;this.b=c;break;case 1:this.j(y,z);break;case 2:A(this);break;default:throw Error("unknown BTYPE: "+b);}}return this.m()}; +var B=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],C=q?new Uint16Array(B):B,D=[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,258,258],E=q?new Uint16Array(D):D,F=[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,0,0],G=q?new Uint8Array(F):F,H=[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],I=q?new Uint16Array(H):H,K=[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],L=q?new Uint8Array(K):K,M=new (q?Uint8Array:Array)(288),N,O;N=0;for(O=M.length;N=N?8:255>=N?9:279>=N?7:8;var y=t(M),P=new (q?Uint8Array:Array)(30),Q,R;Q=0;for(R=P.length;Q=g)throw Error("input buffer is broken");a|=d[f++]<>>e;b.c=c-e;b.d=f;return h} +function S(b,e){for(var a=b.f,c=b.c,d=b.input,f=b.d,g=d.length,h=e[0],k=e[1],m,r;c=g);)a|=d[f++]<>>16;b.f=a>>r;b.c=c-r;b.d=f;return m&65535} +function A(b){function e(a,b,c){var e,d=this.p,f,g;for(g=0;gf)c>=d&&(this.a=c,a=this.e(),c=this.a),a[c++]=f;else{g=f-257;k=E[g];0=d&&(this.a=c,a=this.e(),c=this.a);for(;k--;)a[c]=a[c++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=c}; +u.prototype.t=function(b,e){var a=this.b,c=this.a;this.n=b;for(var d=a.length,f,g,h,k;256!==(f=S(this,b));)if(256>f)c>=d&&(a=this.e(),d=a.length),a[c++]=f;else{g=f-257;k=E[g];0d&&(a=this.e(),d=a.length);for(;k--;)a[c]=a[c++-h]}for(;8<=this.c;)this.c-=8,this.d--;this.a=c}; +u.prototype.e=function(){var b=new (q?Uint8Array:Array)(this.a-32768),e=this.a-32768,a,c,d=this.b;if(q)b.set(d.subarray(32768,b.length));else{a=0;for(c=b.length;aa;++a)d[a]=d[e+a];this.a=32768;return d}; +u.prototype.v=function(b){var e,a=this.input.length/this.d+1|0,c,d,f,g=this.input,h=this.b;b&&("number"===typeof b.o&&(a=b.o),"number"===typeof b.r&&(a+=b.r));2>a?(c=(g.length-this.d)/this.n[2],f=258*(c/2)|0,d=fe&&(this.b.length=e),b=this.b);return this.buffer=b};p("Zlib.RawInflate",u);p("Zlib.RawInflate.prototype.decompress",u.prototype.u);var T={ADAPTIVE:v,BLOCK:w},U,V,W,X;if(Object.keys)U=Object.keys(T);else for(V in U=[],W=0,T)U[W++]=V;W=0;for(X=U.length;Wa;++a)d[a]=d[e+a];this.a=32768;return d}; u.prototype.v=function(b){var e,a=this.input.length/this.d+1|0,c,d,f,g=this.input,h=this.b;b&&("number"===typeof b.o&&(a=b.o),"number"===typeof b.r&&(a+=b.r));2>a?(c=(g.length-this.d)/this.n[2],f=258*(c/2)|0,d=fe&&(this.b.length=e),b=this.b);return this.buffer=b};p("Zlib.RawInflate",u);p("Zlib.RawInflate.prototype.decompress",u.prototype.u);var T={ADAPTIVE:v,BLOCK:w},U,V,W,X;if(Object.keys)U=Object.keys(T);else for(V in U=[],W=0,T)U[W++]=V;W=0;for(X=U.length;We&&(this.b.length=e),b=this.b);return this.buffer=b};p("Zlib.RawInflate",u);p("Zlib.RawInflate.prototype.decompress",u.prototype.u);var T={ADAPTIVE:v,BLOCK:w},U,V,W,X;if(Object.keys)U=Object.keys(T);else for(V in U=[],W=0,T)U[W++]=V;W=0;for(X=U.length;Wx;++x)for(var y=x,ba=7,y=y>>>1;y;y>>>=1)--ba;var z=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],B=w?new Uint32Array(z):z;function C(a){var b=a.length,c=0,d=Number.POSITIVE_INFINITY,f,h,k,e,g,l,p,s,r,A;for(s=0;sc&&(c=a[s]),a[s]>=1;A=k<<16|s;for(r=l;rE;E++)switch(!0){case 143>=E:D.push([E+48,8]);break;case 255>=E:D.push([E-144+400,9]);break;case 279>=E:D.push([E-256+0,7]);break;case 287>=E:D.push([E-280+192,8]);break;default:m("invalid literal: "+E)} +var ca=function(){function a(a){switch(!0){case 3===a:return[257,a-3,0];case 4===a:return[258,a-4,0];case 5===a:return[259,a-5,0];case 6===a:return[260,a-6,0];case 7===a:return[261,a-7,0];case 8===a:return[262,a-8,0];case 9===a:return[263,a-9,0];case 10===a:return[264,a-10,0];case 12>=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:m("invalid length: "+a)}}var b=[],c,d;for(c=3;258>=c;c++)d=a(c),b[c]=d[2]<<24|d[1]<< +16|d[0];return b}();w&&new Uint32Array(ca);function F(a,b){this.l=[];this.m=32768;this.d=this.f=this.c=this.t=0;this.input=w?new Uint8Array(a):a;this.u=!1;this.n=G;this.L=!1;if(b||!(b={}))b.index&&(this.c=b.index),b.bufferSize&&(this.m=b.bufferSize),b.bufferType&&(this.n=b.bufferType),b.resize&&(this.L=b.resize);switch(this.n){case H:this.a=32768;this.b=new (w?Uint8Array:Array)(32768+this.m+258);break;case G:this.a=0;this.b=new (w?Uint8Array:Array)(this.m);this.e=this.X;this.B=this.S;this.q=this.W;break;default:m(Error("invalid inflate mode"))}} +var H=0,G=1; +F.prototype.r=function(){for(;!this.u;){var a=I(this,3);a&1&&(this.u=!0);a>>>=1;switch(a){case 0:var b=this.input,c=this.c,d=this.b,f=this.a,h=b.length,k=q,e=q,g=d.length,l=q;this.d=this.f=0;c+1>=h&&m(Error("invalid uncompressed block header: LEN"));k=b[c++]|b[c++]<<8;c+1>=h&&m(Error("invalid uncompressed block header: NLEN"));e=b[c++]|b[c++]<<8;k===~e&&m(Error("invalid uncompressed block header: length verify"));c+k>b.length&&m(Error("input buffer is broken"));switch(this.n){case H:for(;f+k>d.length;){l= +g-f;k-=l;if(w)d.set(b.subarray(c,c+l),f),f+=l,c+=l;else for(;l--;)d[f++]=b[c++];this.a=f;d=this.e();f=this.a}break;case G:for(;f+k>d.length;)d=this.e({H:2});break;default:m(Error("invalid inflate mode"))}if(w)d.set(b.subarray(c,c+k),f),f+=k,c+=k;else for(;k--;)d[f++]=b[c++];this.c=c;this.a=f;this.b=d;break;case 1:this.q(da,ea);break;case 2:fa(this);break;default:m(Error("unknown BTYPE: "+a))}}return this.B()}; +var J=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],K=w?new Uint16Array(J):J,L=[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,258,258],M=w?new Uint16Array(L):L,ga=[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,0,0],O=w?new Uint8Array(ga):ga,ha=[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],ia=w?new Uint16Array(ha):ha,ja=[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],P=w?new Uint8Array(ja):ja,Q=new (w?Uint8Array:Array)(288),R,la;R=0;for(la=Q.length;R=R?8:255>=R?9:279>=R?7:8;var da=C(Q),S=new (w?Uint8Array:Array)(30),T,ma;T=0;for(ma=S.length;T=k&&m(Error("input buffer is broken")),c|=f[h++]<>>b;a.d=d-b;a.c=h;return e} +function U(a,b){for(var c=a.f,d=a.d,f=a.input,h=a.c,k=f.length,e=b[0],g=b[1],l,p;d=k);)c|=f[h++]<>>16;a.f=c>>p;a.d=d-p;a.c=h;return l&65535} +function fa(a){function b(a,b,c){var d,e=this.K,f,g;for(g=0;gh)d>=f&&(this.a=d,c=this.e(),d=this.a),c[d++]=h;else{k=h-257;g=M[k];0=f&&(this.a=d,c=this.e(),d=this.a);for(;g--;)c[d]=c[d++-e]}for(;8<=this.d;)this.d-=8,this.c--;this.a=d}; +u.W=function(a,b){var c=this.b,d=this.a;this.C=a;for(var f=c.length,h,k,e,g;256!==(h=U(this,a));)if(256>h)d>=f&&(c=this.e(),f=c.length),c[d++]=h;else{k=h-257;g=M[k];0f&&(c=this.e(),f=c.length);for(;g--;)c[d]=c[d++-e]}for(;8<=this.d;)this.d-=8,this.c--;this.a=d}; +u.e=function(){var a=new (w?Uint8Array:Array)(this.a-32768),b=this.a-32768,c,d,f=this.b;if(w)a.set(f.subarray(32768,a.length));else{c=0;for(d=a.length;cc;++c)f[c]=f[b+c];this.a=32768;return f}; +u.X=function(a){var b,c=this.input.length/this.c+1|0,d,f,h,k=this.input,e=this.b;a&&("number"===typeof a.H&&(c=a.H),"number"===typeof a.Q&&(c+=a.Q));2>c?(d=(k.length-this.c)/this.C[2],h=258*(d/2)|0,f=hb&&(this.b.length=b),a=this.b);return this.buffer=a};function V(a){a=a||{};this.files=[];this.v=a.comment}V.prototype.M=function(a){this.j=a};V.prototype.s=function(a){var b=a[2]&65535|2;return b*(b^1)>>8&255};V.prototype.k=function(a,b){a[0]=(B[(a[0]^b)&255]^a[0]>>>8)>>>0;a[1]=(6681*(20173*(a[1]+(a[0]&255))>>>0)>>>0)+1>>>0;a[2]=(B[(a[2]^a[1]>>>24)&255]^a[2]>>>8)>>>0};V.prototype.U=function(a){var b=[305419896,591751049,878082192],c,d;w&&(b=new Uint32Array(b));c=0;for(d=a.length;c>>0;this.z=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.J=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.h=a[b++]|a[b++]<< +8;this.g=a[b++]|a[b++]<<8;this.F=a[b++]|a[b++]<<8;this.fa=a[b++]|a[b++]<<8;this.ha=a[b++]|a[b++]<<8;this.ga=a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24;this.aa=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.filename=String.fromCharCode.apply(null,w?a.subarray(b,b+=this.h):a.slice(b,b+=this.h));this.Y=w?a.subarray(b,b+=this.g):a.slice(b,b+=this.g);this.v=w?a.subarray(b,b+this.F):a.slice(b,b+this.F);this.length=b-this.offset};function pa(a,b){this.input=a;this.offset=b}var qa={O:1,da:8,ea:2048}; +pa.prototype.parse=function(){var a=this.input,b=this.offset;(a[b++]!==Y[0]||a[b++]!==Y[1]||a[b++]!==Y[2]||a[b++]!==Y[3])&&m(Error("invalid local file header signature"));this.$=a[b++]|a[b++]<<8;this.I=a[b++]|a[b++]<<8;this.A=a[b++]|a[b++]<<8;this.time=a[b++]|a[b++]<<8;this.V=a[b++]|a[b++]<<8;this.p=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.z=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.J=(a[b++]|a[b++]<<8|a[b++]<<16|a[b++]<<24)>>>0;this.h=a[b++]|a[b++]<<8;this.g=a[b++]|a[b++]<<8;this.filename= +String.fromCharCode.apply(null,w?a.subarray(b,b+=this.h):a.slice(b,b+=this.h));this.Y=w?a.subarray(b,b+=this.g):a.slice(b,b+=this.g);this.length=b-this.offset}; +function $(a){var b=[],c={},d,f,h,k;if(!a.i){if(a.o===q){var e=a.input,g;if(!a.D)a:{var l=a.input,p;for(p=l.length-12;0>>0;a.o=(e[g++]| +e[g++]<<8|e[g++]<<16|e[g++]<<24)>>>0;a.w=e[g++]|e[g++]<<8;a.v=w?e.subarray(g,g+a.w):e.slice(g,g+a.w)}d=a.o;h=0;for(k=a.ba;h>>8^B[(n^l[t])&255];for(N=ka>>3;N--;t+=8)n=n>>>8^B[(n^l[t])&255],n=n>>>8^B[(n^l[t+1])&255],n=n>>>8^B[(n^l[t+2])&255],n=n>>>8^B[(n^l[t+3])&255],n=n>>>8^B[(n^l[t+4])&255],n=n>>>8^B[(n^l[t+5])&255],n=n>>>8^B[(n^l[t+6])&255],n=n>>>8^B[(n^l[t+7])&255];p=(n^4294967295)>>>0;k.p!==p&&m(Error("wrong crc: file=0x"+ +k.p.toString(16)+", data=0x"+p.toString(16)))}return l};u.M=function(a){this.j=a};function ra(a,b,c){c^=a.s(b);a.k(b,c);return c}u.k=V.prototype.k;u.T=V.prototype.U;u.s=V.prototype.s;v("Zlib.Unzip",W);v("Zlib.Unzip.prototype.decompress",W.prototype.r);v("Zlib.Unzip.prototype.getFilenames",W.prototype.Z);v("Zlib.Unzip.prototype.setPassword",W.prototype.M);}).call(this); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin/unzip.min.js","lineCount":31,"mappings":"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","sources":["closure-primitives/base.js","define/typedarray/hybrid.js","src/bitstream.js","src/crc32.js","src/huffman.js","src/rawdeflate.js","src/rawinflate.js","src/zip.js","src/unzip.js","export/unzip.js"],"names":["goog.global","goog.exportSymbol","publicPath","object","parts","split","cur","execScript","part","length","shift","JSCompiler_alias_VOID","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Array","i","s","n","Zlib.CRC32.Table_","Zlib.CRC32.Table","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","j","value","push","JSCompiler_alias_THROW","c","Zlib.RawInflate","input","opt_params","blocks","bufferSize","ZLIB_RAW_INFLATE_BUFFER_SIZE","bitsbuflen","bitsbuf","ip","totalpos","bfinal","bufferType","Zlib.RawInflate.BufferType.ADAPTIVE","resize","Zlib.RawInflate.BufferType.BLOCK","op","Zlib.RawInflate.MaxBackwardLength","output","Zlib.RawInflate.MaxCopyLength","expandBuffer","expandBufferAdaptive","concatBuffer","concatBufferDynamic","decodeHuffman","decodeHuffmanAdaptive","Error","BLOCK","ADAPTIVE","prototype","decompress","Zlib.RawInflate.prototype.decompress","hdr","readBits","parseBlock","inputLength","len","nlen","olength","preCopy","set","subarray","Zlib.RawInflate.FixedLiteralLengthTable","Zlib.RawInflate.FixedDistanceTable","parseDynamicHuffmanBlock","Zlib.RawInflate.Order","Zlib.RawInflate.LengthCodeTable","Zlib.RawInflate.LengthExtraTable","Zlib.RawInflate.DistCodeTable","Zlib.RawInflate.DistExtraTable","il","Zlib.RawInflate.prototype.readBits","octet","Zlib.RawInflate.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflate.prototype.parseDynamicHuffmanBlock","decode","num","prev","repeat","readCodeByTable","hlit","hdist","hclen","codeLengths","Zlib.RawInflate.Order.length","codeLengthsTable","litlenLengths","distLengths","call","Zlib$RawInflate.prototype","Zlib.RawInflate.prototype","Zlib.RawInflate.prototype.decodeHuffman","litlen","dist","currentLitlenTable","ti","codeDist","Zlib.RawInflate.prototype.decodeHuffmanAdaptive","Zlib.RawInflate.prototype.expandBuffer","buffer","backward","Zlib.RawInflate.prototype.expandBufferAdaptive","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","Zlib.RawInflate.prototype.concatBuffer","pos","block","jl","slice","Zlib.RawInflate.prototype.concatBufferDynamic","Zlib.Zip","files","comment","setPassword","Zlib.Zip.prototype.setPassword","password","getByte","Zlib.Zip.prototype.getByte","key","tmp","updateKeys","Zlib.Zip.prototype.updateKeys","createEncryptionKey","Zlib.Zip.prototype.createEncryptionKey","Zlib.Unzip","verify","Zlib.Unzip.CompressionMethod","Zlib.Zip.CompressionMethod","STORE","DEFLATE","Zlib.Unzip.FileHeaderSignature","Zlib.Zip.FileHeaderSignature","Zlib.Unzip.LocalFileHeaderSignature","Zlib.Zip.LocalFileHeaderSignature","Zlib.Unzip.CentralDirectorySignature","Zlib.Zip.CentralDirectorySignature","Zlib.Unzip.FileHeader","offset","parse","Zlib.Unzip.FileHeader.prototype.parse","version","os","needVersion","flags","compression","time","date","crc32","compressedSize","plainSize","fileNameLength","extraFieldLength","fileCommentLength","diskNumberStart","internalFileAttributes","externalFileAttributes","relativeOffset","filename","String","fromCharCode","apply","extraField","Zlib.Unzip.LocalFileHeader","Zlib.Unzip.LocalFileHeader.Flags","Zlib.Zip.Flags","ENCRYPT","DESCRIPTOR","UTF8","Zlib.Unzip.LocalFileHeader.prototype.parse","Zlib.Unzip.prototype.parseFileHeader","filelist","filetable","fileHeader","fileHeaderList","centralDirectoryOffset","parseEndOfCentralDirectoryRecord","eocdrOffset","numberOfThisDisk","startDisk","totalEntriesThisDisk","totalEntries","centralDirectorySize","commentLength","filenameToIndex","Zlib$Unzip.prototype","Zlib.Unzip.prototype","getFilenames","Zlib.Unzip.prototype.getFilenames","filenameList","parseFileHeader","Zlib.Unzip.prototype.decompress","index","getFileData","localFileHeader","Zlib.Unzip.LocalFileHeader.Flags.ENCRYPT","createDecryptionKey","Zlib.Unzip.CompressionMethod.STORE","Zlib.Unzip.CompressionMethod.DEFLATE","crc","toString","Zlib.Unzip.prototype.setPassword","Zlib.Unzip.prototype.decode"],"sourcesContent":["// Copyright 2006 The Closure Library Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/**\n * @fileoverview Bootstrap for the Google JS Library (Closure).\n *\n * In uncompiled mode base.js will write out Closure's deps file, unless the\n * global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to\n * include their own deps file(s) from different locations.\n *\n */\n\n\n/**\n * @define {boolean} Overridden to true by the compiler when --closure_pass\n *     or --mark_as_compiled is specified.\n */\nvar COMPILED = false;\n\n\n/**\n * Base namespace for the Closure library.  Checks to see goog is\n * already defined in the current scope before assigning to prevent\n * clobbering if base.js is loaded more than once.\n *\n * @const\n */\nvar goog = goog || {}; // Identifies this file as the Closure base.\n\n\n/**\n * Reference to the global context.  In most cases this will be 'window'.\n */\ngoog.global = this;\n\n\n/**\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\n * that should not be included in a production js_binary can be easily stripped\n * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most\n * toString() methods should be declared inside an \"if (goog.DEBUG)\" conditional\n * because they are generally used for debugging purposes and it is difficult\n * for the JSCompiler to statically determine whether they are used.\n */\ngoog.DEBUG = true;\n\n\n/**\n * @define {string} LOCALE defines the locale being used for compilation. It is\n * used to select locale specific data to be compiled in js binary. BUILD rule\n * can specify this value by \"--define goog.LOCALE=<locale_name>\" as JSCompiler\n * option.\n *\n * Take into account that the locale code format is important. You should use\n * the canonical Unicode format with hyphen as a delimiter. Language must be\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\n *\n * See more info about locale codes here:\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\n *\n * For language codes you should use values defined by ISO 693-1. See it here\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\n * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.\n */\ngoog.LOCALE = 'en';  // default to en\n\n\n/**\n * Creates object stubs for a namespace.  The presence of one or more\n * goog.provide() calls indicate that the file defines the given\n * objects/namespaces.  Build tools also scan for provide/require statements\n * to discern dependencies, build dependency files (see deps.js), etc.\n * @see goog.require\n * @param {string} name Namespace provided by this file in the form\n *     \"goog.package.part\".\n */\ngoog.provide = function(name) {\n  if (!COMPILED) {\n    // Ensure that the same namespace isn't provided twice. This is intended\n    // to teach new developers that 'goog.provide' is effectively a variable\n    // declaration. And when JSCompiler transforms goog.provide into a real\n    // variable declaration, the compiled JS should work the same as the raw\n    // JS--even when the raw JS uses goog.provide incorrectly.\n    if (goog.isProvided_(name)) {\n      throw Error('Namespace \"' + name + '\" already declared.');\n    }\n    delete goog.implicitNamespaces_[name];\n\n    var namespace = name;\n    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\n      if (goog.getObjectByName(namespace)) {\n        break;\n      }\n      goog.implicitNamespaces_[namespace] = true;\n    }\n  }\n\n  goog.exportPath_(name);\n};\n\n\n/**\n * Marks that the current file should only be used for testing, and never for\n * live code in production.\n * @param {string=} opt_message Optional message to add to the error that's\n *     raised when used in production code.\n */\ngoog.setTestOnly = function(opt_message) {\n  if (COMPILED && !goog.DEBUG) {\n    opt_message = opt_message || '';\n    throw Error('Importing test-only code into non-debug environment' +\n                opt_message ? ': ' + opt_message : '.');\n  }\n};\n\n\nif (!COMPILED) {\n\n  /**\n   * Check if the given name has been goog.provided. This will return false for\n   * names that are available only as implicit namespaces.\n   * @param {string} name name of the object to look for.\n   * @return {boolean} Whether the name has been provided.\n   * @private\n   */\n  goog.isProvided_ = function(name) {\n    return !goog.implicitNamespaces_[name] && !!goog.getObjectByName(name);\n  };\n\n  /**\n   * Namespaces implicitly defined by goog.provide. For example,\n   * goog.provide('goog.events.Event') implicitly declares\n   * that 'goog' and 'goog.events' must be namespaces.\n   *\n   * @type {Object}\n   * @private\n   */\n  goog.implicitNamespaces_ = {};\n}\n\n\n/**\n * Builds an object structure for the provided namespace path,\n * ensuring that names that already exist are not overwritten. For\n * example:\n * \"a.b.c\" -> a = {};a.b={};a.b.c={};\n * Used by goog.provide and goog.exportSymbol.\n * @param {string} name name of the object that this file defines.\n * @param {*=} opt_object the object to expose at the end of the path.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n * @private\n */\ngoog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {\n  var parts = name.split('.');\n  var cur = opt_objectToExportTo || goog.global;\n\n  // Internet Explorer exhibits strange behavior when throwing errors from\n  // methods externed in this manner.  See the testExportSymbolExceptions in\n  // base_test.html for an example.\n  if (!(parts[0] in cur) && cur.execScript) {\n    cur.execScript('var ' + parts[0]);\n  }\n\n  // Certain browsers cannot parse code in the form for((a in b); c;);\n  // This pattern is produced by the JSCompiler when it collapses the\n  // statement above into the conditional loop below. To prevent this from\n  // happening, use a for-loop and reserve the init logic as below.\n\n  // Parentheses added to eliminate strict JS warning in Firefox.\n  for (var part; parts.length && (part = parts.shift());) {\n    if (!parts.length && goog.isDef(opt_object)) {\n      // last part and we have an object; use it\n      cur[part] = opt_object;\n    } else if (cur[part]) {\n      cur = cur[part];\n    } else {\n      cur = cur[part] = {};\n    }\n  }\n};\n\n\n/**\n * Returns an object based on its fully qualified external name.  If you are\n * using a compilation pass that renames property names beware that using this\n * function will not find renamed properties.\n *\n * @param {string} name The fully qualified name.\n * @param {Object=} opt_obj The object within which to look; default is\n *     |goog.global|.\n * @return {?} The value (object or primitive) or, if not found, null.\n */\ngoog.getObjectByName = function(name, opt_obj) {\n  var parts = name.split('.');\n  var cur = opt_obj || goog.global;\n  for (var part; part = parts.shift(); ) {\n    if (goog.isDefAndNotNull(cur[part])) {\n      cur = cur[part];\n    } else {\n      return null;\n    }\n  }\n  return cur;\n};\n\n\n/**\n * Globalizes a whole namespace, such as goog or goog.lang.\n *\n * @param {Object} obj The namespace to globalize.\n * @param {Object=} opt_global The object to add the properties to.\n * @deprecated Properties may be explicitly exported to the global scope, but\n *     this should no longer be done in bulk.\n */\ngoog.globalize = function(obj, opt_global) {\n  var global = opt_global || goog.global;\n  for (var x in obj) {\n    global[x] = obj[x];\n  }\n};\n\n\n/**\n * Adds a dependency from a file to the files it requires.\n * @param {string} relPath The path to the js file.\n * @param {Array} provides An array of strings with the names of the objects\n *                         this file provides.\n * @param {Array} requires An array of strings with the names of the objects\n *                         this file requires.\n */\ngoog.addDependency = function(relPath, provides, requires) {\n  if (!COMPILED) {\n    var provide, require;\n    var path = relPath.replace(/\\\\/g, '/');\n    var deps = goog.dependencies_;\n    for (var i = 0; provide = provides[i]; i++) {\n      deps.nameToPath[provide] = path;\n      if (!(path in deps.pathToNames)) {\n        deps.pathToNames[path] = {};\n      }\n      deps.pathToNames[path][provide] = true;\n    }\n    for (var j = 0; require = requires[j]; j++) {\n      if (!(path in deps.requires)) {\n        deps.requires[path] = {};\n      }\n      deps.requires[path][require] = true;\n    }\n  }\n};\n\n\n\n\n// NOTE(nnaze): The debug DOM loader was included in base.js as an orignal\n// way to do \"debug-mode\" development.  The dependency system can sometimes\n// be confusing, as can the debug DOM loader's asyncronous nature.\n//\n// With the DOM loader, a call to goog.require() is not blocking -- the\n// script will not load until some point after the current script.  If a\n// namespace is needed at runtime, it needs to be defined in a previous\n// script, or loaded via require() with its registered dependencies.\n// User-defined namespaces may need their own deps file.  See http://go/js_deps,\n// http://go/genjsdeps, or, externally, DepsWriter.\n// http://code.google.com/closure/library/docs/depswriter.html\n//\n// Because of legacy clients, the DOM loader can't be easily removed from\n// base.js.  Work is being done to make it disableable or replaceable for\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\n// for example). See bootstrap/ for more information.\n\n\n/**\n * @define {boolean} Whether to enable the debug loader.\n *\n * If enabled, a call to goog.require() will attempt to load the namespace by\n * appending a script tag to the DOM (if the namespace has been registered).\n *\n * If disabled, goog.require() will simply assert that the namespace has been\n * provided (and depend on the fact that some outside tool correctly ordered\n * the script).\n */\ngoog.ENABLE_DEBUG_LOADER = true;\n\n\n/**\n * Implements a system for the dynamic resolution of dependencies\n * that works in parallel with the BUILD system. Note that all calls\n * to goog.require will be stripped by the JSCompiler when the\n * --closure_pass option is used.\n * @see goog.provide\n * @param {string} name Namespace to include (as was given in goog.provide())\n *     in the form \"goog.package.part\".\n */\ngoog.require = function(name) {\n\n  // if the object already exists we do not need do do anything\n  // TODO(arv): If we start to support require based on file name this has\n  //            to change\n  // TODO(arv): If we allow goog.foo.* this has to change\n  // TODO(arv): If we implement dynamic load after page load we should probably\n  //            not remove this code for the compiled output\n  if (!COMPILED) {\n    if (goog.isProvided_(name)) {\n      return;\n    }\n\n    if (goog.ENABLE_DEBUG_LOADER) {\n      var path = goog.getPathFromDeps_(name);\n      if (path) {\n        goog.included_[path] = true;\n        goog.writeScripts_();\n        return;\n      }\n    }\n\n    var errorMessage = 'goog.require could not find: ' + name;\n    if (goog.global.console) {\n      goog.global.console['error'](errorMessage);\n    }\n\n\n      throw Error(errorMessage);\n\n  }\n};\n\n\n/**\n * Path for included scripts\n * @type {string}\n */\ngoog.basePath = '';\n\n\n/**\n * A hook for overriding the base path.\n * @type {string|undefined}\n */\ngoog.global.CLOSURE_BASE_PATH;\n\n\n/**\n * Whether to write out Closure's deps file. By default,\n * the deps are written.\n * @type {boolean|undefined}\n */\ngoog.global.CLOSURE_NO_DEPS;\n\n\n/**\n * A function to import a single script. This is meant to be overridden when\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\n * in the global scope so that it can be set before base.js is loaded, which\n * allows deps.js to be imported properly.\n *\n * The function is passed the script source, which is a relative URI. It should\n * return true if the script was imported, false otherwise.\n */\ngoog.global.CLOSURE_IMPORT_SCRIPT;\n\n\n/**\n * Null function used for default values of callbacks, etc.\n * @return {void} Nothing.\n */\ngoog.nullFunction = function() {};\n\n\n/**\n * The identity function. Returns its first argument.\n *\n * @param {*=} opt_returnValue The single value that will be returned.\n * @param {...*} var_args Optional trailing arguments. These are ignored.\n * @return {?} The first argument. We can't know the type -- just pass it along\n *      without type.\n * @deprecated Use goog.functions.identity instead.\n */\ngoog.identityFunction = function(opt_returnValue, var_args) {\n  return opt_returnValue;\n};\n\n\n/**\n * When defining a class Foo with an abstract method bar(), you can do:\n *\n * Foo.prototype.bar = goog.abstractMethod\n *\n * Now if a subclass of Foo fails to override bar(), an error\n * will be thrown when bar() is invoked.\n *\n * Note: This does not take the name of the function to override as\n * an argument because that would make it more difficult to obfuscate\n * our JavaScript code.\n *\n * @type {!Function}\n * @throws {Error} when invoked to indicate the method should be\n *   overridden.\n */\ngoog.abstractMethod = function() {\n  throw Error('unimplemented abstract method');\n};\n\n\n/**\n * Adds a {@code getInstance} static method that always return the same instance\n * object.\n * @param {!Function} ctor The constructor for the class to add the static\n *     method to.\n */\ngoog.addSingletonGetter = function(ctor) {\n  ctor.getInstance = function() {\n    if (ctor.instance_) {\n      return ctor.instance_;\n    }\n    if (goog.DEBUG) {\n      // NOTE: JSCompiler can't optimize away Array#push.\n      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n    }\n    return ctor.instance_ = new ctor;\n  };\n};\n\n\n/**\n * All singleton classes that have been instantiated, for testing. Don't read\n * it directly, use the {@code goog.testing.singleton} module. The compiler\n * removes this variable if unused.\n * @type {!Array.<!Function>}\n * @private\n */\ngoog.instantiatedSingletons_ = [];\n\n\nif (!COMPILED && goog.ENABLE_DEBUG_LOADER) {\n  /**\n   * Object used to keep track of urls that have already been added. This\n   * record allows the prevention of circular dependencies.\n   * @type {Object}\n   * @private\n   */\n  goog.included_ = {};\n\n\n  /**\n   * This object is used to keep track of dependencies and other data that is\n   * used for loading scripts\n   * @private\n   * @type {Object}\n   */\n  goog.dependencies_ = {\n    pathToNames: {}, // 1 to many\n    nameToPath: {}, // 1 to 1\n    requires: {}, // 1 to many\n    // used when resolving dependencies to prevent us from\n    // visiting the file twice\n    visited: {},\n    written: {} // used to keep track of script files we have written\n  };\n\n\n  /**\n   * Tries to detect whether is in the context of an HTML document.\n   * @return {boolean} True if it looks like HTML document.\n   * @private\n   */\n  goog.inHtmlDocument_ = function() {\n    var doc = goog.global.document;\n    return typeof doc != 'undefined' &&\n           'write' in doc;  // XULDocument misses write.\n  };\n\n\n  /**\n   * Tries to detect the base path of the base.js script that bootstraps Closure\n   * @private\n   */\n  goog.findBasePath_ = function() {\n    if (goog.global.CLOSURE_BASE_PATH) {\n      goog.basePath = goog.global.CLOSURE_BASE_PATH;\n      return;\n    } else if (!goog.inHtmlDocument_()) {\n      return;\n    }\n    var doc = goog.global.document;\n    var scripts = doc.getElementsByTagName('script');\n    // Search backwards since the current script is in almost all cases the one\n    // that has base.js.\n    for (var i = scripts.length - 1; i >= 0; --i) {\n      var src = scripts[i].src;\n      var qmark = src.lastIndexOf('?');\n      var l = qmark == -1 ? src.length : qmark;\n      if (src.substr(l - 7, 7) == 'base.js') {\n        goog.basePath = src.substr(0, l - 7);\n        return;\n      }\n    }\n  };\n\n\n  /**\n   * Imports a script if, and only if, that script hasn't already been imported.\n   * (Must be called at execution time)\n   * @param {string} src Script source.\n   * @private\n   */\n  goog.importScript_ = function(src) {\n    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||\n        goog.writeScriptTag_;\n    if (!goog.dependencies_.written[src] && importScript(src)) {\n      goog.dependencies_.written[src] = true;\n    }\n  };\n\n\n  /**\n   * The default implementation of the import function. Writes a script tag to\n   * import the script.\n   *\n   * @param {string} src The script source.\n   * @return {boolean} True if the script was imported, false otherwise.\n   * @private\n   */\n  goog.writeScriptTag_ = function(src) {\n    if (goog.inHtmlDocument_()) {\n      var doc = goog.global.document;\n      doc.write(\n          '<script type=\"text/javascript\" src=\"' + src + '\"></' + 'script>');\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n\n  /**\n   * Resolves dependencies based on the dependencies added using addDependency\n   * and calls importScript_ in the correct order.\n   * @private\n   */\n  goog.writeScripts_ = function() {\n    // the scripts we need to write this time\n    var scripts = [];\n    var seenScript = {};\n    var deps = goog.dependencies_;\n\n    function visitNode(path) {\n      if (path in deps.written) {\n        return;\n      }\n\n      // we have already visited this one. We can get here if we have cyclic\n      // dependencies\n      if (path in deps.visited) {\n        if (!(path in seenScript)) {\n          seenScript[path] = true;\n          scripts.push(path);\n        }\n        return;\n      }\n\n      deps.visited[path] = true;\n\n      if (path in deps.requires) {\n        for (var requireName in deps.requires[path]) {\n          // If the required name is defined, we assume that it was already\n          // bootstrapped by other means.\n          if (!goog.isProvided_(requireName)) {\n            if (requireName in deps.nameToPath) {\n              visitNode(deps.nameToPath[requireName]);\n            } else {\n              throw Error('Undefined nameToPath for ' + requireName);\n            }\n          }\n        }\n      }\n\n      if (!(path in seenScript)) {\n        seenScript[path] = true;\n        scripts.push(path);\n      }\n    }\n\n    for (var path in goog.included_) {\n      if (!deps.written[path]) {\n        visitNode(path);\n      }\n    }\n\n    for (var i = 0; i < scripts.length; i++) {\n      if (scripts[i]) {\n        goog.importScript_(goog.basePath + scripts[i]);\n      } else {\n        throw Error('Undefined script input');\n      }\n    }\n  };\n\n\n  /**\n   * Looks at the dependency rules and tries to determine the script file that\n   * fulfills a particular rule.\n   * @param {string} rule In the form goog.namespace.Class or project.script.\n   * @return {?string} Url corresponding to the rule, or null.\n   * @private\n   */\n  goog.getPathFromDeps_ = function(rule) {\n    if (rule in goog.dependencies_.nameToPath) {\n      return goog.dependencies_.nameToPath[rule];\n    } else {\n      return null;\n    }\n  };\n\n  goog.findBasePath_();\n\n  // Allow projects to manage the deps files themselves.\n  if (!goog.global.CLOSURE_NO_DEPS) {\n    goog.importScript_(goog.basePath + 'deps.js');\n  }\n}\n\n\n\n//==============================================================================\n// Language Enhancements\n//==============================================================================\n\n\n/**\n * This is a \"fixed\" version of the typeof operator.  It differs from the typeof\n * operator in such a way that null returns 'null' and arrays return 'array'.\n * @param {*} value The value to get the type of.\n * @return {string} The name of the type.\n */\ngoog.typeOf = function(value) {\n  var s = typeof value;\n  if (s == 'object') {\n    if (value) {\n      // Check these first, so we can avoid calling Object.prototype.toString if\n      // possible.\n      //\n      // IE improperly marshals tyepof across execution contexts, but a\n      // cross-context object will still return false for \"instanceof Object\".\n      if (value instanceof Array) {\n        return 'array';\n      } else if (value instanceof Object) {\n        return s;\n      }\n\n      // HACK: In order to use an Object prototype method on the arbitrary\n      //   value, the compiler requires the value be cast to type Object,\n      //   even though the ECMA spec explicitly allows it.\n      var className = Object.prototype.toString.call(\n          /** @type {Object} */ (value));\n      // In Firefox 3.6, attempting to access iframe window objects' length\n      // property throws an NS_ERROR_FAILURE, so we need to special-case it\n      // here.\n      if (className == '[object Window]') {\n        return 'object';\n      }\n\n      // We cannot always use constructor == Array or instanceof Array because\n      // different frames have different Array objects. In IE6, if the iframe\n      // where the array was created is destroyed, the array loses its\n      // prototype. Then dereferencing val.splice here throws an exception, so\n      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'\n      // so that will work. In this case, this function will return false and\n      // most array functions will still work because the array is still\n      // array-like (supports length and []) even though it has lost its\n      // prototype.\n      // Mark Miller noticed that Object.prototype.toString\n      // allows access to the unforgeable [[Class]] property.\n      //  15.2.4.2 Object.prototype.toString ( )\n      //  When the toString method is called, the following steps are taken:\n      //      1. Get the [[Class]] property of this object.\n      //      2. Compute a string value by concatenating the three strings\n      //         \"[object \", Result(1), and \"]\".\n      //      3. Return Result(2).\n      // and this behavior survives the destruction of the execution context.\n      if ((className == '[object Array]' ||\n           // In IE all non value types are wrapped as objects across window\n           // boundaries (not iframe though) so we have to do object detection\n           // for this edge case\n           typeof value.length == 'number' &&\n           typeof value.splice != 'undefined' &&\n           typeof value.propertyIsEnumerable != 'undefined' &&\n           !value.propertyIsEnumerable('splice')\n\n          )) {\n        return 'array';\n      }\n      // HACK: There is still an array case that fails.\n      //     function ArrayImpostor() {}\n      //     ArrayImpostor.prototype = [];\n      //     var impostor = new ArrayImpostor;\n      // this can be fixed by getting rid of the fast path\n      // (value instanceof Array) and solely relying on\n      // (value && Object.prototype.toString.vall(value) === '[object Array]')\n      // but that would require many more function calls and is not warranted\n      // unless closure code is receiving objects from untrusted sources.\n\n      // IE in cross-window calls does not correctly marshal the function type\n      // (it appears just as an object) so we cannot use just typeof val ==\n      // 'function'. However, if the object has a call property, it is a\n      // function.\n      if ((className == '[object Function]' ||\n          typeof value.call != 'undefined' &&\n          typeof value.propertyIsEnumerable != 'undefined' &&\n          !value.propertyIsEnumerable('call'))) {\n        return 'function';\n      }\n\n\n    } else {\n      return 'null';\n    }\n\n  } else if (s == 'function' && typeof value.call == 'undefined') {\n    // In Safari typeof nodeList returns 'function', and on Firefox\n    // typeof behaves similarly for HTML{Applet,Embed,Object}Elements\n    // and RegExps.  We would like to return object for those and we can\n    // detect an invalid function by making sure that the function\n    // object has a call method.\n    return 'object';\n  }\n  return s;\n};\n\n\n/**\n * Returns true if the specified value is not |undefined|.\n * WARNING: Do not use this to test if an object has a property. Use the in\n * operator instead.  Additionally, this function assumes that the global\n * undefined variable has not been redefined.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined.\n */\ngoog.isDef = function(val) {\n  return val !== undefined;\n};\n\n\n/**\n * Returns true if the specified value is |null|\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is null.\n */\ngoog.isNull = function(val) {\n  return val === null;\n};\n\n\n/**\n * Returns true if the specified value is defined and not null\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is defined and not null.\n */\ngoog.isDefAndNotNull = function(val) {\n  // Note that undefined == null.\n  return val != null;\n};\n\n\n/**\n * Returns true if the specified value is an array\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArray = function(val) {\n  return goog.typeOf(val) == 'array';\n};\n\n\n/**\n * Returns true if the object looks like an array. To qualify as array like\n * the value needs to be either a NodeList or an object with a Number length\n * property.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArrayLike = function(val) {\n  var type = goog.typeOf(val);\n  return type == 'array' || type == 'object' && typeof val.length == 'number';\n};\n\n\n/**\n * Returns true if the object looks like a Date. To qualify as Date-like\n * the value needs to be an object and have a getFullYear() function.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a like a Date.\n */\ngoog.isDateLike = function(val) {\n  return goog.isObject(val) && typeof val.getFullYear == 'function';\n};\n\n\n/**\n * Returns true if the specified value is a string\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a string.\n */\ngoog.isString = function(val) {\n  return typeof val == 'string';\n};\n\n\n/**\n * Returns true if the specified value is a boolean\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is boolean.\n */\ngoog.isBoolean = function(val) {\n  return typeof val == 'boolean';\n};\n\n\n/**\n * Returns true if the specified value is a number\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a number.\n */\ngoog.isNumber = function(val) {\n  return typeof val == 'number';\n};\n\n\n/**\n * Returns true if the specified value is a function\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is a function.\n */\ngoog.isFunction = function(val) {\n  return goog.typeOf(val) == 'function';\n};\n\n\n/**\n * Returns true if the specified value is an object.  This includes arrays\n * and functions.\n * @param {*} val Variable to test.\n * @return {boolean} Whether variable is an object.\n */\ngoog.isObject = function(val) {\n  var type = typeof val;\n  return type == 'object' && val != null || type == 'function';\n  // return Object(val) === val also works, but is slower, especially if val is\n  // not an object.\n};\n\n\n/**\n * Gets a unique ID for an object. This mutates the object so that further\n * calls with the same object as a parameter returns the same value. The unique\n * ID is guaranteed to be unique across the current session amongst objects that\n * are passed into {@code getUid}. There is no guarantee that the ID is unique\n * or consistent across sessions. It is unsafe to generate unique ID for\n * function prototypes.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {number} The unique ID for the object.\n */\ngoog.getUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // In Opera window.hasOwnProperty exists but always returns false so we avoid\n  // using it. As a consequence the unique ID generated for BaseClass.prototype\n  // and SubClass.prototype will be the same.\n  return obj[goog.UID_PROPERTY_] ||\n      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n\n\n/**\n * Removes the unique ID from an object. This is useful if the object was\n * previously mutated using {@code goog.getUid} in which case the mutation is\n * undone.\n * @param {Object} obj The object to remove the unique ID field from.\n */\ngoog.removeUid = function(obj) {\n  // TODO(arv): Make the type stricter, do not accept null.\n\n  // DOM nodes in IE are not instance of Object and throws exception\n  // for delete. Instead we try to use removeAttribute\n  if ('removeAttribute' in obj) {\n    obj.removeAttribute(goog.UID_PROPERTY_);\n  }\n  /** @preserveTry */\n  try {\n    delete obj[goog.UID_PROPERTY_];\n  } catch (ex) {\n  }\n};\n\n\n/**\n * Name for unique ID property. Initialized in a way to help avoid collisions\n * with other closure javascript on the same page.\n * @type {string}\n * @private\n */\ngoog.UID_PROPERTY_ = 'closure_uid_' +\n    Math.floor(Math.random() * 2147483648).toString(36);\n\n\n/**\n * Counter for UID.\n * @type {number}\n * @private\n */\ngoog.uidCounter_ = 0;\n\n\n/**\n * Adds a hash code field to an object. The hash code is unique for the\n * given object.\n * @param {Object} obj The object to get the hash code for.\n * @return {number} The hash code for the object.\n * @deprecated Use goog.getUid instead.\n */\ngoog.getHashCode = goog.getUid;\n\n\n/**\n * Removes the hash code field from an object.\n * @param {Object} obj The object to remove the field from.\n * @deprecated Use goog.removeUid instead.\n */\ngoog.removeHashCode = goog.removeUid;\n\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n *\n * WARNINGS:\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\n * refer to themselves will cause infinite recursion.\n *\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\n * UIDs created by <code>getUid</code> into cloned results.\n *\n * @param {*} obj The value to clone.\n * @return {*} A clone of the input value.\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n  var type = goog.typeOf(obj);\n  if (type == 'object' || type == 'array') {\n    if (obj.clone) {\n      return obj.clone();\n    }\n    var clone = type == 'array' ? [] : {};\n    for (var key in obj) {\n      clone[key] = goog.cloneObject(obj[key]);\n    }\n    return clone;\n  }\n\n  return obj;\n};\n\n\n/**\n * Forward declaration for the clone method. This is necessary until the\n * compiler can better support duck-typing constructs as used in\n * goog.cloneObject.\n *\n * TODO(brenneman): Remove once the JSCompiler can infer that the check for\n * proto.clone is safe in goog.cloneObject.\n *\n * @type {Function}\n */\nObject.prototype.clone;\n\n\n/**\n * A native implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n * @suppress {deprecated} The compiler thinks that Function.prototype.bind\n *     is deprecated because some people have declared a pure-JS version.\n *     Only the pure-JS version is truly deprecated.\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\n};\n\n\n/**\n * A pure-JS implementation of goog.bind.\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @private\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n  if (!fn) {\n    throw new Error();\n  }\n\n  if (arguments.length > 2) {\n    var boundArgs = Array.prototype.slice.call(arguments, 2);\n    return function() {\n      // Prepend the bound arguments to the current arguments.\n      var newArgs = Array.prototype.slice.call(arguments);\n      Array.prototype.unshift.apply(newArgs, boundArgs);\n      return fn.apply(selfObj, newArgs);\n    };\n\n  } else {\n    return function() {\n      return fn.apply(selfObj, arguments);\n    };\n  }\n};\n\n\n/**\n * Partially applies this function to a particular 'this object' and zero or\n * more arguments. The result is a new function with some arguments of the first\n * function pre-filled and the value of |this| 'pre-specified'.<br><br>\n *\n * Remaining arguments specified at call-time are appended to the pre-\n * specified ones.<br><br>\n *\n * Also see: {@link #partial}.<br><br>\n *\n * Usage:\n * <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');\n * barMethBound('arg3', 'arg4');</pre>\n *\n * @param {Function} fn A function to partially apply.\n * @param {Object|undefined} selfObj Specifies the object which |this| should\n *     point to when the function is run.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to the function.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n * @suppress {deprecated} See above.\n */\ngoog.bind = function(fn, selfObj, var_args) {\n  // TODO(nicksantos): narrow the type signature.\n  if (Function.prototype.bind &&\n      // NOTE(nicksantos): Somebody pulled base.js into the default\n      // Chrome extension environment. This means that for Chrome extensions,\n      // they get the implementation of Function.prototype.bind that\n      // calls goog.bind instead of the native one. Even worse, we don't want\n      // to introduce a circular dependency between goog.bind and\n      // Function.prototype.bind, so we have to hack this to make sure it\n      // works correctly.\n      Function.prototype.bind.toString().indexOf('native code') != -1) {\n    goog.bind = goog.bindNative_;\n  } else {\n    goog.bind = goog.bindJs_;\n  }\n  return goog.bind.apply(null, arguments);\n};\n\n\n/**\n * Like bind(), except that a 'this object' is not required. Useful when the\n * target function is already bound.\n *\n * Usage:\n * var g = partial(f, arg1, arg2);\n * g(arg3, arg4);\n *\n * @param {Function} fn A function to partially apply.\n * @param {...*} var_args Additional arguments that are partially\n *     applied to fn.\n * @return {!Function} A partially-applied form of the function bind() was\n *     invoked as a method of.\n */\ngoog.partial = function(fn, var_args) {\n  var args = Array.prototype.slice.call(arguments, 1);\n  return function() {\n    // Prepend the bound arguments to the current arguments.\n    var newArgs = Array.prototype.slice.call(arguments);\n    newArgs.unshift.apply(newArgs, args);\n    return fn.apply(this, newArgs);\n  };\n};\n\n\n/**\n * Copies all the members of a source object to a target object. This method\n * does not work on all browsers for all objects that contain keys such as\n * toString or hasOwnProperty. Use goog.object.extend for this purpose.\n * @param {Object} target Target.\n * @param {Object} source Source.\n */\ngoog.mixin = function(target, source) {\n  for (var x in source) {\n    target[x] = source[x];\n  }\n\n  // For IE7 or lower, the for-in-loop does not contain any properties that are\n  // not enumerable on the prototype object (for example, isPrototypeOf from\n  // Object.prototype) but also it will not include 'replace' on objects that\n  // extend String and change 'replace' (not that it is common for anyone to\n  // extend anything except Object).\n};\n\n\n/**\n * @return {number} An integer value representing the number of milliseconds\n *     between midnight, January 1, 1970 and the current time.\n */\ngoog.now = Date.now || (function() {\n  // Unary plus operator converts its operand to a number which in the case of\n  // a date is done by calling getTime().\n  return +new Date();\n});\n\n\n/**\n * Evals javascript in the global scope.  In IE this uses execScript, other\n * browsers use goog.global.eval. If goog.global.eval does not evaluate in the\n * global scope (for example, in Safari), appends a script tag instead.\n * Throws an exception if neither execScript or eval is defined.\n * @param {string} script JavaScript string.\n */\ngoog.globalEval = function(script) {\n  if (goog.global.execScript) {\n    goog.global.execScript(script, 'JavaScript');\n  } else if (goog.global.eval) {\n    // Test to see if eval works\n    if (goog.evalWorksForGlobals_ == null) {\n      goog.global.eval('var _et_ = 1;');\n      if (typeof goog.global['_et_'] != 'undefined') {\n        delete goog.global['_et_'];\n        goog.evalWorksForGlobals_ = true;\n      } else {\n        goog.evalWorksForGlobals_ = false;\n      }\n    }\n\n    if (goog.evalWorksForGlobals_) {\n      goog.global.eval(script);\n    } else {\n      var doc = goog.global.document;\n      var scriptElt = doc.createElement('script');\n      scriptElt.type = 'text/javascript';\n      scriptElt.defer = false;\n      // Note(user): can't use .innerHTML since \"t('<test>')\" will fail and\n      // .text doesn't work in Safari 2.  Therefore we append a text node.\n      scriptElt.appendChild(doc.createTextNode(script));\n      doc.body.appendChild(scriptElt);\n      doc.body.removeChild(scriptElt);\n    }\n  } else {\n    throw Error('goog.globalEval not available');\n  }\n};\n\n\n/**\n * Indicates whether or not we can call 'eval' directly to eval code in the\n * global scope. Set to a Boolean by the first call to goog.globalEval (which\n * empirically tests whether eval works for globals). @see goog.globalEval\n * @type {?boolean}\n * @private\n */\ngoog.evalWorksForGlobals_ = null;\n\n\n/**\n * Optional map of CSS class names to obfuscated names used with\n * goog.getCssName().\n * @type {Object|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMapping_;\n\n\n/**\n * Optional obfuscation style for CSS class names. Should be set to either\n * 'BY_WHOLE' or 'BY_PART' if defined.\n * @type {string|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMappingStyle_;\n\n\n/**\n * Handles strings that are intended to be used as CSS class names.\n *\n * This function works in tandem with @see goog.setCssNameMapping.\n *\n * Without any mapping set, the arguments are simple joined with a\n * hyphen and passed through unaltered.\n *\n * When there is a mapping, there are two possible styles in which\n * these mappings are used. In the BY_PART style, each part (i.e. in\n * between hyphens) of the passed in css name is rewritten according\n * to the map. In the BY_WHOLE style, the full css name is looked up in\n * the map directly. If a rewrite is not specified by the map, the\n * compiler will output a warning.\n *\n * When the mapping is passed to the compiler, it will replace calls\n * to goog.getCssName with the strings from the mapping, e.g.\n *     var x = goog.getCssName('foo');\n *     var y = goog.getCssName(this.baseClass, 'active');\n *  becomes:\n *     var x= 'foo';\n *     var y = this.baseClass + '-active';\n *\n * If one argument is passed it will be processed, if two are passed\n * only the modifier will be processed, as it is assumed the first\n * argument was generated as a result of calling goog.getCssName.\n *\n * @param {string} className The class name.\n * @param {string=} opt_modifier A modifier to be appended to the class name.\n * @return {string} The class name or the concatenation of the class name and\n *     the modifier.\n */\ngoog.getCssName = function(className, opt_modifier) {\n  var getMapping = function(cssName) {\n    return goog.cssNameMapping_[cssName] || cssName;\n  };\n\n  var renameByParts = function(cssName) {\n    // Remap all the parts individually.\n    var parts = cssName.split('-');\n    var mapped = [];\n    for (var i = 0; i < parts.length; i++) {\n      mapped.push(getMapping(parts[i]));\n    }\n    return mapped.join('-');\n  };\n\n  var rename;\n  if (goog.cssNameMapping_) {\n    rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?\n        getMapping : renameByParts;\n  } else {\n    rename = function(a) {\n      return a;\n    };\n  }\n\n  if (opt_modifier) {\n    return className + '-' + rename(opt_modifier);\n  } else {\n    return rename(className);\n  }\n};\n\n\n/**\n * Sets the map to check when returning a value from goog.getCssName(). Example:\n * <pre>\n * goog.setCssNameMapping({\n *   \"goog\": \"a\",\n *   \"disabled\": \"b\",\n * });\n *\n * var x = goog.getCssName('goog');\n * // The following evaluates to: \"a a-b\".\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\n * </pre>\n * When declared as a map of string literals to string literals, the JSCompiler\n * will replace all calls to goog.getCssName() using the supplied map if the\n * --closure_pass flag is set.\n *\n * @param {!Object} mapping A map of strings to strings where keys are possible\n *     arguments to goog.getCssName() and values are the corresponding values\n *     that should be returned.\n * @param {string=} opt_style The style of css name mapping. There are two valid\n *     options: 'BY_PART', and 'BY_WHOLE'.\n * @see goog.getCssName for a description.\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n  goog.cssNameMapping_ = mapping;\n  goog.cssNameMappingStyle_ = opt_style;\n};\n\n\n/**\n * To use CSS renaming in compiled mode, one of the input files should have a\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\n * mode, JavaScript code should be loaded before this base.js file that declares\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\n * are made in uncompiled mode.\n *\n * A hook for overriding the CSS name mapping.\n * @type {Object|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\n\n\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n  // This does not call goog.setCssNameMapping() because the JSCompiler\n  // requires that goog.setCssNameMapping() be called with an object literal.\n  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n\n\n/**\n * Abstract implementation of goog.getMsg for use with localized messages.\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {Object=} opt_values Map of place holder name to value.\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values) {\n  var values = opt_values || {};\n  for (var key in values) {\n    var value = ('' + values[key]).replace(/\\$/g, '$$$$');\n    str = str.replace(new RegExp('\\\\{\\\\$' + key + '\\\\}', 'gi'), value);\n  }\n  return str;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated,\n * unless they are exported in turn via this function or\n * goog.exportProperty\n *\n * <p>Also handy for making public items that are defined in anonymous\n * closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction',\n *                       Foo.staticFunction);\n *     public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n *                       Foo.prototype.myMethod);\n *     new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {Object=} opt_objectToExportTo The object to add the path to; default\n *     is |goog.global|.\n */\ngoog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {\n  goog.exportPath_(publicPath, object, opt_objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n  object[publicName] = symbol;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * <pre>\n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { }\n *\n * function ChildClass(a, b, c) {\n *   goog.base(this, a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // works\n * </pre>\n *\n * In addition, a superclass' implementation of a method can be invoked\n * as follows:\n *\n * <pre>\n * ChildClass.prototype.foo = function(a) {\n *   ChildClass.superClass_.foo.call(this, a);\n *   // other code\n * };\n * </pre>\n *\n * @param {Function} childCtor Child class.\n * @param {Function} parentCtor Parent class.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n  /** @constructor */\n  function tempCtor() {};\n  tempCtor.prototype = parentCtor.prototype;\n  childCtor.superClass_ = parentCtor.prototype;\n  childCtor.prototype = new tempCtor();\n  childCtor.prototype.constructor = childCtor;\n};\n\n\n/**\n * Call up to the superclass.\n *\n * If this is called from a constructor, then this calls the superclass\n * contructor with arguments 1-N.\n *\n * If this is called from a prototype method, then you must pass\n * the name of the method as the second argument to this function. If\n * you do not, you will get a runtime error. This calls the superclass'\n * method with arguments 2-N.\n *\n * This function only works if you use goog.inherits to express\n * inheritance relationships between your classes.\n *\n * This function is a compiler primitive. At compile-time, the\n * compiler will do macro expansion to remove a lot of\n * the extra overhead that this function introduces. The compiler\n * will also enforce a lot of the assumptions that this function\n * makes, and treat it as a compiler error if you break them.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {*=} opt_methodName The method name if calling a super method.\n * @param {...*} var_args The rest of the arguments.\n * @return {*} The return value of the superclass method.\n */\ngoog.base = function(me, opt_methodName, var_args) {\n  var caller = arguments.callee.caller;\n  if (caller.superClass_) {\n    // This is a constructor. Call the superclass constructor.\n    return caller.superClass_.constructor.apply(\n        me, Array.prototype.slice.call(arguments, 1));\n  }\n\n  var args = Array.prototype.slice.call(arguments, 2);\n  var foundCaller = false;\n  for (var ctor = me.constructor;\n       ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {\n    if (ctor.prototype[opt_methodName] === caller) {\n      foundCaller = true;\n    } else if (foundCaller) {\n      return ctor.prototype[opt_methodName].apply(me, args);\n    }\n  }\n\n  // If we did not find the caller in the prototype chain,\n  // then one of two things happened:\n  // 1) The caller is an instance method.\n  // 2) This method was not called by the right caller.\n  if (me[opt_methodName] === caller) {\n    return me.constructor.prototype[opt_methodName].apply(me, args);\n  } else {\n    throw Error(\n        'goog.base called from a method of one name ' +\n        'to a method of a different name');\n  }\n};\n\n\n/**\n * Allow for aliasing within scope functions.  This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the\n * aliases applied.  In uncompiled code the function is simply run since the\n * aliases as written are valid JavaScript.\n * @param {function()} fn Function to call.  This function can contain aliases\n *     to namespaces (e.g. \"var dom = goog.dom\") or classes\n *    (e.g. \"var Timer = goog.Timer\").\n */\ngoog.scope = function(fn) {\n  fn.call(goog.global);\n};\n\n\n","/**\n * defines\n */\n\ngoog.provide('USE_TYPEDARRAY');\n\n// Safari が typeof Uint8Array === 'object' になるため、\n// 未定義か否かで Typed Array の使用を決定する\n\n/** @const {boolean} use typed array flag. */\nvar USE_TYPEDARRAY =\n  (typeof Uint8Array !== 'undefined') &&\n  (typeof Uint16Array !== 'undefined') &&\n  (typeof Uint32Array !== 'undefined') &&\n  (typeof DataView !== 'undefined');\n","/**\n * @fileoverview bit 単位での書き込み実装.\n */\ngoog.provide('Zlib.BitStream');\n\ngoog.require('USE_TYPEDARRAY');\n\ngoog.scope(function() {\n\n/**\n * ビットストリーム\n * @constructor\n * @param {!(Array|Uint8Array)=} buffer output buffer.\n * @param {number=} bufferPosition start buffer pointer.\n */\nZlib.BitStream = function(buffer, bufferPosition) {\n  /** @type {number} buffer index. */\n  this.index = typeof bufferPosition === 'number' ? bufferPosition : 0;\n  /** @type {number} bit index. */\n  this.bitindex = 0;\n  /** @type {!(Array|Uint8Array)} bit-stream output buffer. */\n  this.buffer = buffer instanceof (USE_TYPEDARRAY ? Uint8Array : Array) ?\n    buffer :\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.BitStream.DefaultBlockSize);\n\n  // 入力された index が足りなかったら拡張するが、倍にしてもダメなら不正とする\n  if (this.buffer.length * 2 <= this.index) {\n    throw new Error(\"invalid index\");\n  } else if (this.buffer.length <= this.index) {\n    this.expandBuffer();\n  }\n};\n\n/**\n * デフォルトブロックサイズ.\n * @const\n * @type {number}\n */\nZlib.BitStream.DefaultBlockSize = 0x8000;\n\n/**\n * expand buffer.\n * @return {!(Array|Uint8Array)} new buffer.\n */\nZlib.BitStream.prototype.expandBuffer = function() {\n  /** @type {!(Array|Uint8Array)} old buffer. */\n  var oldbuf = this.buffer;\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limiter. */\n  var il = oldbuf.length;\n  /** @type {!(Array|Uint8Array)} new buffer. */\n  var buffer =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(il << 1);\n\n  // copy buffer\n  if (USE_TYPEDARRAY) {\n    buffer.set(oldbuf);\n  } else {\n    // XXX: loop unrolling\n    for (i = 0; i < il; ++i) {\n      buffer[i] = oldbuf[i];\n    }\n  }\n\n  return (this.buffer = buffer);\n};\n\n\n/**\n * 数値をビットで指定した数だけ書き込む.\n * @param {number} number 書き込む数値.\n * @param {number} n 書き込むビット数.\n * @param {boolean=} reverse 逆順に書き込むならば true.\n */\nZlib.BitStream.prototype.writeBits = function(number, n, reverse) {\n  var buffer = this.buffer;\n  var index = this.index;\n  var bitindex = this.bitindex;\n\n  /** @type {number} current octet. */\n  var current = buffer[index];\n  /** @type {number} loop counter. */\n  var i;\n\n  /**\n   * 32-bit 整数のビット順を逆にする\n   * @param {number} n 32-bit integer.\n   * @return {number} reversed 32-bit integer.\n   * @private\n   */\n  function rev32_(n) {\n    return (Zlib.BitStream.ReverseTable[n & 0xFF] << 24) |\n      (Zlib.BitStream.ReverseTable[n >>> 8 & 0xFF] << 16) |\n      (Zlib.BitStream.ReverseTable[n >>> 16 & 0xFF] << 8) |\n      Zlib.BitStream.ReverseTable[n >>> 24 & 0xFF];\n  }\n\n  if (reverse && n > 1) {\n    number = n > 8 ?\n      rev32_(number) >> (32 - n) :\n      Zlib.BitStream.ReverseTable[number] >> (8 - n);\n  }\n\n  // Byte 境界を超えないとき\n  if (n + bitindex < 8) {\n    current = (current << n) | number;\n    bitindex += n;\n  // Byte 境界を超えるとき\n  } else {\n    for (i = 0; i < n; ++i) {\n      current = (current << 1) | ((number >> n - i - 1) & 1);\n\n      // next byte\n      if (++bitindex === 8) {\n        bitindex = 0;\n        buffer[index++] = Zlib.BitStream.ReverseTable[current];\n        current = 0;\n\n        // expand\n        if (index === buffer.length) {\n          buffer = this.expandBuffer();\n        }\n      }\n    }\n  }\n  buffer[index] = current;\n\n  this.buffer = buffer;\n  this.bitindex = bitindex;\n  this.index = index;\n};\n\n\n/**\n * ストリームの終端処理を行う\n * @return {!(Array|Uint8Array)} 終端処理後のバッファを byte array で返す.\n */\nZlib.BitStream.prototype.finish = function() {\n  var buffer = this.buffer;\n  var index = this.index;\n\n  /** @type {!(Array|Uint8Array)} output buffer. */\n  var output;\n\n  // bitindex が 0 の時は余分に index が進んでいる状態\n  if (this.bitindex > 0) {\n    buffer[index] <<= 8 - this.bitindex;\n    buffer[index] = Zlib.BitStream.ReverseTable[buffer[index]];\n    index++;\n  }\n\n  // array truncation\n  if (USE_TYPEDARRAY) {\n    output = buffer.subarray(0, index);\n  } else {\n    buffer.length = index;\n    output = buffer;\n  }\n\n  return output;\n};\n\n/**\n * 0-255 のビット順を反転したテーブル\n * @const\n * @type {!(Uint8Array|Array.<number>)}\n */\nZlib.BitStream.ReverseTable = (function(table) {\n  return table;\n})((function() {\n  /** @type {!(Array|Uint8Array)} reverse table. */\n  var table = new (USE_TYPEDARRAY ? Uint8Array : Array)(256);\n  /** @type {number} loop counter. */\n  var i;\n\n  // generate\n  for (i = 0; i < 256; ++i) {\n    table[i] = (function(n) {\n      var r = n;\n      var s = 7;\n\n      for (n >>>= 1; n; n >>>= 1) {\n        r <<= 1;\n        r |= n & 1;\n        --s;\n      }\n\n      return (r << s & 0xff) >>> 0;\n    })(i);\n  }\n\n  return table;\n})());\n\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview CRC32 実装.\n */\ngoog.provide('Zlib.CRC32');\n\ngoog.require('USE_TYPEDARRAY');\n\n/** @define {boolean} */\nvar ZLIB_CRC32_COMPACT = false;\n\ngoog.scope(function() {\n\n/**\n * CRC32 ハッシュ値を取得\n * @param {!(Array.<number>|Uint8Array)} data data byte array.\n * @param {number=} pos data position.\n * @param {number=} length data length.\n * @return {number} CRC32.\n */\nZlib.CRC32.calc = function(data, pos, length) {\n  return Zlib.CRC32.update(data, 0, pos, length);\n};\n\n/**\n * CRC32ハッシュ値を更新\n * @param {!(Array.<number>|Uint8Array)} data data byte array.\n * @param {number} crc CRC32.\n * @param {number=} pos data position.\n * @param {number=} length data length.\n * @return {number} CRC32.\n */\nZlib.CRC32.update = function(data, crc, pos, length) {\n  var table = Zlib.CRC32.Table;\n  var i = (typeof pos === 'number') ? pos : (pos = 0);\n  var il = (typeof length === 'number') ? length : data.length;\n\n  crc ^= 0xffffffff;\n\n  // loop unrolling for performance\n  for (i = il & 7; i--; ++pos) {\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos]) & 0xff];\n  }\n  for (i = il >> 3; i--; pos += 8) {\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos    ]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 1]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 2]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 3]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 4]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 5]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 6]) & 0xff];\n    crc = (crc >>> 8) ^ table[(crc ^ data[pos + 7]) & 0xff];\n  }\n\n  return (crc ^ 0xffffffff) >>> 0;\n};\n\n/**\n * @param {number} num\n * @param {number} crc\n * @returns {number}\n */\nZlib.CRC32.single = function(num, crc) {\n  return (Zlib.CRC32.Table[(num ^ crc) & 0xff] ^ (num >>> 8)) >>> 0;\n};\n\n/**\n * @type {Array.<number>}\n * @const\n * @private\n */\nZlib.CRC32.Table_ = [\n  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,\n  0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,\n  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,\n  0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,\n  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,\n  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,\n  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,\n  0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,\n  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,\n  0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,\n  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,\n  0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,\n  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,\n  0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,\n  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,\n  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,\n  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,\n  0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,\n  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,\n  0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,\n  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,\n  0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,\n  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,\n  0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,\n  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,\n  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,\n  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,\n  0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,\n  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,\n  0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,\n  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,\n  0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,\n  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,\n  0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,\n  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,\n  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,\n  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,\n  0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,\n  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,\n  0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,\n  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,\n  0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,\n  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d\n];\n\n/**\n * @type {!(Array.<number>|Uint32Array)} CRC-32 Table.\n * @const\n */\nZlib.CRC32.Table = ZLIB_CRC32_COMPACT ? (function() {\n  /** @type {!(Array.<number>|Uint32Array)} */\n  var table = new (USE_TYPEDARRAY ? Uint32Array : Array)(256);\n  /** @type {number} */\n  var c;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var j;\n\n  for (i = 0; i < 256; ++i) {\n    c = i;\n    for (j = 0; j < 8; ++j) {\n      c = (c & 1) ? (0xedB88320 ^ (c >>> 1)) : (c >>> 1);\n    }\n    table[i] = c >>> 0;\n  }\n\n  return table;\n})() : USE_TYPEDARRAY ? new Uint32Array(Zlib.CRC32.Table_) : Zlib.CRC32.Table_;\n\n});\n","goog.provide('Zlib.Huffman');\n\ngoog.require('USE_TYPEDARRAY');\n\ngoog.scope(function() {\n\n/**\n * build huffman table from length list.\n * @param {!(Array.<number>|Uint8Array)} lengths length list.\n * @return {!Array} huffman table.\n */\nZlib.Huffman.buildHuffmanTable = function(lengths) {\n  /** @type {number} length list size. */\n  var listSize = lengths.length;\n  /** @type {number} max code length for table size. */\n  var maxCodeLength = 0;\n  /** @type {number} min code length for table size. */\n  var minCodeLength = Number.POSITIVE_INFINITY;\n  /** @type {number} table size. */\n  var size;\n  /** @type {!(Array|Uint8Array)} huffman code table. */\n  var table;\n  /** @type {number} bit length. */\n  var bitLength;\n  /** @type {number} huffman code. */\n  var code;\n  /**\n   * サイズが 2^maxlength 個のテーブルを埋めるためのスキップ長.\n   * @type {number} skip length for table filling.\n   */\n  var skip;\n  /** @type {number} reversed code. */\n  var reversed;\n  /** @type {number} reverse temp. */\n  var rtemp;\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limit. */\n  var il;\n  /** @type {number} loop counter. */\n  var j;\n  /** @type {number} table value. */\n  var value;\n\n  // Math.max は遅いので最長の値は for-loop で取得する\n  for (i = 0, il = listSize; i < il; ++i) {\n    if (lengths[i] > maxCodeLength) {\n      maxCodeLength = lengths[i];\n    }\n    if (lengths[i] < minCodeLength) {\n      minCodeLength = lengths[i];\n    }\n  }\n\n  size = 1 << maxCodeLength;\n  table = new (USE_TYPEDARRAY ? Uint32Array : Array)(size);\n\n  // ビット長の短い順からハフマン符号を割り当てる\n  for (bitLength = 1, code = 0, skip = 2; bitLength <= maxCodeLength;) {\n    for (i = 0; i < listSize; ++i) {\n      if (lengths[i] === bitLength) {\n        // ビットオーダーが逆になるためビット長分並びを反転する\n        for (reversed = 0, rtemp = code, j = 0; j < bitLength; ++j) {\n          reversed = (reversed << 1) | (rtemp & 1);\n          rtemp >>= 1;\n        }\n\n        // 最大ビット長をもとにテーブルを作るため、\n        // 最大ビット長以外では 0 / 1 どちらでも良い箇所ができる\n        // そのどちらでも良い場所は同じ値で埋めることで\n        // 本来のビット長以上のビット数取得しても問題が起こらないようにする\n        value = (bitLength << 16) | i;\n        for (j = reversed; j < size; j += skip) {\n          table[j] = value;\n        }\n\n        ++code;\n      }\n    }\n\n    // 次のビット長へ\n    ++bitLength;\n    code <<= 1;\n    skip <<= 1;\n  }\n\n  return [table, maxCodeLength, minCodeLength];\n};\n\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","/**\n * @fileoverview Deflate (RFC1951) 符号化アルゴリズム実装.\n */\n\ngoog.provide('Zlib.RawDeflate');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.BitStream');\ngoog.require('Zlib.Heap');\n\ngoog.scope(function() {\n\n/**\n * Raw Deflate 実装\n *\n * @constructor\n * @param {!(Array.<number>|Uint8Array)} input 符号化する対象のバッファ.\n * @param {Object=} opt_params option parameters.\n *\n * typed array が使用可能なとき、outputBuffer が Array は自動的に Uint8Array に\n * 変換されます.\n * 別のオブジェクトになるため出力バッファを参照している変数などは\n * 更新する必要があります.\n */\nZlib.RawDeflate = function(input, opt_params) {\n  /** @type {Zlib.RawDeflate.CompressionType} */\n  this.compressionType = Zlib.RawDeflate.CompressionType.DYNAMIC;\n  /** @type {number} */\n  this.lazy = 0;\n  /** @type {!(Array.<number>|Uint32Array)} */\n  this.freqsLitLen;\n  /** @type {!(Array.<number>|Uint32Array)} */\n  this.freqsDist;\n  /** @type {!(Array.<number>|Uint8Array)} */\n  this.input =\n    (USE_TYPEDARRAY && input instanceof Array) ? new Uint8Array(input) : input;\n  /** @type {!(Array.<number>|Uint8Array)} output output buffer. */\n  this.output;\n  /** @type {number} pos output buffer position. */\n  this.op = 0;\n\n  // option parameters\n  if (opt_params) {\n    if (opt_params['lazy']) {\n      this.lazy = opt_params['lazy'];\n    }\n    if (typeof opt_params['compressionType'] === 'number') {\n      this.compressionType = opt_params['compressionType'];\n    }\n    if (opt_params['outputBuffer']) {\n      this.output =\n        (USE_TYPEDARRAY && opt_params['outputBuffer'] instanceof Array) ?\n        new Uint8Array(opt_params['outputBuffer']) : opt_params['outputBuffer'];\n    }\n    if (typeof opt_params['outputIndex'] === 'number') {\n      this.op = opt_params['outputIndex'];\n    }\n  }\n\n  if (!this.output) {\n    this.output = new (USE_TYPEDARRAY ? Uint8Array : Array)(0x8000);\n  }\n};\n\n/**\n * @enum {number}\n */\nZlib.RawDeflate.CompressionType = {\n  NONE: 0,\n  FIXED: 1,\n  DYNAMIC: 2,\n  RESERVED: 3\n};\n\n\n/**\n * LZ77 の最小マッチ長\n * @const\n * @type {number}\n */\nZlib.RawDeflate.Lz77MinLength = 3;\n\n/**\n * LZ77 の最大マッチ長\n * @const\n * @type {number}\n */\nZlib.RawDeflate.Lz77MaxLength = 258;\n\n/**\n * LZ77 のウィンドウサイズ\n * @const\n * @type {number}\n */\nZlib.RawDeflate.WindowSize = 0x8000;\n\n/**\n * 最長の符号長\n * @const\n * @type {number}\n */\nZlib.RawDeflate.MaxCodeLength = 16;\n\n/**\n * ハフマン符号の最大数値\n * @const\n * @type {number}\n */\nZlib.RawDeflate.HUFMAX = 286;\n\n/**\n * 固定ハフマン符号の符号化テーブル\n * @const\n * @type {Array.<Array.<number, number>>}\n */\nZlib.RawDeflate.FixedHuffmanTable = (function() {\n  var table = [], i;\n\n  for (i = 0; i < 288; i++) {\n    switch (true) {\n      case (i <= 143): table.push([i       + 0x030, 8]); break;\n      case (i <= 255): table.push([i - 144 + 0x190, 9]); break;\n      case (i <= 279): table.push([i - 256 + 0x000, 7]); break;\n      case (i <= 287): table.push([i - 280 + 0x0C0, 8]); break;\n      default:\n        throw 'invalid literal: ' + i;\n    }\n  }\n\n  return table;\n})();\n\n/**\n * DEFLATE ブロックの作成\n * @return {!(Array.<number>|Uint8Array)} 圧縮済み byte array.\n */\nZlib.RawDeflate.prototype.compress = function() {\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var blockArray;\n  /** @type {number} */\n  var position;\n  /** @type {number} */\n  var length;\n\n  var input = this.input;\n\n  // compression\n  switch (this.compressionType) {\n    case Zlib.RawDeflate.CompressionType.NONE:\n      // each 65535-Byte (length header: 16-bit)\n      for (position = 0, length = input.length; position < length;) {\n        blockArray = USE_TYPEDARRAY ?\n          input.subarray(position, position + 0xffff) :\n          input.slice(position, position + 0xffff);\n        position += blockArray.length;\n        this.makeNocompressBlock(blockArray, (position === length));\n      }\n      break;\n    case Zlib.RawDeflate.CompressionType.FIXED:\n      this.output = this.makeFixedHuffmanBlock(input, true);\n      this.op = this.output.length;\n      break;\n    case Zlib.RawDeflate.CompressionType.DYNAMIC:\n      this.output = this.makeDynamicHuffmanBlock(input, true);\n      this.op = this.output.length;\n      break;\n    default:\n      throw 'invalid compression type';\n  }\n\n  return this.output;\n};\n\n/**\n * 非圧縮ブロックの作成\n * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.\n * @param {!boolean} isFinalBlock 最後のブロックならばtrue.\n * @return {!(Array.<number>|Uint8Array)} 非圧縮ブロック byte array.\n */\nZlib.RawDeflate.prototype.makeNocompressBlock =\nfunction(blockArray, isFinalBlock) {\n  /** @type {number} */\n  var bfinal;\n  /** @type {Zlib.RawDeflate.CompressionType} */\n  var btype;\n  /** @type {number} */\n  var len;\n  /** @type {number} */\n  var nlen;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var il;\n\n  var output = this.output;\n  var op = this.op;\n\n  // expand buffer\n  if (USE_TYPEDARRAY) {\n    output = new Uint8Array(this.output.buffer);\n    while (output.length <= op + blockArray.length + 5) {\n      output = new Uint8Array(output.length << 1);\n    }\n    output.set(this.output);\n  }\n\n  // header\n  bfinal = isFinalBlock ? 1 : 0;\n  btype = Zlib.RawDeflate.CompressionType.NONE;\n  output[op++] = (bfinal) | (btype << 1);\n\n  // length\n  len = blockArray.length;\n  nlen = (~len + 0x10000) & 0xffff;\n  output[op++] =          len & 0xff;\n  output[op++] =  (len >>> 8) & 0xff;\n  output[op++] =         nlen & 0xff;\n  output[op++] = (nlen >>> 8) & 0xff;\n\n  // copy buffer\n  if (USE_TYPEDARRAY) {\n     output.set(blockArray, op);\n     op += blockArray.length;\n     output = output.subarray(0, op);\n  } else {\n    for (i = 0, il = blockArray.length; i < il; ++i) {\n      output[op++] = blockArray[i];\n    }\n    output.length = op;\n  }\n\n  this.op = op;\n  this.output = output;\n\n  return output;\n};\n\n/**\n * 固定ハフマンブロックの作成\n * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.\n * @param {!boolean} isFinalBlock 最後のブロックならばtrue.\n * @return {!(Array.<number>|Uint8Array)} 固定ハフマン符号化ブロック byte array.\n */\nZlib.RawDeflate.prototype.makeFixedHuffmanBlock =\nfunction(blockArray, isFinalBlock) {\n  /** @type {Zlib.BitStream} */\n  var stream = new Zlib.BitStream(USE_TYPEDARRAY ?\n    new Uint8Array(this.output.buffer) : this.output, this.op);\n  /** @type {number} */\n  var bfinal;\n  /** @type {Zlib.RawDeflate.CompressionType} */\n  var btype;\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var data;\n\n  // header\n  bfinal = isFinalBlock ? 1 : 0;\n  btype = Zlib.RawDeflate.CompressionType.FIXED;\n\n  stream.writeBits(bfinal, 1, true);\n  stream.writeBits(btype, 2, true);\n\n  data = this.lz77(blockArray);\n  this.fixedHuffman(data, stream);\n\n  return stream.finish();\n};\n\n/**\n * 動的ハフマンブロックの作成\n * @param {!(Array.<number>|Uint8Array)} blockArray ブロックデータ byte array.\n * @param {!boolean} isFinalBlock 最後のブロックならばtrue.\n * @return {!(Array.<number>|Uint8Array)} 動的ハフマン符号ブロック byte array.\n */\nZlib.RawDeflate.prototype.makeDynamicHuffmanBlock =\nfunction(blockArray, isFinalBlock) {\n  /** @type {Zlib.BitStream} */\n  var stream = new Zlib.BitStream(USE_TYPEDARRAY ?\n    new Uint8Array(this.output.buffer) : this.output, this.op);\n  /** @type {number} */\n  var bfinal;\n  /** @type {Zlib.RawDeflate.CompressionType} */\n  var btype;\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var data;\n  /** @type {number} */\n  var hlit;\n  /** @type {number} */\n  var hdist;\n  /** @type {number} */\n  var hclen;\n  /** @const @type {Array.<number>} */\n  var hclenOrder =\n        [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var litLenLengths;\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var litLenCodes;\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var distLengths;\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var distCodes;\n  /** @type {{\n   *   codes: !(Array.<number>|Uint32Array),\n   *   freqs: !(Array.<number>|Uint32Array)\n   * }} */\n  var treeSymbols;\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var treeLengths;\n  /** @type {Array} */\n  var transLengths = new Array(19);\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var treeCodes;\n  /** @type {number} */\n  var code;\n  /** @type {number} */\n  var bitlen;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var il;\n\n  // header\n  bfinal = isFinalBlock ? 1 : 0;\n  btype = Zlib.RawDeflate.CompressionType.DYNAMIC;\n\n  stream.writeBits(bfinal, 1, true);\n  stream.writeBits(btype, 2, true);\n\n  data = this.lz77(blockArray);\n\n  // リテラル・長さ, 距離のハフマン符号と符号長の算出\n  litLenLengths = this.getLengths_(this.freqsLitLen, 15);\n  litLenCodes = this.getCodesFromLengths_(litLenLengths);\n  distLengths = this.getLengths_(this.freqsDist, 7);\n  distCodes = this.getCodesFromLengths_(distLengths);\n\n  // HLIT, HDIST の決定\n  for (hlit = 286; hlit > 257 && litLenLengths[hlit - 1] === 0; hlit--) {}\n  for (hdist = 30; hdist > 1 && distLengths[hdist - 1] === 0; hdist--) {}\n\n  // HCLEN\n  treeSymbols =\n    this.getTreeSymbols_(hlit, litLenLengths, hdist, distLengths);\n  treeLengths = this.getLengths_(treeSymbols.freqs, 7);\n  for (i = 0; i < 19; i++) {\n    transLengths[i] = treeLengths[hclenOrder[i]];\n  }\n  for (hclen = 19; hclen > 4 && transLengths[hclen - 1] === 0; hclen--) {}\n\n  treeCodes = this.getCodesFromLengths_(treeLengths);\n\n  // 出力\n  stream.writeBits(hlit - 257, 5, true);\n  stream.writeBits(hdist - 1, 5, true);\n  stream.writeBits(hclen - 4, 4, true);\n  for (i = 0; i < hclen; i++) {\n    stream.writeBits(transLengths[i], 3, true);\n  }\n\n  // ツリーの出力\n  for (i = 0, il = treeSymbols.codes.length; i < il; i++) {\n    code = treeSymbols.codes[i];\n\n    stream.writeBits(treeCodes[code], treeLengths[code], true);\n\n    // extra bits\n    if (code >= 16) {\n      i++;\n      switch (code) {\n        case 16: bitlen = 2; break;\n        case 17: bitlen = 3; break;\n        case 18: bitlen = 7; break;\n        default:\n          throw 'invalid code: ' + code;\n      }\n\n      stream.writeBits(treeSymbols.codes[i], bitlen, true);\n    }\n  }\n\n  this.dynamicHuffman(\n    data,\n    [litLenCodes, litLenLengths],\n    [distCodes, distLengths],\n    stream\n  );\n\n  return stream.finish();\n};\n\n\n/**\n * 動的ハフマン符号化(カスタムハフマンテーブル)\n * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.\n * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.\n * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.\n */\nZlib.RawDeflate.prototype.dynamicHuffman =\nfunction(dataArray, litLen, dist, stream) {\n  /** @type {number} */\n  var index;\n  /** @type {number} */\n  var length;\n  /** @type {number} */\n  var literal;\n  /** @type {number} */\n  var code;\n  /** @type {number} */\n  var litLenCodes;\n  /** @type {number} */\n  var litLenLengths;\n  /** @type {number} */\n  var distCodes;\n  /** @type {number} */\n  var distLengths;\n\n  litLenCodes = litLen[0];\n  litLenLengths = litLen[1];\n  distCodes = dist[0];\n  distLengths = dist[1];\n\n  // 符号を BitStream に書き込んでいく\n  for (index = 0, length = dataArray.length; index < length; ++index) {\n    literal = dataArray[index];\n\n    // literal or length\n    stream.writeBits(litLenCodes[literal], litLenLengths[literal], true);\n\n    // 長さ・距離符号\n    if (literal > 256) {\n      // length extra\n      stream.writeBits(dataArray[++index], dataArray[++index], true);\n      // distance\n      code = dataArray[++index];\n      stream.writeBits(distCodes[code], distLengths[code], true);\n      // distance extra\n      stream.writeBits(dataArray[++index], dataArray[++index], true);\n    // 終端\n    } else if (literal === 256) {\n      break;\n    }\n  }\n\n  return stream;\n};\n\n/**\n * 固定ハフマン符号化\n * @param {!(Array.<number>|Uint16Array)} dataArray LZ77 符号化済み byte array.\n * @param {!Zlib.BitStream} stream 書き込み用ビットストリーム.\n * @return {!Zlib.BitStream} ハフマン符号化済みビットストリームオブジェクト.\n */\nZlib.RawDeflate.prototype.fixedHuffman = function(dataArray, stream) {\n  /** @type {number} */\n  var index;\n  /** @type {number} */\n  var length;\n  /** @type {number} */\n  var literal;\n\n  // 符号を BitStream に書き込んでいく\n  for (index = 0, length = dataArray.length; index < length; index++) {\n    literal = dataArray[index];\n\n    // 符号の書き込み\n    Zlib.BitStream.prototype.writeBits.apply(\n      stream,\n      Zlib.RawDeflate.FixedHuffmanTable[literal]\n    );\n\n    // 長さ・距離符号\n    if (literal > 0x100) {\n      // length extra\n      stream.writeBits(dataArray[++index], dataArray[++index], true);\n      // distance\n      stream.writeBits(dataArray[++index], 5);\n      // distance extra\n      stream.writeBits(dataArray[++index], dataArray[++index], true);\n    // 終端\n    } else if (literal === 0x100) {\n      break;\n    }\n  }\n\n  return stream;\n};\n\n/**\n * マッチ情報\n * @param {!number} length マッチした長さ.\n * @param {!number} backwardDistance マッチ位置との距離.\n * @constructor\n */\nZlib.RawDeflate.Lz77Match = function(length, backwardDistance) {\n  /** @type {number} match length. */\n  this.length = length;\n  /** @type {number} backward distance. */\n  this.backwardDistance = backwardDistance;\n};\n\n/**\n * 長さ符号テーブル.\n * [コード, 拡張ビット, 拡張ビット長] の配列となっている.\n * @const\n * @type {!(Array.<number>|Uint32Array)}\n */\nZlib.RawDeflate.Lz77Match.LengthCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint32Array(table) : table;\n})((function() {\n  /** @type {!Array} */\n  var table = [];\n  /** @type {number} */\n  var i;\n  /** @type {!Array.<number>} */\n  var c;\n\n  for (i = 3; i <= 258; i++) {\n    c = code(i);\n    table[i] = (c[2] << 24) | (c[1] << 16) | c[0];\n  }\n\n  /**\n   * @param {number} length lz77 length.\n   * @return {!Array.<number>} lz77 codes.\n   */\n  function code(length) {\n    switch (true) {\n      case (length === 3): return [257, length - 3, 0]; break;\n      case (length === 4): return [258, length - 4, 0]; break;\n      case (length === 5): return [259, length - 5, 0]; break;\n      case (length === 6): return [260, length - 6, 0]; break;\n      case (length === 7): return [261, length - 7, 0]; break;\n      case (length === 8): return [262, length - 8, 0]; break;\n      case (length === 9): return [263, length - 9, 0]; break;\n      case (length === 10): return [264, length - 10, 0]; break;\n      case (length <= 12): return [265, length - 11, 1]; break;\n      case (length <= 14): return [266, length - 13, 1]; break;\n      case (length <= 16): return [267, length - 15, 1]; break;\n      case (length <= 18): return [268, length - 17, 1]; break;\n      case (length <= 22): return [269, length - 19, 2]; break;\n      case (length <= 26): return [270, length - 23, 2]; break;\n      case (length <= 30): return [271, length - 27, 2]; break;\n      case (length <= 34): return [272, length - 31, 2]; break;\n      case (length <= 42): return [273, length - 35, 3]; break;\n      case (length <= 50): return [274, length - 43, 3]; break;\n      case (length <= 58): return [275, length - 51, 3]; break;\n      case (length <= 66): return [276, length - 59, 3]; break;\n      case (length <= 82): return [277, length - 67, 4]; break;\n      case (length <= 98): return [278, length - 83, 4]; break;\n      case (length <= 114): return [279, length - 99, 4]; break;\n      case (length <= 130): return [280, length - 115, 4]; break;\n      case (length <= 162): return [281, length - 131, 5]; break;\n      case (length <= 194): return [282, length - 163, 5]; break;\n      case (length <= 226): return [283, length - 195, 5]; break;\n      case (length <= 257): return [284, length - 227, 5]; break;\n      case (length === 258): return [285, length - 258, 0]; break;\n      default: throw 'invalid length: ' + length;\n    }\n  }\n\n  return table;\n})());\n\n/**\n * 距離符号テーブル\n * @param {!number} dist 距離.\n * @return {!Array.<number>} コード、拡張ビット、拡張ビット長の配列.\n * @private\n */\nZlib.RawDeflate.Lz77Match.prototype.getDistanceCode_ = function(dist) {\n  /** @type {!Array.<number>} distance code table. */\n  var r;\n\n  switch (true) {\n    case (dist === 1): r = [0, dist - 1, 0]; break;\n    case (dist === 2): r = [1, dist - 2, 0]; break;\n    case (dist === 3): r = [2, dist - 3, 0]; break;\n    case (dist === 4): r = [3, dist - 4, 0]; break;\n    case (dist <= 6): r = [4, dist - 5, 1]; break;\n    case (dist <= 8): r = [5, dist - 7, 1]; break;\n    case (dist <= 12): r = [6, dist - 9, 2]; break;\n    case (dist <= 16): r = [7, dist - 13, 2]; break;\n    case (dist <= 24): r = [8, dist - 17, 3]; break;\n    case (dist <= 32): r = [9, dist - 25, 3]; break;\n    case (dist <= 48): r = [10, dist - 33, 4]; break;\n    case (dist <= 64): r = [11, dist - 49, 4]; break;\n    case (dist <= 96): r = [12, dist - 65, 5]; break;\n    case (dist <= 128): r = [13, dist - 97, 5]; break;\n    case (dist <= 192): r = [14, dist - 129, 6]; break;\n    case (dist <= 256): r = [15, dist - 193, 6]; break;\n    case (dist <= 384): r = [16, dist - 257, 7]; break;\n    case (dist <= 512): r = [17, dist - 385, 7]; break;\n    case (dist <= 768): r = [18, dist - 513, 8]; break;\n    case (dist <= 1024): r = [19, dist - 769, 8]; break;\n    case (dist <= 1536): r = [20, dist - 1025, 9]; break;\n    case (dist <= 2048): r = [21, dist - 1537, 9]; break;\n    case (dist <= 3072): r = [22, dist - 2049, 10]; break;\n    case (dist <= 4096): r = [23, dist - 3073, 10]; break;\n    case (dist <= 6144): r = [24, dist - 4097, 11]; break;\n    case (dist <= 8192): r = [25, dist - 6145, 11]; break;\n    case (dist <= 12288): r = [26, dist - 8193, 12]; break;\n    case (dist <= 16384): r = [27, dist - 12289, 12]; break;\n    case (dist <= 24576): r = [28, dist - 16385, 13]; break;\n    case (dist <= 32768): r = [29, dist - 24577, 13]; break;\n    default: throw 'invalid distance';\n  }\n\n  return r;\n};\n\n/**\n * マッチ情報を LZ77 符号化配列で返す.\n * なお、ここでは以下の内部仕様で符号化している\n * [ CODE, EXTRA-BIT-LEN, EXTRA, CODE, EXTRA-BIT-LEN, EXTRA ]\n * @return {!Array.<number>} LZ77 符号化 byte array.\n */\nZlib.RawDeflate.Lz77Match.prototype.toLz77Array = function() {\n  /** @type {number} */\n  var length = this.length;\n  /** @type {number} */\n  var dist = this.backwardDistance;\n  /** @type {Array} */\n  var codeArray = [];\n  /** @type {number} */\n  var pos = 0;\n  /** @type {!Array.<number>} */\n  var code;\n\n  // length\n  code = Zlib.RawDeflate.Lz77Match.LengthCodeTable[length];\n  codeArray[pos++] = code & 0xffff;\n  codeArray[pos++] = (code >> 16) & 0xff;\n  codeArray[pos++] = code >> 24;\n\n  // distance\n  code = this.getDistanceCode_(dist);\n  codeArray[pos++] = code[0];\n  codeArray[pos++] = code[1];\n  codeArray[pos++] = code[2];\n\n  return codeArray;\n};\n\n/**\n * LZ77 実装\n * @param {!(Array.<number>|Uint8Array)} dataArray LZ77 符号化するバイト配列.\n * @return {!(Array.<number>|Uint16Array)} LZ77 符号化した配列.\n */\nZlib.RawDeflate.prototype.lz77 = function(dataArray) {\n  /** @type {number} input position */\n  var position;\n  /** @type {number} input length */\n  var length;\n  /** @type {number} loop counter */\n  var i;\n  /** @type {number} loop limiter */\n  var il;\n  /** @type {number} chained-hash-table key */\n  var matchKey;\n  /** @type {Object.<number, Array.<number>>} chained-hash-table */\n  var table = {};\n  /** @const @type {number} */\n  var windowSize = Zlib.RawDeflate.WindowSize;\n  /** @type {Array.<number>} match list */\n  var matchList;\n  /** @type {Zlib.RawDeflate.Lz77Match} longest match */\n  var longestMatch;\n  /** @type {Zlib.RawDeflate.Lz77Match} previous longest match */\n  var prevMatch;\n  /** @type {!(Array.<number>|Uint16Array)} lz77 buffer */\n  var lz77buf = USE_TYPEDARRAY ?\n    new Uint16Array(dataArray.length * 2) : [];\n  /** @type {number} lz77 output buffer pointer */\n  var pos = 0;\n  /** @type {number} lz77 skip length */\n  var skipLength = 0;\n  /** @type {!(Array.<number>|Uint32Array)} */\n  var freqsLitLen = new (USE_TYPEDARRAY ? Uint32Array : Array)(286);\n  /** @type {!(Array.<number>|Uint32Array)} */\n  var freqsDist = new (USE_TYPEDARRAY ? Uint32Array : Array)(30);\n  /** @type {number} */\n  var lazy = this.lazy;\n  /** @type {*} temporary variable */\n  var tmp;\n\n  // 初期化\n  if (!USE_TYPEDARRAY) {\n    for (i = 0; i <= 285;) { freqsLitLen[i++] = 0; }\n    for (i = 0; i <= 29;) { freqsDist[i++] = 0; }\n  }\n  freqsLitLen[256] = 1; // EOB の最低出現回数は 1\n\n  /**\n   * マッチデータの書き込み\n   * @param {Zlib.RawDeflate.Lz77Match} match LZ77 Match data.\n   * @param {!number} offset スキップ開始位置(相対指定).\n   * @private\n   */\n  function writeMatch(match, offset) {\n    /** @type {Array.<number>} */\n    var lz77Array = match.toLz77Array();\n    /** @type {number} */\n    var i;\n    /** @type {number} */\n    var il;\n\n    for (i = 0, il = lz77Array.length; i < il; ++i) {\n      lz77buf[pos++] = lz77Array[i];\n    }\n    freqsLitLen[lz77Array[0]]++;\n    freqsDist[lz77Array[3]]++;\n    skipLength = match.length + offset - 1;\n    prevMatch = null;\n  }\n\n  // LZ77 符号化\n  for (position = 0, length = dataArray.length; position < length; ++position) {\n    // ハッシュキーの作成\n    for (matchKey = 0, i = 0, il = Zlib.RawDeflate.Lz77MinLength; i < il; ++i) {\n      if (position + i === length) {\n        break;\n      }\n      matchKey = (matchKey << 8) | dataArray[position + i];\n    }\n\n    // テーブルが未定義だったら作成する\n    if (table[matchKey] === void 0) { table[matchKey] = []; }\n    matchList = table[matchKey];\n\n    // skip\n    if (skipLength-- > 0) {\n      matchList.push(position);\n      continue;\n    }\n\n    // マッチテーブルの更新 (最大戻り距離を超えているものを削除する)\n    while (matchList.length > 0 && position - matchList[0] > windowSize) {\n      matchList.shift();\n    }\n\n    // データ末尾でマッチしようがない場合はそのまま流しこむ\n    if (position + Zlib.RawDeflate.Lz77MinLength >= length) {\n      if (prevMatch) {\n        writeMatch(prevMatch, -1);\n      }\n\n      for (i = 0, il = length - position; i < il; ++i) {\n        tmp = dataArray[position + i];\n        lz77buf[pos++] = tmp;\n        ++freqsLitLen[tmp];\n      }\n      break;\n    }\n\n    // マッチ候補から最長のものを探す\n    if (matchList.length > 0) {\n      longestMatch = this.searchLongestMatch_(dataArray, position, matchList);\n\n      if (prevMatch) {\n        // 現在のマッチの方が前回のマッチよりも長い\n        if (prevMatch.length < longestMatch.length) {\n          // write previous literal\n          tmp = dataArray[position - 1];\n          lz77buf[pos++] = tmp;\n          ++freqsLitLen[tmp];\n\n          // write current match\n          writeMatch(longestMatch, 0);\n        } else {\n          // write previous match\n          writeMatch(prevMatch, -1);\n        }\n      } else if (longestMatch.length < lazy) {\n        prevMatch = longestMatch;\n      } else {\n        writeMatch(longestMatch, 0);\n      }\n    // 前回マッチしていて今回マッチがなかったら前回のを採用\n    } else if (prevMatch) {\n      writeMatch(prevMatch, -1);\n    } else {\n      tmp = dataArray[position];\n      lz77buf[pos++] = tmp;\n      ++freqsLitLen[tmp];\n    }\n\n    matchList.push(position); // マッチテーブルに現在の位置を保存\n  }\n\n  // 終端処理\n  lz77buf[pos++] = 256;\n  freqsLitLen[256]++;\n  this.freqsLitLen = freqsLitLen;\n  this.freqsDist = freqsDist;\n\n  return /** @type {!(Uint16Array|Array.<number>)} */ (\n    USE_TYPEDARRAY ?  lz77buf.subarray(0, pos) : lz77buf\n  );\n};\n\n/**\n * マッチした候補の中から最長一致を探す\n * @param {!Object} data plain data byte array.\n * @param {!number} position plain data byte array position.\n * @param {!Array.<number>} matchList 候補となる位置の配列.\n * @return {!Zlib.RawDeflate.Lz77Match} 最長かつ最短距離のマッチオブジェクト.\n * @private\n */\nZlib.RawDeflate.prototype.searchLongestMatch_ =\nfunction(data, position, matchList) {\n  var match,\n      currentMatch,\n      matchMax = 0, matchLength,\n      i, j, l, dl = data.length;\n\n  // 候補を後ろから 1 つずつ絞り込んでゆく\n  permatch:\n  for (i = 0, l = matchList.length; i < l; i++) {\n    match = matchList[l - i - 1];\n    matchLength = Zlib.RawDeflate.Lz77MinLength;\n\n    // 前回までの最長一致を末尾から一致検索する\n    if (matchMax > Zlib.RawDeflate.Lz77MinLength) {\n      for (j = matchMax; j > Zlib.RawDeflate.Lz77MinLength; j--) {\n        if (data[match + j - 1] !== data[position + j - 1]) {\n          continue permatch;\n        }\n      }\n      matchLength = matchMax;\n    }\n\n    // 最長一致探索\n    while (matchLength < Zlib.RawDeflate.Lz77MaxLength &&\n           position + matchLength < dl &&\n           data[match + matchLength] === data[position + matchLength]) {\n      ++matchLength;\n    }\n\n    // マッチ長が同じ場合は後方を優先\n    if (matchLength > matchMax) {\n      currentMatch = match;\n      matchMax = matchLength;\n    }\n\n    // 最長が確定したら後の処理は省略\n    if (matchLength === Zlib.RawDeflate.Lz77MaxLength) {\n      break;\n    }\n  }\n\n  return new Zlib.RawDeflate.Lz77Match(matchMax, position - currentMatch);\n};\n\n/**\n * Tree-Transmit Symbols の算出\n * reference: PuTTY Deflate implementation\n * @param {number} hlit HLIT.\n * @param {!(Array.<number>|Uint8Array)} litlenLengths リテラルと長さ符号の符号長配列.\n * @param {number} hdist HDIST.\n * @param {!(Array.<number>|Uint8Array)} distLengths 距離符号の符号長配列.\n * @return {{\n *   codes: !(Array.<number>|Uint32Array),\n *   freqs: !(Array.<number>|Uint32Array)\n * }} Tree-Transmit Symbols.\n */\nZlib.RawDeflate.prototype.getTreeSymbols_ =\nfunction(hlit, litlenLengths, hdist, distLengths) {\n  var src = new (USE_TYPEDARRAY ? Uint32Array : Array)(hlit + hdist),\n      i, j, runLength, l,\n      result = new (USE_TYPEDARRAY ? Uint32Array : Array)(286 + 30),\n      nResult,\n      rpt,\n      freqs = new (USE_TYPEDARRAY ? Uint8Array : Array)(19);\n\n  j = 0;\n  for (i = 0; i < hlit; i++) {\n    src[j++] = litlenLengths[i];\n  }\n  for (i = 0; i < hdist; i++) {\n    src[j++] = distLengths[i];\n  }\n\n  // 初期化\n  if (!USE_TYPEDARRAY) {\n    for (i = 0, l = freqs.length; i < l; ++i) {\n      freqs[i] = 0;\n    }\n  }\n\n  // 符号化\n  nResult = 0;\n  for (i = 0, l = src.length; i < l; i += j) {\n    // Run Length Encoding\n    for (j = 1; i + j < l && src[i + j] === src[i]; ++j) {}\n\n    runLength = j;\n\n    if (src[i] === 0) {\n      // 0 の繰り返しが 3 回未満ならばそのまま\n      if (runLength < 3) {\n        while (runLength-- > 0) {\n          result[nResult++] = 0;\n          freqs[0]++;\n        }\n      } else {\n        while (runLength > 0) {\n          // 繰り返しは最大 138 までなので切り詰める\n          rpt = (runLength < 138 ? runLength : 138);\n\n          if (rpt > runLength - 3 && rpt < runLength) {\n            rpt = runLength - 3;\n          }\n\n          // 3-10 回 -> 17\n          if (rpt <= 10) {\n            result[nResult++] = 17;\n            result[nResult++] = rpt - 3;\n            freqs[17]++;\n          // 11-138 回 -> 18\n          } else {\n            result[nResult++] = 18;\n            result[nResult++] = rpt - 11;\n            freqs[18]++;\n          }\n\n          runLength -= rpt;\n        }\n      }\n    } else {\n      result[nResult++] = src[i];\n      freqs[src[i]]++;\n      runLength--;\n\n      // 繰り返し回数が3回未満ならばランレングス符号は要らない\n      if (runLength < 3) {\n        while (runLength-- > 0) {\n          result[nResult++] = src[i];\n          freqs[src[i]]++;\n        }\n      // 3 回以上ならばランレングス符号化\n      } else {\n        while (runLength > 0) {\n          // runLengthを 3-6 で分割\n          rpt = (runLength < 6 ? runLength : 6);\n\n          if (rpt > runLength - 3 && rpt < runLength) {\n            rpt = runLength - 3;\n          }\n\n          result[nResult++] = 16;\n          result[nResult++] = rpt - 3;\n          freqs[16]++;\n\n          runLength -= rpt;\n        }\n      }\n    }\n  }\n\n  return {\n    codes:\n      USE_TYPEDARRAY ? result.subarray(0, nResult) : result.slice(0, nResult),\n    freqs: freqs\n  };\n};\n\n/**\n * ハフマン符号の長さを取得する\n * @param {!(Array.<number>|Uint32Array)} freqs 出現カウント.\n * @param {number} limit 符号長の制限.\n * @return {!(Array.<number>|Uint8Array)} 符号長配列.\n * @private\n */\nZlib.RawDeflate.prototype.getLengths_ = function(freqs, limit) {\n  /** @type {number} */\n  var nSymbols = freqs.length;\n  /** @type {Zlib.Heap} */\n  var heap = new Zlib.Heap(2 * Zlib.RawDeflate.HUFMAX);\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var length = new (USE_TYPEDARRAY ? Uint8Array : Array)(nSymbols);\n  /** @type {Array} */\n  var nodes;\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var values;\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var codeLength;\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var il;\n\n  // 配列の初期化\n  if (!USE_TYPEDARRAY) {\n    for (i = 0; i < nSymbols; i++) {\n      length[i] = 0;\n    }\n  }\n\n  // ヒープの構築\n  for (i = 0; i < nSymbols; ++i) {\n    if (freqs[i] > 0) {\n      heap.push(i, freqs[i]);\n    }\n  }\n  nodes = new Array(heap.length / 2);\n  values = new (USE_TYPEDARRAY ? Uint32Array : Array)(heap.length / 2);\n\n  // 非 0 の要素が一つだけだった場合は、そのシンボルに符号長 1 を割り当てて終了\n  if (nodes.length === 1) {\n    length[heap.pop().index] = 1;\n    return length;\n  }\n\n  // Reverse Package Merge Algorithm による Canonical Huffman Code の符号長決定\n  for (i = 0, il = heap.length / 2; i < il; ++i) {\n    nodes[i] = heap.pop();\n    values[i] = nodes[i].value;\n  }\n  codeLength = this.reversePackageMerge_(values, values.length, limit);\n\n  for (i = 0, il = nodes.length; i < il; ++i) {\n    length[nodes[i].index] = codeLength[i];\n  }\n\n  return length;\n};\n\n/**\n * Reverse Package Merge Algorithm.\n * @param {!(Array.<number>|Uint32Array)} freqs sorted probability.\n * @param {number} symbols number of symbols.\n * @param {number} limit code length limit.\n * @return {!(Array.<number>|Uint8Array)} code lengths.\n */\nZlib.RawDeflate.prototype.reversePackageMerge_ = function(freqs, symbols, limit) {\n  /** @type {!(Array.<number>|Uint16Array)} */\n  var minimumCost = new (USE_TYPEDARRAY ? Uint16Array : Array)(limit);\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var flag = new (USE_TYPEDARRAY ? Uint8Array : Array)(limit);\n  /** @type {!(Array.<number>|Uint8Array)} */\n  var codeLength = new (USE_TYPEDARRAY ? Uint8Array : Array)(symbols);\n  /** @type {Array} */\n  var value = new Array(limit);\n  /** @type {Array} */\n  var type  = new Array(limit);\n  /** @type {Array.<number>} */\n  var currentPosition = new Array(limit);\n  /** @type {number} */\n  var excess = (1 << limit) - symbols;\n  /** @type {number} */\n  var half = (1 << (limit - 1));\n  /** @type {number} */\n  var i;\n  /** @type {number} */\n  var j;\n  /** @type {number} */\n  var t;\n  /** @type {number} */\n  var weight;\n  /** @type {number} */\n  var next;\n\n  /**\n   * @param {number} j\n   */\n  function takePackage(j) {\n    /** @type {number} */\n    var x = type[j][currentPosition[j]];\n\n    if (x === symbols) {\n      takePackage(j+1);\n      takePackage(j+1);\n    } else {\n      --codeLength[x];\n    }\n\n    ++currentPosition[j];\n  }\n\n  minimumCost[limit-1] = symbols;\n\n  for (j = 0; j < limit; ++j) {\n    if (excess < half) {\n      flag[j] = 0;\n    } else {\n      flag[j] = 1;\n      excess -= half;\n    }\n    excess <<= 1;\n    minimumCost[limit-2-j] = (minimumCost[limit-1-j] / 2 | 0) + symbols;\n  }\n  minimumCost[0] = flag[0];\n\n  value[0] = new Array(minimumCost[0]);\n  type[0]  = new Array(minimumCost[0]);\n  for (j = 1; j < limit; ++j) {\n    if (minimumCost[j] > 2 * minimumCost[j-1] + flag[j]) {\n      minimumCost[j] = 2 * minimumCost[j-1] + flag[j];\n    }\n    value[j] = new Array(minimumCost[j]);\n    type[j]  = new Array(minimumCost[j]);\n  }\n\n  for (i = 0; i < symbols; ++i) {\n    codeLength[i] = limit;\n  }\n\n  for (t = 0; t < minimumCost[limit-1]; ++t) {\n    value[limit-1][t] = freqs[t];\n    type[limit-1][t]  = t;\n  }\n\n  for (i = 0; i < limit; ++i) {\n    currentPosition[i] = 0;\n  }\n  if (flag[limit-1] === 1) {\n    --codeLength[0];\n    ++currentPosition[limit-1];\n  }\n\n  for (j = limit-2; j >= 0; --j) {\n    i = 0;\n    weight = 0;\n    next = currentPosition[j+1];\n\n    for (t = 0; t < minimumCost[j]; t++) {\n      weight = value[j+1][next] + value[j+1][next+1];\n\n      if (weight > freqs[i]) {\n        value[j][t] = weight;\n        type[j][t] = symbols;\n        next += 2;\n      } else {\n        value[j][t] = freqs[i];\n        type[j][t] = i;\n        ++i;\n      }\n    }\n\n    currentPosition[j] = 0;\n    if (flag[j] === 1) {\n      takePackage(j);\n    }\n  }\n\n  return codeLength;\n};\n\n/**\n * 符号長配列からハフマン符号を取得する\n * reference: PuTTY Deflate implementation\n * @param {!(Array.<number>|Uint8Array)} lengths 符号長配列.\n * @return {!(Array.<number>|Uint16Array)} ハフマン符号配列.\n * @private\n */\nZlib.RawDeflate.prototype.getCodesFromLengths_ = function(lengths) {\n  var codes = new (USE_TYPEDARRAY ? Uint16Array : Array)(lengths.length),\n      count = [],\n      startCode = [],\n      code = 0, i, il, j, m;\n\n  // Count the codes of each length.\n  for (i = 0, il = lengths.length; i < il; i++) {\n    count[lengths[i]] = (count[lengths[i]] | 0) + 1;\n  }\n\n  // Determine the starting code for each length block.\n  for (i = 1, il = Zlib.RawDeflate.MaxCodeLength; i <= il; i++) {\n    startCode[i] = code;\n    code += count[i] | 0;\n    code <<= 1;\n  }\n\n  // Determine the code for each symbol. Mirrored, of course.\n  for (i = 0, il = lengths.length; i < il; i++) {\n    code = startCode[lengths[i]];\n    startCode[lengths[i]] += 1;\n    codes[i] = 0;\n\n    for (j = 0, m = lengths[i]; j < m; j++) {\n      codes[i] = (codes[i] << 1) | (code & 1);\n      code >>>= 1;\n    }\n  }\n\n  return codes;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.RawInflate');\n\ngoog.require('USE_TYPEDARRAY');\ngoog.require('Zlib.Huffman');\n\n//-----------------------------------------------------------------------------\n\n/** @define {number} buffer block size. */\nvar ZLIB_RAW_INFLATE_BUFFER_SIZE = 0x8000; // [ 0x8000 >= ZLIB_BUFFER_BLOCK_SIZE ]\n\n//-----------------------------------------------------------------------------\n\ngoog.scope(function() {\n\nvar buildHuffmanTable = Zlib.Huffman.buildHuffmanTable;\n\n/**\n * @constructor\n * @param {!(Uint8Array|Array.<number>)} input input buffer.\n * @param {Object} opt_params option parameter.\n *\n * opt_params は以下のプロパティを指定する事ができます。\n *   - index: input buffer の deflate コンテナの開始位置.\n *   - blockSize: バッファのブロックサイズ.\n *   - bufferType: Zlib.RawInflate.BufferType の値によってバッファの管理方法を指定する.\n *   - resize: 確保したバッファが実際の大きさより大きかった場合に切り詰める.\n */\nZlib.RawInflate = function(input, opt_params) {\n  /** @type {!(Array.<number>|Uint8Array)} inflated buffer */\n  this.buffer;\n  /** @type {!Array.<(Array.<number>|Uint8Array)>} */\n  this.blocks = [];\n  /** @type {number} block size. */\n  this.bufferSize = ZLIB_RAW_INFLATE_BUFFER_SIZE;\n  /** @type {!number} total output buffer pointer. */\n  this.totalpos = 0;\n  /** @type {!number} input buffer pointer. */\n  this.ip = 0;\n  /** @type {!number} bit stream reader buffer. */\n  this.bitsbuf = 0;\n  /** @type {!number} bit stream reader buffer size. */\n  this.bitsbuflen = 0;\n  /** @type {!(Array.<number>|Uint8Array)} input buffer. */\n  this.input = USE_TYPEDARRAY ? new Uint8Array(input) : input;\n  /** @type {!(Uint8Array|Array.<number>)} output buffer. */\n  this.output;\n  /** @type {!number} output buffer pointer. */\n  this.op;\n  /** @type {boolean} is final block flag. */\n  this.bfinal = false;\n  /** @type {Zlib.RawInflate.BufferType} buffer management. */\n  this.bufferType = Zlib.RawInflate.BufferType.ADAPTIVE;\n  /** @type {boolean} resize flag for memory size optimization. */\n  this.resize = false;\n  /** @type {number} previous RLE value */\n  this.prev;\n\n  // option parameters\n  if (opt_params || !(opt_params = {})) {\n    if (opt_params['index']) {\n      this.ip = opt_params['index'];\n    }\n    if (opt_params['bufferSize']) {\n      this.bufferSize = opt_params['bufferSize'];\n    }\n    if (opt_params['bufferType']) {\n      this.bufferType = opt_params['bufferType'];\n    }\n    if (opt_params['resize']) {\n      this.resize = opt_params['resize'];\n    }\n  }\n\n  // initialize\n  switch (this.bufferType) {\n    case Zlib.RawInflate.BufferType.BLOCK:\n      this.op = Zlib.RawInflate.MaxBackwardLength;\n      this.output =\n        new (USE_TYPEDARRAY ? Uint8Array : Array)(\n          Zlib.RawInflate.MaxBackwardLength +\n          this.bufferSize +\n          Zlib.RawInflate.MaxCopyLength\n        );\n      break;\n    case Zlib.RawInflate.BufferType.ADAPTIVE:\n      this.op = 0;\n      this.output = new (USE_TYPEDARRAY ? Uint8Array : Array)(this.bufferSize);\n      this.expandBuffer = this.expandBufferAdaptive;\n      this.concatBuffer = this.concatBufferDynamic;\n      this.decodeHuffman = this.decodeHuffmanAdaptive;\n      break;\n    default:\n      throw new Error('invalid inflate mode');\n  }\n};\n\n/**\n * @enum {number}\n */\nZlib.RawInflate.BufferType = {\n  BLOCK: 0,\n  ADAPTIVE: 1\n};\n\n/**\n * decompress.\n * @return {!(Uint8Array|Array.<number>)} inflated buffer.\n */\nZlib.RawInflate.prototype.decompress = function() {\n  while (!this.bfinal) {\n    this.parseBlock();\n  }\n\n  return this.concatBuffer();\n};\n\n/**\n * @const\n * @type {number} max backward length for LZ77.\n */\nZlib.RawInflate.MaxBackwardLength = 32768;\n\n/**\n * @const\n * @type {number} max copy length for LZ77.\n */\nZlib.RawInflate.MaxCopyLength = 258;\n\n/**\n * huffman order\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.Order = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n\n/**\n * huffman length code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflate.LengthCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b,\n  0x000d, 0x000f, 0x0011, 0x0013, 0x0017, 0x001b, 0x001f, 0x0023, 0x002b,\n  0x0033, 0x003b, 0x0043, 0x0053, 0x0063, 0x0073, 0x0083, 0x00a3, 0x00c3,\n  0x00e3, 0x0102, 0x0102, 0x0102\n]);\n\n/**\n * huffman length extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.LengthExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  5, 5, 0, 0, 0\n]);\n\n/**\n * huffman dist code table.\n * @const\n * @type {!(Array.<number>|Uint16Array)}\n */\nZlib.RawInflate.DistCodeTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint16Array(table) : table;\n})([\n  0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0007, 0x0009, 0x000d, 0x0011,\n  0x0019, 0x0021, 0x0031, 0x0041, 0x0061, 0x0081, 0x00c1, 0x0101, 0x0181,\n  0x0201, 0x0301, 0x0401, 0x0601, 0x0801, 0x0c01, 0x1001, 0x1801, 0x2001,\n  0x3001, 0x4001, 0x6001\n]);\n\n/**\n * huffman dist extra-bits table.\n * @const\n * @type {!(Array.<number>|Uint8Array)}\n */\nZlib.RawInflate.DistExtraTable = (function(table) {\n  return USE_TYPEDARRAY ? new Uint8Array(table) : table;\n})([\n  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,\n  11, 12, 12, 13, 13\n]);\n\n/**\n * fixed huffman length code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflate.FixedLiteralLengthTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(288);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] =\n      (i <= 143) ? 8 :\n      (i <= 255) ? 9 :\n      (i <= 279) ? 7 :\n      8;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * fixed huffman distance code table\n * @const\n * @type {!Array}\n */\nZlib.RawInflate.FixedDistanceTable = (function(table) {\n  return table;\n})((function() {\n  var lengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(30);\n  var i, il;\n\n  for (i = 0, il = lengths.length; i < il; ++i) {\n    lengths[i] = 5;\n  }\n\n  return buildHuffmanTable(lengths);\n})());\n\n/**\n * parse deflated block.\n */\nZlib.RawInflate.prototype.parseBlock = function() {\n  /** @type {number} header */\n  var hdr = this.readBits(3);\n\n  // BFINAL\n  if (hdr & 0x1) {\n    this.bfinal = true;\n  }\n\n  // BTYPE\n  hdr >>>= 1;\n  switch (hdr) {\n    // uncompressed\n    case 0:\n      this.parseUncompressedBlock();\n      break;\n    // fixed huffman\n    case 1:\n      this.parseFixedHuffmanBlock();\n      break;\n    // dynamic huffman\n    case 2:\n      this.parseDynamicHuffmanBlock();\n      break;\n    // reserved or other\n    default:\n      throw new Error('unknown BTYPE: ' + hdr);\n  }\n};\n\n/**\n * read inflate bits\n * @param {number} length bits length.\n * @return {number} read bits.\n */\nZlib.RawInflate.prototype.readBits = function(length) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {number} input and output byte. */\n  var octet;\n\n  // not enough buffer\n  while (bitsbuflen < length) {\n    // input byte\n    if (ip >= inputLength) {\n      throw new Error('input buffer is broken');\n    }\n\n    // concat octet\n    bitsbuf |= input[ip++] << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // output byte\n  octet = bitsbuf & /* MASK */ ((1 << length) - 1);\n  bitsbuf >>>= length;\n  bitsbuflen -= length;\n\n  this.bitsbuf = bitsbuf;\n  this.bitsbuflen = bitsbuflen;\n  this.ip = ip;\n\n  return octet;\n};\n\n/**\n * read huffman code using table\n * @param {Array} table huffman code table.\n * @return {number} huffman code.\n */\nZlib.RawInflate.prototype.readCodeByTable = function(table) {\n  var bitsbuf = this.bitsbuf;\n  var bitsbuflen = this.bitsbuflen;\n  var input = this.input;\n  var ip = this.ip;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {!(Array.<number>|Uint8Array)} huffman code table */\n  var codeTable = table[0];\n  /** @type {number} */\n  var maxCodeLength = table[1];\n  /** @type {number} code length & code (16bit, 16bit) */\n  var codeWithLength;\n  /** @type {number} code bits length */\n  var codeLength;\n\n  // not enough buffer\n  while (bitsbuflen < maxCodeLength) {\n    if (ip >= inputLength) {\n      break;\n    }\n    bitsbuf |= input[ip++] << bitsbuflen;\n    bitsbuflen += 8;\n  }\n\n  // read max length\n  codeWithLength = codeTable[bitsbuf & ((1 << maxCodeLength) - 1)];\n  codeLength = codeWithLength >>> 16;\n\n  this.bitsbuf = bitsbuf >> codeLength;\n  this.bitsbuflen = bitsbuflen - codeLength;\n  this.ip = ip;\n\n  return codeWithLength & 0xffff;\n};\n\n/**\n * parse uncompressed block.\n */\nZlib.RawInflate.prototype.parseUncompressedBlock = function() {\n  var input = this.input;\n  var ip = this.ip;\n  var output = this.output;\n  var op = this.op;\n\n  /** @type {number} */\n  var inputLength = input.length;\n  /** @type {number} block length */\n  var len;\n  /** @type {number} number for check block length */\n  var nlen;\n  /** @type {number} output buffer length */\n  var olength = output.length;\n  /** @type {number} copy counter */\n  var preCopy;\n\n  // skip buffered header bits\n  this.bitsbuf = 0;\n  this.bitsbuflen = 0;\n\n  // len\n  if (ip + 1 >= inputLength) {\n    throw new Error('invalid uncompressed block header: LEN');\n  }\n  len = input[ip++] | (input[ip++] << 8);\n\n  // nlen\n  if (ip + 1 >= inputLength) {\n    throw new Error('invalid uncompressed block header: NLEN');\n  }\n  nlen = input[ip++] | (input[ip++] << 8);\n\n  // check len & nlen\n  if (len === ~nlen) {\n    throw new Error('invalid uncompressed block header: length verify');\n  }\n\n  // check size\n  if (ip + len > input.length) { throw new Error('input buffer is broken'); }\n\n  // expand buffer\n  switch (this.bufferType) {\n    case Zlib.RawInflate.BufferType.BLOCK:\n      // pre copy\n      while (op + len > output.length) {\n        preCopy = olength - op;\n        len -= preCopy;\n        if (USE_TYPEDARRAY) {\n          output.set(input.subarray(ip, ip + preCopy), op);\n          op += preCopy;\n          ip += preCopy;\n        } else {\n          while (preCopy--) {\n            output[op++] = input[ip++];\n          }\n        }\n        this.op = op;\n        output = this.expandBuffer();\n        op = this.op;\n      }\n      break;\n    case Zlib.RawInflate.BufferType.ADAPTIVE:\n      while (op + len > output.length) {\n        output = this.expandBuffer({fixRatio: 2});\n      }\n      break;\n    default:\n      throw new Error('invalid inflate mode');\n  }\n\n  // copy\n  if (USE_TYPEDARRAY) {\n    output.set(input.subarray(ip, ip + len), op);\n    op += len;\n    ip += len;\n  } else {\n    while (len--) {\n      output[op++] = input[ip++];\n    }\n  }\n\n  this.ip = ip;\n  this.op = op;\n  this.output = output;\n};\n\n/**\n * parse fixed huffman block.\n */\nZlib.RawInflate.prototype.parseFixedHuffmanBlock = function() {\n  this.decodeHuffman(\n    Zlib.RawInflate.FixedLiteralLengthTable,\n    Zlib.RawInflate.FixedDistanceTable\n  );\n};\n\n/**\n * parse dynamic huffman block.\n */\nZlib.RawInflate.prototype.parseDynamicHuffmanBlock = function() {\n  /** @type {number} number of literal and length codes. */\n  var hlit = this.readBits(5) + 257;\n  /** @type {number} number of distance codes. */\n  var hdist = this.readBits(5) + 1;\n  /** @type {number} number of code lengths. */\n  var hclen = this.readBits(4) + 4;\n  /** @type {!(Uint8Array|Array.<number>)} code lengths. */\n  var codeLengths =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(Zlib.RawInflate.Order.length);\n  /** @type {!Array} code lengths table. */\n  var codeLengthsTable;\n  /** @type {!(Uint8Array|Array.<number>)} literal and length code lengths. */\n  var litlenLengths;\n  /** @type {!(Uint8Array|Array.<number>)} distance code lengths. */\n  var distLengths;\n  /** @type {number} loop counter. */\n  var i;\n\n  // decode code lengths\n  for (i = 0; i < hclen; ++i) {\n    codeLengths[Zlib.RawInflate.Order[i]] = this.readBits(3);\n  }\n  if (!USE_TYPEDARRAY) {\n    for (i = hclen, hclen = codeLengths.length; i < hclen; ++i) {\n      codeLengths[Zlib.RawInflate.Order[i]] = 0;\n    }\n  }\n  codeLengthsTable = buildHuffmanTable(codeLengths);\n\n  /**\n   * decode function\n   * @param {number} num number of lengths.\n   * @param {!Array} table code lengths table.\n   * @param {!(Uint8Array|Array.<number>)} lengths code lengths buffer.\n   * @return {!(Uint8Array|Array.<number>)} code lengths buffer.\n   */\n  function decode(num, table, lengths) {\n    /** @type {number} */\n    var code;\n    /** @type {number} */\n    var prev = this.prev;\n    /** @type {number} */\n    var repeat;\n    /** @type {number} */\n    var i;\n\n    for (i = 0; i < num;) {\n      code = this.readCodeByTable(table);\n      switch (code) {\n        case 16:\n          repeat = 3 + this.readBits(2);\n          while (repeat--) { lengths[i++] = prev; }\n          break;\n        case 17:\n          repeat = 3 + this.readBits(3);\n          while (repeat--) { lengths[i++] = 0; }\n          prev = 0;\n          break;\n        case 18:\n          repeat = 11 + this.readBits(7);\n          while (repeat--) { lengths[i++] = 0; }\n          prev = 0;\n          break;\n        default:\n          lengths[i++] = code;\n          prev = code;\n          break;\n      }\n    }\n\n    this.prev = prev;\n\n    return lengths;\n  }\n\n  // literal and length code\n  litlenLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hlit);\n\n  // distance code\n  distLengths = new (USE_TYPEDARRAY ? Uint8Array : Array)(hdist);\n\n  this.prev = 0;\n  this.decodeHuffman(\n    buildHuffmanTable(decode.call(this, hlit, codeLengthsTable, litlenLengths)),\n    buildHuffmanTable(decode.call(this, hdist, codeLengthsTable, distLengths))\n  );\n};\n\n/**\n * decode huffman code\n * @param {!Array} litlen literal and length code table.\n * @param {!Array} dist distination code table.\n */\nZlib.RawInflate.prototype.decodeHuffman = function(litlen, dist) {\n  var output = this.output;\n  var op = this.op;\n\n  this.currentLitlenTable = litlen;\n\n  /** @type {number} output position limit. */\n  var olength = output.length - Zlib.RawInflate.MaxCopyLength;\n  /** @type {number} huffman code. */\n  var code;\n  /** @type {number} table index. */\n  var ti;\n  /** @type {number} huffman code distination. */\n  var codeDist;\n  /** @type {number} huffman code length. */\n  var codeLength;\n\n  while ((code = this.readCodeByTable(litlen)) !== 256) {\n    // literal\n    if (code < 256) {\n      if (op >= olength) {\n        this.op = op;\n        output = this.expandBuffer();\n        op = this.op;\n      }\n      output[op++] = code;\n\n      continue;\n    }\n\n    // length code\n    ti = code - 257;\n    codeLength = Zlib.RawInflate.LengthCodeTable[ti];\n    if (Zlib.RawInflate.LengthExtraTable[ti] > 0) {\n      codeLength += this.readBits(Zlib.RawInflate.LengthExtraTable[ti]);\n    }\n\n    // dist code\n    code = this.readCodeByTable(dist);\n    codeDist = Zlib.RawInflate.DistCodeTable[code];\n    if (Zlib.RawInflate.DistExtraTable[code] > 0) {\n      codeDist += this.readBits(Zlib.RawInflate.DistExtraTable[code]);\n    }\n\n    // lz77 decode\n    if (op >= olength) {\n      this.op = op;\n      output = this.expandBuffer();\n      op = this.op;\n    }\n    while (codeLength--) {\n      output[op] = output[(op++) - codeDist];\n    }\n  }\n\n  while (this.bitsbuflen >= 8) {\n    this.bitsbuflen -= 8;\n    this.ip--;\n  }\n  this.op = op;\n};\n\n/**\n * decode huffman code (adaptive)\n * @param {!Array} litlen literal and length code table.\n * @param {!Array} dist distination code table.\n */\nZlib.RawInflate.prototype.decodeHuffmanAdaptive = function(litlen, dist) {\n  var output = this.output;\n  var op = this.op;\n\n  this.currentLitlenTable = litlen;\n\n  /** @type {number} output position limit. */\n  var olength = output.length;\n  /** @type {number} huffman code. */\n  var code;\n  /** @type {number} table index. */\n  var ti;\n  /** @type {number} huffman code distination. */\n  var codeDist;\n  /** @type {number} huffman code length. */\n  var codeLength;\n\n  while ((code = this.readCodeByTable(litlen)) !== 256) {\n    // literal\n    if (code < 256) {\n      if (op >= olength) {\n        output = this.expandBuffer();\n        olength = output.length;\n      }\n      output[op++] = code;\n\n      continue;\n    }\n\n    // length code\n    ti = code - 257;\n    codeLength = Zlib.RawInflate.LengthCodeTable[ti];\n    if (Zlib.RawInflate.LengthExtraTable[ti] > 0) {\n      codeLength += this.readBits(Zlib.RawInflate.LengthExtraTable[ti]);\n    }\n\n    // dist code\n    code = this.readCodeByTable(dist);\n    codeDist = Zlib.RawInflate.DistCodeTable[code];\n    if (Zlib.RawInflate.DistExtraTable[code] > 0) {\n      codeDist += this.readBits(Zlib.RawInflate.DistExtraTable[code]);\n    }\n\n    // lz77 decode\n    if (op + codeLength > olength) {\n      output = this.expandBuffer();\n      olength = output.length;\n    }\n    while (codeLength--) {\n      output[op] = output[(op++) - codeDist];\n    }\n  }\n\n  while (this.bitsbuflen >= 8) {\n    this.bitsbuflen -= 8;\n    this.ip--;\n  }\n  this.op = op;\n};\n\n/**\n * expand output buffer.\n * @param {Object=} opt_param option parameters.\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.expandBuffer = function(opt_param) {\n  /** @type {!(Array.<number>|Uint8Array)} store buffer. */\n  var buffer =\n    new (USE_TYPEDARRAY ? Uint8Array : Array)(\n        this.op - Zlib.RawInflate.MaxBackwardLength\n    );\n  /** @type {number} backward base point */\n  var backward = this.op - Zlib.RawInflate.MaxBackwardLength;\n  /** @type {number} copy index. */\n  var i;\n  /** @type {number} copy limit */\n  var il;\n\n  var output = this.output;\n\n  // copy to output buffer\n  if (USE_TYPEDARRAY) {\n    buffer.set(output.subarray(Zlib.RawInflate.MaxBackwardLength, buffer.length));\n  } else {\n    for (i = 0, il = buffer.length; i < il; ++i) {\n      buffer[i] = output[i + Zlib.RawInflate.MaxBackwardLength];\n    }\n  }\n\n  this.blocks.push(buffer);\n  this.totalpos += buffer.length;\n\n  // copy to backward buffer\n  if (USE_TYPEDARRAY) {\n    output.set(\n      output.subarray(backward, backward + Zlib.RawInflate.MaxBackwardLength)\n    );\n  } else {\n    for (i = 0; i < Zlib.RawInflate.MaxBackwardLength; ++i) {\n      output[i] = output[backward + i];\n    }\n  }\n\n  this.op = Zlib.RawInflate.MaxBackwardLength;\n\n  return output;\n};\n\n/**\n * expand output buffer. (adaptive)\n * @param {Object=} opt_param option parameters.\n * @return {!(Array.<number>|Uint8Array)} output buffer pointer.\n */\nZlib.RawInflate.prototype.expandBufferAdaptive = function(opt_param) {\n  /** @type {!(Array.<number>|Uint8Array)} store buffer. */\n  var buffer;\n  /** @type {number} expantion ratio. */\n  var ratio = (this.input.length / this.ip + 1) | 0;\n  /** @type {number} maximum number of huffman code. */\n  var maxHuffCode;\n  /** @type {number} new output buffer size. */\n  var newSize;\n  /** @type {number} max inflate size. */\n  var maxInflateSize;\n\n  var input = this.input;\n  var output = this.output;\n\n  if (opt_param) {\n    if (typeof opt_param.fixRatio === 'number') {\n      ratio = opt_param.fixRatio;\n    }\n    if (typeof opt_param.addRatio === 'number') {\n      ratio += opt_param.addRatio;\n    }\n  }\n\n  // calculate new buffer size\n  if (ratio < 2) {\n    maxHuffCode =\n      (input.length - this.ip) / this.currentLitlenTable[2];\n    maxInflateSize = (maxHuffCode / 2 * 258) | 0;\n    newSize = maxInflateSize < output.length ?\n      output.length + maxInflateSize :\n      output.length << 1;\n  } else {\n    newSize = output.length * ratio;\n  }\n\n  // buffer expantion\n  if (USE_TYPEDARRAY) {\n    buffer = new Uint8Array(newSize);\n    buffer.set(output);\n  } else {\n    buffer = output;\n  }\n\n  this.output = buffer;\n\n  return this.output;\n};\n\n/**\n * concat output buffer.\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.concatBuffer = function() {\n  /** @type {number} buffer pointer. */\n  var pos = 0;\n  /** @type {number} buffer pointer. */\n  var limit = this.totalpos + (this.op - Zlib.RawInflate.MaxBackwardLength);\n  /** @type {!(Array.<number>|Uint8Array)} output block array. */\n  var output = this.output;\n  /** @type {!Array} blocks array. */\n  var blocks = this.blocks;\n  /** @type {!(Array.<number>|Uint8Array)} output block array. */\n  var block;\n  /** @type {!(Array.<number>|Uint8Array)} output buffer. */\n  var buffer = new (USE_TYPEDARRAY ? Uint8Array : Array)(limit);\n  /** @type {number} loop counter. */\n  var i;\n  /** @type {number} loop limiter. */\n  var il;\n  /** @type {number} loop counter. */\n  var j;\n  /** @type {number} loop limiter. */\n  var jl;\n\n  // single buffer\n  if (blocks.length === 0) {\n    return USE_TYPEDARRAY ?\n      this.output.subarray(Zlib.RawInflate.MaxBackwardLength, this.op) :\n      this.output.slice(Zlib.RawInflate.MaxBackwardLength, this.op);\n  }\n\n  // copy to buffer\n  for (i = 0, il = blocks.length; i < il; ++i) {\n    block = blocks[i];\n    for (j = 0, jl = block.length; j < jl; ++j) {\n      buffer[pos++] = block[j];\n    }\n  }\n\n  // current buffer\n  for (i = Zlib.RawInflate.MaxBackwardLength, il = this.op; i < il; ++i) {\n    buffer[pos++] = output[i];\n  }\n\n  this.blocks = [];\n  this.buffer = buffer;\n\n  return this.buffer;\n};\n\n/**\n * concat output buffer. (dynamic)\n * @return {!(Array.<number>|Uint8Array)} output buffer.\n */\nZlib.RawInflate.prototype.concatBufferDynamic = function() {\n  /** @type {Array.<number>|Uint8Array} output buffer. */\n  var buffer;\n  var op = this.op;\n\n  if (USE_TYPEDARRAY) {\n    if (this.resize) {\n      buffer = new Uint8Array(op);\n      buffer.set(this.output.subarray(0, op));\n    } else {\n      buffer = this.output.subarray(0, op);\n    }\n  } else {\n    if (this.output.length > op) {\n      this.output.length = op;\n    }\n    buffer = this.output;\n  }\n\n  this.buffer = buffer;\n\n  return this.buffer;\n};\n\n// end of scope\n});\n\n/* vim:set expandtab ts=2 sw=2 tw=80: */\n","goog.provide('Zlib.Zip');\r\n\r\ngoog.require('USE_TYPEDARRAY');\r\ngoog.require('Zlib.RawDeflate');\r\ngoog.require('Zlib.CRC32');\r\n\r\ngoog.scope(function() {\r\n\r\n/**\r\n * @param {Object=} opt_params options.\r\n * @constructor\r\n */\r\nZlib.Zip = function(opt_params) {\r\n  opt_params = opt_params || {};\r\n  /** @type {Array.<{\r\n   *   buffer: !(Array.<number>|Uint8Array),\r\n   *   option: Object,\r\n   *   compressed: boolean,\r\n   *   encrypted: boolean,\r\n   *   size: number,\r\n   *   crc32: number\r\n   * }>} */\r\n  this.files = [];\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  this.comment = opt_params['comment'];\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  this.password;\r\n};\r\n\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nZlib.Zip.CompressionMethod = {\r\n  STORE: 0,\r\n  DEFLATE: 8\r\n};\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nZlib.Zip.OperatingSystem = {\r\n  MSDOS: 0,\r\n  UNIX: 3,\r\n  MACINTOSH: 7\r\n};\r\n\r\n/**\r\n * @enum {number}\r\n */\r\nZlib.Zip.Flags = {\r\n  ENCRYPT:    0x0001,\r\n  DESCRIPTOR: 0x0008,\r\n  UTF8:       0x0800\r\n};\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Zip.FileHeaderSignature = [0x50, 0x4b, 0x01, 0x02];\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Zip.LocalFileHeaderSignature = [0x50, 0x4b, 0x03, 0x04];\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Zip.CentralDirectorySignature = [0x50, 0x4b, 0x05, 0x06];\r\n\r\n/**\r\n * @param {Array.<number>|Uint8Array} input\r\n * @param {Object=} opt_params options.\r\n */\r\nZlib.Zip.prototype.addFile = function(input, opt_params) {\r\n  opt_params = opt_params || {};\r\n  /** @type {string} */\r\n  var filename = '' || opt_params['filename'];\r\n  /** @type {boolean} */\r\n  var compressed;\r\n  /** @type {number} */\r\n  var size = input.length;\r\n  /** @type {number} */\r\n  var crc32 = 0;\r\n\r\n  if (USE_TYPEDARRAY && input instanceof Array) {\r\n    input = new Uint8Array(input);\r\n  }\r\n\r\n  // default\r\n  if (typeof opt_params['compressionMethod'] !== 'number') {\r\n    opt_params['compressionMethod'] = Zlib.Zip.CompressionMethod.DEFLATE;\r\n  }\r\n\r\n  // その場で圧縮する場合\r\n  if (opt_params['compress']) {\r\n    switch (opt_params['compressionMethod']) {\r\n      case Zlib.Zip.CompressionMethod.STORE:\r\n        break;\r\n      case Zlib.Zip.CompressionMethod.DEFLATE:\r\n        crc32 = Zlib.CRC32.calc(input);\r\n        input = this.deflateWithOption(input, opt_params);\r\n        compressed = true;\r\n        break;\r\n      default:\r\n        throw new Error('unknown compression method:' + opt_params['compressionMethod']);\r\n    }\r\n  }\r\n\r\n  this.files.push({\r\n    buffer: input,\r\n    option: opt_params,\r\n    compressed: compressed,\r\n    encrypted: false,\r\n    size: size,\r\n    crc32: crc32\r\n  });\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint8Array)} password\r\n */\r\nZlib.Zip.prototype.setPassword = function(password) {\r\n  this.password = password;\r\n};\r\n\r\nZlib.Zip.prototype.compress = function() {\r\n  /** @type {Array.<{\r\n   *   buffer: !(Array.<number>|Uint8Array),\r\n   *   option: Object,\r\n   *   compressed: boolean,\r\n   *   encrypted: boolean,\r\n   *   size: number,\r\n   *   crc32: number\r\n   * }>} */\r\n  var files = this.files;\r\n  /** @type {{\r\n   *   buffer: !(Array.<number>|Uint8Array),\r\n   *   option: Object,\r\n   *   compressed: boolean,\r\n   *   encrypted: boolean,\r\n   *   size: number,\r\n   *   crc32: number\r\n   * }} */\r\n  var file;\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var output;\r\n  /** @type {number} */\r\n  var op1;\r\n  /** @type {number} */\r\n  var op2;\r\n  /** @type {number} */\r\n  var op3;\r\n  /** @type {number} */\r\n  var localFileSize = 0;\r\n  /** @type {number} */\r\n  var centralDirectorySize = 0;\r\n  /** @type {number} */\r\n  var endOfCentralDirectorySize;\r\n  /** @type {number} */\r\n  var offset;\r\n  /** @type {number} */\r\n  var needVersion;\r\n  /** @type {number} */\r\n  var flags;\r\n  /** @type {Zlib.Zip.CompressionMethod} */\r\n  var compressionMethod;\r\n  /** @type {Date} */\r\n  var date;\r\n  /** @type {number} */\r\n  var crc32;\r\n  /** @type {number} */\r\n  var size;\r\n  /** @type {number} */\r\n  var plainSize;\r\n  /** @type {number} */\r\n  var filenameLength;\r\n  /** @type {number} */\r\n  var extraFieldLength;\r\n  /** @type {number} */\r\n  var commentLength;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  var filename;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  var extraField;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  var comment;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  var buffer;\r\n  /** @type {*} */\r\n  var tmp;\r\n  /** @type {Array.<number>|Uint32Array|Object} */\r\n  var key;\r\n  /** @type {number} */\r\n  var i;\r\n  /** @type {number} */\r\n  var il;\r\n  /** @type {number} */\r\n  var j;\r\n  /** @type {number} */\r\n  var jl;\r\n\r\n  // ファイルの圧縮\r\n  for (i = 0, il = files.length; i < il; ++i) {\r\n    file = files[i];\r\n    filenameLength =\r\n      (file.option['filename']) ? file.option['filename'].length : 0;\r\n    extraFieldLength =\r\n      (file.option['extraField']) ? file.option['extraField'].length : 0;\r\n    commentLength =\r\n      (file.option['comment']) ? file.option['comment'].length : 0;\r\n\r\n    // 圧縮されていなかったら圧縮\r\n    if (!file.compressed) {\r\n      // 圧縮前に CRC32 の計算をしておく\r\n      file.crc32 = Zlib.CRC32.calc(file.buffer);\r\n\r\n      switch (file.option['compressionMethod']) {\r\n        case Zlib.Zip.CompressionMethod.STORE:\r\n          break;\r\n        case Zlib.Zip.CompressionMethod.DEFLATE:\r\n          file.buffer = this.deflateWithOption(file.buffer, file.option);\r\n          file.compressed = true;\r\n          break;\r\n        default:\r\n          throw new Error('unknown compression method:' + file.option['compressionMethod']);\r\n      }\r\n    }\r\n\r\n    // encryption\r\n    if (file.option['password'] !== void 0|| this.password !== void 0) {\r\n      // init encryption\r\n      key = this.createEncryptionKey(file.option['password'] || this.password);\r\n\r\n      // add header\r\n      buffer = file.buffer;\r\n      if (USE_TYPEDARRAY) {\r\n        tmp = new Uint8Array(buffer.length + 12);\r\n        tmp.set(buffer, 12);\r\n        buffer = tmp;\r\n      } else {\r\n        buffer.unshift(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\r\n      }\r\n\r\n      for (j = 0; j < 12; ++j) {\r\n        buffer[j] = this.encode(\r\n          key,\r\n          i === 11 ? (file.crc32 & 0xff) : (Math.random() * 256 | 0)\r\n        );\r\n      }\r\n\r\n      // data encryption\r\n      for (jl = buffer.length; j < jl; ++j) {\r\n        buffer[j] = this.encode(key, buffer[j]);\r\n      }\r\n      file.buffer = buffer;\r\n    }\r\n\r\n    // 必要バッファサイズの計算\r\n    localFileSize +=\r\n      // local file header\r\n      30 + filenameLength +\r\n      // file data\r\n      file.buffer.length;\r\n\r\n    centralDirectorySize +=\r\n      // file header\r\n      46 + filenameLength + commentLength;\r\n  }\r\n\r\n  // end of central directory\r\n  endOfCentralDirectorySize = 46 + (this.comment ? this.comment.length : 0);\r\n  output = new (USE_TYPEDARRAY ? Uint8Array : Array)(\r\n    localFileSize + centralDirectorySize + endOfCentralDirectorySize\r\n  );\r\n  op1 = 0;\r\n  op2 = localFileSize;\r\n  op3 = op2 + centralDirectorySize;\r\n\r\n  // ファイルの圧縮\r\n  for (i = 0, il = files.length; i < il; ++i) {\r\n    file = files[i];\r\n    filenameLength =\r\n      file.option['filename'] ? file.option['filename'].length :  0;\r\n    extraFieldLength = 0; // TODO\r\n    commentLength =\r\n      file.option['comment'] ? file.option['comment'].length : 0;\r\n\r\n    //-------------------------------------------------------------------------\r\n    // local file header & file header\r\n    //-------------------------------------------------------------------------\r\n\r\n    offset = op1;\r\n\r\n    // signature\r\n    // local file header\r\n    output[op1++] = Zlib.Zip.LocalFileHeaderSignature[0];\r\n    output[op1++] = Zlib.Zip.LocalFileHeaderSignature[1];\r\n    output[op1++] = Zlib.Zip.LocalFileHeaderSignature[2];\r\n    output[op1++] = Zlib.Zip.LocalFileHeaderSignature[3];\r\n    // file header\r\n    output[op2++] = Zlib.Zip.FileHeaderSignature[0];\r\n    output[op2++] = Zlib.Zip.FileHeaderSignature[1];\r\n    output[op2++] = Zlib.Zip.FileHeaderSignature[2];\r\n    output[op2++] = Zlib.Zip.FileHeaderSignature[3];\r\n\r\n    // compressor info\r\n    needVersion = 20;\r\n    output[op2++] = needVersion & 0xff;\r\n    output[op2++] =\r\n      /** @type {Zlib.Zip.OperatingSystem} */\r\n      (file.option['os']) ||\r\n      Zlib.Zip.OperatingSystem.MSDOS;\r\n\r\n    // need version\r\n    output[op1++] = output[op2++] =  needVersion       & 0xff;\r\n    output[op1++] = output[op2++] = (needVersion >> 8) & 0xff;\r\n\r\n    // general purpose bit flag\r\n    flags = 0;\r\n    if (file.option['password'] || this.password) {\r\n      flags |= Zlib.Zip.Flags.ENCRYPT;\r\n    }\r\n    output[op1++] = output[op2++] =  flags       & 0xff;\r\n    output[op1++] = output[op2++] = (flags >> 8) & 0xff;\r\n\r\n    // compression method\r\n    compressionMethod =\r\n      /** @type {Zlib.Zip.CompressionMethod} */\r\n      (file.option['compressionMethod']);\r\n    output[op1++] = output[op2++] =  compressionMethod       & 0xff;\r\n    output[op1++] = output[op2++] = (compressionMethod >> 8) & 0xff;\r\n\r\n    // date\r\n    date = /** @type {(Date|undefined)} */(file.option['date']) || new Date();\r\n    output[op1++] = output[op2++] =\r\n      ((date.getMinutes() & 0x7) << 5) |\r\n      (date.getSeconds() / 2 | 0);\r\n    output[op1++] = output[op2++] =\r\n      (date.getHours()   << 3) |\r\n      (date.getMinutes() >> 3);\r\n    //\r\n    output[op1++] = output[op2++] =\r\n      ((date.getMonth() + 1 & 0x7) << 5) |\r\n      (date.getDate());\r\n    output[op1++] = output[op2++] =\r\n      ((date.getFullYear() - 1980 & 0x7f) << 1) |\r\n      (date.getMonth() + 1 >> 3);\r\n\r\n    // CRC-32\r\n    crc32 = file.crc32;\r\n    output[op1++] = output[op2++] =  crc32        & 0xff;\r\n    output[op1++] = output[op2++] = (crc32 >>  8) & 0xff;\r\n    output[op1++] = output[op2++] = (crc32 >> 16) & 0xff;\r\n    output[op1++] = output[op2++] = (crc32 >> 24) & 0xff;\r\n\r\n    // compressed size\r\n    size = file.buffer.length;\r\n    output[op1++] = output[op2++] =  size        & 0xff;\r\n    output[op1++] = output[op2++] = (size >>  8) & 0xff;\r\n    output[op1++] = output[op2++] = (size >> 16) & 0xff;\r\n    output[op1++] = output[op2++] = (size >> 24) & 0xff;\r\n\r\n    // uncompressed size\r\n    plainSize = file.size;\r\n    output[op1++] = output[op2++] =  plainSize        & 0xff;\r\n    output[op1++] = output[op2++] = (plainSize >>  8) & 0xff;\r\n    output[op1++] = output[op2++] = (plainSize >> 16) & 0xff;\r\n    output[op1++] = output[op2++] = (plainSize >> 24) & 0xff;\r\n\r\n    // filename length\r\n    output[op1++] = output[op2++] =  filenameLength       & 0xff;\r\n    output[op1++] = output[op2++] = (filenameLength >> 8) & 0xff;\r\n\r\n    // extra field length\r\n    output[op1++] = output[op2++] =  extraFieldLength       & 0xff;\r\n    output[op1++] = output[op2++] = (extraFieldLength >> 8) & 0xff;\r\n\r\n    // file comment length\r\n    output[op2++] =  commentLength       & 0xff;\r\n    output[op2++] = (commentLength >> 8) & 0xff;\r\n\r\n    // disk number start\r\n    output[op2++] = 0;\r\n    output[op2++] = 0;\r\n\r\n    // internal file attributes\r\n    output[op2++] = 0;\r\n    output[op2++] = 0;\r\n\r\n    // external file attributes\r\n    output[op2++] = 0;\r\n    output[op2++] = 0;\r\n    output[op2++] = 0;\r\n    output[op2++] = 0;\r\n\r\n    // relative offset of local header\r\n    output[op2++] =  offset        & 0xff;\r\n    output[op2++] = (offset >>  8) & 0xff;\r\n    output[op2++] = (offset >> 16) & 0xff;\r\n    output[op2++] = (offset >> 24) & 0xff;\r\n\r\n    // filename\r\n    filename = file.option['filename'];\r\n    if (filename) {\r\n      if (USE_TYPEDARRAY) {\r\n        output.set(filename, op1);\r\n        output.set(filename, op2);\r\n        op1 += filenameLength;\r\n        op2 += filenameLength;\r\n      } else {\r\n        for (j = 0; j < filenameLength; ++j) {\r\n          output[op1++] = output[op2++] = filename[j];\r\n        }\r\n      }\r\n    }\r\n\r\n    // extra field\r\n    extraField = file.option['extraField'];\r\n    if (extraField) {\r\n      if (USE_TYPEDARRAY) {\r\n        output.set(extraField, op1);\r\n        output.set(extraField, op2);\r\n        op1 += extraFieldLength;\r\n        op2 += extraFieldLength;\r\n      } else {\r\n        for (j = 0; j < commentLength; ++j) {\r\n          output[op1++] = output[op2++] = extraField[j];\r\n        }\r\n      }\r\n    }\r\n\r\n    // comment\r\n    comment = file.option['comment'];\r\n    if (comment) {\r\n      if (USE_TYPEDARRAY) {\r\n        output.set(comment, op2);\r\n        op2 += commentLength;\r\n      } else {\r\n        for (j = 0; j < commentLength; ++j) {\r\n          output[op2++] = comment[j];\r\n        }\r\n      }\r\n    }\r\n\r\n    //-------------------------------------------------------------------------\r\n    // file data\r\n    //-------------------------------------------------------------------------\r\n\r\n    if (USE_TYPEDARRAY) {\r\n      output.set(file.buffer, op1);\r\n      op1 += file.buffer.length;\r\n    } else {\r\n      for (j = 0, jl = file.buffer.length; j < jl; ++j) {\r\n        output[op1++] = file.buffer[j];\r\n      }\r\n    }\r\n  }\r\n\r\n  //-------------------------------------------------------------------------\r\n  // end of central directory\r\n  //-------------------------------------------------------------------------\r\n\r\n  // signature\r\n  output[op3++] = Zlib.Zip.CentralDirectorySignature[0];\r\n  output[op3++] = Zlib.Zip.CentralDirectorySignature[1];\r\n  output[op3++] = Zlib.Zip.CentralDirectorySignature[2];\r\n  output[op3++] = Zlib.Zip.CentralDirectorySignature[3];\r\n\r\n  // number of this disk\r\n  output[op3++] = 0;\r\n  output[op3++] = 0;\r\n\r\n  // number of the disk with the start of the central directory\r\n  output[op3++] = 0;\r\n  output[op3++] = 0;\r\n\r\n  // total number of entries in the central directory on this disk\r\n  output[op3++] =  il       & 0xff;\r\n  output[op3++] = (il >> 8) & 0xff;\r\n\r\n  // total number of entries in the central directory\r\n  output[op3++] =  il       & 0xff;\r\n  output[op3++] = (il >> 8) & 0xff;\r\n\r\n  // size of the central directory\r\n  output[op3++] =  centralDirectorySize        & 0xff;\r\n  output[op3++] = (centralDirectorySize >>  8) & 0xff;\r\n  output[op3++] = (centralDirectorySize >> 16) & 0xff;\r\n  output[op3++] = (centralDirectorySize >> 24) & 0xff;\r\n\r\n  // offset of start of central directory with respect to the starting disk number\r\n  output[op3++] =  localFileSize        & 0xff;\r\n  output[op3++] = (localFileSize >>  8) & 0xff;\r\n  output[op3++] = (localFileSize >> 16) & 0xff;\r\n  output[op3++] = (localFileSize >> 24) & 0xff;\r\n\r\n  // .ZIP file comment length\r\n  commentLength = this.comment ? this.comment.length : 0;\r\n  output[op3++] =  commentLength       & 0xff;\r\n  output[op3++] = (commentLength >> 8) & 0xff;\r\n\r\n  // .ZIP file comment\r\n  if (this.comment) {\r\n    if (USE_TYPEDARRAY) {\r\n      output.set(this.comment, op3);\r\n      op3 += commentLength;\r\n    } else {\r\n      for (j = 0, jl = commentLength; j < jl; ++j) {\r\n        output[op3++] = this.comment[j];\r\n      }\r\n    }\r\n  }\r\n\r\n  return output;\r\n};\r\n\r\n/**\r\n * @param {!(Array.<number>|Uint8Array)} input\r\n * @param {Object=} opt_params options.\r\n * @return {!(Array.<number>|Uint8Array)}\r\n */\r\nZlib.Zip.prototype.deflateWithOption = function(input, opt_params) {\r\n  /** @type {Zlib.RawDeflate} */\r\n  var deflator = new Zlib.RawDeflate(input, opt_params['deflateOption']);\r\n\r\n  return deflator.compress();\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint32Array)} key\r\n * @return {number}\r\n */\r\nZlib.Zip.prototype.getByte = function(key) {\r\n  /** @type {number} */\r\n  var tmp = ((key[2] & 0xffff) | 2);\r\n\r\n  return ((tmp * (tmp ^ 1)) >> 8) & 0xff;\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint32Array|Object)} key\r\n * @param {number} n\r\n * @return {number}\r\n */\r\nZlib.Zip.prototype.encode = function(key, n) {\r\n  /** @type {number} */\r\n  var tmp = this.getByte(/** @type {(Array.<number>|Uint32Array)} */(key));\r\n\r\n  this.updateKeys(/** @type {(Array.<number>|Uint32Array)} */(key), n);\r\n\r\n  return tmp ^ n;\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint32Array)} key\r\n * @param {number} n\r\n */\r\nZlib.Zip.prototype.updateKeys = function(key, n) {\r\n  key[0] = Zlib.CRC32.single(key[0], n);\r\n  key[1] =\r\n    (((((key[1] + (key[0] & 0xff)) * 20173 >>> 0) * 6681) >>> 0) + 1) >>> 0;\r\n  key[2] = Zlib.CRC32.single(key[2], key[1] >>> 24);\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint8Array)} password\r\n * @return {!(Array.<number>|Uint32Array|Object)}\r\n */\r\nZlib.Zip.prototype.createEncryptionKey = function(password) {\r\n  /** @type {!(Array.<number>|Uint32Array)} */\r\n  var key = [305419896, 591751049, 878082192];\r\n  /** @type {number} */\r\n  var i;\r\n  /** @type {number} */\r\n  var il;\r\n\r\n  if (USE_TYPEDARRAY) {\r\n    key = new Uint32Array(key);\r\n  }\r\n\r\n  for (i = 0, il = password.length; i < il; ++i) {\r\n    this.updateKeys(key, password[i] & 0xff);\r\n  }\r\n\r\n  return key;\r\n};\r\n\r\n});","goog.provide('Zlib.Unzip');\r\n\r\ngoog.require('USE_TYPEDARRAY');\r\ngoog.require('Zlib.RawInflate');\r\ngoog.require('Zlib.CRC32');\r\ngoog.require('Zlib.Zip');\r\n\r\ngoog.scope(function() {\r\n\r\n/**\r\n * @param {!(Array.<number>|Uint8Array)} input input buffer.\r\n * @param {Object=} opt_params options.\r\n * @constructor\r\n */\r\nZlib.Unzip = function(input, opt_params) {\r\n  opt_params = opt_params || {};\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.input =\r\n    (USE_TYPEDARRAY && (input instanceof Array)) ?\r\n    new Uint8Array(input) : input;\r\n  /** @type {number} */\r\n  this.ip = 0;\r\n  /** @type {number} */\r\n  this.eocdrOffset;\r\n  /** @type {number} */\r\n  this.numberOfThisDisk;\r\n  /** @type {number} */\r\n  this.startDisk;\r\n  /** @type {number} */\r\n  this.totalEntriesThisDisk;\r\n  /** @type {number} */\r\n  this.totalEntries;\r\n  /** @type {number} */\r\n  this.centralDirectorySize;\r\n  /** @type {number} */\r\n  this.centralDirectoryOffset;\r\n  /** @type {number} */\r\n  this.commentLength;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  this.comment;\r\n  /** @type {Array.<Zlib.Unzip.FileHeader>} */\r\n  this.fileHeaderList;\r\n  /** @type {Object.<string, number>} */\r\n  this.filenameToIndex;\r\n  /** @type {boolean} */\r\n  this.verify = opt_params['verify'] || false;\r\n  /** @type {(Array.<number>|Uint8Array)} */\r\n  this.password = opt_params['password'];\r\n};\r\n\r\nZlib.Unzip.CompressionMethod = Zlib.Zip.CompressionMethod;\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Unzip.FileHeaderSignature = Zlib.Zip.FileHeaderSignature;\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Unzip.LocalFileHeaderSignature = Zlib.Zip.LocalFileHeaderSignature;\r\n\r\n/**\r\n * @type {Array.<number>}\r\n * @const\r\n */\r\nZlib.Unzip.CentralDirectorySignature = Zlib.Zip.CentralDirectorySignature;\r\n\r\n/**\r\n * @param {!(Array.<number>|Uint8Array)} input input buffer.\r\n * @param {number} ip input position.\r\n * @constructor\r\n */\r\nZlib.Unzip.FileHeader = function(input, ip) {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.input = input;\r\n  /** @type {number} */\r\n  this.offset = ip;\r\n  /** @type {number} */\r\n  this.length;\r\n  /** @type {number} */\r\n  this.version;\r\n  /** @type {number} */\r\n  this.os;\r\n  /** @type {number} */\r\n  this.needVersion;\r\n  /** @type {number} */\r\n  this.flags;\r\n  /** @type {number} */\r\n  this.compression;\r\n  /** @type {number} */\r\n  this.time;\r\n  /** @type {number} */\r\n  this.date;\r\n  /** @type {number} */\r\n  this.crc32;\r\n  /** @type {number} */\r\n  this.compressedSize;\r\n  /** @type {number} */\r\n  this.plainSize;\r\n  /** @type {number} */\r\n  this.fileNameLength;\r\n  /** @type {number} */\r\n  this.extraFieldLength;\r\n  /** @type {number} */\r\n  this.fileCommentLength;\r\n  /** @type {number} */\r\n  this.diskNumberStart;\r\n  /** @type {number} */\r\n  this.internalFileAttributes;\r\n  /** @type {number} */\r\n  this.externalFileAttributes;\r\n  /** @type {number} */\r\n  this.relativeOffset;\r\n  /** @type {string} */\r\n  this.filename;\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.extraField;\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.comment;\r\n};\r\n\r\nZlib.Unzip.FileHeader.prototype.parse = function() {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var input = this.input;\r\n  /** @type {number} */\r\n  var ip = this.offset;\r\n\r\n  // central file header signature\r\n  if (input[ip++] !== Zlib.Unzip.FileHeaderSignature[0] ||\r\n      input[ip++] !== Zlib.Unzip.FileHeaderSignature[1] ||\r\n      input[ip++] !== Zlib.Unzip.FileHeaderSignature[2] ||\r\n      input[ip++] !== Zlib.Unzip.FileHeaderSignature[3]) {\r\n    throw new Error('invalid file header signature');\r\n  }\r\n\r\n  // version made by\r\n  this.version = input[ip++];\r\n  this.os = input[ip++];\r\n\r\n  // version needed to extract\r\n  this.needVersion = input[ip++] | (input[ip++] << 8);\r\n\r\n  // general purpose bit flag\r\n  this.flags = input[ip++] | (input[ip++] << 8);\r\n\r\n  // compression method\r\n  this.compression = input[ip++] | (input[ip++] << 8);\r\n\r\n  // last mod file time\r\n  this.time = input[ip++] | (input[ip++] << 8);\r\n\r\n  //last mod file date\r\n  this.date = input[ip++] | (input[ip++] << 8);\r\n\r\n  // crc-32\r\n  this.crc32 = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // compressed size\r\n  this.compressedSize = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // uncompressed size\r\n  this.plainSize = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // file name length\r\n  this.fileNameLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // extra field length\r\n  this.extraFieldLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // file comment length\r\n  this.fileCommentLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // disk number start\r\n  this.diskNumberStart = input[ip++] | (input[ip++] << 8);\r\n\r\n  // internal file attributes\r\n  this.internalFileAttributes = input[ip++] | (input[ip++] << 8);\r\n\r\n  // external file attributes\r\n  this.externalFileAttributes =\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24);\r\n\r\n  // relative offset of local header\r\n  this.relativeOffset = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // file name\r\n  this.filename = String.fromCharCode.apply(null, USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip += this.fileNameLength) :\r\n    input.slice(ip, ip += this.fileNameLength)\r\n  );\r\n\r\n  // extra field\r\n  this.extraField = USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip += this.extraFieldLength) :\r\n    input.slice(ip, ip += this.extraFieldLength);\r\n\r\n  // file comment\r\n  this.comment = USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip + this.fileCommentLength) :\r\n    input.slice(ip, ip + this.fileCommentLength);\r\n\r\n  this.length = ip - this.offset;\r\n};\r\n\r\n/**\r\n * @param {!(Array.<number>|Uint8Array)} input input buffer.\r\n * @param {number} ip input position.\r\n * @constructor\r\n */\r\nZlib.Unzip.LocalFileHeader = function(input, ip) {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.input = input;\r\n  /** @type {number} */\r\n  this.offset = ip;\r\n  /** @type {number} */\r\n  this.length;\r\n  /** @type {number} */\r\n  this.needVersion;\r\n  /** @type {number} */\r\n  this.flags;\r\n  /** @type {number} */\r\n  this.compression;\r\n  /** @type {number} */\r\n  this.time;\r\n  /** @type {number} */\r\n  this.date;\r\n  /** @type {number} */\r\n  this.crc32;\r\n  /** @type {number} */\r\n  this.compressedSize;\r\n  /** @type {number} */\r\n  this.plainSize;\r\n  /** @type {number} */\r\n  this.fileNameLength;\r\n  /** @type {number} */\r\n  this.extraFieldLength;\r\n  /** @type {string} */\r\n  this.filename;\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  this.extraField;\r\n};\r\n\r\nZlib.Unzip.LocalFileHeader.Flags = Zlib.Zip.Flags;\r\n\r\nZlib.Unzip.LocalFileHeader.prototype.parse = function() {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var input = this.input;\r\n  /** @type {number} */\r\n  var ip = this.offset;\r\n\r\n  // local file header signature\r\n  if (input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[0] ||\r\n      input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[1] ||\r\n      input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[2] ||\r\n      input[ip++] !== Zlib.Unzip.LocalFileHeaderSignature[3]) {\r\n    throw new Error('invalid local file header signature');\r\n  }\r\n\r\n  // version needed to extract\r\n  this.needVersion = input[ip++] | (input[ip++] << 8);\r\n\r\n  // general purpose bit flag\r\n  this.flags = input[ip++] | (input[ip++] << 8);\r\n\r\n  // compression method\r\n  this.compression = input[ip++] | (input[ip++] << 8);\r\n\r\n  // last mod file time\r\n  this.time = input[ip++] | (input[ip++] << 8);\r\n\r\n  //last mod file date\r\n  this.date = input[ip++] | (input[ip++] << 8);\r\n\r\n  // crc-32\r\n  this.crc32 = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // compressed size\r\n  this.compressedSize = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // uncompressed size\r\n  this.plainSize = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // file name length\r\n  this.fileNameLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // extra field length\r\n  this.extraFieldLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // file name\r\n  this.filename = String.fromCharCode.apply(null, USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip += this.fileNameLength) :\r\n    input.slice(ip, ip += this.fileNameLength)\r\n  );\r\n\r\n  // extra field\r\n  this.extraField = USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip += this.extraFieldLength) :\r\n    input.slice(ip, ip += this.extraFieldLength);\r\n\r\n  this.length = ip - this.offset;\r\n};\r\n\r\n\r\nZlib.Unzip.prototype.searchEndOfCentralDirectoryRecord = function() {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var input = this.input;\r\n  /** @type {number} */\r\n  var ip;\r\n\r\n  for (ip = input.length - 12; ip > 0; --ip) {\r\n    if (input[ip  ] === Zlib.Unzip.CentralDirectorySignature[0] &&\r\n        input[ip+1] === Zlib.Unzip.CentralDirectorySignature[1] &&\r\n        input[ip+2] === Zlib.Unzip.CentralDirectorySignature[2] &&\r\n        input[ip+3] === Zlib.Unzip.CentralDirectorySignature[3]) {\r\n      this.eocdrOffset = ip;\r\n      return;\r\n    }\r\n  }\r\n\r\n  throw new Error('End of Central Directory Record not found');\r\n};\r\n\r\nZlib.Unzip.prototype.parseEndOfCentralDirectoryRecord = function() {\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var input = this.input;\r\n  /** @type {number} */\r\n  var ip;\r\n\r\n  if (!this.eocdrOffset) {\r\n    this.searchEndOfCentralDirectoryRecord();\r\n  }\r\n  ip = this.eocdrOffset;\r\n\r\n  // signature\r\n  if (input[ip++] !== Zlib.Unzip.CentralDirectorySignature[0] ||\r\n      input[ip++] !== Zlib.Unzip.CentralDirectorySignature[1] ||\r\n      input[ip++] !== Zlib.Unzip.CentralDirectorySignature[2] ||\r\n      input[ip++] !== Zlib.Unzip.CentralDirectorySignature[3]) {\r\n    throw new Error('invalid signature');\r\n  }\r\n\r\n  // number of this disk\r\n  this.numberOfThisDisk = input[ip++] | (input[ip++] << 8);\r\n\r\n  // number of the disk with the start of the central directory\r\n  this.startDisk = input[ip++] | (input[ip++] << 8);\r\n\r\n  // total number of entries in the central directory on this disk\r\n  this.totalEntriesThisDisk = input[ip++] | (input[ip++] << 8);\r\n\r\n  // total number of entries in the central directory\r\n  this.totalEntries = input[ip++] | (input[ip++] << 8);\r\n\r\n  // size of the central directory\r\n  this.centralDirectorySize = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // offset of start of central directory with respect to the starting disk number\r\n  this.centralDirectoryOffset = (\r\n    (input[ip++]      ) | (input[ip++] <<  8) |\r\n    (input[ip++] << 16) | (input[ip++] << 24)\r\n  ) >>> 0;\r\n\r\n  // .ZIP file comment length\r\n  this.commentLength = input[ip++] | (input[ip++] << 8);\r\n\r\n  // .ZIP file comment\r\n  this.comment = USE_TYPEDARRAY ?\r\n    input.subarray(ip, ip + this.commentLength) :\r\n    input.slice(ip, ip + this.commentLength);\r\n};\r\n\r\nZlib.Unzip.prototype.parseFileHeader = function() {\r\n  /** @type {Array.<Zlib.Unzip.FileHeader>} */\r\n  var filelist = [];\r\n  /** @type {Object.<string, number>} */\r\n  var filetable = {};\r\n  /** @type {number} */\r\n  var ip;\r\n  /** @type {Zlib.Unzip.FileHeader} */\r\n  var fileHeader;\r\n  /*: @type {number} */\r\n  var i;\r\n  /*: @type {number} */\r\n  var il;\r\n\r\n  if (this.fileHeaderList) {\r\n    return;\r\n  }\r\n\r\n  if (this.centralDirectoryOffset === void 0) {\r\n    this.parseEndOfCentralDirectoryRecord();\r\n  }\r\n  ip = this.centralDirectoryOffset;\r\n\r\n  for (i = 0, il = this.totalEntries; i < il; ++i) {\r\n    fileHeader = new Zlib.Unzip.FileHeader(this.input, ip);\r\n    fileHeader.parse();\r\n    ip += fileHeader.length;\r\n    filelist[i] = fileHeader;\r\n    filetable[fileHeader.filename] = i;\r\n  }\r\n\r\n  if (this.centralDirectorySize < ip - this.centralDirectoryOffset) {\r\n    throw new Error('invalid file header size');\r\n  }\r\n\r\n  this.fileHeaderList = filelist;\r\n  this.filenameToIndex = filetable;\r\n};\r\n\r\n/**\r\n * @param {number} index file header index.\r\n * @param {Object=} opt_params\r\n * @return {!(Array.<number>|Uint8Array)} file data.\r\n */\r\nZlib.Unzip.prototype.getFileData = function(index, opt_params) {\r\n  opt_params = opt_params || {};\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var input = this.input;\r\n  /** @type {Array.<Zlib.Unzip.FileHeader>} */\r\n  var fileHeaderList = this.fileHeaderList;\r\n  /** @type {Zlib.Unzip.LocalFileHeader} */\r\n  var localFileHeader;\r\n  /** @type {number} */\r\n  var offset;\r\n  /** @type {number} */\r\n  var length;\r\n  /** @type {!(Array.<number>|Uint8Array)} */\r\n  var buffer;\r\n  /** @type {number} */\r\n  var crc32;\r\n  /** @type {Array.<number>|Uint32Array|Object} */\r\n  var key;\r\n  /** @type {number} */\r\n  var i;\r\n  /** @type {number} */\r\n  var il;\r\n\r\n  if (!fileHeaderList) {\r\n    this.parseFileHeader();\r\n  }\r\n\r\n  if (fileHeaderList[index] === void 0) {\r\n    throw new Error('wrong index');\r\n  }\r\n\r\n  offset = fileHeaderList[index].relativeOffset;\r\n  localFileHeader = new Zlib.Unzip.LocalFileHeader(this.input, offset);\r\n  localFileHeader.parse();\r\n  offset += localFileHeader.length;\r\n  length = localFileHeader.compressedSize;\r\n\r\n  // decryption\r\n  if ((localFileHeader.flags & Zlib.Unzip.LocalFileHeader.Flags.ENCRYPT) !== 0) {\r\n    if (!(opt_params['password'] || this.password)) {\r\n      throw new Error('please set password');\r\n    }\r\n    key =  this.createDecryptionKey(opt_params['password'] || this.password);\r\n\r\n    // encryption header\r\n    for(i = offset, il = offset + 12; i < il; ++i) {\r\n      this.decode(key, input[i]);\r\n    }\r\n    offset += 12;\r\n    length -= 12;\r\n\r\n    // decryption\r\n    for (i = offset, il = offset + length; i < il; ++i) {\r\n      input[i] = this.decode(key, input[i]);\r\n    }\r\n  }\r\n\r\n  switch (localFileHeader.compression) {\r\n    case Zlib.Unzip.CompressionMethod.STORE:\r\n      buffer = USE_TYPEDARRAY ?\r\n        this.input.subarray(offset, offset + length) :\r\n        this.input.slice(offset, offset + length);\r\n      break;\r\n    case Zlib.Unzip.CompressionMethod.DEFLATE:\r\n      buffer = new Zlib.RawInflate(this.input, {\r\n        'index': offset,\r\n        'bufferSize': localFileHeader.plainSize\r\n      }).decompress();\r\n      break;\r\n    default:\r\n      throw new Error('unknown compression type');\r\n  }\r\n\r\n  if (this.verify) {\r\n    crc32 = Zlib.CRC32.calc(buffer);\r\n    if (localFileHeader.crc32 !== crc32) {\r\n      throw new Error(\r\n        'wrong crc: file=0x' + localFileHeader.crc32.toString(16) +\r\n        ', data=0x' + crc32.toString(16)\r\n      );\r\n    }\r\n  }\r\n\r\n  return buffer;\r\n};\r\n\r\n/**\r\n * @return {Array.<string>}\r\n */\r\nZlib.Unzip.prototype.getFilenames = function() {\r\n  /** @type {Array.<string>} */\r\n  var filenameList = [];\r\n  /** @type {number} */\r\n  var i;\r\n  /** @type {number} */\r\n  var il;\r\n  /** @type {Array.<Zlib.Unzip.FileHeader>} */\r\n  var fileHeaderList;\r\n\r\n  if (!this.fileHeaderList) {\r\n    this.parseFileHeader();\r\n  }\r\n  fileHeaderList = this.fileHeaderList;\r\n\r\n  for (i = 0, il = fileHeaderList.length; i < il; ++i) {\r\n    filenameList[i] = fileHeaderList[i].filename;\r\n  }\r\n\r\n  return filenameList;\r\n};\r\n\r\n/**\r\n * @param {string} filename extract filename.\r\n * @param {Object=} opt_params\r\n * @return {!(Array.<number>|Uint8Array)} decompressed data.\r\n */\r\nZlib.Unzip.prototype.decompress = function(filename, opt_params) {\r\n  /** @type {number} */\r\n  var index;\r\n\r\n  if (!this.filenameToIndex) {\r\n    this.parseFileHeader();\r\n  }\r\n  index = this.filenameToIndex[filename];\r\n\r\n  if (index === void 0) {\r\n    throw new Error(filename + ' not found');\r\n  }\r\n\r\n  return this.getFileData(index, opt_params);\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint8Array)} password\r\n */\r\nZlib.Unzip.prototype.setPassword = function(password) {\r\n  this.password = password;\r\n};\r\n\r\n/**\r\n * @param {(Array.<number>|Uint32Array|Object)} key\r\n * @param {number} n\r\n * @return {number}\r\n */\r\nZlib.Unzip.prototype.decode = function(key, n) {\r\n  n ^= this.getByte(/** @type {(Array.<number>|Uint32Array)} */(key));\r\n  this.updateKeys(/** @type {(Array.<number>|Uint32Array)} */(key), n);\r\n\r\n  return n;\r\n};\r\n\r\n// common method\r\nZlib.Unzip.prototype.updateKeys = Zlib.Zip.prototype.updateKeys;\r\nZlib.Unzip.prototype.createDecryptionKey = Zlib.Zip.prototype.createEncryptionKey;\r\nZlib.Unzip.prototype.getByte = Zlib.Zip.prototype.getByte;\r\n\r\n// end of scope\r\n});\r\n","goog.require('Zlib.Unzip');\n\ngoog.exportSymbol('Zlib.Unzip', Zlib.Unzip);\ngoog.exportSymbol(\n  'Zlib.Unzip.prototype.decompress',\n  Zlib.Unzip.prototype.decompress\n);\ngoog.exportSymbol(\n  'Zlib.Unzip.prototype.getFilenames',\n  Zlib.Unzip.prototype.getFilenames\n);\ngoog.exportSymbol(\n  'Zlib.Unzip.prototype.setPassword',\n  Zlib.Unzip.prototype.setPassword\n);"]} \ No newline at end of file diff --git a/bin/unzip.min.js b/bin/unzip.min.js index 8d19e36..1c1a364 100644 --- a/bin/unzip.min.js +++ b/bin/unzip.min.js @@ -28,4 +28,4 @@ function $(a){var b=[],c={},d,f,h,k;if(!a.i){if(a.o===q){var e=a.input,g;if(!a.D e[g++]<<8|e[g++]<<16|e[g++]<<24)>>>0;a.w=e[g++]|e[g++]<<8;a.v=w?e.subarray(g,g+a.w):e.slice(g,g+a.w)}d=a.o;h=0;for(k=a.ba;h>>8^B[(n^l[t])&255];for(N=ka>>3;N--;t+=8)n=n>>>8^B[(n^l[t])&255],n=n>>>8^B[(n^l[t+1])&255],n=n>>>8^B[(n^l[t+2])&255],n=n>>>8^B[(n^l[t+3])&255],n=n>>>8^B[(n^l[t+4])&255],n=n>>>8^B[(n^l[t+5])&255],n=n>>>8^B[(n^l[t+6])&255],n=n>>>8^B[(n^l[t+7])&255];p=(n^4294967295)>>>0;k.p!==p&&m(Error("wrong crc: file=0x"+ -k.p.toString(16)+", data=0x"+p.toString(16)))}return l};u.M=function(a){this.j=a};function ra(a,b,c){c^=a.s(b);a.k(b,c);return c}u.k=V.prototype.k;u.T=V.prototype.U;u.s=V.prototype.s;v("Zlib.Unzip",W);v("Zlib.Unzip.prototype.decompress",W.prototype.r);v("Zlib.Unzip.prototype.getFilenames",W.prototype.Z);v("Zlib.Unzip.prototype.setPassword",W.prototype.M);}).call(this); //@ sourceMappingURL=unzip.min.js.map +k.p.toString(16)+", data=0x"+p.toString(16)))}return l};u.M=function(a){this.j=a};function ra(a,b,c){c^=a.s(b);a.k(b,c);return c}u.k=V.prototype.k;u.T=V.prototype.U;u.s=V.prototype.s;v("Zlib.Unzip",W);v("Zlib.Unzip.prototype.decompress",W.prototype.r);v("Zlib.Unzip.prototype.getFilenames",W.prototype.Z);v("Zlib.Unzip.prototype.setPassword",W.prototype.M);}).call(this); diff --git a/bin/unzip.min.js.map b/bin/unzip.min.js.map deleted file mode 100644 index c9b90b4..0000000 --- a/bin/unzip.min.js.map +++ /dev/null @@ -1,8 +0,0 @@ -{ -"version":3, -"file":"./unzip.min.js", -"lineCount":31, -"mappings":"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", -"sources":["../closure-primitives/base.js","../define/typedarray/hybrid.js","../src/bitstream.js","../src/crc32.js","../src/huffman.js","../src/rawdeflate.js","../src/rawinflate.js","../src/zip.js","../src/unzip.js","../export/unzip.js"], -"names":["goog.global","goog.exportSymbol","publicPath","object","parts","split","cur","execScript","part","length","shift","JSCompiler_alias_VOID","USE_TYPEDARRAY","Uint8Array","Uint16Array","Uint32Array","DataView","Array","i","s","n","Zlib.CRC32.Table_","Zlib.CRC32.Table","Zlib.Huffman.buildHuffmanTable","lengths","listSize","maxCodeLength","minCodeLength","Number","POSITIVE_INFINITY","size","table","bitLength","code","skip","reversed","rtemp","j","value","push","JSCompiler_alias_THROW","c","Zlib.RawInflate","input","opt_params","blocks","bufferSize","ZLIB_RAW_INFLATE_BUFFER_SIZE","bitsbuflen","bitsbuf","ip","totalpos","bfinal","bufferType","Zlib.RawInflate.BufferType.ADAPTIVE","resize","Zlib.RawInflate.BufferType.BLOCK","op","Zlib.RawInflate.MaxBackwardLength","output","Zlib.RawInflate.MaxCopyLength","expandBuffer","expandBufferAdaptive","concatBuffer","concatBufferDynamic","decodeHuffman","decodeHuffmanAdaptive","Error","BLOCK","ADAPTIVE","prototype","decompress","Zlib.RawInflate.prototype.decompress","hdr","readBits","parseBlock","inputLength","len","nlen","olength","preCopy","set","subarray","Zlib.RawInflate.FixedLiteralLengthTable","Zlib.RawInflate.FixedDistanceTable","parseDynamicHuffmanBlock","Zlib.RawInflate.Order","Zlib.RawInflate.LengthCodeTable","Zlib.RawInflate.LengthExtraTable","Zlib.RawInflate.DistCodeTable","Zlib.RawInflate.DistExtraTable","il","Zlib.RawInflate.prototype.readBits","octet","Zlib.RawInflate.prototype.readCodeByTable","codeTable","codeWithLength","codeLength","Zlib.RawInflate.prototype.parseDynamicHuffmanBlock","decode","num","prev","repeat","readCodeByTable","hlit","hdist","hclen","codeLengths","Zlib.RawInflate.Order.length","codeLengthsTable","litlenLengths","distLengths","call","Zlib$RawInflate.prototype","Zlib.RawInflate.prototype","Zlib.RawInflate.prototype.decodeHuffman","litlen","dist","currentLitlenTable","ti","codeDist","Zlib.RawInflate.prototype.decodeHuffmanAdaptive","Zlib.RawInflate.prototype.expandBuffer","buffer","backward","Zlib.RawInflate.prototype.expandBufferAdaptive","opt_param","ratio","maxHuffCode","newSize","maxInflateSize","fixRatio","addRatio","Zlib.RawInflate.prototype.concatBuffer","pos","block","jl","slice","Zlib.RawInflate.prototype.concatBufferDynamic","Zlib.Zip","files","comment","setPassword","Zlib.Zip.prototype.setPassword","password","getByte","Zlib.Zip.prototype.getByte","key","tmp","updateKeys","Zlib.Zip.prototype.updateKeys","createEncryptionKey","Zlib.Zip.prototype.createEncryptionKey","Zlib.Unzip","verify","Zlib.Unzip.CompressionMethod","Zlib.Zip.CompressionMethod","STORE","DEFLATE","Zlib.Unzip.FileHeaderSignature","Zlib.Zip.FileHeaderSignature","Zlib.Unzip.LocalFileHeaderSignature","Zlib.Zip.LocalFileHeaderSignature","Zlib.Unzip.CentralDirectorySignature","Zlib.Zip.CentralDirectorySignature","Zlib.Unzip.FileHeader","offset","parse","Zlib.Unzip.FileHeader.prototype.parse","version","os","needVersion","flags","compression","time","date","crc32","compressedSize","plainSize","fileNameLength","extraFieldLength","fileCommentLength","diskNumberStart","internalFileAttributes","externalFileAttributes","relativeOffset","filename","String","fromCharCode","apply","extraField","Zlib.Unzip.LocalFileHeader","Zlib.Unzip.LocalFileHeader.Flags","Zlib.Zip.Flags","ENCRYPT","DESCRIPTOR","UTF8","Zlib.Unzip.LocalFileHeader.prototype.parse","Zlib.Unzip.prototype.parseFileHeader","filelist","filetable","fileHeader","fileHeaderList","centralDirectoryOffset","parseEndOfCentralDirectoryRecord","eocdrOffset","numberOfThisDisk","startDisk","totalEntriesThisDisk","totalEntries","centralDirectorySize","commentLength","filenameToIndex","Zlib$Unzip.prototype","Zlib.Unzip.prototype","getFilenames","Zlib.Unzip.prototype.getFilenames","filenameList","parseFileHeader","Zlib.Unzip.prototype.decompress","index","getFileData","localFileHeader","Zlib.Unzip.LocalFileHeader.Flags.ENCRYPT","createDecryptionKey","Zlib.Unzip.CompressionMethod.STORE","Zlib.Unzip.CompressionMethod.DEFLATE","crc","toString","Zlib.Unzip.prototype.setPassword","Zlib.Unzip.prototype.decode"] -} diff --git a/bin/zip.dev.min.js b/bin/zip.dev.min.js new file mode 100644 index 0000000..449cf52 --- /dev/null +++ b/bin/zip.dev.min.js @@ -0,0 +1,38 @@ +/** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */(function() {'use strict';var n=void 0,y=!0,aa=this;function G(e,b){var a=e.split("."),d=aa;!(a[0]in d)&&d.execScript&&d.execScript("var "+a[0]);for(var c;a.length&&(c=a.shift());)!a.length&&b!==n?d[c]=b:d=d[c]?d[c]:d[c]={}};var H="undefined"!==typeof Uint8Array&&"undefined"!==typeof Uint16Array&&"undefined"!==typeof Uint32Array&&"undefined"!==typeof DataView;function ba(e,b){this.index="number"===typeof b?b:0;this.f=0;this.buffer=e instanceof(H?Uint8Array:Array)?e:new (H?Uint8Array:Array)(32768);if(2*this.buffer.length<=this.index)throw Error("invalid index");this.buffer.length<=this.index&&ca(this)}function ca(e){var b=e.buffer,a,d=b.length,c=new (H?Uint8Array:Array)(d<<1);if(H)c.set(b);else for(a=0;a>>8&255]<<16|L[e>>>16&255]<<8|L[e>>>24&255])>>32-b:L[e]>>8-b);if(8>b+f)l=l<>b-p-1&1,8===++f&&(f=0,d[c++]=L[l],l=0,c===d.length&&(d=ca(this)));d[c]=l;this.buffer=d;this.f=f;this.index=c};ba.prototype.finish=function(){var e=this.buffer,b=this.index,a;0ha;++ha){for(var U=ha,ja=U,ka=7,U=U>>>1;U;U>>>=1)ja<<=1,ja|=U&1,--ka;da[ha]=(ja<>>0}var L=da;function la(e){var b=n,a,d="number"===typeof b?b:b=0,c=e.length;a=-1;for(d=c&7;d--;++b)a=a>>>8^V[(a^e[b])&255];for(d=c>>3;d--;b+=8)a=a>>>8^V[(a^e[b])&255],a=a>>>8^V[(a^e[b+1])&255],a=a>>>8^V[(a^e[b+2])&255],a=a>>>8^V[(a^e[b+3])&255],a=a>>>8^V[(a^e[b+4])&255],a=a>>>8^V[(a^e[b+5])&255],a=a>>>8^V[(a^e[b+6])&255],a=a>>>8^V[(a^e[b+7])&255];return(a^4294967295)>>>0} +var ma=[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759, +2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977, +2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755, +2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956, +3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270, +936918E3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],V=H?new Uint32Array(ma):ma;function na(e){this.buffer=new (H?Uint16Array:Array)(2*e);this.length=0}na.prototype.getParent=function(e){return 2*((e-2)/4|0)};na.prototype.push=function(e,b){var a,d,c=this.buffer,f;a=this.length;c[this.length++]=b;for(c[this.length++]=e;0c[d])f=c[a],c[a]=c[d],c[d]=f,f=c[a+1],c[a+1]=c[d+1],c[d+1]=f,a=d;else break;return this.length}; +na.prototype.pop=function(){var e,b,a=this.buffer,d,c,f;b=a[0];e=a[1];this.length-=2;a[0]=a[this.length];a[1]=a[this.length+1];for(f=0;;){c=2*f+2;if(c>=this.length)break;c+2a[c]&&(c+=2);if(a[c]>a[f])d=a[f],a[f]=a[c],a[c]=d,d=a[f+1],a[f+1]=a[c+1],a[c+1]=d;else break;f=c}return{index:e,value:b,length:this.length}};function pa(e,b){this.k=qa;this.l=0;this.input=H&&e instanceof Array?new Uint8Array(e):e;this.e=0;b&&(b.lazy&&(this.l=b.lazy),"number"===typeof b.compressionType&&(this.k=b.compressionType),b.outputBuffer&&(this.c=H&&b.outputBuffer instanceof Array?new Uint8Array(b.outputBuffer):b.outputBuffer),"number"===typeof b.outputIndex&&(this.e=b.outputIndex));this.c||(this.c=new (H?Uint8Array:Array)(32768))}var qa=2,sa=[],Y; +for(Y=0;288>Y;Y++)switch(y){case 143>=Y:sa.push([Y+48,8]);break;case 255>=Y:sa.push([Y-144+400,9]);break;case 279>=Y:sa.push([Y-256+0,7]);break;case 287>=Y:sa.push([Y-280+192,8]);break;default:throw"invalid literal: "+Y;} +pa.prototype.g=function(){var e,b,a,d,c=this.input;switch(this.k){case 0:a=0;for(d=c.length;a>>8&255;m[h++]=q&255;m[h++]=q>>>8&255;if(H)m.set(f,h),h+=f.length,m=m.subarray(0,h);else{w=0;for(u=f.length;wx)for(;0x?x:138,E>x-3&&E=E?(M[K++]=17,M[K++]=E-3,S[17]++):(M[K++]=18,M[K++]=E-11,S[18]++),x-=E;else if(M[K++]=P[v],S[P[v]]++,x--,3>x)for(;0x?x:6,E>x-3&&ED;D++)oa[D]=X[g[D]];for(C=19;4=a:return[265,a-11,1];case 14>=a:return[266,a-13,1];case 16>=a:return[267,a-15,1];case 18>=a:return[268,a-17,1];case 22>=a:return[269,a-19,2];case 26>=a:return[270,a-23,2];case 30>=a:return[271,a-27,2];case 34>=a:return[272, +a-31,2];case 42>=a:return[273,a-35,3];case 50>=a:return[274,a-43,3];case 58>=a:return[275,a-51,3];case 66>=a:return[276,a-59,3];case 82>=a:return[277,a-67,4];case 98>=a:return[278,a-83,4];case 114>=a:return[279,a-99,4];case 130>=a:return[280,a-115,4];case 162>=a:return[281,a-131,5];case 194>=a:return[282,a-163,5];case 226>=a:return[283,a-195,5];case 257>=a:return[284,a-227,5];case 258===a:return[285,a-258,0];default:throw"invalid length: "+a;}}var b=[],a,d;for(a=3;258>=a;a++)d=e(a),b[a]=d[2]<<24| +d[1]<<16|d[0];return b}(),Ja=H?new Uint32Array(xa):xa; +function ta(e,b){function a(a,c){var b=a.n,d=[],e=0,f;f=Ja[a.length];d[e++]=f&65535;d[e++]=f>>16&255;d[e++]=f>>24;var g;switch(y){case 1===b:g=[0,b-1,0];break;case 2===b:g=[1,b-2,0];break;case 3===b:g=[2,b-3,0];break;case 4===b:g=[3,b-4,0];break;case 6>=b:g=[4,b-5,1];break;case 8>=b:g=[5,b-7,1];break;case 12>=b:g=[6,b-9,2];break;case 16>=b:g=[7,b-13,2];break;case 24>=b:g=[8,b-17,3];break;case 32>=b:g=[9,b-25,3];break;case 48>=b:g=[10,b-33,4];break;case 64>=b:g=[11,b-49,4];break;case 96>=b:g=[12,b- +65,5];break;case 128>=b:g=[13,b-97,5];break;case 192>=b:g=[14,b-129,6];break;case 256>=b:g=[15,b-193,6];break;case 384>=b:g=[16,b-257,7];break;case 512>=b:g=[17,b-385,7];break;case 768>=b:g=[18,b-513,8];break;case 1024>=b:g=[19,b-769,8];break;case 1536>=b:g=[20,b-1025,9];break;case 2048>=b:g=[21,b-1537,9];break;case 3072>=b:g=[22,b-2049,10];break;case 4096>=b:g=[23,b-3073,10];break;case 6144>=b:g=[24,b-4097,11];break;case 8192>=b:g=[25,b-6145,11];break;case 12288>=b:g=[26,b-8193,12];break;case 16384>= +b:g=[27,b-12289,12];break;case 24576>=b:g=[28,b-16385,13];break;case 32768>=b:g=[29,b-24577,13];break;default:throw"invalid distance";}f=g;d[e++]=f[0];d[e++]=f[1];d[e++]=f[2];var k,l;k=0;for(l=d.length;k=f;)t[f++]=0;for(f=0;29>=f;)r[f++]=0}t[256]=1;d=0;for(c=b.length;d=c){u&&a(u,-1);f=0;for(l=c-d;fl&&b+lf&&(c=d,f=l);if(258===l)break}return new wa(f,b-c)} +function ua(e,b){var a=e.length,d=new na(572),c=new (H?Uint8Array:Array)(a),f,l,p,k,q;if(!H)for(k=0;k2*c[h-1]+f[h]&&(c[h]=2*c[h-1]+f[h]),p[h]=Array(c[h]),k[h]=Array(c[h]);for(m=0;me[m]?(p[h][s]=t,k[h][s]=b,r+=2):(p[h][s]=e[m],k[h][s]=m,++m);q[h]=0;1===f[h]&&d(h)}return l} +function va(e){var b=new (H?Uint16Array:Array)(e.length),a=[],d=[],c=0,f,l,p,k;f=0;for(l=e.length;f>>=1}return b};function $(e){e=e||{};this.files=[];this.d=e.comment}var Ma=[80,75,1,2],Na=[80,75,3,4],Oa=[80,75,5,6];$.prototype.m=function(e,b){b=b||{};var a,d=e.length,c=0;H&&e instanceof Array&&(e=new Uint8Array(e));"number"!==typeof b.compressionMethod&&(b.compressionMethod=8);if(b.compress)switch(b.compressionMethod){case 0:break;case 8:c=la(e);e=(new pa(e,b.deflateOption)).g();a=y;break;default:throw Error("unknown compression method:"+b.compressionMethod);}this.files.push({buffer:e,a:b,j:a,r:!1,size:d,h:c})}; +$.prototype.q=function(e){this.i=e}; +$.prototype.g=function(){var e=this.files,b,a,d,c,f,l=0,p=0,k,q,w,u,m,h,s,t,r,Q,z,A,F,I,N,B,C,g,J;B=0;for(C=e.length;Bg;++g)F[g]=Qa(N,11===B?b.h&255:256*Math.random()|0);for(J=F.length;g>8&255;w=b.a.compressionMethod;a[d++]=a[c++]=w&255;a[d++]=a[c++]=w>>8&255;u=b.a.date||new Date;a[d++]=a[c++]=(u.getMinutes()&7)<<5|u.getSeconds()/2|0;a[d++]=a[c++]=u.getHours()<<3|u.getMinutes()>>3;a[d++]=a[c++]=(u.getMonth()+1&7)<<5|u.getDate();a[d++]=a[c++]=(u.getFullYear()- +1980&127)<<1|u.getMonth()+1>>3;m=b.h;a[d++]=a[c++]=m&255;a[d++]=a[c++]=m>>8&255;a[d++]=a[c++]=m>>16&255;a[d++]=a[c++]=m>>24&255;h=b.buffer.length;a[d++]=a[c++]=h&255;a[d++]=a[c++]=h>>8&255;a[d++]=a[c++]=h>>16&255;a[d++]=a[c++]=h>>24&255;s=b.size;a[d++]=a[c++]=s&255;a[d++]=a[c++]=s>>8&255;a[d++]=a[c++]=s>>16&255;a[d++]=a[c++]=s>>24&255;a[d++]=a[c++]=t&255;a[d++]=a[c++]=t>>8&255;a[d++]=a[c++]=0;a[d++]=a[c++]=0;a[c++]=r&255;a[c++]=r>>8&255;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]= +0;a[c++]=0;a[c++]=k&255;a[c++]=k>>8&255;a[c++]=k>>16&255;a[c++]=k>>24&255;if(Q=b.a.filename)if(H)a.set(Q,d),a.set(Q,c),d+=t,c+=t;else for(g=0;g>8&255;a[f++]=C&255;a[f++]=C>>8&255;a[f++]=p&255;a[f++]=p>>8&255;a[f++]=p>>16&255;a[f++]=p>>24&255;a[f++]=l&255;a[f++]=l>>8&255;a[f++]=l>>16&255;a[f++]=l>>24&255;r=this.d?this.d.length:0;a[f++]=r&255;a[f++]=r>>8&255;if(this.d)if(H)a.set(this.d,f);else{g=0;for(J=r;g>8&255;Pa(e,b);return a^b} +function Pa(e,b){e[0]=(V[(e[0]^b)&255]^e[0]>>>8)>>>0;e[1]=(6681*(20173*(e[1]+(e[0]&255))>>>0)>>>0)+1>>>0;e[2]=(V[(e[2]^e[1]>>>24)&255]^e[2]>>>8)>>>0};function Ra(e,b){var a,d,c,f;if(Object.keys)a=Object.keys(b);else for(d in a=[],c=0,b)a[c++]=d;c=0;for(f=a.length;c>3;m=b.h;a[d++]=a[c++]=m&255;a[d++]=a[c++]=m>>8&255;a[d++]=a[c++]=m>>16&255;a[d++]=a[c++]=m>>24&255;h=b.buffer.length;a[d++]=a[c++]=h&255;a[d++]=a[c++]=h>>8&255;a[d++]=a[c++]=h>>16&255;a[d++]=a[c++]=h>>24&255;s=b.size;a[d++]=a[c++]=s&255;a[d++]=a[c++]=s>>8&255;a[d++]=a[c++]=s>>16&255;a[d++]=a[c++]=s>>24&255;a[d++]=a[c++]=t&255;a[d++]=a[c++]=t>>8&255;a[d++]=a[c++]=0;a[d++]=a[c++]=0;a[c++]=r&255;a[c++]=r>>8&255;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]=0;a[c++]= 0;a[c++]=0;a[c++]=k&255;a[c++]=k>>8&255;a[c++]=k>>16&255;a[c++]=k>>24&255;if(Q=b.a.filename)if(H)a.set(Q,d),a.set(Q,c),d+=t,c+=t;else for(g=0;g>8&255;a[f++]=C&255;a[f++]=C>>8&255;a[f++]=p&255;a[f++]=p>>8&255;a[f++]=p>>16&255;a[f++]=p>>24&255;a[f++]=l&255;a[f++]=l>>8&255;a[f++]=l>>16&255;a[f++]=l>>24&255;r=this.d?this.d.length:0;a[f++]=r&255;a[f++]=r>>8&255;if(this.d)if(H)a.set(this.d,f);else{g=0;for(J=r;g>8&255;Pa(e,b);return a^b} -function Pa(e,b){e[0]=(V[(e[0]^b)&255]^e[0]>>>8)>>>0;e[1]=(6681*(20173*(e[1]+(e[0]&255))>>>0)>>>0)+1>>>0;e[2]=(V[(e[2]^e[1]>>>24)&255]^e[2]>>>8)>>>0};function Ra(e,b){var a,d,c,f;if(Object.keys)a=Object.keys(b);else for(d in a=[],c=0,b)a[c++]=d;c=0;for(f=a.length;c>>8)>>>0;e[1]=(6681*(20173*(e[1]+(e[0]&255))>>>0)>>>0)+1>>>0;e[2]=(V[(e[2]^e[1]>>>24)&255]^e[2]>>>8)>>>0};function Ra(e,b){var a,d,c,f;if(Object.keys)a=Object.keys(b);else for(d in a=[],c=0,b)a[c++]=d;c=0;for(f=a.length;c>>8&255]<<16|N[d>>>16&255]<<8|N[d>>>24&255])>>32-a:N[d]>>8-a);if(8>a+f)g=g<>a-h-1&1,8===++f&&(f=0,e[b++]=N[g],g=0,b===e.length&&(e=this.f()));e[b]=g;this.buffer=e;this.i=f;this.index=b};H.prototype.finish=function(){var d=this.buffer,a=this.index,c;0O;++O){for(var P=O,Q=P,ga=7,P=P>>>1;P;P>>>=1)Q<<=1,Q|=P&1,--ga;fa[O]=(Q<>>0}var N=fa;function ha(d){this.buffer=new (F?Uint16Array:Array)(2*d);this.length=0}ha.prototype.getParent=function(d){return 2*((d-2)/4|0)};ha.prototype.push=function(d,a){var c,e,b=this.buffer,f;c=this.length;b[this.length++]=a;for(b[this.length++]=d;0b[e])f=b[c],b[c]=b[e],b[e]=f,f=b[c+1],b[c+1]=b[e+1],b[e+1]=f,c=e;else break;return this.length}; +ha.prototype.pop=function(){var d,a,c=this.buffer,e,b,f;a=c[0];d=c[1];this.length-=2;c[0]=c[this.length];c[1]=c[this.length+1];for(f=0;;){b=2*f+2;if(b>=this.length)break;b+2c[b]&&(b+=2);if(c[b]>c[f])e=c[f],c[f]=c[b],c[b]=e,e=c[f+1],c[f+1]=c[b+1],c[b+1]=e;else break;f=b}return{index:d,value:a,length:this.length}};function R(d){var a=d.length,c=0,e=Number.POSITIVE_INFINITY,b,f,g,h,k,n,q,r,p,m;for(r=0;rc&&(c=d[r]),d[r]>=1;m=g<<16|r;for(p=n;pS;S++)switch(x){case 143>=S:oa.push([S+48,8]);break;case 255>=S:oa.push([S-144+400,9]);break;case 279>=S:oa.push([S-256+0,7]);break;case 287>=S:oa.push([S-280+192,8]);break;default:l("invalid literal: "+S)} +ia.prototype.j=function(){var d,a,c,e,b=this.input;switch(this.h){case 0:c=0;for(e=b.length;c>>8&255;p[m++]=n&255;p[m++]=n>>>8&255;if(F)p.set(f,m),m+=f.length,p=p.subarray(0,m);else{q=0;for(r=f.length;qu)for(;0< +u--;)G[E++]=0,K[0]++;else for(;0u?u:138,B>u-3&&B=B?(G[E++]=17,G[E++]=B-3,K[17]++):(G[E++]=18,G[E++]=B-11,K[18]++),u-=B;else if(G[E++]=I[t],K[I[t]]++,u--,3>u)for(;0u?u:6,B>u-3&&Bz;z++)ra[z]=ka[gb[z]];for(W=19;4=b:return[265,b-11,1];case 14>=b:return[266,b-13,1];case 16>=b:return[267,b-15,1];case 18>=b:return[268,b-17,1];case 22>=b:return[269,b-19,2];case 26>=b:return[270,b-23,2];case 30>=b:return[271,b-27,2];case 34>=b:return[272, +b-31,2];case 42>=b:return[273,b-35,3];case 50>=b:return[274,b-43,3];case 58>=b:return[275,b-51,3];case 66>=b:return[276,b-59,3];case 82>=b:return[277,b-67,4];case 98>=b:return[278,b-83,4];case 114>=b:return[279,b-99,4];case 130>=b:return[280,b-115,4];case 162>=b:return[281,b-131,5];case 194>=b:return[282,b-163,5];case 226>=b:return[283,b-195,5];case 257>=b:return[284,b-227,5];case 258===b:return[285,b-258,0];default:l("invalid length: "+b)}}var a=[],c,e;for(c=3;258>=c;c++)e=d(c),a[c]=e[2]<<24|e[1]<< +16|e[0];return a}(),wa=F?new Uint32Array(va):va; +function pa(d,a){function c(b,c){var a=b.H,d=[],e=0,f;f=wa[b.length];d[e++]=f&65535;d[e++]=f>>16&255;d[e++]=f>>24;var g;switch(x){case 1===a:g=[0,a-1,0];break;case 2===a:g=[1,a-2,0];break;case 3===a:g=[2,a-3,0];break;case 4===a:g=[3,a-4,0];break;case 6>=a:g=[4,a-5,1];break;case 8>=a:g=[5,a-7,1];break;case 12>=a:g=[6,a-9,2];break;case 16>=a:g=[7,a-13,2];break;case 24>=a:g=[8,a-17,3];break;case 32>=a:g=[9,a-25,3];break;case 48>=a:g=[10,a-33,4];break;case 64>=a:g=[11,a-49,4];break;case 96>=a:g=[12,a- +65,5];break;case 128>=a:g=[13,a-97,5];break;case 192>=a:g=[14,a-129,6];break;case 256>=a:g=[15,a-193,6];break;case 384>=a:g=[16,a-257,7];break;case 512>=a:g=[17,a-385,7];break;case 768>=a:g=[18,a-513,8];break;case 1024>=a:g=[19,a-769,8];break;case 1536>=a:g=[20,a-1025,9];break;case 2048>=a:g=[21,a-1537,9];break;case 3072>=a:g=[22,a-2049,10];break;case 4096>=a:g=[23,a-3073,10];break;case 6144>=a:g=[24,a-4097,11];break;case 8192>=a:g=[25,a-6145,11];break;case 12288>=a:g=[26,a-8193,12];break;case 16384>= +a:g=[27,a-12289,12];break;case 24576>=a:g=[28,a-16385,13];break;case 32768>=a:g=[29,a-24577,13];break;default:l("invalid distance")}f=g;d[e++]=f[0];d[e++]=f[1];d[e++]=f[2];var h,k;h=0;for(k=d.length;h=f;)w[f++]=0;for(f=0;29>=f;)y[f++]=0}w[256]=1;e=0;for(b=a.length;e=b){r&&c(r,-1);f=0;for(g=b-e;fg&&a+gf&&(b=e,f=g);if(258===g)break}return new ta(f,a-b)} +function qa(d,a){var c=d.length,e=new ha(572),b=new (F?Uint8Array:Array)(c),f,g,h,k,n;if(!F)for(k=0;k2*b[m-1]+f[m]&&(b[m]=2*b[m-1]+f[m]),h[m]=Array(b[m]),k[m]=Array(b[m]);for(p=0;pd[p]?(h[m][s]=w,k[m][s]=a,y+=2):(h[m][s]=d[p],k[m][s]=p,++p);n[m]=0;1===f[m]&&e(m)}return g} +function sa(d){var a=new (F?Uint16Array:Array)(d.length),c=[],e=[],b=0,f,g,h,k;f=0;for(g=d.length;f>>=1}return a};function T(d,a){this.l=[];this.m=32768;this.e=this.g=this.c=this.q=0;this.input=F?new Uint8Array(d):d;this.s=!1;this.n=za;this.C=!1;if(a||!(a={}))a.index&&(this.c=a.index),a.bufferSize&&(this.m=a.bufferSize),a.bufferType&&(this.n=a.bufferType),a.resize&&(this.C=a.resize);switch(this.n){case Aa:this.b=32768;this.a=new (F?Uint8Array:Array)(32768+this.m+258);break;case za:this.b=0;this.a=new (F?Uint8Array:Array)(this.m);this.f=this.K;this.t=this.I;this.o=this.J;break;default:l(Error("invalid inflate mode"))}} +var Aa=0,za=1,Ba={F:Aa,D:za}; +T.prototype.p=function(){for(;!this.s;){var d=Y(this,3);d&1&&(this.s=x);d>>>=1;switch(d){case 0:var a=this.input,c=this.c,e=this.a,b=this.b,f=a.length,g=v,h=v,k=e.length,n=v;this.e=this.g=0;c+1>=f&&l(Error("invalid uncompressed block header: LEN"));g=a[c++]|a[c++]<<8;c+1>=f&&l(Error("invalid uncompressed block header: NLEN"));h=a[c++]|a[c++]<<8;g===~h&&l(Error("invalid uncompressed block header: length verify"));c+g>a.length&&l(Error("input buffer is broken"));switch(this.n){case Aa:for(;b+g>e.length;){n= +k-b;g-=n;if(F)e.set(a.subarray(c,c+n),b),b+=n,c+=n;else for(;n--;)e[b++]=a[c++];this.b=b;e=this.f();b=this.b}break;case za:for(;b+g>e.length;)e=this.f({v:2});break;default:l(Error("invalid inflate mode"))}if(F)e.set(a.subarray(c,c+g),b),b+=g,c+=g;else for(;g--;)e[b++]=a[c++];this.c=c;this.b=b;this.a=e;break;case 1:this.o(Ca,Da);break;case 2:Sa(this);break;default:l(Error("unknown BTYPE: "+d))}}return this.t()}; +var Ta=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],Ua=F?new Uint16Array(Ta):Ta,Va=[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,258,258],Wa=F?new Uint16Array(Va):Va,Xa=[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,0,0],Ya=F?new Uint8Array(Xa):Xa,Za=[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],$a=F?new Uint16Array(Za):Za,ab=[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],bb=F?new Uint8Array(ab):ab,cb=new (F?Uint8Array:Array)(288),Z,db;Z=0;for(db=cb.length;Z=Z?8:255>=Z?9:279>=Z?7:8;var Ca=R(cb),eb=new (F?Uint8Array:Array)(30),fb,hb;fb=0;for(hb=eb.length;fb=g&&l(Error("input buffer is broken")),c|=b[f++]<>>a;d.e=e-a;d.c=f;return h} +function ib(d,a){for(var c=d.g,e=d.e,b=d.input,f=d.c,g=b.length,h=a[0],k=a[1],n,q;e=g);)c|=b[f++]<>>16;d.g=c>>q;d.e=e-q;d.c=f;return n&65535} +function Sa(d){function a(a,b,c){var d,e=this.z,f,g;for(g=0;gf)e>=b&&(this.b=e,c=this.f(),e=this.b),c[e++]=f;else{g=f-257;k=Wa[g];0=b&&(this.b=e,c=this.f(),e=this.b);for(;k--;)c[e]=c[e++-h]}for(;8<=this.e;)this.e-=8,this.c--;this.b=e}; +T.prototype.J=function(d,a){var c=this.a,e=this.b;this.u=d;for(var b=c.length,f,g,h,k;256!==(f=ib(this,d));)if(256>f)e>=b&&(c=this.f(),b=c.length),c[e++]=f;else{g=f-257;k=Wa[g];0b&&(c=this.f(),b=c.length);for(;k--;)c[e]=c[e++-h]}for(;8<=this.e;)this.e-=8,this.c--;this.b=e}; +T.prototype.f=function(){var d=new (F?Uint8Array:Array)(this.b-32768),a=this.b-32768,c,e,b=this.a;if(F)d.set(b.subarray(32768,d.length));else{c=0;for(e=d.length;cc;++c)b[c]=b[a+c];this.b=32768;return b}; +T.prototype.K=function(d){var a,c=this.input.length/this.c+1|0,e,b,f,g=this.input,h=this.a;d&&("number"===typeof d.v&&(c=d.v),"number"===typeof d.G&&(c+=d.G));2>c?(e=(g.length-this.c)/this.u[2],f=258*(e/2)|0,b=fa&&(this.a.length=a),d=this.a);return this.buffer=d};function jb(d){if("string"===typeof d){var a=d.split(""),c,e;c=0;for(e=a.length;c>>0;d=a}for(var b=1,f=0,g=d.length,h,k=0;0>>0};function kb(d,a){var c,e;this.input=d;this.c=0;if(a||!(a={}))a.index&&(this.c=a.index),a.verify&&(this.N=a.verify);c=d[this.c++];e=d[this.c++];switch(c&15){case lb:this.method=lb;break;default:l(Error("unsupported compression method"))}0!==((c<<8)+e)%31&&l(Error("invalid fcheck flag:"+((c<<8)+e)%31));e&32&&l(Error("fdict flag is not supported"));this.B=new T(d,{index:this.c,bufferSize:a.bufferSize,bufferType:a.bufferType,resize:a.resize})} +kb.prototype.p=function(){var d=this.input,a,c;a=this.B.p();this.c=this.B.c;this.N&&(c=(d[this.c++]<<24|d[this.c++]<<16|d[this.c++]<<8|d[this.c++])>>>0,c!==jb(a)&&l(Error("invalid adler-32 checksum")));return a};var lb=8;function mb(d,a){this.input=d;this.a=new (F?Uint8Array:Array)(32768);this.h=$.k;var c={},e;if((a||!(a={}))&&"number"===typeof a.compressionType)this.h=a.compressionType;for(e in a)c[e]=a[e];c.outputBuffer=this.a;this.A=new ia(this.input,c)}var $=na; +mb.prototype.j=function(){var d,a,c,e,b,f,g,h=0;g=this.a;d=lb;switch(d){case lb:a=Math.LOG2E*Math.log(32768)-8;break;default:l(Error("invalid compression method"))}c=a<<4|d;g[h++]=c;switch(d){case lb:switch(this.h){case $.NONE:b=0;break;case $.r:b=1;break;case $.k:b=2;break;default:l(Error("unsupported compression type"))}break;default:l(Error("invalid compression method"))}e=b<<6|0;g[h++]=e|31-(256*c+e)%31;f=jb(this.input);this.A.b=h;g=this.A.j();h=g.length;F&&(g=new Uint8Array(g.buffer),g.length<= +h+4&&(this.a=new Uint8Array(g.length+4),this.a.set(g),g=this.a),g=g.subarray(0,h+4));g[h++]=f>>24&255;g[h++]=f>>16&255;g[h++]=f>>8&255;g[h++]=f&255;return g};function nb(d,a){var c,e,b,f;if(Object.keys)c=Object.keys(a);else for(e in c=[],b=0,a)c[b++]=e;b=0;for(f=c.length;ba&&(this.a.length=a),d=this.a);return this.buffer=d};function jb(d){if("string"===typeof d){var a=d.split(""),c,e;c=0;for(e=a.length;c>>0;d=a}for(var b=1,f=0,g=d.length,h,k=0;0>>0};function kb(d,a){var c,e;this.input=d;this.c=0;if(a||!(a={}))a.index&&(this.c=a.index),a.verify&&(this.N=a.verify);c=d[this.c++];e=d[this.c++];switch(c&15){case lb:this.method=lb;break;default:l(Error("unsupported compression method"))}0!==((c<<8)+e)%31&&l(Error("invalid fcheck flag:"+((c<<8)+e)%31));e&32&&l(Error("fdict flag is not supported"));this.B=new T(d,{index:this.c,bufferSize:a.bufferSize,bufferType:a.bufferType,resize:a.resize})} kb.prototype.p=function(){var d=this.input,a,c;a=this.B.p();this.c=this.B.c;this.N&&(c=(d[this.c++]<<24|d[this.c++]<<16|d[this.c++]<<8|d[this.c++])>>>0,c!==jb(a)&&l(Error("invalid adler-32 checksum")));return a};var lb=8;function mb(d,a){this.input=d;this.a=new (F?Uint8Array:Array)(32768);this.h=$.k;var c={},e;if((a||!(a={}))&&"number"===typeof a.compressionType)this.h=a.compressionType;for(e in a)c[e]=a[e];c.outputBuffer=this.a;this.A=new ia(this.input,c)}var $=na; mb.prototype.j=function(){var d,a,c,e,b,f,g,h=0;g=this.a;d=lb;switch(d){case lb:a=Math.LOG2E*Math.log(32768)-8;break;default:l(Error("invalid compression method"))}c=a<<4|d;g[h++]=c;switch(d){case lb:switch(this.h){case $.NONE:b=0;break;case $.r:b=1;break;case $.k:b=2;break;default:l(Error("unsupported compression type"))}break;default:l(Error("invalid compression method"))}e=b<<6|0;g[h++]=e|31-(256*c+e)%31;f=jb(this.input);this.A.b=h;g=this.A.j();h=g.length;F&&(g=new Uint8Array(g.buffer),g.length<= -h+4&&(this.a=new Uint8Array(g.length+4),this.a.set(g),g=this.a),g=g.subarray(0,h+4));g[h++]=f>>24&255;g[h++]=f>>16&255;g[h++]=f>>8&255;g[h++]=f&255;return g};function nb(d,a){var c,e,b,f;if(Object.keys)c=Object.keys(a);else for(e in c=[],b=0,a)c[b++]=e;b=0;for(f=c.length;b>24&255;g[h++]=f>>16&255;g[h++]=f>>8&255;g[h++]=f&255;return g};function nb(d,a){var c,e,b,f;if(Object.keys)c=Object.keys(a);else for(e in c=[],b=0,a)c[b++]=e;b=0;for(f=c.length;b= 0;--i) { + var src = scripts[i].src; + var qmark = src.lastIndexOf("?"); + var l = qmark == -1 ? src.length : qmark; + if(src.substr(l - 7, 7) == "base.js") { + goog.basePath = src.substr(0, l - 7); + return + } + } + }; + goog.importScript_ = function(src) { + var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_; + if(!goog.dependencies_.written[src] && importScript(src)) { + goog.dependencies_.written[src] = true + } + }; + goog.writeScriptTag_ = function(src) { + if(goog.inHtmlDocument_()) { + var doc = goog.global.document; + doc.write('