You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8861 lines
267 KiB
8861 lines
267 KiB
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
(function (process){
|
|
/* Copyright (c) 2013 Rod Vagg, MIT License */
|
|
|
|
function AbstractChainedBatch (db) {
|
|
this._db = db
|
|
this._operations = []
|
|
this._written = false
|
|
}
|
|
|
|
AbstractChainedBatch.prototype._checkWritten = function () {
|
|
if (this._written)
|
|
throw new Error('write() already called on this batch')
|
|
}
|
|
|
|
AbstractChainedBatch.prototype.put = function (key, value) {
|
|
this._checkWritten()
|
|
|
|
var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
|
|
if (err) throw err
|
|
err = this._db._checkKeyValue(value, 'value', this._db._isBuffer)
|
|
if (err) throw err
|
|
|
|
if (!this._db._isBuffer(key)) key = String(key)
|
|
if (!this._db._isBuffer(value)) value = String(value)
|
|
|
|
if (typeof this._put == 'function' )
|
|
this._put(key, value)
|
|
else
|
|
this._operations.push({ type: 'put', key: key, value: value })
|
|
|
|
return this
|
|
}
|
|
|
|
AbstractChainedBatch.prototype.del = function (key) {
|
|
this._checkWritten()
|
|
|
|
var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
|
|
if (err) throw err
|
|
|
|
if (!this._db._isBuffer(key)) key = String(key)
|
|
|
|
if (typeof this._del == 'function' )
|
|
this._del(key)
|
|
else
|
|
this._operations.push({ type: 'del', key: key })
|
|
|
|
return this
|
|
}
|
|
|
|
AbstractChainedBatch.prototype.clear = function () {
|
|
this._checkWritten()
|
|
|
|
this._operations = []
|
|
|
|
if (typeof this._clear == 'function' )
|
|
this._clear()
|
|
|
|
return this
|
|
}
|
|
|
|
AbstractChainedBatch.prototype.write = function (options, callback) {
|
|
this._checkWritten()
|
|
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
if (typeof callback != 'function')
|
|
throw new Error('write() requires a callback argument')
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
this._written = true
|
|
|
|
if (typeof this._write == 'function' )
|
|
return this._write(callback)
|
|
|
|
if (typeof this._db._batch == 'function')
|
|
return this._db._batch(this._operations, options, callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
module.exports = AbstractChainedBatch
|
|
}).call(this,require('_process'))
|
|
},{"_process":33}],2:[function(require,module,exports){
|
|
(function (process){
|
|
/* Copyright (c) 2013 Rod Vagg, MIT License */
|
|
|
|
function AbstractIterator (db) {
|
|
this.db = db
|
|
this._ended = false
|
|
this._nexting = false
|
|
}
|
|
|
|
AbstractIterator.prototype.next = function (callback) {
|
|
var self = this
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('next() requires a callback argument')
|
|
|
|
if (self._ended)
|
|
return callback(new Error('cannot call next() after end()'))
|
|
if (self._nexting)
|
|
return callback(new Error('cannot call next() before previous next() has completed'))
|
|
|
|
self._nexting = true
|
|
if (typeof self._next == 'function') {
|
|
return self._next(function () {
|
|
self._nexting = false
|
|
callback.apply(null, arguments)
|
|
})
|
|
}
|
|
|
|
process.nextTick(function () {
|
|
self._nexting = false
|
|
callback()
|
|
})
|
|
}
|
|
|
|
AbstractIterator.prototype.end = function (callback) {
|
|
if (typeof callback != 'function')
|
|
throw new Error('end() requires a callback argument')
|
|
|
|
if (this._ended)
|
|
return callback(new Error('end() already called on iterator'))
|
|
|
|
this._ended = true
|
|
|
|
if (typeof this._end == 'function')
|
|
return this._end(callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
module.exports = AbstractIterator
|
|
|
|
}).call(this,require('_process'))
|
|
},{"_process":33}],3:[function(require,module,exports){
|
|
(function (Buffer,process){
|
|
/* Copyright (c) 2013 Rod Vagg, MIT License */
|
|
|
|
var xtend = require('xtend')
|
|
, AbstractIterator = require('./abstract-iterator')
|
|
, AbstractChainedBatch = require('./abstract-chained-batch')
|
|
|
|
function AbstractLevelDOWN (location) {
|
|
if (!arguments.length || location === undefined)
|
|
throw new Error('constructor requires at least a location argument')
|
|
|
|
if (typeof location != 'string')
|
|
throw new Error('constructor requires a location string argument')
|
|
|
|
this.location = location
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.open = function (options, callback) {
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('open() requires a callback argument')
|
|
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
if (typeof this._open == 'function')
|
|
return this._open(options, callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.close = function (callback) {
|
|
if (typeof callback != 'function')
|
|
throw new Error('close() requires a callback argument')
|
|
|
|
if (typeof this._close == 'function')
|
|
return this._close(callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.get = function (key, options, callback) {
|
|
var err
|
|
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('get() requires a callback argument')
|
|
|
|
if (err = this._checkKeyValue(key, 'key', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (!this._isBuffer(key))
|
|
key = String(key)
|
|
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
if (typeof this._get == 'function')
|
|
return this._get(key, options, callback)
|
|
|
|
process.nextTick(function () { callback(new Error('NotFound')) })
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.put = function (key, value, options, callback) {
|
|
var err
|
|
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('put() requires a callback argument')
|
|
|
|
if (err = this._checkKeyValue(key, 'key', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (err = this._checkKeyValue(value, 'value', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (!this._isBuffer(key))
|
|
key = String(key)
|
|
|
|
// coerce value to string in node, don't touch it in browser
|
|
// (indexeddb can store any JS type)
|
|
if (!this._isBuffer(value) && !process.browser)
|
|
value = String(value)
|
|
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
if (typeof this._put == 'function')
|
|
return this._put(key, value, options, callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.del = function (key, options, callback) {
|
|
var err
|
|
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('del() requires a callback argument')
|
|
|
|
if (err = this._checkKeyValue(key, 'key', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (!this._isBuffer(key))
|
|
key = String(key)
|
|
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
if (typeof this._del == 'function')
|
|
return this._del(key, options, callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.batch = function (array, options, callback) {
|
|
if (!arguments.length)
|
|
return this._chainedBatch()
|
|
|
|
if (typeof options == 'function')
|
|
callback = options
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('batch(array) requires a callback argument')
|
|
|
|
if (!Array.isArray(array))
|
|
return callback(new Error('batch(array) requires an array argument'))
|
|
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
var i = 0
|
|
, l = array.length
|
|
, e
|
|
, err
|
|
|
|
for (; i < l; i++) {
|
|
e = array[i]
|
|
if (typeof e != 'object')
|
|
continue
|
|
|
|
if (err = this._checkKeyValue(e.type, 'type', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (err = this._checkKeyValue(e.key, 'key', this._isBuffer))
|
|
return callback(err)
|
|
|
|
if (e.type == 'put') {
|
|
if (err = this._checkKeyValue(e.value, 'value', this._isBuffer))
|
|
return callback(err)
|
|
}
|
|
}
|
|
|
|
if (typeof this._batch == 'function')
|
|
return this._batch(array, options, callback)
|
|
|
|
process.nextTick(callback)
|
|
}
|
|
|
|
//TODO: remove from here, not a necessary primitive
|
|
AbstractLevelDOWN.prototype.approximateSize = function (start, end, callback) {
|
|
if ( start == null
|
|
|| end == null
|
|
|| typeof start == 'function'
|
|
|| typeof end == 'function') {
|
|
throw new Error('approximateSize() requires valid `start`, `end` and `callback` arguments')
|
|
}
|
|
|
|
if (typeof callback != 'function')
|
|
throw new Error('approximateSize() requires a callback argument')
|
|
|
|
if (!this._isBuffer(start))
|
|
start = String(start)
|
|
|
|
if (!this._isBuffer(end))
|
|
end = String(end)
|
|
|
|
if (typeof this._approximateSize == 'function')
|
|
return this._approximateSize(start, end, callback)
|
|
|
|
process.nextTick(function () {
|
|
callback(null, 0)
|
|
})
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype._setupIteratorOptions = function (options) {
|
|
var self = this
|
|
|
|
options = xtend(options)
|
|
|
|
;[ 'start', 'end', 'gt', 'gte', 'lt', 'lte' ].forEach(function (o) {
|
|
if (options[o] && self._isBuffer(options[o]) && options[o].length === 0)
|
|
delete options[o]
|
|
})
|
|
|
|
options.reverse = !!options.reverse
|
|
|
|
// fix `start` so it takes into account gt, gte, lt, lte as appropriate
|
|
if (options.reverse && options.lt)
|
|
options.start = options.lt
|
|
if (options.reverse && options.lte)
|
|
options.start = options.lte
|
|
if (!options.reverse && options.gt)
|
|
options.start = options.gt
|
|
if (!options.reverse && options.gte)
|
|
options.start = options.gte
|
|
|
|
if ((options.reverse && options.lt && !options.lte)
|
|
|| (!options.reverse && options.gt && !options.gte))
|
|
options.exclusiveStart = true // start should *not* include matching key
|
|
|
|
return options
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype.iterator = function (options) {
|
|
if (typeof options != 'object')
|
|
options = {}
|
|
|
|
options = this._setupIteratorOptions(options)
|
|
|
|
if (typeof this._iterator == 'function')
|
|
return this._iterator(options)
|
|
|
|
return new AbstractIterator(this)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype._chainedBatch = function () {
|
|
return new AbstractChainedBatch(this)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype._isBuffer = function (obj) {
|
|
return Buffer.isBuffer(obj)
|
|
}
|
|
|
|
AbstractLevelDOWN.prototype._checkKeyValue = function (obj, type) {
|
|
|
|
if (obj === null || obj === undefined)
|
|
return new Error(type + ' cannot be `null` or `undefined`')
|
|
|
|
if (this._isBuffer(obj)) {
|
|
if (obj.length === 0)
|
|
return new Error(type + ' cannot be an empty Buffer')
|
|
} else if (String(obj) === '')
|
|
return new Error(type + ' cannot be an empty String')
|
|
}
|
|
|
|
module.exports.AbstractLevelDOWN = AbstractLevelDOWN
|
|
module.exports.AbstractIterator = AbstractIterator
|
|
module.exports.AbstractChainedBatch = AbstractChainedBatch
|
|
|
|
}).call(this,{"isBuffer":require("../is-buffer/index.js")},require('_process'))
|
|
},{"../is-buffer/index.js":9,"./abstract-chained-batch":1,"./abstract-iterator":2,"_process":33,"xtend":4}],4:[function(require,module,exports){
|
|
module.exports = extend
|
|
|
|
function extend() {
|
|
var target = {}
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var source = arguments[i]
|
|
|
|
for (var key in source) {
|
|
if (source.hasOwnProperty(key)) {
|
|
target[key] = source[key]
|
|
}
|
|
}
|
|
}
|
|
|
|
return target
|
|
}
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
'use strict'
|
|
|
|
exports.byteLength = byteLength
|
|
exports.toByteArray = toByteArray
|
|
exports.fromByteArray = fromByteArray
|
|
|
|
var lookup = []
|
|
var revLookup = []
|
|
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
|
|
|
|
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
|
|
for (var i = 0, len = code.length; i < len; ++i) {
|
|
lookup[i] = code[i]
|
|
revLookup[code.charCodeAt(i)] = i
|
|
}
|
|
|
|
revLookup['-'.charCodeAt(0)] = 62
|
|
revLookup['_'.charCodeAt(0)] = 63
|
|
|
|
function placeHoldersCount (b64) {
|
|
var len = b64.length
|
|
if (len % 4 > 0) {
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
}
|
|
|
|
// the number of equal signs (place holders)
|
|
// if there are two placeholders, than the two characters before it
|
|
// represent one byte
|
|
// if there is only one, then the three characters before it represent 2 bytes
|
|
// this is just a cheap hack to not do indexOf twice
|
|
return b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0
|
|
}
|
|
|
|
function byteLength (b64) {
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
return b64.length * 3 / 4 - placeHoldersCount(b64)
|
|
}
|
|
|
|
function toByteArray (b64) {
|
|
var i, j, l, tmp, placeHolders, arr
|
|
var len = b64.length
|
|
placeHolders = placeHoldersCount(b64)
|
|
|
|
arr = new Arr(len * 3 / 4 - placeHolders)
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
l = placeHolders > 0 ? len - 4 : len
|
|
|
|
var L = 0
|
|
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
|
|
arr[L++] = (tmp >> 16) & 0xFF
|
|
arr[L++] = (tmp >> 8) & 0xFF
|
|
arr[L++] = tmp & 0xFF
|
|
}
|
|
|
|
if (placeHolders === 2) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
|
|
arr[L++] = tmp & 0xFF
|
|
} else if (placeHolders === 1) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
|
|
arr[L++] = (tmp >> 8) & 0xFF
|
|
arr[L++] = tmp & 0xFF
|
|
}
|
|
|
|
return arr
|
|
}
|
|
|
|
function tripletToBase64 (num) {
|
|
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
|
|
}
|
|
|
|
function encodeChunk (uint8, start, end) {
|
|
var tmp
|
|
var output = []
|
|
for (var i = start; i < end; i += 3) {
|
|
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
|
|
output.push(tripletToBase64(tmp))
|
|
}
|
|
return output.join('')
|
|
}
|
|
|
|
function fromByteArray (uint8) {
|
|
var tmp
|
|
var len = uint8.length
|
|
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
|
|
var output = ''
|
|
var parts = []
|
|
var maxChunkLength = 16383 // must be multiple of 3
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
|
|
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
|
|
}
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
if (extraBytes === 1) {
|
|
tmp = uint8[len - 1]
|
|
output += lookup[tmp >> 2]
|
|
output += lookup[(tmp << 4) & 0x3F]
|
|
output += '=='
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
|
|
output += lookup[tmp >> 10]
|
|
output += lookup[(tmp >> 4) & 0x3F]
|
|
output += lookup[(tmp << 2) & 0x3F]
|
|
output += '='
|
|
}
|
|
|
|
parts.push(output)
|
|
|
|
return parts.join('')
|
|
}
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
(function (global){
|
|
/*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* @license MIT
|
|
*/
|
|
/* eslint-disable no-proto */
|
|
|
|
'use strict'
|
|
|
|
var base64 = require('base64-js')
|
|
var ieee754 = require('ieee754')
|
|
var isArray = require('isarray')
|
|
|
|
exports.Buffer = Buffer
|
|
exports.SlowBuffer = SlowBuffer
|
|
exports.INSPECT_MAX_BYTES = 50
|
|
|
|
/**
|
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
|
* === true Use Uint8Array implementation (fastest)
|
|
* === false Use Object implementation (most compatible, even IE6)
|
|
*
|
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
|
* Opera 11.6+, iOS 4.2+.
|
|
*
|
|
* Due to various browser bugs, sometimes the Object implementation will be used even
|
|
* when the browser supports typed arrays.
|
|
*
|
|
* Note:
|
|
*
|
|
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
|
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
|
*
|
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
|
*
|
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
|
* incorrect length in some situations.
|
|
|
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
|
|
* get the Object implementation, which is slower but behaves correctly.
|
|
*/
|
|
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
|
|
? global.TYPED_ARRAY_SUPPORT
|
|
: typedArraySupport()
|
|
|
|
/*
|
|
* Export kMaxLength after typed array support is determined.
|
|
*/
|
|
exports.kMaxLength = kMaxLength()
|
|
|
|
function typedArraySupport () {
|
|
try {
|
|
var arr = new Uint8Array(1)
|
|
arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
|
|
return arr.foo() === 42 && // typed array instances can be augmented
|
|
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
|
|
arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function kMaxLength () {
|
|
return Buffer.TYPED_ARRAY_SUPPORT
|
|
? 0x7fffffff
|
|
: 0x3fffffff
|
|
}
|
|
|
|
function createBuffer (that, length) {
|
|
if (kMaxLength() < length) {
|
|
throw new RangeError('Invalid typed array length')
|
|
}
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
that = new Uint8Array(length)
|
|
that.__proto__ = Buffer.prototype
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
if (that === null) {
|
|
that = new Buffer(length)
|
|
}
|
|
that.length = length
|
|
}
|
|
|
|
return that
|
|
}
|
|
|
|
/**
|
|
* The Buffer constructor returns instances of `Uint8Array` that have their
|
|
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
|
|
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
|
|
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
|
|
* returns a single octet.
|
|
*
|
|
* The `Uint8Array` prototype remains unmodified.
|
|
*/
|
|
|
|
function Buffer (arg, encodingOrOffset, length) {
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
|
|
return new Buffer(arg, encodingOrOffset, length)
|
|
}
|
|
|
|
// Common case.
|
|
if (typeof arg === 'number') {
|
|
if (typeof encodingOrOffset === 'string') {
|
|
throw new Error(
|
|
'If encoding is specified then the first argument must be a string'
|
|
)
|
|
}
|
|
return allocUnsafe(this, arg)
|
|
}
|
|
return from(this, arg, encodingOrOffset, length)
|
|
}
|
|
|
|
Buffer.poolSize = 8192 // not used by this implementation
|
|
|
|
// TODO: Legacy, not needed anymore. Remove in next major version.
|
|
Buffer._augment = function (arr) {
|
|
arr.__proto__ = Buffer.prototype
|
|
return arr
|
|
}
|
|
|
|
function from (that, value, encodingOrOffset, length) {
|
|
if (typeof value === 'number') {
|
|
throw new TypeError('"value" argument must not be a number')
|
|
}
|
|
|
|
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
|
|
return fromArrayBuffer(that, value, encodingOrOffset, length)
|
|
}
|
|
|
|
if (typeof value === 'string') {
|
|
return fromString(that, value, encodingOrOffset)
|
|
}
|
|
|
|
return fromObject(that, value)
|
|
}
|
|
|
|
/**
|
|
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
|
|
* if value is a number.
|
|
* Buffer.from(str[, encoding])
|
|
* Buffer.from(array)
|
|
* Buffer.from(buffer)
|
|
* Buffer.from(arrayBuffer[, byteOffset[, length]])
|
|
**/
|
|
Buffer.from = function (value, encodingOrOffset, length) {
|
|
return from(null, value, encodingOrOffset, length)
|
|
}
|
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype
|
|
Buffer.__proto__ = Uint8Array
|
|
if (typeof Symbol !== 'undefined' && Symbol.species &&
|
|
Buffer[Symbol.species] === Buffer) {
|
|
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
|
|
Object.defineProperty(Buffer, Symbol.species, {
|
|
value: null,
|
|
configurable: true
|
|
})
|
|
}
|
|
}
|
|
|
|
function assertSize (size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('"size" argument must be a number')
|
|
} else if (size < 0) {
|
|
throw new RangeError('"size" argument must not be negative')
|
|
}
|
|
}
|
|
|
|
function alloc (that, size, fill, encoding) {
|
|
assertSize(size)
|
|
if (size <= 0) {
|
|
return createBuffer(that, size)
|
|
}
|
|
if (fill !== undefined) {
|
|
// Only pay attention to encoding if it's a string. This
|
|
// prevents accidentally sending in a number that would
|
|
// be interpretted as a start offset.
|
|
return typeof encoding === 'string'
|
|
? createBuffer(that, size).fill(fill, encoding)
|
|
: createBuffer(that, size).fill(fill)
|
|
}
|
|
return createBuffer(that, size)
|
|
}
|
|
|
|
/**
|
|
* Creates a new filled Buffer instance.
|
|
* alloc(size[, fill[, encoding]])
|
|
**/
|
|
Buffer.alloc = function (size, fill, encoding) {
|
|
return alloc(null, size, fill, encoding)
|
|
}
|
|
|
|
function allocUnsafe (that, size) {
|
|
assertSize(size)
|
|
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
|
for (var i = 0; i < size; ++i) {
|
|
that[i] = 0
|
|
}
|
|
}
|
|
return that
|
|
}
|
|
|
|
/**
|
|
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
|
* */
|
|
Buffer.allocUnsafe = function (size) {
|
|
return allocUnsafe(null, size)
|
|
}
|
|
/**
|
|
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
|
*/
|
|
Buffer.allocUnsafeSlow = function (size) {
|
|
return allocUnsafe(null, size)
|
|
}
|
|
|
|
function fromString (that, string, encoding) {
|
|
if (typeof encoding !== 'string' || encoding === '') {
|
|
encoding = 'utf8'
|
|
}
|
|
|
|
if (!Buffer.isEncoding(encoding)) {
|
|
throw new TypeError('"encoding" must be a valid string encoding')
|
|
}
|
|
|
|
var length = byteLength(string, encoding) | 0
|
|
that = createBuffer(that, length)
|
|
|
|
var actual = that.write(string, encoding)
|
|
|
|
if (actual !== length) {
|
|
// Writing a hex string, for example, that contains invalid characters will
|
|
// cause everything after the first invalid character to be ignored. (e.g.
|
|
// 'abxxcd' will be treated as 'ab')
|
|
that = that.slice(0, actual)
|
|
}
|
|
|
|
return that
|
|
}
|
|
|
|
function fromArrayLike (that, array) {
|
|
var length = array.length < 0 ? 0 : checked(array.length) | 0
|
|
that = createBuffer(that, length)
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromArrayBuffer (that, array, byteOffset, length) {
|
|
array.byteLength // this throws if `array` is not a valid ArrayBuffer
|
|
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
throw new RangeError('\'offset\' is out of bounds')
|
|
}
|
|
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
throw new RangeError('\'length\' is out of bounds')
|
|
}
|
|
|
|
if (byteOffset === undefined && length === undefined) {
|
|
array = new Uint8Array(array)
|
|
} else if (length === undefined) {
|
|
array = new Uint8Array(array, byteOffset)
|
|
} else {
|
|
array = new Uint8Array(array, byteOffset, length)
|
|
}
|
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
that = array
|
|
that.__proto__ = Buffer.prototype
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
that = fromArrayLike(that, array)
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromObject (that, obj) {
|
|
if (Buffer.isBuffer(obj)) {
|
|
var len = checked(obj.length) | 0
|
|
that = createBuffer(that, len)
|
|
|
|
if (that.length === 0) {
|
|
return that
|
|
}
|
|
|
|
obj.copy(that, 0, 0, len)
|
|
return that
|
|
}
|
|
|
|
if (obj) {
|
|
if ((typeof ArrayBuffer !== 'undefined' &&
|
|
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
|
|
if (typeof obj.length !== 'number' || isnan(obj.length)) {
|
|
return createBuffer(that, 0)
|
|
}
|
|
return fromArrayLike(that, obj)
|
|
}
|
|
|
|
if (obj.type === 'Buffer' && isArray(obj.data)) {
|
|
return fromArrayLike(that, obj.data)
|
|
}
|
|
}
|
|
|
|
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
|
|
}
|
|
|
|
function checked (length) {
|
|
// Note: cannot use `length < kMaxLength()` here because that fails when
|
|
// length is NaN (which is otherwise coerced to zero.)
|
|
if (length >= kMaxLength()) {
|
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
|
'size: 0x' + kMaxLength().toString(16) + ' bytes')
|
|
}
|
|
return length | 0
|
|
}
|
|
|
|
function SlowBuffer (length) {
|
|
if (+length != length) { // eslint-disable-line eqeqeq
|
|
length = 0
|
|
}
|
|
return Buffer.alloc(+length)
|
|
}
|
|
|
|
Buffer.isBuffer = function isBuffer (b) {
|
|
return !!(b != null && b._isBuffer)
|
|
}
|
|
|
|
Buffer.compare = function compare (a, b) {
|
|
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
|
throw new TypeError('Arguments must be Buffers')
|
|
}
|
|
|
|
if (a === b) return 0
|
|
|
|
var x = a.length
|
|
var y = b.length
|
|
|
|
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
if (a[i] !== b[i]) {
|
|
x = a[i]
|
|
y = b[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
if (x < y) return -1
|
|
if (y < x) return 1
|
|
return 0
|
|
}
|
|
|
|
Buffer.isEncoding = function isEncoding (encoding) {
|
|
switch (String(encoding).toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
Buffer.concat = function concat (list, length) {
|
|
if (!isArray(list)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
}
|
|
|
|
if (list.length === 0) {
|
|
return Buffer.alloc(0)
|
|
}
|
|
|
|
var i
|
|
if (length === undefined) {
|
|
length = 0
|
|
for (i = 0; i < list.length; ++i) {
|
|
length += list[i].length
|
|
}
|
|
}
|
|
|
|
var buffer = Buffer.allocUnsafe(length)
|
|
var pos = 0
|
|
for (i = 0; i < list.length; ++i) {
|
|
var buf = list[i]
|
|
if (!Buffer.isBuffer(buf)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
}
|
|
buf.copy(buffer, pos)
|
|
pos += buf.length
|
|
}
|
|
return buffer
|
|
}
|
|
|
|
function byteLength (string, encoding) {
|
|
if (Buffer.isBuffer(string)) {
|
|
return string.length
|
|
}
|
|
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
|
|
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
|
|
return string.byteLength
|
|
}
|
|
if (typeof string !== 'string') {
|
|
string = '' + string
|
|
}
|
|
|
|
var len = string.length
|
|
if (len === 0) return 0
|
|
|
|
// Use a for loop to avoid recursion
|
|
var loweredCase = false
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
return len
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case undefined:
|
|
return utf8ToBytes(string).length
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return len * 2
|
|
case 'hex':
|
|
return len >>> 1
|
|
case 'base64':
|
|
return base64ToBytes(string).length
|
|
default:
|
|
if (loweredCase) return utf8ToBytes(string).length // assume utf8
|
|
encoding = ('' + encoding).toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
Buffer.byteLength = byteLength
|
|
|
|
function slowToString (encoding, start, end) {
|
|
var loweredCase = false
|
|
|
|
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
|
// property of a typed array.
|
|
|
|
// This behaves neither like String nor Uint8Array in that we set start/end
|
|
// to their upper/lower bounds if the value passed is out of range.
|
|
// undefined is handled specially as per ECMA-262 6th Edition,
|
|
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
|
|
if (start === undefined || start < 0) {
|
|
start = 0
|
|
}
|
|
// Return early if start > this.length. Done here to prevent potential uint32
|
|
// coercion fail below.
|
|
if (start > this.length) {
|
|
return ''
|
|
}
|
|
|
|
if (end === undefined || end > this.length) {
|
|
end = this.length
|
|
}
|
|
|
|
if (end <= 0) {
|
|
return ''
|
|
}
|
|
|
|
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
|
|
end >>>= 0
|
|
start >>>= 0
|
|
|
|
if (end <= start) {
|
|
return ''
|
|
}
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
|
|
while (true) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexSlice(this, start, end)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Slice(this, start, end)
|
|
|
|
case 'ascii':
|
|
return asciiSlice(this, start, end)
|
|
|
|
case 'latin1':
|
|
case 'binary':
|
|
return latin1Slice(this, start, end)
|
|
|
|
case 'base64':
|
|
return base64Slice(this, start, end)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return utf16leSlice(this, start, end)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = (encoding + '').toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
|
|
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
|
|
// Buffer instances.
|
|
Buffer.prototype._isBuffer = true
|
|
|
|
function swap (b, n, m) {
|
|
var i = b[n]
|
|
b[n] = b[m]
|
|
b[m] = i
|
|
}
|
|
|
|
Buffer.prototype.swap16 = function swap16 () {
|
|
var len = this.length
|
|
if (len % 2 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 16-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 2) {
|
|
swap(this, i, i + 1)
|
|
}
|
|
return this
|
|
}
|
|
|
|
Buffer.prototype.swap32 = function swap32 () {
|
|
var len = this.length
|
|
if (len % 4 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 32-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 4) {
|
|
swap(this, i, i + 3)
|
|
swap(this, i + 1, i + 2)
|
|
}
|
|
return this
|
|
}
|
|
|
|
Buffer.prototype.swap64 = function swap64 () {
|
|
var len = this.length
|
|
if (len % 8 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 64-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 8) {
|
|
swap(this, i, i + 7)
|
|
swap(this, i + 1, i + 6)
|
|
swap(this, i + 2, i + 5)
|
|
swap(this, i + 3, i + 4)
|
|
}
|
|
return this
|
|
}
|
|
|
|
Buffer.prototype.toString = function toString () {
|
|
var length = this.length | 0
|
|
if (length === 0) return ''
|
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
|
return slowToString.apply(this, arguments)
|
|
}
|
|
|
|
Buffer.prototype.equals = function equals (b) {
|
|
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
|
if (this === b) return true
|
|
return Buffer.compare(this, b) === 0
|
|
}
|
|
|
|
Buffer.prototype.inspect = function inspect () {
|
|
var str = ''
|
|
var max = exports.INSPECT_MAX_BYTES
|
|
if (this.length > 0) {
|
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
|
|
if (this.length > max) str += ' ... '
|
|
}
|
|
return '<Buffer ' + str + '>'
|
|
}
|
|
|
|
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
|
if (!Buffer.isBuffer(target)) {
|
|
throw new TypeError('Argument must be a Buffer')
|
|
}
|
|
|
|
if (start === undefined) {
|
|
start = 0
|
|
}
|
|
if (end === undefined) {
|
|
end = target ? target.length : 0
|
|
}
|
|
if (thisStart === undefined) {
|
|
thisStart = 0
|
|
}
|
|
if (thisEnd === undefined) {
|
|
thisEnd = this.length
|
|
}
|
|
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
|
throw new RangeError('out of range index')
|
|
}
|
|
|
|
if (thisStart >= thisEnd && start >= end) {
|
|
return 0
|
|
}
|
|
if (thisStart >= thisEnd) {
|
|
return -1
|
|
}
|
|
if (start >= end) {
|
|
return 1
|
|
}
|
|
|
|
start >>>= 0
|
|
end >>>= 0
|
|
thisStart >>>= 0
|
|
thisEnd >>>= 0
|
|
|
|
if (this === target) return 0
|
|
|
|
var x = thisEnd - thisStart
|
|
var y = end - start
|
|
var len = Math.min(x, y)
|
|
|
|
var thisCopy = this.slice(thisStart, thisEnd)
|
|
var targetCopy = target.slice(start, end)
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
if (thisCopy[i] !== targetCopy[i]) {
|
|
x = thisCopy[i]
|
|
y = targetCopy[i]
|
|
break
|
|
}
|
|
}
|
|
|
|
if (x < y) return -1
|
|
if (y < x) return 1
|
|
return 0
|
|
}
|
|
|
|
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
|
|
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
|
|
//
|
|
// Arguments:
|
|
// - buffer - a Buffer to search
|
|
// - val - a string, Buffer, or number
|
|
// - byteOffset - an index into `buffer`; will be clamped to an int32
|
|
// - encoding - an optional encoding, relevant is val is a string
|
|
// - dir - true for indexOf, false for lastIndexOf
|
|
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
|
|
// Empty buffer means no match
|
|
if (buffer.length === 0) return -1
|
|
|
|
// Normalize byteOffset
|
|
if (typeof byteOffset === 'string') {
|
|
encoding = byteOffset
|
|
byteOffset = 0
|
|
} else if (byteOffset > 0x7fffffff) {
|
|
byteOffset = 0x7fffffff
|
|
} else if (byteOffset < -0x80000000) {
|
|
byteOffset = -0x80000000
|
|
}
|
|
byteOffset = +byteOffset // Coerce to Number.
|
|
if (isNaN(byteOffset)) {
|
|
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
|
byteOffset = dir ? 0 : (buffer.length - 1)
|
|
}
|
|
|
|
// Normalize byteOffset: negative offsets start from the end of the buffer
|
|
if (byteOffset < 0) byteOffset = buffer.length + byteOffset
|
|
if (byteOffset >= buffer.length) {
|
|
if (dir) return -1
|
|
else byteOffset = buffer.length - 1
|
|
} else if (byteOffset < 0) {
|
|
if (dir) byteOffset = 0
|
|
else return -1
|
|
}
|
|
|
|
// Normalize val
|
|
if (typeof val === 'string') {
|
|
val = Buffer.from(val, encoding)
|
|
}
|
|
|
|
// Finally, search either indexOf (if dir is true) or lastIndexOf
|
|
if (Buffer.isBuffer(val)) {
|
|
// Special case: looking for empty string/buffer always fails
|
|
if (val.length === 0) {
|
|
return -1
|
|
}
|
|
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
|
|
} else if (typeof val === 'number') {
|
|
val = val & 0xFF // Search for a byte value [0-255]
|
|
if (Buffer.TYPED_ARRAY_SUPPORT &&
|
|
typeof Uint8Array.prototype.indexOf === 'function') {
|
|
if (dir) {
|
|
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
|
|
} else {
|
|
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
|
|
}
|
|
}
|
|
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
|
|
}
|
|
|
|
throw new TypeError('val must be string, number or Buffer')
|
|
}
|
|
|
|
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
|
|
var indexSize = 1
|
|
var arrLength = arr.length
|
|
var valLength = val.length
|
|
|
|
if (encoding !== undefined) {
|
|
encoding = String(encoding).toLowerCase()
|
|
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
|
|
encoding === 'utf16le' || encoding === 'utf-16le') {
|
|
if (arr.length < 2 || val.length < 2) {
|
|
return -1
|
|
}
|
|
indexSize = 2
|
|
arrLength /= 2
|
|
valLength /= 2
|
|
byteOffset /= 2
|
|
}
|
|
}
|
|
|
|
function read (buf, i) {
|
|
if (indexSize === 1) {
|
|
return buf[i]
|
|
} else {
|
|
return buf.readUInt16BE(i * indexSize)
|
|
}
|
|
}
|
|
|
|
var i
|
|
if (dir) {
|
|
var foundIndex = -1
|
|
for (i = byteOffset; i < arrLength; i++) {
|
|
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
|
if (foundIndex === -1) foundIndex = i
|
|
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
|
|
} else {
|
|
if (foundIndex !== -1) i -= i - foundIndex
|
|
foundIndex = -1
|
|
}
|
|
}
|
|
} else {
|
|
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
|
|
for (i = byteOffset; i >= 0; i--) {
|
|
var found = true
|
|
for (var j = 0; j < valLength; j++) {
|
|
if (read(arr, i + j) !== read(val, j)) {
|
|
found = false
|
|
break
|
|
}
|
|
}
|
|
if (found) return i
|
|
}
|
|
}
|
|
|
|
return -1
|
|
}
|
|
|
|
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
|
|
return this.indexOf(val, byteOffset, encoding) !== -1
|
|
}
|
|
|
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
|
|
}
|
|
|
|
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
|
|
}
|
|
|
|
function hexWrite (buf, string, offset, length) {
|
|
offset = Number(offset) || 0
|
|
var remaining = buf.length - offset
|
|
if (!length) {
|
|
length = remaining
|
|
} else {
|
|
length = Number(length)
|
|
if (length > remaining) {
|
|
length = remaining
|
|
}
|
|
}
|
|
|
|
// must be an even number of digits
|
|
var strLen = string.length
|
|
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
|
|
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2
|
|
}
|
|
for (var i = 0; i < length; ++i) {
|
|
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
|
if (isNaN(parsed)) return i
|
|
buf[offset + i] = parsed
|
|
}
|
|
return i
|
|
}
|
|
|
|
function utf8Write (buf, string, offset, length) {
|
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
function asciiWrite (buf, string, offset, length) {
|
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function latin1Write (buf, string, offset, length) {
|
|
return asciiWrite(buf, string, offset, length)
|
|
}
|
|
|
|
function base64Write (buf, string, offset, length) {
|
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function ucs2Write (buf, string, offset, length) {
|
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
Buffer.prototype.write = function write (string, offset, length, encoding) {
|
|
// Buffer#write(string)
|
|
if (offset === undefined) {
|
|
encoding = 'utf8'
|
|
length = this.length
|
|
offset = 0
|
|
// Buffer#write(string, encoding)
|
|
} else if (length === undefined && typeof offset === 'string') {
|
|
encoding = offset
|
|
length = this.length
|
|
offset = 0
|
|
// Buffer#write(string, offset[, length][, encoding])
|
|
} else if (isFinite(offset)) {
|
|
offset = offset | 0
|
|
if (isFinite(length)) {
|
|
length = length | 0
|
|
if (encoding === undefined) encoding = 'utf8'
|
|
} else {
|
|
encoding = length
|
|
length = undefined
|
|
}
|
|
// legacy write(string, encoding, offset, length) - remove in v0.13
|
|
} else {
|
|
throw new Error(
|
|
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
|
|
)
|
|
}
|
|
|
|
var remaining = this.length - offset
|
|
if (length === undefined || length > remaining) length = remaining
|
|
|
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
|
throw new RangeError('Attempt to write outside buffer bounds')
|
|
}
|
|
|
|
if (!encoding) encoding = 'utf8'
|
|
|
|
var loweredCase = false
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexWrite(this, string, offset, length)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Write(this, string, offset, length)
|
|
|
|
case 'ascii':
|
|
return asciiWrite(this, string, offset, length)
|
|
|
|
case 'latin1':
|
|
case 'binary':
|
|
return latin1Write(this, string, offset, length)
|
|
|
|
case 'base64':
|
|
// Warning: maxLength not taken into account in base64Write
|
|
return base64Write(this, string, offset, length)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return ucs2Write(this, string, offset, length)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = ('' + encoding).toLowerCase()
|
|
loweredCase = true
|
|
}
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.toJSON = function toJSON () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
}
|
|
}
|
|
|
|
function base64Slice (buf, start, end) {
|
|
if (start === 0 && end === buf.length) {
|
|
return base64.fromByteArray(buf)
|
|
} else {
|
|
return base64.fromByteArray(buf.slice(start, end))
|
|
}
|
|
}
|
|
|
|
function utf8Slice (buf, start, end) {
|
|
end = Math.min(buf.length, end)
|
|
var res = []
|
|
|
|
var i = start
|
|
while (i < end) {
|
|
var firstByte = buf[i]
|
|
var codePoint = null
|
|
var bytesPerSequence = (firstByte > 0xEF) ? 4
|
|
: (firstByte > 0xDF) ? 3
|
|
: (firstByte > 0xBF) ? 2
|
|
: 1
|
|
|
|
if (i + bytesPerSequence <= end) {
|
|
var secondByte, thirdByte, fourthByte, tempCodePoint
|
|
|
|
switch (bytesPerSequence) {
|
|
case 1:
|
|
if (firstByte < 0x80) {
|
|
codePoint = firstByte
|
|
}
|
|
break
|
|
case 2:
|
|
secondByte = buf[i + 1]
|
|
if ((secondByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
|
|
if (tempCodePoint > 0x7F) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
break
|
|
case 3:
|
|
secondByte = buf[i + 1]
|
|
thirdByte = buf[i + 2]
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
|
|
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
break
|
|
case 4:
|
|
secondByte = buf[i + 1]
|
|
thirdByte = buf[i + 2]
|
|
fourthByte = buf[i + 3]
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
|
|
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
|
|
codePoint = tempCodePoint
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (codePoint === null) {
|
|
// we did not generate a valid codePoint so insert a
|
|
// replacement char (U+FFFD) and advance only 1 byte
|
|
codePoint = 0xFFFD
|
|
bytesPerSequence = 1
|
|
} else if (codePoint > 0xFFFF) {
|
|
// encode to utf16 (surrogate pair dance)
|
|
codePoint -= 0x10000
|
|
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
|
|
codePoint = 0xDC00 | codePoint & 0x3FF
|
|
}
|
|
|
|
res.push(codePoint)
|
|
i += bytesPerSequence
|
|
}
|
|
|
|
return decodeCodePointsArray(res)
|
|
}
|
|
|
|
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
|
// the lowest limit is Chrome, with 0x10000 args.
|
|
// We go 1 magnitude less, for safety
|
|
var MAX_ARGUMENTS_LENGTH = 0x1000
|
|
|
|
function decodeCodePointsArray (codePoints) {
|
|
var len = codePoints.length
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
|
}
|
|
|
|
// Decode in chunks to avoid "call stack size exceeded".
|
|
var res = ''
|
|
var i = 0
|
|
while (i < len) {
|
|
res += String.fromCharCode.apply(
|
|
String,
|
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
|
)
|
|
}
|
|
return res
|
|
}
|
|
|
|
function asciiSlice (buf, start, end) {
|
|
var ret = ''
|
|
end = Math.min(buf.length, end)
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i] & 0x7F)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function latin1Slice (buf, start, end) {
|
|
var ret = ''
|
|
end = Math.min(buf.length, end)
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i])
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function hexSlice (buf, start, end) {
|
|
var len = buf.length
|
|
|
|
if (!start || start < 0) start = 0
|
|
if (!end || end < 0 || end > len) end = len
|
|
|
|
var out = ''
|
|
for (var i = start; i < end; ++i) {
|
|
out += toHex(buf[i])
|
|
}
|
|
return out
|
|
}
|
|
|
|
function utf16leSlice (buf, start, end) {
|
|
var bytes = buf.slice(start, end)
|
|
var res = ''
|
|
for (var i = 0; i < bytes.length; i += 2) {
|
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
|
|
}
|
|
return res
|
|
}
|
|
|
|
Buffer.prototype.slice = function slice (start, end) {
|
|
var len = this.length
|
|
start = ~~start
|
|
end = end === undefined ? len : ~~end
|
|
|
|
if (start < 0) {
|
|
start += len
|
|
if (start < 0) start = 0
|
|
} else if (start > len) {
|
|
start = len
|
|
}
|
|
|
|
if (end < 0) {
|
|
end += len
|
|
if (end < 0) end = 0
|
|
} else if (end > len) {
|
|
end = len
|
|
}
|
|
|
|
if (end < start) end = start
|
|
|
|
var newBuf
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
newBuf = this.subarray(start, end)
|
|
newBuf.__proto__ = Buffer.prototype
|
|
} else {
|
|
var sliceLen = end - start
|
|
newBuf = new Buffer(sliceLen, undefined)
|
|
for (var i = 0; i < sliceLen; ++i) {
|
|
newBuf[i] = this[i + start]
|
|
}
|
|
}
|
|
|
|
return newBuf
|
|
}
|
|
|
|
/*
|
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
|
*/
|
|
function checkOffset (offset, ext, length) {
|
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
|
}
|
|
|
|
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var val = this[offset]
|
|
var mul = 1
|
|
var i = 0
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul
|
|
}
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) {
|
|
checkOffset(offset, byteLength, this.length)
|
|
}
|
|
|
|
var val = this[offset + --byteLength]
|
|
var mul = 1
|
|
while (byteLength > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --byteLength] * mul
|
|
}
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
return this[offset]
|
|
}
|
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return this[offset] | (this[offset + 1] << 8)
|
|
}
|
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return (this[offset] << 8) | this[offset + 1]
|
|
}
|
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return ((this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16)) +
|
|
(this[offset + 3] * 0x1000000)
|
|
}
|
|
|
|
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset] * 0x1000000) +
|
|
((this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
this[offset + 3])
|
|
}
|
|
|
|
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var val = this[offset]
|
|
var mul = 1
|
|
var i = 0
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul
|
|
}
|
|
mul *= 0x80
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
|
|
|
var i = byteLength
|
|
var mul = 1
|
|
var val = this[offset + --i]
|
|
while (i > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --i] * mul
|
|
}
|
|
mul *= 0x80
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
|
|
|
return val
|
|
}
|
|
|
|
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
if (!(this[offset] & 0x80)) return (this[offset])
|
|
return ((0xff - this[offset] + 1) * -1)
|
|
}
|
|
|
|
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
var val = this[offset] | (this[offset + 1] << 8)
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
}
|
|
|
|
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
var val = this[offset + 1] | (this[offset] << 8)
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
}
|
|
|
|
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16) |
|
|
(this[offset + 3] << 24)
|
|
}
|
|
|
|
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
|
|
return (this[offset] << 24) |
|
|
(this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
(this[offset + 3])
|
|
}
|
|
|
|
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, true, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, false, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
return ieee754.read(this, offset, true, 52, 8)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
return ieee754.read(this, offset, false, 52, 8)
|
|
}
|
|
|
|
function checkInt (buf, value, offset, ext, max, min) {
|
|
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
|
|
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
}
|
|
|
|
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) {
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0)
|
|
}
|
|
|
|
var mul = 1
|
|
var i = 0
|
|
this[offset] = value & 0xFF
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
byteLength = byteLength | 0
|
|
if (!noAssert) {
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0)
|
|
}
|
|
|
|
var i = byteLength - 1
|
|
var mul = 1
|
|
this[offset + i] = value & 0xFF
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
|
this[offset] = (value & 0xff)
|
|
return offset + 1
|
|
}
|
|
|
|
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffff + value + 1
|
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
|
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
|
(littleEndian ? i : 1 - i) * 8
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffffffff + value + 1
|
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
|
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset + 3] = (value >>> 24)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
}
|
|
|
|
var i = 0
|
|
var mul = 1
|
|
var sub = 0
|
|
this[offset] = value & 0xFF
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
|
sub = 1
|
|
}
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1)
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
|
}
|
|
|
|
var i = byteLength - 1
|
|
var mul = 1
|
|
var sub = 0
|
|
this[offset + i] = value & 0xFF
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
|
sub = 1
|
|
}
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
|
|
}
|
|
|
|
return offset + byteLength
|
|
}
|
|
|
|
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
|
if (value < 0) value = 0xff + value + 1
|
|
this[offset] = (value & 0xff)
|
|
return offset + 1
|
|
}
|
|
|
|
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false)
|
|
}
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 3] = (value >>> 24)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset | 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
|
if (value < 0) value = 0xffffffff + value + 1
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false)
|
|
}
|
|
return offset + 4
|
|
}
|
|
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
if (offset < 0) throw new RangeError('Index out of range')
|
|
}
|
|
|
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
|
}
|
|
ieee754.write(buf, value, offset, littleEndian, 52, 8)
|
|
return offset + 8
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, true, noAssert)
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, false, noAssert)
|
|
}
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
|
if (!start) start = 0
|
|
if (!end && end !== 0) end = this.length
|
|
if (targetStart >= target.length) targetStart = target.length
|
|
if (!targetStart) targetStart = 0
|
|
if (end > 0 && end < start) end = start
|
|
|
|
// Copy 0 bytes; we're done
|
|
if (end === start) return 0
|
|
if (target.length === 0 || this.length === 0) return 0
|
|
|
|
// Fatal error conditions
|
|
if (targetStart < 0) {
|
|
throw new RangeError('targetStart out of bounds')
|
|
}
|
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
|
|
|
// Are we oob?
|
|
if (end > this.length) end = this.length
|
|
if (target.length - targetStart < end - start) {
|
|
end = target.length - targetStart + start
|
|
}
|
|
|
|
var len = end - start
|
|
var i
|
|
|
|
if (this === target && start < targetStart && targetStart < end) {
|
|
// descending copy from end
|
|
for (i = len - 1; i >= 0; --i) {
|
|
target[i + targetStart] = this[i + start]
|
|
}
|
|
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// ascending copy from start
|
|
for (i = 0; i < len; ++i) {
|
|
target[i + targetStart] = this[i + start]
|
|
}
|
|
} else {
|
|
Uint8Array.prototype.set.call(
|
|
target,
|
|
this.subarray(start, start + len),
|
|
targetStart
|
|
)
|
|
}
|
|
|
|
return len
|
|
}
|
|
|
|
// Usage:
|
|
// buffer.fill(number[, offset[, end]])
|
|
// buffer.fill(buffer[, offset[, end]])
|
|
// buffer.fill(string[, offset[, end]][, encoding])
|
|
Buffer.prototype.fill = function fill (val, start, end, encoding) {
|
|
// Handle string cases:
|
|
if (typeof val === 'string') {
|
|
if (typeof start === 'string') {
|
|
encoding = start
|
|
start = 0
|
|
end = this.length
|
|
} else if (typeof end === 'string') {
|
|
encoding = end
|
|
end = this.length
|
|
}
|
|
if (val.length === 1) {
|
|
var code = val.charCodeAt(0)
|
|
if (code < 256) {
|
|
val = code
|
|
}
|
|
}
|
|
if (encoding !== undefined && typeof encoding !== 'string') {
|
|
throw new TypeError('encoding must be a string')
|
|
}
|
|
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
|
|
throw new TypeError('Unknown encoding: ' + encoding)
|
|
}
|
|
} else if (typeof val === 'number') {
|
|
val = val & 255
|
|
}
|
|
|
|
// Invalid ranges are not set to a default, so can range check early.
|
|
if (start < 0 || this.length < start || this.length < end) {
|
|
throw new RangeError('Out of range index')
|
|
}
|
|
|
|
if (end <= start) {
|
|
return this
|
|
}
|
|
|
|
start = start >>> 0
|
|
end = end === undefined ? this.length : end >>> 0
|
|
|
|
if (!val) val = 0
|
|
|
|
var i
|
|
if (typeof val === 'number') {
|
|
for (i = start; i < end; ++i) {
|
|
this[i] = val
|
|
}
|
|
} else {
|
|
var bytes = Buffer.isBuffer(val)
|
|
? val
|
|
: utf8ToBytes(new Buffer(val, encoding).toString())
|
|
var len = bytes.length
|
|
for (i = 0; i < end - start; ++i) {
|
|
this[i + start] = bytes[i % len]
|
|
}
|
|
}
|
|
|
|
return this
|
|
}
|
|
|
|
// HELPER FUNCTIONS
|
|
// ================
|
|
|
|
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
|
|
|
|
function base64clean (str) {
|
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
|
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
|
|
// Node converts strings with length < 2 to ''
|
|
if (str.length < 2) return ''
|
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
|
while (str.length % 4 !== 0) {
|
|
str = str + '='
|
|
}
|
|
return str
|
|
}
|
|
|
|
function stringtrim (str) {
|
|
if (str.trim) return str.trim()
|
|
return str.replace(/^\s+|\s+$/g, '')
|
|
}
|
|
|
|
function toHex (n) {
|
|
if (n < 16) return '0' + n.toString(16)
|
|
return n.toString(16)
|
|
}
|
|
|
|
function utf8ToBytes (string, units) {
|
|
units = units || Infinity
|
|
var codePoint
|
|
var length = string.length
|
|
var leadSurrogate = null
|
|
var bytes = []
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
codePoint = string.charCodeAt(i)
|
|
|
|
// is surrogate component
|
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
|
// last char was a lead
|
|
if (!leadSurrogate) {
|
|
// no lead yet
|
|
if (codePoint > 0xDBFF) {
|
|
// unexpected trail
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
continue
|
|
} else if (i + 1 === length) {
|
|
// unpaired lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
continue
|
|
}
|
|
|
|
// valid lead
|
|
leadSurrogate = codePoint
|
|
|
|
continue
|
|
}
|
|
|
|
// 2 leads in a row
|
|
if (codePoint < 0xDC00) {
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
leadSurrogate = codePoint
|
|
continue
|
|
}
|
|
|
|
// valid surrogate pair
|
|
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
|
|
} else if (leadSurrogate) {
|
|
// valid bmp char, but last char was a lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
|
}
|
|
|
|
leadSurrogate = null
|
|
|
|
// encode utf8
|
|
if (codePoint < 0x80) {
|
|
if ((units -= 1) < 0) break
|
|
bytes.push(codePoint)
|
|
} else if (codePoint < 0x800) {
|
|
if ((units -= 2) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x6 | 0xC0,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else if (codePoint < 0x10000) {
|
|
if ((units -= 3) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0xC | 0xE0,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else if (codePoint < 0x110000) {
|
|
if ((units -= 4) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x12 | 0xF0,
|
|
codePoint >> 0xC & 0x3F | 0x80,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
)
|
|
} else {
|
|
throw new Error('Invalid code point')
|
|
}
|
|
}
|
|
|
|
return bytes
|
|
}
|
|
|
|
function asciiToBytes (str) {
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Node's code seems to be doing this and not & 0x7F..
|
|
byteArray.push(str.charCodeAt(i) & 0xFF)
|
|
}
|
|
return byteArray
|
|
}
|
|
|
|
function utf16leToBytes (str, units) {
|
|
var c, hi, lo
|
|
var byteArray = []
|
|
for (var i = 0; i < str.length; ++i) {
|
|
if ((units -= 2) < 0) break
|
|
|
|
c = str.charCodeAt(i)
|
|
hi = c >> 8
|
|
lo = c % 256
|
|
byteArray.push(lo)
|
|
byteArray.push(hi)
|
|
}
|
|
|
|
return byteArray
|
|
}
|
|
|
|
function base64ToBytes (str) {
|
|
return base64.toByteArray(base64clean(str))
|
|
}
|
|
|
|
function blitBuffer (src, dst, offset, length) {
|
|
for (var i = 0; i < length; ++i) {
|
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
|
dst[i + offset] = src[i]
|
|
}
|
|
return i
|
|
}
|
|
|
|
function isnan (val) {
|
|
return val !== val // eslint-disable-line no-self-compare
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"base64-js":5,"ieee754":8,"isarray":10}],7:[function(require,module,exports){
|
|
/*global window:false, self:false, define:false, module:false */
|
|
|
|
/**
|
|
* @license IDBWrapper - A cross-browser wrapper for IndexedDB
|
|
* Version 1.7.1
|
|
* Copyright (c) 2011 - 2016 Jens Arps
|
|
* http://jensarps.de/
|
|
*
|
|
* Licensed under the MIT (X11) license
|
|
*/
|
|
|
|
(function (name, definition, global) {
|
|
|
|
'use strict';
|
|
|
|
if (typeof define === 'function') {
|
|
define(definition);
|
|
} else if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = definition();
|
|
} else {
|
|
global[name] = definition();
|
|
}
|
|
})('IDBStore', function () {
|
|
|
|
'use strict';
|
|
|
|
var defaultErrorHandler = function (error) {
|
|
throw error;
|
|
};
|
|
var defaultSuccessHandler = function () {
|
|
};
|
|
|
|
var defaults = {
|
|
storeName: 'Store',
|
|
storePrefix: 'IDBWrapper-',
|
|
dbVersion: 1,
|
|
keyPath: 'id',
|
|
autoIncrement: true,
|
|
onStoreReady: function () {
|
|
},
|
|
onError: defaultErrorHandler,
|
|
indexes: [],
|
|
implementationPreference: [
|
|
'indexedDB',
|
|
'webkitIndexedDB',
|
|
'mozIndexedDB',
|
|
'shimIndexedDB'
|
|
]
|
|
};
|
|
|
|
/**
|
|
*
|
|
* The IDBStore constructor
|
|
*
|
|
* @constructor
|
|
* @name IDBStore
|
|
* @version 1.7.1
|
|
*
|
|
* @param {Object} [kwArgs] An options object used to configure the store and
|
|
* set callbacks
|
|
* @param {String} [kwArgs.storeName='Store'] The name of the store
|
|
* @param {String} [kwArgs.storePrefix='IDBWrapper-'] A prefix that is
|
|
* internally used to construct the name of the database, which will be
|
|
* kwArgs.storePrefix + kwArgs.storeName
|
|
* @param {Number} [kwArgs.dbVersion=1] The version of the store
|
|
* @param {String} [kwArgs.keyPath='id'] The key path to use. If you want to
|
|
* setup IDBWrapper to work with out-of-line keys, you need to set this to
|
|
* `null`
|
|
* @param {Boolean} [kwArgs.autoIncrement=true] If set to true, IDBStore will
|
|
* automatically make sure a unique keyPath value is present on each object
|
|
* that is stored.
|
|
* @param {Function} [kwArgs.onStoreReady] A callback to be called when the
|
|
* store is ready to be used.
|
|
* @param {Function} [kwArgs.onError=throw] A callback to be called when an
|
|
* error occurred during instantiation of the store.
|
|
* @param {Array} [kwArgs.indexes=[]] An array of indexData objects
|
|
* defining the indexes to use with the store. For every index to be used
|
|
* one indexData object needs to be passed in the array.
|
|
* An indexData object is defined as follows:
|
|
* @param {Object} [kwArgs.indexes.indexData] An object defining the index to
|
|
* use
|
|
* @param {String} kwArgs.indexes.indexData.name The name of the index
|
|
* @param {String} [kwArgs.indexes.indexData.keyPath] The key path of the index
|
|
* @param {Boolean} [kwArgs.indexes.indexData.unique] Whether the index is unique
|
|
* @param {Boolean} [kwArgs.indexes.indexData.multiEntry] Whether the index is multi entry
|
|
* @param {Array} [kwArgs.implementationPreference=['indexedDB','webkitIndexedDB','mozIndexedDB','shimIndexedDB']] An array of strings naming implementations to be used, in order or preference
|
|
* @param {Function} [onStoreReady] A callback to be called when the store
|
|
* is ready to be used.
|
|
* @example
|
|
// create a store for customers with an additional index over the
|
|
// `lastname` property.
|
|
var myCustomerStore = new IDBStore({
|
|
dbVersion: 1,
|
|
storeName: 'customer-index',
|
|
keyPath: 'customerid',
|
|
autoIncrement: true,
|
|
onStoreReady: populateTable,
|
|
indexes: [
|
|
{ name: 'lastname', keyPath: 'lastname', unique: false, multiEntry: false }
|
|
]
|
|
});
|
|
* @example
|
|
// create a generic store
|
|
var myCustomerStore = new IDBStore({
|
|
storeName: 'my-data-store',
|
|
onStoreReady: function(){
|
|
// start working with the store.
|
|
}
|
|
});
|
|
*/
|
|
var IDBStore = function (kwArgs, onStoreReady) {
|
|
|
|
if (typeof onStoreReady == 'undefined' && typeof kwArgs == 'function') {
|
|
onStoreReady = kwArgs;
|
|
}
|
|
if (Object.prototype.toString.call(kwArgs) != '[object Object]') {
|
|
kwArgs = {};
|
|
}
|
|
|
|
for (var key in defaults) {
|
|
this[key] = typeof kwArgs[key] != 'undefined' ? kwArgs[key] : defaults[key];
|
|
}
|
|
|
|
this.dbName = this.storePrefix + this.storeName;
|
|
this.dbVersion = parseInt(this.dbVersion, 10) || 1;
|
|
|
|
onStoreReady && (this.onStoreReady = onStoreReady);
|
|
|
|
var env = typeof window == 'object' ? window : self;
|
|
var availableImplementations = this.implementationPreference.filter(function (implName) {
|
|
return implName in env;
|
|
});
|
|
this.implementation = availableImplementations[0];
|
|
this.idb = env[this.implementation];
|
|
this.keyRange = env.IDBKeyRange || env.webkitIDBKeyRange || env.mozIDBKeyRange;
|
|
|
|
this.consts = {
|
|
'READ_ONLY': 'readonly',
|
|
'READ_WRITE': 'readwrite',
|
|
'VERSION_CHANGE': 'versionchange',
|
|
'NEXT': 'next',
|
|
'NEXT_NO_DUPLICATE': 'nextunique',
|
|
'PREV': 'prev',
|
|
'PREV_NO_DUPLICATE': 'prevunique'
|
|
};
|
|
|
|
this.openDB();
|
|
};
|
|
|
|
/** @lends IDBStore.prototype */
|
|
var proto = {
|
|
|
|
/**
|
|
* A pointer to the IDBStore ctor
|
|
*
|
|
* @private
|
|
* @type {Function}
|
|
* @constructs
|
|
*/
|
|
constructor: IDBStore,
|
|
|
|
/**
|
|
* The version of IDBStore
|
|
*
|
|
* @type {String}
|
|
*/
|
|
version: '1.7.1',
|
|
|
|
/**
|
|
* A reference to the IndexedDB object
|
|
*
|
|
* @type {IDBDatabase}
|
|
*/
|
|
db: null,
|
|
|
|
/**
|
|
* The full name of the IndexedDB used by IDBStore, composed of
|
|
* this.storePrefix + this.storeName
|
|
*
|
|
* @type {String}
|
|
*/
|
|
dbName: null,
|
|
|
|
/**
|
|
* The version of the IndexedDB used by IDBStore
|
|
*
|
|
* @type {Number}
|
|
*/
|
|
dbVersion: null,
|
|
|
|
/**
|
|
* A reference to the objectStore used by IDBStore
|
|
*
|
|
* @type {IDBObjectStore}
|
|
*/
|
|
store: null,
|
|
|
|
/**
|
|
* The store name
|
|
*
|
|
* @type {String}
|
|
*/
|
|
storeName: null,
|
|
|
|
/**
|
|
* The prefix to prepend to the store name
|
|
*
|
|
* @type {String}
|
|
*/
|
|
storePrefix: null,
|
|
|
|
/**
|
|
* The key path
|
|
*
|
|
* @type {String}
|
|
*/
|
|
keyPath: null,
|
|
|
|
/**
|
|
* Whether IDBStore uses autoIncrement
|
|
*
|
|
* @type {Boolean}
|
|
*/
|
|
autoIncrement: null,
|
|
|
|
/**
|
|
* The indexes used by IDBStore
|
|
*
|
|
* @type {Array}
|
|
*/
|
|
indexes: null,
|
|
|
|
/**
|
|
* The implemantations to try to use, in order of preference
|
|
*
|
|
* @type {Array}
|
|
*/
|
|
implementationPreference: null,
|
|
|
|
/**
|
|
* The actual implementation being used
|
|
*
|
|
* @type {String}
|
|
*/
|
|
implementation: '',
|
|
|
|
/**
|
|
* The callback to be called when the store is ready to be used
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
onStoreReady: null,
|
|
|
|
/**
|
|
* The callback to be called if an error occurred during instantiation
|
|
* of the store
|
|
*
|
|
* @type {Function}
|
|
*/
|
|
onError: null,
|
|
|
|
/**
|
|
* The internal insertID counter
|
|
*
|
|
* @type {Number}
|
|
* @private
|
|
*/
|
|
_insertIdCount: 0,
|
|
|
|
/**
|
|
* Opens an IndexedDB; called by the constructor.
|
|
*
|
|
* Will check if versions match and compare provided index configuration
|
|
* with existing ones, and update indexes if necessary.
|
|
*
|
|
* Will call this.onStoreReady() if everything went well and the store
|
|
* is ready to use, and this.onError() is something went wrong.
|
|
*
|
|
* @private
|
|
*
|
|
*/
|
|
openDB: function () {
|
|
|
|
var openRequest = this.idb.open(this.dbName, this.dbVersion);
|
|
var preventSuccessCallback = false;
|
|
|
|
openRequest.onerror = function (errorEvent) {
|
|
|
|
if (hasVersionError(errorEvent)) {
|
|
this.onError(new Error('The version number provided is lower than the existing one.'));
|
|
} else {
|
|
var error;
|
|
|
|
if (errorEvent.target.error) {
|
|
error = errorEvent.target.error;
|
|
} else {
|
|
var errorMessage = 'IndexedDB unknown error occurred when opening DB ' + this.dbName + ' version ' + this.dbVersion;
|
|
if ('errorCode' in errorEvent.target) {
|
|
errorMessage += ' with error code ' + errorEvent.target.errorCode;
|
|
}
|
|
error = new Error(errorMessage);
|
|
}
|
|
|
|
this.onError(error);
|
|
}
|
|
}.bind(this);
|
|
|
|
openRequest.onsuccess = function (event) {
|
|
|
|
if (preventSuccessCallback) {
|
|
return;
|
|
}
|
|
|
|
if (this.db) {
|
|
this.onStoreReady();
|
|
return;
|
|
}
|
|
|
|
this.db = event.target.result;
|
|
|
|
if (typeof this.db.version == 'string') {
|
|
this.onError(new Error('The IndexedDB implementation in this browser is outdated. Please upgrade your browser.'));
|
|
return;
|
|
}
|
|
|
|
if (!this.db.objectStoreNames.contains(this.storeName)) {
|
|
// We should never ever get here.
|
|
// Lets notify the user anyway.
|
|
this.onError(new Error('Object store couldn\'t be created.'));
|
|
return;
|
|
}
|
|
|
|
var emptyTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
|
|
this.store = emptyTransaction.objectStore(this.storeName);
|
|
|
|
// check indexes
|
|
var existingIndexes = Array.prototype.slice.call(this.getIndexList());
|
|
this.indexes.forEach(function (indexData) {
|
|
var indexName = indexData.name;
|
|
|
|
if (!indexName) {
|
|
preventSuccessCallback = true;
|
|
this.onError(new Error('Cannot create index: No index name given.'));
|
|
return;
|
|
}
|
|
|
|
this.normalizeIndexData(indexData);
|
|
|
|
if (this.hasIndex(indexName)) {
|
|
// check if it complies
|
|
var actualIndex = this.store.index(indexName);
|
|
var complies = this.indexComplies(actualIndex, indexData);
|
|
if (!complies) {
|
|
preventSuccessCallback = true;
|
|
this.onError(new Error('Cannot modify index "' + indexName + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
|
|
}
|
|
|
|
existingIndexes.splice(existingIndexes.indexOf(indexName), 1);
|
|
} else {
|
|
preventSuccessCallback = true;
|
|
this.onError(new Error('Cannot create new index "' + indexName + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
|
|
}
|
|
|
|
}, this);
|
|
|
|
if (existingIndexes.length) {
|
|
preventSuccessCallback = true;
|
|
this.onError(new Error('Cannot delete index(es) "' + existingIndexes.toString() + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
|
|
}
|
|
|
|
preventSuccessCallback || this.onStoreReady();
|
|
}.bind(this);
|
|
|
|
openRequest.onupgradeneeded = function (/* IDBVersionChangeEvent */ event) {
|
|
|
|
this.db = event.target.result;
|
|
|
|
if (this.db.objectStoreNames.contains(this.storeName)) {
|
|
this.store = event.target.transaction.objectStore(this.storeName);
|
|
} else {
|
|
var optionalParameters = {autoIncrement: this.autoIncrement};
|
|
if (this.keyPath !== null) {
|
|
optionalParameters.keyPath = this.keyPath;
|
|
}
|
|
this.store = this.db.createObjectStore(this.storeName, optionalParameters);
|
|
}
|
|
|
|
var existingIndexes = Array.prototype.slice.call(this.getIndexList());
|
|
this.indexes.forEach(function (indexData) {
|
|
var indexName = indexData.name;
|
|
|
|
if (!indexName) {
|
|
preventSuccessCallback = true;
|
|
this.onError(new Error('Cannot create index: No index name given.'));
|
|
}
|
|
|
|
this.normalizeIndexData(indexData);
|
|
|
|
if (this.hasIndex(indexName)) {
|
|
// check if it complies
|
|
var actualIndex = this.store.index(indexName);
|
|
var complies = this.indexComplies(actualIndex, indexData);
|
|
if (!complies) {
|
|
// index differs, need to delete and re-create
|
|
this.store.deleteIndex(indexName);
|
|
this.store.createIndex(indexName, indexData.keyPath, {
|
|
unique: indexData.unique,
|
|
multiEntry: indexData.multiEntry
|
|
});
|
|
}
|
|
|
|
existingIndexes.splice(existingIndexes.indexOf(indexName), 1);
|
|
} else {
|
|
this.store.createIndex(indexName, indexData.keyPath, {
|
|
unique: indexData.unique,
|
|
multiEntry: indexData.multiEntry
|
|
});
|
|
}
|
|
|
|
}, this);
|
|
|
|
if (existingIndexes.length) {
|
|
existingIndexes.forEach(function (_indexName) {
|
|
this.store.deleteIndex(_indexName);
|
|
}, this);
|
|
}
|
|
|
|
}.bind(this);
|
|
},
|
|
|
|
/**
|
|
* Deletes the database used for this store if the IDB implementations
|
|
* provides that functionality.
|
|
*
|
|
* @param {Function} [onSuccess] A callback that is called if deletion
|
|
* was successful.
|
|
* @param {Function} [onError] A callback that is called if deletion
|
|
* failed.
|
|
*/
|
|
deleteDatabase: function (onSuccess, onError) {
|
|
if (this.idb.deleteDatabase) {
|
|
this.db.close();
|
|
var deleteRequest = this.idb.deleteDatabase(this.dbName);
|
|
deleteRequest.onsuccess = onSuccess;
|
|
deleteRequest.onerror = onError;
|
|
} else {
|
|
onError(new Error('Browser does not support IndexedDB deleteDatabase!'));
|
|
}
|
|
},
|
|
|
|
/*********************
|
|
* data manipulation *
|
|
*********************/
|
|
|
|
/**
|
|
* Puts an object into the store. If an entry with the given id exists,
|
|
* it will be overwritten. This method has a different signature for inline
|
|
* keys and out-of-line keys; please see the examples below.
|
|
*
|
|
* @param {*} [key] The key to store. This is only needed if IDBWrapper
|
|
* is set to use out-of-line keys. For inline keys - the default scenario -
|
|
* this can be omitted.
|
|
* @param {Object} value The data object to store.
|
|
* @param {Function} [onSuccess] A callback that is called if insertion
|
|
* was successful.
|
|
* @param {Function} [onError] A callback that is called if insertion
|
|
* failed.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
* @example
|
|
// Storing an object, using inline keys (the default scenario):
|
|
var myCustomer = {
|
|
customerid: 2346223,
|
|
lastname: 'Doe',
|
|
firstname: 'John'
|
|
};
|
|
myCustomerStore.put(myCustomer, mySuccessHandler, myErrorHandler);
|
|
// Note that passing success- and error-handlers is optional.
|
|
* @example
|
|
// Storing an object, using out-of-line keys:
|
|
var myCustomer = {
|
|
lastname: 'Doe',
|
|
firstname: 'John'
|
|
};
|
|
myCustomerStore.put(2346223, myCustomer, mySuccessHandler, myErrorHandler);
|
|
// Note that passing success- and error-handlers is optional.
|
|
*/
|
|
put: function (key, value, onSuccess, onError) {
|
|
if (this.keyPath !== null) {
|
|
onError = onSuccess;
|
|
onSuccess = value;
|
|
value = key;
|
|
}
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
|
|
var hasSuccess = false,
|
|
result = null,
|
|
putRequest;
|
|
|
|
var putTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
|
|
putTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
putTransaction.onabort = onError;
|
|
putTransaction.onerror = onError;
|
|
|
|
if (this.keyPath !== null) { // in-line keys
|
|
this._addIdPropertyIfNeeded(value);
|
|
putRequest = putTransaction.objectStore(this.storeName).put(value);
|
|
} else { // out-of-line keys
|
|
putRequest = putTransaction.objectStore(this.storeName).put(value, key);
|
|
}
|
|
putRequest.onsuccess = function (event) {
|
|
hasSuccess = true;
|
|
result = event.target.result;
|
|
};
|
|
putRequest.onerror = onError;
|
|
|
|
return putTransaction;
|
|
},
|
|
|
|
/**
|
|
* Retrieves an object from the store. If no entry exists with the given id,
|
|
* the success handler will be called with null as first and only argument.
|
|
*
|
|
* @param {*} key The id of the object to fetch.
|
|
* @param {Function} [onSuccess] A callback that is called if fetching
|
|
* was successful. Will receive the object as only argument.
|
|
* @param {Function} [onError] A callback that will be called if an error
|
|
* occurred during the operation.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
get: function (key, onSuccess, onError) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
|
|
var hasSuccess = false,
|
|
result = null;
|
|
|
|
var getTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
|
|
getTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
getTransaction.onabort = onError;
|
|
getTransaction.onerror = onError;
|
|
var getRequest = getTransaction.objectStore(this.storeName).get(key);
|
|
getRequest.onsuccess = function (event) {
|
|
hasSuccess = true;
|
|
result = event.target.result;
|
|
};
|
|
getRequest.onerror = onError;
|
|
|
|
return getTransaction;
|
|
},
|
|
|
|
/**
|
|
* Removes an object from the store.
|
|
*
|
|
* @param {*} key The id of the object to remove.
|
|
* @param {Function} [onSuccess] A callback that is called if the removal
|
|
* was successful.
|
|
* @param {Function} [onError] A callback that will be called if an error
|
|
* occurred during the operation.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
remove: function (key, onSuccess, onError) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
|
|
var hasSuccess = false,
|
|
result = null;
|
|
|
|
var removeTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
|
|
removeTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
removeTransaction.onabort = onError;
|
|
removeTransaction.onerror = onError;
|
|
|
|
var deleteRequest = removeTransaction.objectStore(this.storeName)['delete'](key);
|
|
deleteRequest.onsuccess = function (event) {
|
|
hasSuccess = true;
|
|
result = event.target.result;
|
|
};
|
|
deleteRequest.onerror = onError;
|
|
|
|
return removeTransaction;
|
|
},
|
|
|
|
/**
|
|
* Runs a batch of put and/or remove operations on the store.
|
|
*
|
|
* @param {Array} dataArray An array of objects containing the operation to run
|
|
* and the data object (for put operations).
|
|
* @param {Function} [onSuccess] A callback that is called if all operations
|
|
* were successful.
|
|
* @param {Function} [onError] A callback that is called if an error
|
|
* occurred during one of the operations.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
batch: function (dataArray, onSuccess, onError) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
|
|
if (Object.prototype.toString.call(dataArray) != '[object Array]') {
|
|
onError(new Error('dataArray argument must be of type Array.'));
|
|
} else if (dataArray.length === 0) {
|
|
return onSuccess(true);
|
|
}
|
|
|
|
var count = dataArray.length;
|
|
var called = false;
|
|
var hasSuccess = false;
|
|
|
|
var batchTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
|
|
batchTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(hasSuccess);
|
|
};
|
|
batchTransaction.onabort = onError;
|
|
batchTransaction.onerror = onError;
|
|
|
|
|
|
var onItemSuccess = function () {
|
|
count--;
|
|
if (count === 0 && !called) {
|
|
called = true;
|
|
hasSuccess = true;
|
|
}
|
|
};
|
|
|
|
dataArray.forEach(function (operation) {
|
|
var type = operation.type;
|
|
var key = operation.key;
|
|
var value = operation.value;
|
|
|
|
var onItemError = function (err) {
|
|
batchTransaction.abort();
|
|
if (!called) {
|
|
called = true;
|
|
onError(err, type, key);
|
|
}
|
|
};
|
|
|
|
if (type == 'remove') {
|
|
var deleteRequest = batchTransaction.objectStore(this.storeName)['delete'](key);
|
|
deleteRequest.onsuccess = onItemSuccess;
|
|
deleteRequest.onerror = onItemError;
|
|
} else if (type == 'put') {
|
|
var putRequest;
|
|
if (this.keyPath !== null) { // in-line keys
|
|
this._addIdPropertyIfNeeded(value);
|
|
putRequest = batchTransaction.objectStore(this.storeName).put(value);
|
|
} else { // out-of-line keys
|
|
putRequest = batchTransaction.objectStore(this.storeName).put(value, key);
|
|
}
|
|
putRequest.onsuccess = onItemSuccess;
|
|
putRequest.onerror = onItemError;
|
|
}
|
|
}, this);
|
|
|
|
return batchTransaction;
|
|
},
|
|
|
|
/**
|
|
* Takes an array of objects and stores them in a single transaction.
|
|
*
|
|
* @param {Array} dataArray An array of objects to store
|
|
* @param {Function} [onSuccess] A callback that is called if all operations
|
|
* were successful.
|
|
* @param {Function} [onError] A callback that is called if an error
|
|
* occurred during one of the operations.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
putBatch: function (dataArray, onSuccess, onError) {
|
|
var batchData = dataArray.map(function (item) {
|
|
return {type: 'put', value: item};
|
|
});
|
|
|
|
return this.batch(batchData, onSuccess, onError);
|
|
},
|
|
|
|
/**
|
|
* Like putBatch, takes an array of objects and stores them in a single
|
|
* transaction, but allows processing of the result values. Returns the
|
|
* processed records containing the key for newly created records to the
|
|
* onSuccess calllback instead of only returning true or false for success.
|
|
* In addition, added the option for the caller to specify a key field that
|
|
* should be set to the newly created key.
|
|
*
|
|
* @param {Array} dataArray An array of objects to store
|
|
* @param {Object} [options] An object containing optional options
|
|
* @param {String} [options.keyField=this.keyPath] Specifies a field in the record to update
|
|
* with the auto-incrementing key. Defaults to the store's keyPath.
|
|
* @param {Function} [onSuccess] A callback that is called if all operations
|
|
* were successful.
|
|
* @param {Function} [onError] A callback that is called if an error
|
|
* occurred during one of the operations.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*
|
|
*/
|
|
upsertBatch: function (dataArray, options, onSuccess, onError) {
|
|
// handle `dataArray, onSuccess, onError` signature
|
|
if (typeof options == 'function') {
|
|
onSuccess = options;
|
|
onError = onSuccess;
|
|
options = {};
|
|
}
|
|
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
options || (options = {});
|
|
|
|
if (Object.prototype.toString.call(dataArray) != '[object Array]') {
|
|
onError(new Error('dataArray argument must be of type Array.'));
|
|
}
|
|
|
|
var keyField = options.keyField || this.keyPath;
|
|
var count = dataArray.length;
|
|
var called = false;
|
|
var hasSuccess = false;
|
|
var index = 0; // assume success callbacks are executed in order
|
|
|
|
var batchTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
|
|
batchTransaction.oncomplete = function () {
|
|
if (hasSuccess) {
|
|
onSuccess(dataArray);
|
|
} else {
|
|
onError(false);
|
|
}
|
|
};
|
|
batchTransaction.onabort = onError;
|
|
batchTransaction.onerror = onError;
|
|
|
|
var onItemSuccess = function (event) {
|
|
var record = dataArray[index++];
|
|
record[keyField] = event.target.result;
|
|
|
|
count--;
|
|
if (count === 0 && !called) {
|
|
called = true;
|
|
hasSuccess = true;
|
|
}
|
|
};
|
|
|
|
dataArray.forEach(function (record) {
|
|
var key = record.key;
|
|
|
|
var onItemError = function (err) {
|
|
batchTransaction.abort();
|
|
if (!called) {
|
|
called = true;
|
|
onError(err);
|
|
}
|
|
};
|
|
|
|
var putRequest;
|
|
if (this.keyPath !== null) { // in-line keys
|
|
this._addIdPropertyIfNeeded(record);
|
|
putRequest = batchTransaction.objectStore(this.storeName).put(record);
|
|
} else { // out-of-line keys
|
|
putRequest = batchTransaction.objectStore(this.storeName).put(record, key);
|
|
}
|
|
putRequest.onsuccess = onItemSuccess;
|
|
putRequest.onerror = onItemError;
|
|
}, this);
|
|
|
|
return batchTransaction;
|
|
},
|
|
|
|
/**
|
|
* Takes an array of keys and removes matching objects in a single
|
|
* transaction.
|
|
*
|
|
* @param {Array} keyArray An array of keys to remove
|
|
* @param {Function} [onSuccess] A callback that is called if all operations
|
|
* were successful.
|
|
* @param {Function} [onError] A callback that is called if an error
|
|
* occurred during one of the operations.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
removeBatch: function (keyArray, onSuccess, onError) {
|
|
var batchData = keyArray.map(function (key) {
|
|
return {type: 'remove', key: key};
|
|
});
|
|
|
|
return this.batch(batchData, onSuccess, onError);
|
|
},
|
|
|
|
/**
|
|
* Takes an array of keys and fetches matching objects
|
|
*
|
|
* @param {Array} keyArray An array of keys identifying the objects to fetch
|
|
* @param {Function} [onSuccess] A callback that is called if all operations
|
|
* were successful.
|
|
* @param {Function} [onError] A callback that is called if an error
|
|
* occurred during one of the operations.
|
|
* @param {String} [arrayType='sparse'] The type of array to pass to the
|
|
* success handler. May be one of 'sparse', 'dense' or 'skip'. Defaults to
|
|
* 'sparse'. This parameter specifies how to handle the situation if a get
|
|
* operation did not throw an error, but there was no matching object in
|
|
* the database. In most cases, 'sparse' provides the most desired
|
|
* behavior. See the examples for details.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
* @example
|
|
// given that there are two objects in the database with the keypath
|
|
// values 1 and 2, and the call looks like this:
|
|
myStore.getBatch([1, 5, 2], onError, function (data) { … }, arrayType);
|
|
|
|
// this is what the `data` array will be like:
|
|
|
|
// arrayType == 'sparse':
|
|
// data is a sparse array containing two entries and having a length of 3:
|
|
[Object, 2: Object]
|
|
0: Object
|
|
2: Object
|
|
length: 3
|
|
// calling forEach on data will result in the callback being called two
|
|
// times, with the index parameter matching the index of the key in the
|
|
// keyArray.
|
|
|
|
// arrayType == 'dense':
|
|
// data is a dense array containing three entries and having a length of 3,
|
|
// where data[1] is of type undefined:
|
|
[Object, undefined, Object]
|
|
0: Object
|
|
1: undefined
|
|
2: Object
|
|
length: 3
|
|
// calling forEach on data will result in the callback being called three
|
|
// times, with the index parameter matching the index of the key in the
|
|
// keyArray, but the second call will have undefined as first argument.
|
|
|
|
// arrayType == 'skip':
|
|
// data is a dense array containing two entries and having a length of 2:
|
|
[Object, Object]
|
|
0: Object
|
|
1: Object
|
|
length: 2
|
|
// calling forEach on data will result in the callback being called two
|
|
// times, with the index parameter not matching the index of the key in the
|
|
// keyArray.
|
|
*/
|
|
getBatch: function (keyArray, onSuccess, onError, arrayType) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
arrayType || (arrayType = 'sparse');
|
|
|
|
if (Object.prototype.toString.call(keyArray) != '[object Array]') {
|
|
onError(new Error('keyArray argument must be of type Array.'));
|
|
} else if (keyArray.length === 0) {
|
|
return onSuccess([]);
|
|
}
|
|
|
|
var data = [];
|
|
var count = keyArray.length;
|
|
var called = false;
|
|
var hasSuccess = false;
|
|
var result = null;
|
|
|
|
var batchTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
|
|
batchTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
batchTransaction.onabort = onError;
|
|
batchTransaction.onerror = onError;
|
|
|
|
var onItemSuccess = function (event) {
|
|
if (event.target.result || arrayType == 'dense') {
|
|
data.push(event.target.result);
|
|
} else if (arrayType == 'sparse') {
|
|
data.length++;
|
|
}
|
|
count--;
|
|
if (count === 0) {
|
|
called = true;
|
|
hasSuccess = true;
|
|
result = data;
|
|
}
|
|
};
|
|
|
|
keyArray.forEach(function (key) {
|
|
|
|
var onItemError = function (err) {
|
|
called = true;
|
|
result = err;
|
|
onError(err);
|
|
batchTransaction.abort();
|
|
};
|
|
|
|
var getRequest = batchTransaction.objectStore(this.storeName).get(key);
|
|
getRequest.onsuccess = onItemSuccess;
|
|
getRequest.onerror = onItemError;
|
|
|
|
}, this);
|
|
|
|
return batchTransaction;
|
|
},
|
|
|
|
/**
|
|
* Fetches all entries in the store.
|
|
*
|
|
* @param {Function} [onSuccess] A callback that is called if the operation
|
|
* was successful. Will receive an array of objects.
|
|
* @param {Function} [onError] A callback that will be called if an error
|
|
* occurred during the operation.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
getAll: function (onSuccess, onError) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
var getAllTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
|
|
var store = getAllTransaction.objectStore(this.storeName);
|
|
if (store.getAll) {
|
|
this._getAllNative(getAllTransaction, store, onSuccess, onError);
|
|
} else {
|
|
this._getAllCursor(getAllTransaction, store, onSuccess, onError);
|
|
}
|
|
|
|
return getAllTransaction;
|
|
},
|
|
|
|
/**
|
|
* Implements getAll for IDB implementations that have a non-standard
|
|
* getAll() method.
|
|
*
|
|
* @param {IDBTransaction} getAllTransaction An open READ transaction.
|
|
* @param {IDBObjectStore} store A reference to the store.
|
|
* @param {Function} onSuccess A callback that will be called if the
|
|
* operation was successful.
|
|
* @param {Function} onError A callback that will be called if an
|
|
* error occurred during the operation.
|
|
* @private
|
|
*/
|
|
_getAllNative: function (getAllTransaction, store, onSuccess, onError) {
|
|
var hasSuccess = false,
|
|
result = null;
|
|
|
|
getAllTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
getAllTransaction.onabort = onError;
|
|
getAllTransaction.onerror = onError;
|
|
|
|
var getAllRequest = store.getAll();
|
|
getAllRequest.onsuccess = function (event) {
|
|
hasSuccess = true;
|
|
result = event.target.result;
|
|
};
|
|
getAllRequest.onerror = onError;
|
|
},
|
|
|
|
/**
|
|
* Implements getAll for IDB implementations that do not have a getAll()
|
|
* method.
|
|
*
|
|
* @param {IDBTransaction} getAllTransaction An open READ transaction.
|
|
* @param {IDBObjectStore} store A reference to the store.
|
|
* @param {Function} onSuccess A callback that will be called if the
|
|
* operation was successful.
|
|
* @param {Function} onError A callback that will be called if an
|
|
* error occurred during the operation.
|
|
* @private
|
|
*/
|
|
_getAllCursor: function (getAllTransaction, store, onSuccess, onError) {
|
|
var all = [],
|
|
hasSuccess = false,
|
|
result = null;
|
|
|
|
getAllTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
getAllTransaction.onabort = onError;
|
|
getAllTransaction.onerror = onError;
|
|
|
|
var cursorRequest = store.openCursor();
|
|
cursorRequest.onsuccess = function (event) {
|
|
var cursor = event.target.result;
|
|
if (cursor) {
|
|
all.push(cursor.value);
|
|
cursor['continue']();
|
|
}
|
|
else {
|
|
hasSuccess = true;
|
|
result = all;
|
|
}
|
|
};
|
|
cursorRequest.onError = onError;
|
|
},
|
|
|
|
/**
|
|
* Clears the store, i.e. deletes all entries in the store.
|
|
*
|
|
* @param {Function} [onSuccess] A callback that will be called if the
|
|
* operation was successful.
|
|
* @param {Function} [onError] A callback that will be called if an
|
|
* error occurred during the operation.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
clear: function (onSuccess, onError) {
|
|
onError || (onError = defaultErrorHandler);
|
|
onSuccess || (onSuccess = defaultSuccessHandler);
|
|
|
|
var hasSuccess = false,
|
|
result = null;
|
|
|
|
var clearTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
|
|
clearTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
clearTransaction.onabort = onError;
|
|
clearTransaction.onerror = onError;
|
|
|
|
var clearRequest = clearTransaction.objectStore(this.storeName).clear();
|
|
clearRequest.onsuccess = function (event) {
|
|
hasSuccess = true;
|
|
result = event.target.result;
|
|
};
|
|
clearRequest.onerror = onError;
|
|
|
|
return clearTransaction;
|
|
},
|
|
|
|
/**
|
|
* Checks if an id property needs to present on a object and adds one if
|
|
* necessary.
|
|
*
|
|
* @param {Object} dataObj The data object that is about to be stored
|
|
* @private
|
|
*/
|
|
_addIdPropertyIfNeeded: function (dataObj) {
|
|
if (typeof dataObj[this.keyPath] == 'undefined') {
|
|
dataObj[this.keyPath] = this._insertIdCount++ + Date.now();
|
|
}
|
|
},
|
|
|
|
/************
|
|
* indexing *
|
|
************/
|
|
|
|
/**
|
|
* Returns a DOMStringList of index names of the store.
|
|
*
|
|
* @return {DOMStringList} The list of index names
|
|
*/
|
|
getIndexList: function () {
|
|
return this.store.indexNames;
|
|
},
|
|
|
|
/**
|
|
* Checks if an index with the given name exists in the store.
|
|
*
|
|
* @param {String} indexName The name of the index to look for
|
|
* @return {Boolean} Whether the store contains an index with the given name
|
|
*/
|
|
hasIndex: function (indexName) {
|
|
return this.store.indexNames.contains(indexName);
|
|
},
|
|
|
|
/**
|
|
* Normalizes an object containing index data and assures that all
|
|
* properties are set.
|
|
*
|
|
* @param {Object} indexData The index data object to normalize
|
|
* @param {String} indexData.name The name of the index
|
|
* @param {String} [indexData.keyPath] The key path of the index
|
|
* @param {Boolean} [indexData.unique] Whether the index is unique
|
|
* @param {Boolean} [indexData.multiEntry] Whether the index is multi entry
|
|
*/
|
|
normalizeIndexData: function (indexData) {
|
|
indexData.keyPath = indexData.keyPath || indexData.name;
|
|
indexData.unique = !!indexData.unique;
|
|
indexData.multiEntry = !!indexData.multiEntry;
|
|
},
|
|
|
|
/**
|
|
* Checks if an actual index complies with an expected index.
|
|
*
|
|
* @param {IDBIndex} actual The actual index found in the store
|
|
* @param {Object} expected An Object describing an expected index
|
|
* @return {Boolean} Whether both index definitions are identical
|
|
*/
|
|
indexComplies: function (actual, expected) {
|
|
var complies = ['keyPath', 'unique', 'multiEntry'].every(function (key) {
|
|
// IE10 returns undefined for no multiEntry
|
|
if (key == 'multiEntry' && actual[key] === undefined && expected[key] === false) {
|
|
return true;
|
|
}
|
|
// Compound keys
|
|
if (key == 'keyPath' && Object.prototype.toString.call(expected[key]) == '[object Array]') {
|
|
var exp = expected.keyPath;
|
|
var act = actual.keyPath;
|
|
|
|
// IE10 can't handle keyPath sequences and stores them as a string.
|
|
// The index will be unusable there, but let's still return true if
|
|
// the keyPath sequence matches.
|
|
if (typeof act == 'string') {
|
|
return exp.toString() == act;
|
|
}
|
|
|
|
// Chrome/Opera stores keyPath squences as DOMStringList, Firefox
|
|
// as Array
|
|
if (!(typeof act.contains == 'function' || typeof act.indexOf == 'function')) {
|
|
return false;
|
|
}
|
|
|
|
if (act.length !== exp.length) {
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0, m = exp.length; i < m; i++) {
|
|
if (!( (act.contains && act.contains(exp[i])) || act.indexOf(exp[i] !== -1) )) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return expected[key] == actual[key];
|
|
});
|
|
return complies;
|
|
},
|
|
|
|
/**********
|
|
* cursor *
|
|
**********/
|
|
|
|
/**
|
|
* Iterates over the store using the given options and calling onItem
|
|
* for each entry matching the options.
|
|
*
|
|
* @param {Function} onItem A callback to be called for each match
|
|
* @param {Object} [options] An object defining specific options
|
|
* @param {String} [options.index=null] A name of an IDBIndex to operate on
|
|
* @param {String} [options.order=ASC] The order in which to provide the
|
|
* results, can be 'DESC' or 'ASC'
|
|
* @param {Boolean} [options.autoContinue=true] Whether to automatically
|
|
* iterate the cursor to the next result
|
|
* @param {Boolean} [options.filterDuplicates=false] Whether to exclude
|
|
* duplicate matches
|
|
* @param {IDBKeyRange} [options.keyRange=null] An IDBKeyRange to use
|
|
* @param {Boolean} [options.writeAccess=false] Whether grant write access
|
|
* to the store in the onItem callback
|
|
* @param {Function} [options.onEnd=null] A callback to be called after
|
|
* iteration has ended
|
|
* @param {Function} [options.onError=throw] A callback to be called
|
|
* if an error occurred during the operation.
|
|
* @param {Number} [options.limit=Infinity] Limit the number of returned
|
|
* results to this number
|
|
* @param {Number} [options.offset=0] Skip the provided number of results
|
|
* in the resultset
|
|
* @param {Boolean} [options.allowItemRejection=false] Allows the onItem
|
|
* function to return a Boolean to accept or reject the current item
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
iterate: function (onItem, options) {
|
|
options = mixin({
|
|
index: null,
|
|
order: 'ASC',
|
|
autoContinue: true,
|
|
filterDuplicates: false,
|
|
keyRange: null,
|
|
writeAccess: false,
|
|
onEnd: null,
|
|
onError: defaultErrorHandler,
|
|
limit: Infinity,
|
|
offset: 0,
|
|
allowItemRejection: false
|
|
}, options || {});
|
|
|
|
var directionType = options.order.toLowerCase() == 'desc' ? 'PREV' : 'NEXT';
|
|
if (options.filterDuplicates) {
|
|
directionType += '_NO_DUPLICATE';
|
|
}
|
|
|
|
var hasSuccess = false;
|
|
var cursorTransaction = this.db.transaction([this.storeName], this.consts[options.writeAccess ? 'READ_WRITE' : 'READ_ONLY']);
|
|
var cursorTarget = cursorTransaction.objectStore(this.storeName);
|
|
if (options.index) {
|
|
cursorTarget = cursorTarget.index(options.index);
|
|
}
|
|
var recordCount = 0;
|
|
|
|
cursorTransaction.oncomplete = function () {
|
|
if (!hasSuccess) {
|
|
options.onError(null);
|
|
return;
|
|
}
|
|
if (options.onEnd) {
|
|
options.onEnd();
|
|
} else {
|
|
onItem(null);
|
|
}
|
|
};
|
|
cursorTransaction.onabort = options.onError;
|
|
cursorTransaction.onerror = options.onError;
|
|
|
|
var cursorRequest = cursorTarget.openCursor(options.keyRange, this.consts[directionType]);
|
|
cursorRequest.onerror = options.onError;
|
|
cursorRequest.onsuccess = function (event) {
|
|
var cursor = event.target.result;
|
|
if (cursor) {
|
|
if (options.offset) {
|
|
cursor.advance(options.offset);
|
|
options.offset = 0;
|
|
} else {
|
|
var onItemReturn = onItem(cursor.value, cursor, cursorTransaction);
|
|
if (!options.allowItemRejection || onItemReturn !== false) {
|
|
recordCount++;
|
|
}
|
|
if (options.autoContinue) {
|
|
if (recordCount + options.offset < options.limit) {
|
|
cursor['continue']();
|
|
} else {
|
|
hasSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
hasSuccess = true;
|
|
}
|
|
};
|
|
|
|
return cursorTransaction;
|
|
},
|
|
|
|
/**
|
|
* Runs a query against the store and passes an array containing matched
|
|
* objects to the success handler.
|
|
*
|
|
* @param {Function} onSuccess A callback to be called when the operation
|
|
* was successful.
|
|
* @param {Object} [options] An object defining specific options
|
|
* @param {String} [options.index=null] A name of an IDBIndex to operate on
|
|
* @param {String} [options.order=ASC] The order in which to provide the
|
|
* results, can be 'DESC' or 'ASC'
|
|
* @param {Boolean} [options.filterDuplicates=false] Whether to exclude
|
|
* duplicate matches
|
|
* @param {IDBKeyRange} [options.keyRange=null] An IDBKeyRange to use
|
|
* @param {Function} [options.onError=throw] A callback to be called
|
|
* if an error occurred during the operation.
|
|
* @param {Number} [options.limit=Infinity] Limit the number of returned
|
|
* results to this number
|
|
* @param {Number} [options.offset=0] Skip the provided number of results
|
|
* in the resultset
|
|
* @param {Function} [options.filter=null] A custom filter function to
|
|
* apply to query resuts before returning. Must return `false` to reject
|
|
* an item. Can be combined with keyRanges.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
query: function (onSuccess, options) {
|
|
var result = [],
|
|
processedItems = 0;
|
|
options = options || {};
|
|
options.autoContinue = true;
|
|
options.writeAccess = false;
|
|
options.allowItemRejection = !!options.filter;
|
|
options.onEnd = function () {
|
|
onSuccess(result, processedItems);
|
|
};
|
|
return this.iterate(function (item) {
|
|
processedItems++;
|
|
var accept = options.filter ? options.filter(item) : true;
|
|
if (accept !== false) {
|
|
result.push(item);
|
|
}
|
|
return accept;
|
|
}, options);
|
|
},
|
|
|
|
/**
|
|
*
|
|
* Runs a query against the store, but only returns the number of matches
|
|
* instead of the matches itself.
|
|
*
|
|
* @param {Function} onSuccess A callback to be called if the opration
|
|
* was successful.
|
|
* @param {Object} [options] An object defining specific options
|
|
* @param {String} [options.index=null] A name of an IDBIndex to operate on
|
|
* @param {IDBKeyRange} [options.keyRange=null] An IDBKeyRange to use
|
|
* @param {Function} [options.onError=throw] A callback to be called if an error
|
|
* occurred during the operation.
|
|
* @returns {IDBTransaction} The transaction used for this operation.
|
|
*/
|
|
count: function (onSuccess, options) {
|
|
|
|
options = mixin({
|
|
index: null,
|
|
keyRange: null
|
|
}, options || {});
|
|
|
|
var onError = options.onError || defaultErrorHandler;
|
|
|
|
var hasSuccess = false,
|
|
result = null;
|
|
|
|
var cursorTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
|
|
cursorTransaction.oncomplete = function () {
|
|
var callback = hasSuccess ? onSuccess : onError;
|
|
callback(result);
|
|
};
|
|
cursorTransaction.onabort = onError;
|
|
cursorTransaction.onerror = onError;
|
|
|
|
var cursorTarget = cursorTransaction.objectStore(this.storeName);
|
|
if (options.index) {
|
|
cursorTarget = cursorTarget.index(options.index);
|
|
}
|
|
var countRequest = cursorTarget.count(options.keyRange);
|
|
countRequest.onsuccess = function (evt) {
|
|
hasSuccess = true;
|
|
result = evt.target.result;
|
|
};
|
|
countRequest.onError = onError;
|
|
|
|
return cursorTransaction;
|
|
},
|
|
|
|
/**************/
|
|
/* key ranges */
|
|
/**************/
|
|
|
|
/**
|
|
* Creates a key range using specified options. This key range can be
|
|
* handed over to the count() and iterate() methods.
|
|
*
|
|
* Note: You must provide at least one or both of "lower" or "upper" value.
|
|
*
|
|
* @param {Object} options The options for the key range to create
|
|
* @param {*} [options.lower] The lower bound
|
|
* @param {Boolean} [options.excludeLower] Whether to exclude the lower
|
|
* bound passed in options.lower from the key range
|
|
* @param {*} [options.upper] The upper bound
|
|
* @param {Boolean} [options.excludeUpper] Whether to exclude the upper
|
|
* bound passed in options.upper from the key range
|
|
* @param {*} [options.only] A single key value. Use this if you need a key
|
|
* range that only includes one value for a key. Providing this
|
|
* property invalidates all other properties.
|
|
* @return {IDBKeyRange} The IDBKeyRange representing the specified options
|
|
*/
|
|
makeKeyRange: function (options) {
|
|
/*jshint onecase:true */
|
|
var keyRange,
|
|
hasLower = typeof options.lower != 'undefined',
|
|
hasUpper = typeof options.upper != 'undefined',
|
|
isOnly = typeof options.only != 'undefined';
|
|
|
|
switch (true) {
|
|
case isOnly:
|
|
keyRange = this.keyRange.only(options.only);
|
|
break;
|
|
case hasLower && hasUpper:
|
|
keyRange = this.keyRange.bound(options.lower, options.upper, options.excludeLower, options.excludeUpper);
|
|
break;
|
|
case hasLower:
|
|
keyRange = this.keyRange.lowerBound(options.lower, options.excludeLower);
|
|
break;
|
|
case hasUpper:
|
|
keyRange = this.keyRange.upperBound(options.upper, options.excludeUpper);
|
|
break;
|
|
default:
|
|
throw new Error('Cannot create KeyRange. Provide one or both of "lower" or "upper" value, or an "only" value.');
|
|
}
|
|
|
|
return keyRange;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/** helpers **/
|
|
var empty = {};
|
|
|
|
function mixin (target, source) {
|
|
var name, s;
|
|
for (name in source) {
|
|
s = source[name];
|
|
if (s !== empty[name] && s !== target[name]) {
|
|
target[name] = s;
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
function hasVersionError(errorEvent) {
|
|
if ('error' in errorEvent.target) {
|
|
return errorEvent.target.error.name == 'VersionError';
|
|
} else if ('errorCode' in errorEvent.target) {
|
|
return errorEvent.target.errorCode == 12;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
IDBStore.prototype = proto;
|
|
IDBStore.version = proto.version;
|
|
|
|
return IDBStore;
|
|
|
|
}, this);
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
var eMax = (1 << eLen) - 1
|
|
var eBias = eMax >> 1
|
|
var nBits = -7
|
|
var i = isLE ? (nBytes - 1) : 0
|
|
var d = isLE ? -1 : 1
|
|
var s = buffer[offset + i]
|
|
|
|
i += d
|
|
|
|
e = s & ((1 << (-nBits)) - 1)
|
|
s >>= (-nBits)
|
|
nBits += eLen
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
m = e & ((1 << (-nBits)) - 1)
|
|
e >>= (-nBits)
|
|
nBits += mLen
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
if (e === 0) {
|
|
e = 1 - eBias
|
|
} else if (e === eMax) {
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
|
} else {
|
|
m = m + Math.pow(2, mLen)
|
|
e = e - eBias
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
|
}
|
|
|
|
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c
|
|
var eLen = nBytes * 8 - mLen - 1
|
|
var eMax = (1 << eLen) - 1
|
|
var eBias = eMax >> 1
|
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
|
|
var i = isLE ? 0 : (nBytes - 1)
|
|
var d = isLE ? 1 : -1
|
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
|
|
|
value = Math.abs(value)
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0
|
|
e = eMax
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2)
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--
|
|
c *= 2
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias)
|
|
}
|
|
if (value * c >= 2) {
|
|
e++
|
|
c /= 2
|
|
}
|
|
|
|
if (e + eBias >= eMax) {
|
|
m = 0
|
|
e = eMax
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen)
|
|
e = e + eBias
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
|
e = 0
|
|
}
|
|
}
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
|
|
e = (e << mLen) | m
|
|
eLen += mLen
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
|
|
buffer[offset + i - d] |= s * 128
|
|
}
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
/*!
|
|
* Determine if an object is a Buffer
|
|
*
|
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* @license MIT
|
|
*/
|
|
|
|
// The _isBuffer check is for Safari 5-7 support, because it's missing
|
|
// Object.prototype.constructor. Remove this eventually
|
|
module.exports = function (obj) {
|
|
return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
|
|
}
|
|
|
|
function isBuffer (obj) {
|
|
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
|
|
}
|
|
|
|
// For Node v0.10 support. Remove this eventually.
|
|
function isSlowBuffer (obj) {
|
|
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
|
|
}
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
var toString = {}.toString;
|
|
|
|
module.exports = Array.isArray || function (arr) {
|
|
return toString.call(arr) == '[object Array]';
|
|
};
|
|
|
|
},{}],11:[function(require,module,exports){
|
|
var Buffer = require('buffer').Buffer;
|
|
|
|
module.exports = isBuffer;
|
|
|
|
function isBuffer (o) {
|
|
return Buffer.isBuffer(o)
|
|
|| /\[object (.+Array|Array.+)\]/.test(Object.prototype.toString.call(o));
|
|
}
|
|
|
|
},{"buffer":6}],12:[function(require,module,exports){
|
|
(function (Buffer){
|
|
module.exports = Level
|
|
|
|
var IDB = require('idb-wrapper')
|
|
var AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
|
|
var util = require('util')
|
|
var Iterator = require('./iterator')
|
|
var isBuffer = require('isbuffer')
|
|
var xtend = require('xtend')
|
|
var toBuffer = require('typedarray-to-buffer')
|
|
|
|
function Level(location) {
|
|
if (!(this instanceof Level)) return new Level(location)
|
|
if (!location) throw new Error("constructor requires at least a location argument")
|
|
this.IDBOptions = {}
|
|
this.location = location
|
|
}
|
|
|
|
util.inherits(Level, AbstractLevelDOWN)
|
|
|
|
Level.prototype._open = function(options, callback) {
|
|
var self = this
|
|
|
|
var idbOpts = {
|
|
storeName: this.location,
|
|
autoIncrement: false,
|
|
keyPath: null,
|
|
onStoreReady: function () {
|
|
callback && callback(null, self.idb)
|
|
},
|
|
onError: function(err) {
|
|
callback && callback(err)
|
|
}
|
|
}
|
|
|
|
xtend(idbOpts, options)
|
|
this.IDBOptions = idbOpts
|
|
this.idb = new IDB(idbOpts)
|
|
}
|
|
|
|
Level.prototype._get = function (key, options, callback) {
|
|
this.idb.get(key, function (value) {
|
|
if (value === undefined) {
|
|
// 'NotFound' error, consistent with LevelDOWN API
|
|
return callback(new Error('NotFound'))
|
|
}
|
|
// by default return buffers, unless explicitly told not to
|
|
var asBuffer = true
|
|
if (options.asBuffer === false) asBuffer = false
|
|
if (options.raw) asBuffer = false
|
|
if (asBuffer) {
|
|
if (value instanceof Uint8Array) value = toBuffer(value)
|
|
else value = new Buffer(String(value))
|
|
}
|
|
return callback(null, value, key)
|
|
}, callback)
|
|
}
|
|
|
|
Level.prototype._del = function(id, options, callback) {
|
|
this.idb.remove(id, callback, callback)
|
|
}
|
|
|
|
Level.prototype._put = function (key, value, options, callback) {
|
|
if (value instanceof ArrayBuffer) {
|
|
value = toBuffer(new Uint8Array(value))
|
|
}
|
|
var obj = this.convertEncoding(key, value, options)
|
|
if (Buffer.isBuffer(obj.value)) {
|
|
if (typeof value.toArrayBuffer === 'function') {
|
|
obj.value = new Uint8Array(value.toArrayBuffer())
|
|
} else {
|
|
obj.value = new Uint8Array(value)
|
|
}
|
|
}
|
|
this.idb.put(obj.key, obj.value, function() { callback() }, callback)
|
|
}
|
|
|
|
Level.prototype.convertEncoding = function(key, value, options) {
|
|
if (options.raw) return {key: key, value: value}
|
|
if (value) {
|
|
var stringed = value.toString()
|
|
if (stringed === 'NaN') value = 'NaN'
|
|
}
|
|
var valEnc = options.valueEncoding
|
|
var obj = {key: key, value: value}
|
|
if (value && (!valEnc || valEnc !== 'binary')) {
|
|
if (typeof obj.value !== 'object') {
|
|
obj.value = stringed
|
|
}
|
|
}
|
|
return obj
|
|
}
|
|
|
|
Level.prototype.iterator = function (options) {
|
|
if (typeof options !== 'object') options = {}
|
|
return new Iterator(this.idb, options)
|
|
}
|
|
|
|
Level.prototype._batch = function (array, options, callback) {
|
|
var op
|
|
var i
|
|
var k
|
|
var copiedOp
|
|
var currentOp
|
|
var modified = []
|
|
|
|
if (array.length === 0) return setTimeout(callback, 0)
|
|
|
|
for (i = 0; i < array.length; i++) {
|
|
copiedOp = {}
|
|
currentOp = array[i]
|
|
modified[i] = copiedOp
|
|
|
|
var converted = this.convertEncoding(currentOp.key, currentOp.value, options)
|
|
currentOp.key = converted.key
|
|
currentOp.value = converted.value
|
|
|
|
for (k in currentOp) {
|
|
if (k === 'type' && currentOp[k] == 'del') {
|
|
copiedOp[k] = 'remove'
|
|
} else {
|
|
copiedOp[k] = currentOp[k]
|
|
}
|
|
}
|
|
}
|
|
|
|
return this.idb.batch(modified, function(){ callback() }, callback)
|
|
}
|
|
|
|
Level.prototype._close = function (callback) {
|
|
this.idb.db.close()
|
|
callback()
|
|
}
|
|
|
|
Level.prototype._approximateSize = function (start, end, callback) {
|
|
var err = new Error('Not implemented')
|
|
if (callback)
|
|
return callback(err)
|
|
|
|
throw err
|
|
}
|
|
|
|
Level.prototype._isBuffer = function (obj) {
|
|
return Buffer.isBuffer(obj)
|
|
}
|
|
|
|
Level.destroy = function (db, callback) {
|
|
if (typeof db === 'object') {
|
|
var prefix = db.IDBOptions.storePrefix || 'IDBWrapper-'
|
|
var dbname = db.location
|
|
} else {
|
|
var prefix = 'IDBWrapper-'
|
|
var dbname = db
|
|
}
|
|
var request = indexedDB.deleteDatabase(prefix + dbname)
|
|
request.onsuccess = function() {
|
|
callback()
|
|
}
|
|
request.onerror = function(err) {
|
|
callback(err)
|
|
}
|
|
}
|
|
|
|
var checkKeyValue = Level.prototype._checkKeyValue = function (obj, type) {
|
|
if (obj === null || obj === undefined)
|
|
return new Error(type + ' cannot be `null` or `undefined`')
|
|
if (obj === null || obj === undefined)
|
|
return new Error(type + ' cannot be `null` or `undefined`')
|
|
if (isBuffer(obj) && obj.byteLength === 0)
|
|
return new Error(type + ' cannot be an empty ArrayBuffer')
|
|
if (String(obj) === '')
|
|
return new Error(type + ' cannot be an empty String')
|
|
if (obj.length === 0)
|
|
return new Error(type + ' cannot be an empty Array')
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"./iterator":13,"abstract-leveldown":3,"buffer":6,"idb-wrapper":7,"isbuffer":11,"typedarray-to-buffer":34,"util":37,"xtend":15}],13:[function(require,module,exports){
|
|
var util = require('util')
|
|
var AbstractIterator = require('abstract-leveldown').AbstractIterator
|
|
var ltgt = require('ltgt')
|
|
|
|
module.exports = Iterator
|
|
|
|
function Iterator (db, options) {
|
|
if (!options) options = {}
|
|
this.options = options
|
|
AbstractIterator.call(this, db)
|
|
this._order = options.reverse ? 'DESC': 'ASC'
|
|
this._limit = options.limit
|
|
this._count = 0
|
|
this._done = false
|
|
var lower = ltgt.lowerBound(options)
|
|
var upper = ltgt.upperBound(options)
|
|
try {
|
|
this._keyRange = lower || upper ? this.db.makeKeyRange({
|
|
lower: lower,
|
|
upper: upper,
|
|
excludeLower: ltgt.lowerBoundExclusive(options),
|
|
excludeUpper: ltgt.upperBoundExclusive(options)
|
|
}) : null
|
|
} catch (e) {
|
|
// The lower key is greater than the upper key.
|
|
// IndexedDB throws an error, but we'll just return 0 results.
|
|
this._keyRangeError = true
|
|
}
|
|
this.callback = null
|
|
}
|
|
|
|
util.inherits(Iterator, AbstractIterator)
|
|
|
|
Iterator.prototype.createIterator = function() {
|
|
var self = this
|
|
|
|
self.iterator = self.db.iterate(function () {
|
|
self.onItem.apply(self, arguments)
|
|
}, {
|
|
keyRange: self._keyRange,
|
|
autoContinue: false,
|
|
order: self._order,
|
|
onError: function(err) { console.log('horrible error', err) },
|
|
})
|
|
}
|
|
|
|
// TODO the limit implementation here just ignores all reads after limit has been reached
|
|
// it should cancel the iterator instead but I don't know how
|
|
Iterator.prototype.onItem = function (value, cursor, cursorTransaction) {
|
|
if (!cursor && this.callback) {
|
|
this.callback()
|
|
this.callback = false
|
|
return
|
|
}
|
|
var shouldCall = true
|
|
|
|
if (!!this._limit && this._limit > 0 && this._count++ >= this._limit)
|
|
shouldCall = false
|
|
|
|
if (shouldCall) this.callback(false, cursor.key, cursor.value)
|
|
if (cursor) cursor['continue']()
|
|
}
|
|
|
|
Iterator.prototype._next = function (callback) {
|
|
if (!callback) return new Error('next() requires a callback argument')
|
|
if (this._keyRangeError) return callback()
|
|
if (!this._started) {
|
|
this.createIterator()
|
|
this._started = true
|
|
}
|
|
this.callback = callback
|
|
}
|
|
|
|
},{"abstract-leveldown":3,"ltgt":16,"util":37}],14:[function(require,module,exports){
|
|
module.exports = hasKeys
|
|
|
|
function hasKeys(source) {
|
|
return source !== null &&
|
|
(typeof source === "object" ||
|
|
typeof source === "function")
|
|
}
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
var Keys = require("object-keys")
|
|
var hasKeys = require("./has-keys")
|
|
|
|
module.exports = extend
|
|
|
|
function extend() {
|
|
var target = {}
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var source = arguments[i]
|
|
|
|
if (!hasKeys(source)) {
|
|
continue
|
|
}
|
|
|
|
var keys = Keys(source)
|
|
|
|
for (var j = 0; j < keys.length; j++) {
|
|
var name = keys[j]
|
|
target[name] = source[name]
|
|
}
|
|
}
|
|
|
|
return target
|
|
}
|
|
|
|
},{"./has-keys":14,"object-keys":18}],16:[function(require,module,exports){
|
|
(function (Buffer){
|
|
|
|
exports.compare = function (a, b) {
|
|
|
|
if(Buffer.isBuffer(a)) {
|
|
var l = Math.min(a.length, b.length)
|
|
for(var i = 0; i < l; i++) {
|
|
var cmp = a[i] - b[i]
|
|
if(cmp) return cmp
|
|
}
|
|
return a.length - b.length
|
|
}
|
|
|
|
return a < b ? -1 : a > b ? 1 : 0
|
|
}
|
|
|
|
function has(obj, key) {
|
|
return Object.hasOwnProperty.call(obj, key)
|
|
}
|
|
|
|
// to be compatible with the current abstract-leveldown tests
|
|
// nullish or empty strings.
|
|
// I could use !!val but I want to permit numbers and booleans,
|
|
// if possible.
|
|
|
|
function isDef (val) {
|
|
return val !== undefined && val !== ''
|
|
}
|
|
|
|
function has (range, name) {
|
|
return Object.hasOwnProperty.call(range, name)
|
|
}
|
|
|
|
function hasKey(range, name) {
|
|
return Object.hasOwnProperty.call(range, name) && name
|
|
}
|
|
|
|
var lowerBoundKey = exports.lowerBoundKey = function (range) {
|
|
return (
|
|
hasKey(range, 'gt')
|
|
|| hasKey(range, 'gte')
|
|
|| hasKey(range, 'min')
|
|
|| (range.reverse ? hasKey(range, 'end') : hasKey(range, 'start'))
|
|
|| undefined
|
|
)
|
|
}
|
|
|
|
var lowerBound = exports.lowerBound = function (range) {
|
|
var k = lowerBoundKey(range)
|
|
return k && range[k]
|
|
}
|
|
|
|
exports.lowerBoundInclusive = function (range) {
|
|
return has(range, 'gt') ? false : true
|
|
}
|
|
|
|
exports.upperBoundInclusive =
|
|
function (range) {
|
|
return has(range, 'lt') || !range.minEx ? false : true
|
|
}
|
|
|
|
var lowerBoundExclusive = exports.lowerBoundExclusive =
|
|
function (range) {
|
|
return has(range, 'gt') || range.minEx ? true : false
|
|
}
|
|
|
|
var upperBoundExclusive = exports.upperBoundExclusive =
|
|
function (range) {
|
|
return has(range, 'lt') ? true : false
|
|
}
|
|
|
|
var upperBoundKey = exports.upperBoundKey = function (range) {
|
|
return (
|
|
hasKey(range, 'lt')
|
|
|| hasKey(range, 'lte')
|
|
|| hasKey(range, 'max')
|
|
|| (range.reverse ? hasKey(range, 'start') : hasKey(range, 'end'))
|
|
|| undefined
|
|
)
|
|
}
|
|
|
|
var upperBound = exports.upperBound = function (range) {
|
|
var k = upperBoundKey(range)
|
|
return k && range[k]
|
|
}
|
|
|
|
function id (e) { return e }
|
|
|
|
exports.toLtgt = function (range, _range, map, lower, upper) {
|
|
_range = _range || {}
|
|
map = map || id
|
|
var defaults = arguments.length > 3
|
|
var lb = exports.lowerBoundKey(range)
|
|
var ub = exports.upperBoundKey(range)
|
|
if(lb) {
|
|
if(lb === 'gt') _range.gt = map(range.gt, false)
|
|
else _range.gte = map(range[lb], false)
|
|
}
|
|
else if(defaults)
|
|
_range.gte = map(lower, false)
|
|
|
|
if(ub) {
|
|
if(ub === 'lt') _range.lt = map(range.lt, true)
|
|
else _range.lte = map(range[ub], true)
|
|
}
|
|
else if(defaults)
|
|
_range.lte = map(upper, true)
|
|
|
|
if(range.reverse != null)
|
|
_range.reverse = !!range.reverse
|
|
|
|
//if range was used mutably
|
|
//(in level-sublevel it's part of an options object
|
|
//that has more properties on it.)
|
|
if(has(_range, 'max')) delete _range.max
|
|
if(has(_range, 'min')) delete _range.min
|
|
if(has(_range, 'start')) delete _range.start
|
|
if(has(_range, 'end')) delete _range.end
|
|
|
|
return _range
|
|
}
|
|
|
|
exports.contains = function (range, key, compare) {
|
|
compare = compare || exports.compare
|
|
|
|
var lb = lowerBound(range)
|
|
if(isDef(lb)) {
|
|
var cmp = compare(key, lb)
|
|
if(cmp < 0 || (cmp === 0 && lowerBoundExclusive(range)))
|
|
return false
|
|
}
|
|
|
|
var ub = upperBound(range)
|
|
if(isDef(ub)) {
|
|
var cmp = compare(key, ub)
|
|
if(cmp > 0 || (cmp === 0) && upperBoundExclusive(range))
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
exports.filter = function (range, compare) {
|
|
return function (key) {
|
|
return exports.contains(range, key, compare)
|
|
}
|
|
}
|
|
|
|
}).call(this,{"isBuffer":require("../is-buffer/index.js")})
|
|
},{"../is-buffer/index.js":9}],17:[function(require,module,exports){
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var toString = Object.prototype.toString;
|
|
|
|
var isFunction = function (fn) {
|
|
var isFunc = (typeof fn === 'function' && !(fn instanceof RegExp)) || toString.call(fn) === '[object Function]';
|
|
if (!isFunc && typeof window !== 'undefined') {
|
|
isFunc = fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt;
|
|
}
|
|
return isFunc;
|
|
};
|
|
|
|
module.exports = function forEach(obj, fn) {
|
|
if (!isFunction(fn)) {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
var i, k,
|
|
isString = typeof obj === 'string',
|
|
l = obj.length,
|
|
context = arguments.length > 2 ? arguments[2] : null;
|
|
if (l === +l) {
|
|
for (i = 0; i < l; i++) {
|
|
if (context === null) {
|
|
fn(isString ? obj.charAt(i) : obj[i], i, obj);
|
|
} else {
|
|
fn.call(context, isString ? obj.charAt(i) : obj[i], i, obj);
|
|
}
|
|
}
|
|
} else {
|
|
for (k in obj) {
|
|
if (hasOwn.call(obj, k)) {
|
|
if (context === null) {
|
|
fn(obj[k], k, obj);
|
|
} else {
|
|
fn.call(context, obj[k], k, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
},{}],18:[function(require,module,exports){
|
|
module.exports = Object.keys || require('./shim');
|
|
|
|
|
|
},{"./shim":20}],19:[function(require,module,exports){
|
|
var toString = Object.prototype.toString;
|
|
|
|
module.exports = function isArguments(value) {
|
|
var str = toString.call(value);
|
|
var isArguments = str === '[object Arguments]';
|
|
if (!isArguments) {
|
|
isArguments = str !== '[object Array]'
|
|
&& value !== null
|
|
&& typeof value === 'object'
|
|
&& typeof value.length === 'number'
|
|
&& value.length >= 0
|
|
&& toString.call(value.callee) === '[object Function]';
|
|
}
|
|
return isArguments;
|
|
};
|
|
|
|
|
|
},{}],20:[function(require,module,exports){
|
|
(function () {
|
|
"use strict";
|
|
|
|
// modified from https://github.com/kriskowal/es5-shim
|
|
var has = Object.prototype.hasOwnProperty,
|
|
toString = Object.prototype.toString,
|
|
forEach = require('./foreach'),
|
|
isArgs = require('./isArguments'),
|
|
hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
|
|
hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
|
|
dontEnums = [
|
|
"toString",
|
|
"toLocaleString",
|
|
"valueOf",
|
|
"hasOwnProperty",
|
|
"isPrototypeOf",
|
|
"propertyIsEnumerable",
|
|
"constructor"
|
|
],
|
|
keysShim;
|
|
|
|
keysShim = function keys(object) {
|
|
var isObject = object !== null && typeof object === 'object',
|
|
isFunction = toString.call(object) === '[object Function]',
|
|
isArguments = isArgs(object),
|
|
theKeys = [];
|
|
|
|
if (!isObject && !isFunction && !isArguments) {
|
|
throw new TypeError("Object.keys called on a non-object");
|
|
}
|
|
|
|
if (isArguments) {
|
|
forEach(object, function (value) {
|
|
theKeys.push(value);
|
|
});
|
|
} else {
|
|
var name,
|
|
skipProto = hasProtoEnumBug && isFunction;
|
|
|
|
for (name in object) {
|
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
|
|
theKeys.push(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasDontEnumBug) {
|
|
var ctor = object.constructor,
|
|
skipConstructor = ctor && ctor.prototype === object;
|
|
|
|
forEach(dontEnums, function (dontEnum) {
|
|
if (!(skipConstructor && dontEnum === 'constructor') && has.call(object, dontEnum)) {
|
|
theKeys.push(dontEnum);
|
|
}
|
|
});
|
|
}
|
|
return theKeys;
|
|
};
|
|
|
|
module.exports = keysShim;
|
|
}());
|
|
|
|
|
|
},{"./foreach":17,"./isArguments":19}],21:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var zlib_inflate = require('./zlib/inflate');
|
|
var utils = require('./utils/common');
|
|
var strings = require('./utils/strings');
|
|
var c = require('./zlib/constants');
|
|
var msg = require('./zlib/messages');
|
|
var ZStream = require('./zlib/zstream');
|
|
var GZheader = require('./zlib/gzheader');
|
|
|
|
var toString = Object.prototype.toString;
|
|
|
|
/**
|
|
* class Inflate
|
|
*
|
|
* Generic JS-style wrapper for zlib calls. If you don't need
|
|
* streaming behaviour - use more simple functions: [[inflate]]
|
|
* and [[inflateRaw]].
|
|
**/
|
|
|
|
/* internal
|
|
* inflate.chunks -> Array
|
|
*
|
|
* Chunks of output data, if [[Inflate#onData]] not overriden.
|
|
**/
|
|
|
|
/**
|
|
* Inflate.result -> Uint8Array|Array|String
|
|
*
|
|
* Uncompressed result, generated by default [[Inflate#onData]]
|
|
* and [[Inflate#onEnd]] handlers. Filled after you push last chunk
|
|
* (call [[Inflate#push]] with `Z_FINISH` / `true` param) or if you
|
|
* push a chunk with explicit flush (call [[Inflate#push]] with
|
|
* `Z_SYNC_FLUSH` param).
|
|
**/
|
|
|
|
/**
|
|
* Inflate.err -> Number
|
|
*
|
|
* Error code after inflate finished. 0 (Z_OK) on success.
|
|
* Should be checked if broken data possible.
|
|
**/
|
|
|
|
/**
|
|
* Inflate.msg -> String
|
|
*
|
|
* Error message, if [[Inflate.err]] != 0
|
|
**/
|
|
|
|
|
|
/**
|
|
* new Inflate(options)
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Creates new inflator instance with specified params. Throws exception
|
|
* on bad params. Supported options:
|
|
*
|
|
* - `windowBits`
|
|
* - `dictionary`
|
|
*
|
|
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
|
* for more information on these.
|
|
*
|
|
* Additional options, for internal needs:
|
|
*
|
|
* - `chunkSize` - size of generated data chunks (16K by default)
|
|
* - `raw` (Boolean) - do raw inflate
|
|
* - `to` (String) - if equal to 'string', then result will be converted
|
|
* from utf8 to utf16 (javascript) string. When string output requested,
|
|
* chunk length can differ from `chunkSize`, depending on content.
|
|
*
|
|
* By default, when no options set, autodetect deflate/gzip data format via
|
|
* wrapper header.
|
|
*
|
|
* ##### Example:
|
|
*
|
|
* ```javascript
|
|
* var pako = require('pako')
|
|
* , chunk1 = Uint8Array([1,2,3,4,5,6,7,8,9])
|
|
* , chunk2 = Uint8Array([10,11,12,13,14,15,16,17,18,19]);
|
|
*
|
|
* var inflate = new pako.Inflate({ level: 3});
|
|
*
|
|
* inflate.push(chunk1, false);
|
|
* inflate.push(chunk2, true); // true -> last chunk
|
|
*
|
|
* if (inflate.err) { throw new Error(inflate.err); }
|
|
*
|
|
* console.log(inflate.result);
|
|
* ```
|
|
**/
|
|
function Inflate(options) {
|
|
if (!(this instanceof Inflate)) return new Inflate(options);
|
|
|
|
this.options = utils.assign({
|
|
chunkSize: 16384,
|
|
windowBits: 0,
|
|
to: ''
|
|
}, options || {});
|
|
|
|
var opt = this.options;
|
|
|
|
// Force window size for `raw` data, if not set directly,
|
|
// because we have no header for autodetect.
|
|
if (opt.raw && (opt.windowBits >= 0) && (opt.windowBits < 16)) {
|
|
opt.windowBits = -opt.windowBits;
|
|
if (opt.windowBits === 0) { opt.windowBits = -15; }
|
|
}
|
|
|
|
// If `windowBits` not defined (and mode not raw) - set autodetect flag for gzip/deflate
|
|
if ((opt.windowBits >= 0) && (opt.windowBits < 16) &&
|
|
!(options && options.windowBits)) {
|
|
opt.windowBits += 32;
|
|
}
|
|
|
|
// Gzip header has no info about windows size, we can do autodetect only
|
|
// for deflate. So, if window size not set, force it to max when gzip possible
|
|
if ((opt.windowBits > 15) && (opt.windowBits < 48)) {
|
|
// bit 3 (16) -> gzipped data
|
|
// bit 4 (32) -> autodetect gzip/deflate
|
|
if ((opt.windowBits & 15) === 0) {
|
|
opt.windowBits |= 15;
|
|
}
|
|
}
|
|
|
|
this.err = 0; // error code, if happens (0 = Z_OK)
|
|
this.msg = ''; // error message
|
|
this.ended = false; // used to avoid multiple onEnd() calls
|
|
this.chunks = []; // chunks of compressed data
|
|
|
|
this.strm = new ZStream();
|
|
this.strm.avail_out = 0;
|
|
|
|
var status = zlib_inflate.inflateInit2(
|
|
this.strm,
|
|
opt.windowBits
|
|
);
|
|
|
|
if (status !== c.Z_OK) {
|
|
throw new Error(msg[status]);
|
|
}
|
|
|
|
this.header = new GZheader();
|
|
|
|
zlib_inflate.inflateGetHeader(this.strm, this.header);
|
|
}
|
|
|
|
/**
|
|
* Inflate#push(data[, mode]) -> Boolean
|
|
* - data (Uint8Array|Array|ArrayBuffer|String): input data
|
|
* - mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.
|
|
* See constants. Skipped or `false` means Z_NO_FLUSH, `true` meansh Z_FINISH.
|
|
*
|
|
* Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
|
|
* new output chunks. Returns `true` on success. The last data block must have
|
|
* mode Z_FINISH (or `true`). That will flush internal pending buffers and call
|
|
* [[Inflate#onEnd]]. For interim explicit flushes (without ending the stream) you
|
|
* can use mode Z_SYNC_FLUSH, keeping the decompression context.
|
|
*
|
|
* On fail call [[Inflate#onEnd]] with error code and return false.
|
|
*
|
|
* We strongly recommend to use `Uint8Array` on input for best speed (output
|
|
* format is detected automatically). Also, don't skip last param and always
|
|
* use the same type in your code (boolean or number). That will improve JS speed.
|
|
*
|
|
* For regular `Array`-s make sure all elements are [0..255].
|
|
*
|
|
* ##### Example
|
|
*
|
|
* ```javascript
|
|
* push(chunk, false); // push one of data chunks
|
|
* ...
|
|
* push(chunk, true); // push last chunk
|
|
* ```
|
|
**/
|
|
Inflate.prototype.push = function (data, mode) {
|
|
var strm = this.strm;
|
|
var chunkSize = this.options.chunkSize;
|
|
var dictionary = this.options.dictionary;
|
|
var status, _mode;
|
|
var next_out_utf8, tail, utf8str;
|
|
var dict;
|
|
|
|
// Flag to properly process Z_BUF_ERROR on testing inflate call
|
|
// when we check that all output data was flushed.
|
|
var allowBufError = false;
|
|
|
|
if (this.ended) { return false; }
|
|
_mode = (mode === ~~mode) ? mode : ((mode === true) ? c.Z_FINISH : c.Z_NO_FLUSH);
|
|
|
|
// Convert data if needed
|
|
if (typeof data === 'string') {
|
|
// Only binary strings can be decompressed on practice
|
|
strm.input = strings.binstring2buf(data);
|
|
} else if (toString.call(data) === '[object ArrayBuffer]') {
|
|
strm.input = new Uint8Array(data);
|
|
} else {
|
|
strm.input = data;
|
|
}
|
|
|
|
strm.next_in = 0;
|
|
strm.avail_in = strm.input.length;
|
|
|
|
do {
|
|
if (strm.avail_out === 0) {
|
|
strm.output = new utils.Buf8(chunkSize);
|
|
strm.next_out = 0;
|
|
strm.avail_out = chunkSize;
|
|
}
|
|
|
|
status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); /* no bad return value */
|
|
|
|
if (status === c.Z_NEED_DICT && dictionary) {
|
|
// Convert data if needed
|
|
if (typeof dictionary === 'string') {
|
|
dict = strings.string2buf(dictionary);
|
|
} else if (toString.call(dictionary) === '[object ArrayBuffer]') {
|
|
dict = new Uint8Array(dictionary);
|
|
} else {
|
|
dict = dictionary;
|
|
}
|
|
|
|
status = zlib_inflate.inflateSetDictionary(this.strm, dict);
|
|
|
|
}
|
|
|
|
if (status === c.Z_BUF_ERROR && allowBufError === true) {
|
|
status = c.Z_OK;
|
|
allowBufError = false;
|
|
}
|
|
|
|
if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
|
|
this.onEnd(status);
|
|
this.ended = true;
|
|
return false;
|
|
}
|
|
|
|
if (strm.next_out) {
|
|
if (strm.avail_out === 0 || status === c.Z_STREAM_END || (strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH))) {
|
|
|
|
if (this.options.to === 'string') {
|
|
|
|
next_out_utf8 = strings.utf8border(strm.output, strm.next_out);
|
|
|
|
tail = strm.next_out - next_out_utf8;
|
|
utf8str = strings.buf2string(strm.output, next_out_utf8);
|
|
|
|
// move tail
|
|
strm.next_out = tail;
|
|
strm.avail_out = chunkSize - tail;
|
|
if (tail) { utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); }
|
|
|
|
this.onData(utf8str);
|
|
|
|
} else {
|
|
this.onData(utils.shrinkBuf(strm.output, strm.next_out));
|
|
}
|
|
}
|
|
}
|
|
|
|
// When no more input data, we should check that internal inflate buffers
|
|
// are flushed. The only way to do it when avail_out = 0 - run one more
|
|
// inflate pass. But if output data not exists, inflate return Z_BUF_ERROR.
|
|
// Here we set flag to process this error properly.
|
|
//
|
|
// NOTE. Deflate does not return error in this case and does not needs such
|
|
// logic.
|
|
if (strm.avail_in === 0 && strm.avail_out === 0) {
|
|
allowBufError = true;
|
|
}
|
|
|
|
} while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
|
|
|
|
if (status === c.Z_STREAM_END) {
|
|
_mode = c.Z_FINISH;
|
|
}
|
|
|
|
// Finalize on the last chunk.
|
|
if (_mode === c.Z_FINISH) {
|
|
status = zlib_inflate.inflateEnd(this.strm);
|
|
this.onEnd(status);
|
|
this.ended = true;
|
|
return status === c.Z_OK;
|
|
}
|
|
|
|
// callback interim results if Z_SYNC_FLUSH.
|
|
if (_mode === c.Z_SYNC_FLUSH) {
|
|
this.onEnd(c.Z_OK);
|
|
strm.avail_out = 0;
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
|
|
/**
|
|
* Inflate#onData(chunk) -> Void
|
|
* - chunk (Uint8Array|Array|String): ouput data. Type of array depends
|
|
* on js engine support. When string output requested, each chunk
|
|
* will be string.
|
|
*
|
|
* By default, stores data blocks in `chunks[]` property and glue
|
|
* those in `onEnd`. Override this handler, if you need another behaviour.
|
|
**/
|
|
Inflate.prototype.onData = function (chunk) {
|
|
this.chunks.push(chunk);
|
|
};
|
|
|
|
|
|
/**
|
|
* Inflate#onEnd(status) -> Void
|
|
* - status (Number): inflate status. 0 (Z_OK) on success,
|
|
* other if not.
|
|
*
|
|
* Called either after you tell inflate that the input stream is
|
|
* complete (Z_FINISH) or should be flushed (Z_SYNC_FLUSH)
|
|
* or if an error happened. By default - join collected chunks,
|
|
* free memory and fill `results` / `err` properties.
|
|
**/
|
|
Inflate.prototype.onEnd = function (status) {
|
|
// On success - join
|
|
if (status === c.Z_OK) {
|
|
if (this.options.to === 'string') {
|
|
// Glue & convert here, until we teach pako to send
|
|
// utf8 alligned strings to onData
|
|
this.result = this.chunks.join('');
|
|
} else {
|
|
this.result = utils.flattenChunks(this.chunks);
|
|
}
|
|
}
|
|
this.chunks = [];
|
|
this.err = status;
|
|
this.msg = this.strm.msg;
|
|
};
|
|
|
|
|
|
/**
|
|
* inflate(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Decompress `data` with inflate/ungzip and `options`. Autodetect
|
|
* format via wrapper header by default. That's why we don't provide
|
|
* separate `ungzip` method.
|
|
*
|
|
* Supported options are:
|
|
*
|
|
* - windowBits
|
|
*
|
|
* [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)
|
|
* for more information.
|
|
*
|
|
* Sugar (options):
|
|
*
|
|
* - `raw` (Boolean) - say that we work with raw stream, if you don't wish to specify
|
|
* negative windowBits implicitly.
|
|
* - `to` (String) - if equal to 'string', then result will be converted
|
|
* from utf8 to utf16 (javascript) string. When string output requested,
|
|
* chunk length can differ from `chunkSize`, depending on content.
|
|
*
|
|
*
|
|
* ##### Example:
|
|
*
|
|
* ```javascript
|
|
* var pako = require('pako')
|
|
* , input = pako.deflate([1,2,3,4,5,6,7,8,9])
|
|
* , output;
|
|
*
|
|
* try {
|
|
* output = pako.inflate(input);
|
|
* } catch (err)
|
|
* console.log(err);
|
|
* }
|
|
* ```
|
|
**/
|
|
function inflate(input, options) {
|
|
var inflator = new Inflate(options);
|
|
|
|
inflator.push(input, true);
|
|
|
|
// That will never happens, if you don't cheat with options :)
|
|
if (inflator.err) { throw inflator.msg; }
|
|
|
|
return inflator.result;
|
|
}
|
|
|
|
|
|
/**
|
|
* inflateRaw(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* The same as [[inflate]], but creates raw data, without wrapper
|
|
* (header and adler32 crc).
|
|
**/
|
|
function inflateRaw(input, options) {
|
|
options = options || {};
|
|
options.raw = true;
|
|
return inflate(input, options);
|
|
}
|
|
|
|
|
|
/**
|
|
* ungzip(data[, options]) -> Uint8Array|Array|String
|
|
* - data (Uint8Array|Array|String): input data to decompress.
|
|
* - options (Object): zlib inflate options.
|
|
*
|
|
* Just shortcut to [[inflate]], because it autodetects format
|
|
* by header.content. Done for convenience.
|
|
**/
|
|
|
|
|
|
exports.Inflate = Inflate;
|
|
exports.inflate = inflate;
|
|
exports.inflateRaw = inflateRaw;
|
|
exports.ungzip = inflate;
|
|
|
|
},{"./utils/common":22,"./utils/strings":23,"./zlib/constants":25,"./zlib/gzheader":27,"./zlib/inflate":29,"./zlib/messages":31,"./zlib/zstream":32}],22:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var TYPED_OK = (typeof Uint8Array !== 'undefined') &&
|
|
(typeof Uint16Array !== 'undefined') &&
|
|
(typeof Int32Array !== 'undefined');
|
|
|
|
|
|
exports.assign = function (obj /*from1, from2, from3, ...*/) {
|
|
var sources = Array.prototype.slice.call(arguments, 1);
|
|
while (sources.length) {
|
|
var source = sources.shift();
|
|
if (!source) { continue; }
|
|
|
|
if (typeof source !== 'object') {
|
|
throw new TypeError(source + 'must be non-object');
|
|
}
|
|
|
|
for (var p in source) {
|
|
if (source.hasOwnProperty(p)) {
|
|
obj[p] = source[p];
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
|
|
// reduce buffer size, avoiding mem copy
|
|
exports.shrinkBuf = function (buf, size) {
|
|
if (buf.length === size) { return buf; }
|
|
if (buf.subarray) { return buf.subarray(0, size); }
|
|
buf.length = size;
|
|
return buf;
|
|
};
|
|
|
|
|
|
var fnTyped = {
|
|
arraySet: function (dest, src, src_offs, len, dest_offs) {
|
|
if (src.subarray && dest.subarray) {
|
|
dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
|
|
return;
|
|
}
|
|
// Fallback to ordinary array
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
// Join array of chunks to single array.
|
|
flattenChunks: function (chunks) {
|
|
var i, l, len, pos, chunk, result;
|
|
|
|
// calculate data length
|
|
len = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
len += chunks[i].length;
|
|
}
|
|
|
|
// join chunks
|
|
result = new Uint8Array(len);
|
|
pos = 0;
|
|
for (i = 0, l = chunks.length; i < l; i++) {
|
|
chunk = chunks[i];
|
|
result.set(chunk, pos);
|
|
pos += chunk.length;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
var fnUntyped = {
|
|
arraySet: function (dest, src, src_offs, len, dest_offs) {
|
|
for (var i = 0; i < len; i++) {
|
|
dest[dest_offs + i] = src[src_offs + i];
|
|
}
|
|
},
|
|
// Join array of chunks to single array.
|
|
flattenChunks: function (chunks) {
|
|
return [].concat.apply([], chunks);
|
|
}
|
|
};
|
|
|
|
|
|
// Enable/Disable typed arrays use, for testing
|
|
//
|
|
exports.setTyped = function (on) {
|
|
if (on) {
|
|
exports.Buf8 = Uint8Array;
|
|
exports.Buf16 = Uint16Array;
|
|
exports.Buf32 = Int32Array;
|
|
exports.assign(exports, fnTyped);
|
|
} else {
|
|
exports.Buf8 = Array;
|
|
exports.Buf16 = Array;
|
|
exports.Buf32 = Array;
|
|
exports.assign(exports, fnUntyped);
|
|
}
|
|
};
|
|
|
|
exports.setTyped(TYPED_OK);
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
// String encode/decode helpers
|
|
'use strict';
|
|
|
|
|
|
var utils = require('./common');
|
|
|
|
|
|
// Quick check if we can use fast array to bin string conversion
|
|
//
|
|
// - apply(Array) can fail on Android 2.2
|
|
// - apply(Uint8Array) can fail on iOS 5.1 Safary
|
|
//
|
|
var STR_APPLY_OK = true;
|
|
var STR_APPLY_UIA_OK = true;
|
|
|
|
try { String.fromCharCode.apply(null, [ 0 ]); } catch (__) { STR_APPLY_OK = false; }
|
|
try { String.fromCharCode.apply(null, new Uint8Array(1)); } catch (__) { STR_APPLY_UIA_OK = false; }
|
|
|
|
|
|
// Table with utf8 lengths (calculated by first byte of sequence)
|
|
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
|
|
// because max possible codepoint is 0x10ffff
|
|
var _utf8len = new utils.Buf8(256);
|
|
for (var q = 0; q < 256; q++) {
|
|
_utf8len[q] = (q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1);
|
|
}
|
|
_utf8len[254] = _utf8len[254] = 1; // Invalid sequence start
|
|
|
|
|
|
// convert string to array (typed, when possible)
|
|
exports.string2buf = function (str) {
|
|
var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0;
|
|
|
|
// count binary size
|
|
for (m_pos = 0; m_pos < str_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 0xfc00) === 0xdc00) {
|
|
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
|
|
m_pos++;
|
|
}
|
|
}
|
|
buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
|
|
}
|
|
|
|
// allocate buffer
|
|
buf = new utils.Buf8(buf_len);
|
|
|
|
// convert
|
|
for (i = 0, m_pos = 0; i < buf_len; m_pos++) {
|
|
c = str.charCodeAt(m_pos);
|
|
if ((c & 0xfc00) === 0xd800 && (m_pos + 1 < str_len)) {
|
|
c2 = str.charCodeAt(m_pos + 1);
|
|
if ((c2 & 0xfc00) === 0xdc00) {
|
|
c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);
|
|
m_pos++;
|
|
}
|
|
}
|
|
if (c < 0x80) {
|
|
/* one byte */
|
|
buf[i++] = c;
|
|
} else if (c < 0x800) {
|
|
/* two bytes */
|
|
buf[i++] = 0xC0 | (c >>> 6);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
} else if (c < 0x10000) {
|
|
/* three bytes */
|
|
buf[i++] = 0xE0 | (c >>> 12);
|
|
buf[i++] = 0x80 | (c >>> 6 & 0x3f);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
} else {
|
|
/* four bytes */
|
|
buf[i++] = 0xf0 | (c >>> 18);
|
|
buf[i++] = 0x80 | (c >>> 12 & 0x3f);
|
|
buf[i++] = 0x80 | (c >>> 6 & 0x3f);
|
|
buf[i++] = 0x80 | (c & 0x3f);
|
|
}
|
|
}
|
|
|
|
return buf;
|
|
};
|
|
|
|
// Helper (used in 2 places)
|
|
function buf2binstring(buf, len) {
|
|
// use fallback for big arrays to avoid stack overflow
|
|
if (len < 65537) {
|
|
if ((buf.subarray && STR_APPLY_UIA_OK) || (!buf.subarray && STR_APPLY_OK)) {
|
|
return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
|
|
}
|
|
}
|
|
|
|
var result = '';
|
|
for (var i = 0; i < len; i++) {
|
|
result += String.fromCharCode(buf[i]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Convert byte array to binary string
|
|
exports.buf2binstring = function (buf) {
|
|
return buf2binstring(buf, buf.length);
|
|
};
|
|
|
|
|
|
// Convert binary string (typed, when possible)
|
|
exports.binstring2buf = function (str) {
|
|
var buf = new utils.Buf8(str.length);
|
|
for (var i = 0, len = buf.length; i < len; i++) {
|
|
buf[i] = str.charCodeAt(i);
|
|
}
|
|
return buf;
|
|
};
|
|
|
|
|
|
// convert array to string
|
|
exports.buf2string = function (buf, max) {
|
|
var i, out, c, c_len;
|
|
var len = max || buf.length;
|
|
|
|
// Reserve max possible length (2 words per char)
|
|
// NB: by unknown reasons, Array is significantly faster for
|
|
// String.fromCharCode.apply than Uint16Array.
|
|
var utf16buf = new Array(len * 2);
|
|
|
|
for (out = 0, i = 0; i < len;) {
|
|
c = buf[i++];
|
|
// quick process ascii
|
|
if (c < 0x80) { utf16buf[out++] = c; continue; }
|
|
|
|
c_len = _utf8len[c];
|
|
// skip 5 & 6 byte codes
|
|
if (c_len > 4) { utf16buf[out++] = 0xfffd; i += c_len - 1; continue; }
|
|
|
|
// apply mask on first byte
|
|
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
|
|
// join the rest
|
|
while (c_len > 1 && i < len) {
|
|
c = (c << 6) | (buf[i++] & 0x3f);
|
|
c_len--;
|
|
}
|
|
|
|
// terminated by end of string?
|
|
if (c_len > 1) { utf16buf[out++] = 0xfffd; continue; }
|
|
|
|
if (c < 0x10000) {
|
|
utf16buf[out++] = c;
|
|
} else {
|
|
c -= 0x10000;
|
|
utf16buf[out++] = 0xd800 | ((c >> 10) & 0x3ff);
|
|
utf16buf[out++] = 0xdc00 | (c & 0x3ff);
|
|
}
|
|
}
|
|
|
|
return buf2binstring(utf16buf, out);
|
|
};
|
|
|
|
|
|
// Calculate max possible position in utf8 buffer,
|
|
// that will not break sequence. If that's not possible
|
|
// - (very small limits) return max size as is.
|
|
//
|
|
// buf[] - utf8 bytes array
|
|
// max - length limit (mandatory);
|
|
exports.utf8border = function (buf, max) {
|
|
var pos;
|
|
|
|
max = max || buf.length;
|
|
if (max > buf.length) { max = buf.length; }
|
|
|
|
// go back from last position, until start of sequence found
|
|
pos = max - 1;
|
|
while (pos >= 0 && (buf[pos] & 0xC0) === 0x80) { pos--; }
|
|
|
|
// Fuckup - very small and broken sequence,
|
|
// return max, because we should return something anyway.
|
|
if (pos < 0) { return max; }
|
|
|
|
// If we came to start of buffer - that means vuffer is too small,
|
|
// return max too.
|
|
if (pos === 0) { return max; }
|
|
|
|
return (pos + _utf8len[buf[pos]] > max) ? pos : max;
|
|
};
|
|
|
|
},{"./common":22}],24:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// Note: adler32 takes 12% for level 0 and 2% for level 6.
|
|
// It doesn't worth to make additional optimizationa as in original.
|
|
// Small size is preferable.
|
|
|
|
function adler32(adler, buf, len, pos) {
|
|
var s1 = (adler & 0xffff) |0,
|
|
s2 = ((adler >>> 16) & 0xffff) |0,
|
|
n = 0;
|
|
|
|
while (len !== 0) {
|
|
// Set limit ~ twice less than 5552, to keep
|
|
// s2 in 31-bits, because we force signed ints.
|
|
// in other case %= will fail.
|
|
n = len > 2000 ? 2000 : len;
|
|
len -= n;
|
|
|
|
do {
|
|
s1 = (s1 + buf[pos++]) |0;
|
|
s2 = (s2 + s1) |0;
|
|
} while (--n);
|
|
|
|
s1 %= 65521;
|
|
s2 %= 65521;
|
|
}
|
|
|
|
return (s1 | (s2 << 16)) |0;
|
|
}
|
|
|
|
|
|
module.exports = adler32;
|
|
|
|
},{}],25:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
module.exports = {
|
|
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
Z_NO_FLUSH: 0,
|
|
Z_PARTIAL_FLUSH: 1,
|
|
Z_SYNC_FLUSH: 2,
|
|
Z_FULL_FLUSH: 3,
|
|
Z_FINISH: 4,
|
|
Z_BLOCK: 5,
|
|
Z_TREES: 6,
|
|
|
|
/* Return codes for the compression/decompression functions. Negative values
|
|
* are errors, positive values are used for special but normal events.
|
|
*/
|
|
Z_OK: 0,
|
|
Z_STREAM_END: 1,
|
|
Z_NEED_DICT: 2,
|
|
Z_ERRNO: -1,
|
|
Z_STREAM_ERROR: -2,
|
|
Z_DATA_ERROR: -3,
|
|
//Z_MEM_ERROR: -4,
|
|
Z_BUF_ERROR: -5,
|
|
//Z_VERSION_ERROR: -6,
|
|
|
|
/* compression levels */
|
|
Z_NO_COMPRESSION: 0,
|
|
Z_BEST_SPEED: 1,
|
|
Z_BEST_COMPRESSION: 9,
|
|
Z_DEFAULT_COMPRESSION: -1,
|
|
|
|
|
|
Z_FILTERED: 1,
|
|
Z_HUFFMAN_ONLY: 2,
|
|
Z_RLE: 3,
|
|
Z_FIXED: 4,
|
|
Z_DEFAULT_STRATEGY: 0,
|
|
|
|
/* Possible values of the data_type field (though see inflate()) */
|
|
Z_BINARY: 0,
|
|
Z_TEXT: 1,
|
|
//Z_ASCII: 1, // = Z_TEXT (deprecated)
|
|
Z_UNKNOWN: 2,
|
|
|
|
/* The deflate compression method */
|
|
Z_DEFLATED: 8
|
|
//Z_NULL: null // Use -1 or null inline, depending on var type
|
|
};
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// Note: we can't get significant speed boost here.
|
|
// So write code to minimize size - no pregenerated tables
|
|
// and array tools dependencies.
|
|
|
|
|
|
// Use ordinary array, since untyped makes no boost here
|
|
function makeTable() {
|
|
var c, table = [];
|
|
|
|
for (var n = 0; n < 256; n++) {
|
|
c = n;
|
|
for (var k = 0; k < 8; k++) {
|
|
c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
|
|
}
|
|
table[n] = c;
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
// Create table on load. Just 255 signed longs. Not a problem.
|
|
var crcTable = makeTable();
|
|
|
|
|
|
function crc32(crc, buf, len, pos) {
|
|
var t = crcTable,
|
|
end = pos + len;
|
|
|
|
crc ^= -1;
|
|
|
|
for (var i = pos; i < end; i++) {
|
|
crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF];
|
|
}
|
|
|
|
return (crc ^ (-1)); // >>> 0;
|
|
}
|
|
|
|
|
|
module.exports = crc32;
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
function GZheader() {
|
|
/* true if compressed data believed to be text */
|
|
this.text = 0;
|
|
/* modification time */
|
|
this.time = 0;
|
|
/* extra flags (not used when writing a gzip file) */
|
|
this.xflags = 0;
|
|
/* operating system */
|
|
this.os = 0;
|
|
/* pointer to extra field or Z_NULL if none */
|
|
this.extra = null;
|
|
/* extra field length (valid if extra != Z_NULL) */
|
|
this.extra_len = 0; // Actually, we don't need it in JS,
|
|
// but leave for few code modifications
|
|
|
|
//
|
|
// Setup limits is not necessary because in js we should not preallocate memory
|
|
// for inflate use constant limit in 65536 bytes
|
|
//
|
|
|
|
/* space at extra (only when reading header) */
|
|
// this.extra_max = 0;
|
|
/* pointer to zero-terminated file name or Z_NULL */
|
|
this.name = '';
|
|
/* space at name (only when reading header) */
|
|
// this.name_max = 0;
|
|
/* pointer to zero-terminated comment or Z_NULL */
|
|
this.comment = '';
|
|
/* space at comment (only when reading header) */
|
|
// this.comm_max = 0;
|
|
/* true if there was or will be a header crc */
|
|
this.hcrc = 0;
|
|
/* true when done reading gzip header (not used when writing a gzip file) */
|
|
this.done = false;
|
|
}
|
|
|
|
module.exports = GZheader;
|
|
|
|
},{}],28:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// See state defs from inflate.js
|
|
var BAD = 30; /* got a data error -- remain here until reset */
|
|
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
|
|
|
|
/*
|
|
Decode literal, length, and distance codes and write out the resulting
|
|
literal and match bytes until either not enough input or output is
|
|
available, an end-of-block is encountered, or a data error is encountered.
|
|
When large enough input and output buffers are supplied to inflate(), for
|
|
example, a 16K input buffer and a 64K output buffer, more than 95% of the
|
|
inflate execution time is spent in this routine.
|
|
|
|
Entry assumptions:
|
|
|
|
state.mode === LEN
|
|
strm.avail_in >= 6
|
|
strm.avail_out >= 258
|
|
start >= strm.avail_out
|
|
state.bits < 8
|
|
|
|
On return, state.mode is one of:
|
|
|
|
LEN -- ran out of enough output space or enough available input
|
|
TYPE -- reached end of block code, inflate() to interpret next block
|
|
BAD -- error in block data
|
|
|
|
Notes:
|
|
|
|
- The maximum input bits used by a length/distance pair is 15 bits for the
|
|
length code, 5 bits for the length extra, 15 bits for the distance code,
|
|
and 13 bits for the distance extra. This totals 48 bits, or six bytes.
|
|
Therefore if strm.avail_in >= 6, then there is enough input to avoid
|
|
checking for available input while decoding.
|
|
|
|
- The maximum bytes that a single length/distance pair can output is 258
|
|
bytes, which is the maximum length that can be coded. inflate_fast()
|
|
requires strm.avail_out >= 258 for each loop to avoid checking for
|
|
output space.
|
|
*/
|
|
module.exports = function inflate_fast(strm, start) {
|
|
var state;
|
|
var _in; /* local strm.input */
|
|
var last; /* have enough input while in < last */
|
|
var _out; /* local strm.output */
|
|
var beg; /* inflate()'s initial strm.output */
|
|
var end; /* while out < end, enough space available */
|
|
//#ifdef INFLATE_STRICT
|
|
var dmax; /* maximum distance from zlib header */
|
|
//#endif
|
|
var wsize; /* window size or zero if not using window */
|
|
var whave; /* valid bytes in the window */
|
|
var wnext; /* window write index */
|
|
// Use `s_window` instead `window`, avoid conflict with instrumentation tools
|
|
var s_window; /* allocated sliding window, if wsize != 0 */
|
|
var hold; /* local strm.hold */
|
|
var bits; /* local strm.bits */
|
|
var lcode; /* local strm.lencode */
|
|
var dcode; /* local strm.distcode */
|
|
var lmask; /* mask for first level of length codes */
|
|
var dmask; /* mask for first level of distance codes */
|
|
var here; /* retrieved table entry */
|
|
var op; /* code bits, operation, extra bits, or */
|
|
/* window position, window bytes to copy */
|
|
var len; /* match length, unused bytes */
|
|
var dist; /* match distance */
|
|
var from; /* where to copy match from */
|
|
var from_source;
|
|
|
|
|
|
var input, output; // JS specific, because we have no pointers
|
|
|
|
/* copy state to local variables */
|
|
state = strm.state;
|
|
//here = state.here;
|
|
_in = strm.next_in;
|
|
input = strm.input;
|
|
last = _in + (strm.avail_in - 5);
|
|
_out = strm.next_out;
|
|
output = strm.output;
|
|
beg = _out - (start - strm.avail_out);
|
|
end = _out + (strm.avail_out - 257);
|
|
//#ifdef INFLATE_STRICT
|
|
dmax = state.dmax;
|
|
//#endif
|
|
wsize = state.wsize;
|
|
whave = state.whave;
|
|
wnext = state.wnext;
|
|
s_window = state.window;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
lcode = state.lencode;
|
|
dcode = state.distcode;
|
|
lmask = (1 << state.lenbits) - 1;
|
|
dmask = (1 << state.distbits) - 1;
|
|
|
|
|
|
/* decode literals and length/distances until end-of-block or not enough
|
|
input data or output space */
|
|
|
|
top:
|
|
do {
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
|
|
here = lcode[hold & lmask];
|
|
|
|
dolen:
|
|
for (;;) { // Goto emulation
|
|
op = here >>> 24/*here.bits*/;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = (here >>> 16) & 0xff/*here.op*/;
|
|
if (op === 0) { /* literal */
|
|
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
|
// "inflate: literal '%c'\n" :
|
|
// "inflate: literal 0x%02x\n", here.val));
|
|
output[_out++] = here & 0xffff/*here.val*/;
|
|
}
|
|
else if (op & 16) { /* length base */
|
|
len = here & 0xffff/*here.val*/;
|
|
op &= 15; /* number of extra bits */
|
|
if (op) {
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
len += hold & ((1 << op) - 1);
|
|
hold >>>= op;
|
|
bits -= op;
|
|
}
|
|
//Tracevv((stderr, "inflate: length %u\n", len));
|
|
if (bits < 15) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
here = dcode[hold & dmask];
|
|
|
|
dodist:
|
|
for (;;) { // goto emulation
|
|
op = here >>> 24/*here.bits*/;
|
|
hold >>>= op;
|
|
bits -= op;
|
|
op = (here >>> 16) & 0xff/*here.op*/;
|
|
|
|
if (op & 16) { /* distance base */
|
|
dist = here & 0xffff/*here.val*/;
|
|
op &= 15; /* number of extra bits */
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
if (bits < op) {
|
|
hold += input[_in++] << bits;
|
|
bits += 8;
|
|
}
|
|
}
|
|
dist += hold & ((1 << op) - 1);
|
|
//#ifdef INFLATE_STRICT
|
|
if (dist > dmax) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
//#endif
|
|
hold >>>= op;
|
|
bits -= op;
|
|
//Tracevv((stderr, "inflate: distance %u\n", dist));
|
|
op = _out - beg; /* max distance in output */
|
|
if (dist > op) { /* see if copy from window */
|
|
op = dist - op; /* distance back in window */
|
|
if (op > whave) {
|
|
if (state.sane) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
// (!) This block is disabled in zlib defailts,
|
|
// don't enable it for binary compatibility
|
|
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
|
// if (len <= op - whave) {
|
|
// do {
|
|
// output[_out++] = 0;
|
|
// } while (--len);
|
|
// continue top;
|
|
// }
|
|
// len -= op - whave;
|
|
// do {
|
|
// output[_out++] = 0;
|
|
// } while (--op > whave);
|
|
// if (op === 0) {
|
|
// from = _out - dist;
|
|
// do {
|
|
// output[_out++] = output[from++];
|
|
// } while (--len);
|
|
// continue top;
|
|
// }
|
|
//#endif
|
|
}
|
|
from = 0; // window index
|
|
from_source = s_window;
|
|
if (wnext === 0) { /* very common case */
|
|
from += wsize - op;
|
|
if (op < len) { /* some from window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
else if (wnext < op) { /* wrap around window */
|
|
from += wsize + wnext - op;
|
|
op -= wnext;
|
|
if (op < len) { /* some from end of window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = 0;
|
|
if (wnext < len) { /* some from start of window */
|
|
op = wnext;
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
}
|
|
else { /* contiguous in window */
|
|
from += wnext - op;
|
|
if (op < len) { /* some from window */
|
|
len -= op;
|
|
do {
|
|
output[_out++] = s_window[from++];
|
|
} while (--op);
|
|
from = _out - dist; /* rest from output */
|
|
from_source = output;
|
|
}
|
|
}
|
|
while (len > 2) {
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
output[_out++] = from_source[from++];
|
|
len -= 3;
|
|
}
|
|
if (len) {
|
|
output[_out++] = from_source[from++];
|
|
if (len > 1) {
|
|
output[_out++] = from_source[from++];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
from = _out - dist; /* copy direct from output */
|
|
do { /* minimum length is three */
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
output[_out++] = output[from++];
|
|
len -= 3;
|
|
} while (len > 2);
|
|
if (len) {
|
|
output[_out++] = output[from++];
|
|
if (len > 1) {
|
|
output[_out++] = output[from++];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((op & 64) === 0) { /* 2nd level distance code */
|
|
here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
|
|
continue dodist;
|
|
}
|
|
else {
|
|
strm.msg = 'invalid distance code';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
break; // need to emulate goto via "continue"
|
|
}
|
|
}
|
|
else if ((op & 64) === 0) { /* 2nd level length code */
|
|
here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))];
|
|
continue dolen;
|
|
}
|
|
else if (op & 32) { /* end-of-block */
|
|
//Tracevv((stderr, "inflate: end of block\n"));
|
|
state.mode = TYPE;
|
|
break top;
|
|
}
|
|
else {
|
|
strm.msg = 'invalid literal/length code';
|
|
state.mode = BAD;
|
|
break top;
|
|
}
|
|
|
|
break; // need to emulate goto via "continue"
|
|
}
|
|
} while (_in < last && _out < end);
|
|
|
|
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */
|
|
len = bits >> 3;
|
|
_in -= len;
|
|
bits -= len << 3;
|
|
hold &= (1 << bits) - 1;
|
|
|
|
/* update state and return */
|
|
strm.next_in = _in;
|
|
strm.next_out = _out;
|
|
strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last));
|
|
strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end));
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
return;
|
|
};
|
|
|
|
},{}],29:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var utils = require('../utils/common');
|
|
var adler32 = require('./adler32');
|
|
var crc32 = require('./crc32');
|
|
var inflate_fast = require('./inffast');
|
|
var inflate_table = require('./inftrees');
|
|
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
|
|
/* Public constants ==========================================================*/
|
|
/* ===========================================================================*/
|
|
|
|
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
//var Z_NO_FLUSH = 0;
|
|
//var Z_PARTIAL_FLUSH = 1;
|
|
//var Z_SYNC_FLUSH = 2;
|
|
//var Z_FULL_FLUSH = 3;
|
|
var Z_FINISH = 4;
|
|
var Z_BLOCK = 5;
|
|
var Z_TREES = 6;
|
|
|
|
|
|
/* Return codes for the compression/decompression functions. Negative values
|
|
* are errors, positive values are used for special but normal events.
|
|
*/
|
|
var Z_OK = 0;
|
|
var Z_STREAM_END = 1;
|
|
var Z_NEED_DICT = 2;
|
|
//var Z_ERRNO = -1;
|
|
var Z_STREAM_ERROR = -2;
|
|
var Z_DATA_ERROR = -3;
|
|
var Z_MEM_ERROR = -4;
|
|
var Z_BUF_ERROR = -5;
|
|
//var Z_VERSION_ERROR = -6;
|
|
|
|
/* The deflate compression method */
|
|
var Z_DEFLATED = 8;
|
|
|
|
|
|
/* STATES ====================================================================*/
|
|
/* ===========================================================================*/
|
|
|
|
|
|
var HEAD = 1; /* i: waiting for magic header */
|
|
var FLAGS = 2; /* i: waiting for method and flags (gzip) */
|
|
var TIME = 3; /* i: waiting for modification time (gzip) */
|
|
var OS = 4; /* i: waiting for extra flags and operating system (gzip) */
|
|
var EXLEN = 5; /* i: waiting for extra length (gzip) */
|
|
var EXTRA = 6; /* i: waiting for extra bytes (gzip) */
|
|
var NAME = 7; /* i: waiting for end of file name (gzip) */
|
|
var COMMENT = 8; /* i: waiting for end of comment (gzip) */
|
|
var HCRC = 9; /* i: waiting for header crc (gzip) */
|
|
var DICTID = 10; /* i: waiting for dictionary check value */
|
|
var DICT = 11; /* waiting for inflateSetDictionary() call */
|
|
var TYPE = 12; /* i: waiting for type bits, including last-flag bit */
|
|
var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */
|
|
var STORED = 14; /* i: waiting for stored size (length and complement) */
|
|
var COPY_ = 15; /* i/o: same as COPY below, but only first time in */
|
|
var COPY = 16; /* i/o: waiting for input or output to copy stored block */
|
|
var TABLE = 17; /* i: waiting for dynamic block table lengths */
|
|
var LENLENS = 18; /* i: waiting for code length code lengths */
|
|
var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */
|
|
var LEN_ = 20; /* i: same as LEN below, but only first time in */
|
|
var LEN = 21; /* i: waiting for length/lit/eob code */
|
|
var LENEXT = 22; /* i: waiting for length extra bits */
|
|
var DIST = 23; /* i: waiting for distance code */
|
|
var DISTEXT = 24; /* i: waiting for distance extra bits */
|
|
var MATCH = 25; /* o: waiting for output space to copy string */
|
|
var LIT = 26; /* o: waiting for output space to write literal */
|
|
var CHECK = 27; /* i: waiting for 32-bit check value */
|
|
var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */
|
|
var DONE = 29; /* finished check, done -- remain here until reset */
|
|
var BAD = 30; /* got a data error -- remain here until reset */
|
|
var MEM = 31; /* got an inflate() memory error -- remain here until reset */
|
|
var SYNC = 32; /* looking for synchronization bytes to restart inflate() */
|
|
|
|
/* ===========================================================================*/
|
|
|
|
|
|
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
|
|
|
var MAX_WBITS = 15;
|
|
/* 32K LZ77 window */
|
|
var DEF_WBITS = MAX_WBITS;
|
|
|
|
|
|
function zswap32(q) {
|
|
return (((q >>> 24) & 0xff) +
|
|
((q >>> 8) & 0xff00) +
|
|
((q & 0xff00) << 8) +
|
|
((q & 0xff) << 24));
|
|
}
|
|
|
|
|
|
function InflateState() {
|
|
this.mode = 0; /* current inflate mode */
|
|
this.last = false; /* true if processing last block */
|
|
this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
|
|
this.havedict = false; /* true if dictionary provided */
|
|
this.flags = 0; /* gzip header method and flags (0 if zlib) */
|
|
this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
|
|
this.check = 0; /* protected copy of check value */
|
|
this.total = 0; /* protected copy of output count */
|
|
// TODO: may be {}
|
|
this.head = null; /* where to save gzip header information */
|
|
|
|
/* sliding window */
|
|
this.wbits = 0; /* log base 2 of requested window size */
|
|
this.wsize = 0; /* window size or zero if not using window */
|
|
this.whave = 0; /* valid bytes in the window */
|
|
this.wnext = 0; /* window write index */
|
|
this.window = null; /* allocated sliding window, if needed */
|
|
|
|
/* bit accumulator */
|
|
this.hold = 0; /* input bit accumulator */
|
|
this.bits = 0; /* number of bits in "in" */
|
|
|
|
/* for string and stored block copying */
|
|
this.length = 0; /* literal or length of data to copy */
|
|
this.offset = 0; /* distance back to copy string from */
|
|
|
|
/* for table and code decoding */
|
|
this.extra = 0; /* extra bits needed */
|
|
|
|
/* fixed and dynamic code tables */
|
|
this.lencode = null; /* starting table for length/literal codes */
|
|
this.distcode = null; /* starting table for distance codes */
|
|
this.lenbits = 0; /* index bits for lencode */
|
|
this.distbits = 0; /* index bits for distcode */
|
|
|
|
/* dynamic table building */
|
|
this.ncode = 0; /* number of code length code lengths */
|
|
this.nlen = 0; /* number of length code lengths */
|
|
this.ndist = 0; /* number of distance code lengths */
|
|
this.have = 0; /* number of code lengths in lens[] */
|
|
this.next = null; /* next available space in codes[] */
|
|
|
|
this.lens = new utils.Buf16(320); /* temporary storage for code lengths */
|
|
this.work = new utils.Buf16(288); /* work area for code table building */
|
|
|
|
/*
|
|
because we don't have pointers in js, we use lencode and distcode directly
|
|
as buffers so we don't need codes
|
|
*/
|
|
//this.codes = new utils.Buf32(ENOUGH); /* space for code tables */
|
|
this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */
|
|
this.distdyn = null; /* dynamic table for distance codes (JS specific) */
|
|
this.sane = 0; /* if false, allow invalid distance too far */
|
|
this.back = 0; /* bits back of last unprocessed length/lit */
|
|
this.was = 0; /* initial length of match */
|
|
}
|
|
|
|
function inflateResetKeep(strm) {
|
|
var state;
|
|
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
strm.total_in = strm.total_out = state.total = 0;
|
|
strm.msg = ''; /*Z_NULL*/
|
|
if (state.wrap) { /* to support ill-conceived Java test suite */
|
|
strm.adler = state.wrap & 1;
|
|
}
|
|
state.mode = HEAD;
|
|
state.last = 0;
|
|
state.havedict = 0;
|
|
state.dmax = 32768;
|
|
state.head = null/*Z_NULL*/;
|
|
state.hold = 0;
|
|
state.bits = 0;
|
|
//state.lencode = state.distcode = state.next = state.codes;
|
|
state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS);
|
|
state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS);
|
|
|
|
state.sane = 1;
|
|
state.back = -1;
|
|
//Tracev((stderr, "inflate: reset\n"));
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateReset(strm) {
|
|
var state;
|
|
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
state.wsize = 0;
|
|
state.whave = 0;
|
|
state.wnext = 0;
|
|
return inflateResetKeep(strm);
|
|
|
|
}
|
|
|
|
function inflateReset2(strm, windowBits) {
|
|
var wrap;
|
|
var state;
|
|
|
|
/* get the state */
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
|
|
/* extract wrap request from windowBits parameter */
|
|
if (windowBits < 0) {
|
|
wrap = 0;
|
|
windowBits = -windowBits;
|
|
}
|
|
else {
|
|
wrap = (windowBits >> 4) + 1;
|
|
if (windowBits < 48) {
|
|
windowBits &= 15;
|
|
}
|
|
}
|
|
|
|
/* set number of window bits, free window if different */
|
|
if (windowBits && (windowBits < 8 || windowBits > 15)) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
if (state.window !== null && state.wbits !== windowBits) {
|
|
state.window = null;
|
|
}
|
|
|
|
/* update state and reset the rest of it */
|
|
state.wrap = wrap;
|
|
state.wbits = windowBits;
|
|
return inflateReset(strm);
|
|
}
|
|
|
|
function inflateInit2(strm, windowBits) {
|
|
var ret;
|
|
var state;
|
|
|
|
if (!strm) { return Z_STREAM_ERROR; }
|
|
//strm.msg = Z_NULL; /* in case we return an error */
|
|
|
|
state = new InflateState();
|
|
|
|
//if (state === Z_NULL) return Z_MEM_ERROR;
|
|
//Tracev((stderr, "inflate: allocated\n"));
|
|
strm.state = state;
|
|
state.window = null/*Z_NULL*/;
|
|
ret = inflateReset2(strm, windowBits);
|
|
if (ret !== Z_OK) {
|
|
strm.state = null/*Z_NULL*/;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function inflateInit(strm) {
|
|
return inflateInit2(strm, DEF_WBITS);
|
|
}
|
|
|
|
|
|
/*
|
|
Return state with length and distance decoding tables and index sizes set to
|
|
fixed code decoding. Normally this returns fixed tables from inffixed.h.
|
|
If BUILDFIXED is defined, then instead this routine builds the tables the
|
|
first time it's called, and returns those tables the first time and
|
|
thereafter. This reduces the size of the code by about 2K bytes, in
|
|
exchange for a little execution time. However, BUILDFIXED should not be
|
|
used for threaded applications, since the rewriting of the tables and virgin
|
|
may not be thread-safe.
|
|
*/
|
|
var virgin = true;
|
|
|
|
var lenfix, distfix; // We have no pointers in JS, so keep tables separate
|
|
|
|
function fixedtables(state) {
|
|
/* build fixed huffman tables if first call (may not be thread safe) */
|
|
if (virgin) {
|
|
var sym;
|
|
|
|
lenfix = new utils.Buf32(512);
|
|
distfix = new utils.Buf32(32);
|
|
|
|
/* literal/length table */
|
|
sym = 0;
|
|
while (sym < 144) { state.lens[sym++] = 8; }
|
|
while (sym < 256) { state.lens[sym++] = 9; }
|
|
while (sym < 280) { state.lens[sym++] = 7; }
|
|
while (sym < 288) { state.lens[sym++] = 8; }
|
|
|
|
inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
|
|
|
|
/* distance table */
|
|
sym = 0;
|
|
while (sym < 32) { state.lens[sym++] = 5; }
|
|
|
|
inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
|
|
|
|
/* do this just once */
|
|
virgin = false;
|
|
}
|
|
|
|
state.lencode = lenfix;
|
|
state.lenbits = 9;
|
|
state.distcode = distfix;
|
|
state.distbits = 5;
|
|
}
|
|
|
|
|
|
/*
|
|
Update the window with the last wsize (normally 32K) bytes written before
|
|
returning. If window does not exist yet, create it. This is only called
|
|
when a window is already in use, or when output has been written during this
|
|
inflate call, but the end of the deflate stream has not been reached yet.
|
|
It is also called to create a window for dictionary data when a dictionary
|
|
is loaded.
|
|
|
|
Providing output buffers larger than 32K to inflate() should provide a speed
|
|
advantage, since only the last 32K of output is copied to the sliding window
|
|
upon return from inflate(), and since all distances after the first 32K of
|
|
output will fall in the output data, making match copies simpler and faster.
|
|
The advantage may be dependent on the size of the processor's data caches.
|
|
*/
|
|
function updatewindow(strm, src, end, copy) {
|
|
var dist;
|
|
var state = strm.state;
|
|
|
|
/* if it hasn't been done already, allocate space for the window */
|
|
if (state.window === null) {
|
|
state.wsize = 1 << state.wbits;
|
|
state.wnext = 0;
|
|
state.whave = 0;
|
|
|
|
state.window = new utils.Buf8(state.wsize);
|
|
}
|
|
|
|
/* copy state->wsize or less output bytes into the circular window */
|
|
if (copy >= state.wsize) {
|
|
utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0);
|
|
state.wnext = 0;
|
|
state.whave = state.wsize;
|
|
}
|
|
else {
|
|
dist = state.wsize - state.wnext;
|
|
if (dist > copy) {
|
|
dist = copy;
|
|
}
|
|
//zmemcpy(state->window + state->wnext, end - copy, dist);
|
|
utils.arraySet(state.window, src, end - copy, dist, state.wnext);
|
|
copy -= dist;
|
|
if (copy) {
|
|
//zmemcpy(state->window, end - copy, copy);
|
|
utils.arraySet(state.window, src, end - copy, copy, 0);
|
|
state.wnext = copy;
|
|
state.whave = state.wsize;
|
|
}
|
|
else {
|
|
state.wnext += dist;
|
|
if (state.wnext === state.wsize) { state.wnext = 0; }
|
|
if (state.whave < state.wsize) { state.whave += dist; }
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function inflate(strm, flush) {
|
|
var state;
|
|
var input, output; // input/output buffers
|
|
var next; /* next input INDEX */
|
|
var put; /* next output INDEX */
|
|
var have, left; /* available input and output */
|
|
var hold; /* bit buffer */
|
|
var bits; /* bits in bit buffer */
|
|
var _in, _out; /* save starting available input and output */
|
|
var copy; /* number of stored or match bytes to copy */
|
|
var from; /* where to copy match bytes from */
|
|
var from_source;
|
|
var here = 0; /* current decoding table entry */
|
|
var here_bits, here_op, here_val; // paked "here" denormalized (JS specific)
|
|
//var last; /* parent table entry */
|
|
var last_bits, last_op, last_val; // paked "last" denormalized (JS specific)
|
|
var len; /* length to copy for repeats, bits to drop */
|
|
var ret; /* return code */
|
|
var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */
|
|
var opts;
|
|
|
|
var n; // temporary var for NEED_BITS
|
|
|
|
var order = /* permutation of code lengths */
|
|
[ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ];
|
|
|
|
|
|
if (!strm || !strm.state || !strm.output ||
|
|
(!strm.input && strm.avail_in !== 0)) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
state = strm.state;
|
|
if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */
|
|
|
|
|
|
//--- LOAD() ---
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
//---
|
|
|
|
_in = have;
|
|
_out = left;
|
|
ret = Z_OK;
|
|
|
|
inf_leave: // goto emulation
|
|
for (;;) {
|
|
switch (state.mode) {
|
|
case HEAD:
|
|
if (state.wrap === 0) {
|
|
state.mode = TYPEDO;
|
|
break;
|
|
}
|
|
//=== NEEDBITS(16);
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */
|
|
state.check = 0/*crc32(0L, Z_NULL, 0)*/;
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = FLAGS;
|
|
break;
|
|
}
|
|
state.flags = 0; /* expect zlib header */
|
|
if (state.head) {
|
|
state.head.done = false;
|
|
}
|
|
if (!(state.wrap & 1) || /* check if zlib header allowed */
|
|
(((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) {
|
|
strm.msg = 'incorrect header check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) {
|
|
strm.msg = 'unknown compression method';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//--- DROPBITS(4) ---//
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
//---//
|
|
len = (hold & 0x0f)/*BITS(4)*/ + 8;
|
|
if (state.wbits === 0) {
|
|
state.wbits = len;
|
|
}
|
|
else if (len > state.wbits) {
|
|
strm.msg = 'invalid window size';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.dmax = 1 << len;
|
|
//Tracev((stderr, "inflate: zlib header ok\n"));
|
|
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
|
|
state.mode = hold & 0x200 ? DICTID : TYPE;
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
break;
|
|
case FLAGS:
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.flags = hold;
|
|
if ((state.flags & 0xff) !== Z_DEFLATED) {
|
|
strm.msg = 'unknown compression method';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.flags & 0xe000) {
|
|
strm.msg = 'unknown header flags set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
if (state.head) {
|
|
state.head.text = ((hold >> 8) & 1);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = TIME;
|
|
/* falls through */
|
|
case TIME:
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (state.head) {
|
|
state.head.time = hold;
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC4(state.check, hold)
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
hbuf[2] = (hold >>> 16) & 0xff;
|
|
hbuf[3] = (hold >>> 24) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 4, 0);
|
|
//===
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = OS;
|
|
/* falls through */
|
|
case OS:
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (state.head) {
|
|
state.head.xflags = (hold & 0xff);
|
|
state.head.os = (hold >> 8);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = EXLEN;
|
|
/* falls through */
|
|
case EXLEN:
|
|
if (state.flags & 0x0400) {
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.length = hold;
|
|
if (state.head) {
|
|
state.head.extra_len = hold;
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
//=== CRC2(state.check, hold);
|
|
hbuf[0] = hold & 0xff;
|
|
hbuf[1] = (hold >>> 8) & 0xff;
|
|
state.check = crc32(state.check, hbuf, 2, 0);
|
|
//===//
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
}
|
|
else if (state.head) {
|
|
state.head.extra = null/*Z_NULL*/;
|
|
}
|
|
state.mode = EXTRA;
|
|
/* falls through */
|
|
case EXTRA:
|
|
if (state.flags & 0x0400) {
|
|
copy = state.length;
|
|
if (copy > have) { copy = have; }
|
|
if (copy) {
|
|
if (state.head) {
|
|
len = state.head.extra_len - state.length;
|
|
if (!state.head.extra) {
|
|
// Use untyped array for more conveniend processing later
|
|
state.head.extra = new Array(state.head.extra_len);
|
|
}
|
|
utils.arraySet(
|
|
state.head.extra,
|
|
input,
|
|
next,
|
|
// extra field is limited to 65536 bytes
|
|
// - no need for additional size check
|
|
copy,
|
|
/*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
|
|
len
|
|
);
|
|
//zmemcpy(state.head.extra + len, next,
|
|
// len + copy > state.head.extra_max ?
|
|
// state.head.extra_max - len : copy);
|
|
}
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
state.length -= copy;
|
|
}
|
|
if (state.length) { break inf_leave; }
|
|
}
|
|
state.length = 0;
|
|
state.mode = NAME;
|
|
/* falls through */
|
|
case NAME:
|
|
if (state.flags & 0x0800) {
|
|
if (have === 0) { break inf_leave; }
|
|
copy = 0;
|
|
do {
|
|
// TODO: 2 or 1 bytes?
|
|
len = input[next + copy++];
|
|
/* use constant limit because in js we should not preallocate memory */
|
|
if (state.head && len &&
|
|
(state.length < 65536 /*state.head.name_max*/)) {
|
|
state.head.name += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy < have);
|
|
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
if (len) { break inf_leave; }
|
|
}
|
|
else if (state.head) {
|
|
state.head.name = null;
|
|
}
|
|
state.length = 0;
|
|
state.mode = COMMENT;
|
|
/* falls through */
|
|
case COMMENT:
|
|
if (state.flags & 0x1000) {
|
|
if (have === 0) { break inf_leave; }
|
|
copy = 0;
|
|
do {
|
|
len = input[next + copy++];
|
|
/* use constant limit because in js we should not preallocate memory */
|
|
if (state.head && len &&
|
|
(state.length < 65536 /*state.head.comm_max*/)) {
|
|
state.head.comment += String.fromCharCode(len);
|
|
}
|
|
} while (len && copy < have);
|
|
if (state.flags & 0x0200) {
|
|
state.check = crc32(state.check, input, copy, next);
|
|
}
|
|
have -= copy;
|
|
next += copy;
|
|
if (len) { break inf_leave; }
|
|
}
|
|
else if (state.head) {
|
|
state.head.comment = null;
|
|
}
|
|
state.mode = HCRC;
|
|
/* falls through */
|
|
case HCRC:
|
|
if (state.flags & 0x0200) {
|
|
//=== NEEDBITS(16); */
|
|
while (bits < 16) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (hold !== (state.check & 0xffff)) {
|
|
strm.msg = 'header crc mismatch';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
}
|
|
if (state.head) {
|
|
state.head.hcrc = ((state.flags >> 9) & 1);
|
|
state.head.done = true;
|
|
}
|
|
strm.adler = state.check = 0;
|
|
state.mode = TYPE;
|
|
break;
|
|
case DICTID:
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
strm.adler = state.check = zswap32(hold);
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = DICT;
|
|
/* falls through */
|
|
case DICT:
|
|
if (state.havedict === 0) {
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
return Z_NEED_DICT;
|
|
}
|
|
strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/;
|
|
state.mode = TYPE;
|
|
/* falls through */
|
|
case TYPE:
|
|
if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case TYPEDO:
|
|
if (state.last) {
|
|
//--- BYTEBITS() ---//
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
//---//
|
|
state.mode = CHECK;
|
|
break;
|
|
}
|
|
//=== NEEDBITS(3); */
|
|
while (bits < 3) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.last = (hold & 0x01)/*BITS(1)*/;
|
|
//--- DROPBITS(1) ---//
|
|
hold >>>= 1;
|
|
bits -= 1;
|
|
//---//
|
|
|
|
switch ((hold & 0x03)/*BITS(2)*/) {
|
|
case 0: /* stored block */
|
|
//Tracev((stderr, "inflate: stored block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = STORED;
|
|
break;
|
|
case 1: /* fixed block */
|
|
fixedtables(state);
|
|
//Tracev((stderr, "inflate: fixed codes block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = LEN_; /* decode codes */
|
|
if (flush === Z_TREES) {
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
break inf_leave;
|
|
}
|
|
break;
|
|
case 2: /* dynamic block */
|
|
//Tracev((stderr, "inflate: dynamic codes block%s\n",
|
|
// state.last ? " (last)" : ""));
|
|
state.mode = TABLE;
|
|
break;
|
|
case 3:
|
|
strm.msg = 'invalid block type';
|
|
state.mode = BAD;
|
|
}
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
break;
|
|
case STORED:
|
|
//--- BYTEBITS() ---// /* go to byte boundary */
|
|
hold >>>= bits & 7;
|
|
bits -= bits & 7;
|
|
//---//
|
|
//=== NEEDBITS(32); */
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) {
|
|
strm.msg = 'invalid stored block lengths';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.length = hold & 0xffff;
|
|
//Tracev((stderr, "inflate: stored length %u\n",
|
|
// state.length));
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
state.mode = COPY_;
|
|
if (flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case COPY_:
|
|
state.mode = COPY;
|
|
/* falls through */
|
|
case COPY:
|
|
copy = state.length;
|
|
if (copy) {
|
|
if (copy > have) { copy = have; }
|
|
if (copy > left) { copy = left; }
|
|
if (copy === 0) { break inf_leave; }
|
|
//--- zmemcpy(put, next, copy); ---
|
|
utils.arraySet(output, input, next, copy, put);
|
|
//---//
|
|
have -= copy;
|
|
next += copy;
|
|
left -= copy;
|
|
put += copy;
|
|
state.length -= copy;
|
|
break;
|
|
}
|
|
//Tracev((stderr, "inflate: stored end\n"));
|
|
state.mode = TYPE;
|
|
break;
|
|
case TABLE:
|
|
//=== NEEDBITS(14); */
|
|
while (bits < 14) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257;
|
|
//--- DROPBITS(5) ---//
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
//---//
|
|
state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1;
|
|
//--- DROPBITS(5) ---//
|
|
hold >>>= 5;
|
|
bits -= 5;
|
|
//---//
|
|
state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4;
|
|
//--- DROPBITS(4) ---//
|
|
hold >>>= 4;
|
|
bits -= 4;
|
|
//---//
|
|
//#ifndef PKZIP_BUG_WORKAROUND
|
|
if (state.nlen > 286 || state.ndist > 30) {
|
|
strm.msg = 'too many length or distance symbols';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//#endif
|
|
//Tracev((stderr, "inflate: table sizes ok\n"));
|
|
state.have = 0;
|
|
state.mode = LENLENS;
|
|
/* falls through */
|
|
case LENLENS:
|
|
while (state.have < state.ncode) {
|
|
//=== NEEDBITS(3);
|
|
while (bits < 3) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.lens[order[state.have++]] = (hold & 0x07);//BITS(3);
|
|
//--- DROPBITS(3) ---//
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
//---//
|
|
}
|
|
while (state.have < 19) {
|
|
state.lens[order[state.have++]] = 0;
|
|
}
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
//state.next = state.codes;
|
|
//state.lencode = state.next;
|
|
// Switch to use dynamic table
|
|
state.lencode = state.lendyn;
|
|
state.lenbits = 7;
|
|
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts);
|
|
state.lenbits = opts.bits;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid code lengths set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//Tracev((stderr, "inflate: code lengths ok\n"));
|
|
state.have = 0;
|
|
state.mode = CODELENS;
|
|
/* falls through */
|
|
case CODELENS:
|
|
while (state.have < state.nlen + state.ndist) {
|
|
for (;;) {
|
|
here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if (here_val < 16) {
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.lens[state.have++] = here_val;
|
|
}
|
|
else {
|
|
if (here_val === 16) {
|
|
//=== NEEDBITS(here.bits + 2);
|
|
n = here_bits + 2;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
if (state.have === 0) {
|
|
strm.msg = 'invalid bit length repeat';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
len = state.lens[state.have - 1];
|
|
copy = 3 + (hold & 0x03);//BITS(2);
|
|
//--- DROPBITS(2) ---//
|
|
hold >>>= 2;
|
|
bits -= 2;
|
|
//---//
|
|
}
|
|
else if (here_val === 17) {
|
|
//=== NEEDBITS(here.bits + 3);
|
|
n = here_bits + 3;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
len = 0;
|
|
copy = 3 + (hold & 0x07);//BITS(3);
|
|
//--- DROPBITS(3) ---//
|
|
hold >>>= 3;
|
|
bits -= 3;
|
|
//---//
|
|
}
|
|
else {
|
|
//=== NEEDBITS(here.bits + 7);
|
|
n = here_bits + 7;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
len = 0;
|
|
copy = 11 + (hold & 0x7f);//BITS(7);
|
|
//--- DROPBITS(7) ---//
|
|
hold >>>= 7;
|
|
bits -= 7;
|
|
//---//
|
|
}
|
|
if (state.have + copy > state.nlen + state.ndist) {
|
|
strm.msg = 'invalid bit length repeat';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
while (copy--) {
|
|
state.lens[state.have++] = len;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* handle error breaks in while */
|
|
if (state.mode === BAD) { break; }
|
|
|
|
/* check for end-of-block code (better have one) */
|
|
if (state.lens[256] === 0) {
|
|
strm.msg = 'invalid code -- missing end-of-block';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
|
|
/* build code tables -- note: do not change the lenbits or distbits
|
|
values here (9 and 6) without reading the comments in inftrees.h
|
|
concerning the ENOUGH constants, which depend on those values */
|
|
state.lenbits = 9;
|
|
|
|
opts = { bits: state.lenbits };
|
|
ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
// state.next_index = opts.table_index;
|
|
state.lenbits = opts.bits;
|
|
// state.lencode = state.next;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid literal/lengths set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
|
|
state.distbits = 6;
|
|
//state.distcode.copy(state.codes);
|
|
// Switch to use dynamic table
|
|
state.distcode = state.distdyn;
|
|
opts = { bits: state.distbits };
|
|
ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
|
|
// We have separate tables & no pointers. 2 commented lines below not needed.
|
|
// state.next_index = opts.table_index;
|
|
state.distbits = opts.bits;
|
|
// state.distcode = state.next;
|
|
|
|
if (ret) {
|
|
strm.msg = 'invalid distances set';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//Tracev((stderr, 'inflate: codes ok\n'));
|
|
state.mode = LEN_;
|
|
if (flush === Z_TREES) { break inf_leave; }
|
|
/* falls through */
|
|
case LEN_:
|
|
state.mode = LEN;
|
|
/* falls through */
|
|
case LEN:
|
|
if (have >= 6 && left >= 258) {
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
inflate_fast(strm, _out);
|
|
//--- LOAD() ---
|
|
put = strm.next_out;
|
|
output = strm.output;
|
|
left = strm.avail_out;
|
|
next = strm.next_in;
|
|
input = strm.input;
|
|
have = strm.avail_in;
|
|
hold = state.hold;
|
|
bits = state.bits;
|
|
//---
|
|
|
|
if (state.mode === TYPE) {
|
|
state.back = -1;
|
|
}
|
|
break;
|
|
}
|
|
state.back = 0;
|
|
for (;;) {
|
|
here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if (here_bits <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if (here_op && (here_op & 0xf0) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (;;) {
|
|
here = state.lencode[last_val +
|
|
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((last_bits + here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
//--- DROPBITS(last.bits) ---//
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
//---//
|
|
state.back += last_bits;
|
|
}
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.back += here_bits;
|
|
state.length = here_val;
|
|
if (here_op === 0) {
|
|
//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
|
// "inflate: literal '%c'\n" :
|
|
// "inflate: literal 0x%02x\n", here.val));
|
|
state.mode = LIT;
|
|
break;
|
|
}
|
|
if (here_op & 32) {
|
|
//Tracevv((stderr, "inflate: end of block\n"));
|
|
state.back = -1;
|
|
state.mode = TYPE;
|
|
break;
|
|
}
|
|
if (here_op & 64) {
|
|
strm.msg = 'invalid literal/length code';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.extra = here_op & 15;
|
|
state.mode = LENEXT;
|
|
/* falls through */
|
|
case LENEXT:
|
|
if (state.extra) {
|
|
//=== NEEDBITS(state.extra);
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
|
|
//--- DROPBITS(state.extra) ---//
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
//---//
|
|
state.back += state.extra;
|
|
}
|
|
//Tracevv((stderr, "inflate: length %u\n", state.length));
|
|
state.was = state.length;
|
|
state.mode = DIST;
|
|
/* falls through */
|
|
case DIST:
|
|
for (;;) {
|
|
here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
if ((here_op & 0xf0) === 0) {
|
|
last_bits = here_bits;
|
|
last_op = here_op;
|
|
last_val = here_val;
|
|
for (;;) {
|
|
here = state.distcode[last_val +
|
|
((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)];
|
|
here_bits = here >>> 24;
|
|
here_op = (here >>> 16) & 0xff;
|
|
here_val = here & 0xffff;
|
|
|
|
if ((last_bits + here_bits) <= bits) { break; }
|
|
//--- PULLBYTE() ---//
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
//---//
|
|
}
|
|
//--- DROPBITS(last.bits) ---//
|
|
hold >>>= last_bits;
|
|
bits -= last_bits;
|
|
//---//
|
|
state.back += last_bits;
|
|
}
|
|
//--- DROPBITS(here.bits) ---//
|
|
hold >>>= here_bits;
|
|
bits -= here_bits;
|
|
//---//
|
|
state.back += here_bits;
|
|
if (here_op & 64) {
|
|
strm.msg = 'invalid distance code';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
state.offset = here_val;
|
|
state.extra = (here_op) & 15;
|
|
state.mode = DISTEXT;
|
|
/* falls through */
|
|
case DISTEXT:
|
|
if (state.extra) {
|
|
//=== NEEDBITS(state.extra);
|
|
n = state.extra;
|
|
while (bits < n) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/;
|
|
//--- DROPBITS(state.extra) ---//
|
|
hold >>>= state.extra;
|
|
bits -= state.extra;
|
|
//---//
|
|
state.back += state.extra;
|
|
}
|
|
//#ifdef INFLATE_STRICT
|
|
if (state.offset > state.dmax) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//#endif
|
|
//Tracevv((stderr, "inflate: distance %u\n", state.offset));
|
|
state.mode = MATCH;
|
|
/* falls through */
|
|
case MATCH:
|
|
if (left === 0) { break inf_leave; }
|
|
copy = _out - left;
|
|
if (state.offset > copy) { /* copy from window */
|
|
copy = state.offset - copy;
|
|
if (copy > state.whave) {
|
|
if (state.sane) {
|
|
strm.msg = 'invalid distance too far back';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
// (!) This block is disabled in zlib defailts,
|
|
// don't enable it for binary compatibility
|
|
//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
|
// Trace((stderr, "inflate.c too far\n"));
|
|
// copy -= state.whave;
|
|
// if (copy > state.length) { copy = state.length; }
|
|
// if (copy > left) { copy = left; }
|
|
// left -= copy;
|
|
// state.length -= copy;
|
|
// do {
|
|
// output[put++] = 0;
|
|
// } while (--copy);
|
|
// if (state.length === 0) { state.mode = LEN; }
|
|
// break;
|
|
//#endif
|
|
}
|
|
if (copy > state.wnext) {
|
|
copy -= state.wnext;
|
|
from = state.wsize - copy;
|
|
}
|
|
else {
|
|
from = state.wnext - copy;
|
|
}
|
|
if (copy > state.length) { copy = state.length; }
|
|
from_source = state.window;
|
|
}
|
|
else { /* copy from output */
|
|
from_source = output;
|
|
from = put - state.offset;
|
|
copy = state.length;
|
|
}
|
|
if (copy > left) { copy = left; }
|
|
left -= copy;
|
|
state.length -= copy;
|
|
do {
|
|
output[put++] = from_source[from++];
|
|
} while (--copy);
|
|
if (state.length === 0) { state.mode = LEN; }
|
|
break;
|
|
case LIT:
|
|
if (left === 0) { break inf_leave; }
|
|
output[put++] = state.length;
|
|
left--;
|
|
state.mode = LEN;
|
|
break;
|
|
case CHECK:
|
|
if (state.wrap) {
|
|
//=== NEEDBITS(32);
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
// Use '|' insdead of '+' to make sure that result is signed
|
|
hold |= input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
_out -= left;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (_out) {
|
|
strm.adler = state.check =
|
|
/*UPDATE(state.check, put - _out, _out);*/
|
|
(state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out));
|
|
|
|
}
|
|
_out = left;
|
|
// NB: crc32 stored as signed 32-bit int, zswap32 returns signed too
|
|
if ((state.flags ? hold : zswap32(hold)) !== state.check) {
|
|
strm.msg = 'incorrect data check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
//Tracev((stderr, "inflate: check matches trailer\n"));
|
|
}
|
|
state.mode = LENGTH;
|
|
/* falls through */
|
|
case LENGTH:
|
|
if (state.wrap && state.flags) {
|
|
//=== NEEDBITS(32);
|
|
while (bits < 32) {
|
|
if (have === 0) { break inf_leave; }
|
|
have--;
|
|
hold += input[next++] << bits;
|
|
bits += 8;
|
|
}
|
|
//===//
|
|
if (hold !== (state.total & 0xffffffff)) {
|
|
strm.msg = 'incorrect length check';
|
|
state.mode = BAD;
|
|
break;
|
|
}
|
|
//=== INITBITS();
|
|
hold = 0;
|
|
bits = 0;
|
|
//===//
|
|
//Tracev((stderr, "inflate: length matches trailer\n"));
|
|
}
|
|
state.mode = DONE;
|
|
/* falls through */
|
|
case DONE:
|
|
ret = Z_STREAM_END;
|
|
break inf_leave;
|
|
case BAD:
|
|
ret = Z_DATA_ERROR;
|
|
break inf_leave;
|
|
case MEM:
|
|
return Z_MEM_ERROR;
|
|
case SYNC:
|
|
/* falls through */
|
|
default:
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
}
|
|
|
|
// inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave"
|
|
|
|
/*
|
|
Return from inflate(), updating the total counts and the check value.
|
|
If there was no progress during the inflate() call, return a buffer
|
|
error. Call updatewindow() to create and/or update the window state.
|
|
Note: a memory error from inflate() is non-recoverable.
|
|
*/
|
|
|
|
//--- RESTORE() ---
|
|
strm.next_out = put;
|
|
strm.avail_out = left;
|
|
strm.next_in = next;
|
|
strm.avail_in = have;
|
|
state.hold = hold;
|
|
state.bits = bits;
|
|
//---
|
|
|
|
if (state.wsize || (_out !== strm.avail_out && state.mode < BAD &&
|
|
(state.mode < CHECK || flush !== Z_FINISH))) {
|
|
if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
}
|
|
_in -= strm.avail_in;
|
|
_out -= strm.avail_out;
|
|
strm.total_in += _in;
|
|
strm.total_out += _out;
|
|
state.total += _out;
|
|
if (state.wrap && _out) {
|
|
strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
|
|
(state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out));
|
|
}
|
|
strm.data_type = state.bits + (state.last ? 64 : 0) +
|
|
(state.mode === TYPE ? 128 : 0) +
|
|
(state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
|
|
if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) {
|
|
ret = Z_BUF_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function inflateEnd(strm) {
|
|
|
|
if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
var state = strm.state;
|
|
if (state.window) {
|
|
state.window = null;
|
|
}
|
|
strm.state = null;
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateGetHeader(strm, head) {
|
|
var state;
|
|
|
|
/* check state */
|
|
if (!strm || !strm.state) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; }
|
|
|
|
/* save header structure */
|
|
state.head = head;
|
|
head.done = false;
|
|
return Z_OK;
|
|
}
|
|
|
|
function inflateSetDictionary(strm, dictionary) {
|
|
var dictLength = dictionary.length;
|
|
|
|
var state;
|
|
var dictid;
|
|
var ret;
|
|
|
|
/* check state */
|
|
if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; }
|
|
state = strm.state;
|
|
|
|
if (state.wrap !== 0 && state.mode !== DICT) {
|
|
return Z_STREAM_ERROR;
|
|
}
|
|
|
|
/* check for correct dictionary identifier */
|
|
if (state.mode === DICT) {
|
|
dictid = 1; /* adler32(0, null, 0)*/
|
|
/* dictid = adler32(dictid, dictionary, dictLength); */
|
|
dictid = adler32(dictid, dictionary, dictLength, 0);
|
|
if (dictid !== state.check) {
|
|
return Z_DATA_ERROR;
|
|
}
|
|
}
|
|
/* copy dictionary to window using updatewindow(), which will amend the
|
|
existing dictionary if appropriate */
|
|
ret = updatewindow(strm, dictionary, dictLength, dictLength);
|
|
if (ret) {
|
|
state.mode = MEM;
|
|
return Z_MEM_ERROR;
|
|
}
|
|
state.havedict = 1;
|
|
// Tracev((stderr, "inflate: dictionary set\n"));
|
|
return Z_OK;
|
|
}
|
|
|
|
exports.inflateReset = inflateReset;
|
|
exports.inflateReset2 = inflateReset2;
|
|
exports.inflateResetKeep = inflateResetKeep;
|
|
exports.inflateInit = inflateInit;
|
|
exports.inflateInit2 = inflateInit2;
|
|
exports.inflate = inflate;
|
|
exports.inflateEnd = inflateEnd;
|
|
exports.inflateGetHeader = inflateGetHeader;
|
|
exports.inflateSetDictionary = inflateSetDictionary;
|
|
exports.inflateInfo = 'pako inflate (from Nodeca project)';
|
|
|
|
/* Not implemented
|
|
exports.inflateCopy = inflateCopy;
|
|
exports.inflateGetDictionary = inflateGetDictionary;
|
|
exports.inflateMark = inflateMark;
|
|
exports.inflatePrime = inflatePrime;
|
|
exports.inflateSync = inflateSync;
|
|
exports.inflateSyncPoint = inflateSyncPoint;
|
|
exports.inflateUndermine = inflateUndermine;
|
|
*/
|
|
|
|
},{"../utils/common":22,"./adler32":24,"./crc32":26,"./inffast":28,"./inftrees":30}],30:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
var utils = require('../utils/common');
|
|
|
|
var MAXBITS = 15;
|
|
var ENOUGH_LENS = 852;
|
|
var ENOUGH_DISTS = 592;
|
|
//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS);
|
|
|
|
var CODES = 0;
|
|
var LENS = 1;
|
|
var DISTS = 2;
|
|
|
|
var lbase = [ /* Length codes 257..285 base */
|
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
|
|
];
|
|
|
|
var lext = [ /* Length codes 257..285 extra */
|
|
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
|
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78
|
|
];
|
|
|
|
var dbase = [ /* Distance codes 0..29 base */
|
|
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, 0, 0
|
|
];
|
|
|
|
var dext = [ /* Distance codes 0..29 extra */
|
|
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
|
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
|
28, 28, 29, 29, 64, 64
|
|
];
|
|
|
|
module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts)
|
|
{
|
|
var bits = opts.bits;
|
|
//here = opts.here; /* table entry for duplication */
|
|
|
|
var len = 0; /* a code's length in bits */
|
|
var sym = 0; /* index of code symbols */
|
|
var min = 0, max = 0; /* minimum and maximum code lengths */
|
|
var root = 0; /* number of index bits for root table */
|
|
var curr = 0; /* number of index bits for current table */
|
|
var drop = 0; /* code bits to drop for sub-table */
|
|
var left = 0; /* number of prefix codes available */
|
|
var used = 0; /* code entries in table used */
|
|
var huff = 0; /* Huffman code */
|
|
var incr; /* for incrementing code, index */
|
|
var fill; /* index for replicating entries */
|
|
var low; /* low bits for current root entry */
|
|
var mask; /* mask for low root bits */
|
|
var next; /* next available space in table */
|
|
var base = null; /* base value table to use */
|
|
var base_index = 0;
|
|
// var shoextra; /* extra bits table to use */
|
|
var end; /* use base and extra for symbol > end */
|
|
var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */
|
|
var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */
|
|
var extra = null;
|
|
var extra_index = 0;
|
|
|
|
var here_bits, here_op, here_val;
|
|
|
|
/*
|
|
Process a set of code lengths to create a canonical Huffman code. The
|
|
code lengths are lens[0..codes-1]. Each length corresponds to the
|
|
symbols 0..codes-1. The Huffman code is generated by first sorting the
|
|
symbols by length from short to long, and retaining the symbol order
|
|
for codes with equal lengths. Then the code starts with all zero bits
|
|
for the first code of the shortest length, and the codes are integer
|
|
increments for the same length, and zeros are appended as the length
|
|
increases. For the deflate format, these bits are stored backwards
|
|
from their more natural integer increment ordering, and so when the
|
|
decoding tables are built in the large loop below, the integer codes
|
|
are incremented backwards.
|
|
|
|
This routine assumes, but does not check, that all of the entries in
|
|
lens[] are in the range 0..MAXBITS. The caller must assure this.
|
|
1..MAXBITS is interpreted as that code length. zero means that that
|
|
symbol does not occur in this code.
|
|
|
|
The codes are sorted by computing a count of codes for each length,
|
|
creating from that a table of starting indices for each length in the
|
|
sorted table, and then entering the symbols in order in the sorted
|
|
table. The sorted table is work[], with that space being provided by
|
|
the caller.
|
|
|
|
The length counts are used for other purposes as well, i.e. finding
|
|
the minimum and maximum length codes, determining if there are any
|
|
codes at all, checking for a valid set of lengths, and looking ahead
|
|
at length counts to determine sub-table sizes when building the
|
|
decoding tables.
|
|
*/
|
|
|
|
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
|
|
for (len = 0; len <= MAXBITS; len++) {
|
|
count[len] = 0;
|
|
}
|
|
for (sym = 0; sym < codes; sym++) {
|
|
count[lens[lens_index + sym]]++;
|
|
}
|
|
|
|
/* bound code lengths, force root to be within code lengths */
|
|
root = bits;
|
|
for (max = MAXBITS; max >= 1; max--) {
|
|
if (count[max] !== 0) { break; }
|
|
}
|
|
if (root > max) {
|
|
root = max;
|
|
}
|
|
if (max === 0) { /* no symbols to code at all */
|
|
//table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */
|
|
//table.bits[opts.table_index] = 1; //here.bits = (var char)1;
|
|
//table.val[opts.table_index++] = 0; //here.val = (var short)0;
|
|
table[table_index++] = (1 << 24) | (64 << 16) | 0;
|
|
|
|
|
|
//table.op[opts.table_index] = 64;
|
|
//table.bits[opts.table_index] = 1;
|
|
//table.val[opts.table_index++] = 0;
|
|
table[table_index++] = (1 << 24) | (64 << 16) | 0;
|
|
|
|
opts.bits = 1;
|
|
return 0; /* no symbols, but wait for decoding to report error */
|
|
}
|
|
for (min = 1; min < max; min++) {
|
|
if (count[min] !== 0) { break; }
|
|
}
|
|
if (root < min) {
|
|
root = min;
|
|
}
|
|
|
|
/* check for an over-subscribed or incomplete set of lengths */
|
|
left = 1;
|
|
for (len = 1; len <= MAXBITS; len++) {
|
|
left <<= 1;
|
|
left -= count[len];
|
|
if (left < 0) {
|
|
return -1;
|
|
} /* over-subscribed */
|
|
}
|
|
if (left > 0 && (type === CODES || max !== 1)) {
|
|
return -1; /* incomplete set */
|
|
}
|
|
|
|
/* generate offsets into symbol table for each length for sorting */
|
|
offs[1] = 0;
|
|
for (len = 1; len < MAXBITS; len++) {
|
|
offs[len + 1] = offs[len] + count[len];
|
|
}
|
|
|
|
/* sort symbols by length, by symbol order within each length */
|
|
for (sym = 0; sym < codes; sym++) {
|
|
if (lens[lens_index + sym] !== 0) {
|
|
work[offs[lens[lens_index + sym]]++] = sym;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Create and fill in decoding tables. In this loop, the table being
|
|
filled is at next and has curr index bits. The code being used is huff
|
|
with length len. That code is converted to an index by dropping drop
|
|
bits off of the bottom. For codes where len is less than drop + curr,
|
|
those top drop + curr - len bits are incremented through all values to
|
|
fill the table with replicated entries.
|
|
|
|
root is the number of index bits for the root table. When len exceeds
|
|
root, sub-tables are created pointed to by the root entry with an index
|
|
of the low root bits of huff. This is saved in low to check for when a
|
|
new sub-table should be started. drop is zero when the root table is
|
|
being filled, and drop is root when sub-tables are being filled.
|
|
|
|
When a new sub-table is needed, it is necessary to look ahead in the
|
|
code lengths to determine what size sub-table is needed. The length
|
|
counts are used for this, and so count[] is decremented as codes are
|
|
entered in the tables.
|
|
|
|
used keeps track of how many table entries have been allocated from the
|
|
provided *table space. It is checked for LENS and DIST tables against
|
|
the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
|
|
the initial root table size constants. See the comments in inftrees.h
|
|
for more information.
|
|
|
|
sym increments through all symbols, and the loop terminates when
|
|
all codes of length max, i.e. all codes, have been processed. This
|
|
routine permits incomplete codes, so another loop after this one fills
|
|
in the rest of the decoding tables with invalid code markers.
|
|
*/
|
|
|
|
/* set up for code type */
|
|
// poor man optimization - use if-else instead of switch,
|
|
// to avoid deopts in old v8
|
|
if (type === CODES) {
|
|
base = extra = work; /* dummy value--not used */
|
|
end = 19;
|
|
|
|
} else if (type === LENS) {
|
|
base = lbase;
|
|
base_index -= 257;
|
|
extra = lext;
|
|
extra_index -= 257;
|
|
end = 256;
|
|
|
|
} else { /* DISTS */
|
|
base = dbase;
|
|
extra = dext;
|
|
end = -1;
|
|
}
|
|
|
|
/* initialize opts for loop */
|
|
huff = 0; /* starting code */
|
|
sym = 0; /* starting code symbol */
|
|
len = min; /* starting code length */
|
|
next = table_index; /* current table to fill in */
|
|
curr = root; /* current table index bits */
|
|
drop = 0; /* current bits to drop from code for index */
|
|
low = -1; /* trigger new sub-table when len > root */
|
|
used = 1 << root; /* use root table entries */
|
|
mask = used - 1; /* mask for comparing low */
|
|
|
|
/* check available table space */
|
|
if ((type === LENS && used > ENOUGH_LENS) ||
|
|
(type === DISTS && used > ENOUGH_DISTS)) {
|
|
return 1;
|
|
}
|
|
|
|
var i = 0;
|
|
/* process all codes and make table entries */
|
|
for (;;) {
|
|
i++;
|
|
/* create table entry */
|
|
here_bits = len - drop;
|
|
if (work[sym] < end) {
|
|
here_op = 0;
|
|
here_val = work[sym];
|
|
}
|
|
else if (work[sym] > end) {
|
|
here_op = extra[extra_index + work[sym]];
|
|
here_val = base[base_index + work[sym]];
|
|
}
|
|
else {
|
|
here_op = 32 + 64; /* end of block */
|
|
here_val = 0;
|
|
}
|
|
|
|
/* replicate for those indices with low len bits equal to huff */
|
|
incr = 1 << (len - drop);
|
|
fill = 1 << curr;
|
|
min = fill; /* save offset to next table */
|
|
do {
|
|
fill -= incr;
|
|
table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0;
|
|
} while (fill !== 0);
|
|
|
|
/* backwards increment the len-bit code huff */
|
|
incr = 1 << (len - 1);
|
|
while (huff & incr) {
|
|
incr >>= 1;
|
|
}
|
|
if (incr !== 0) {
|
|
huff &= incr - 1;
|
|
huff += incr;
|
|
} else {
|
|
huff = 0;
|
|
}
|
|
|
|
/* go to next symbol, update count, len */
|
|
sym++;
|
|
if (--count[len] === 0) {
|
|
if (len === max) { break; }
|
|
len = lens[lens_index + work[sym]];
|
|
}
|
|
|
|
/* create new sub-table if needed */
|
|
if (len > root && (huff & mask) !== low) {
|
|
/* if first time, transition to sub-tables */
|
|
if (drop === 0) {
|
|
drop = root;
|
|
}
|
|
|
|
/* increment past last table */
|
|
next += min; /* here min is 1 << curr */
|
|
|
|
/* determine length of next table */
|
|
curr = len - drop;
|
|
left = 1 << curr;
|
|
while (curr + drop < max) {
|
|
left -= count[curr + drop];
|
|
if (left <= 0) { break; }
|
|
curr++;
|
|
left <<= 1;
|
|
}
|
|
|
|
/* check for enough space */
|
|
used += 1 << curr;
|
|
if ((type === LENS && used > ENOUGH_LENS) ||
|
|
(type === DISTS && used > ENOUGH_DISTS)) {
|
|
return 1;
|
|
}
|
|
|
|
/* point entry in root table to sub-table */
|
|
low = huff & mask;
|
|
/*table.op[low] = curr;
|
|
table.bits[low] = root;
|
|
table.val[low] = next - opts.table_index;*/
|
|
table[low] = (root << 24) | (curr << 16) | (next - table_index) |0;
|
|
}
|
|
}
|
|
|
|
/* fill in remaining table entry if code is incomplete (guaranteed to have
|
|
at most one remaining entry, since if the code is incomplete, the
|
|
maximum code length that was allowed to get this far is one bit) */
|
|
if (huff !== 0) {
|
|
//table.op[next + huff] = 64; /* invalid code marker */
|
|
//table.bits[next + huff] = len - drop;
|
|
//table.val[next + huff] = 0;
|
|
table[next + huff] = ((len - drop) << 24) | (64 << 16) |0;
|
|
}
|
|
|
|
/* set return parameters */
|
|
//opts.table_index += used;
|
|
opts.bits = root;
|
|
return 0;
|
|
};
|
|
|
|
},{"../utils/common":22}],31:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = {
|
|
2: 'need dictionary', /* Z_NEED_DICT 2 */
|
|
1: 'stream end', /* Z_STREAM_END 1 */
|
|
0: '', /* Z_OK 0 */
|
|
'-1': 'file error', /* Z_ERRNO (-1) */
|
|
'-2': 'stream error', /* Z_STREAM_ERROR (-2) */
|
|
'-3': 'data error', /* Z_DATA_ERROR (-3) */
|
|
'-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */
|
|
'-5': 'buffer error', /* Z_BUF_ERROR (-5) */
|
|
'-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */
|
|
};
|
|
|
|
},{}],32:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
|
|
function ZStream() {
|
|
/* next input byte */
|
|
this.input = null; // JS specific, because we have no pointers
|
|
this.next_in = 0;
|
|
/* number of bytes available at input */
|
|
this.avail_in = 0;
|
|
/* total number of input bytes read so far */
|
|
this.total_in = 0;
|
|
/* next output byte should be put there */
|
|
this.output = null; // JS specific, because we have no pointers
|
|
this.next_out = 0;
|
|
/* remaining free space at output */
|
|
this.avail_out = 0;
|
|
/* total number of bytes output so far */
|
|
this.total_out = 0;
|
|
/* last error message, NULL if no error */
|
|
this.msg = ''/*Z_NULL*/;
|
|
/* not visible by applications */
|
|
this.state = null;
|
|
/* best guess about the data type: binary or text */
|
|
this.data_type = 2/*Z_UNKNOWN*/;
|
|
/* adler32 value of the uncompressed data */
|
|
this.adler = 0;
|
|
}
|
|
|
|
module.exports = ZStream;
|
|
|
|
},{}],33:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
var process = module.exports = {};
|
|
|
|
// cached from whatever global is present so that test runners that stub it
|
|
// don't break things. But we need to wrap it in a try catch in case it is
|
|
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
// function because try/catches deoptimize in certain engines.
|
|
|
|
var cachedSetTimeout;
|
|
var cachedClearTimeout;
|
|
|
|
function defaultSetTimout() {
|
|
throw new Error('setTimeout has not been defined');
|
|
}
|
|
function defaultClearTimeout () {
|
|
throw new Error('clearTimeout has not been defined');
|
|
}
|
|
(function () {
|
|
try {
|
|
if (typeof setTimeout === 'function') {
|
|
cachedSetTimeout = setTimeout;
|
|
} else {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
} catch (e) {
|
|
cachedSetTimeout = defaultSetTimout;
|
|
}
|
|
try {
|
|
if (typeof clearTimeout === 'function') {
|
|
cachedClearTimeout = clearTimeout;
|
|
} else {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} catch (e) {
|
|
cachedClearTimeout = defaultClearTimeout;
|
|
}
|
|
} ())
|
|
function runTimeout(fun) {
|
|
if (cachedSetTimeout === setTimeout) {
|
|
//normal enviroments in sane situations
|
|
return setTimeout(fun, 0);
|
|
}
|
|
// if setTimeout wasn't available but was latter defined
|
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
cachedSetTimeout = setTimeout;
|
|
return setTimeout(fun, 0);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedSetTimeout(fun, 0);
|
|
} catch(e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedSetTimeout.call(null, fun, 0);
|
|
} catch(e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
return cachedSetTimeout.call(this, fun, 0);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
function runClearTimeout(marker) {
|
|
if (cachedClearTimeout === clearTimeout) {
|
|
//normal enviroments in sane situations
|
|
return clearTimeout(marker);
|
|
}
|
|
// if clearTimeout wasn't available but was latter defined
|
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
cachedClearTimeout = clearTimeout;
|
|
return clearTimeout(marker);
|
|
}
|
|
try {
|
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
return cachedClearTimeout(marker);
|
|
} catch (e){
|
|
try {
|
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
return cachedClearTimeout.call(null, marker);
|
|
} catch (e){
|
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
return cachedClearTimeout.call(this, marker);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
var queue = [];
|
|
var draining = false;
|
|
var currentQueue;
|
|
var queueIndex = -1;
|
|
|
|
function cleanUpNextTick() {
|
|
if (!draining || !currentQueue) {
|
|
return;
|
|
}
|
|
draining = false;
|
|
if (currentQueue.length) {
|
|
queue = currentQueue.concat(queue);
|
|
} else {
|
|
queueIndex = -1;
|
|
}
|
|
if (queue.length) {
|
|
drainQueue();
|
|
}
|
|
}
|
|
|
|
function drainQueue() {
|
|
if (draining) {
|
|
return;
|
|
}
|
|
var timeout = runTimeout(cleanUpNextTick);
|
|
draining = true;
|
|
|
|
var len = queue.length;
|
|
while(len) {
|
|
currentQueue = queue;
|
|
queue = [];
|
|
while (++queueIndex < len) {
|
|
if (currentQueue) {
|
|
currentQueue[queueIndex].run();
|
|
}
|
|
}
|
|
queueIndex = -1;
|
|
len = queue.length;
|
|
}
|
|
currentQueue = null;
|
|
draining = false;
|
|
runClearTimeout(timeout);
|
|
}
|
|
|
|
process.nextTick = function (fun) {
|
|
var args = new Array(arguments.length - 1);
|
|
if (arguments.length > 1) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
args[i - 1] = arguments[i];
|
|
}
|
|
}
|
|
queue.push(new Item(fun, args));
|
|
if (queue.length === 1 && !draining) {
|
|
runTimeout(drainQueue);
|
|
}
|
|
};
|
|
|
|
// v8 likes predictible objects
|
|
function Item(fun, array) {
|
|
this.fun = fun;
|
|
this.array = array;
|
|
}
|
|
Item.prototype.run = function () {
|
|
this.fun.apply(null, this.array);
|
|
};
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
process.version = ''; // empty string to avoid regexp issues
|
|
process.versions = {};
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
};
|
|
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
process.umask = function() { return 0; };
|
|
|
|
},{}],34:[function(require,module,exports){
|
|
(function (Buffer){
|
|
/**
|
|
* Convert a typed array to a Buffer without a copy
|
|
*
|
|
* Author: Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
|
* License: MIT
|
|
*
|
|
* `npm install typedarray-to-buffer`
|
|
*/
|
|
|
|
module.exports = function (arr) {
|
|
if (typeof Buffer._augment === 'function' && Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// If `Buffer` is from the `buffer` module and this browser supports typed arrays,
|
|
// then augment it with all the `Buffer` methods.
|
|
return Buffer._augment(arr)
|
|
} else {
|
|
// Otherwise, fallback to creating a `Buffer` with a copy.
|
|
return new Buffer(arr)
|
|
}
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":6}],35:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
|
|
},{}],36:[function(require,module,exports){
|
|
module.exports = function isBuffer(arg) {
|
|
return arg && typeof arg === 'object'
|
|
&& typeof arg.copy === 'function'
|
|
&& typeof arg.fill === 'function'
|
|
&& typeof arg.readUInt8 === 'function';
|
|
}
|
|
},{}],37:[function(require,module,exports){
|
|
(function (process,global){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var formatRegExp = /%[sdj%]/g;
|
|
exports.format = function(f) {
|
|
if (!isString(f)) {
|
|
var objects = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
objects.push(inspect(arguments[i]));
|
|
}
|
|
return objects.join(' ');
|
|
}
|
|
|
|
var i = 1;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
var str = String(f).replace(formatRegExp, function(x) {
|
|
if (x === '%%') return '%';
|
|
if (i >= len) return x;
|
|
switch (x) {
|
|
case '%s': return String(args[i++]);
|
|
case '%d': return Number(args[i++]);
|
|
case '%j':
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_) {
|
|
return '[Circular]';
|
|
}
|
|
default:
|
|
return x;
|
|
}
|
|
});
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|
if (isNull(x) || !isObject(x)) {
|
|
str += ' ' + x;
|
|
} else {
|
|
str += ' ' + inspect(x);
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
|
|
// Mark that a method should not be used.
|
|
// Returns a modified function which warns once by default.
|
|
// If --no-deprecation is set, then it is a no-op.
|
|
exports.deprecate = function(fn, msg) {
|
|
// Allow for deprecating things in the process of starting up.
|
|
if (isUndefined(global.process)) {
|
|
return function() {
|
|
return exports.deprecate(fn, msg).apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
if (process.noDeprecation === true) {
|
|
return fn;
|
|
}
|
|
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (process.throwDeprecation) {
|
|
throw new Error(msg);
|
|
} else if (process.traceDeprecation) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.error(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
};
|
|
|
|
|
|
var debugs = {};
|
|
var debugEnviron;
|
|
exports.debuglog = function(set) {
|
|
if (isUndefined(debugEnviron))
|
|
debugEnviron = process.env.NODE_DEBUG || '';
|
|
set = set.toUpperCase();
|
|
if (!debugs[set]) {
|
|
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
|
|
var pid = process.pid;
|
|
debugs[set] = function() {
|
|
var msg = exports.format.apply(exports, arguments);
|
|
console.error('%s %d: %s', set, pid, msg);
|
|
};
|
|
} else {
|
|
debugs[set] = function() {};
|
|
}
|
|
}
|
|
return debugs[set];
|
|
};
|
|
|
|
|
|
/**
|
|
* Echos the value of a value. Trys to print the value out
|
|
* in the best way possible given the different types.
|
|
*
|
|
* @param {Object} obj The object to print out.
|
|
* @param {Object} opts Optional options object that alters the output.
|
|
*/
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|
function inspect(obj, opts) {
|
|
// default options
|
|
var ctx = {
|
|
seen: [],
|
|
stylize: stylizeNoColor
|
|
};
|
|
// legacy...
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
if (isBoolean(opts)) {
|
|
// legacy...
|
|
ctx.showHidden = opts;
|
|
} else if (opts) {
|
|
// got an "options" object
|
|
exports._extend(ctx, opts);
|
|
}
|
|
// set default options
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
return formatValue(ctx, obj, ctx.depth);
|
|
}
|
|
exports.inspect = inspect;
|
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
inspect.colors = {
|
|
'bold' : [1, 22],
|
|
'italic' : [3, 23],
|
|
'underline' : [4, 24],
|
|
'inverse' : [7, 27],
|
|
'white' : [37, 39],
|
|
'grey' : [90, 39],
|
|
'black' : [30, 39],
|
|
'blue' : [34, 39],
|
|
'cyan' : [36, 39],
|
|
'green' : [32, 39],
|
|
'magenta' : [35, 39],
|
|
'red' : [31, 39],
|
|
'yellow' : [33, 39]
|
|
};
|
|
|
|
// Don't use 'blue' not visible on cmd.exe
|
|
inspect.styles = {
|
|
'special': 'cyan',
|
|
'number': 'yellow',
|
|
'boolean': 'yellow',
|
|
'undefined': 'grey',
|
|
'null': 'bold',
|
|
'string': 'green',
|
|
'date': 'magenta',
|
|
// "name": intentionally not styling
|
|
'regexp': 'red'
|
|
};
|
|
|
|
|
|
function stylizeWithColor(str, styleType) {
|
|
var style = inspect.styles[styleType];
|
|
|
|
if (style) {
|
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
|
|
|
|
function stylizeNoColor(str, styleType) {
|
|
return str;
|
|
}
|
|
|
|
|
|
function arrayToHash(array) {
|
|
var hash = {};
|
|
|
|
array.forEach(function(val, idx) {
|
|
hash[val] = true;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
|
// Provide a hook for user-specified inspect functions.
|
|
// Check that value is an object with an inspect function on it
|
|
if (ctx.customInspect &&
|
|
value &&
|
|
isFunction(value.inspect) &&
|
|
// Filter out the util module, it's inspect function is special
|
|
value.inspect !== exports.inspect &&
|
|
// Also filter out any prototype objects using the circular check.
|
|
!(value.constructor && value.constructor.prototype === value)) {
|
|
var ret = value.inspect(recurseTimes, ctx);
|
|
if (!isString(ret)) {
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Primitive types cannot have properties
|
|
var primitive = formatPrimitive(ctx, value);
|
|
if (primitive) {
|
|
return primitive;
|
|
}
|
|
|
|
// Look up the keys of the object.
|
|
var keys = Object.keys(value);
|
|
var visibleKeys = arrayToHash(keys);
|
|
|
|
if (ctx.showHidden) {
|
|
keys = Object.getOwnPropertyNames(value);
|
|
}
|
|
|
|
// IE doesn't make error fields non-enumerable
|
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|
if (isError(value)
|
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
|
return formatError(value);
|
|
}
|
|
|
|
// Some type of object without properties can be shortcutted.
|
|
if (keys.length === 0) {
|
|
if (isFunction(value)) {
|
|
var name = value.name ? ': ' + value.name : '';
|
|
return ctx.stylize('[Function' + name + ']', 'special');
|
|
}
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
}
|
|
if (isDate(value)) {
|
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
}
|
|
if (isError(value)) {
|
|
return formatError(value);
|
|
}
|
|
}
|
|
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
|
|
// Make Array say that they are Array
|
|
if (isArray(value)) {
|
|
array = true;
|
|
braces = ['[', ']'];
|
|
}
|
|
|
|
// Make functions say that they are functions
|
|
if (isFunction(value)) {
|
|
var n = value.name ? ': ' + value.name : '';
|
|
base = ' [Function' + n + ']';
|
|
}
|
|
|
|
// Make RegExps say that they are RegExps
|
|
if (isRegExp(value)) {
|
|
base = ' ' + RegExp.prototype.toString.call(value);
|
|
}
|
|
|
|
// Make dates with properties first say the date
|
|
if (isDate(value)) {
|
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
}
|
|
|
|
// Make error with message first say the error
|
|
if (isError(value)) {
|
|
base = ' ' + formatError(value);
|
|
}
|
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
return braces[0] + base + braces[1];
|
|
}
|
|
|
|
if (recurseTimes < 0) {
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
} else {
|
|
return ctx.stylize('[Object]', 'special');
|
|
}
|
|
}
|
|
|
|
ctx.seen.push(value);
|
|
|
|
var output;
|
|
if (array) {
|
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
} else {
|
|
output = keys.map(function(key) {
|
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
});
|
|
}
|
|
|
|
ctx.seen.pop();
|
|
|
|
return reduceToSingleString(output, base, braces);
|
|
}
|
|
|
|
|
|
function formatPrimitive(ctx, value) {
|
|
if (isUndefined(value))
|
|
return ctx.stylize('undefined', 'undefined');
|
|
if (isString(value)) {
|
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"') + '\'';
|
|
return ctx.stylize(simple, 'string');
|
|
}
|
|
if (isNumber(value))
|
|
return ctx.stylize('' + value, 'number');
|
|
if (isBoolean(value))
|
|
return ctx.stylize('' + value, 'boolean');
|
|
// For some reason typeof null is "object", so special case here.
|
|
if (isNull(value))
|
|
return ctx.stylize('null', 'null');
|
|
}
|
|
|
|
|
|
function formatError(value) {
|
|
return '[' + Error.prototype.toString.call(value) + ']';
|
|
}
|
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
var output = [];
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|
if (hasOwnProperty(value, String(i))) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
String(i), true));
|
|
} else {
|
|
output.push('');
|
|
}
|
|
}
|
|
keys.forEach(function(key) {
|
|
if (!key.match(/^\d+$/)) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
key, true));
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
var name, str, desc;
|
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
if (desc.get) {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
} else {
|
|
str = ctx.stylize('[Getter]', 'special');
|
|
}
|
|
} else {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Setter]', 'special');
|
|
}
|
|
}
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|
name = '[' + key + ']';
|
|
}
|
|
if (!str) {
|
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
|
if (isNull(recurseTimes)) {
|
|
str = formatValue(ctx, desc.value, null);
|
|
} else {
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
}
|
|
if (str.indexOf('\n') > -1) {
|
|
if (array) {
|
|
str = str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n').substr(2);
|
|
} else {
|
|
str = '\n' + str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n');
|
|
}
|
|
}
|
|
} else {
|
|
str = ctx.stylize('[Circular]', 'special');
|
|
}
|
|
}
|
|
if (isUndefined(name)) {
|
|
if (array && key.match(/^\d+$/)) {
|
|
return str;
|
|
}
|
|
name = JSON.stringify('' + key);
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
name = name.substr(1, name.length - 2);
|
|
name = ctx.stylize(name, 'name');
|
|
} else {
|
|
name = name.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"')
|
|
.replace(/(^"|"$)/g, "'");
|
|
name = ctx.stylize(name, 'string');
|
|
}
|
|
}
|
|
|
|
return name + ': ' + str;
|
|
}
|
|
|
|
|
|
function reduceToSingleString(output, base, braces) {
|
|
var numLinesEst = 0;
|
|
var length = output.reduce(function(prev, cur) {
|
|
numLinesEst++;
|
|
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
}, 0);
|
|
|
|
if (length > 60) {
|
|
return braces[0] +
|
|
(base === '' ? '' : base + '\n ') +
|
|
' ' +
|
|
output.join(',\n ') +
|
|
' ' +
|
|
braces[1];
|
|
}
|
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
}
|
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|
function isArray(ar) {
|
|
return Array.isArray(ar);
|
|
}
|
|
exports.isArray = isArray;
|
|
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
exports.isNumber = isNumber;
|
|
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
exports.isString = isString;
|
|
|
|
function isSymbol(arg) {
|
|
return typeof arg === 'symbol';
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
|
|
function isRegExp(re) {
|
|
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
exports.isObject = isObject;
|
|
|
|
function isDate(d) {
|
|
return isObject(d) && objectToString(d) === '[object Date]';
|
|
}
|
|
exports.isDate = isDate;
|
|
|
|
function isError(e) {
|
|
return isObject(e) &&
|
|
(objectToString(e) === '[object Error]' || e instanceof Error);
|
|
}
|
|
exports.isError = isError;
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
exports.isFunction = isFunction;
|
|
|
|
function isPrimitive(arg) {
|
|
return arg === null ||
|
|
typeof arg === 'boolean' ||
|
|
typeof arg === 'number' ||
|
|
typeof arg === 'string' ||
|
|
typeof arg === 'symbol' || // ES6 symbol
|
|
typeof arg === 'undefined';
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
|
|
exports.isBuffer = require('./support/isBuffer');
|
|
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
|
|
|
|
function pad(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'];
|
|
|
|
// 26 Feb 16:19:34
|
|
function timestamp() {
|
|
var d = new Date();
|
|
var time = [pad(d.getHours()),
|
|
pad(d.getMinutes()),
|
|
pad(d.getSeconds())].join(':');
|
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
}
|
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
exports.log = function() {
|
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|
*
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|
* prototype.
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
*/
|
|
exports.inherits = require('inherits');
|
|
|
|
exports._extend = function(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || !isObject(add)) return origin;
|
|
|
|
var keys = Object.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
};
|
|
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./support/isBuffer":36,"_process":33,"inherits":35}],38:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var leveljs = require('level-js');
|
|
|
|
// something about trying to store these language files in indexedDB
|
|
// causes iOS Safari to crash
|
|
|
|
var iOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
|
|
var noIDB = typeof indexedDB === 'undefined' || iOS;
|
|
|
|
var db = noIDB ? { open: function open(_, cb) {
|
|
return cb(true);
|
|
} } : leveljs('./tessdata2');
|
|
|
|
var langdata = require('../common/langdata.json');
|
|
|
|
module.exports = function getLanguageData(req, res, cb) {
|
|
var lang = req.options.lang;
|
|
|
|
function saveDataFile(data) {
|
|
try {
|
|
db.put(lang, data, function (err) {
|
|
return console.log('cached', lang, err);
|
|
});
|
|
} finally {
|
|
cb(data);
|
|
}
|
|
}
|
|
|
|
db.open({ compression: false }, function (err) {
|
|
if (err) return fetchLanguageData(req, res, cb);
|
|
db.get(lang, function (err, data) {
|
|
if (err) return fetchLanguageData(req, res, saveDataFile);
|
|
res.progress({ status: 'found in cache ' + lang + '.traineddata' });
|
|
cb(data);
|
|
});
|
|
});
|
|
};
|
|
|
|
var ungzip = require('pako/lib/inflate.js').ungzip;
|
|
|
|
function fetchLanguageData(req, res, cb) {
|
|
var lang = req.options.lang;
|
|
var langfile = lang + '.traineddata.gz';
|
|
var url = req.workerOptions.langPath + langfile;
|
|
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url, true);
|
|
xhr.responseType = 'arraybuffer';
|
|
xhr.onerror = function (e) {
|
|
xhr.onprogress = xhr.onload = null;
|
|
cb(xhr, null);
|
|
};
|
|
xhr.onprogress = function (e) {
|
|
return res.progress({
|
|
status: 'downloading ' + langfile,
|
|
loaded: e.loaded,
|
|
progress: Math.min(1, e.loaded / langdata[lang])
|
|
});
|
|
};
|
|
|
|
xhr.onload = function (e) {
|
|
if (!(xhr.status == 200 || xhr.status == 0 && xhr.response)) return res.reject('Error downloading language ' + url);
|
|
res.progress({ status: 'unzipping ' + langfile, progress: 0 });
|
|
|
|
// in case the gzips are already ungzipped or extra gzipped
|
|
var response = new Uint8Array(xhr.response);
|
|
try {
|
|
var n = 2;
|
|
while (response[0] == 0x1f && response[1] == 0x8b) {
|
|
response = ungzip(response);
|
|
res.progress({ status: 'unzipping ' + langfile, progress: 1 - 1 / n++ });
|
|
}
|
|
} catch (err) {
|
|
return res.reject('Error unzipping language file ' + langfile + '\n' + err.message);
|
|
}
|
|
res.progress({ status: 'unzipping ' + langfile, progress: 1 });
|
|
|
|
cb(response);
|
|
};
|
|
xhr.send();
|
|
}
|
|
|
|
},{"../common/langdata.json":42,"level-js":12,"pako/lib/inflate.js":21}],39:[function(require,module,exports){
|
|
(function (process,global){
|
|
'use strict';
|
|
|
|
var workerUtils = require('../common/worker.js');
|
|
|
|
if (process.env.NODE_ENV === "development") {
|
|
console.debug('Using Development Worker');
|
|
}
|
|
|
|
global.addEventListener('message', function (e) {
|
|
var packet = e.data;
|
|
workerUtils.dispatchHandlers(packet, function (obj) {
|
|
return postMessage(obj);
|
|
});
|
|
});
|
|
|
|
exports.getCore = function (req, res) {
|
|
if (!global.TesseractCore) {
|
|
res.progress({ status: 'loading tesseract core', progress: 0 });
|
|
importScripts(req.workerOptions.corePath);
|
|
res.progress({ status: 'loading tesseract core', progress: 1 });
|
|
}
|
|
return TesseractCore;
|
|
};
|
|
|
|
exports.getLanguageData = require('./lang.js');
|
|
|
|
workerUtils.setAdapter(module.exports);
|
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"../common/worker.js":43,"./lang.js":38,"_process":33}],40:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// This converts an image to grayscale
|
|
|
|
module.exports = function desaturate(image) {
|
|
var width, height;
|
|
if (image.data) {
|
|
var src = image.data;
|
|
width = image.width, height = image.height;
|
|
var dst = new Uint8Array(width * height);
|
|
var srcLength = src.length | 0,
|
|
srcLength_16 = srcLength - 16 | 0;
|
|
|
|
for (var i = 0, j = 0; i <= srcLength_16; i += 16, j += 4) {
|
|
// convert to grayscale 4 pixels at a time; eveything with alpha gets put in front of 50% gray
|
|
dst[j] = (src[i] * 77 + src[i + 1] * 151 + src[i + 2] * 28) * src[i + 3] + (255 - src[i + 3] << 15) + 32768 >> 16;
|
|
dst[j + 1] = (src[i + 4] * 77 + src[i + 5] * 151 + src[i + 6] * 28) * src[i + 7] + (255 - src[i + 7] << 15) + 32768 >> 16;
|
|
dst[j + 2] = (src[i + 8] * 77 + src[i + 9] * 151 + src[i + 10] * 28) * src[i + 11] + (255 - src[i + 11] << 15) + 32768 >> 16;
|
|
dst[j + 3] = (src[i + 12] * 77 + src[i + 13] * 151 + src[i + 14] * 28) * src[i + 15] + (255 - src[i + 15] << 15) + 32768 >> 16;
|
|
}
|
|
for (; i < srcLength; i += 4, ++j) {
|
|
//finish up
|
|
dst[j] = (src[i] * 77 + src[i + 1] * 151 + src[i + 2] * 28) * src[i + 3] + (255 - src[i + 3] << 15) + 32768 >> 16;
|
|
}image = dst;
|
|
} else {
|
|
throw 'Invalid ImageData';
|
|
}
|
|
return image;
|
|
};
|
|
|
|
},{}],41:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = function DumpLiterallyEverything(Module, base) {
|
|
var ri = base.GetIterator();
|
|
var blocks = [];
|
|
var block, para, textline, word, symbol;
|
|
|
|
function enumToString(value, prefix) {
|
|
return Object.keys(Module).filter(function (e) {
|
|
return e.substr(0, prefix.length + 1) == prefix + '_';
|
|
}).filter(function (e) {
|
|
return Module[e] === value;
|
|
}).map(function (e) {
|
|
return e.slice(prefix.length + 1);
|
|
})[0];
|
|
}
|
|
|
|
ri.Begin();
|
|
do {
|
|
if (ri.IsAtBeginningOf(Module.RIL_BLOCK)) {
|
|
var poly = ri.BlockPolygon();
|
|
var polygon = null;
|
|
// BlockPolygon() returns null when automatic page segmentation is off
|
|
if (Module.getPointer(poly) > 0) {
|
|
var n = poly.get_n(),
|
|
px = poly.get_x(),
|
|
py = poly.get_y(),
|
|
polygon = [];
|
|
for (var i = 0; i < n; i++) {
|
|
polygon.push([px.getValue(i), py.getValue(i)]);
|
|
}
|
|
Module._ptaDestroy(Module.getPointer(poly));
|
|
}
|
|
|
|
block = {
|
|
paragraphs: [],
|
|
|
|
text: ri.GetUTF8Text(Module.RIL_BLOCK),
|
|
confidence: ri.Confidence(Module.RIL_BLOCK),
|
|
baseline: ri.getBaseline(Module.RIL_BLOCK),
|
|
bbox: ri.getBoundingBox(Module.RIL_BLOCK),
|
|
|
|
blocktype: enumToString(ri.BlockType(), 'PT'),
|
|
polygon: polygon
|
|
};
|
|
blocks.push(block);
|
|
}
|
|
if (ri.IsAtBeginningOf(Module.RIL_PARA)) {
|
|
para = {
|
|
lines: [],
|
|
|
|
text: ri.GetUTF8Text(Module.RIL_PARA),
|
|
confidence: ri.Confidence(Module.RIL_PARA),
|
|
baseline: ri.getBaseline(Module.RIL_PARA),
|
|
bbox: ri.getBoundingBox(Module.RIL_PARA),
|
|
|
|
is_ltr: !!ri.ParagraphIsLtr()
|
|
};
|
|
block.paragraphs.push(para);
|
|
}
|
|
if (ri.IsAtBeginningOf(Module.RIL_TEXTLINE)) {
|
|
textline = {
|
|
words: [],
|
|
|
|
text: ri.GetUTF8Text(Module.RIL_TEXTLINE),
|
|
confidence: ri.Confidence(Module.RIL_TEXTLINE),
|
|
baseline: ri.getBaseline(Module.RIL_TEXTLINE),
|
|
bbox: ri.getBoundingBox(Module.RIL_TEXTLINE)
|
|
};
|
|
para.lines.push(textline);
|
|
}
|
|
if (ri.IsAtBeginningOf(Module.RIL_WORD)) {
|
|
var fontInfo = ri.getWordFontAttributes(),
|
|
wordDir = ri.WordDirection();
|
|
word = {
|
|
symbols: [],
|
|
choices: [],
|
|
|
|
text: ri.GetUTF8Text(Module.RIL_WORD),
|
|
confidence: ri.Confidence(Module.RIL_WORD),
|
|
baseline: ri.getBaseline(Module.RIL_WORD),
|
|
bbox: ri.getBoundingBox(Module.RIL_WORD),
|
|
|
|
is_numeric: !!ri.WordIsNumeric(),
|
|
in_dictionary: !!ri.WordIsFromDictionary(),
|
|
direction: enumToString(wordDir, 'DIR'),
|
|
language: ri.WordRecognitionLanguage(),
|
|
|
|
is_bold: fontInfo.is_bold,
|
|
is_italic: fontInfo.is_italic,
|
|
is_underlined: fontInfo.is_underlined,
|
|
is_monospace: fontInfo.is_monospace,
|
|
is_serif: fontInfo.is_serif,
|
|
is_smallcaps: fontInfo.is_smallcaps,
|
|
font_size: fontInfo.pointsize,
|
|
font_id: fontInfo.font_id,
|
|
font_name: fontInfo.font_name
|
|
};
|
|
var wc = new Module.WordChoiceIterator(ri);
|
|
do {
|
|
word.choices.push({
|
|
text: wc.GetUTF8Text(),
|
|
confidence: wc.Confidence()
|
|
});
|
|
} while (wc.Next());
|
|
Module.destroy(wc);
|
|
textline.words.push(word);
|
|
}
|
|
|
|
var image = null;
|
|
// var pix = ri.GetBinaryImage(Module.RIL_SYMBOL)
|
|
// var image = pix2array(pix);
|
|
// // for some reason it seems that things stop working if you destroy pics
|
|
// Module._pixDestroy(Module.getPointer(pix));
|
|
if (ri.IsAtBeginningOf(Module.RIL_SYMBOL)) {
|
|
symbol = {
|
|
choices: [],
|
|
image: image,
|
|
|
|
text: ri.GetUTF8Text(Module.RIL_SYMBOL),
|
|
confidence: ri.Confidence(Module.RIL_SYMBOL),
|
|
baseline: ri.getBaseline(Module.RIL_SYMBOL),
|
|
bbox: ri.getBoundingBox(Module.RIL_SYMBOL),
|
|
|
|
is_superscript: !!ri.SymbolIsSuperscript(),
|
|
is_subscript: !!ri.SymbolIsSubscript(),
|
|
is_dropcap: !!ri.SymbolIsDropcap()
|
|
};
|
|
word.symbols.push(symbol);
|
|
var ci = new Module.ChoiceIterator(ri);
|
|
do {
|
|
symbol.choices.push({
|
|
text: ci.GetUTF8Text(),
|
|
confidence: ci.Confidence()
|
|
});
|
|
} while (ci.Next());
|
|
Module.destroy(ci);
|
|
}
|
|
} while (ri.Next(Module.RIL_SYMBOL));
|
|
Module.destroy(ri);
|
|
|
|
return {
|
|
text: base.GetUTF8Text(),
|
|
html: deindent(base.GetHOCRText()),
|
|
|
|
confidence: base.MeanTextConf(),
|
|
|
|
blocks: blocks,
|
|
|
|
psm: enumToString(base.GetPageSegMode(), 'PSM'),
|
|
oem: enumToString(base.oem(), 'OEM'),
|
|
version: base.Version()
|
|
};
|
|
};
|
|
|
|
// the generated HOCR is excessively indented, so
|
|
// we get rid of that indentation
|
|
|
|
function deindent(html) {
|
|
var lines = html.split('\n');
|
|
if (lines[0].substring(0, 2) === " ") {
|
|
for (var i = 0; i < lines.length; i++) {
|
|
if (lines[i].substring(0, 2) === " ") {
|
|
lines[i] = lines[i].slice(2);
|
|
}
|
|
};
|
|
}
|
|
return lines.join('\n');
|
|
}
|
|
|
|
},{}],42:[function(require,module,exports){
|
|
module.exports={"afr": 1079573, "ara": 1701536, "aze": 1420865, "bel": 1276820, "ben": 6772012, "bul": 1605615, "cat": 1652368, "ces": 1035441, "chi_sim": 17710414, "chi_tra": 24717749, "chr": 320649, "dan-frak": 677656, "dan": 1972936, "deu-frak": 822644, "deu": 991656, "ell": 859719, "eng": 9453554, "enm": 619254, "epo": 1241212, "equ": 821130, "est": 1905040, "eus": 1641190, "fin": 979418, "fra": 1376221, "frk": 5912963, "frm": 5147082, "glg": 1674938, "grc": 3012615, "heb": 1051501, "hin": 6590065, "hrv": 1926995, "hun": 3074473, "ind": 1874776, "isl": 1634041, "ita": 948593, "ita_old": 3436571, "jpn": 13507168, "kan": 4390317, "kor": 5353098, "lav": 1843944, "lit": 1779240, "mal": 5966263, "meme": 88453, "mkd": 1163087, "mlt": 1463001, "msa": 1665427, "nld": 1134708, "nor": 2191610, "osd": 4274649, "pol": 7024662, "por": 909359, "ron": 915680, "rus": 5969957, "slk-frak": 289885, "slk": 2217342, "slv": 1611338, "spa": 883170, "spa_old": 5647453, "sqi": 1667041, "srp": 1770244, "swa": 757916, "swe": 2451917, "tam": 3498763, "tel": 5795246, "tgl": 1496256, "tha": 3811136, "tur": 3563264, "ukr": 937566, "vie": 2195922}
|
|
},{}],43:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var latestJob;
|
|
var Module;
|
|
var base;
|
|
var adapter = {};
|
|
|
|
function dispatchHandlers(packet, send) {
|
|
function respond(status, data) {
|
|
send({
|
|
jobId: packet.jobId,
|
|
status: status,
|
|
action: packet.action,
|
|
data: data
|
|
});
|
|
}
|
|
respond.resolve = respond.bind(this, 'resolve');
|
|
respond.reject = respond.bind(this, 'reject');
|
|
respond.progress = respond.bind(this, 'progress');
|
|
|
|
latestJob = respond;
|
|
|
|
try {
|
|
if (packet.action === 'recognize') {
|
|
handleRecognize(packet.payload, respond);
|
|
} else if (packet.action === 'detect') {
|
|
handleDetect(packet.payload, respond);
|
|
}
|
|
} catch (err) {
|
|
respond.reject(err);
|
|
}
|
|
}
|
|
exports.dispatchHandlers = dispatchHandlers;
|
|
|
|
exports.setAdapter = function setAdapter(impl) {
|
|
adapter = impl;
|
|
};
|
|
|
|
function handleInit(req, res) {
|
|
var MIN_MEMORY = 100663296;
|
|
|
|
if (['chi_sim', 'chi_tra', 'jpn'].indexOf(req.options.lang) != -1) {
|
|
MIN_MEMORY = 167772160;
|
|
}
|
|
|
|
if (!Module || Module.TOTAL_MEMORY < MIN_MEMORY) {
|
|
var Core = adapter.getCore(req, res);
|
|
|
|
res.progress({ status: 'initializing tesseract', progress: 0 });
|
|
|
|
Module = Core({
|
|
TOTAL_MEMORY: MIN_MEMORY,
|
|
TesseractProgress: function TesseractProgress(percent) {
|
|
latestJob.progress({ status: 'recognizing text', progress: Math.max(0, (percent - 30) / 70) });
|
|
},
|
|
onRuntimeInitialized: function onRuntimeInitialized() {}
|
|
});
|
|
|
|
Module.FS_createPath("/", "tessdata", true, true);
|
|
base = new Module.TessBaseAPI();
|
|
res.progress({ status: 'initializing tesseract', progress: 1 });
|
|
}
|
|
}
|
|
|
|
var dump = require('./dump.js');
|
|
var desaturate = require('./desaturate.js');
|
|
|
|
function setImage(Module, base, image) {
|
|
var imgbin = desaturate(image),
|
|
width = image.width,
|
|
height = image.height;
|
|
|
|
var ptr = Module.allocate(imgbin, 'i8', Module.ALLOC_NORMAL);
|
|
base.SetImage(Module.wrapPointer(ptr), width, height, 1, width);
|
|
base.SetRectangle(0, 0, width, height);
|
|
return ptr;
|
|
}
|
|
|
|
function loadLanguage(req, res, cb) {
|
|
var lang = req.options.lang;
|
|
|
|
if (!Module._loadedLanguages) Module._loadedLanguages = {};
|
|
if (lang in Module._loadedLanguages) return cb();
|
|
|
|
adapter.getLanguageData(req, res, function (data) {
|
|
res.progress({ status: 'loading ' + lang + '.traineddata', progress: 0 });
|
|
Module.FS_createDataFile('tessdata', lang + ".traineddata", data, true, false);
|
|
Module._loadedLanguages[lang] = true;
|
|
res.progress({ status: 'loading ' + lang + '.traineddata', progress: 1 });
|
|
cb();
|
|
});
|
|
}
|
|
|
|
function handleRecognize(req, res) {
|
|
handleInit(req, res);
|
|
|
|
loadLanguage(req, res, function () {
|
|
var lang = req.options.lang;
|
|
|
|
res.progress({ status: 'initializing api', progress: 0 });
|
|
base.Init(null, lang);
|
|
res.progress({ status: 'initializing api', progress: 0.3 });
|
|
|
|
var options = req.options;
|
|
for (var option in options) {
|
|
if (options.hasOwnProperty(option)) {
|
|
base.SetVariable(option, options[option]);
|
|
}
|
|
}
|
|
|
|
res.progress({ status: 'initializing api', progress: 0.6 });
|
|
var ptr = setImage(Module, base, req.image);
|
|
res.progress({ status: 'initializing api', progress: 1 });
|
|
|
|
base.Recognize(null);
|
|
|
|
var result = dump(Module, base);
|
|
|
|
base.End();
|
|
Module._free(ptr);
|
|
|
|
res.resolve(result);
|
|
});
|
|
}
|
|
|
|
function handleDetect(req, res) {
|
|
handleInit(req, res);
|
|
req.options.lang = 'osd';
|
|
loadLanguage(req, res, function () {
|
|
|
|
base.Init(null, 'osd');
|
|
base.SetPageSegMode(Module.PSM_OSD_ONLY);
|
|
|
|
var ptr = setImage(Module, base, req.image);
|
|
|
|
var results = new Module.OSResults();
|
|
var success = base.DetectOS(results);
|
|
if (!success) {
|
|
base.End();
|
|
Module._free(ptr);
|
|
res.reject("failed to detect os");
|
|
} else {
|
|
var charset = results.get_unicharset();
|
|
|
|
var best = results.get_best_result();
|
|
var oid = best.get_orientation_id(),
|
|
sid = best.get_script_id();
|
|
|
|
var result = {
|
|
tesseract_script_id: sid,
|
|
script: charset.get_script_from_script_id(sid),
|
|
script_confidence: best.get_sconfidence(),
|
|
orientation_degrees: [0, 270, 180, 90][oid],
|
|
orientation_confidence: best.get_oconfidence()
|
|
};
|
|
|
|
base.End();
|
|
Module._free(ptr);
|
|
|
|
res.resolve(result);
|
|
}
|
|
});
|
|
}
|
|
|
|
},{"./desaturate.js":40,"./dump.js":41}]},{},[39]);
|
|
|