UrgentcareCLI 0.1.1 → 0.2.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (317) hide show
  1. checksums.yaml +4 -4
  2. data/lib/UrgentCare/CLI.rb +1 -2
  3. data/lib/UrgentCare/Scraper.rb +65 -0
  4. data/lib/UrgentCare/version.rb +2 -2
  5. data/lib/UrgentCare.rb +1 -0
  6. metadata +3 -313
  7. data/.gitignore +0 -11
  8. data/.rspec +0 -3
  9. data/.travis.yml +0 -5
  10. data/CODE_OF_CONDUCT.md +0 -74
  11. data/Gemfile +0 -12
  12. data/Gemfile.lock +0 -84
  13. data/LICENSE.txt +0 -21
  14. data/Notes +0 -41
  15. data/README.md +0 -41
  16. data/Rakefile +0 -8
  17. data/UrgentCare.gemspec +0 -39
  18. data/background.jpg +0 -0
  19. data/data.txt +0 -4
  20. data/lib/Urgentcare/Scraper.rb +0 -78
  21. data/node_modules/.bin/rimraf +0 -1
  22. data/node_modules/.package-lock.json +0 -250
  23. data/node_modules/balanced-match/.github/FUNDING.yml +0 -2
  24. data/node_modules/balanced-match/LICENSE.md +0 -21
  25. data/node_modules/balanced-match/README.md +0 -97
  26. data/node_modules/balanced-match/index.js +0 -62
  27. data/node_modules/balanced-match/package.json +0 -48
  28. data/node_modules/brace-expansion/LICENSE +0 -21
  29. data/node_modules/brace-expansion/README.md +0 -129
  30. data/node_modules/brace-expansion/index.js +0 -201
  31. data/node_modules/brace-expansion/package.json +0 -47
  32. data/node_modules/concat-map/.travis.yml +0 -4
  33. data/node_modules/concat-map/LICENSE +0 -18
  34. data/node_modules/concat-map/README.markdown +0 -62
  35. data/node_modules/concat-map/example/map.js +0 -6
  36. data/node_modules/concat-map/index.js +0 -13
  37. data/node_modules/concat-map/package.json +0 -43
  38. data/node_modules/concat-map/test/map.js +0 -39
  39. data/node_modules/core-util-is/LICENSE +0 -19
  40. data/node_modules/core-util-is/README.md +0 -3
  41. data/node_modules/core-util-is/float.patch +0 -604
  42. data/node_modules/core-util-is/lib/util.js +0 -107
  43. data/node_modules/core-util-is/package.json +0 -32
  44. data/node_modules/core-util-is/test.js +0 -68
  45. data/node_modules/fs.realpath/LICENSE +0 -43
  46. data/node_modules/fs.realpath/README.md +0 -33
  47. data/node_modules/fs.realpath/index.js +0 -66
  48. data/node_modules/fs.realpath/old.js +0 -303
  49. data/node_modules/fs.realpath/package.json +0 -26
  50. data/node_modules/glob/LICENSE +0 -21
  51. data/node_modules/glob/README.md +0 -375
  52. data/node_modules/glob/changelog.md +0 -67
  53. data/node_modules/glob/common.js +0 -234
  54. data/node_modules/glob/glob.js +0 -788
  55. data/node_modules/glob/package.json +0 -51
  56. data/node_modules/glob/sync.js +0 -484
  57. data/node_modules/immediate/LICENSE.txt +0 -20
  58. data/node_modules/immediate/README.md +0 -93
  59. data/node_modules/immediate/dist/immediate.js +0 -75
  60. data/node_modules/immediate/dist/immediate.min.js +0 -1
  61. data/node_modules/immediate/lib/browser.js +0 -69
  62. data/node_modules/immediate/lib/index.js +0 -73
  63. data/node_modules/immediate/package.json +0 -42
  64. data/node_modules/inflight/LICENSE +0 -15
  65. data/node_modules/inflight/README.md +0 -37
  66. data/node_modules/inflight/inflight.js +0 -54
  67. data/node_modules/inflight/package.json +0 -29
  68. data/node_modules/inherits/LICENSE +0 -16
  69. data/node_modules/inherits/README.md +0 -42
  70. data/node_modules/inherits/inherits.js +0 -9
  71. data/node_modules/inherits/inherits_browser.js +0 -27
  72. data/node_modules/inherits/package.json +0 -29
  73. data/node_modules/isarray/.npmignore +0 -1
  74. data/node_modules/isarray/.travis.yml +0 -4
  75. data/node_modules/isarray/Makefile +0 -6
  76. data/node_modules/isarray/README.md +0 -60
  77. data/node_modules/isarray/component.json +0 -19
  78. data/node_modules/isarray/index.js +0 -5
  79. data/node_modules/isarray/package.json +0 -45
  80. data/node_modules/isarray/test.js +0 -20
  81. data/node_modules/jszip/.codeclimate.yml +0 -16
  82. data/node_modules/jszip/.editorconfig +0 -8
  83. data/node_modules/jszip/.jshintignore +0 -1
  84. data/node_modules/jszip/.jshintrc +0 -21
  85. data/node_modules/jszip/.travis.yml +0 -17
  86. data/node_modules/jszip/CHANGES.md +0 -163
  87. data/node_modules/jszip/LICENSE.markdown +0 -651
  88. data/node_modules/jszip/README.markdown +0 -35
  89. data/node_modules/jszip/dist/jszip.js +0 -30
  90. data/node_modules/jszip/dist/jszip.min.js +0 -13
  91. data/node_modules/jszip/index.d.ts +0 -270
  92. data/node_modules/jszip/lib/base64.js +0 -106
  93. data/node_modules/jszip/lib/compressedObject.js +0 -74
  94. data/node_modules/jszip/lib/compressions.js +0 -14
  95. data/node_modules/jszip/lib/crc32.js +0 -77
  96. data/node_modules/jszip/lib/defaults.js +0 -11
  97. data/node_modules/jszip/lib/external.js +0 -19
  98. data/node_modules/jszip/lib/flate.js +0 -85
  99. data/node_modules/jszip/lib/generate/ZipFileWorker.js +0 -540
  100. data/node_modules/jszip/lib/generate/index.js +0 -57
  101. data/node_modules/jszip/lib/index.js +0 -52
  102. data/node_modules/jszip/lib/license_header.js +0 -11
  103. data/node_modules/jszip/lib/load.js +0 -81
  104. data/node_modules/jszip/lib/nodejs/NodejsStreamInputAdapter.js +0 -74
  105. data/node_modules/jszip/lib/nodejs/NodejsStreamOutputAdapter.js +0 -42
  106. data/node_modules/jszip/lib/nodejsUtils.js +0 -57
  107. data/node_modules/jszip/lib/object.js +0 -389
  108. data/node_modules/jszip/lib/readable-stream-browser.js +0 -9
  109. data/node_modules/jszip/lib/reader/ArrayReader.js +0 -57
  110. data/node_modules/jszip/lib/reader/DataReader.js +0 -116
  111. data/node_modules/jszip/lib/reader/NodeBufferReader.js +0 -19
  112. data/node_modules/jszip/lib/reader/StringReader.js +0 -38
  113. data/node_modules/jszip/lib/reader/Uint8ArrayReader.js +0 -22
  114. data/node_modules/jszip/lib/reader/readerFor.js +0 -28
  115. data/node_modules/jszip/lib/signature.js +0 -7
  116. data/node_modules/jszip/lib/stream/ConvertWorker.js +0 -26
  117. data/node_modules/jszip/lib/stream/Crc32Probe.js +0 -24
  118. data/node_modules/jszip/lib/stream/DataLengthProbe.js +0 -29
  119. data/node_modules/jszip/lib/stream/DataWorker.js +0 -116
  120. data/node_modules/jszip/lib/stream/GenericWorker.js +0 -263
  121. data/node_modules/jszip/lib/stream/StreamHelper.js +0 -212
  122. data/node_modules/jszip/lib/support.js +0 -38
  123. data/node_modules/jszip/lib/utf8.js +0 -275
  124. data/node_modules/jszip/lib/utils.js +0 -476
  125. data/node_modules/jszip/lib/zipEntries.js +0 -262
  126. data/node_modules/jszip/lib/zipEntry.js +0 -294
  127. data/node_modules/jszip/lib/zipObject.js +0 -133
  128. data/node_modules/jszip/package.json +0 -63
  129. data/node_modules/jszip/vendor/FileSaver.js +0 -247
  130. data/node_modules/lie/README.md +0 -62
  131. data/node_modules/lie/dist/lie.js +0 -350
  132. data/node_modules/lie/dist/lie.min.js +0 -1
  133. data/node_modules/lie/dist/lie.polyfill.js +0 -358
  134. data/node_modules/lie/dist/lie.polyfill.min.js +0 -1
  135. data/node_modules/lie/lib/browser.js +0 -273
  136. data/node_modules/lie/lib/index.js +0 -298
  137. data/node_modules/lie/license.md +0 -7
  138. data/node_modules/lie/lie.d.ts +0 -244
  139. data/node_modules/lie/package.json +0 -69
  140. data/node_modules/lie/polyfill.js +0 -4
  141. data/node_modules/minimatch/LICENSE +0 -15
  142. data/node_modules/minimatch/README.md +0 -209
  143. data/node_modules/minimatch/minimatch.js +0 -923
  144. data/node_modules/minimatch/package.json +0 -30
  145. data/node_modules/once/LICENSE +0 -15
  146. data/node_modules/once/README.md +0 -79
  147. data/node_modules/once/once.js +0 -42
  148. data/node_modules/once/package.json +0 -33
  149. data/node_modules/pako/CHANGELOG.md +0 -164
  150. data/node_modules/pako/LICENSE +0 -21
  151. data/node_modules/pako/README.md +0 -191
  152. data/node_modules/pako/dist/pako.js +0 -6818
  153. data/node_modules/pako/dist/pako.min.js +0 -1
  154. data/node_modules/pako/dist/pako_deflate.js +0 -3997
  155. data/node_modules/pako/dist/pako_deflate.min.js +0 -1
  156. data/node_modules/pako/dist/pako_inflate.js +0 -3300
  157. data/node_modules/pako/dist/pako_inflate.min.js +0 -1
  158. data/node_modules/pako/index.js +0 -14
  159. data/node_modules/pako/lib/deflate.js +0 -400
  160. data/node_modules/pako/lib/inflate.js +0 -423
  161. data/node_modules/pako/lib/utils/common.js +0 -105
  162. data/node_modules/pako/lib/utils/strings.js +0 -187
  163. data/node_modules/pako/lib/zlib/README +0 -59
  164. data/node_modules/pako/lib/zlib/adler32.js +0 -51
  165. data/node_modules/pako/lib/zlib/constants.js +0 -68
  166. data/node_modules/pako/lib/zlib/crc32.js +0 -59
  167. data/node_modules/pako/lib/zlib/deflate.js +0 -1874
  168. data/node_modules/pako/lib/zlib/gzheader.js +0 -58
  169. data/node_modules/pako/lib/zlib/inffast.js +0 -345
  170. data/node_modules/pako/lib/zlib/inflate.js +0 -1556
  171. data/node_modules/pako/lib/zlib/inftrees.js +0 -343
  172. data/node_modules/pako/lib/zlib/messages.js +0 -32
  173. data/node_modules/pako/lib/zlib/trees.js +0 -1222
  174. data/node_modules/pako/lib/zlib/zstream.js +0 -47
  175. data/node_modules/pako/package.json +0 -44
  176. data/node_modules/path-is-absolute/index.js +0 -20
  177. data/node_modules/path-is-absolute/license +0 -21
  178. data/node_modules/path-is-absolute/package.json +0 -43
  179. data/node_modules/path-is-absolute/readme.md +0 -59
  180. data/node_modules/process-nextick-args/index.js +0 -45
  181. data/node_modules/process-nextick-args/license.md +0 -19
  182. data/node_modules/process-nextick-args/package.json +0 -25
  183. data/node_modules/process-nextick-args/readme.md +0 -18
  184. data/node_modules/readable-stream/.travis.yml +0 -34
  185. data/node_modules/readable-stream/CONTRIBUTING.md +0 -38
  186. data/node_modules/readable-stream/GOVERNANCE.md +0 -136
  187. data/node_modules/readable-stream/LICENSE +0 -47
  188. data/node_modules/readable-stream/README.md +0 -58
  189. data/node_modules/readable-stream/doc/wg-meetings/2015-01-30.md +0 -60
  190. data/node_modules/readable-stream/duplex-browser.js +0 -1
  191. data/node_modules/readable-stream/duplex.js +0 -1
  192. data/node_modules/readable-stream/lib/_stream_duplex.js +0 -131
  193. data/node_modules/readable-stream/lib/_stream_passthrough.js +0 -47
  194. data/node_modules/readable-stream/lib/_stream_readable.js +0 -1019
  195. data/node_modules/readable-stream/lib/_stream_transform.js +0 -214
  196. data/node_modules/readable-stream/lib/_stream_writable.js +0 -687
  197. data/node_modules/readable-stream/lib/internal/streams/BufferList.js +0 -79
  198. data/node_modules/readable-stream/lib/internal/streams/destroy.js +0 -74
  199. data/node_modules/readable-stream/lib/internal/streams/stream-browser.js +0 -1
  200. data/node_modules/readable-stream/lib/internal/streams/stream.js +0 -1
  201. data/node_modules/readable-stream/package.json +0 -52
  202. data/node_modules/readable-stream/passthrough.js +0 -1
  203. data/node_modules/readable-stream/readable-browser.js +0 -7
  204. data/node_modules/readable-stream/readable.js +0 -19
  205. data/node_modules/readable-stream/transform.js +0 -1
  206. data/node_modules/readable-stream/writable-browser.js +0 -1
  207. data/node_modules/readable-stream/writable.js +0 -8
  208. data/node_modules/rimraf/LICENSE +0 -15
  209. data/node_modules/rimraf/README.md +0 -101
  210. data/node_modules/rimraf/bin.js +0 -50
  211. data/node_modules/rimraf/package.json +0 -29
  212. data/node_modules/rimraf/rimraf.js +0 -372
  213. data/node_modules/safe-buffer/LICENSE +0 -21
  214. data/node_modules/safe-buffer/README.md +0 -584
  215. data/node_modules/safe-buffer/index.d.ts +0 -187
  216. data/node_modules/safe-buffer/index.js +0 -62
  217. data/node_modules/safe-buffer/package.json +0 -37
  218. data/node_modules/selenium-webdriver/CHANGES.md +0 -1114
  219. data/node_modules/selenium-webdriver/LICENSE +0 -202
  220. data/node_modules/selenium-webdriver/NOTICE +0 -2
  221. data/node_modules/selenium-webdriver/README.md +0 -229
  222. data/node_modules/selenium-webdriver/chrome.js +0 -295
  223. data/node_modules/selenium-webdriver/chromium.js +0 -829
  224. data/node_modules/selenium-webdriver/devtools/CDPConnection.js +0 -35
  225. data/node_modules/selenium-webdriver/edge.js +0 -224
  226. data/node_modules/selenium-webdriver/example/chrome_android.js +0 -45
  227. data/node_modules/selenium-webdriver/example/chrome_mobile_emulation.js +0 -46
  228. data/node_modules/selenium-webdriver/example/firefox_channels.js +0 -84
  229. data/node_modules/selenium-webdriver/example/google_search.js +0 -50
  230. data/node_modules/selenium-webdriver/example/google_search_test.js +0 -70
  231. data/node_modules/selenium-webdriver/example/headless.js +0 -63
  232. data/node_modules/selenium-webdriver/example/logging.js +0 -64
  233. data/node_modules/selenium-webdriver/firefox.js +0 -789
  234. data/node_modules/selenium-webdriver/http/index.js +0 -324
  235. data/node_modules/selenium-webdriver/http/util.js +0 -172
  236. data/node_modules/selenium-webdriver/ie.js +0 -503
  237. data/node_modules/selenium-webdriver/index.js +0 -825
  238. data/node_modules/selenium-webdriver/io/exec.js +0 -162
  239. data/node_modules/selenium-webdriver/io/index.js +0 -348
  240. data/node_modules/selenium-webdriver/io/zip.js +0 -223
  241. data/node_modules/selenium-webdriver/lib/atoms/find-elements.js +0 -123
  242. data/node_modules/selenium-webdriver/lib/atoms/get-attribute.js +0 -101
  243. data/node_modules/selenium-webdriver/lib/atoms/is-displayed.js +0 -101
  244. data/node_modules/selenium-webdriver/lib/atoms/mutation-listener.js +0 -55
  245. data/node_modules/selenium-webdriver/lib/by.js +0 -415
  246. data/node_modules/selenium-webdriver/lib/capabilities.js +0 -553
  247. data/node_modules/selenium-webdriver/lib/command.js +0 -206
  248. data/node_modules/selenium-webdriver/lib/error.js +0 -605
  249. data/node_modules/selenium-webdriver/lib/http.js +0 -704
  250. data/node_modules/selenium-webdriver/lib/input.js +0 -946
  251. data/node_modules/selenium-webdriver/lib/logging.js +0 -661
  252. data/node_modules/selenium-webdriver/lib/promise.js +0 -285
  253. data/node_modules/selenium-webdriver/lib/proxy.js +0 -212
  254. data/node_modules/selenium-webdriver/lib/session.js +0 -77
  255. data/node_modules/selenium-webdriver/lib/symbols.js +0 -37
  256. data/node_modules/selenium-webdriver/lib/until.js +0 -429
  257. data/node_modules/selenium-webdriver/lib/webdriver.js +0 -2919
  258. data/node_modules/selenium-webdriver/net/index.js +0 -107
  259. data/node_modules/selenium-webdriver/net/portprober.js +0 -75
  260. data/node_modules/selenium-webdriver/opera.js +0 -406
  261. data/node_modules/selenium-webdriver/package.json +0 -54
  262. data/node_modules/selenium-webdriver/proxy.js +0 -32
  263. data/node_modules/selenium-webdriver/remote/index.js +0 -624
  264. data/node_modules/selenium-webdriver/safari.js +0 -168
  265. data/node_modules/selenium-webdriver/testing/index.js +0 -504
  266. data/node_modules/set-immediate-shim/index.js +0 -7
  267. data/node_modules/set-immediate-shim/package.json +0 -34
  268. data/node_modules/set-immediate-shim/readme.md +0 -31
  269. data/node_modules/string_decoder/.travis.yml +0 -50
  270. data/node_modules/string_decoder/LICENSE +0 -48
  271. data/node_modules/string_decoder/README.md +0 -47
  272. data/node_modules/string_decoder/lib/string_decoder.js +0 -296
  273. data/node_modules/string_decoder/package.json +0 -31
  274. data/node_modules/tmp/CHANGELOG.md +0 -288
  275. data/node_modules/tmp/LICENSE +0 -21
  276. data/node_modules/tmp/README.md +0 -365
  277. data/node_modules/tmp/lib/tmp.js +0 -780
  278. data/node_modules/tmp/node_modules/.bin/rimraf +0 -1
  279. data/node_modules/tmp/node_modules/rimraf/CHANGELOG.md +0 -65
  280. data/node_modules/tmp/node_modules/rimraf/LICENSE +0 -15
  281. data/node_modules/tmp/node_modules/rimraf/README.md +0 -101
  282. data/node_modules/tmp/node_modules/rimraf/bin.js +0 -68
  283. data/node_modules/tmp/node_modules/rimraf/package.json +0 -32
  284. data/node_modules/tmp/node_modules/rimraf/rimraf.js +0 -360
  285. data/node_modules/tmp/package.json +0 -58
  286. data/node_modules/util-deprecate/History.md +0 -16
  287. data/node_modules/util-deprecate/LICENSE +0 -24
  288. data/node_modules/util-deprecate/README.md +0 -53
  289. data/node_modules/util-deprecate/browser.js +0 -67
  290. data/node_modules/util-deprecate/node.js +0 -6
  291. data/node_modules/util-deprecate/package.json +0 -27
  292. data/node_modules/wrappy/LICENSE +0 -15
  293. data/node_modules/wrappy/README.md +0 -36
  294. data/node_modules/wrappy/package.json +0 -29
  295. data/node_modules/wrappy/wrappy.js +0 -33
  296. data/node_modules/ws/LICENSE +0 -21
  297. data/node_modules/ws/README.md +0 -496
  298. data/node_modules/ws/browser.js +0 -8
  299. data/node_modules/ws/index.js +0 -10
  300. data/node_modules/ws/lib/buffer-util.js +0 -129
  301. data/node_modules/ws/lib/constants.js +0 -10
  302. data/node_modules/ws/lib/event-target.js +0 -184
  303. data/node_modules/ws/lib/extension.js +0 -223
  304. data/node_modules/ws/lib/limiter.js +0 -55
  305. data/node_modules/ws/lib/permessage-deflate.js +0 -517
  306. data/node_modules/ws/lib/receiver.js +0 -507
  307. data/node_modules/ws/lib/sender.js +0 -405
  308. data/node_modules/ws/lib/stream.js +0 -165
  309. data/node_modules/ws/lib/validation.js +0 -104
  310. data/node_modules/ws/lib/websocket-server.js +0 -418
  311. data/node_modules/ws/lib/websocket.js +0 -942
  312. data/node_modules/ws/package.json +0 -56
  313. data/package-lock.json +0 -458
  314. data/package.json +0 -5
  315. data/selenium.log +0 -1
  316. data/spec.md +0 -6
  317. data/test.data +0 -2110
