770 lines
22 KiB
JavaScript
770 lines
22 KiB
JavaScript
/*
|
||
* node-cache 4.2.1 ( 2019-07-24 )
|
||
* https://github.com/mpneuried/nodecache
|
||
*
|
||
* Released under the MIT license
|
||
* https://github.com/mpneuried/nodecache/blob/master/LICENSE
|
||
*
|
||
* Maintained by ( )
|
||
*/
|
||
(function() {
|
||
// lodash requires
|
||
var EventEmitter, NodeCache, _assignIn, _isArray, _isFunction, _isNumber, _isObject, _isString, _size, _template, clone,
|
||
boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } },
|
||
indexOf = [].indexOf;
|
||
|
||
_assignIn = require("lodash/assignIn");
|
||
|
||
_isArray = require("lodash/isArray");
|
||
|
||
_isString = require("lodash/isString");
|
||
|
||
_isFunction = require("lodash/isFunction");
|
||
|
||
_isNumber = require("lodash/isNumber");
|
||
|
||
_isObject = require("lodash/isObject");
|
||
|
||
_size = require("lodash/size");
|
||
|
||
_template = require("lodash/template");
|
||
|
||
clone = require("clone");
|
||
|
||
EventEmitter = require('events').EventEmitter;
|
||
|
||
// generate superclass
|
||
module.exports = NodeCache = (function() {
|
||
class NodeCache extends EventEmitter {
|
||
constructor(options = {}) {
|
||
super();
|
||
// ## get
|
||
|
||
// get a cached key and change the stats
|
||
|
||
// **Parameters:**
|
||
|
||
// * `key` ( String | Number ): cache key
|
||
// * `[cb]` ( Function ): Callback function
|
||
// * `[errorOnMissing=false]` ( Boolean ) return a error to the `cb` or throw it if no `cb` is used. Otherwise the get will return `undefined` on a miss.
|
||
|
||
// **Example:**
|
||
|
||
// myCache.get "myKey", ( err, val )->
|
||
// console.log( err, val )
|
||
// return
|
||
|
||
this.get = this.get.bind(this);
|
||
// ## mget
|
||
|
||
// get multiple cached keys at once and change the stats
|
||
|
||
// **Parameters:**
|
||
|
||
// * `keys` ( String|Number[] ): an array of keys
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Example:**
|
||
|
||
// myCache.mget [ "foo", "bar" ], ( err, val )->
|
||
// console.log( err, val )
|
||
// return
|
||
|
||
this.mget = this.mget.bind(this);
|
||
// ## set
|
||
|
||
// set a cached key and change the stats
|
||
|
||
// **Parameters:**
|
||
|
||
// * `key` ( String | Number ): cache key
|
||
// * `value` ( Any ): A element to cache. If the option `option.forceString` is `true` the module trys to translate it to a serialized JSON
|
||
// * `[ ttl ]` ( Number | String ): ( optional ) The time to live in seconds.
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Example:**
|
||
|
||
// myCache.set "myKey", "my_String Value", ( err, success )->
|
||
// console.log( err, success )
|
||
|
||
// myCache.set "myKey", "my_String Value", "10", ( err, success )->
|
||
// console.log( err, success )
|
||
|
||
this.set = this.set.bind(this);
|
||
// ## del
|
||
|
||
// remove keys
|
||
|
||
// **Parameters:**
|
||
|
||
// * `keys` ( String | Number | String|Number[] ): cache key to delete or a array of cache keys
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Return**
|
||
|
||
// ( Number ): Number of deleted keys
|
||
|
||
// **Example:**
|
||
|
||
// myCache.del( "myKey" )
|
||
|
||
// myCache.del( "myKey", ( err, delCount )->
|
||
// console.log( err, delCount )
|
||
// return
|
||
this.del = this.del.bind(this);
|
||
// ## ttl
|
||
|
||
// reset or redefine the ttl of a key. `ttl` = 0 means infinite lifetime.
|
||
// If `ttl` is not passed the default ttl is used.
|
||
// If `ttl` < 0 the key will be deleted.
|
||
|
||
// **Parameters:**
|
||
|
||
// * `key` ( String | Number ): cache key to reset the ttl value
|
||
// * `ttl` ( Number ): ( optional -> options.stdTTL || 0 ) The time to live in seconds
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Return**
|
||
|
||
// ( Boolen ): key found and ttl set
|
||
|
||
// **Example:**
|
||
|
||
// myCache.ttl( "myKey" ) // will set ttl to default ttl
|
||
|
||
// myCache.ttl( "myKey", 1000, ( err, keyFound )->
|
||
// console.log( err, success )
|
||
|
||
this.ttl = this.ttl.bind(this);
|
||
// ## getTtl
|
||
|
||
// receive the ttl of a key.
|
||
|
||
// **Parameters:**
|
||
|
||
// * `key` ( String | Number ): cache key to check the ttl value
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Return**
|
||
|
||
// ( Number|undefined ): The timestamp in ms when the key will expire, 0 if it will never expire or undefined if it not exists
|
||
|
||
// **Example:**
|
||
|
||
// ts = myCache.getTtl( "myKey" )
|
||
|
||
// myCache.getTtl( "myKey",( err, ttl )->
|
||
// console.log( err, ttl )
|
||
// return
|
||
|
||
this.getTtl = this.getTtl.bind(this);
|
||
// ## keys
|
||
|
||
// list all keys within this cache
|
||
|
||
// **Parameters:**
|
||
|
||
// * `[cb]` ( Function ): Callback function
|
||
|
||
// **Return**
|
||
|
||
// ( Array ): An array of all keys
|
||
|
||
// **Example:**
|
||
|
||
// _keys = myCache.keys()
|
||
|
||
// # [ "foo", "bar", "fizz", "buzz", "anotherKeys" ]
|
||
|
||
this.keys = this.keys.bind(this);
|
||
// ## getStats
|
||
|
||
// get the stats
|
||
|
||
// **Parameters:**
|
||
|
||
// -
|
||
|
||
// **Return**
|
||
|
||
// ( Object ): Stats data
|
||
|
||
// **Example:**
|
||
|
||
// myCache.getStats()
|
||
// # {
|
||
// # hits: 0,
|
||
// # misses: 0,
|
||
// # keys: 0,
|
||
// # ksize: 0,
|
||
// # vsize: 0
|
||
// # }
|
||
|
||
this.getStats = this.getStats.bind(this);
|
||
// ## flushAll
|
||
|
||
// flush the whole data and reset the stats
|
||
|
||
// **Example:**
|
||
|
||
// myCache.flushAll()
|
||
|
||
// myCache.getStats()
|
||
// # {
|
||
// # hits: 0,
|
||
// # misses: 0,
|
||
// # keys: 0,
|
||
// # ksize: 0,
|
||
// # vsize: 0
|
||
// # }
|
||
|
||
this.flushAll = this.flushAll.bind(this);
|
||
// ## close
|
||
|
||
// This will clear the interval timeout which is set on checkperiod option.
|
||
|
||
// **Example:**
|
||
|
||
// myCache.close()
|
||
|
||
this.close = this.close.bind(this);
|
||
// ## _checkData
|
||
|
||
// internal housekeeping method.
|
||
// Check all the cached data and delete the invalid values
|
||
this._checkData = this._checkData.bind(this);
|
||
// ## _check
|
||
|
||
// internal method the check the value. If it's not valid any more delete it
|
||
this._check = this._check.bind(this);
|
||
// ## _isInvalidKey
|
||
|
||
// internal method to check if the type of a key is either `number` or `string`
|
||
this._isInvalidKey = this._isInvalidKey.bind(this);
|
||
// ## _wrap
|
||
|
||
// internal method to wrap a value in an object with some metadata
|
||
this._wrap = this._wrap.bind(this);
|
||
// ## _getValLength
|
||
|
||
// internal method to calculate the value length
|
||
this._getValLength = this._getValLength.bind(this);
|
||
// ## _error
|
||
|
||
// internal method to handle an error message
|
||
this._error = this._error.bind(this);
|
||
// ## _initErrors
|
||
|
||
// internal method to generate error message templates
|
||
this._initErrors = this._initErrors.bind(this);
|
||
this.options = options;
|
||
this._initErrors();
|
||
// container for cached data
|
||
this.data = {};
|
||
// module options
|
||
this.options = _assignIn({
|
||
// convert all elements to string
|
||
forceString: false,
|
||
// used standard size for calculating value size
|
||
objectValueSize: 80,
|
||
promiseValueSize: 80,
|
||
arrayValueSize: 40,
|
||
// standard time to live in seconds. 0 = infinity;
|
||
stdTTL: 0,
|
||
// time in seconds to check all data and delete expired keys
|
||
checkperiod: 600,
|
||
// en/disable cloning of variables. If `true` you'll get a copy of the cached variable. If `false` you'll save and get just the reference
|
||
useClones: true,
|
||
// en/disable throwing errors when trying to `.get` missing or expired values.
|
||
errorOnMissing: false,
|
||
// whether values should be deleted automatically at expiration
|
||
deleteOnExpire: true
|
||
}, this.options);
|
||
// statistics container
|
||
this.stats = {
|
||
hits: 0,
|
||
misses: 0,
|
||
keys: 0,
|
||
ksize: 0,
|
||
vsize: 0
|
||
};
|
||
// pre allocate valid keytypes array
|
||
this.validKeyTypes = ["string", "number"];
|
||
// initalize checking period
|
||
this._checkData();
|
||
return;
|
||
}
|
||
|
||
get(key, cb, errorOnMissing) {
|
||
var _err, _ret, err;
|
||
boundMethodCheck(this, NodeCache);
|
||
// handle passing in errorOnMissing without cb
|
||
if (typeof cb === "boolean" && arguments.length === 2) {
|
||
errorOnMissing = cb;
|
||
cb = void 0;
|
||
}
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// get data and incremet stats
|
||
if ((this.data[key] != null) && this._check(key, this.data[key])) {
|
||
this.stats.hits++;
|
||
_ret = this._unwrap(this.data[key]);
|
||
if (cb != null) {
|
||
// return data
|
||
cb(null, _ret);
|
||
}
|
||
return _ret;
|
||
} else {
|
||
// if not found return a error
|
||
this.stats.misses++;
|
||
if (this.options.errorOnMissing || errorOnMissing) {
|
||
_err = this._error("ENOTFOUND", {
|
||
key: key
|
||
}, cb);
|
||
if (_err != null) {
|
||
throw _err;
|
||
}
|
||
return;
|
||
} else {
|
||
if (cb != null) {
|
||
cb(null, void 0);
|
||
}
|
||
}
|
||
return void 0;
|
||
}
|
||
}
|
||
|
||
mget(keys, cb) {
|
||
var _err, err, i, key, len, oRet;
|
||
boundMethodCheck(this, NodeCache);
|
||
// convert a string to an array of one key
|
||
if (!_isArray(keys)) {
|
||
_err = this._error("EKEYSTYPE");
|
||
if (cb != null) {
|
||
cb(_err);
|
||
}
|
||
return _err;
|
||
}
|
||
// define return
|
||
oRet = {};
|
||
for (i = 0, len = keys.length; i < len; i++) {
|
||
key = keys[i];
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// get data and increment stats
|
||
if ((this.data[key] != null) && this._check(key, this.data[key])) {
|
||
this.stats.hits++;
|
||
oRet[key] = this._unwrap(this.data[key]);
|
||
} else {
|
||
// if not found return a error
|
||
this.stats.misses++;
|
||
}
|
||
}
|
||
if (cb != null) {
|
||
// return all found keys
|
||
cb(null, oRet);
|
||
}
|
||
return oRet;
|
||
}
|
||
|
||
set(key, value, ttl, cb) {
|
||
var err, existent;
|
||
boundMethodCheck(this, NodeCache);
|
||
// force the data to string
|
||
if (this.options.forceString && !_isString(value)) {
|
||
value = JSON.stringify(value);
|
||
}
|
||
// remap the arguments if `ttl` is not passed
|
||
if (arguments.length === 3 && _isFunction(ttl)) {
|
||
cb = ttl;
|
||
ttl = this.options.stdTTL;
|
||
}
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// internal helper variables
|
||
existent = false;
|
||
// remove existing data from stats
|
||
if (this.data[key]) {
|
||
existent = true;
|
||
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
|
||
}
|
||
// set the value
|
||
this.data[key] = this._wrap(value, ttl);
|
||
this.stats.vsize += this._getValLength(value);
|
||
// only add the keys and key-size if the key is new
|
||
if (!existent) {
|
||
this.stats.ksize += this._getKeyLength(key);
|
||
this.stats.keys++;
|
||
}
|
||
this.emit("set", key, value);
|
||
if (cb != null) {
|
||
// return true
|
||
cb(null, true);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
del(keys, cb) {
|
||
var delCount, err, i, key, len, oldVal;
|
||
boundMethodCheck(this, NodeCache);
|
||
// convert keys to an array of itself
|
||
if (!_isArray(keys)) {
|
||
keys = [keys];
|
||
}
|
||
delCount = 0;
|
||
for (i = 0, len = keys.length; i < len; i++) {
|
||
key = keys[i];
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// only delete if existent
|
||
if (this.data[key] != null) {
|
||
// calc the stats
|
||
this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
|
||
this.stats.ksize -= this._getKeyLength(key);
|
||
this.stats.keys--;
|
||
delCount++;
|
||
// delete the value
|
||
oldVal = this.data[key];
|
||
delete this.data[key];
|
||
// return true
|
||
this.emit("del", key, oldVal.v);
|
||
} else {
|
||
// if the key has not been found return an error
|
||
this.stats.misses++;
|
||
}
|
||
}
|
||
if (cb != null) {
|
||
cb(null, delCount);
|
||
}
|
||
return delCount;
|
||
}
|
||
|
||
ttl() {
|
||
var arg, args, cb, err, i, key, len, ttl;
|
||
boundMethodCheck(this, NodeCache);
|
||
// change args if only key and callback are passed
|
||
[key, ...args] = arguments;
|
||
for (i = 0, len = args.length; i < len; i++) {
|
||
arg = args[i];
|
||
switch (typeof arg) {
|
||
case "number":
|
||
ttl = arg;
|
||
break;
|
||
case "function":
|
||
cb = arg;
|
||
}
|
||
}
|
||
ttl || (ttl = this.options.stdTTL);
|
||
if (!key) {
|
||
if (cb != null) {
|
||
cb(null, false);
|
||
}
|
||
return false;
|
||
}
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// check for existant data and update the ttl value
|
||
if ((this.data[key] != null) && this._check(key, this.data[key])) {
|
||
// if ttl < 0 delete the key. otherwise reset the value
|
||
if (ttl >= 0) {
|
||
this.data[key] = this._wrap(this.data[key].v, ttl, false);
|
||
} else {
|
||
this.del(key);
|
||
}
|
||
if (cb != null) {
|
||
cb(null, true);
|
||
}
|
||
return true;
|
||
} else {
|
||
if (cb != null) {
|
||
// return false if key has not been found
|
||
cb(null, false);
|
||
}
|
||
return false;
|
||
}
|
||
}
|
||
|
||
getTtl(key, cb) {
|
||
var _ttl, err;
|
||
boundMethodCheck(this, NodeCache);
|
||
if (!key) {
|
||
if (cb != null) {
|
||
cb(null, void 0);
|
||
}
|
||
return void 0;
|
||
}
|
||
// handle invalid key types
|
||
if ((err = this._isInvalidKey(key)) != null) {
|
||
if (cb != null) {
|
||
cb(err);
|
||
return;
|
||
} else {
|
||
throw err;
|
||
}
|
||
}
|
||
// check for existant data and update the ttl value
|
||
if ((this.data[key] != null) && this._check(key, this.data[key])) {
|
||
_ttl = this.data[key].t;
|
||
if (cb != null) {
|
||
cb(null, _ttl);
|
||
}
|
||
return _ttl;
|
||
} else {
|
||
if (cb != null) {
|
||
// return undefined if key has not been found
|
||
cb(null, void 0);
|
||
}
|
||
return void 0;
|
||
}
|
||
}
|
||
|
||
keys(cb) {
|
||
var _keys;
|
||
boundMethodCheck(this, NodeCache);
|
||
_keys = Object.keys(this.data);
|
||
if (cb != null) {
|
||
cb(null, _keys);
|
||
}
|
||
return _keys;
|
||
}
|
||
|
||
getStats() {
|
||
boundMethodCheck(this, NodeCache);
|
||
return this.stats;
|
||
}
|
||
|
||
flushAll(_startPeriod = true) {
|
||
boundMethodCheck(this, NodeCache);
|
||
// parameter just for testing
|
||
|
||
// set data empty
|
||
this.data = {};
|
||
// reset stats
|
||
this.stats = {
|
||
hits: 0,
|
||
misses: 0,
|
||
keys: 0,
|
||
ksize: 0,
|
||
vsize: 0
|
||
};
|
||
// reset check period
|
||
this._killCheckPeriod();
|
||
this._checkData(_startPeriod);
|
||
this.emit("flush");
|
||
}
|
||
|
||
close() {
|
||
boundMethodCheck(this, NodeCache);
|
||
this._killCheckPeriod();
|
||
}
|
||
|
||
_checkData(startPeriod = true) {
|
||
var key, ref, value;
|
||
boundMethodCheck(this, NodeCache);
|
||
ref = this.data;
|
||
// run the housekeeping method
|
||
for (key in ref) {
|
||
value = ref[key];
|
||
this._check(key, value);
|
||
}
|
||
if (startPeriod && this.options.checkperiod > 0) {
|
||
this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);
|
||
if (this.checkTimeout.unref != null) {
|
||
this.checkTimeout.unref();
|
||
}
|
||
}
|
||
}
|
||
|
||
// ## _killCheckPeriod
|
||
|
||
// stop the checkdata period. Only needed to abort the script in testing mode.
|
||
_killCheckPeriod() {
|
||
if (this.checkTimeout != null) {
|
||
return clearTimeout(this.checkTimeout);
|
||
}
|
||
}
|
||
|
||
_check(key, data) {
|
||
var _retval;
|
||
boundMethodCheck(this, NodeCache);
|
||
_retval = true;
|
||
// data is invalid if the ttl is too old and is not 0
|
||
// console.log data.t < Date.now(), data.t, Date.now()
|
||
if (data.t !== 0 && data.t < Date.now()) {
|
||
if (this.options.deleteOnExpire) {
|
||
_retval = false;
|
||
this.del(key);
|
||
}
|
||
this.emit("expired", key, this._unwrap(data));
|
||
}
|
||
return _retval;
|
||
}
|
||
|
||
_isInvalidKey(key) {
|
||
var ref;
|
||
boundMethodCheck(this, NodeCache);
|
||
if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {
|
||
return this._error("EKEYTYPE", {
|
||
type: typeof key
|
||
});
|
||
}
|
||
}
|
||
|
||
_wrap(value, ttl, asClone = true) {
|
||
var livetime, now, oReturn, ttlMultiplicator;
|
||
boundMethodCheck(this, NodeCache);
|
||
if (!this.options.useClones) {
|
||
asClone = false;
|
||
}
|
||
// define the time to live
|
||
now = Date.now();
|
||
livetime = 0;
|
||
ttlMultiplicator = 1000;
|
||
// use given ttl
|
||
if (ttl === 0) {
|
||
livetime = 0;
|
||
} else if (ttl) {
|
||
livetime = now + (ttl * ttlMultiplicator);
|
||
} else {
|
||
// use standard ttl
|
||
if (this.options.stdTTL === 0) {
|
||
livetime = this.options.stdTTL;
|
||
} else {
|
||
livetime = now + (this.options.stdTTL * ttlMultiplicator);
|
||
}
|
||
}
|
||
// return the wrapped value
|
||
return oReturn = {
|
||
t: livetime,
|
||
v: asClone ? clone(value) : value
|
||
};
|
||
}
|
||
|
||
// ## _unwrap
|
||
|
||
// internal method to extract get the value out of the wrapped value
|
||
_unwrap(value, asClone = true) {
|
||
if (!this.options.useClones) {
|
||
asClone = false;
|
||
}
|
||
if (value.v != null) {
|
||
if (asClone) {
|
||
return clone(value.v);
|
||
} else {
|
||
return value.v;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// ## _getKeyLength
|
||
|
||
// internal method the calculate the key length
|
||
_getKeyLength(key) {
|
||
return key.length;
|
||
}
|
||
|
||
_getValLength(value) {
|
||
boundMethodCheck(this, NodeCache);
|
||
if (_isString(value)) {
|
||
// if the value is a String get the real length
|
||
return value.length;
|
||
} else if (this.options.forceString) {
|
||
// force string if it's defined and not passed
|
||
return JSON.stringify(value).length;
|
||
} else if (_isArray(value)) {
|
||
// if the data is an Array multiply each element with a defined default length
|
||
return this.options.arrayValueSize * value.length;
|
||
} else if (_isNumber(value)) {
|
||
return 8;
|
||
} else if (typeof (value != null ? value.then : void 0) === "function") {
|
||
// if the data is a Promise, use defined default
|
||
// (can't calculate actual/resolved value size synchronously)
|
||
return this.options.promiseValueSize;
|
||
} else if (_isObject(value)) {
|
||
// if the data is an Object multiply each element with a defined default length
|
||
return this.options.objectValueSize * _size(value);
|
||
} else {
|
||
// default fallback
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
_error(type, data = {}, cb) {
|
||
var error;
|
||
boundMethodCheck(this, NodeCache);
|
||
// generate the error object
|
||
error = new Error();
|
||
error.name = type;
|
||
error.errorcode = type;
|
||
error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-";
|
||
error.data = data;
|
||
if (cb && _isFunction(cb)) {
|
||
// return the error
|
||
cb(error, null);
|
||
} else {
|
||
// if no callback is defined return the error object
|
||
return error;
|
||
}
|
||
}
|
||
|
||
_initErrors() {
|
||
var _errMsg, _errT, ref;
|
||
boundMethodCheck(this, NodeCache);
|
||
this.ERRORS = {};
|
||
ref = this._ERRORS;
|
||
for (_errT in ref) {
|
||
_errMsg = ref[_errT];
|
||
this.ERRORS[_errT] = _template(_errMsg);
|
||
}
|
||
}
|
||
|
||
};
|
||
|
||
NodeCache.prototype._ERRORS = {
|
||
"ENOTFOUND": "Key `<%= key %>` not found",
|
||
"EKEYTYPE": "The key argument has to be of type `string` or `number`. Found: `<%= type %>`",
|
||
"EKEYSTYPE": "The keys argument has to be an array."
|
||
};
|
||
|
||
return NodeCache;
|
||
|
||
}).call(this);
|
||
|
||
}).call(this);
|