@@ -1,343 +0,0 @@
1
- 'use strict';
2
-
3
- // (C) 1995-2013 Jean-loup Gailly and Mark Adler
4
- // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5
- //
6
- // This software is provided 'as-is', without any express or implied
7
- // warranty. In no event will the authors be held liable for any damages
8
- // arising from the use of this software.
9
- //
10
- // Permission is granted to anyone to use this software for any purpose,
11
- // including commercial applications, and to alter it and redistribute it
12
- // freely, subject to the following restrictions:
13
- //
14
- // 1. The origin of this software must not be misrepresented; you must not
15
- // claim that you wrote the original software. If you use this software
16
- // in a product, an acknowledgment in the product documentation would be
17
- // appreciated but is not required.
18
- // 2. Altered source versions must be plainly marked as such, and must not be
19
- // misrepresented as being the original software.
20
- // 3. This notice may not be removed or altered from any source distribution.
21
-
22
- var utils = require('../utils/common');
23
-
24
- var MAXBITS = 15;
25
- var ENOUGH_LENS = 852;
26
- var ENOUGH_DISTS = 592;
27
- //var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
28
-
29
- var CODES = 0;
30
- var LENS = 1;
31
- var DISTS = 2;
32
-
33
- var lbase = [ /* Length codes 257..285 base */
34
- 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35
- 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
36
- ];
37
-
38
- var lext = [ /* Length codes 257..285 extra */
39
- 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
40
- 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
41
- ];
42
-
43
- var dbase = [ /* Distance codes 0..29 base */
44
- 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
45
- 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
46
- 8193, 12289, 16385, 24577, 0, 0
47
- ];
48
-
49
- var dext = [ /* Distance codes 0..29 extra */
50
- 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
51
- 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
52
- 28, 28, 29, 29, 64, 64
53
- ];
54
-
55
- module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
56
- {
57
- var bits = opts.bits;
58
- //here = opts.here; /* table entry for duplication */
59
-
60
- var len = 0; /* a code's length in bits */
61
- var sym = 0; /* index of code symbols */
62
- var min = 0, max = 0; /* minimum and maximum code lengths */
63
- var root = 0; /* number of index bits for root table */
64
- var curr = 0; /* number of index bits for current table */
65
- var drop = 0; /* code bits to drop for sub-table */
66
- var left = 0; /* number of prefix codes available */
67
- var used = 0; /* code entries in table used */
68
- var huff = 0; /* Huffman code */
69
- var incr; /* for incrementing code, index */
70
- var fill; /* index for replicating entries */
71
- var low; /* low bits for current root entry */
72
- var mask; /* mask for low root bits */
73
- var next; /* next available space in table */
74
- var base = null; /* base value table to use */
75
- var base_index = 0;
76
- // var shoextra; /* extra bits table to use */
77
- var end; /* use base and extra for symbol > end */
78
- var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
79
- var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
80
- var extra = null;
81
- var extra_index = 0;
82
-
83
- var here_bits, here_op, here_val;
84
-
85
- /*
86
- Process a set of code lengths to create a canonical Huffman code. The
87
- code lengths are lens[0..codes-1]. Each length corresponds to the
88
- symbols 0..codes-1. The Huffman code is generated by first sorting the
89
- symbols by length from short to long, and retaining the symbol order
90
- for codes with equal lengths. Then the code starts with all zero bits
91
- for the first code of the shortest length, and the codes are integer
92
- increments for the same length, and zeros are appended as the length
93
- increases. For the deflate format, these bits are stored backwards
94
- from their more natural integer increment ordering, and so when the
95
- decoding tables are built in the large loop below, the integer codes
96
- are incremented backwards.
97
-
98
- This routine assumes, but does not check, that all of the entries in
99
- lens[] are in the range 0..MAXBITS. The caller must assure this.
100
- 1..MAXBITS is interpreted as that code length. zero means that that
101
- symbol does not occur in this code.
102
-
103
- The codes are sorted by computing a count of codes for each length,
104
- creating from that a table of starting indices for each length in the
105
- sorted table, and then entering the symbols in order in the sorted
106
- table. The sorted table is work[], with that space being provided by
107
- the caller.
108
-
109
- The length counts are used for other purposes as well, i.e. finding
110
- the minimum and maximum length codes, determining if there are any
111
- codes at all, checking for a valid set of lengths, and looking ahead
112
- at length counts to determine sub-table sizes when building the
113
- decoding tables.
114
- */
115
-
116
- /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
117
- for (len = 0; len <= MAXBITS; len++) {
118
- count[len] = 0;
119
- }
120
- for (sym = 0; sym < codes; sym++) {
121
- count[lens[lens_index + sym]]++;
122
- }
123
-
124
- /* bound code lengths, force root to be within code lengths */
125
- root = bits;
126
- for (max = MAXBITS; max >= 1; max--) {
127
- if (count[max] !== 0) { break; }
128
- }
129
- if (root > max) {
130
- root = max;
131
- }
132
- if (max === 0) { /* no symbols to code at all */
133
- //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
134
- //table.bits[opts.table_index] = 1; //here.bits = (var char)1;
135
- //table.val[opts.table_index++] = 0; //here.val = (var short)0;
136
- table[table_index++] = (1 << 24) | (64 << 16) | 0;
137
-
138
-
139
- //table.op[opts.table_index] = 64;
140
- //table.bits[opts.table_index] = 1;
141
- //table.val[opts.table_index++] = 0;
142
- table[table_index++] = (1 << 24) | (64 << 16) | 0;
143
-
144
- opts.bits = 1;
145
- return 0; /* no symbols, but wait for decoding to report error */
146
- }
147
- for (min = 1; min < max; min++) {
148
- if (count[min] !== 0) { break; }
149
- }
150
- if (root < min) {
151
- root = min;
152
- }
153
-
154
- /* check for an over-subscribed or incomplete set of lengths */
155
- left = 1;
156
- for (len = 1; len <= MAXBITS; len++) {
157
- left <<= 1;
158
- left -= count[len];
159
- if (left < 0) {
160
- return -1;
161
- } /* over-subscribed */
162
- }
163
- if (left > 0 && (type === CODES || max !== 1)) {
164
- return -1; /* incomplete set */
165
- }
166
-
167
- /* generate offsets into symbol table for each length for sorting */
168
- offs[1] = 0;
169
- for (len = 1; len < MAXBITS; len++) {
170
- offs[len + 1] = offs[len] + count[len];
171
- }
172
-
173
- /* sort symbols by length, by symbol order within each length */
174
- for (sym = 0; sym < codes; sym++) {
175
- if (lens[lens_index + sym] !== 0) {
176
- work[offs[lens[lens_index + sym]]++] = sym;
177
- }
178
- }
179
-
180
- /*
181
- Create and fill in decoding tables. In this loop, the table being
182
- filled is at next and has curr index bits. The code being used is huff
183
- with length len. That code is converted to an index by dropping drop
184
- bits off of the bottom. For codes where len is less than drop + curr,
185
- those top drop + curr - len bits are incremented through all values to
186
- fill the table with replicated entries.
187
-
188
- root is the number of index bits for the root table. When len exceeds
189
- root, sub-tables are created pointed to by the root entry with an index
190
- of the low root bits of huff. This is saved in low to check for when a
191
- new sub-table should be started. drop is zero when the root table is
192
- being filled, and drop is root when sub-tables are being filled.
193
-
194
- When a new sub-table is needed, it is necessary to look ahead in the
195
- code lengths to determine what size sub-table is needed. The length
196
- counts are used for this, and so count[] is decremented as codes are
197
- entered in the tables.
198
-
199
- used keeps track of how many table entries have been allocated from the
200
- provided *table space. It is checked for LENS and DIST tables against
201
- the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
202
- the initial root table size constants. See the comments in inftrees.h
203
- for more information.
204
-
205
- sym increments through all symbols, and the loop terminates when
206
- all codes of length max, i.e. all codes, have been processed. This
207
- routine permits incomplete codes, so another loop after this one fills
208
- in the rest of the decoding tables with invalid code markers.
209
- */
210
-
211
- /* set up for code type */
212
- // poor man optimization - use if-else instead of switch,
213
- // to avoid deopts in old v8
214
- if (type === CODES) {
215
- base = extra = work; /* dummy value--not used */
216
- end = 19;
217
-
218
- } else if (type === LENS) {
219
- base = lbase;
220
- base_index -= 257;
221
- extra = lext;
222
- extra_index -= 257;
223
- end = 256;
224
-
225
- } else { /* DISTS */
226
- base = dbase;
227
- extra = dext;
228
- end = -1;
229
- }
230
-
231
- /* initialize opts for loop */
232
- huff = 0; /* starting code */
233
- sym = 0; /* starting code symbol */
234
- len = min; /* starting code length */
235
- next = table_index; /* current table to fill in */
236
- curr = root; /* current table index bits */
237
- drop = 0; /* current bits to drop from code for index */
238
- low = -1; /* trigger new sub-table when len > root */
239
- used = 1 << root; /* use root table entries */
240
- mask = used - 1; /* mask for comparing low */
241
-
242
- /* check available table space */
243
- if ((type === LENS && used > ENOUGH_LENS) ||
244
- (type === DISTS && used > ENOUGH_DISTS)) {
245
- return 1;
246
- }
247
-
248
- /* process all codes and make table entries */
249
- for (;;) {
250
- /* create table entry */
251
- here_bits = len - drop;
252
- if (work[sym] < end) {
253
- here_op = 0;
254
- here_val = work[sym];
255
- }
256
- else if (work[sym] > end) {
257
- here_op = extra[extra_index + work[sym]];
258
- here_val = base[base_index + work[sym]];
259
- }
260
- else {
261
- here_op = 32 + 64; /* end of block */
262
- here_val = 0;
263
- }
264
-
265
- /* replicate for those indices with low len bits equal to huff */
266
- incr = 1 << (len - drop);
267
- fill = 1 << curr;
268
- min = fill; /* save offset to next table */
269
- do {
270
- fill -= incr;
271
- table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
272
- } while (fill !== 0);
273
-
274
- /* backwards increment the len-bit code huff */
275
- incr = 1 << (len - 1);
276
- while (huff & incr) {
277
- incr >>= 1;
278
- }
279
- if (incr !== 0) {
280
- huff &= incr - 1;
281
- huff += incr;
282
- } else {
283
- huff = 0;
284
- }
285
-
286
- /* go to next symbol, update count, len */
287
- sym++;
288
- if (--count[len] === 0) {
289
- if (len === max) { break; }
290
- len = lens[lens_index + work[sym]];
291
- }
292
-
293
- /* create new sub-table if needed */
294
- if (len > root && (huff & mask) !== low) {
295
- /* if first time, transition to sub-tables */
296
- if (drop === 0) {
297
- drop = root;
298
- }
299
-
300
- /* increment past last table */
301
- next += min; /* here min is 1 << curr */
302
-
303
- /* determine length of next table */
304
- curr = len - drop;
305
- left = 1 << curr;
306
- while (curr + drop < max) {
307
- left -= count[curr + drop];
308
- if (left <= 0) { break; }
309
- curr++;
310
- left <<= 1;
311
- }
312
-
313
- /* check for enough space */
314
- used += 1 << curr;
315
- if ((type === LENS && used > ENOUGH_LENS) ||
316
- (type === DISTS && used > ENOUGH_DISTS)) {
317
- return 1;
318
- }
319
-
320
- /* point entry in root table to sub-table */
321
- low = huff & mask;
322
- /*table.op[low] = curr;
323
- table.bits[low] = root;
324
- table.val[low] = next - opts.table_index;*/
325
- table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
326
- }
327
- }
328
-
329
- /* fill in remaining table entry if code is incomplete (guaranteed to have
330
- at most one remaining entry, since if the code is incomplete, the
331
- maximum code length that was allowed to get this far is one bit) */
332
- if (huff !== 0) {
333
- //table.op[next + huff] = 64; /* invalid code marker */
334
- //table.bits[next + huff] = len - drop;
335
- //table.val[next + huff] = 0;
336
- table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
337
- }
338
-
339
- /* set return parameters */
340
- //opts.table_index += used;
341
- opts.bits = root;
342
- return 0;
343
- };
@@ -1,32 +0,0 @@
1
- 'use strict';
2
-
3
- // (C) 1995-2013 Jean-loup Gailly and Mark Adler
4
- // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5
- //
6
- // This software is provided 'as-is', without any express or implied
7
- // warranty. In no event will the authors be held liable for any damages
8
- // arising from the use of this software.
9
- //
10
- // Permission is granted to anyone to use this software for any purpose,
11
- // including commercial applications, and to alter it and redistribute it
12
- // freely, subject to the following restrictions:
13
- //
14
- // 1. The origin of this software must not be misrepresented; you must not
15
- // claim that you wrote the original software. If you use this software
16
- // in a product, an acknowledgment in the product documentation would be
17
- // appreciated but is not required.
18
- // 2. Altered source versions must be plainly marked as such, and must not be
19
- // misrepresented as being the original software.
20
- // 3. This notice may not be removed or altered from any source distribution.
21
-
22
- module.exports = {
23
- 2: 'need dictionary', /* Z_NEED_DICT 2 */
24
- 1: 'stream end', /* Z_STREAM_END 1 */
25
- 0: '', /* Z_OK 0 */
26
- '-1': 'file error', /* Z_ERRNO (-1) */
27
- '-2': 'stream error', /* Z_STREAM_ERROR (-2) */
28
- '-3': 'data error', /* Z_DATA_ERROR (-3) */
29
- '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */
30
- '-5': 'buffer error', /* Z_BUF_ERROR (-5) */
31
- '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
32
- };
@@ -1,1222 +0,0 @@
1
- 'use strict';
2
-
3
- // (C) 1995-2013 Jean-loup Gailly and Mark Adler
4
- // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
5
- //
6
- // This software is provided 'as-is', without any express or implied
7
- // warranty. In no event will the authors be held liable for any damages
8
- // arising from the use of this software.
9
- //
10
- // Permission is granted to anyone to use this software for any purpose,
11
- // including commercial applications, and to alter it and redistribute it
12
- // freely, subject to the following restrictions:
13
- //
14
- // 1. The origin of this software must not be misrepresented; you must not
15
- // claim that you wrote the original software. If you use this software
16
- // in a product, an acknowledgment in the product documentation would be
17
- // appreciated but is not required.
18
- // 2. Altered source versions must be plainly marked as such, and must not be
19
- // misrepresented as being the original software.
20
- // 3. This notice may not be removed or altered from any source distribution.
21
-
22
- /* eslint-disable space-unary-ops */
23
-
24
- var utils = require('../utils/common');
25
-
26
- /* Public constants ==========================================================*/
27
- /* ===========================================================================*/
28
-
29
-
30
- //var Z_FILTERED = 1;
31
- //var Z_HUFFMAN_ONLY = 2;
32
- //var Z_RLE = 3;
33
- var Z_FIXED = 4;
34
- //var Z_DEFAULT_STRATEGY = 0;
35
-
36
- /* Possible values of the data_type field (though see inflate()) */
37
- var Z_BINARY = 0;
38
- var Z_TEXT = 1;
39
- //var Z_ASCII = 1; // = Z_TEXT
40
- var Z_UNKNOWN = 2;
41
-
42
- /*============================================================================*/
43
-
44
-
45
- function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } }
46
-
47
- // From zutil.h
48
-
49
- var STORED_BLOCK = 0;
50
- var STATIC_TREES = 1;
51
- var DYN_TREES = 2;
52
- /* The three kinds of block type */
53
-
54
- var MIN_MATCH = 3;
55
- var MAX_MATCH = 258;
56
- /* The minimum and maximum match lengths */
57
-
58
- // From deflate.h
59
- /* ===========================================================================
60
- * Internal compression state.
61
- */
62
-
63
- var LENGTH_CODES = 29;
64
- /* number of length codes, not counting the special END_BLOCK code */
65
-
66
- var LITERALS = 256;
67
- /* number of literal bytes 0..255 */
68
-
69
- var L_CODES = LITERALS + 1 + LENGTH_CODES;
70
- /* number of Literal or Length codes, including the END_BLOCK code */
71
-
72
- var D_CODES = 30;
73
- /* number of distance codes */
74
-
75
- var BL_CODES = 19;
76
- /* number of codes used to transfer the bit lengths */
77
-
78
- var HEAP_SIZE = 2 * L_CODES + 1;
79
- /* maximum heap size */
80
-
81
- var MAX_BITS = 15;
82
- /* All codes must not exceed MAX_BITS bits */
83
-
84
- var Buf_size = 16;
85
- /* size of bit buffer in bi_buf */
86
-
87
-
88
- /* ===========================================================================
89
- * Constants
90
- */
91
-
92
- var MAX_BL_BITS = 7;
93
- /* Bit length codes must not exceed MAX_BL_BITS bits */
94
-
95
- var END_BLOCK = 256;
96
- /* end of block literal code */
97
-
98
- var REP_3_6 = 16;
99
- /* repeat previous bit length 3-6 times (2 bits of repeat count) */
100
-
101
- var REPZ_3_10 = 17;
102
- /* repeat a zero length 3-10 times (3 bits of repeat count) */
103
-
104
- var REPZ_11_138 = 18;
105
- /* repeat a zero length 11-138 times (7 bits of repeat count) */
106
-
107
- /* eslint-disable comma-spacing,array-bracket-spacing */
108
- var extra_lbits = /* extra bits for each length code */
109
- [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];
110
-
111
- var extra_dbits = /* extra bits for each distance code */
112
- [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];
113
-
114
- var extra_blbits = /* extra bits for each bit length code */
115
- [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7];
116
-
117
- var bl_order =
118
- [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
119
- /* eslint-enable comma-spacing,array-bracket-spacing */
120
-
121
- /* The lengths of the bit length codes are sent in order of decreasing
122
- * probability, to avoid transmitting the lengths for unused bit length codes.
123
- */
124
-
125
- /* ===========================================================================
126
- * Local data. These are initialized only once.
127
- */
128
-
129
- // We pre-fill arrays with 0 to avoid uninitialized gaps
130
-
131
- var DIST_CODE_LEN = 512; /* see definition of array dist_code below */
132
-
133
- // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1
134
- var static_ltree = new Array((L_CODES + 2) * 2);
135
- zero(static_ltree);
136
- /* The static literal tree. Since the bit lengths are imposed, there is no
137
- * need for the L_CODES extra codes used during heap construction. However
138
- * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
139
- * below).
140
- */
141
-
142
- var static_dtree = new Array(D_CODES * 2);
143
- zero(static_dtree);
144
- /* The static distance tree. (Actually a trivial tree since all codes use
145
- * 5 bits.)
146
- */
147
-
148
- var _dist_code = new Array(DIST_CODE_LEN);
149
- zero(_dist_code);
150
- /* Distance codes. The first 256 values correspond to the distances
151
- * 3 .. 258, the last 256 values correspond to the top 8 bits of
152
- * the 15 bit distances.
153
- */
154
-
155
- var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
156
- zero(_length_code);
157
- /* length code for each normalized match length (0 == MIN_MATCH) */
158
-
159
- var base_length = new Array(LENGTH_CODES);
160
- zero(base_length);
161
- /* First normalized length for each code (0 = MIN_MATCH) */
162
-
163
- var base_dist = new Array(D_CODES);
164
- zero(base_dist);
165
- /* First normalized distance for each code (0 = distance of 1) */
166
-
167
-
168
- function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
169
-
170
- this.static_tree = static_tree; /* static tree or NULL */
171
- this.extra_bits = extra_bits; /* extra bits for each code or NULL */
172
- this.extra_base = extra_base; /* base index for extra_bits */
173
- this.elems = elems; /* max number of elements in the tree */
174
- this.max_length = max_length; /* max bit length for the codes */
175
-
176
- // show if `static_tree` has data or dummy - needed for monomorphic objects
177
- this.has_stree = static_tree && static_tree.length;
178
- }
179
-
180
-
181
- var static_l_desc;
182
- var static_d_desc;
183
- var static_bl_desc;
184
-
185
-
186
- function TreeDesc(dyn_tree, stat_desc) {
187
- this.dyn_tree = dyn_tree; /* the dynamic tree */
188
- this.max_code = 0; /* largest code with non zero frequency */
189
- this.stat_desc = stat_desc; /* the corresponding static tree */
190
- }
191
-
192
-
193
-
194
- function d_code(dist) {
195
- return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
196
- }
197
-
198
-
199
- /* ===========================================================================
200
- * Output a short LSB first on the stream.
201
- * IN assertion: there is enough room in pendingBuf.
202
- */
203
- function put_short(s, w) {
204
- // put_byte(s, (uch)((w) & 0xff));
205
- // put_byte(s, (uch)((ush)(w) >> 8));
206
- s.pending_buf[s.pending++] = (w) & 0xff;
207
- s.pending_buf[s.pending++] = (w >>> 8) & 0xff;
208
- }
209
-
210
-
211
- /* ===========================================================================
212
- * Send a value on a given number of bits.
213
- * IN assertion: length <= 16 and value fits in length bits.
214
- */
215
- function send_bits(s, value, length) {
216
- if (s.bi_valid > (Buf_size - length)) {
217
- s.bi_buf |= (value << s.bi_valid) & 0xffff;
218
- put_short(s, s.bi_buf);
219
- s.bi_buf = value >> (Buf_size - s.bi_valid);
220
- s.bi_valid += length - Buf_size;
221
- } else {
222
- s.bi_buf |= (value << s.bi_valid) & 0xffff;
223
- s.bi_valid += length;
224
- }
225
- }
226
-
227
-
228
- function send_code(s, c, tree) {
229
- send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/);
230
- }
231
-
232
-
233
- /* ===========================================================================
234
- * Reverse the first len bits of a code, using straightforward code (a faster
235
- * method would use a table)
236
- * IN assertion: 1 <= len <= 15
237
- */
238
- function bi_reverse(code, len) {
239
- var res = 0;
240
- do {
241
- res |= code & 1;
242
- code >>>= 1;
243
- res <<= 1;
244
- } while (--len > 0);
245
- return res >>> 1;
246
- }
247
-
248
-
249
- /* ===========================================================================
250
- * Flush the bit buffer, keeping at most 7 bits in it.
251
- */
252
- function bi_flush(s) {
253
- if (s.bi_valid === 16) {
254
- put_short(s, s.bi_buf);
255
- s.bi_buf = 0;
256
- s.bi_valid = 0;
257
-
258
- } else if (s.bi_valid >= 8) {
259
- s.pending_buf[s.pending++] = s.bi_buf & 0xff;
260
- s.bi_buf >>= 8;
261
- s.bi_valid -= 8;
262
- }
263
- }
264
-
265
-
266
- /* ===========================================================================
267
- * Compute the optimal bit lengths for a tree and update the total bit length
268
- * for the current block.
269
- * IN assertion: the fields freq and dad are set, heap[heap_max] and
270
- * above are the tree nodes sorted by increasing frequency.
271
- * OUT assertions: the field len is set to the optimal bit length, the
272
- * array bl_count contains the frequencies for each bit length.
273
- * The length opt_len is updated; static_len is also updated if stree is
274
- * not null.
275
- */
276
- function gen_bitlen(s, desc)
277
- // deflate_state *s;
278
- // tree_desc *desc; /* the tree descriptor */
279
- {
280
- var tree = desc.dyn_tree;
281
- var max_code = desc.max_code;
282
- var stree = desc.stat_desc.static_tree;
283
- var has_stree = desc.stat_desc.has_stree;
284
- var extra = desc.stat_desc.extra_bits;
285
- var base = desc.stat_desc.extra_base;
286
- var max_length = desc.stat_desc.max_length;
287
- var h; /* heap index */
288
- var n, m; /* iterate over the tree elements */
289
- var bits; /* bit length */
290
- var xbits; /* extra bits */
291
- var f; /* frequency */
292
- var overflow = 0; /* number of elements with bit length too large */
293
-
294
- for (bits = 0; bits <= MAX_BITS; bits++) {
295
- s.bl_count[bits] = 0;
296
- }
297
-
298
- /* In a first pass, compute the optimal bit lengths (which may
299
- * overflow in the case of the bit length tree).
300
- */
301
- tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */
302
-
303
- for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
304
- n = s.heap[h];
305
- bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1;
306
- if (bits > max_length) {
307
- bits = max_length;
308
- overflow++;
309
- }
310
- tree[n * 2 + 1]/*.Len*/ = bits;
311
- /* We overwrite tree[n].Dad which is no longer needed */
312
-
313
- if (n > max_code) { continue; } /* not a leaf node */
314
-
315
- s.bl_count[bits]++;
316
- xbits = 0;
317
- if (n >= base) {
318
- xbits = extra[n - base];
319
- }
320
- f = tree[n * 2]/*.Freq*/;
321
- s.opt_len += f * (bits + xbits);
322
- if (has_stree) {
323
- s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits);
324
- }
325
- }
326
- if (overflow === 0) { return; }
327
-
328
- // Trace((stderr,"\nbit length overflow\n"));
329
- /* This happens for example on obj2 and pic of the Calgary corpus */
330
-
331
- /* Find the first bit length which could increase: */
332
- do {
333
- bits = max_length - 1;
334
- while (s.bl_count[bits] === 0) { bits--; }
335
- s.bl_count[bits]--; /* move one leaf down the tree */
336
- s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */
337
- s.bl_count[max_length]--;
338
- /* The brother of the overflow item also moves one step up,
339
- * but this does not affect bl_count[max_length]
340
- */
341
- overflow -= 2;
342
- } while (overflow > 0);
343
-
344
- /* Now recompute all bit lengths, scanning in increasing frequency.
345
- * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
346
- * lengths instead of fixing only the wrong ones. This idea is taken
347
- * from 'ar' written by Haruhiko Okumura.)
348
- */
349
- for (bits = max_length; bits !== 0; bits--) {
350
- n = s.bl_count[bits];
351
- while (n !== 0) {
352
- m = s.heap[--h];
353
- if (m > max_code) { continue; }
354
- if (tree[m * 2 + 1]/*.Len*/ !== bits) {
355
- // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
356
- s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/;
357
- tree[m * 2 + 1]/*.Len*/ = bits;
358
- }
359
- n--;
360
- }
361
- }
362
- }
363
-
364
-
365
- /* ===========================================================================
366
- * Generate the codes for a given tree and bit counts (which need not be
367
- * optimal).
368
- * IN assertion: the array bl_count contains the bit length statistics for
369
- * the given tree and the field len is set for all tree elements.
370
- * OUT assertion: the field code is set for all tree elements of non
371
- * zero code length.
372
- */
373
- function gen_codes(tree, max_code, bl_count)
374
- // ct_data *tree; /* the tree to decorate */
375
- // int max_code; /* largest code with non zero frequency */
376
- // ushf *bl_count; /* number of codes at each bit length */
377
- {
378
- var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */
379
- var code = 0; /* running code value */
380
- var bits; /* bit index */
381
- var n; /* code index */
382
-
383
- /* The distribution counts are first used to generate the code values
384
- * without bit reversal.
385
- */
386
- for (bits = 1; bits <= MAX_BITS; bits++) {
387
- next_code[bits] = code = (code + bl_count[bits - 1]) << 1;
388
- }
389
- /* Check that the bit counts in bl_count are consistent. The last code
390
- * must be all ones.
391
- */
392
- //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
393
- // "inconsistent bit counts");
394
- //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
395
-
396
- for (n = 0; n <= max_code; n++) {
397
- var len = tree[n * 2 + 1]/*.Len*/;
398
- if (len === 0) { continue; }
399
- /* Now reverse the bits */
400
- tree[n * 2]/*.Code*/ = bi_reverse(next_code[len]++, len);
401
-
402
- //Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
403
- // n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
404
- }
405
- }
406
-
407
-
408
- /* ===========================================================================
409
- * Initialize the various 'constant' tables.
410
- */
411
- function tr_static_init() {
412
- var n; /* iterates over tree elements */
413
- var bits; /* bit counter */
414
- var length; /* length value */
415
- var code; /* code value */
416
- var dist; /* distance index */
417
- var bl_count = new Array(MAX_BITS + 1);
418
- /* number of codes at each bit length for an optimal tree */
419
-
420
- // do check in _tr_init()
421
- //if (static_init_done) return;
422
-
423
- /* For some embedded targets, global variables are not initialized: */
424
- /*#ifdef NO_INIT_GLOBAL_POINTERS
425
- static_l_desc.static_tree = static_ltree;
426
- static_l_desc.extra_bits = extra_lbits;
427
- static_d_desc.static_tree = static_dtree;
428
- static_d_desc.extra_bits = extra_dbits;
429
- static_bl_desc.extra_bits = extra_blbits;
430
- #endif*/
431
-
432
- /* Initialize the mapping length (0..255) -> length code (0..28) */
433
- length = 0;
434
- for (code = 0; code < LENGTH_CODES - 1; code++) {
435
- base_length[code] = length;
436
- for (n = 0; n < (1 << extra_lbits[code]); n++) {
437
- _length_code[length++] = code;
438
- }
439
- }
440
- //Assert (length == 256, "tr_static_init: length != 256");
441
- /* Note that the length 255 (match length 258) can be represented
442
- * in two different ways: code 284 + 5 bits or code 285, so we
443
- * overwrite length_code[255] to use the best encoding:
444
- */
445
- _length_code[length - 1] = code;
446
-
447
- /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
448
- dist = 0;
449
- for (code = 0; code < 16; code++) {
450
- base_dist[code] = dist;
451
- for (n = 0; n < (1 << extra_dbits[code]); n++) {
452
- _dist_code[dist++] = code;
453
- }
454
- }
455
- //Assert (dist == 256, "tr_static_init: dist != 256");
456
- dist >>= 7; /* from now on, all distances are divided by 128 */
457
- for (; code < D_CODES; code++) {
458
- base_dist[code] = dist << 7;
459
- for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) {
460
- _dist_code[256 + dist++] = code;
461
- }
462
- }
463
- //Assert (dist == 256, "tr_static_init: 256+dist != 512");
464
-
465
- /* Construct the codes of the static literal tree */
466
- for (bits = 0; bits <= MAX_BITS; bits++) {
467
- bl_count[bits] = 0;
468
- }
469
-
470
- n = 0;
471
- while (n <= 143) {
472
- static_ltree[n * 2 + 1]/*.Len*/ = 8;
473
- n++;
474
- bl_count[8]++;
475
- }
476
- while (n <= 255) {
477
- static_ltree[n * 2 + 1]/*.Len*/ = 9;
478
- n++;
479
- bl_count[9]++;
480
- }
481
- while (n <= 279) {
482
- static_ltree[n * 2 + 1]/*.Len*/ = 7;
483
- n++;
484
- bl_count[7]++;
485
- }
486
- while (n <= 287) {
487
- static_ltree[n * 2 + 1]/*.Len*/ = 8;
488
- n++;
489
- bl_count[8]++;
490
- }
491
- /* Codes 286 and 287 do not exist, but we must include them in the
492
- * tree construction to get a canonical Huffman tree (longest code
493
- * all ones)
494
- */
495
- gen_codes(static_ltree, L_CODES + 1, bl_count);
496
-
497
- /* The static distance tree is trivial: */
498
- for (n = 0; n < D_CODES; n++) {
499
- static_dtree[n * 2 + 1]/*.Len*/ = 5;
500
- static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5);
501
- }
502
-
503
- // Now data ready and we can init static trees
504
- static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
505
- static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
506
- static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
507
-
508
- //static_init_done = true;
509
- }
510
-
511
-
512
- /* ===========================================================================
513
- * Initialize a new block.
514
- */
515
- function init_block(s) {
516
- var n; /* iterates over tree elements */
517
-
518
- /* Initialize the trees. */
519
- for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; }
520
- for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; }
521
- for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; }
522
-
523
- s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1;
524
- s.opt_len = s.static_len = 0;
525
- s.last_lit = s.matches = 0;
526
- }
527
-
528
-
529
- /* ===========================================================================
530
- * Flush the bit buffer and align the output on a byte boundary
531
- */
532
- function bi_windup(s)
533
- {
534
- if (s.bi_valid > 8) {
535
- put_short(s, s.bi_buf);
536
- } else if (s.bi_valid > 0) {
537
- //put_byte(s, (Byte)s->bi_buf);
538
- s.pending_buf[s.pending++] = s.bi_buf;
539
- }
540
- s.bi_buf = 0;
541
- s.bi_valid = 0;
542
- }
543
-
544
- /* ===========================================================================
545
- * Copy a stored block, storing first the length and its
546
- * one's complement if requested.
547
- */
548
- function copy_block(s, buf, len, header)
549
- //DeflateState *s;
550
- //charf *buf; /* the input data */
551
- //unsigned len; /* its length */
552
- //int header; /* true if block header must be written */
553
- {
554
- bi_windup(s); /* align on byte boundary */
555
-
556
- if (header) {
557
- put_short(s, len);
558
- put_short(s, ~len);
559
- }
560
- // while (len--) {
561
- // put_byte(s, *buf++);
562
- // }
563
- utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
564
- s.pending += len;
565
- }
566
-
567
- /* ===========================================================================
568
- * Compares to subtrees, using the tree depth as tie breaker when
569
- * the subtrees have equal frequency. This minimizes the worst case length.
570
- */
571
- function smaller(tree, n, m, depth) {
572
- var _n2 = n * 2;
573
- var _m2 = m * 2;
574
- return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ ||
575
- (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m]));
576
- }
577
-
578
- /* ===========================================================================
579
- * Restore the heap property by moving down the tree starting at node k,
580
- * exchanging a node with the smallest of its two sons if necessary, stopping
581
- * when the heap property is re-established (each father smaller than its
582
- * two sons).
583
- */
584
- function pqdownheap(s, tree, k)
585
- // deflate_state *s;
586
- // ct_data *tree; /* the tree to restore */
587
- // int k; /* node to move down */
588
- {
589
- var v = s.heap[k];
590
- var j = k << 1; /* left son of k */
591
- while (j <= s.heap_len) {
592
- /* Set j to the smallest of the two sons: */
593
- if (j < s.heap_len &&
594
- smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
595
- j++;
596
- }
597
- /* Exit if v is smaller than both sons */
598
- if (smaller(tree, v, s.heap[j], s.depth)) { break; }
599
-
600
- /* Exchange v with the smallest son */
601
- s.heap[k] = s.heap[j];
602
- k = j;
603
-
604
- /* And continue down the tree, setting j to the left son of k */
605
- j <<= 1;
606
- }
607
- s.heap[k] = v;
608
- }
609
-
610
-
611
- // inlined manually
612
- // var SMALLEST = 1;
613
-
614
- /* ===========================================================================
615
- * Send the block data compressed using the given Huffman trees
616
- */
617
- function compress_block(s, ltree, dtree)
618
- // deflate_state *s;
619
- // const ct_data *ltree; /* literal tree */
620
- // const ct_data *dtree; /* distance tree */
621
- {
622
- var dist; /* distance of matched string */
623
- var lc; /* match length or unmatched char (if dist == 0) */
624
- var lx = 0; /* running index in l_buf */
625
- var code; /* the code to send */
626
- var extra; /* number of extra bits to send */
627
-
628
- if (s.last_lit !== 0) {
629
- do {
630
- dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]);
631
- lc = s.pending_buf[s.l_buf + lx];
632
- lx++;
633
-
634
- if (dist === 0) {
635
- send_code(s, lc, ltree); /* send a literal byte */
636
- //Tracecv(isgraph(lc), (stderr," '%c' ", lc));
637
- } else {
638
- /* Here, lc is the match length - MIN_MATCH */
639
- code = _length_code[lc];
640
- send_code(s, code + LITERALS + 1, ltree); /* send the length code */
641
- extra = extra_lbits[code];
642
- if (extra !== 0) {
643
- lc -= base_length[code];
644
- send_bits(s, lc, extra); /* send the extra length bits */
645
- }
646
- dist--; /* dist is now the match distance - 1 */
647
- code = d_code(dist);
648
- //Assert (code < D_CODES, "bad d_code");
649
-
650
- send_code(s, code, dtree); /* send the distance code */
651
- extra = extra_dbits[code];
652
- if (extra !== 0) {
653
- dist -= base_dist[code];
654
- send_bits(s, dist, extra); /* send the extra distance bits */
655
- }
656
- } /* literal or match pair ? */
657
-
658
- /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
659
- //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
660
- // "pendingBuf overflow");
661
-
662
- } while (lx < s.last_lit);
663
- }
664
-
665
- send_code(s, END_BLOCK, ltree);
666
- }
667
-
668
-
669
- /* ===========================================================================
670
- * Construct one Huffman tree and assigns the code bit strings and lengths.
671
- * Update the total bit length for the current block.
672
- * IN assertion: the field freq is set for all tree elements.
673
- * OUT assertions: the fields len and code are set to the optimal bit length
674
- * and corresponding code. The length opt_len is updated; static_len is
675
- * also updated if stree is not null. The field max_code is set.
676
- */
677
- function build_tree(s, desc)
678
- // deflate_state *s;
679
- // tree_desc *desc; /* the tree descriptor */
680
- {
681
- var tree = desc.dyn_tree;
682
- var stree = desc.stat_desc.static_tree;
683
- var has_stree = desc.stat_desc.has_stree;
684
- var elems = desc.stat_desc.elems;
685
- var n, m; /* iterate over heap elements */
686
- var max_code = -1; /* largest code with non zero frequency */
687
- var node; /* new node being created */
688
-
689
- /* Construct the initial heap, with least frequent element in
690
- * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
691
- * heap[0] is not used.
692
- */
693
- s.heap_len = 0;
694
- s.heap_max = HEAP_SIZE;
695
-
696
- for (n = 0; n < elems; n++) {
697
- if (tree[n * 2]/*.Freq*/ !== 0) {
698
- s.heap[++s.heap_len] = max_code = n;
699
- s.depth[n] = 0;
700
-
701
- } else {
702
- tree[n * 2 + 1]/*.Len*/ = 0;
703
- }
704
- }
705
-
706
- /* The pkzip format requires that at least one distance code exists,
707
- * and that at least one bit should be sent even if there is only one
708
- * possible code. So to avoid special checks later on we force at least
709
- * two codes of non zero frequency.
710
- */
711
- while (s.heap_len < 2) {
712
- node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
713
- tree[node * 2]/*.Freq*/ = 1;
714
- s.depth[node] = 0;
715
- s.opt_len--;
716
-
717
- if (has_stree) {
718
- s.static_len -= stree[node * 2 + 1]/*.Len*/;
719
- }
720
- /* node is 0 or 1 so it does not have extra bits */
721
- }
722
- desc.max_code = max_code;
723
-
724
- /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
725
- * establish sub-heaps of increasing lengths:
726
- */
727
- for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); }
728
-
729
- /* Construct the Huffman tree by repeatedly combining the least two
730
- * frequent nodes.
731
- */
732
- node = elems; /* next internal node of the tree */
733
- do {
734
- //pqremove(s, tree, n); /* n = node of least frequency */
735
- /*** pqremove ***/
736
- n = s.heap[1/*SMALLEST*/];
737
- s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--];
738
- pqdownheap(s, tree, 1/*SMALLEST*/);
739
- /***/
740
-
741
- m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */
742
-
743
- s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */
744
- s.heap[--s.heap_max] = m;
745
-
746
- /* Create a new node father of n and m */
747
- tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/;
748
- s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
749
- tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node;
750
-
751
- /* and insert the new node in the heap */
752
- s.heap[1/*SMALLEST*/] = node++;
753
- pqdownheap(s, tree, 1/*SMALLEST*/);
754
-
755
- } while (s.heap_len >= 2);
756
-
757
- s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/];
758
-
759
- /* At this point, the fields freq and dad are set. We can now
760
- * generate the bit lengths.
761
- */
762
- gen_bitlen(s, desc);
763
-
764
- /* The field len is now set, we can generate the bit codes */
765
- gen_codes(tree, max_code, s.bl_count);
766
- }
767
-
768
-
769
- /* ===========================================================================
770
- * Scan a literal or distance tree to determine the frequencies of the codes
771
- * in the bit length tree.
772
- */
773
- function scan_tree(s, tree, max_code)
774
- // deflate_state *s;
775
- // ct_data *tree; /* the tree to be scanned */
776
- // int max_code; /* and its largest code of non zero frequency */
777
- {
778
- var n; /* iterates over all tree elements */
779
- var prevlen = -1; /* last emitted length */
780
- var curlen; /* length of current code */
781
-
782
- var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
783
-
784
- var count = 0; /* repeat count of the current code */
785
- var max_count = 7; /* max repeat count */
786
- var min_count = 4; /* min repeat count */
787
-
788
- if (nextlen === 0) {
789
- max_count = 138;
790
- min_count = 3;
791
- }
792
- tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */
793
-
794
- for (n = 0; n <= max_code; n++) {
795
- curlen = nextlen;
796
- nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
797
-
798
- if (++count < max_count && curlen === nextlen) {
799
- continue;
800
-
801
- } else if (count < min_count) {
802
- s.bl_tree[curlen * 2]/*.Freq*/ += count;
803
-
804
- } else if (curlen !== 0) {
805
-
806
- if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; }
807
- s.bl_tree[REP_3_6 * 2]/*.Freq*/++;
808
-
809
- } else if (count <= 10) {
810
- s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++;
811
-
812
- } else {
813
- s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++;
814
- }
815
-
816
- count = 0;
817
- prevlen = curlen;
818
-
819
- if (nextlen === 0) {
820
- max_count = 138;
821
- min_count = 3;
822
-
823
- } else if (curlen === nextlen) {
824
- max_count = 6;
825
- min_count = 3;
826
-
827
- } else {
828
- max_count = 7;
829
- min_count = 4;
830
- }
831
- }
832
- }
833
-
834
-
835
- /* ===========================================================================
836
- * Send a literal or distance tree in compressed form, using the codes in
837
- * bl_tree.
838
- */
839
- function send_tree(s, tree, max_code)
840
- // deflate_state *s;
841
- // ct_data *tree; /* the tree to be scanned */
842
- // int max_code; /* and its largest code of non zero frequency */
843
- {
844
- var n; /* iterates over all tree elements */
845
- var prevlen = -1; /* last emitted length */
846
- var curlen; /* length of current code */
847
-
848
- var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */
849
-
850
- var count = 0; /* repeat count of the current code */
851
- var max_count = 7; /* max repeat count */
852
- var min_count = 4; /* min repeat count */
853
-
854
- /* tree[max_code+1].Len = -1; */ /* guard already set */
855
- if (nextlen === 0) {
856
- max_count = 138;
857
- min_count = 3;
858
- }
859
-
860
- for (n = 0; n <= max_code; n++) {
861
- curlen = nextlen;
862
- nextlen = tree[(n + 1) * 2 + 1]/*.Len*/;
863
-
864
- if (++count < max_count && curlen === nextlen) {
865
- continue;
866
-
867
- } else if (count < min_count) {
868
- do { send_code(s, curlen, s.bl_tree); } while (--count !== 0);
869
-
870
- } else if (curlen !== 0) {
871
- if (curlen !== prevlen) {
872
- send_code(s, curlen, s.bl_tree);
873
- count--;
874
- }
875
- //Assert(count >= 3 && count <= 6, " 3_6?");
876
- send_code(s, REP_3_6, s.bl_tree);
877
- send_bits(s, count - 3, 2);
878
-
879
- } else if (count <= 10) {
880
- send_code(s, REPZ_3_10, s.bl_tree);
881
- send_bits(s, count - 3, 3);
882
-
883
- } else {
884
- send_code(s, REPZ_11_138, s.bl_tree);
885
- send_bits(s, count - 11, 7);
886
- }
887
-
888
- count = 0;
889
- prevlen = curlen;
890
- if (nextlen === 0) {
891
- max_count = 138;
892
- min_count = 3;
893
-
894
- } else if (curlen === nextlen) {
895
- max_count = 6;
896
- min_count = 3;
897
-
898
- } else {
899
- max_count = 7;
900
- min_count = 4;
901
- }
902
- }
903
- }
904
-
905
-
906
- /* ===========================================================================
907
- * Construct the Huffman tree for the bit lengths and return the index in
908
- * bl_order of the last bit length code to send.
909
- */
910
- function build_bl_tree(s) {
911
- var max_blindex; /* index of last bit length code of non zero freq */
912
-
913
- /* Determine the bit length frequencies for literal and distance trees */
914
- scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
915
- scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
916
-
917
- /* Build the bit length tree: */
918
- build_tree(s, s.bl_desc);
919
- /* opt_len now includes the length of the tree representations, except
920
- * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
921
- */
922
-
923
- /* Determine the number of bit length codes to send. The pkzip format
924
- * requires that at least 4 bit length codes be sent. (appnote.txt says
925
- * 3 but the actual value used is 4.)
926
- */
927
- for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
928
- if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) {
929
- break;
930
- }
931
- }
932
- /* Update opt_len to include the bit length tree and counts */
933
- s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
934
- //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
935
- // s->opt_len, s->static_len));
936
-
937
- return max_blindex;
938
- }
939
-
940
-
941
- /* ===========================================================================
942
- * Send the header for a block using dynamic Huffman trees: the counts, the
943
- * lengths of the bit length codes, the literal tree and the distance tree.
944
- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
945
- */
946
- function send_all_trees(s, lcodes, dcodes, blcodes)
947
- // deflate_state *s;
948
- // int lcodes, dcodes, blcodes; /* number of codes for each tree */
949
- {
950
- var rank; /* index in bl_order */
951
-
952
- //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
953
- //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
954
- // "too many codes");
955
- //Tracev((stderr, "\nbl counts: "));
956
- send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */
957
- send_bits(s, dcodes - 1, 5);
958
- send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */
959
- for (rank = 0; rank < blcodes; rank++) {
960
- //Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
961
- send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3);
962
- }
963
- //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
964
-
965
- send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */
966
- //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
967
-
968
- send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */
969
- //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
970
- }
971
-
972
-
973
- /* ===========================================================================
974
- * Check if the data type is TEXT or BINARY, using the following algorithm:
975
- * - TEXT if the two conditions below are satisfied:
976
- * a) There are no non-portable control characters belonging to the
977
- * "black list" (0..6, 14..25, 28..31).
978
- * b) There is at least one printable character belonging to the
979
- * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
980
- * - BINARY otherwise.
981
- * - The following partially-portable control characters form a
982
- * "gray list" that is ignored in this detection algorithm:
983
- * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
984
- * IN assertion: the fields Freq of dyn_ltree are set.
985
- */
986
- function detect_data_type(s) {
987
- /* black_mask is the bit mask of black-listed bytes
988
- * set bits 0..6, 14..25, and 28..31
989
- * 0xf3ffc07f = binary 11110011111111111100000001111111
990
- */
991
- var black_mask = 0xf3ffc07f;
992
- var n;
993
-
994
- /* Check for non-textual ("black-listed") bytes. */
995
- for (n = 0; n <= 31; n++, black_mask >>>= 1) {
996
- if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) {
997
- return Z_BINARY;
998
- }
999
- }
1000
-
1001
- /* Check for textual ("white-listed") bytes. */
1002
- if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 ||
1003
- s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) {
1004
- return Z_TEXT;
1005
- }
1006
- for (n = 32; n < LITERALS; n++) {
1007
- if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) {
1008
- return Z_TEXT;
1009
- }
1010
- }
1011
-
1012
- /* There are no "black-listed" or "white-listed" bytes:
1013
- * this stream either is empty or has tolerated ("gray-listed") bytes only.
1014
- */
1015
- return Z_BINARY;
1016
- }
1017
-
1018
-
1019
- var static_init_done = false;
1020
-
1021
- /* ===========================================================================
1022
- * Initialize the tree data structures for a new zlib stream.
1023
- */
1024
- function _tr_init(s)
1025
- {
1026
-
1027
- if (!static_init_done) {
1028
- tr_static_init();
1029
- static_init_done = true;
1030
- }
1031
-
1032
- s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
1033
- s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
1034
- s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
1035
-
1036
- s.bi_buf = 0;
1037
- s.bi_valid = 0;
1038
-
1039
- /* Initialize the first block of the first file: */
1040
- init_block(s);
1041
- }
1042
-
1043
-
1044
- /* ===========================================================================
1045
- * Send a stored block
1046
- */
1047
- function _tr_stored_block(s, buf, stored_len, last)
1048
- //DeflateState *s;
1049
- //charf *buf; /* input block */
1050
- //ulg stored_len; /* length of input block */
1051
- //int last; /* one if this is the last block for a file */
1052
- {
1053
- send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */
1054
- copy_block(s, buf, stored_len, true); /* with header */
1055
- }
1056
-
1057
-
1058
- /* ===========================================================================
1059
- * Send one empty static block to give enough lookahead for inflate.
1060
- * This takes 10 bits, of which 7 may remain in the bit buffer.
1061
- */
1062
- function _tr_align(s) {
1063
- send_bits(s, STATIC_TREES << 1, 3);
1064
- send_code(s, END_BLOCK, static_ltree);
1065
- bi_flush(s);
1066
- }
1067
-
1068
-
1069
- /* ===========================================================================
1070
- * Determine the best encoding for the current block: dynamic trees, static
1071
- * trees or store, and output the encoded block to the zip file.
1072
- */
1073
- function _tr_flush_block(s, buf, stored_len, last)
1074
- //DeflateState *s;
1075
- //charf *buf; /* input block, or NULL if too old */
1076
- //ulg stored_len; /* length of input block */
1077
- //int last; /* one if this is the last block for a file */
1078
- {
1079
- var opt_lenb, static_lenb; /* opt_len and static_len in bytes */
1080
- var max_blindex = 0; /* index of last bit length code of non zero freq */
1081
-
1082
- /* Build the Huffman trees unless a stored block is forced */
1083
- if (s.level > 0) {
1084
-
1085
- /* Check if the file is binary or text */
1086
- if (s.strm.data_type === Z_UNKNOWN) {
1087
- s.strm.data_type = detect_data_type(s);
1088
- }
1089
-
1090
- /* Construct the literal and distance trees */
1091
- build_tree(s, s.l_desc);
1092
- // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
1093
- // s->static_len));
1094
-
1095
- build_tree(s, s.d_desc);
1096
- // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
1097
- // s->static_len));
1098
- /* At this point, opt_len and static_len are the total bit lengths of
1099
- * the compressed block data, excluding the tree representations.
1100
- */
1101
-
1102
- /* Build the bit length tree for the above two trees, and get the index
1103
- * in bl_order of the last bit length code to send.
1104
- */
1105
- max_blindex = build_bl_tree(s);
1106
-
1107
- /* Determine the best encoding. Compute the block lengths in bytes. */
1108
- opt_lenb = (s.opt_len + 3 + 7) >>> 3;
1109
- static_lenb = (s.static_len + 3 + 7) >>> 3;
1110
-
1111
- // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
1112
- // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
1113
- // s->last_lit));
1114
-
1115
- if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; }
1116
-
1117
- } else {
1118
- // Assert(buf != (char*)0, "lost buf");
1119
- opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
1120
- }
1121
-
1122
- if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) {
1123
- /* 4: two words for the lengths */
1124
-
1125
- /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
1126
- * Otherwise we can't have processed more than WSIZE input bytes since
1127
- * the last block flush, because compression would have been
1128
- * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
1129
- * transform a block into a stored block.
1130
- */
1131
- _tr_stored_block(s, buf, stored_len, last);
1132
-
1133
- } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
1134
-
1135
- send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
1136
- compress_block(s, static_ltree, static_dtree);
1137
-
1138
- } else {
1139
- send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
1140
- send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
1141
- compress_block(s, s.dyn_ltree, s.dyn_dtree);
1142
- }
1143
- // Assert (s->compressed_len == s->bits_sent, "bad compressed size");
1144
- /* The above check is made mod 2^32, for files larger than 512 MB
1145
- * and uLong implemented on 32 bits.
1146
- */
1147
- init_block(s);
1148
-
1149
- if (last) {
1150
- bi_windup(s);
1151
- }
1152
- // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
1153
- // s->compressed_len-7*last));
1154
- }
1155
-
1156
- /* ===========================================================================
1157
- * Save the match info and tally the frequency counts. Return true if
1158
- * the current block must be flushed.
1159
- */
1160
- function _tr_tally(s, dist, lc)
1161
- // deflate_state *s;
1162
- // unsigned dist; /* distance of matched string */
1163
- // unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
1164
- {
1165
- //var out_length, in_length, dcode;
1166
-
1167
- s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;
1168
- s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;
1169
-
1170
- s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;
1171
- s.last_lit++;
1172
-
1173
- if (dist === 0) {
1174
- /* lc is the unmatched char */
1175
- s.dyn_ltree[lc * 2]/*.Freq*/++;
1176
- } else {
1177
- s.matches++;
1178
- /* Here, lc is the match length - MIN_MATCH */
1179
- dist--; /* dist = match distance - 1 */
1180
- //Assert((ush)dist < (ush)MAX_DIST(s) &&
1181
- // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
1182
- // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match");
1183
-
1184
- s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++;
1185
- s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++;
1186
- }
1187
-
1188
- // (!) This block is disabled in zlib defaults,
1189
- // don't enable it for binary compatibility
1190
-
1191
- //#ifdef TRUNCATE_BLOCK
1192
- // /* Try to guess if it is profitable to stop the current block here */
1193
- // if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {
1194
- // /* Compute an upper bound for the compressed length */
1195
- // out_length = s.last_lit*8;
1196
- // in_length = s.strstart - s.block_start;
1197
- //
1198
- // for (dcode = 0; dcode < D_CODES; dcode++) {
1199
- // out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);
1200
- // }
1201
- // out_length >>>= 3;
1202
- // //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
1203
- // // s->last_lit, in_length, out_length,
1204
- // // 100L - out_length*100L/in_length));
1205
- // if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {
1206
- // return true;
1207
- // }
1208
- // }
1209
- //#endif
1210
-
1211
- return (s.last_lit === s.lit_bufsize - 1);
1212
- /* We avoid equality with lit_bufsize because of wraparound at 64K
1213
- * on 16 bit machines and because stored blocks are restricted to
1214
- * 64K-1 bytes.
1215
- */
1216
- }
1217
-
1218
- exports._tr_init = _tr_init;
1219
- exports._tr_stored_block = _tr_stored_block;
1220
- exports._tr_flush_block = _tr_flush_block;
1221
- exports._tr_tally = _tr_tally;
1222
- exports._tr_align = _tr_align;