mirror of
https://github.com/leoherzog/TorrentParts.git
synced 2026-01-24 04:08:04 -08:00
21020 lines
547 KiB
JavaScript
21020 lines
547 KiB
JavaScript
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
(function (Buffer){
|
|
if ('undefined' === typeof Buffer) {
|
|
// implicit global
|
|
Buffer = undefined;
|
|
}
|
|
|
|
(function () {
|
|
"use strict";
|
|
|
|
function createBuffer() {
|
|
return Array;
|
|
|
|
/*
|
|
function Buffer(sizeOrArrayOrString, encoding) {
|
|
var size, arr, str;
|
|
|
|
if ('number' === typeof sizeOrArrayOrString) {
|
|
size = sizeOrArrayOrString;
|
|
} else if ('string' === typeof sizeOrArrayOrString) {
|
|
// TODO handle encoding
|
|
str = String(sizeOrArrayOrString);
|
|
arr = arr.split('');
|
|
size = arr.length;
|
|
} else {
|
|
arr = sizeOrArrayOrString;
|
|
size = arr.length;
|
|
}
|
|
|
|
this.length = size;
|
|
}
|
|
|
|
Buffer.prototype = new Array();
|
|
delete Buffer.prototype.push;
|
|
delete Buffer.prototype.pop;
|
|
delete Buffer.prototype.shift;
|
|
delete Buffer.prototype.unshift;
|
|
delete Buffer.prototype.splice;
|
|
|
|
Buffer.isBuffer = function (buf) {
|
|
return buf instanceof Buffer;
|
|
};
|
|
|
|
// TODO
|
|
Buffer.byteLength = function (string, encoding) {
|
|
console.log('[todo] byteLength');
|
|
encoding = encoding || 'utf8';
|
|
// return string.length;
|
|
};
|
|
|
|
// TODO
|
|
Buffer.prototype.write = function (string, offset, encoding) {
|
|
console.log('[todo] write');
|
|
};
|
|
|
|
Buffer.prototype.toString = function (encoding, start, end) {
|
|
var res = {}
|
|
, i
|
|
;
|
|
|
|
start = start || 0;
|
|
end = end || this.length - 1;
|
|
res.length = end + 1;
|
|
|
|
if (this.length === res.length) {
|
|
res = this;
|
|
} else {
|
|
i = 0;
|
|
while (start <= end) {
|
|
res[i] = this[start];
|
|
i += 1;
|
|
start += 1;
|
|
}
|
|
}
|
|
|
|
return JSON.stringify(res);
|
|
};
|
|
|
|
Buffer.prototype.copy = function (targetBuffer, targetStart, sourceStart, sourceEnd) {
|
|
targetStart = targetStart || 0;
|
|
sourceStart = sourceStart || 0;
|
|
sourceEnd = sourceEnd || targetBuffer.length;
|
|
|
|
};
|
|
|
|
Buffer.prototype.slice = function (start, end) {
|
|
end = end || this.length;
|
|
this.slice(start, end);
|
|
}
|
|
|
|
return Buffer;
|
|
*/
|
|
}
|
|
|
|
if ('undefined' === typeof Buffer) {
|
|
Buffer = createBuffer();
|
|
}
|
|
|
|
module.exports = Buffer;
|
|
}());
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28}],2:[function(require,module,exports){
|
|
var Buffer = require('safe-buffer').Buffer
|
|
|
|
const INTEGER_START = 0x69 // 'i'
|
|
const STRING_DELIM = 0x3A // ':'
|
|
const DICTIONARY_START = 0x64 // 'd'
|
|
const LIST_START = 0x6C // 'l'
|
|
const END_OF_TYPE = 0x65 // 'e'
|
|
|
|
/**
|
|
* replaces parseInt(buffer.toString('ascii', start, end)).
|
|
* For strings with less then ~30 charachters, this is actually a lot faster.
|
|
*
|
|
* @param {Buffer} data
|
|
* @param {Number} start
|
|
* @param {Number} end
|
|
* @return {Number} calculated number
|
|
*/
|
|
function getIntFromBuffer (buffer, start, end) {
|
|
var sum = 0
|
|
var sign = 1
|
|
|
|
for (var i = start; i < end; i++) {
|
|
var num = buffer[i]
|
|
|
|
if (num < 58 && num >= 48) {
|
|
sum = sum * 10 + (num - 48)
|
|
continue
|
|
}
|
|
|
|
if (i === start && num === 43) { // +
|
|
continue
|
|
}
|
|
|
|
if (i === start && num === 45) { // -
|
|
sign = -1
|
|
continue
|
|
}
|
|
|
|
if (num === 46) { // .
|
|
// its a float. break here.
|
|
break
|
|
}
|
|
|
|
throw new Error('not a number: buffer[' + i + '] = ' + num)
|
|
}
|
|
|
|
return sum * sign
|
|
}
|
|
|
|
/**
|
|
* Decodes bencoded data.
|
|
*
|
|
* @param {Buffer} data
|
|
* @param {Number} start (optional)
|
|
* @param {Number} end (optional)
|
|
* @param {String} encoding (optional)
|
|
* @return {Object|Array|Buffer|String|Number}
|
|
*/
|
|
function decode (data, start, end, encoding) {
|
|
if (data == null || data.length === 0) {
|
|
return null
|
|
}
|
|
|
|
if (typeof start !== 'number' && encoding == null) {
|
|
encoding = start
|
|
start = undefined
|
|
}
|
|
|
|
if (typeof end !== 'number' && encoding == null) {
|
|
encoding = end
|
|
end = undefined
|
|
}
|
|
|
|
decode.position = 0
|
|
decode.encoding = encoding || null
|
|
|
|
decode.data = !(Buffer.isBuffer(data))
|
|
? Buffer.from(data)
|
|
: data.slice(start, end)
|
|
|
|
decode.bytes = decode.data.length
|
|
|
|
return decode.next()
|
|
}
|
|
|
|
decode.bytes = 0
|
|
decode.position = 0
|
|
decode.data = null
|
|
decode.encoding = null
|
|
|
|
decode.next = function () {
|
|
switch (decode.data[decode.position]) {
|
|
case DICTIONARY_START:
|
|
return decode.dictionary()
|
|
case LIST_START:
|
|
return decode.list()
|
|
case INTEGER_START:
|
|
return decode.integer()
|
|
default:
|
|
return decode.buffer()
|
|
}
|
|
}
|
|
|
|
decode.find = function (chr) {
|
|
var i = decode.position
|
|
var c = decode.data.length
|
|
var d = decode.data
|
|
|
|
while (i < c) {
|
|
if (d[i] === chr) return i
|
|
i++
|
|
}
|
|
|
|
throw new Error(
|
|
'Invalid data: Missing delimiter "' +
|
|
String.fromCharCode(chr) + '" [0x' +
|
|
chr.toString(16) + ']'
|
|
)
|
|
}
|
|
|
|
decode.dictionary = function () {
|
|
decode.position++
|
|
|
|
var dict = {}
|
|
|
|
while (decode.data[decode.position] !== END_OF_TYPE) {
|
|
dict[decode.buffer()] = decode.next()
|
|
}
|
|
|
|
decode.position++
|
|
|
|
return dict
|
|
}
|
|
|
|
decode.list = function () {
|
|
decode.position++
|
|
|
|
var lst = []
|
|
|
|
while (decode.data[decode.position] !== END_OF_TYPE) {
|
|
lst.push(decode.next())
|
|
}
|
|
|
|
decode.position++
|
|
|
|
return lst
|
|
}
|
|
|
|
decode.integer = function () {
|
|
var end = decode.find(END_OF_TYPE)
|
|
var number = getIntFromBuffer(decode.data, decode.position + 1, end)
|
|
|
|
decode.position += end + 1 - decode.position
|
|
|
|
return number
|
|
}
|
|
|
|
decode.buffer = function () {
|
|
var sep = decode.find(STRING_DELIM)
|
|
var length = getIntFromBuffer(decode.data, decode.position, sep)
|
|
var end = ++sep + length
|
|
|
|
decode.position = end
|
|
|
|
return decode.encoding
|
|
? decode.data.toString(decode.encoding, sep, end)
|
|
: decode.data.slice(sep, end)
|
|
}
|
|
|
|
module.exports = decode
|
|
|
|
},{"safe-buffer":15}],3:[function(require,module,exports){
|
|
var Buffer = require('safe-buffer').Buffer
|
|
|
|
/**
|
|
* Encodes data in bencode.
|
|
*
|
|
* @param {Buffer|Array|String|Object|Number|Boolean} data
|
|
* @return {Buffer}
|
|
*/
|
|
function encode (data, buffer, offset) {
|
|
var buffers = []
|
|
var result = null
|
|
|
|
encode._encode(buffers, data)
|
|
result = Buffer.concat(buffers)
|
|
encode.bytes = result.length
|
|
|
|
if (Buffer.isBuffer(buffer)) {
|
|
result.copy(buffer, offset)
|
|
return buffer
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
encode.bytes = -1
|
|
encode._floatConversionDetected = false
|
|
|
|
encode.getType = function (value) {
|
|
if (Buffer.isBuffer(value)) return 'buffer'
|
|
if (Array.isArray(value)) return 'array'
|
|
if (ArrayBuffer.isView(value)) return 'arraybufferview'
|
|
if (value instanceof Number) return 'number'
|
|
if (value instanceof Boolean) return 'boolean'
|
|
if (value instanceof ArrayBuffer) return 'arraybuffer'
|
|
return typeof value
|
|
}
|
|
|
|
encode._encode = function (buffers, data) {
|
|
if (data == null) { return }
|
|
|
|
switch (encode.getType(data)) {
|
|
case 'buffer': encode.buffer(buffers, data); break
|
|
case 'object': encode.dict(buffers, data); break
|
|
case 'array': encode.list(buffers, data); break
|
|
case 'string': encode.string(buffers, data); break
|
|
case 'number': encode.number(buffers, data); break
|
|
case 'boolean': encode.number(buffers, data); break
|
|
case 'arraybufferview': encode.buffer(buffers, Buffer.from(data.buffer, data.byteOffset, data.byteLength)); break
|
|
case 'arraybuffer': encode.buffer(buffers, Buffer.from(data)); break
|
|
}
|
|
}
|
|
|
|
var buffE = Buffer.from('e')
|
|
var buffD = Buffer.from('d')
|
|
var buffL = Buffer.from('l')
|
|
|
|
encode.buffer = function (buffers, data) {
|
|
buffers.push(Buffer.from(data.length + ':'), data)
|
|
}
|
|
|
|
encode.string = function (buffers, data) {
|
|
buffers.push(Buffer.from(Buffer.byteLength(data) + ':' + data))
|
|
}
|
|
|
|
encode.number = function (buffers, data) {
|
|
var maxLo = 0x80000000
|
|
var hi = (data / maxLo) << 0
|
|
var lo = (data % maxLo) << 0
|
|
var val = hi * maxLo + lo
|
|
|
|
buffers.push(Buffer.from('i' + val + 'e'))
|
|
|
|
if (val !== data && !encode._floatConversionDetected) {
|
|
encode._floatConversionDetected = true
|
|
console.warn(
|
|
'WARNING: Possible data corruption detected with value "' + data + '":',
|
|
'Bencoding only defines support for integers, value was converted to "' + val + '"'
|
|
)
|
|
console.trace()
|
|
}
|
|
}
|
|
|
|
encode.dict = function (buffers, data) {
|
|
buffers.push(buffD)
|
|
|
|
var j = 0
|
|
var k
|
|
// fix for issue #13 - sorted dicts
|
|
var keys = Object.keys(data).sort()
|
|
var kl = keys.length
|
|
|
|
for (; j < kl; j++) {
|
|
k = keys[j]
|
|
if (data[k] == null) continue
|
|
encode.string(buffers, k)
|
|
encode._encode(buffers, data[k])
|
|
}
|
|
|
|
buffers.push(buffE)
|
|
}
|
|
|
|
encode.list = function (buffers, data) {
|
|
var i = 0
|
|
var c = data.length
|
|
buffers.push(buffL)
|
|
|
|
for (; i < c; i++) {
|
|
if (data[i] == null) continue
|
|
encode._encode(buffers, data[i])
|
|
}
|
|
|
|
buffers.push(buffE)
|
|
}
|
|
|
|
module.exports = encode
|
|
|
|
},{"safe-buffer":15}],4:[function(require,module,exports){
|
|
var bencode = module.exports
|
|
|
|
bencode.encode = require('./encode')
|
|
bencode.decode = require('./decode')
|
|
|
|
/**
|
|
* Determines the amount of bytes
|
|
* needed to encode the given value
|
|
* @param {Object|Array|Buffer|String|Number|Boolean} value
|
|
* @return {Number} byteCount
|
|
*/
|
|
bencode.byteLength = bencode.encodingLength = function (value) {
|
|
return bencode.encode(value).length
|
|
}
|
|
|
|
},{"./decode":2,"./encode":3}],5:[function(require,module,exports){
|
|
(function (Buffer){
|
|
/* global Blob, FileReader */
|
|
|
|
module.exports = function blobToBuffer (blob, cb) {
|
|
if (typeof Blob === 'undefined' || !(blob instanceof Blob)) {
|
|
throw new Error('first argument must be a Blob')
|
|
}
|
|
if (typeof cb !== 'function') {
|
|
throw new Error('second argument must be a function')
|
|
}
|
|
|
|
var reader = new FileReader()
|
|
|
|
function onLoadEnd (e) {
|
|
reader.removeEventListener('loadend', onLoadEnd, false)
|
|
if (e.error) cb(e.error)
|
|
else cb(null, Buffer.from(reader.result))
|
|
}
|
|
|
|
reader.addEventListener('loadend', onLoadEnd, false)
|
|
reader.readAsArrayBuffer(blob)
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28}],6:[function(require,module,exports){
|
|
/*!
|
|
* bytes
|
|
* Copyright(c) 2012-2014 TJ Holowaychuk
|
|
* Copyright(c) 2015 Jed Watson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
module.exports = bytes;
|
|
module.exports.format = format;
|
|
module.exports.parse = parse;
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
|
|
|
|
var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
|
|
|
|
var map = {
|
|
b: 1,
|
|
kb: 1 << 10,
|
|
mb: 1 << 20,
|
|
gb: 1 << 30,
|
|
tb: Math.pow(1024, 4),
|
|
pb: Math.pow(1024, 5),
|
|
};
|
|
|
|
var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
|
|
|
|
/**
|
|
* Convert the given value in bytes into a string or parse to string to an integer in bytes.
|
|
*
|
|
* @param {string|number} value
|
|
* @param {{
|
|
* case: [string],
|
|
* decimalPlaces: [number]
|
|
* fixedDecimals: [boolean]
|
|
* thousandsSeparator: [string]
|
|
* unitSeparator: [string]
|
|
* }} [options] bytes options.
|
|
*
|
|
* @returns {string|number|null}
|
|
*/
|
|
|
|
function bytes(value, options) {
|
|
if (typeof value === 'string') {
|
|
return parse(value);
|
|
}
|
|
|
|
if (typeof value === 'number') {
|
|
return format(value, options);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Format the given value in bytes into a string.
|
|
*
|
|
* If the value is negative, it is kept as such. If it is a float,
|
|
* it is rounded.
|
|
*
|
|
* @param {number} value
|
|
* @param {object} [options]
|
|
* @param {number} [options.decimalPlaces=2]
|
|
* @param {number} [options.fixedDecimals=false]
|
|
* @param {string} [options.thousandsSeparator=]
|
|
* @param {string} [options.unit=]
|
|
* @param {string} [options.unitSeparator=]
|
|
*
|
|
* @returns {string|null}
|
|
* @public
|
|
*/
|
|
|
|
function format(value, options) {
|
|
if (!Number.isFinite(value)) {
|
|
return null;
|
|
}
|
|
|
|
var mag = Math.abs(value);
|
|
var thousandsSeparator = (options && options.thousandsSeparator) || '';
|
|
var unitSeparator = (options && options.unitSeparator) || '';
|
|
var decimalPlaces = (options && options.decimalPlaces !== undefined) ? options.decimalPlaces : 2;
|
|
var fixedDecimals = Boolean(options && options.fixedDecimals);
|
|
var unit = (options && options.unit) || '';
|
|
|
|
if (!unit || !map[unit.toLowerCase()]) {
|
|
if (mag >= map.pb) {
|
|
unit = 'PB';
|
|
} else if (mag >= map.tb) {
|
|
unit = 'TB';
|
|
} else if (mag >= map.gb) {
|
|
unit = 'GB';
|
|
} else if (mag >= map.mb) {
|
|
unit = 'MB';
|
|
} else if (mag >= map.kb) {
|
|
unit = 'KB';
|
|
} else {
|
|
unit = 'B';
|
|
}
|
|
}
|
|
|
|
var val = value / map[unit.toLowerCase()];
|
|
var str = val.toFixed(decimalPlaces);
|
|
|
|
if (!fixedDecimals) {
|
|
str = str.replace(formatDecimalsRegExp, '$1');
|
|
}
|
|
|
|
if (thousandsSeparator) {
|
|
str = str.replace(formatThousandsRegExp, thousandsSeparator);
|
|
}
|
|
|
|
return str + unitSeparator + unit;
|
|
}
|
|
|
|
/**
|
|
* Parse the string value into an integer in bytes.
|
|
*
|
|
* If no unit is given, it is assumed the value is in bytes.
|
|
*
|
|
* @param {number|string} val
|
|
*
|
|
* @returns {number|null}
|
|
* @public
|
|
*/
|
|
|
|
function parse(val) {
|
|
if (typeof val === 'number' && !isNaN(val)) {
|
|
return val;
|
|
}
|
|
|
|
if (typeof val !== 'string') {
|
|
return null;
|
|
}
|
|
|
|
// Test if the string passed is valid
|
|
var results = parseRegExp.exec(val);
|
|
var floatValue;
|
|
var unit = 'b';
|
|
|
|
if (!results) {
|
|
// Nothing could be extracted from the given string
|
|
floatValue = parseInt(val, 10);
|
|
unit = 'b'
|
|
} else {
|
|
// Retrieve the value and the unit
|
|
floatValue = parseFloat(results[1]);
|
|
unit = results[4].toLowerCase();
|
|
}
|
|
|
|
return Math.floor(map[unit] * floatValue);
|
|
}
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
/*!
|
|
* clipboard.js v2.0.6
|
|
* https://clipboardjs.com/
|
|
*
|
|
* Licensed MIT © Zeno Rocha
|
|
*/
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["ClipboardJS"] = factory();
|
|
else
|
|
root["ClipboardJS"] = factory();
|
|
})(this, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
/******/ }
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/
|
|
/******/ // create a fake namespace object
|
|
/******/ // mode & 1: value is a module id, require it
|
|
/******/ // mode & 2: merge all properties of value into the ns
|
|
/******/ // mode & 4: return value when already ns object
|
|
/******/ // mode & 8|1: behave like require
|
|
/******/ __webpack_require__.t = function(value, mode) {
|
|
/******/ if(mode & 1) value = __webpack_require__(value);
|
|
/******/ if(mode & 8) return value;
|
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
|
/******/ var ns = Object.create(null);
|
|
/******/ __webpack_require__.r(ns);
|
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
|
/******/ return ns;
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 6);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports) {
|
|
|
|
function select(element) {
|
|
var selectedText;
|
|
|
|
if (element.nodeName === 'SELECT') {
|
|
element.focus();
|
|
|
|
selectedText = element.value;
|
|
}
|
|
else if (element.nodeName === 'INPUT' || element.nodeName === 'TEXTAREA') {
|
|
var isReadOnly = element.hasAttribute('readonly');
|
|
|
|
if (!isReadOnly) {
|
|
element.setAttribute('readonly', '');
|
|
}
|
|
|
|
element.select();
|
|
element.setSelectionRange(0, element.value.length);
|
|
|
|
if (!isReadOnly) {
|
|
element.removeAttribute('readonly');
|
|
}
|
|
|
|
selectedText = element.value;
|
|
}
|
|
else {
|
|
if (element.hasAttribute('contenteditable')) {
|
|
element.focus();
|
|
}
|
|
|
|
var selection = window.getSelection();
|
|
var range = document.createRange();
|
|
|
|
range.selectNodeContents(element);
|
|
selection.removeAllRanges();
|
|
selection.addRange(range);
|
|
|
|
selectedText = selection.toString();
|
|
}
|
|
|
|
return selectedText;
|
|
}
|
|
|
|
module.exports = select;
|
|
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports) {
|
|
|
|
function E () {
|
|
// Keep this empty so it's easier to inherit from
|
|
// (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
|
|
}
|
|
|
|
E.prototype = {
|
|
on: function (name, callback, ctx) {
|
|
var e = this.e || (this.e = {});
|
|
|
|
(e[name] || (e[name] = [])).push({
|
|
fn: callback,
|
|
ctx: ctx
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
once: function (name, callback, ctx) {
|
|
var self = this;
|
|
function listener () {
|
|
self.off(name, listener);
|
|
callback.apply(ctx, arguments);
|
|
};
|
|
|
|
listener._ = callback
|
|
return this.on(name, listener, ctx);
|
|
},
|
|
|
|
emit: function (name) {
|
|
var data = [].slice.call(arguments, 1);
|
|
var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
|
|
var i = 0;
|
|
var len = evtArr.length;
|
|
|
|
for (i; i < len; i++) {
|
|
evtArr[i].fn.apply(evtArr[i].ctx, data);
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
off: function (name, callback) {
|
|
var e = this.e || (this.e = {});
|
|
var evts = e[name];
|
|
var liveEvents = [];
|
|
|
|
if (evts && callback) {
|
|
for (var i = 0, len = evts.length; i < len; i++) {
|
|
if (evts[i].fn !== callback && evts[i].fn._ !== callback)
|
|
liveEvents.push(evts[i]);
|
|
}
|
|
}
|
|
|
|
// Remove event from queue to prevent memory leak
|
|
// Suggested by https://github.com/lazd
|
|
// Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910
|
|
|
|
(liveEvents.length)
|
|
? e[name] = liveEvents
|
|
: delete e[name];
|
|
|
|
return this;
|
|
}
|
|
};
|
|
|
|
module.exports = E;
|
|
module.exports.TinyEmitter = E;
|
|
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var is = __webpack_require__(3);
|
|
var delegate = __webpack_require__(4);
|
|
|
|
/**
|
|
* Validates all params and calls the right
|
|
* listener function based on its target type.
|
|
*
|
|
* @param {String|HTMLElement|HTMLCollection|NodeList} target
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @return {Object}
|
|
*/
|
|
function listen(target, type, callback) {
|
|
if (!target && !type && !callback) {
|
|
throw new Error('Missing required arguments');
|
|
}
|
|
|
|
if (!is.string(type)) {
|
|
throw new TypeError('Second argument must be a String');
|
|
}
|
|
|
|
if (!is.fn(callback)) {
|
|
throw new TypeError('Third argument must be a Function');
|
|
}
|
|
|
|
if (is.node(target)) {
|
|
return listenNode(target, type, callback);
|
|
}
|
|
else if (is.nodeList(target)) {
|
|
return listenNodeList(target, type, callback);
|
|
}
|
|
else if (is.string(target)) {
|
|
return listenSelector(target, type, callback);
|
|
}
|
|
else {
|
|
throw new TypeError('First argument must be a String, HTMLElement, HTMLCollection, or NodeList');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds an event listener to a HTML element
|
|
* and returns a remove listener function.
|
|
*
|
|
* @param {HTMLElement} node
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @return {Object}
|
|
*/
|
|
function listenNode(node, type, callback) {
|
|
node.addEventListener(type, callback);
|
|
|
|
return {
|
|
destroy: function() {
|
|
node.removeEventListener(type, callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add an event listener to a list of HTML elements
|
|
* and returns a remove listener function.
|
|
*
|
|
* @param {NodeList|HTMLCollection} nodeList
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @return {Object}
|
|
*/
|
|
function listenNodeList(nodeList, type, callback) {
|
|
Array.prototype.forEach.call(nodeList, function(node) {
|
|
node.addEventListener(type, callback);
|
|
});
|
|
|
|
return {
|
|
destroy: function() {
|
|
Array.prototype.forEach.call(nodeList, function(node) {
|
|
node.removeEventListener(type, callback);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add an event listener to a selector
|
|
* and returns a remove listener function.
|
|
*
|
|
* @param {String} selector
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @return {Object}
|
|
*/
|
|
function listenSelector(selector, type, callback) {
|
|
return delegate(document.body, selector, type, callback);
|
|
}
|
|
|
|
module.exports = listen;
|
|
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/**
|
|
* Check if argument is a HTML element.
|
|
*
|
|
* @param {Object} value
|
|
* @return {Boolean}
|
|
*/
|
|
exports.node = function(value) {
|
|
return value !== undefined
|
|
&& value instanceof HTMLElement
|
|
&& value.nodeType === 1;
|
|
};
|
|
|
|
/**
|
|
* Check if argument is a list of HTML elements.
|
|
*
|
|
* @param {Object} value
|
|
* @return {Boolean}
|
|
*/
|
|
exports.nodeList = function(value) {
|
|
var type = Object.prototype.toString.call(value);
|
|
|
|
return value !== undefined
|
|
&& (type === '[object NodeList]' || type === '[object HTMLCollection]')
|
|
&& ('length' in value)
|
|
&& (value.length === 0 || exports.node(value[0]));
|
|
};
|
|
|
|
/**
|
|
* Check if argument is a string.
|
|
*
|
|
* @param {Object} value
|
|
* @return {Boolean}
|
|
*/
|
|
exports.string = function(value) {
|
|
return typeof value === 'string'
|
|
|| value instanceof String;
|
|
};
|
|
|
|
/**
|
|
* Check if argument is a function.
|
|
*
|
|
* @param {Object} value
|
|
* @return {Boolean}
|
|
*/
|
|
exports.fn = function(value) {
|
|
var type = Object.prototype.toString.call(value);
|
|
|
|
return type === '[object Function]';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var closest = __webpack_require__(5);
|
|
|
|
/**
|
|
* Delegates event to a selector.
|
|
*
|
|
* @param {Element} element
|
|
* @param {String} selector
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @param {Boolean} useCapture
|
|
* @return {Object}
|
|
*/
|
|
function _delegate(element, selector, type, callback, useCapture) {
|
|
var listenerFn = listener.apply(this, arguments);
|
|
|
|
element.addEventListener(type, listenerFn, useCapture);
|
|
|
|
return {
|
|
destroy: function() {
|
|
element.removeEventListener(type, listenerFn, useCapture);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delegates event to a selector.
|
|
*
|
|
* @param {Element|String|Array} [elements]
|
|
* @param {String} selector
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @param {Boolean} useCapture
|
|
* @return {Object}
|
|
*/
|
|
function delegate(elements, selector, type, callback, useCapture) {
|
|
// Handle the regular Element usage
|
|
if (typeof elements.addEventListener === 'function') {
|
|
return _delegate.apply(null, arguments);
|
|
}
|
|
|
|
// Handle Element-less usage, it defaults to global delegation
|
|
if (typeof type === 'function') {
|
|
// Use `document` as the first parameter, then apply arguments
|
|
// This is a short way to .unshift `arguments` without running into deoptimizations
|
|
return _delegate.bind(null, document).apply(null, arguments);
|
|
}
|
|
|
|
// Handle Selector-based usage
|
|
if (typeof elements === 'string') {
|
|
elements = document.querySelectorAll(elements);
|
|
}
|
|
|
|
// Handle Array-like based usage
|
|
return Array.prototype.map.call(elements, function (element) {
|
|
return _delegate(element, selector, type, callback, useCapture);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Finds closest match and invokes callback.
|
|
*
|
|
* @param {Element} element
|
|
* @param {String} selector
|
|
* @param {String} type
|
|
* @param {Function} callback
|
|
* @return {Function}
|
|
*/
|
|
function listener(element, selector, type, callback) {
|
|
return function(e) {
|
|
e.delegateTarget = closest(e.target, selector);
|
|
|
|
if (e.delegateTarget) {
|
|
callback.call(element, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = delegate;
|
|
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports) {
|
|
|
|
var DOCUMENT_NODE_TYPE = 9;
|
|
|
|
/**
|
|
* A polyfill for Element.matches()
|
|
*/
|
|
if (typeof Element !== 'undefined' && !Element.prototype.matches) {
|
|
var proto = Element.prototype;
|
|
|
|
proto.matches = proto.matchesSelector ||
|
|
proto.mozMatchesSelector ||
|
|
proto.msMatchesSelector ||
|
|
proto.oMatchesSelector ||
|
|
proto.webkitMatchesSelector;
|
|
}
|
|
|
|
/**
|
|
* Finds the closest parent that matches a selector.
|
|
*
|
|
* @param {Element} element
|
|
* @param {String} selector
|
|
* @return {Function}
|
|
*/
|
|
function closest (element, selector) {
|
|
while (element && element.nodeType !== DOCUMENT_NODE_TYPE) {
|
|
if (typeof element.matches === 'function' &&
|
|
element.matches(selector)) {
|
|
return element;
|
|
}
|
|
element = element.parentNode;
|
|
}
|
|
}
|
|
|
|
module.exports = closest;
|
|
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/select/src/select.js
|
|
var src_select = __webpack_require__(0);
|
|
var select_default = /*#__PURE__*/__webpack_require__.n(src_select);
|
|
|
|
// CONCATENATED MODULE: ./src/clipboard-action.js
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
|
|
|
|
/**
|
|
* Inner class which performs selection from either `text` or `target`
|
|
* properties and then executes copy or cut operations.
|
|
*/
|
|
|
|
var clipboard_action_ClipboardAction = function () {
|
|
/**
|
|
* @param {Object} options
|
|
*/
|
|
function ClipboardAction(options) {
|
|
_classCallCheck(this, ClipboardAction);
|
|
|
|
this.resolveOptions(options);
|
|
this.initSelection();
|
|
}
|
|
|
|
/**
|
|
* Defines base properties passed from constructor.
|
|
* @param {Object} options
|
|
*/
|
|
|
|
|
|
_createClass(ClipboardAction, [{
|
|
key: 'resolveOptions',
|
|
value: function resolveOptions() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
this.action = options.action;
|
|
this.container = options.container;
|
|
this.emitter = options.emitter;
|
|
this.target = options.target;
|
|
this.text = options.text;
|
|
this.trigger = options.trigger;
|
|
|
|
this.selectedText = '';
|
|
}
|
|
|
|
/**
|
|
* Decides which selection strategy is going to be applied based
|
|
* on the existence of `text` and `target` properties.
|
|
*/
|
|
|
|
}, {
|
|
key: 'initSelection',
|
|
value: function initSelection() {
|
|
if (this.text) {
|
|
this.selectFake();
|
|
} else if (this.target) {
|
|
this.selectTarget();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a fake textarea element, sets its value from `text` property,
|
|
* and makes a selection on it.
|
|
*/
|
|
|
|
}, {
|
|
key: 'selectFake',
|
|
value: function selectFake() {
|
|
var _this = this;
|
|
|
|
var isRTL = document.documentElement.getAttribute('dir') == 'rtl';
|
|
|
|
this.removeFake();
|
|
|
|
this.fakeHandlerCallback = function () {
|
|
return _this.removeFake();
|
|
};
|
|
this.fakeHandler = this.container.addEventListener('click', this.fakeHandlerCallback) || true;
|
|
|
|
this.fakeElem = document.createElement('textarea');
|
|
// Prevent zooming on iOS
|
|
this.fakeElem.style.fontSize = '12pt';
|
|
// Reset box model
|
|
this.fakeElem.style.border = '0';
|
|
this.fakeElem.style.padding = '0';
|
|
this.fakeElem.style.margin = '0';
|
|
// Move element out of screen horizontally
|
|
this.fakeElem.style.position = 'absolute';
|
|
this.fakeElem.style[isRTL ? 'right' : 'left'] = '-9999px';
|
|
// Move element to the same position vertically
|
|
var yPosition = window.pageYOffset || document.documentElement.scrollTop;
|
|
this.fakeElem.style.top = yPosition + 'px';
|
|
|
|
this.fakeElem.setAttribute('readonly', '');
|
|
this.fakeElem.value = this.text;
|
|
|
|
this.container.appendChild(this.fakeElem);
|
|
|
|
this.selectedText = select_default()(this.fakeElem);
|
|
this.copyText();
|
|
}
|
|
|
|
/**
|
|
* Only removes the fake element after another click event, that way
|
|
* a user can hit `Ctrl+C` to copy because selection still exists.
|
|
*/
|
|
|
|
}, {
|
|
key: 'removeFake',
|
|
value: function removeFake() {
|
|
if (this.fakeHandler) {
|
|
this.container.removeEventListener('click', this.fakeHandlerCallback);
|
|
this.fakeHandler = null;
|
|
this.fakeHandlerCallback = null;
|
|
}
|
|
|
|
if (this.fakeElem) {
|
|
this.container.removeChild(this.fakeElem);
|
|
this.fakeElem = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Selects the content from element passed on `target` property.
|
|
*/
|
|
|
|
}, {
|
|
key: 'selectTarget',
|
|
value: function selectTarget() {
|
|
this.selectedText = select_default()(this.target);
|
|
this.copyText();
|
|
}
|
|
|
|
/**
|
|
* Executes the copy operation based on the current selection.
|
|
*/
|
|
|
|
}, {
|
|
key: 'copyText',
|
|
value: function copyText() {
|
|
var succeeded = void 0;
|
|
|
|
try {
|
|
succeeded = document.execCommand(this.action);
|
|
} catch (err) {
|
|
succeeded = false;
|
|
}
|
|
|
|
this.handleResult(succeeded);
|
|
}
|
|
|
|
/**
|
|
* Fires an event based on the copy operation result.
|
|
* @param {Boolean} succeeded
|
|
*/
|
|
|
|
}, {
|
|
key: 'handleResult',
|
|
value: function handleResult(succeeded) {
|
|
this.emitter.emit(succeeded ? 'success' : 'error', {
|
|
action: this.action,
|
|
text: this.selectedText,
|
|
trigger: this.trigger,
|
|
clearSelection: this.clearSelection.bind(this)
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Moves focus away from `target` and back to the trigger, removes current selection.
|
|
*/
|
|
|
|
}, {
|
|
key: 'clearSelection',
|
|
value: function clearSelection() {
|
|
if (this.trigger) {
|
|
this.trigger.focus();
|
|
}
|
|
document.activeElement.blur();
|
|
window.getSelection().removeAllRanges();
|
|
}
|
|
|
|
/**
|
|
* Sets the `action` to be performed which can be either 'copy' or 'cut'.
|
|
* @param {String} action
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
|
|
|
|
/**
|
|
* Destroy lifecycle.
|
|
*/
|
|
value: function destroy() {
|
|
this.removeFake();
|
|
}
|
|
}, {
|
|
key: 'action',
|
|
set: function set() {
|
|
var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'copy';
|
|
|
|
this._action = action;
|
|
|
|
if (this._action !== 'copy' && this._action !== 'cut') {
|
|
throw new Error('Invalid "action" value, use either "copy" or "cut"');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the `action` property.
|
|
* @return {String}
|
|
*/
|
|
,
|
|
get: function get() {
|
|
return this._action;
|
|
}
|
|
|
|
/**
|
|
* Sets the `target` property using an element
|
|
* that will be have its content copied.
|
|
* @param {Element} target
|
|
*/
|
|
|
|
}, {
|
|
key: 'target',
|
|
set: function set(target) {
|
|
if (target !== undefined) {
|
|
if (target && (typeof target === 'undefined' ? 'undefined' : _typeof(target)) === 'object' && target.nodeType === 1) {
|
|
if (this.action === 'copy' && target.hasAttribute('disabled')) {
|
|
throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
|
|
}
|
|
|
|
if (this.action === 'cut' && (target.hasAttribute('readonly') || target.hasAttribute('disabled'))) {
|
|
throw new Error('Invalid "target" attribute. You can\'t cut text from elements with "readonly" or "disabled" attributes');
|
|
}
|
|
|
|
this._target = target;
|
|
} else {
|
|
throw new Error('Invalid "target" value, use a valid Element');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the `target` property.
|
|
* @return {String|HTMLElement}
|
|
*/
|
|
,
|
|
get: function get() {
|
|
return this._target;
|
|
}
|
|
}]);
|
|
|
|
return ClipboardAction;
|
|
}();
|
|
|
|
/* harmony default export */ var clipboard_action = (clipboard_action_ClipboardAction);
|
|
// EXTERNAL MODULE: ./node_modules/tiny-emitter/index.js
|
|
var tiny_emitter = __webpack_require__(1);
|
|
var tiny_emitter_default = /*#__PURE__*/__webpack_require__.n(tiny_emitter);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/good-listener/src/listen.js
|
|
var listen = __webpack_require__(2);
|
|
var listen_default = /*#__PURE__*/__webpack_require__.n(listen);
|
|
|
|
// CONCATENATED MODULE: ./src/clipboard.js
|
|
var clipboard_typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
var clipboard_createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function clipboard_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Base class which takes one or more elements, adds event listeners to them,
|
|
* and instantiates a new `ClipboardAction` on each click.
|
|
*/
|
|
|
|
var clipboard_Clipboard = function (_Emitter) {
|
|
_inherits(Clipboard, _Emitter);
|
|
|
|
/**
|
|
* @param {String|HTMLElement|HTMLCollection|NodeList} trigger
|
|
* @param {Object} options
|
|
*/
|
|
function Clipboard(trigger, options) {
|
|
clipboard_classCallCheck(this, Clipboard);
|
|
|
|
var _this = _possibleConstructorReturn(this, (Clipboard.__proto__ || Object.getPrototypeOf(Clipboard)).call(this));
|
|
|
|
_this.resolveOptions(options);
|
|
_this.listenClick(trigger);
|
|
return _this;
|
|
}
|
|
|
|
/**
|
|
* Defines if attributes would be resolved using internal setter functions
|
|
* or custom functions that were passed in the constructor.
|
|
* @param {Object} options
|
|
*/
|
|
|
|
|
|
clipboard_createClass(Clipboard, [{
|
|
key: 'resolveOptions',
|
|
value: function resolveOptions() {
|
|
var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
this.action = typeof options.action === 'function' ? options.action : this.defaultAction;
|
|
this.target = typeof options.target === 'function' ? options.target : this.defaultTarget;
|
|
this.text = typeof options.text === 'function' ? options.text : this.defaultText;
|
|
this.container = clipboard_typeof(options.container) === 'object' ? options.container : document.body;
|
|
}
|
|
|
|
/**
|
|
* Adds a click event listener to the passed trigger.
|
|
* @param {String|HTMLElement|HTMLCollection|NodeList} trigger
|
|
*/
|
|
|
|
}, {
|
|
key: 'listenClick',
|
|
value: function listenClick(trigger) {
|
|
var _this2 = this;
|
|
|
|
this.listener = listen_default()(trigger, 'click', function (e) {
|
|
return _this2.onClick(e);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Defines a new `ClipboardAction` on each click event.
|
|
* @param {Event} e
|
|
*/
|
|
|
|
}, {
|
|
key: 'onClick',
|
|
value: function onClick(e) {
|
|
var trigger = e.delegateTarget || e.currentTarget;
|
|
|
|
if (this.clipboardAction) {
|
|
this.clipboardAction = null;
|
|
}
|
|
|
|
this.clipboardAction = new clipboard_action({
|
|
action: this.action(trigger),
|
|
target: this.target(trigger),
|
|
text: this.text(trigger),
|
|
container: this.container,
|
|
trigger: trigger,
|
|
emitter: this
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Default `action` lookup function.
|
|
* @param {Element} trigger
|
|
*/
|
|
|
|
}, {
|
|
key: 'defaultAction',
|
|
value: function defaultAction(trigger) {
|
|
return getAttributeValue('action', trigger);
|
|
}
|
|
|
|
/**
|
|
* Default `target` lookup function.
|
|
* @param {Element} trigger
|
|
*/
|
|
|
|
}, {
|
|
key: 'defaultTarget',
|
|
value: function defaultTarget(trigger) {
|
|
var selector = getAttributeValue('target', trigger);
|
|
|
|
if (selector) {
|
|
return document.querySelector(selector);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the support of the given action, or all actions if no action is
|
|
* given.
|
|
* @param {String} [action]
|
|
*/
|
|
|
|
}, {
|
|
key: 'defaultText',
|
|
|
|
|
|
/**
|
|
* Default `text` lookup function.
|
|
* @param {Element} trigger
|
|
*/
|
|
value: function defaultText(trigger) {
|
|
return getAttributeValue('text', trigger);
|
|
}
|
|
|
|
/**
|
|
* Destroy lifecycle.
|
|
*/
|
|
|
|
}, {
|
|
key: 'destroy',
|
|
value: function destroy() {
|
|
this.listener.destroy();
|
|
|
|
if (this.clipboardAction) {
|
|
this.clipboardAction.destroy();
|
|
this.clipboardAction = null;
|
|
}
|
|
}
|
|
}], [{
|
|
key: 'isSupported',
|
|
value: function isSupported() {
|
|
var action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['copy', 'cut'];
|
|
|
|
var actions = typeof action === 'string' ? [action] : action;
|
|
var support = !!document.queryCommandSupported;
|
|
|
|
actions.forEach(function (action) {
|
|
support = support && !!document.queryCommandSupported(action);
|
|
});
|
|
|
|
return support;
|
|
}
|
|
}]);
|
|
|
|
return Clipboard;
|
|
}(tiny_emitter_default.a);
|
|
|
|
/**
|
|
* Helper function to retrieve attribute value.
|
|
* @param {String} suffix
|
|
* @param {Element} element
|
|
*/
|
|
|
|
|
|
function getAttributeValue(suffix, element) {
|
|
var attribute = 'data-clipboard-' + suffix;
|
|
|
|
if (!element.hasAttribute(attribute)) {
|
|
return;
|
|
}
|
|
|
|
return element.getAttribute(attribute);
|
|
}
|
|
|
|
/* harmony default export */ var clipboard = __webpack_exports__["default"] = (clipboard_Clipboard);
|
|
|
|
/***/ })
|
|
/******/ ])["default"];
|
|
});
|
|
},{}],8:[function(require,module,exports){
|
|
(function (Buffer){
|
|
module.exports = magnetURIDecode
|
|
module.exports.decode = magnetURIDecode
|
|
module.exports.encode = magnetURIEncode
|
|
|
|
const base32 = require('thirty-two')
|
|
const uniq = require('uniq')
|
|
|
|
/**
|
|
* Parse a magnet URI and return an object of keys/values
|
|
*
|
|
* @param {string} uri
|
|
* @return {Object} parsed uri
|
|
*/
|
|
function magnetURIDecode (uri) {
|
|
const result = {}
|
|
|
|
// Support 'magnet:' and 'stream-magnet:' uris
|
|
const data = uri.split('magnet:?')[1]
|
|
|
|
const params = (data && data.length >= 0)
|
|
? data.split('&')
|
|
: []
|
|
|
|
params.forEach(param => {
|
|
const keyval = param.split('=')
|
|
|
|
// This keyval is invalid, skip it
|
|
if (keyval.length !== 2) return
|
|
|
|
const key = keyval[0]
|
|
let val = keyval[1]
|
|
|
|
// Clean up torrent name
|
|
if (key === 'dn') val = decodeURIComponent(val).replace(/\+/g, ' ')
|
|
|
|
// Address tracker (tr), exact source (xs), and acceptable source (as) are encoded
|
|
// URIs, so decode them
|
|
if (key === 'tr' || key === 'xs' || key === 'as' || key === 'ws') {
|
|
val = decodeURIComponent(val)
|
|
}
|
|
|
|
// Return keywords as an array
|
|
if (key === 'kt') val = decodeURIComponent(val).split('+')
|
|
|
|
// Cast file index (ix) to a number
|
|
if (key === 'ix') val = Number(val)
|
|
|
|
// If there are repeated parameters, return an array of values
|
|
if (result[key]) {
|
|
if (Array.isArray(result[key])) {
|
|
result[key].push(val)
|
|
} else {
|
|
const old = result[key]
|
|
result[key] = [old, val]
|
|
}
|
|
} else {
|
|
result[key] = val
|
|
}
|
|
})
|
|
|
|
// Convenience properties for parity with `parse-torrent-file` module
|
|
let m
|
|
if (result.xt) {
|
|
const xts = Array.isArray(result.xt) ? result.xt : [ result.xt ]
|
|
xts.forEach(xt => {
|
|
if ((m = xt.match(/^urn:btih:(.{40})/))) {
|
|
result.infoHash = m[1].toLowerCase()
|
|
} else if ((m = xt.match(/^urn:btih:(.{32})/))) {
|
|
const decodedStr = base32.decode(m[1])
|
|
result.infoHash = Buffer.from(decodedStr, 'binary').toString('hex')
|
|
}
|
|
})
|
|
}
|
|
if (result.infoHash) result.infoHashBuffer = Buffer.from(result.infoHash, 'hex')
|
|
|
|
if (result.dn) result.name = result.dn
|
|
if (result.kt) result.keywords = result.kt
|
|
|
|
if (typeof result.tr === 'string') result.announce = [ result.tr ]
|
|
else if (Array.isArray(result.tr)) result.announce = result.tr
|
|
else result.announce = []
|
|
|
|
result.urlList = []
|
|
if (typeof result.as === 'string' || Array.isArray(result.as)) {
|
|
result.urlList = result.urlList.concat(result.as)
|
|
}
|
|
if (typeof result.ws === 'string' || Array.isArray(result.ws)) {
|
|
result.urlList = result.urlList.concat(result.ws)
|
|
}
|
|
|
|
uniq(result.announce)
|
|
uniq(result.urlList)
|
|
|
|
return result
|
|
}
|
|
|
|
function magnetURIEncode (obj) {
|
|
obj = Object.assign({}, obj) // clone obj, so we can mutate it
|
|
|
|
// support using convenience names, in addition to spec names
|
|
// (example: `infoHash` for `xt`, `name` for `dn`)
|
|
if (obj.infoHashBuffer) obj.xt = `urn:btih:${obj.infoHashBuffer.toString('hex')}`
|
|
if (obj.infoHash) obj.xt = `urn:btih:${obj.infoHash}`
|
|
if (obj.name) obj.dn = obj.name
|
|
if (obj.keywords) obj.kt = obj.keywords
|
|
if (obj.announce) obj.tr = obj.announce
|
|
if (obj.urlList) {
|
|
obj.ws = obj.urlList
|
|
delete obj.as
|
|
}
|
|
|
|
let result = 'magnet:?'
|
|
Object.keys(obj)
|
|
.filter(key => key.length === 2)
|
|
.forEach((key, i) => {
|
|
const values = Array.isArray(obj[key]) ? obj[key] : [ obj[key] ]
|
|
values.forEach((val, j) => {
|
|
if ((i > 0 || j > 0) && (key !== 'kt' || j === 0)) result += '&'
|
|
|
|
if (key === 'dn') val = encodeURIComponent(val).replace(/%20/g, '+')
|
|
if (key === 'tr' || key === 'xs' || key === 'as' || key === 'ws') {
|
|
val = encodeURIComponent(val)
|
|
}
|
|
if (key === 'kt') val = encodeURIComponent(val)
|
|
|
|
if (key === 'kt' && j > 0) result += `+${val}`
|
|
else result += `${key}=${val}`
|
|
})
|
|
})
|
|
|
|
return result
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28,"thirty-two":20,"uniq":22}],9:[function(require,module,exports){
|
|
module.exports={
|
|
"application/1d-interleaved-parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"application/3gpdash-qoe-report+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/3gpp-ims+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/a2l": {
|
|
"source": "iana"
|
|
},
|
|
"application/activemessage": {
|
|
"source": "iana"
|
|
},
|
|
"application/activity+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-costmap+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-costmapfilter+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-directory+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-endpointcost+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-endpointcostparams+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-endpointprop+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-endpointpropparams+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-error+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-networkmap+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-networkmapfilter+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-updatestreamcontrol+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/alto-updatestreamparams+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/aml": {
|
|
"source": "iana"
|
|
},
|
|
"application/andrew-inset": {
|
|
"source": "iana",
|
|
"extensions": ["ez"]
|
|
},
|
|
"application/applefile": {
|
|
"source": "iana"
|
|
},
|
|
"application/applixware": {
|
|
"source": "apache",
|
|
"extensions": ["aw"]
|
|
},
|
|
"application/atf": {
|
|
"source": "iana"
|
|
},
|
|
"application/atfx": {
|
|
"source": "iana"
|
|
},
|
|
"application/atom+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["atom"]
|
|
},
|
|
"application/atomcat+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["atomcat"]
|
|
},
|
|
"application/atomdeleted+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["atomdeleted"]
|
|
},
|
|
"application/atomicmail": {
|
|
"source": "iana"
|
|
},
|
|
"application/atomsvc+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["atomsvc"]
|
|
},
|
|
"application/atsc-dwd+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["dwd"]
|
|
},
|
|
"application/atsc-dynamic-event-message": {
|
|
"source": "iana"
|
|
},
|
|
"application/atsc-held+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["held"]
|
|
},
|
|
"application/atsc-rdt+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/atsc-rsat+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rsat"]
|
|
},
|
|
"application/atxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/auth-policy+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/bacnet-xdd+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/batch-smtp": {
|
|
"source": "iana"
|
|
},
|
|
"application/bdoc": {
|
|
"compressible": false,
|
|
"extensions": ["bdoc"]
|
|
},
|
|
"application/beep+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/calendar+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/calendar+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xcs"]
|
|
},
|
|
"application/call-completion": {
|
|
"source": "iana"
|
|
},
|
|
"application/cals-1840": {
|
|
"source": "iana"
|
|
},
|
|
"application/cap+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/cbor-seq": {
|
|
"source": "iana"
|
|
},
|
|
"application/cccex": {
|
|
"source": "iana"
|
|
},
|
|
"application/ccmp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/ccxml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ccxml"]
|
|
},
|
|
"application/cdfx+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["cdfx"]
|
|
},
|
|
"application/cdmi-capability": {
|
|
"source": "iana",
|
|
"extensions": ["cdmia"]
|
|
},
|
|
"application/cdmi-container": {
|
|
"source": "iana",
|
|
"extensions": ["cdmic"]
|
|
},
|
|
"application/cdmi-domain": {
|
|
"source": "iana",
|
|
"extensions": ["cdmid"]
|
|
},
|
|
"application/cdmi-object": {
|
|
"source": "iana",
|
|
"extensions": ["cdmio"]
|
|
},
|
|
"application/cdmi-queue": {
|
|
"source": "iana",
|
|
"extensions": ["cdmiq"]
|
|
},
|
|
"application/cdni": {
|
|
"source": "iana"
|
|
},
|
|
"application/cea": {
|
|
"source": "iana"
|
|
},
|
|
"application/cea-2018+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cellml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cfw": {
|
|
"source": "iana"
|
|
},
|
|
"application/clue+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/clue_info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cms": {
|
|
"source": "iana"
|
|
},
|
|
"application/cnrp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/coap-group+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/coap-payload": {
|
|
"source": "iana"
|
|
},
|
|
"application/commonground": {
|
|
"source": "iana"
|
|
},
|
|
"application/conference-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cose": {
|
|
"source": "iana"
|
|
},
|
|
"application/cose-key": {
|
|
"source": "iana"
|
|
},
|
|
"application/cose-key-set": {
|
|
"source": "iana"
|
|
},
|
|
"application/cpl+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/csrattrs": {
|
|
"source": "iana"
|
|
},
|
|
"application/csta+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cstadata+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/csvm+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/cu-seeme": {
|
|
"source": "apache",
|
|
"extensions": ["cu"]
|
|
},
|
|
"application/cwt": {
|
|
"source": "iana"
|
|
},
|
|
"application/cybercash": {
|
|
"source": "iana"
|
|
},
|
|
"application/dart": {
|
|
"compressible": true
|
|
},
|
|
"application/dash+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mpd"]
|
|
},
|
|
"application/dashdelta": {
|
|
"source": "iana"
|
|
},
|
|
"application/davmount+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["davmount"]
|
|
},
|
|
"application/dca-rft": {
|
|
"source": "iana"
|
|
},
|
|
"application/dcd": {
|
|
"source": "iana"
|
|
},
|
|
"application/dec-dx": {
|
|
"source": "iana"
|
|
},
|
|
"application/dialog-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/dicom": {
|
|
"source": "iana"
|
|
},
|
|
"application/dicom+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/dicom+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/dii": {
|
|
"source": "iana"
|
|
},
|
|
"application/dit": {
|
|
"source": "iana"
|
|
},
|
|
"application/dns": {
|
|
"source": "iana"
|
|
},
|
|
"application/dns+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/dns-message": {
|
|
"source": "iana"
|
|
},
|
|
"application/docbook+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["dbk"]
|
|
},
|
|
"application/dots+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/dskpp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/dssc+der": {
|
|
"source": "iana",
|
|
"extensions": ["dssc"]
|
|
},
|
|
"application/dssc+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xdssc"]
|
|
},
|
|
"application/dvcs": {
|
|
"source": "iana"
|
|
},
|
|
"application/ecmascript": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ecma","es"]
|
|
},
|
|
"application/edi-consent": {
|
|
"source": "iana"
|
|
},
|
|
"application/edi-x12": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/edifact": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/efi": {
|
|
"source": "iana"
|
|
},
|
|
"application/emergencycalldata.comment+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.control+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.deviceinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.ecall.msd": {
|
|
"source": "iana"
|
|
},
|
|
"application/emergencycalldata.providerinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.serviceinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.subscriberinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emergencycalldata.veds+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/emma+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["emma"]
|
|
},
|
|
"application/emotionml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["emotionml"]
|
|
},
|
|
"application/encaprtp": {
|
|
"source": "iana"
|
|
},
|
|
"application/epp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/epub+zip": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["epub"]
|
|
},
|
|
"application/eshop": {
|
|
"source": "iana"
|
|
},
|
|
"application/exi": {
|
|
"source": "iana",
|
|
"extensions": ["exi"]
|
|
},
|
|
"application/expect-ct-report+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/fastinfoset": {
|
|
"source": "iana"
|
|
},
|
|
"application/fastsoap": {
|
|
"source": "iana"
|
|
},
|
|
"application/fdt+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["fdt"]
|
|
},
|
|
"application/fhir+json": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/fhir+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/fido.trusted-apps+json": {
|
|
"compressible": true
|
|
},
|
|
"application/fits": {
|
|
"source": "iana"
|
|
},
|
|
"application/flexfec": {
|
|
"source": "iana"
|
|
},
|
|
"application/font-sfnt": {
|
|
"source": "iana"
|
|
},
|
|
"application/font-tdpfr": {
|
|
"source": "iana",
|
|
"extensions": ["pfr"]
|
|
},
|
|
"application/font-woff": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/framework-attributes+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/geo+json": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["geojson"]
|
|
},
|
|
"application/geo+json-seq": {
|
|
"source": "iana"
|
|
},
|
|
"application/geopackage+sqlite3": {
|
|
"source": "iana"
|
|
},
|
|
"application/geoxacml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/gltf-buffer": {
|
|
"source": "iana"
|
|
},
|
|
"application/gml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["gml"]
|
|
},
|
|
"application/gpx+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["gpx"]
|
|
},
|
|
"application/gxf": {
|
|
"source": "apache",
|
|
"extensions": ["gxf"]
|
|
},
|
|
"application/gzip": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["gz"]
|
|
},
|
|
"application/h224": {
|
|
"source": "iana"
|
|
},
|
|
"application/held+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/hjson": {
|
|
"extensions": ["hjson"]
|
|
},
|
|
"application/http": {
|
|
"source": "iana"
|
|
},
|
|
"application/hyperstudio": {
|
|
"source": "iana",
|
|
"extensions": ["stk"]
|
|
},
|
|
"application/ibe-key-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/ibe-pkg-reply+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/ibe-pp-data": {
|
|
"source": "iana"
|
|
},
|
|
"application/iges": {
|
|
"source": "iana"
|
|
},
|
|
"application/im-iscomposing+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/index": {
|
|
"source": "iana"
|
|
},
|
|
"application/index.cmd": {
|
|
"source": "iana"
|
|
},
|
|
"application/index.obj": {
|
|
"source": "iana"
|
|
},
|
|
"application/index.response": {
|
|
"source": "iana"
|
|
},
|
|
"application/index.vnd": {
|
|
"source": "iana"
|
|
},
|
|
"application/inkml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ink","inkml"]
|
|
},
|
|
"application/iotp": {
|
|
"source": "iana"
|
|
},
|
|
"application/ipfix": {
|
|
"source": "iana",
|
|
"extensions": ["ipfix"]
|
|
},
|
|
"application/ipp": {
|
|
"source": "iana"
|
|
},
|
|
"application/isup": {
|
|
"source": "iana"
|
|
},
|
|
"application/its+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["its"]
|
|
},
|
|
"application/java-archive": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["jar","war","ear"]
|
|
},
|
|
"application/java-serialized-object": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["ser"]
|
|
},
|
|
"application/java-vm": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["class"]
|
|
},
|
|
"application/javascript": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["js","mjs"]
|
|
},
|
|
"application/jf2feed+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/jose": {
|
|
"source": "iana"
|
|
},
|
|
"application/jose+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/jrd+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/json": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["json","map"]
|
|
},
|
|
"application/json-patch+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/json-seq": {
|
|
"source": "iana"
|
|
},
|
|
"application/json5": {
|
|
"extensions": ["json5"]
|
|
},
|
|
"application/jsonml+json": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["jsonml"]
|
|
},
|
|
"application/jwk+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/jwk-set+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/jwt": {
|
|
"source": "iana"
|
|
},
|
|
"application/kpml-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/kpml-response+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/ld+json": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["jsonld"]
|
|
},
|
|
"application/lgr+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["lgr"]
|
|
},
|
|
"application/link-format": {
|
|
"source": "iana"
|
|
},
|
|
"application/load-control+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/lost+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["lostxml"]
|
|
},
|
|
"application/lostsync+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/lpf+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/lxf": {
|
|
"source": "iana"
|
|
},
|
|
"application/mac-binhex40": {
|
|
"source": "iana",
|
|
"extensions": ["hqx"]
|
|
},
|
|
"application/mac-compactpro": {
|
|
"source": "apache",
|
|
"extensions": ["cpt"]
|
|
},
|
|
"application/macwriteii": {
|
|
"source": "iana"
|
|
},
|
|
"application/mads+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mads"]
|
|
},
|
|
"application/manifest+json": {
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["webmanifest"]
|
|
},
|
|
"application/marc": {
|
|
"source": "iana",
|
|
"extensions": ["mrc"]
|
|
},
|
|
"application/marcxml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mrcx"]
|
|
},
|
|
"application/mathematica": {
|
|
"source": "iana",
|
|
"extensions": ["ma","nb","mb"]
|
|
},
|
|
"application/mathml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mathml"]
|
|
},
|
|
"application/mathml-content+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mathml-presentation+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-associated-procedure-description+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-deregister+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-envelope+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-msk+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-msk-response+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-protection-description+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-reception-report+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-register+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-register-response+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-schedule+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbms-user-service-description+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mbox": {
|
|
"source": "iana",
|
|
"extensions": ["mbox"]
|
|
},
|
|
"application/media-policy-dataset+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/media_control+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/mediaservercontrol+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mscml"]
|
|
},
|
|
"application/merge-patch+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/metalink+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["metalink"]
|
|
},
|
|
"application/metalink4+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["meta4"]
|
|
},
|
|
"application/mets+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mets"]
|
|
},
|
|
"application/mf4": {
|
|
"source": "iana"
|
|
},
|
|
"application/mikey": {
|
|
"source": "iana"
|
|
},
|
|
"application/mipc": {
|
|
"source": "iana"
|
|
},
|
|
"application/mmt-aei+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["maei"]
|
|
},
|
|
"application/mmt-usd+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["musd"]
|
|
},
|
|
"application/mods+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mods"]
|
|
},
|
|
"application/moss-keys": {
|
|
"source": "iana"
|
|
},
|
|
"application/moss-signature": {
|
|
"source": "iana"
|
|
},
|
|
"application/mosskey-data": {
|
|
"source": "iana"
|
|
},
|
|
"application/mosskey-request": {
|
|
"source": "iana"
|
|
},
|
|
"application/mp21": {
|
|
"source": "iana",
|
|
"extensions": ["m21","mp21"]
|
|
},
|
|
"application/mp4": {
|
|
"source": "iana",
|
|
"extensions": ["mp4s","m4p"]
|
|
},
|
|
"application/mpeg4-generic": {
|
|
"source": "iana"
|
|
},
|
|
"application/mpeg4-iod": {
|
|
"source": "iana"
|
|
},
|
|
"application/mpeg4-iod-xmt": {
|
|
"source": "iana"
|
|
},
|
|
"application/mrb-consumer+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xdf"]
|
|
},
|
|
"application/mrb-publish+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xdf"]
|
|
},
|
|
"application/msc-ivr+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/msc-mixer+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/msword": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["doc","dot"]
|
|
},
|
|
"application/mud+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/multipart-core": {
|
|
"source": "iana"
|
|
},
|
|
"application/mxf": {
|
|
"source": "iana",
|
|
"extensions": ["mxf"]
|
|
},
|
|
"application/n-quads": {
|
|
"source": "iana",
|
|
"extensions": ["nq"]
|
|
},
|
|
"application/n-triples": {
|
|
"source": "iana",
|
|
"extensions": ["nt"]
|
|
},
|
|
"application/nasdata": {
|
|
"source": "iana"
|
|
},
|
|
"application/news-checkgroups": {
|
|
"source": "iana",
|
|
"charset": "US-ASCII"
|
|
},
|
|
"application/news-groupinfo": {
|
|
"source": "iana",
|
|
"charset": "US-ASCII"
|
|
},
|
|
"application/news-transmission": {
|
|
"source": "iana"
|
|
},
|
|
"application/nlsml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/node": {
|
|
"source": "iana",
|
|
"extensions": ["cjs"]
|
|
},
|
|
"application/nss": {
|
|
"source": "iana"
|
|
},
|
|
"application/ocsp-request": {
|
|
"source": "iana"
|
|
},
|
|
"application/ocsp-response": {
|
|
"source": "iana"
|
|
},
|
|
"application/octet-stream": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","exe","dll","deb","dmg","iso","img","msi","msp","msm","buffer"]
|
|
},
|
|
"application/oda": {
|
|
"source": "iana",
|
|
"extensions": ["oda"]
|
|
},
|
|
"application/odm+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/odx": {
|
|
"source": "iana"
|
|
},
|
|
"application/oebps-package+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["opf"]
|
|
},
|
|
"application/ogg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["ogx"]
|
|
},
|
|
"application/omdoc+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["omdoc"]
|
|
},
|
|
"application/onenote": {
|
|
"source": "apache",
|
|
"extensions": ["onetoc","onetoc2","onetmp","onepkg"]
|
|
},
|
|
"application/oscore": {
|
|
"source": "iana"
|
|
},
|
|
"application/oxps": {
|
|
"source": "iana",
|
|
"extensions": ["oxps"]
|
|
},
|
|
"application/p2p-overlay+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["relo"]
|
|
},
|
|
"application/parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"application/passport": {
|
|
"source": "iana"
|
|
},
|
|
"application/patch-ops-error+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xer"]
|
|
},
|
|
"application/pdf": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["pdf"]
|
|
},
|
|
"application/pdx": {
|
|
"source": "iana"
|
|
},
|
|
"application/pem-certificate-chain": {
|
|
"source": "iana"
|
|
},
|
|
"application/pgp-encrypted": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["pgp"]
|
|
},
|
|
"application/pgp-keys": {
|
|
"source": "iana"
|
|
},
|
|
"application/pgp-signature": {
|
|
"source": "iana",
|
|
"extensions": ["asc","sig"]
|
|
},
|
|
"application/pics-rules": {
|
|
"source": "apache",
|
|
"extensions": ["prf"]
|
|
},
|
|
"application/pidf+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/pidf-diff+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/pkcs10": {
|
|
"source": "iana",
|
|
"extensions": ["p10"]
|
|
},
|
|
"application/pkcs12": {
|
|
"source": "iana"
|
|
},
|
|
"application/pkcs7-mime": {
|
|
"source": "iana",
|
|
"extensions": ["p7m","p7c"]
|
|
},
|
|
"application/pkcs7-signature": {
|
|
"source": "iana",
|
|
"extensions": ["p7s"]
|
|
},
|
|
"application/pkcs8": {
|
|
"source": "iana",
|
|
"extensions": ["p8"]
|
|
},
|
|
"application/pkcs8-encrypted": {
|
|
"source": "iana"
|
|
},
|
|
"application/pkix-attr-cert": {
|
|
"source": "iana",
|
|
"extensions": ["ac"]
|
|
},
|
|
"application/pkix-cert": {
|
|
"source": "iana",
|
|
"extensions": ["cer"]
|
|
},
|
|
"application/pkix-crl": {
|
|
"source": "iana",
|
|
"extensions": ["crl"]
|
|
},
|
|
"application/pkix-pkipath": {
|
|
"source": "iana",
|
|
"extensions": ["pkipath"]
|
|
},
|
|
"application/pkixcmp": {
|
|
"source": "iana",
|
|
"extensions": ["pki"]
|
|
},
|
|
"application/pls+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["pls"]
|
|
},
|
|
"application/poc-settings+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/postscript": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ai","eps","ps"]
|
|
},
|
|
"application/ppsp-tracker+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/problem+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/problem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/provenance+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["provx"]
|
|
},
|
|
"application/prs.alvestrand.titrax-sheet": {
|
|
"source": "iana"
|
|
},
|
|
"application/prs.cww": {
|
|
"source": "iana",
|
|
"extensions": ["cww"]
|
|
},
|
|
"application/prs.hpub+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/prs.nprend": {
|
|
"source": "iana"
|
|
},
|
|
"application/prs.plucker": {
|
|
"source": "iana"
|
|
},
|
|
"application/prs.rdf-xml-crypt": {
|
|
"source": "iana"
|
|
},
|
|
"application/prs.xsf+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/pskc+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["pskcxml"]
|
|
},
|
|
"application/pvd+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/qsig": {
|
|
"source": "iana"
|
|
},
|
|
"application/raml+yaml": {
|
|
"compressible": true,
|
|
"extensions": ["raml"]
|
|
},
|
|
"application/raptorfec": {
|
|
"source": "iana"
|
|
},
|
|
"application/rdap+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/rdf+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rdf","owl"]
|
|
},
|
|
"application/reginfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rif"]
|
|
},
|
|
"application/relax-ng-compact-syntax": {
|
|
"source": "iana",
|
|
"extensions": ["rnc"]
|
|
},
|
|
"application/remote-printing": {
|
|
"source": "iana"
|
|
},
|
|
"application/reputon+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/resource-lists+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rl"]
|
|
},
|
|
"application/resource-lists-diff+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rld"]
|
|
},
|
|
"application/rfc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/riscos": {
|
|
"source": "iana"
|
|
},
|
|
"application/rlmi+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/rls-services+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rs"]
|
|
},
|
|
"application/route-apd+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rapd"]
|
|
},
|
|
"application/route-s-tsid+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["sls"]
|
|
},
|
|
"application/route-usd+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rusd"]
|
|
},
|
|
"application/rpki-ghostbusters": {
|
|
"source": "iana",
|
|
"extensions": ["gbr"]
|
|
},
|
|
"application/rpki-manifest": {
|
|
"source": "iana",
|
|
"extensions": ["mft"]
|
|
},
|
|
"application/rpki-publication": {
|
|
"source": "iana"
|
|
},
|
|
"application/rpki-roa": {
|
|
"source": "iana",
|
|
"extensions": ["roa"]
|
|
},
|
|
"application/rpki-updown": {
|
|
"source": "iana"
|
|
},
|
|
"application/rsd+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["rsd"]
|
|
},
|
|
"application/rss+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["rss"]
|
|
},
|
|
"application/rtf": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rtf"]
|
|
},
|
|
"application/rtploopback": {
|
|
"source": "iana"
|
|
},
|
|
"application/rtx": {
|
|
"source": "iana"
|
|
},
|
|
"application/samlassertion+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/samlmetadata+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/sbe": {
|
|
"source": "iana"
|
|
},
|
|
"application/sbml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["sbml"]
|
|
},
|
|
"application/scaip+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/scim+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/scvp-cv-request": {
|
|
"source": "iana",
|
|
"extensions": ["scq"]
|
|
},
|
|
"application/scvp-cv-response": {
|
|
"source": "iana",
|
|
"extensions": ["scs"]
|
|
},
|
|
"application/scvp-vp-request": {
|
|
"source": "iana",
|
|
"extensions": ["spq"]
|
|
},
|
|
"application/scvp-vp-response": {
|
|
"source": "iana",
|
|
"extensions": ["spp"]
|
|
},
|
|
"application/sdp": {
|
|
"source": "iana",
|
|
"extensions": ["sdp"]
|
|
},
|
|
"application/secevent+jwt": {
|
|
"source": "iana"
|
|
},
|
|
"application/senml+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/senml+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/senml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["senmlx"]
|
|
},
|
|
"application/senml-etch+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/senml-etch+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/senml-exi": {
|
|
"source": "iana"
|
|
},
|
|
"application/sensml+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/sensml+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/sensml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["sensmlx"]
|
|
},
|
|
"application/sensml-exi": {
|
|
"source": "iana"
|
|
},
|
|
"application/sep+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/sep-exi": {
|
|
"source": "iana"
|
|
},
|
|
"application/session-info": {
|
|
"source": "iana"
|
|
},
|
|
"application/set-payment": {
|
|
"source": "iana"
|
|
},
|
|
"application/set-payment-initiation": {
|
|
"source": "iana",
|
|
"extensions": ["setpay"]
|
|
},
|
|
"application/set-registration": {
|
|
"source": "iana"
|
|
},
|
|
"application/set-registration-initiation": {
|
|
"source": "iana",
|
|
"extensions": ["setreg"]
|
|
},
|
|
"application/sgml": {
|
|
"source": "iana"
|
|
},
|
|
"application/sgml-open-catalog": {
|
|
"source": "iana"
|
|
},
|
|
"application/shf+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["shf"]
|
|
},
|
|
"application/sieve": {
|
|
"source": "iana",
|
|
"extensions": ["siv","sieve"]
|
|
},
|
|
"application/simple-filter+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/simple-message-summary": {
|
|
"source": "iana"
|
|
},
|
|
"application/simplesymbolcontainer": {
|
|
"source": "iana"
|
|
},
|
|
"application/sipc": {
|
|
"source": "iana"
|
|
},
|
|
"application/slate": {
|
|
"source": "iana"
|
|
},
|
|
"application/smil": {
|
|
"source": "iana"
|
|
},
|
|
"application/smil+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["smi","smil"]
|
|
},
|
|
"application/smpte336m": {
|
|
"source": "iana"
|
|
},
|
|
"application/soap+fastinfoset": {
|
|
"source": "iana"
|
|
},
|
|
"application/soap+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/sparql-query": {
|
|
"source": "iana",
|
|
"extensions": ["rq"]
|
|
},
|
|
"application/sparql-results+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["srx"]
|
|
},
|
|
"application/spirits-event+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/sql": {
|
|
"source": "iana"
|
|
},
|
|
"application/srgs": {
|
|
"source": "iana",
|
|
"extensions": ["gram"]
|
|
},
|
|
"application/srgs+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["grxml"]
|
|
},
|
|
"application/sru+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["sru"]
|
|
},
|
|
"application/ssdl+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["ssdl"]
|
|
},
|
|
"application/ssml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ssml"]
|
|
},
|
|
"application/stix+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/swid+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["swidtag"]
|
|
},
|
|
"application/tamp-apex-update": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-apex-update-confirm": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-community-update": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-community-update-confirm": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-error": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-sequence-adjust": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-sequence-adjust-confirm": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-status-query": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-status-response": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-update": {
|
|
"source": "iana"
|
|
},
|
|
"application/tamp-update-confirm": {
|
|
"source": "iana"
|
|
},
|
|
"application/tar": {
|
|
"compressible": true
|
|
},
|
|
"application/taxii+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/td+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/tei+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["tei","teicorpus"]
|
|
},
|
|
"application/tetra_isi": {
|
|
"source": "iana"
|
|
},
|
|
"application/thraud+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["tfi"]
|
|
},
|
|
"application/timestamp-query": {
|
|
"source": "iana"
|
|
},
|
|
"application/timestamp-reply": {
|
|
"source": "iana"
|
|
},
|
|
"application/timestamped-data": {
|
|
"source": "iana",
|
|
"extensions": ["tsd"]
|
|
},
|
|
"application/tlsrpt+gzip": {
|
|
"source": "iana"
|
|
},
|
|
"application/tlsrpt+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/tnauthlist": {
|
|
"source": "iana"
|
|
},
|
|
"application/toml": {
|
|
"compressible": true,
|
|
"extensions": ["toml"]
|
|
},
|
|
"application/trickle-ice-sdpfrag": {
|
|
"source": "iana"
|
|
},
|
|
"application/trig": {
|
|
"source": "iana"
|
|
},
|
|
"application/ttml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ttml"]
|
|
},
|
|
"application/tve-trigger": {
|
|
"source": "iana"
|
|
},
|
|
"application/tzif": {
|
|
"source": "iana"
|
|
},
|
|
"application/tzif-leap": {
|
|
"source": "iana"
|
|
},
|
|
"application/ulpfec": {
|
|
"source": "iana"
|
|
},
|
|
"application/urc-grpsheet+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/urc-ressheet+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rsheet"]
|
|
},
|
|
"application/urc-targetdesc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/urc-uisocketdesc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vcard+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vcard+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vemmi": {
|
|
"source": "iana"
|
|
},
|
|
"application/vividence.scriptfile": {
|
|
"source": "apache"
|
|
},
|
|
"application/vnd.1000minds.decision-model+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["1km"]
|
|
},
|
|
"application/vnd.3gpp-prose+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp-prose-pc3ch+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp-v2x-local-service-information": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp.access-transfer-events+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.bsf+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.gmop+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mc-signalling-ear": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-affiliation-command+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcdata-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcdata-payload": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-service-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcdata-signalling": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-ue-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcdata-user-profile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-affiliation-command+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-floor-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-location-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-service-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-signed+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-init-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcptt-user-profile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-command+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-location-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-service-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-transmission-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-ue-config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-user-profile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.mid-call+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.pic-bw-large": {
|
|
"source": "iana",
|
|
"extensions": ["plb"]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-small": {
|
|
"source": "iana",
|
|
"extensions": ["psb"]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-var": {
|
|
"source": "iana",
|
|
"extensions": ["pvb"]
|
|
},
|
|
"application/vnd.3gpp.sms": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp.sms+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.srvcc-ext+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.srvcc-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.state-and-event-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp.ussd+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp2.bcmcsinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.3gpp2.sms": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3gpp2.tcap": {
|
|
"source": "iana",
|
|
"extensions": ["tcap"]
|
|
},
|
|
"application/vnd.3lightssoftware.imagescal": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.3m.post-it-notes": {
|
|
"source": "iana",
|
|
"extensions": ["pwn"]
|
|
},
|
|
"application/vnd.accpac.simply.aso": {
|
|
"source": "iana",
|
|
"extensions": ["aso"]
|
|
},
|
|
"application/vnd.accpac.simply.imp": {
|
|
"source": "iana",
|
|
"extensions": ["imp"]
|
|
},
|
|
"application/vnd.acucobol": {
|
|
"source": "iana",
|
|
"extensions": ["acu"]
|
|
},
|
|
"application/vnd.acucorp": {
|
|
"source": "iana",
|
|
"extensions": ["atc","acutc"]
|
|
},
|
|
"application/vnd.adobe.air-application-installer-package+zip": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["air"]
|
|
},
|
|
"application/vnd.adobe.flash.movie": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.adobe.formscentral.fcdt": {
|
|
"source": "iana",
|
|
"extensions": ["fcdt"]
|
|
},
|
|
"application/vnd.adobe.fxp": {
|
|
"source": "iana",
|
|
"extensions": ["fxp","fxpl"]
|
|
},
|
|
"application/vnd.adobe.partial-upload": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.adobe.xdp+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xdp"]
|
|
},
|
|
"application/vnd.adobe.xfdf": {
|
|
"source": "iana",
|
|
"extensions": ["xfdf"]
|
|
},
|
|
"application/vnd.aether.imp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata-pagedef": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.foca-charset": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codedfont": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codepage": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca-formdef": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca-mediummap": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca-objectcontainer": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca-overlay": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.afpc.modca-pagesegment": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ah-barcode": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ahead.space": {
|
|
"source": "iana",
|
|
"extensions": ["ahead"]
|
|
},
|
|
"application/vnd.airzip.filesecure.azf": {
|
|
"source": "iana",
|
|
"extensions": ["azf"]
|
|
},
|
|
"application/vnd.airzip.filesecure.azs": {
|
|
"source": "iana",
|
|
"extensions": ["azs"]
|
|
},
|
|
"application/vnd.amadeus+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.amazon.ebook": {
|
|
"source": "apache",
|
|
"extensions": ["azw"]
|
|
},
|
|
"application/vnd.amazon.mobi8-ebook": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.americandynamics.acc": {
|
|
"source": "iana",
|
|
"extensions": ["acc"]
|
|
},
|
|
"application/vnd.amiga.ami": {
|
|
"source": "iana",
|
|
"extensions": ["ami"]
|
|
},
|
|
"application/vnd.amundsen.maze+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.android.ota": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.android.package-archive": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["apk"]
|
|
},
|
|
"application/vnd.anki": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.anser-web-certificate-issue-initiation": {
|
|
"source": "iana",
|
|
"extensions": ["cii"]
|
|
},
|
|
"application/vnd.anser-web-funds-transfer-initiation": {
|
|
"source": "apache",
|
|
"extensions": ["fti"]
|
|
},
|
|
"application/vnd.antix.game-component": {
|
|
"source": "iana",
|
|
"extensions": ["atx"]
|
|
},
|
|
"application/vnd.apache.thrift.binary": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.apache.thrift.compact": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.apache.thrift.json": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.api+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.aplextor.warrp+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.apothekende.reservation+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.apple.installer+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mpkg"]
|
|
},
|
|
"application/vnd.apple.keynote": {
|
|
"source": "iana",
|
|
"extensions": ["keynote"]
|
|
},
|
|
"application/vnd.apple.mpegurl": {
|
|
"source": "iana",
|
|
"extensions": ["m3u8"]
|
|
},
|
|
"application/vnd.apple.numbers": {
|
|
"source": "iana",
|
|
"extensions": ["numbers"]
|
|
},
|
|
"application/vnd.apple.pages": {
|
|
"source": "iana",
|
|
"extensions": ["pages"]
|
|
},
|
|
"application/vnd.apple.pkpass": {
|
|
"compressible": false,
|
|
"extensions": ["pkpass"]
|
|
},
|
|
"application/vnd.arastra.swi": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.aristanetworks.swi": {
|
|
"source": "iana",
|
|
"extensions": ["swi"]
|
|
},
|
|
"application/vnd.artisan+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.artsquare": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.astraea-software.iota": {
|
|
"source": "iana",
|
|
"extensions": ["iota"]
|
|
},
|
|
"application/vnd.audiograph": {
|
|
"source": "iana",
|
|
"extensions": ["aep"]
|
|
},
|
|
"application/vnd.autopackage": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.avalon+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.avistar+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.balsamiq.bmml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["bmml"]
|
|
},
|
|
"application/vnd.balsamiq.bmpr": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.banana-accounting": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bbf.usp.error": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.bekitzur-stech+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.bint.med-content": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.biopax.rdf+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.blink-idb-value-wrapper": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.blueice.multipass": {
|
|
"source": "iana",
|
|
"extensions": ["mpm"]
|
|
},
|
|
"application/vnd.bluetooth.ep.oob": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bluetooth.le.oob": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bmi": {
|
|
"source": "iana",
|
|
"extensions": ["bmi"]
|
|
},
|
|
"application/vnd.bpf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.bpf3": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.businessobjects": {
|
|
"source": "iana",
|
|
"extensions": ["rep"]
|
|
},
|
|
"application/vnd.byu.uapi+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.cab-jscript": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.canon-cpdl": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.canon-lips": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.capasystems-pg+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.cendio.thinlinc.clientconf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.century-systems.tcp_stream": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.chemdraw+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["cdxml"]
|
|
},
|
|
"application/vnd.chess-pgn": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.chipnuts.karaoke-mmd": {
|
|
"source": "iana",
|
|
"extensions": ["mmd"]
|
|
},
|
|
"application/vnd.ciedi": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.cinderella": {
|
|
"source": "iana",
|
|
"extensions": ["cdy"]
|
|
},
|
|
"application/vnd.cirpack.isdn-ext": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.citationstyles.style+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["csl"]
|
|
},
|
|
"application/vnd.claymore": {
|
|
"source": "iana",
|
|
"extensions": ["cla"]
|
|
},
|
|
"application/vnd.cloanto.rp9": {
|
|
"source": "iana",
|
|
"extensions": ["rp9"]
|
|
},
|
|
"application/vnd.clonk.c4group": {
|
|
"source": "iana",
|
|
"extensions": ["c4g","c4d","c4f","c4p","c4u"]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config": {
|
|
"source": "iana",
|
|
"extensions": ["c11amc"]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config-pkg": {
|
|
"source": "iana",
|
|
"extensions": ["c11amz"]
|
|
},
|
|
"application/vnd.coffeescript": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document-template": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation-template": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet-template": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.collection+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.collection.doc+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.collection.next+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.comicbook+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.comicbook-rar": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.commerce-battelle": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.commonspace": {
|
|
"source": "iana",
|
|
"extensions": ["csp"]
|
|
},
|
|
"application/vnd.contact.cmsg": {
|
|
"source": "iana",
|
|
"extensions": ["cdbcmsg"]
|
|
},
|
|
"application/vnd.coreos.ignition+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.cosmocaller": {
|
|
"source": "iana",
|
|
"extensions": ["cmc"]
|
|
},
|
|
"application/vnd.crick.clicker": {
|
|
"source": "iana",
|
|
"extensions": ["clkx"]
|
|
},
|
|
"application/vnd.crick.clicker.keyboard": {
|
|
"source": "iana",
|
|
"extensions": ["clkk"]
|
|
},
|
|
"application/vnd.crick.clicker.palette": {
|
|
"source": "iana",
|
|
"extensions": ["clkp"]
|
|
},
|
|
"application/vnd.crick.clicker.template": {
|
|
"source": "iana",
|
|
"extensions": ["clkt"]
|
|
},
|
|
"application/vnd.crick.clicker.wordbank": {
|
|
"source": "iana",
|
|
"extensions": ["clkw"]
|
|
},
|
|
"application/vnd.criticaltools.wbs+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["wbs"]
|
|
},
|
|
"application/vnd.cryptii.pipe+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.crypto-shade-file": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ctc-posml": {
|
|
"source": "iana",
|
|
"extensions": ["pml"]
|
|
},
|
|
"application/vnd.ctct.ws+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.cups-pdf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.cups-postscript": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.cups-ppd": {
|
|
"source": "iana",
|
|
"extensions": ["ppd"]
|
|
},
|
|
"application/vnd.cups-raster": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.cups-raw": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.curl": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.curl.car": {
|
|
"source": "apache",
|
|
"extensions": ["car"]
|
|
},
|
|
"application/vnd.curl.pcurl": {
|
|
"source": "apache",
|
|
"extensions": ["pcurl"]
|
|
},
|
|
"application/vnd.cyan.dean.root+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.cybank": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.d2l.coursepackage1p0+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.dart": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["dart"]
|
|
},
|
|
"application/vnd.data-vision.rdz": {
|
|
"source": "iana",
|
|
"extensions": ["rdz"]
|
|
},
|
|
"application/vnd.datapackage+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dataresource+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dbf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.debian.binary-package": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dece.data": {
|
|
"source": "iana",
|
|
"extensions": ["uvf","uvvf","uvd","uvvd"]
|
|
},
|
|
"application/vnd.dece.ttml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["uvt","uvvt"]
|
|
},
|
|
"application/vnd.dece.unspecified": {
|
|
"source": "iana",
|
|
"extensions": ["uvx","uvvx"]
|
|
},
|
|
"application/vnd.dece.zip": {
|
|
"source": "iana",
|
|
"extensions": ["uvz","uvvz"]
|
|
},
|
|
"application/vnd.denovo.fcselayout-link": {
|
|
"source": "iana",
|
|
"extensions": ["fe_launch"]
|
|
},
|
|
"application/vnd.desmume.movie": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dir-bi.plate-dl-nosuffix": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dm.delegation+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dna": {
|
|
"source": "iana",
|
|
"extensions": ["dna"]
|
|
},
|
|
"application/vnd.document+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dolby.mlp": {
|
|
"source": "apache",
|
|
"extensions": ["mlp"]
|
|
},
|
|
"application/vnd.dolby.mobile.1": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dolby.mobile.2": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.doremir.scorecloud-binary-document": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dpgraph": {
|
|
"source": "iana",
|
|
"extensions": ["dpg"]
|
|
},
|
|
"application/vnd.dreamfactory": {
|
|
"source": "iana",
|
|
"extensions": ["dfac"]
|
|
},
|
|
"application/vnd.drive+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ds-keypoint": {
|
|
"source": "apache",
|
|
"extensions": ["kpxx"]
|
|
},
|
|
"application/vnd.dtg.local": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dtg.local.flash": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dtg.local.html": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ait": {
|
|
"source": "iana",
|
|
"extensions": ["ait"]
|
|
},
|
|
"application/vnd.dvb.dvbisl+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.dvbj": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.esgcontainer": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcdftnotifaccess": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess2": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgpdd": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcroaming": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-base": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-enhancement": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.notif-aggregate-root+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-container+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-generic+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-ia-msglist+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-response+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.notif-init+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.dvb.pfr": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dvb.service": {
|
|
"source": "iana",
|
|
"extensions": ["svc"]
|
|
},
|
|
"application/vnd.dxr": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.dynageo": {
|
|
"source": "iana",
|
|
"extensions": ["geo"]
|
|
},
|
|
"application/vnd.dzr": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.easykaraoke.cdgdownload": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecdis-update": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecip.rlp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecowin.chart": {
|
|
"source": "iana",
|
|
"extensions": ["mag"]
|
|
},
|
|
"application/vnd.ecowin.filerequest": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecowin.fileupdate": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecowin.series": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesrequest": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesupdate": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.efi.img": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.efi.iso": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.emclient.accessrequest+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.enliven": {
|
|
"source": "iana",
|
|
"extensions": ["nml"]
|
|
},
|
|
"application/vnd.enphase.envoy": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.eprints.data+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.epson.esf": {
|
|
"source": "iana",
|
|
"extensions": ["esf"]
|
|
},
|
|
"application/vnd.epson.msf": {
|
|
"source": "iana",
|
|
"extensions": ["msf"]
|
|
},
|
|
"application/vnd.epson.quickanime": {
|
|
"source": "iana",
|
|
"extensions": ["qam"]
|
|
},
|
|
"application/vnd.epson.salt": {
|
|
"source": "iana",
|
|
"extensions": ["slt"]
|
|
},
|
|
"application/vnd.epson.ssf": {
|
|
"source": "iana",
|
|
"extensions": ["ssf"]
|
|
},
|
|
"application/vnd.ericsson.quickcall": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.espass-espass+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.eszigno3+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["es3","et3"]
|
|
},
|
|
"application/vnd.etsi.aoc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.asic-e+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.etsi.asic-s+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.etsi.cug+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvcommand+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvdiscovery+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvprofile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvsad-bc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvsad-cod+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvsad-npvr+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvservice+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvsync+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.iptvueprofile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.mcid+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.mheg5": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.etsi.overload-control-policy-dataset+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.pstn+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.sci+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.simservs+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.timestamp-token": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.etsi.tsl+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.etsi.tsl.der": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.eudora.data": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.profile": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.settings": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.theme": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.exstream-empower+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.exstream-package": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ezpix-album": {
|
|
"source": "iana",
|
|
"extensions": ["ez2"]
|
|
},
|
|
"application/vnd.ezpix-package": {
|
|
"source": "iana",
|
|
"extensions": ["ez3"]
|
|
},
|
|
"application/vnd.f-secure.mobile": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fastcopy-disk-image": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fdf": {
|
|
"source": "iana",
|
|
"extensions": ["fdf"]
|
|
},
|
|
"application/vnd.fdsn.mseed": {
|
|
"source": "iana",
|
|
"extensions": ["mseed"]
|
|
},
|
|
"application/vnd.fdsn.seed": {
|
|
"source": "iana",
|
|
"extensions": ["seed","dataless"]
|
|
},
|
|
"application/vnd.ffsns": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ficlab.flb+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.filmit.zfc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fints": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.firemonkeys.cloudcell": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.flographit": {
|
|
"source": "iana",
|
|
"extensions": ["gph"]
|
|
},
|
|
"application/vnd.fluxtime.clip": {
|
|
"source": "iana",
|
|
"extensions": ["ftc"]
|
|
},
|
|
"application/vnd.font-fontforge-sfd": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.framemaker": {
|
|
"source": "iana",
|
|
"extensions": ["fm","frame","maker","book"]
|
|
},
|
|
"application/vnd.frogans.fnc": {
|
|
"source": "iana",
|
|
"extensions": ["fnc"]
|
|
},
|
|
"application/vnd.frogans.ltf": {
|
|
"source": "iana",
|
|
"extensions": ["ltf"]
|
|
},
|
|
"application/vnd.fsc.weblaunch": {
|
|
"source": "iana",
|
|
"extensions": ["fsc"]
|
|
},
|
|
"application/vnd.fujitsu.oasys": {
|
|
"source": "iana",
|
|
"extensions": ["oas"]
|
|
},
|
|
"application/vnd.fujitsu.oasys2": {
|
|
"source": "iana",
|
|
"extensions": ["oa2"]
|
|
},
|
|
"application/vnd.fujitsu.oasys3": {
|
|
"source": "iana",
|
|
"extensions": ["oa3"]
|
|
},
|
|
"application/vnd.fujitsu.oasysgp": {
|
|
"source": "iana",
|
|
"extensions": ["fg5"]
|
|
},
|
|
"application/vnd.fujitsu.oasysprs": {
|
|
"source": "iana",
|
|
"extensions": ["bh2"]
|
|
},
|
|
"application/vnd.fujixerox.art-ex": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fujixerox.art4": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fujixerox.ddd": {
|
|
"source": "iana",
|
|
"extensions": ["ddd"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks": {
|
|
"source": "iana",
|
|
"extensions": ["xdw"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.binder": {
|
|
"source": "iana",
|
|
"extensions": ["xbd"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.container": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fujixerox.hbpl": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.fut-misnet": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.futoin+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.futoin+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.fuzzysheet": {
|
|
"source": "iana",
|
|
"extensions": ["fzs"]
|
|
},
|
|
"application/vnd.genomatix.tuxedo": {
|
|
"source": "iana",
|
|
"extensions": ["txd"]
|
|
},
|
|
"application/vnd.gentics.grd+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.geo+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.geocube+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.geogebra.file": {
|
|
"source": "iana",
|
|
"extensions": ["ggb"]
|
|
},
|
|
"application/vnd.geogebra.tool": {
|
|
"source": "iana",
|
|
"extensions": ["ggt"]
|
|
},
|
|
"application/vnd.geometry-explorer": {
|
|
"source": "iana",
|
|
"extensions": ["gex","gre"]
|
|
},
|
|
"application/vnd.geonext": {
|
|
"source": "iana",
|
|
"extensions": ["gxt"]
|
|
},
|
|
"application/vnd.geoplan": {
|
|
"source": "iana",
|
|
"extensions": ["g2w"]
|
|
},
|
|
"application/vnd.geospace": {
|
|
"source": "iana",
|
|
"extensions": ["g3w"]
|
|
},
|
|
"application/vnd.gerber": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt-response": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.gmx": {
|
|
"source": "iana",
|
|
"extensions": ["gmx"]
|
|
},
|
|
"application/vnd.google-apps.document": {
|
|
"compressible": false,
|
|
"extensions": ["gdoc"]
|
|
},
|
|
"application/vnd.google-apps.presentation": {
|
|
"compressible": false,
|
|
"extensions": ["gslides"]
|
|
},
|
|
"application/vnd.google-apps.spreadsheet": {
|
|
"compressible": false,
|
|
"extensions": ["gsheet"]
|
|
},
|
|
"application/vnd.google-earth.kml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["kml"]
|
|
},
|
|
"application/vnd.google-earth.kmz": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["kmz"]
|
|
},
|
|
"application/vnd.gov.sk.e-form+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.gov.sk.e-form+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.gov.sk.xmldatacontainer+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.grafeq": {
|
|
"source": "iana",
|
|
"extensions": ["gqf","gqs"]
|
|
},
|
|
"application/vnd.gridmp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.groove-account": {
|
|
"source": "iana",
|
|
"extensions": ["gac"]
|
|
},
|
|
"application/vnd.groove-help": {
|
|
"source": "iana",
|
|
"extensions": ["ghf"]
|
|
},
|
|
"application/vnd.groove-identity-message": {
|
|
"source": "iana",
|
|
"extensions": ["gim"]
|
|
},
|
|
"application/vnd.groove-injector": {
|
|
"source": "iana",
|
|
"extensions": ["grv"]
|
|
},
|
|
"application/vnd.groove-tool-message": {
|
|
"source": "iana",
|
|
"extensions": ["gtm"]
|
|
},
|
|
"application/vnd.groove-tool-template": {
|
|
"source": "iana",
|
|
"extensions": ["tpl"]
|
|
},
|
|
"application/vnd.groove-vcard": {
|
|
"source": "iana",
|
|
"extensions": ["vcg"]
|
|
},
|
|
"application/vnd.hal+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hal+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["hal"]
|
|
},
|
|
"application/vnd.handheld-entertainment+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["zmm"]
|
|
},
|
|
"application/vnd.hbci": {
|
|
"source": "iana",
|
|
"extensions": ["hbci"]
|
|
},
|
|
"application/vnd.hc+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hcl-bireports": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.hdt": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.heroku+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hhe.lesson-player": {
|
|
"source": "iana",
|
|
"extensions": ["les"]
|
|
},
|
|
"application/vnd.hp-hpgl": {
|
|
"source": "iana",
|
|
"extensions": ["hpgl"]
|
|
},
|
|
"application/vnd.hp-hpid": {
|
|
"source": "iana",
|
|
"extensions": ["hpid"]
|
|
},
|
|
"application/vnd.hp-hps": {
|
|
"source": "iana",
|
|
"extensions": ["hps"]
|
|
},
|
|
"application/vnd.hp-jlyt": {
|
|
"source": "iana",
|
|
"extensions": ["jlt"]
|
|
},
|
|
"application/vnd.hp-pcl": {
|
|
"source": "iana",
|
|
"extensions": ["pcl"]
|
|
},
|
|
"application/vnd.hp-pclxl": {
|
|
"source": "iana",
|
|
"extensions": ["pclxl"]
|
|
},
|
|
"application/vnd.httphone": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.hydrostatix.sof-data": {
|
|
"source": "iana",
|
|
"extensions": ["sfd-hdstx"]
|
|
},
|
|
"application/vnd.hyper+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hyper-item+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hyperdrive+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.hzn-3d-crossword": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ibm.afplinedata": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ibm.electronic-media": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ibm.minipay": {
|
|
"source": "iana",
|
|
"extensions": ["mpy"]
|
|
},
|
|
"application/vnd.ibm.modcap": {
|
|
"source": "iana",
|
|
"extensions": ["afp","listafp","list3820"]
|
|
},
|
|
"application/vnd.ibm.rights-management": {
|
|
"source": "iana",
|
|
"extensions": ["irm"]
|
|
},
|
|
"application/vnd.ibm.secure-container": {
|
|
"source": "iana",
|
|
"extensions": ["sc"]
|
|
},
|
|
"application/vnd.iccprofile": {
|
|
"source": "iana",
|
|
"extensions": ["icc","icm"]
|
|
},
|
|
"application/vnd.ieee.1905": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.igloader": {
|
|
"source": "iana",
|
|
"extensions": ["igl"]
|
|
},
|
|
"application/vnd.imagemeter.folder+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.imagemeter.image+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.immervision-ivp": {
|
|
"source": "iana",
|
|
"extensions": ["ivp"]
|
|
},
|
|
"application/vnd.immervision-ivu": {
|
|
"source": "iana",
|
|
"extensions": ["ivu"]
|
|
},
|
|
"application/vnd.ims.imsccv1p1": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p2": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p3": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ims.lis.v2.result+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolconsumerprofile+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy.id+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings.simple+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.informedcontrol.rms+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.informix-visionary": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.infotech.project": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.infotech.project+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.innopath.wamp.notification": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.insors.igm": {
|
|
"source": "iana",
|
|
"extensions": ["igm"]
|
|
},
|
|
"application/vnd.intercon.formnet": {
|
|
"source": "iana",
|
|
"extensions": ["xpw","xpx"]
|
|
},
|
|
"application/vnd.intergeo": {
|
|
"source": "iana",
|
|
"extensions": ["i2g"]
|
|
},
|
|
"application/vnd.intertrust.digibox": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.intertrust.nncp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.intu.qbo": {
|
|
"source": "iana",
|
|
"extensions": ["qbo"]
|
|
},
|
|
"application/vnd.intu.qfx": {
|
|
"source": "iana",
|
|
"extensions": ["qfx"]
|
|
},
|
|
"application/vnd.iptc.g2.catalogitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.conceptitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.knowledgeitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.newsitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.newsmessage+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.packageitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.iptc.g2.planningitem+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ipunplugged.rcprofile": {
|
|
"source": "iana",
|
|
"extensions": ["rcprofile"]
|
|
},
|
|
"application/vnd.irepository.package+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["irp"]
|
|
},
|
|
"application/vnd.is-xpr": {
|
|
"source": "iana",
|
|
"extensions": ["xpr"]
|
|
},
|
|
"application/vnd.isac.fcs": {
|
|
"source": "iana",
|
|
"extensions": ["fcs"]
|
|
},
|
|
"application/vnd.iso11783-10+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.jam": {
|
|
"source": "iana",
|
|
"extensions": ["jam"]
|
|
},
|
|
"application/vnd.japannet-directory-service": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-jpnstore-wakeup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-payment-wakeup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-registration": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-registration-wakeup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-setstore-wakeup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-verification": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.japannet-verification-wakeup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.jcp.javame.midlet-rms": {
|
|
"source": "iana",
|
|
"extensions": ["rms"]
|
|
},
|
|
"application/vnd.jisp": {
|
|
"source": "iana",
|
|
"extensions": ["jisp"]
|
|
},
|
|
"application/vnd.joost.joda-archive": {
|
|
"source": "iana",
|
|
"extensions": ["joda"]
|
|
},
|
|
"application/vnd.jsk.isdn-ngn": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.kahootz": {
|
|
"source": "iana",
|
|
"extensions": ["ktz","ktr"]
|
|
},
|
|
"application/vnd.kde.karbon": {
|
|
"source": "iana",
|
|
"extensions": ["karbon"]
|
|
},
|
|
"application/vnd.kde.kchart": {
|
|
"source": "iana",
|
|
"extensions": ["chrt"]
|
|
},
|
|
"application/vnd.kde.kformula": {
|
|
"source": "iana",
|
|
"extensions": ["kfo"]
|
|
},
|
|
"application/vnd.kde.kivio": {
|
|
"source": "iana",
|
|
"extensions": ["flw"]
|
|
},
|
|
"application/vnd.kde.kontour": {
|
|
"source": "iana",
|
|
"extensions": ["kon"]
|
|
},
|
|
"application/vnd.kde.kpresenter": {
|
|
"source": "iana",
|
|
"extensions": ["kpr","kpt"]
|
|
},
|
|
"application/vnd.kde.kspread": {
|
|
"source": "iana",
|
|
"extensions": ["ksp"]
|
|
},
|
|
"application/vnd.kde.kword": {
|
|
"source": "iana",
|
|
"extensions": ["kwd","kwt"]
|
|
},
|
|
"application/vnd.kenameaapp": {
|
|
"source": "iana",
|
|
"extensions": ["htke"]
|
|
},
|
|
"application/vnd.kidspiration": {
|
|
"source": "iana",
|
|
"extensions": ["kia"]
|
|
},
|
|
"application/vnd.kinar": {
|
|
"source": "iana",
|
|
"extensions": ["kne","knp"]
|
|
},
|
|
"application/vnd.koan": {
|
|
"source": "iana",
|
|
"extensions": ["skp","skd","skt","skm"]
|
|
},
|
|
"application/vnd.kodak-descriptor": {
|
|
"source": "iana",
|
|
"extensions": ["sse"]
|
|
},
|
|
"application/vnd.las": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.las.las+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.las.las+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["lasxml"]
|
|
},
|
|
"application/vnd.laszip": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.leap+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.liberty-request+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.desktop": {
|
|
"source": "iana",
|
|
"extensions": ["lbd"]
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.exchange+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["lbe"]
|
|
},
|
|
"application/vnd.logipipe.circuit+zip": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"application/vnd.loom": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.lotus-1-2-3": {
|
|
"source": "iana",
|
|
"extensions": ["123"]
|
|
},
|
|
"application/vnd.lotus-approach": {
|
|
"source": "iana",
|
|
"extensions": ["apr"]
|
|
},
|
|
"application/vnd.lotus-freelance": {
|
|
"source": "iana",
|
|
"extensions": ["pre"]
|
|
},
|
|
"application/vnd.lotus-notes": {
|
|
"source": "iana",
|
|
"extensions": ["nsf"]
|
|
},
|
|
"application/vnd.lotus-organizer": {
|
|
"source": "iana",
|
|
"extensions": ["org"]
|
|
},
|
|
"application/vnd.lotus-screencam": {
|
|
"source": "iana",
|
|
"extensions": ["scm"]
|
|
},
|
|
"application/vnd.lotus-wordpro": {
|
|
"source": "iana",
|
|
"extensions": ["lwp"]
|
|
},
|
|
"application/vnd.macports.portpkg": {
|
|
"source": "iana",
|
|
"extensions": ["portpkg"]
|
|
},
|
|
"application/vnd.mapbox-vector-tile": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.marlin.drm.actiontoken+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.marlin.drm.conftoken+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.marlin.drm.license+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.marlin.drm.mdcf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mason+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.maxmind.maxmind-db": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mcd": {
|
|
"source": "iana",
|
|
"extensions": ["mcd"]
|
|
},
|
|
"application/vnd.medcalcdata": {
|
|
"source": "iana",
|
|
"extensions": ["mc1"]
|
|
},
|
|
"application/vnd.mediastation.cdkey": {
|
|
"source": "iana",
|
|
"extensions": ["cdkey"]
|
|
},
|
|
"application/vnd.meridian-slingshot": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mfer": {
|
|
"source": "iana",
|
|
"extensions": ["mwf"]
|
|
},
|
|
"application/vnd.mfmp": {
|
|
"source": "iana",
|
|
"extensions": ["mfm"]
|
|
},
|
|
"application/vnd.micro+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.micrografx.flo": {
|
|
"source": "iana",
|
|
"extensions": ["flo"]
|
|
},
|
|
"application/vnd.micrografx.igx": {
|
|
"source": "iana",
|
|
"extensions": ["igx"]
|
|
},
|
|
"application/vnd.microsoft.portable-executable": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.microsoft.windows.thumbnail-cache": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.miele+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.mif": {
|
|
"source": "iana",
|
|
"extensions": ["mif"]
|
|
},
|
|
"application/vnd.minisoft-hp3000-save": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mitsubishi.misty-guard.trustweb": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mobius.daf": {
|
|
"source": "iana",
|
|
"extensions": ["daf"]
|
|
},
|
|
"application/vnd.mobius.dis": {
|
|
"source": "iana",
|
|
"extensions": ["dis"]
|
|
},
|
|
"application/vnd.mobius.mbk": {
|
|
"source": "iana",
|
|
"extensions": ["mbk"]
|
|
},
|
|
"application/vnd.mobius.mqy": {
|
|
"source": "iana",
|
|
"extensions": ["mqy"]
|
|
},
|
|
"application/vnd.mobius.msl": {
|
|
"source": "iana",
|
|
"extensions": ["msl"]
|
|
},
|
|
"application/vnd.mobius.plc": {
|
|
"source": "iana",
|
|
"extensions": ["plc"]
|
|
},
|
|
"application/vnd.mobius.txf": {
|
|
"source": "iana",
|
|
"extensions": ["txf"]
|
|
},
|
|
"application/vnd.mophun.application": {
|
|
"source": "iana",
|
|
"extensions": ["mpn"]
|
|
},
|
|
"application/vnd.mophun.certificate": {
|
|
"source": "iana",
|
|
"extensions": ["mpc"]
|
|
},
|
|
"application/vnd.motorola.flexsuite": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.adsi": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.fis": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.gotap": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.kmr": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.ttc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.wem": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.motorola.iprm": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mozilla.xul+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xul"]
|
|
},
|
|
"application/vnd.ms-3mfdocument": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-artgalry": {
|
|
"source": "iana",
|
|
"extensions": ["cil"]
|
|
},
|
|
"application/vnd.ms-asf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-cab-compressed": {
|
|
"source": "iana",
|
|
"extensions": ["cab"]
|
|
},
|
|
"application/vnd.ms-color.iccprofile": {
|
|
"source": "apache"
|
|
},
|
|
"application/vnd.ms-excel": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["xls","xlm","xla","xlc","xlt","xlw"]
|
|
},
|
|
"application/vnd.ms-excel.addin.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["xlam"]
|
|
},
|
|
"application/vnd.ms-excel.sheet.binary.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["xlsb"]
|
|
},
|
|
"application/vnd.ms-excel.sheet.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["xlsm"]
|
|
},
|
|
"application/vnd.ms-excel.template.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["xltm"]
|
|
},
|
|
"application/vnd.ms-fontobject": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["eot"]
|
|
},
|
|
"application/vnd.ms-htmlhelp": {
|
|
"source": "iana",
|
|
"extensions": ["chm"]
|
|
},
|
|
"application/vnd.ms-ims": {
|
|
"source": "iana",
|
|
"extensions": ["ims"]
|
|
},
|
|
"application/vnd.ms-lrm": {
|
|
"source": "iana",
|
|
"extensions": ["lrm"]
|
|
},
|
|
"application/vnd.ms-office.activex+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-officetheme": {
|
|
"source": "iana",
|
|
"extensions": ["thmx"]
|
|
},
|
|
"application/vnd.ms-opentype": {
|
|
"source": "apache",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-outlook": {
|
|
"compressible": false,
|
|
"extensions": ["msg"]
|
|
},
|
|
"application/vnd.ms-package.obfuscated-opentype": {
|
|
"source": "apache"
|
|
},
|
|
"application/vnd.ms-pki.seccat": {
|
|
"source": "apache",
|
|
"extensions": ["cat"]
|
|
},
|
|
"application/vnd.ms-pki.stl": {
|
|
"source": "apache",
|
|
"extensions": ["stl"]
|
|
},
|
|
"application/vnd.ms-playready.initiator+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-powerpoint": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["ppt","pps","pot"]
|
|
},
|
|
"application/vnd.ms-powerpoint.addin.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["ppam"]
|
|
},
|
|
"application/vnd.ms-powerpoint.presentation.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["pptm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.slide.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["sldm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["ppsm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.template.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["potm"]
|
|
},
|
|
"application/vnd.ms-printdevicecapabilities+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-printing.printticket+xml": {
|
|
"source": "apache",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-printschematicket+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.ms-project": {
|
|
"source": "iana",
|
|
"extensions": ["mpp","mpt"]
|
|
},
|
|
"application/vnd.ms-tnef": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-windows.devicepairing": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-windows.nwprinting.oob": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-windows.printerpairing": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-windows.wsd.oob": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-chlg-req": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-resp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-chlg-req": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-resp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ms-word.document.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["docm"]
|
|
},
|
|
"application/vnd.ms-word.template.macroenabled.12": {
|
|
"source": "iana",
|
|
"extensions": ["dotm"]
|
|
},
|
|
"application/vnd.ms-works": {
|
|
"source": "iana",
|
|
"extensions": ["wps","wks","wcm","wdb"]
|
|
},
|
|
"application/vnd.ms-wpl": {
|
|
"source": "iana",
|
|
"extensions": ["wpl"]
|
|
},
|
|
"application/vnd.ms-xpsdocument": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["xps"]
|
|
},
|
|
"application/vnd.msa-disk-image": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.mseq": {
|
|
"source": "iana",
|
|
"extensions": ["mseq"]
|
|
},
|
|
"application/vnd.msign": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.multiad.creator": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.multiad.creator.cif": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.music-niff": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.musician": {
|
|
"source": "iana",
|
|
"extensions": ["mus"]
|
|
},
|
|
"application/vnd.muvee.style": {
|
|
"source": "iana",
|
|
"extensions": ["msty"]
|
|
},
|
|
"application/vnd.mynfc": {
|
|
"source": "iana",
|
|
"extensions": ["taglet"]
|
|
},
|
|
"application/vnd.ncd.control": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ncd.reference": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nearst.inv+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nervana": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.netfpx": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.neurolanguage.nlu": {
|
|
"source": "iana",
|
|
"extensions": ["nlu"]
|
|
},
|
|
"application/vnd.nimn": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nintendo.nitro.rom": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nintendo.snes.rom": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nitf": {
|
|
"source": "iana",
|
|
"extensions": ["ntf","nitf"]
|
|
},
|
|
"application/vnd.noblenet-directory": {
|
|
"source": "iana",
|
|
"extensions": ["nnd"]
|
|
},
|
|
"application/vnd.noblenet-sealer": {
|
|
"source": "iana",
|
|
"extensions": ["nns"]
|
|
},
|
|
"application/vnd.noblenet-web": {
|
|
"source": "iana",
|
|
"extensions": ["nnw"]
|
|
},
|
|
"application/vnd.nokia.catalogs": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.conml+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.conml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nokia.iptv.config+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nokia.isds-radio-presets": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nokia.landmarkcollection+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nokia.n-gage.ac+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ac"]
|
|
},
|
|
"application/vnd.nokia.n-gage.data": {
|
|
"source": "iana",
|
|
"extensions": ["ngdat"]
|
|
},
|
|
"application/vnd.nokia.n-gage.symbian.install": {
|
|
"source": "iana",
|
|
"extensions": ["n-gage"]
|
|
},
|
|
"application/vnd.nokia.ncd": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.nokia.radio-preset": {
|
|
"source": "iana",
|
|
"extensions": ["rpst"]
|
|
},
|
|
"application/vnd.nokia.radio-presets": {
|
|
"source": "iana",
|
|
"extensions": ["rpss"]
|
|
},
|
|
"application/vnd.novadigm.edm": {
|
|
"source": "iana",
|
|
"extensions": ["edm"]
|
|
},
|
|
"application/vnd.novadigm.edx": {
|
|
"source": "iana",
|
|
"extensions": ["edx"]
|
|
},
|
|
"application/vnd.novadigm.ext": {
|
|
"source": "iana",
|
|
"extensions": ["ext"]
|
|
},
|
|
"application/vnd.ntt-local.content-share": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ntt-local.file-transfer": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ntt-local.ogw_remote-access": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_remote": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_tcp_stream": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oasis.opendocument.chart": {
|
|
"source": "iana",
|
|
"extensions": ["odc"]
|
|
},
|
|
"application/vnd.oasis.opendocument.chart-template": {
|
|
"source": "iana",
|
|
"extensions": ["otc"]
|
|
},
|
|
"application/vnd.oasis.opendocument.database": {
|
|
"source": "iana",
|
|
"extensions": ["odb"]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula": {
|
|
"source": "iana",
|
|
"extensions": ["odf"]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula-template": {
|
|
"source": "iana",
|
|
"extensions": ["odft"]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["odg"]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics-template": {
|
|
"source": "iana",
|
|
"extensions": ["otg"]
|
|
},
|
|
"application/vnd.oasis.opendocument.image": {
|
|
"source": "iana",
|
|
"extensions": ["odi"]
|
|
},
|
|
"application/vnd.oasis.opendocument.image-template": {
|
|
"source": "iana",
|
|
"extensions": ["oti"]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["odp"]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation-template": {
|
|
"source": "iana",
|
|
"extensions": ["otp"]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["ods"]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet-template": {
|
|
"source": "iana",
|
|
"extensions": ["ots"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["odt"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-master": {
|
|
"source": "iana",
|
|
"extensions": ["odm"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-template": {
|
|
"source": "iana",
|
|
"extensions": ["ott"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-web": {
|
|
"source": "iana",
|
|
"extensions": ["oth"]
|
|
},
|
|
"application/vnd.obn": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ocf+cbor": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oci.image.manifest.v1+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oftn.l10n+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.contentaccessdownload+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.contentaccessstreaming+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.cspg-hexbinary": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oipf.dae.svg+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.dae.xhtml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.mippvcontrolmessage+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.pae.gem": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oipf.spdiscovery+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.spdlist+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.ueprofile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oipf.userprofile+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.olpc-sugar": {
|
|
"source": "iana",
|
|
"extensions": ["xo"]
|
|
},
|
|
"application/vnd.oma-scws-config": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-request": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-response": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.associated-procedure-parameter+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.drm-trigger+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.imd+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.ltkm": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.notification+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.provisioningtrigger": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgboot": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgdd+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.sgdu": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.simple-symbol-container": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.bcast.smartcard-trigger+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.sprov+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.bcast.stkm": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.cab-address-book+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.cab-feature-handler+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.cab-pcc+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.cab-subs-invite+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.cab-user-prefs+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.dcd": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.dcdc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.dd2+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["dd2"]
|
|
},
|
|
"application/vnd.oma.drm.risd+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.group-usage-list+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.lwm2m+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.lwm2m+tlv": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.pal+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.poc.detailed-progress-report+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.poc.final-report+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.poc.groups+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.poc.invocation-descriptor+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.poc.optimized-progress-report+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.push": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.oma.scidm.messages+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oma.xcap-directory+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.omads-email+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.omads-file+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.omads-folder+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.omaloc-supl-init": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepager": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepagertamp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepagertamx": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepagertat": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepagertatp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.onepagertatx": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.openblox.game+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["obgx"]
|
|
},
|
|
"application/vnd.openblox.game-binary": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.openeye.oeb": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.openofficeorg.extension": {
|
|
"source": "apache",
|
|
"extensions": ["oxt"]
|
|
},
|
|
"application/vnd.openstreetmap.data+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["osm"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.custom-properties+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawing+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.extended-properties+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["pptx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide": {
|
|
"source": "iana",
|
|
"extensions": ["sldx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
|
|
"source": "iana",
|
|
"extensions": ["ppsx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template": {
|
|
"source": "iana",
|
|
"extensions": ["potx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["xlsx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
|
|
"source": "iana",
|
|
"extensions": ["xltx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.theme+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.themeoverride+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.vmldrawing": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["docx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
|
|
"source": "iana",
|
|
"extensions": ["dotx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-package.core-properties+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.openxmlformats-package.relationships+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oracle.resource+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.orange.indata": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.osa.netdeploy": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.osgeo.mapguide.package": {
|
|
"source": "iana",
|
|
"extensions": ["mgp"]
|
|
},
|
|
"application/vnd.osgi.bundle": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.osgi.dp": {
|
|
"source": "iana",
|
|
"extensions": ["dp"]
|
|
},
|
|
"application/vnd.osgi.subsystem": {
|
|
"source": "iana",
|
|
"extensions": ["esa"]
|
|
},
|
|
"application/vnd.otps.ct-kip+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.oxli.countgraph": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.pagerduty+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.palm": {
|
|
"source": "iana",
|
|
"extensions": ["pdb","pqa","oprc"]
|
|
},
|
|
"application/vnd.panoply": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.paos.xml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.patentdive": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.patientecommsdoc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.pawaafile": {
|
|
"source": "iana",
|
|
"extensions": ["paw"]
|
|
},
|
|
"application/vnd.pcos": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.pg.format": {
|
|
"source": "iana",
|
|
"extensions": ["str"]
|
|
},
|
|
"application/vnd.pg.osasli": {
|
|
"source": "iana",
|
|
"extensions": ["ei6"]
|
|
},
|
|
"application/vnd.piaccess.application-licence": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.picsel": {
|
|
"source": "iana",
|
|
"extensions": ["efif"]
|
|
},
|
|
"application/vnd.pmi.widget": {
|
|
"source": "iana",
|
|
"extensions": ["wg"]
|
|
},
|
|
"application/vnd.poc.group-advertisement+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.pocketlearn": {
|
|
"source": "iana",
|
|
"extensions": ["plf"]
|
|
},
|
|
"application/vnd.powerbuilder6": {
|
|
"source": "iana",
|
|
"extensions": ["pbd"]
|
|
},
|
|
"application/vnd.powerbuilder6-s": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.powerbuilder7": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.powerbuilder7-s": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.powerbuilder75": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.powerbuilder75-s": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.preminet": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.previewsystems.box": {
|
|
"source": "iana",
|
|
"extensions": ["box"]
|
|
},
|
|
"application/vnd.proteus.magazine": {
|
|
"source": "iana",
|
|
"extensions": ["mgz"]
|
|
},
|
|
"application/vnd.psfs": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.publishare-delta-tree": {
|
|
"source": "iana",
|
|
"extensions": ["qps"]
|
|
},
|
|
"application/vnd.pvi.ptid1": {
|
|
"source": "iana",
|
|
"extensions": ["ptid"]
|
|
},
|
|
"application/vnd.pwg-multiplexed": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.pwg-xhtml-print+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.qualcomm.brew-app-res": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.quarantainenet": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.quark.quarkxpress": {
|
|
"source": "iana",
|
|
"extensions": ["qxd","qxt","qwd","qwt","qxl","qxb"]
|
|
},
|
|
"application/vnd.quobject-quoxdocument": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.radisys.moml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-audit+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conf+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conn+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-audit-dialog+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-audit-stream+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-conf+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-base+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-detect+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-group+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-speech+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-transform+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.rainstor.data": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.rapid": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.rar": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.realvnc.bed": {
|
|
"source": "iana",
|
|
"extensions": ["bed"]
|
|
},
|
|
"application/vnd.recordare.musicxml": {
|
|
"source": "iana",
|
|
"extensions": ["mxl"]
|
|
},
|
|
"application/vnd.recordare.musicxml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["musicxml"]
|
|
},
|
|
"application/vnd.renlearn.rlprint": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.restful+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.rig.cryptonote": {
|
|
"source": "iana",
|
|
"extensions": ["cryptonote"]
|
|
},
|
|
"application/vnd.rim.cod": {
|
|
"source": "apache",
|
|
"extensions": ["cod"]
|
|
},
|
|
"application/vnd.rn-realmedia": {
|
|
"source": "apache",
|
|
"extensions": ["rm"]
|
|
},
|
|
"application/vnd.rn-realmedia-vbr": {
|
|
"source": "apache",
|
|
"extensions": ["rmvb"]
|
|
},
|
|
"application/vnd.route66.link66+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["link66"]
|
|
},
|
|
"application/vnd.rs-274x": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ruckus.download": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.s3sms": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sailingtracker.track": {
|
|
"source": "iana",
|
|
"extensions": ["st"]
|
|
},
|
|
"application/vnd.sar": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sbm.cid": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sbm.mid2": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.scribus": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.3df": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.csf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.doc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.eml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.mht": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.net": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.ppt": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.tiff": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealed.xls": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.html": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.pdf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.seemail": {
|
|
"source": "iana",
|
|
"extensions": ["see"]
|
|
},
|
|
"application/vnd.sema": {
|
|
"source": "iana",
|
|
"extensions": ["sema"]
|
|
},
|
|
"application/vnd.semd": {
|
|
"source": "iana",
|
|
"extensions": ["semd"]
|
|
},
|
|
"application/vnd.semf": {
|
|
"source": "iana",
|
|
"extensions": ["semf"]
|
|
},
|
|
"application/vnd.shade-save-file": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.shana.informed.formdata": {
|
|
"source": "iana",
|
|
"extensions": ["ifm"]
|
|
},
|
|
"application/vnd.shana.informed.formtemplate": {
|
|
"source": "iana",
|
|
"extensions": ["itp"]
|
|
},
|
|
"application/vnd.shana.informed.interchange": {
|
|
"source": "iana",
|
|
"extensions": ["iif"]
|
|
},
|
|
"application/vnd.shana.informed.package": {
|
|
"source": "iana",
|
|
"extensions": ["ipk"]
|
|
},
|
|
"application/vnd.shootproof+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.shopkick+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.shp": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.shx": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sigrok.session": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.simtech-mindmapper": {
|
|
"source": "iana",
|
|
"extensions": ["twd","twds"]
|
|
},
|
|
"application/vnd.siren+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.smaf": {
|
|
"source": "iana",
|
|
"extensions": ["mmf"]
|
|
},
|
|
"application/vnd.smart.notebook": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.smart.teacher": {
|
|
"source": "iana",
|
|
"extensions": ["teacher"]
|
|
},
|
|
"application/vnd.snesdev-page-table": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.software602.filler.form+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["fo"]
|
|
},
|
|
"application/vnd.software602.filler.form-xml-zip": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.solent.sdkm+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["sdkm","sdkd"]
|
|
},
|
|
"application/vnd.spotfire.dxp": {
|
|
"source": "iana",
|
|
"extensions": ["dxp"]
|
|
},
|
|
"application/vnd.spotfire.sfs": {
|
|
"source": "iana",
|
|
"extensions": ["sfs"]
|
|
},
|
|
"application/vnd.sqlite3": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sss-cod": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sss-dtf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sss-ntf": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.stardivision.calc": {
|
|
"source": "apache",
|
|
"extensions": ["sdc"]
|
|
},
|
|
"application/vnd.stardivision.draw": {
|
|
"source": "apache",
|
|
"extensions": ["sda"]
|
|
},
|
|
"application/vnd.stardivision.impress": {
|
|
"source": "apache",
|
|
"extensions": ["sdd"]
|
|
},
|
|
"application/vnd.stardivision.math": {
|
|
"source": "apache",
|
|
"extensions": ["smf"]
|
|
},
|
|
"application/vnd.stardivision.writer": {
|
|
"source": "apache",
|
|
"extensions": ["sdw","vor"]
|
|
},
|
|
"application/vnd.stardivision.writer-global": {
|
|
"source": "apache",
|
|
"extensions": ["sgl"]
|
|
},
|
|
"application/vnd.stepmania.package": {
|
|
"source": "iana",
|
|
"extensions": ["smzip"]
|
|
},
|
|
"application/vnd.stepmania.stepchart": {
|
|
"source": "iana",
|
|
"extensions": ["sm"]
|
|
},
|
|
"application/vnd.street-stream": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.sun.wadl+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["wadl"]
|
|
},
|
|
"application/vnd.sun.xml.calc": {
|
|
"source": "apache",
|
|
"extensions": ["sxc"]
|
|
},
|
|
"application/vnd.sun.xml.calc.template": {
|
|
"source": "apache",
|
|
"extensions": ["stc"]
|
|
},
|
|
"application/vnd.sun.xml.draw": {
|
|
"source": "apache",
|
|
"extensions": ["sxd"]
|
|
},
|
|
"application/vnd.sun.xml.draw.template": {
|
|
"source": "apache",
|
|
"extensions": ["std"]
|
|
},
|
|
"application/vnd.sun.xml.impress": {
|
|
"source": "apache",
|
|
"extensions": ["sxi"]
|
|
},
|
|
"application/vnd.sun.xml.impress.template": {
|
|
"source": "apache",
|
|
"extensions": ["sti"]
|
|
},
|
|
"application/vnd.sun.xml.math": {
|
|
"source": "apache",
|
|
"extensions": ["sxm"]
|
|
},
|
|
"application/vnd.sun.xml.writer": {
|
|
"source": "apache",
|
|
"extensions": ["sxw"]
|
|
},
|
|
"application/vnd.sun.xml.writer.global": {
|
|
"source": "apache",
|
|
"extensions": ["sxg"]
|
|
},
|
|
"application/vnd.sun.xml.writer.template": {
|
|
"source": "apache",
|
|
"extensions": ["stw"]
|
|
},
|
|
"application/vnd.sus-calendar": {
|
|
"source": "iana",
|
|
"extensions": ["sus","susp"]
|
|
},
|
|
"application/vnd.svd": {
|
|
"source": "iana",
|
|
"extensions": ["svd"]
|
|
},
|
|
"application/vnd.swiftview-ics": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.symbian.install": {
|
|
"source": "apache",
|
|
"extensions": ["sis","sisx"]
|
|
},
|
|
"application/vnd.syncml+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["xsm"]
|
|
},
|
|
"application/vnd.syncml.dm+wbxml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"extensions": ["bdm"]
|
|
},
|
|
"application/vnd.syncml.dm+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["xdm"]
|
|
},
|
|
"application/vnd.syncml.dm.notification": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["ddf"]
|
|
},
|
|
"application/vnd.syncml.dmtnds+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.syncml.dmtnds+xml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.syncml.ds.notification": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.tableschema+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.tao.intent-module-archive": {
|
|
"source": "iana",
|
|
"extensions": ["tao"]
|
|
},
|
|
"application/vnd.tcpdump.pcap": {
|
|
"source": "iana",
|
|
"extensions": ["pcap","cap","dmp"]
|
|
},
|
|
"application/vnd.think-cell.ppttc+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.tmd.mediaflex.api+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.tml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.tmobile-livetv": {
|
|
"source": "iana",
|
|
"extensions": ["tmo"]
|
|
},
|
|
"application/vnd.tri.onesource": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.trid.tpt": {
|
|
"source": "iana",
|
|
"extensions": ["tpt"]
|
|
},
|
|
"application/vnd.triscape.mxs": {
|
|
"source": "iana",
|
|
"extensions": ["mxs"]
|
|
},
|
|
"application/vnd.trueapp": {
|
|
"source": "iana",
|
|
"extensions": ["tra"]
|
|
},
|
|
"application/vnd.truedoc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ubisoft.webplayer": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ufdl": {
|
|
"source": "iana",
|
|
"extensions": ["ufd","ufdl"]
|
|
},
|
|
"application/vnd.uiq.theme": {
|
|
"source": "iana",
|
|
"extensions": ["utz"]
|
|
},
|
|
"application/vnd.umajin": {
|
|
"source": "iana",
|
|
"extensions": ["umj"]
|
|
},
|
|
"application/vnd.unity": {
|
|
"source": "iana",
|
|
"extensions": ["unityweb"]
|
|
},
|
|
"application/vnd.uoml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["uoml"]
|
|
},
|
|
"application/vnd.uplanet.alert": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.alert-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.channel": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.channel-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.list": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.list-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd-wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uplanet.signal": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.uri-map": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.valve.source.material": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.vcx": {
|
|
"source": "iana",
|
|
"extensions": ["vcx"]
|
|
},
|
|
"application/vnd.vd-study": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.vectorworks": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.vel+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.verimatrix.vcas": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.veryant.thin": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.ves.encrypted": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.vidsoft.vidconference": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.visio": {
|
|
"source": "iana",
|
|
"extensions": ["vsd","vst","vss","vsw"]
|
|
},
|
|
"application/vnd.visionary": {
|
|
"source": "iana",
|
|
"extensions": ["vis"]
|
|
},
|
|
"application/vnd.vividence.scriptfile": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.vsf": {
|
|
"source": "iana",
|
|
"extensions": ["vsf"]
|
|
},
|
|
"application/vnd.wap.sic": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wap.slc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wap.wbxml": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"extensions": ["wbxml"]
|
|
},
|
|
"application/vnd.wap.wmlc": {
|
|
"source": "iana",
|
|
"extensions": ["wmlc"]
|
|
},
|
|
"application/vnd.wap.wmlscriptc": {
|
|
"source": "iana",
|
|
"extensions": ["wmlsc"]
|
|
},
|
|
"application/vnd.webturbo": {
|
|
"source": "iana",
|
|
"extensions": ["wtb"]
|
|
},
|
|
"application/vnd.wfa.p2p": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wfa.wsc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.windows.devicepairing": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wmc": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wmf.bootstrap": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica.package": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wolfram.player": {
|
|
"source": "iana",
|
|
"extensions": ["nbp"]
|
|
},
|
|
"application/vnd.wordperfect": {
|
|
"source": "iana",
|
|
"extensions": ["wpd"]
|
|
},
|
|
"application/vnd.wqd": {
|
|
"source": "iana",
|
|
"extensions": ["wqd"]
|
|
},
|
|
"application/vnd.wrq-hp3000-labelled": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wt.stf": {
|
|
"source": "iana",
|
|
"extensions": ["stf"]
|
|
},
|
|
"application/vnd.wv.csp+wbxml": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.wv.csp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.wv.ssp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.xacml+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.xara": {
|
|
"source": "iana",
|
|
"extensions": ["xar"]
|
|
},
|
|
"application/vnd.xfdl": {
|
|
"source": "iana",
|
|
"extensions": ["xfdl"]
|
|
},
|
|
"application/vnd.xfdl.webform": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.xmi+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vnd.xmpie.cpkg": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.xmpie.dpkg": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.xmpie.plan": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.xmpie.ppkg": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.xmpie.xlim": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.yamaha.hv-dic": {
|
|
"source": "iana",
|
|
"extensions": ["hvd"]
|
|
},
|
|
"application/vnd.yamaha.hv-script": {
|
|
"source": "iana",
|
|
"extensions": ["hvs"]
|
|
},
|
|
"application/vnd.yamaha.hv-voice": {
|
|
"source": "iana",
|
|
"extensions": ["hvp"]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat": {
|
|
"source": "iana",
|
|
"extensions": ["osf"]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat.osfpvg+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["osfpvg"]
|
|
},
|
|
"application/vnd.yamaha.remote-setup": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.yamaha.smaf-audio": {
|
|
"source": "iana",
|
|
"extensions": ["saf"]
|
|
},
|
|
"application/vnd.yamaha.smaf-phrase": {
|
|
"source": "iana",
|
|
"extensions": ["spf"]
|
|
},
|
|
"application/vnd.yamaha.through-ngn": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.yamaha.tunnel-udpencap": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.yaoweme": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.yellowriver-custom-menu": {
|
|
"source": "iana",
|
|
"extensions": ["cmp"]
|
|
},
|
|
"application/vnd.youtube.yt": {
|
|
"source": "iana"
|
|
},
|
|
"application/vnd.zul": {
|
|
"source": "iana",
|
|
"extensions": ["zir","zirz"]
|
|
},
|
|
"application/vnd.zzazz.deck+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["zaz"]
|
|
},
|
|
"application/voicexml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["vxml"]
|
|
},
|
|
"application/voucher-cms+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/vq-rtcpxr": {
|
|
"source": "iana"
|
|
},
|
|
"application/wasm": {
|
|
"compressible": true,
|
|
"extensions": ["wasm"]
|
|
},
|
|
"application/watcherinfo+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/webpush-options+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/whoispp-query": {
|
|
"source": "iana"
|
|
},
|
|
"application/whoispp-response": {
|
|
"source": "iana"
|
|
},
|
|
"application/widget": {
|
|
"source": "iana",
|
|
"extensions": ["wgt"]
|
|
},
|
|
"application/winhlp": {
|
|
"source": "apache",
|
|
"extensions": ["hlp"]
|
|
},
|
|
"application/wita": {
|
|
"source": "iana"
|
|
},
|
|
"application/wordperfect5.1": {
|
|
"source": "iana"
|
|
},
|
|
"application/wsdl+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["wsdl"]
|
|
},
|
|
"application/wspolicy+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["wspolicy"]
|
|
},
|
|
"application/x-7z-compressed": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["7z"]
|
|
},
|
|
"application/x-abiword": {
|
|
"source": "apache",
|
|
"extensions": ["abw"]
|
|
},
|
|
"application/x-ace-compressed": {
|
|
"source": "apache",
|
|
"extensions": ["ace"]
|
|
},
|
|
"application/x-amf": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-apple-diskimage": {
|
|
"source": "apache",
|
|
"extensions": ["dmg"]
|
|
},
|
|
"application/x-arj": {
|
|
"compressible": false,
|
|
"extensions": ["arj"]
|
|
},
|
|
"application/x-authorware-bin": {
|
|
"source": "apache",
|
|
"extensions": ["aab","x32","u32","vox"]
|
|
},
|
|
"application/x-authorware-map": {
|
|
"source": "apache",
|
|
"extensions": ["aam"]
|
|
},
|
|
"application/x-authorware-seg": {
|
|
"source": "apache",
|
|
"extensions": ["aas"]
|
|
},
|
|
"application/x-bcpio": {
|
|
"source": "apache",
|
|
"extensions": ["bcpio"]
|
|
},
|
|
"application/x-bdoc": {
|
|
"compressible": false,
|
|
"extensions": ["bdoc"]
|
|
},
|
|
"application/x-bittorrent": {
|
|
"source": "apache",
|
|
"extensions": ["torrent"]
|
|
},
|
|
"application/x-blorb": {
|
|
"source": "apache",
|
|
"extensions": ["blb","blorb"]
|
|
},
|
|
"application/x-bzip": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["bz"]
|
|
},
|
|
"application/x-bzip2": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["bz2","boz"]
|
|
},
|
|
"application/x-cbr": {
|
|
"source": "apache",
|
|
"extensions": ["cbr","cba","cbt","cbz","cb7"]
|
|
},
|
|
"application/x-cdlink": {
|
|
"source": "apache",
|
|
"extensions": ["vcd"]
|
|
},
|
|
"application/x-cfs-compressed": {
|
|
"source": "apache",
|
|
"extensions": ["cfs"]
|
|
},
|
|
"application/x-chat": {
|
|
"source": "apache",
|
|
"extensions": ["chat"]
|
|
},
|
|
"application/x-chess-pgn": {
|
|
"source": "apache",
|
|
"extensions": ["pgn"]
|
|
},
|
|
"application/x-chrome-extension": {
|
|
"extensions": ["crx"]
|
|
},
|
|
"application/x-cocoa": {
|
|
"source": "nginx",
|
|
"extensions": ["cco"]
|
|
},
|
|
"application/x-compress": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-conference": {
|
|
"source": "apache",
|
|
"extensions": ["nsc"]
|
|
},
|
|
"application/x-cpio": {
|
|
"source": "apache",
|
|
"extensions": ["cpio"]
|
|
},
|
|
"application/x-csh": {
|
|
"source": "apache",
|
|
"extensions": ["csh"]
|
|
},
|
|
"application/x-deb": {
|
|
"compressible": false
|
|
},
|
|
"application/x-debian-package": {
|
|
"source": "apache",
|
|
"extensions": ["deb","udeb"]
|
|
},
|
|
"application/x-dgc-compressed": {
|
|
"source": "apache",
|
|
"extensions": ["dgc"]
|
|
},
|
|
"application/x-director": {
|
|
"source": "apache",
|
|
"extensions": ["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"]
|
|
},
|
|
"application/x-doom": {
|
|
"source": "apache",
|
|
"extensions": ["wad"]
|
|
},
|
|
"application/x-dtbncx+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["ncx"]
|
|
},
|
|
"application/x-dtbook+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["dtb"]
|
|
},
|
|
"application/x-dtbresource+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["res"]
|
|
},
|
|
"application/x-dvi": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["dvi"]
|
|
},
|
|
"application/x-envoy": {
|
|
"source": "apache",
|
|
"extensions": ["evy"]
|
|
},
|
|
"application/x-eva": {
|
|
"source": "apache",
|
|
"extensions": ["eva"]
|
|
},
|
|
"application/x-font-bdf": {
|
|
"source": "apache",
|
|
"extensions": ["bdf"]
|
|
},
|
|
"application/x-font-dos": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-font-framemaker": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-font-ghostscript": {
|
|
"source": "apache",
|
|
"extensions": ["gsf"]
|
|
},
|
|
"application/x-font-libgrx": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-font-linux-psf": {
|
|
"source": "apache",
|
|
"extensions": ["psf"]
|
|
},
|
|
"application/x-font-pcf": {
|
|
"source": "apache",
|
|
"extensions": ["pcf"]
|
|
},
|
|
"application/x-font-snf": {
|
|
"source": "apache",
|
|
"extensions": ["snf"]
|
|
},
|
|
"application/x-font-speedo": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-font-sunos-news": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-font-type1": {
|
|
"source": "apache",
|
|
"extensions": ["pfa","pfb","pfm","afm"]
|
|
},
|
|
"application/x-font-vfont": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-freearc": {
|
|
"source": "apache",
|
|
"extensions": ["arc"]
|
|
},
|
|
"application/x-futuresplash": {
|
|
"source": "apache",
|
|
"extensions": ["spl"]
|
|
},
|
|
"application/x-gca-compressed": {
|
|
"source": "apache",
|
|
"extensions": ["gca"]
|
|
},
|
|
"application/x-glulx": {
|
|
"source": "apache",
|
|
"extensions": ["ulx"]
|
|
},
|
|
"application/x-gnumeric": {
|
|
"source": "apache",
|
|
"extensions": ["gnumeric"]
|
|
},
|
|
"application/x-gramps-xml": {
|
|
"source": "apache",
|
|
"extensions": ["gramps"]
|
|
},
|
|
"application/x-gtar": {
|
|
"source": "apache",
|
|
"extensions": ["gtar"]
|
|
},
|
|
"application/x-gzip": {
|
|
"source": "apache"
|
|
},
|
|
"application/x-hdf": {
|
|
"source": "apache",
|
|
"extensions": ["hdf"]
|
|
},
|
|
"application/x-httpd-php": {
|
|
"compressible": true,
|
|
"extensions": ["php"]
|
|
},
|
|
"application/x-install-instructions": {
|
|
"source": "apache",
|
|
"extensions": ["install"]
|
|
},
|
|
"application/x-iso9660-image": {
|
|
"source": "apache",
|
|
"extensions": ["iso"]
|
|
},
|
|
"application/x-java-archive-diff": {
|
|
"source": "nginx",
|
|
"extensions": ["jardiff"]
|
|
},
|
|
"application/x-java-jnlp-file": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["jnlp"]
|
|
},
|
|
"application/x-javascript": {
|
|
"compressible": true
|
|
},
|
|
"application/x-keepass2": {
|
|
"extensions": ["kdbx"]
|
|
},
|
|
"application/x-latex": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["latex"]
|
|
},
|
|
"application/x-lua-bytecode": {
|
|
"extensions": ["luac"]
|
|
},
|
|
"application/x-lzh-compressed": {
|
|
"source": "apache",
|
|
"extensions": ["lzh","lha"]
|
|
},
|
|
"application/x-makeself": {
|
|
"source": "nginx",
|
|
"extensions": ["run"]
|
|
},
|
|
"application/x-mie": {
|
|
"source": "apache",
|
|
"extensions": ["mie"]
|
|
},
|
|
"application/x-mobipocket-ebook": {
|
|
"source": "apache",
|
|
"extensions": ["prc","mobi"]
|
|
},
|
|
"application/x-mpegurl": {
|
|
"compressible": false
|
|
},
|
|
"application/x-ms-application": {
|
|
"source": "apache",
|
|
"extensions": ["application"]
|
|
},
|
|
"application/x-ms-shortcut": {
|
|
"source": "apache",
|
|
"extensions": ["lnk"]
|
|
},
|
|
"application/x-ms-wmd": {
|
|
"source": "apache",
|
|
"extensions": ["wmd"]
|
|
},
|
|
"application/x-ms-wmz": {
|
|
"source": "apache",
|
|
"extensions": ["wmz"]
|
|
},
|
|
"application/x-ms-xbap": {
|
|
"source": "apache",
|
|
"extensions": ["xbap"]
|
|
},
|
|
"application/x-msaccess": {
|
|
"source": "apache",
|
|
"extensions": ["mdb"]
|
|
},
|
|
"application/x-msbinder": {
|
|
"source": "apache",
|
|
"extensions": ["obd"]
|
|
},
|
|
"application/x-mscardfile": {
|
|
"source": "apache",
|
|
"extensions": ["crd"]
|
|
},
|
|
"application/x-msclip": {
|
|
"source": "apache",
|
|
"extensions": ["clp"]
|
|
},
|
|
"application/x-msdos-program": {
|
|
"extensions": ["exe"]
|
|
},
|
|
"application/x-msdownload": {
|
|
"source": "apache",
|
|
"extensions": ["exe","dll","com","bat","msi"]
|
|
},
|
|
"application/x-msmediaview": {
|
|
"source": "apache",
|
|
"extensions": ["mvb","m13","m14"]
|
|
},
|
|
"application/x-msmetafile": {
|
|
"source": "apache",
|
|
"extensions": ["wmf","wmz","emf","emz"]
|
|
},
|
|
"application/x-msmoney": {
|
|
"source": "apache",
|
|
"extensions": ["mny"]
|
|
},
|
|
"application/x-mspublisher": {
|
|
"source": "apache",
|
|
"extensions": ["pub"]
|
|
},
|
|
"application/x-msschedule": {
|
|
"source": "apache",
|
|
"extensions": ["scd"]
|
|
},
|
|
"application/x-msterminal": {
|
|
"source": "apache",
|
|
"extensions": ["trm"]
|
|
},
|
|
"application/x-mswrite": {
|
|
"source": "apache",
|
|
"extensions": ["wri"]
|
|
},
|
|
"application/x-netcdf": {
|
|
"source": "apache",
|
|
"extensions": ["nc","cdf"]
|
|
},
|
|
"application/x-ns-proxy-autoconfig": {
|
|
"compressible": true,
|
|
"extensions": ["pac"]
|
|
},
|
|
"application/x-nzb": {
|
|
"source": "apache",
|
|
"extensions": ["nzb"]
|
|
},
|
|
"application/x-perl": {
|
|
"source": "nginx",
|
|
"extensions": ["pl","pm"]
|
|
},
|
|
"application/x-pilot": {
|
|
"source": "nginx",
|
|
"extensions": ["prc","pdb"]
|
|
},
|
|
"application/x-pkcs12": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["p12","pfx"]
|
|
},
|
|
"application/x-pkcs7-certificates": {
|
|
"source": "apache",
|
|
"extensions": ["p7b","spc"]
|
|
},
|
|
"application/x-pkcs7-certreqresp": {
|
|
"source": "apache",
|
|
"extensions": ["p7r"]
|
|
},
|
|
"application/x-pki-message": {
|
|
"source": "iana"
|
|
},
|
|
"application/x-rar-compressed": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["rar"]
|
|
},
|
|
"application/x-redhat-package-manager": {
|
|
"source": "nginx",
|
|
"extensions": ["rpm"]
|
|
},
|
|
"application/x-research-info-systems": {
|
|
"source": "apache",
|
|
"extensions": ["ris"]
|
|
},
|
|
"application/x-sea": {
|
|
"source": "nginx",
|
|
"extensions": ["sea"]
|
|
},
|
|
"application/x-sh": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["sh"]
|
|
},
|
|
"application/x-shar": {
|
|
"source": "apache",
|
|
"extensions": ["shar"]
|
|
},
|
|
"application/x-shockwave-flash": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["swf"]
|
|
},
|
|
"application/x-silverlight-app": {
|
|
"source": "apache",
|
|
"extensions": ["xap"]
|
|
},
|
|
"application/x-sql": {
|
|
"source": "apache",
|
|
"extensions": ["sql"]
|
|
},
|
|
"application/x-stuffit": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["sit"]
|
|
},
|
|
"application/x-stuffitx": {
|
|
"source": "apache",
|
|
"extensions": ["sitx"]
|
|
},
|
|
"application/x-subrip": {
|
|
"source": "apache",
|
|
"extensions": ["srt"]
|
|
},
|
|
"application/x-sv4cpio": {
|
|
"source": "apache",
|
|
"extensions": ["sv4cpio"]
|
|
},
|
|
"application/x-sv4crc": {
|
|
"source": "apache",
|
|
"extensions": ["sv4crc"]
|
|
},
|
|
"application/x-t3vm-image": {
|
|
"source": "apache",
|
|
"extensions": ["t3"]
|
|
},
|
|
"application/x-tads": {
|
|
"source": "apache",
|
|
"extensions": ["gam"]
|
|
},
|
|
"application/x-tar": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["tar"]
|
|
},
|
|
"application/x-tcl": {
|
|
"source": "apache",
|
|
"extensions": ["tcl","tk"]
|
|
},
|
|
"application/x-tex": {
|
|
"source": "apache",
|
|
"extensions": ["tex"]
|
|
},
|
|
"application/x-tex-tfm": {
|
|
"source": "apache",
|
|
"extensions": ["tfm"]
|
|
},
|
|
"application/x-texinfo": {
|
|
"source": "apache",
|
|
"extensions": ["texinfo","texi"]
|
|
},
|
|
"application/x-tgif": {
|
|
"source": "apache",
|
|
"extensions": ["obj"]
|
|
},
|
|
"application/x-ustar": {
|
|
"source": "apache",
|
|
"extensions": ["ustar"]
|
|
},
|
|
"application/x-virtualbox-hdd": {
|
|
"compressible": true,
|
|
"extensions": ["hdd"]
|
|
},
|
|
"application/x-virtualbox-ova": {
|
|
"compressible": true,
|
|
"extensions": ["ova"]
|
|
},
|
|
"application/x-virtualbox-ovf": {
|
|
"compressible": true,
|
|
"extensions": ["ovf"]
|
|
},
|
|
"application/x-virtualbox-vbox": {
|
|
"compressible": true,
|
|
"extensions": ["vbox"]
|
|
},
|
|
"application/x-virtualbox-vbox-extpack": {
|
|
"compressible": false,
|
|
"extensions": ["vbox-extpack"]
|
|
},
|
|
"application/x-virtualbox-vdi": {
|
|
"compressible": true,
|
|
"extensions": ["vdi"]
|
|
},
|
|
"application/x-virtualbox-vhd": {
|
|
"compressible": true,
|
|
"extensions": ["vhd"]
|
|
},
|
|
"application/x-virtualbox-vmdk": {
|
|
"compressible": true,
|
|
"extensions": ["vmdk"]
|
|
},
|
|
"application/x-wais-source": {
|
|
"source": "apache",
|
|
"extensions": ["src"]
|
|
},
|
|
"application/x-web-app-manifest+json": {
|
|
"compressible": true,
|
|
"extensions": ["webapp"]
|
|
},
|
|
"application/x-www-form-urlencoded": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/x-x509-ca-cert": {
|
|
"source": "iana",
|
|
"extensions": ["der","crt","pem"]
|
|
},
|
|
"application/x-x509-ca-ra-cert": {
|
|
"source": "iana"
|
|
},
|
|
"application/x-x509-next-ca-cert": {
|
|
"source": "iana"
|
|
},
|
|
"application/x-xfig": {
|
|
"source": "apache",
|
|
"extensions": ["fig"]
|
|
},
|
|
"application/x-xliff+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["xlf"]
|
|
},
|
|
"application/x-xpinstall": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["xpi"]
|
|
},
|
|
"application/x-xz": {
|
|
"source": "apache",
|
|
"extensions": ["xz"]
|
|
},
|
|
"application/x-zmachine": {
|
|
"source": "apache",
|
|
"extensions": ["z1","z2","z3","z4","z5","z6","z7","z8"]
|
|
},
|
|
"application/x400-bp": {
|
|
"source": "iana"
|
|
},
|
|
"application/xacml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/xaml+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["xaml"]
|
|
},
|
|
"application/xcap-att+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xav"]
|
|
},
|
|
"application/xcap-caps+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xca"]
|
|
},
|
|
"application/xcap-diff+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xdf"]
|
|
},
|
|
"application/xcap-el+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xel"]
|
|
},
|
|
"application/xcap-error+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xer"]
|
|
},
|
|
"application/xcap-ns+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xns"]
|
|
},
|
|
"application/xcon-conference-info+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/xcon-conference-info-diff+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/xenc+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xenc"]
|
|
},
|
|
"application/xhtml+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xhtml","xht"]
|
|
},
|
|
"application/xhtml-voice+xml": {
|
|
"source": "apache",
|
|
"compressible": true
|
|
},
|
|
"application/xliff+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xlf"]
|
|
},
|
|
"application/xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xml","xsl","xsd","rng"]
|
|
},
|
|
"application/xml-dtd": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["dtd"]
|
|
},
|
|
"application/xml-external-parsed-entity": {
|
|
"source": "iana"
|
|
},
|
|
"application/xml-patch+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/xmpp+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/xop+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xop"]
|
|
},
|
|
"application/xproc+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["xpl"]
|
|
},
|
|
"application/xslt+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xslt"]
|
|
},
|
|
"application/xspf+xml": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["xspf"]
|
|
},
|
|
"application/xv+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["mxml","xhvml","xvml","xvm"]
|
|
},
|
|
"application/yang": {
|
|
"source": "iana",
|
|
"extensions": ["yang"]
|
|
},
|
|
"application/yang-data+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/yang-data+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/yang-patch+json": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/yang-patch+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"application/yin+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["yin"]
|
|
},
|
|
"application/zip": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["zip"]
|
|
},
|
|
"application/zlib": {
|
|
"source": "iana"
|
|
},
|
|
"application/zstd": {
|
|
"source": "iana"
|
|
},
|
|
"audio/1d-interleaved-parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"audio/32kadpcm": {
|
|
"source": "iana"
|
|
},
|
|
"audio/3gpp": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["3gpp"]
|
|
},
|
|
"audio/3gpp2": {
|
|
"source": "iana"
|
|
},
|
|
"audio/aac": {
|
|
"source": "iana"
|
|
},
|
|
"audio/ac3": {
|
|
"source": "iana"
|
|
},
|
|
"audio/adpcm": {
|
|
"source": "apache",
|
|
"extensions": ["adp"]
|
|
},
|
|
"audio/amr": {
|
|
"source": "iana"
|
|
},
|
|
"audio/amr-wb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/amr-wb+": {
|
|
"source": "iana"
|
|
},
|
|
"audio/aptx": {
|
|
"source": "iana"
|
|
},
|
|
"audio/asc": {
|
|
"source": "iana"
|
|
},
|
|
"audio/atrac-advanced-lossless": {
|
|
"source": "iana"
|
|
},
|
|
"audio/atrac-x": {
|
|
"source": "iana"
|
|
},
|
|
"audio/atrac3": {
|
|
"source": "iana"
|
|
},
|
|
"audio/basic": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["au","snd"]
|
|
},
|
|
"audio/bv16": {
|
|
"source": "iana"
|
|
},
|
|
"audio/bv32": {
|
|
"source": "iana"
|
|
},
|
|
"audio/clearmode": {
|
|
"source": "iana"
|
|
},
|
|
"audio/cn": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dat12": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dls": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dsr-es201108": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dsr-es202050": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dsr-es202211": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dsr-es202212": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dv": {
|
|
"source": "iana"
|
|
},
|
|
"audio/dvi4": {
|
|
"source": "iana"
|
|
},
|
|
"audio/eac3": {
|
|
"source": "iana"
|
|
},
|
|
"audio/encaprtp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrc": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrc-qcp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrc0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrc1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcb0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcb1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcnw": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcnw0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcnw1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcwb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcwb0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evrcwb1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/evs": {
|
|
"source": "iana"
|
|
},
|
|
"audio/flexfec": {
|
|
"source": "iana"
|
|
},
|
|
"audio/fwdred": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g711-0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g719": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g722": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g7221": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g723": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g726-16": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g726-24": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g726-32": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g726-40": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g728": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g729": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g7291": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g729d": {
|
|
"source": "iana"
|
|
},
|
|
"audio/g729e": {
|
|
"source": "iana"
|
|
},
|
|
"audio/gsm": {
|
|
"source": "iana"
|
|
},
|
|
"audio/gsm-efr": {
|
|
"source": "iana"
|
|
},
|
|
"audio/gsm-hr-08": {
|
|
"source": "iana"
|
|
},
|
|
"audio/ilbc": {
|
|
"source": "iana"
|
|
},
|
|
"audio/ip-mr_v2.5": {
|
|
"source": "iana"
|
|
},
|
|
"audio/isac": {
|
|
"source": "apache"
|
|
},
|
|
"audio/l16": {
|
|
"source": "iana"
|
|
},
|
|
"audio/l20": {
|
|
"source": "iana"
|
|
},
|
|
"audio/l24": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"audio/l8": {
|
|
"source": "iana"
|
|
},
|
|
"audio/lpc": {
|
|
"source": "iana"
|
|
},
|
|
"audio/melp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/melp1200": {
|
|
"source": "iana"
|
|
},
|
|
"audio/melp2400": {
|
|
"source": "iana"
|
|
},
|
|
"audio/melp600": {
|
|
"source": "iana"
|
|
},
|
|
"audio/mhas": {
|
|
"source": "iana"
|
|
},
|
|
"audio/midi": {
|
|
"source": "apache",
|
|
"extensions": ["mid","midi","kar","rmi"]
|
|
},
|
|
"audio/mobile-xmf": {
|
|
"source": "iana",
|
|
"extensions": ["mxmf"]
|
|
},
|
|
"audio/mp3": {
|
|
"compressible": false,
|
|
"extensions": ["mp3"]
|
|
},
|
|
"audio/mp4": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["m4a","mp4a"]
|
|
},
|
|
"audio/mp4a-latm": {
|
|
"source": "iana"
|
|
},
|
|
"audio/mpa": {
|
|
"source": "iana"
|
|
},
|
|
"audio/mpa-robust": {
|
|
"source": "iana"
|
|
},
|
|
"audio/mpeg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["mpga","mp2","mp2a","mp3","m2a","m3a"]
|
|
},
|
|
"audio/mpeg4-generic": {
|
|
"source": "iana"
|
|
},
|
|
"audio/musepack": {
|
|
"source": "apache"
|
|
},
|
|
"audio/ogg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["oga","ogg","spx"]
|
|
},
|
|
"audio/opus": {
|
|
"source": "iana"
|
|
},
|
|
"audio/parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"audio/pcma": {
|
|
"source": "iana"
|
|
},
|
|
"audio/pcma-wb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/pcmu": {
|
|
"source": "iana"
|
|
},
|
|
"audio/pcmu-wb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/prs.sid": {
|
|
"source": "iana"
|
|
},
|
|
"audio/qcelp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/raptorfec": {
|
|
"source": "iana"
|
|
},
|
|
"audio/red": {
|
|
"source": "iana"
|
|
},
|
|
"audio/rtp-enc-aescm128": {
|
|
"source": "iana"
|
|
},
|
|
"audio/rtp-midi": {
|
|
"source": "iana"
|
|
},
|
|
"audio/rtploopback": {
|
|
"source": "iana"
|
|
},
|
|
"audio/rtx": {
|
|
"source": "iana"
|
|
},
|
|
"audio/s3m": {
|
|
"source": "apache",
|
|
"extensions": ["s3m"]
|
|
},
|
|
"audio/silk": {
|
|
"source": "apache",
|
|
"extensions": ["sil"]
|
|
},
|
|
"audio/smv": {
|
|
"source": "iana"
|
|
},
|
|
"audio/smv-qcp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/smv0": {
|
|
"source": "iana"
|
|
},
|
|
"audio/sp-midi": {
|
|
"source": "iana"
|
|
},
|
|
"audio/speex": {
|
|
"source": "iana"
|
|
},
|
|
"audio/t140c": {
|
|
"source": "iana"
|
|
},
|
|
"audio/t38": {
|
|
"source": "iana"
|
|
},
|
|
"audio/telephone-event": {
|
|
"source": "iana"
|
|
},
|
|
"audio/tetra_acelp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/tetra_acelp_bb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/tone": {
|
|
"source": "iana"
|
|
},
|
|
"audio/uemclip": {
|
|
"source": "iana"
|
|
},
|
|
"audio/ulpfec": {
|
|
"source": "iana"
|
|
},
|
|
"audio/usac": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vdvi": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vmr-wb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.3gpp.iufp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.4sb": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.audiokoz": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.celp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.cisco.nse": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.cmles.radio-events": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.cns.anp1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.cns.inf1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dece.audio": {
|
|
"source": "iana",
|
|
"extensions": ["uva","uvva"]
|
|
},
|
|
"audio/vnd.digital-winds": {
|
|
"source": "iana",
|
|
"extensions": ["eol"]
|
|
},
|
|
"audio/vnd.dlna.adts": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.2": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.mlp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.mps": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2x": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2z": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dolby.pulse.1": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dra": {
|
|
"source": "iana",
|
|
"extensions": ["dra"]
|
|
},
|
|
"audio/vnd.dts": {
|
|
"source": "iana",
|
|
"extensions": ["dts"]
|
|
},
|
|
"audio/vnd.dts.hd": {
|
|
"source": "iana",
|
|
"extensions": ["dtshd"]
|
|
},
|
|
"audio/vnd.dts.uhd": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.dvb.file": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.everad.plj": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.hns.audio": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.lucent.voice": {
|
|
"source": "iana",
|
|
"extensions": ["lvp"]
|
|
},
|
|
"audio/vnd.ms-playready.media.pya": {
|
|
"source": "iana",
|
|
"extensions": ["pya"]
|
|
},
|
|
"audio/vnd.nokia.mobile-xmf": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.nortel.vbk": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.nuera.ecelp4800": {
|
|
"source": "iana",
|
|
"extensions": ["ecelp4800"]
|
|
},
|
|
"audio/vnd.nuera.ecelp7470": {
|
|
"source": "iana",
|
|
"extensions": ["ecelp7470"]
|
|
},
|
|
"audio/vnd.nuera.ecelp9600": {
|
|
"source": "iana",
|
|
"extensions": ["ecelp9600"]
|
|
},
|
|
"audio/vnd.octel.sbc": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.presonus.multitrack": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.qcelp": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.rhetorex.32kadpcm": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.rip": {
|
|
"source": "iana",
|
|
"extensions": ["rip"]
|
|
},
|
|
"audio/vnd.rn-realaudio": {
|
|
"compressible": false
|
|
},
|
|
"audio/vnd.sealedmedia.softseal.mpeg": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.vmx.cvsd": {
|
|
"source": "iana"
|
|
},
|
|
"audio/vnd.wave": {
|
|
"compressible": false
|
|
},
|
|
"audio/vorbis": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"audio/vorbis-config": {
|
|
"source": "iana"
|
|
},
|
|
"audio/wav": {
|
|
"compressible": false,
|
|
"extensions": ["wav"]
|
|
},
|
|
"audio/wave": {
|
|
"compressible": false,
|
|
"extensions": ["wav"]
|
|
},
|
|
"audio/webm": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["weba"]
|
|
},
|
|
"audio/x-aac": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["aac"]
|
|
},
|
|
"audio/x-aiff": {
|
|
"source": "apache",
|
|
"extensions": ["aif","aiff","aifc"]
|
|
},
|
|
"audio/x-caf": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["caf"]
|
|
},
|
|
"audio/x-flac": {
|
|
"source": "apache",
|
|
"extensions": ["flac"]
|
|
},
|
|
"audio/x-m4a": {
|
|
"source": "nginx",
|
|
"extensions": ["m4a"]
|
|
},
|
|
"audio/x-matroska": {
|
|
"source": "apache",
|
|
"extensions": ["mka"]
|
|
},
|
|
"audio/x-mpegurl": {
|
|
"source": "apache",
|
|
"extensions": ["m3u"]
|
|
},
|
|
"audio/x-ms-wax": {
|
|
"source": "apache",
|
|
"extensions": ["wax"]
|
|
},
|
|
"audio/x-ms-wma": {
|
|
"source": "apache",
|
|
"extensions": ["wma"]
|
|
},
|
|
"audio/x-pn-realaudio": {
|
|
"source": "apache",
|
|
"extensions": ["ram","ra"]
|
|
},
|
|
"audio/x-pn-realaudio-plugin": {
|
|
"source": "apache",
|
|
"extensions": ["rmp"]
|
|
},
|
|
"audio/x-realaudio": {
|
|
"source": "nginx",
|
|
"extensions": ["ra"]
|
|
},
|
|
"audio/x-tta": {
|
|
"source": "apache"
|
|
},
|
|
"audio/x-wav": {
|
|
"source": "apache",
|
|
"extensions": ["wav"]
|
|
},
|
|
"audio/xm": {
|
|
"source": "apache",
|
|
"extensions": ["xm"]
|
|
},
|
|
"chemical/x-cdx": {
|
|
"source": "apache",
|
|
"extensions": ["cdx"]
|
|
},
|
|
"chemical/x-cif": {
|
|
"source": "apache",
|
|
"extensions": ["cif"]
|
|
},
|
|
"chemical/x-cmdf": {
|
|
"source": "apache",
|
|
"extensions": ["cmdf"]
|
|
},
|
|
"chemical/x-cml": {
|
|
"source": "apache",
|
|
"extensions": ["cml"]
|
|
},
|
|
"chemical/x-csml": {
|
|
"source": "apache",
|
|
"extensions": ["csml"]
|
|
},
|
|
"chemical/x-pdb": {
|
|
"source": "apache"
|
|
},
|
|
"chemical/x-xyz": {
|
|
"source": "apache",
|
|
"extensions": ["xyz"]
|
|
},
|
|
"font/collection": {
|
|
"source": "iana",
|
|
"extensions": ["ttc"]
|
|
},
|
|
"font/otf": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["otf"]
|
|
},
|
|
"font/sfnt": {
|
|
"source": "iana"
|
|
},
|
|
"font/ttf": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["ttf"]
|
|
},
|
|
"font/woff": {
|
|
"source": "iana",
|
|
"extensions": ["woff"]
|
|
},
|
|
"font/woff2": {
|
|
"source": "iana",
|
|
"extensions": ["woff2"]
|
|
},
|
|
"image/aces": {
|
|
"source": "iana",
|
|
"extensions": ["exr"]
|
|
},
|
|
"image/apng": {
|
|
"compressible": false,
|
|
"extensions": ["apng"]
|
|
},
|
|
"image/avci": {
|
|
"source": "iana"
|
|
},
|
|
"image/avcs": {
|
|
"source": "iana"
|
|
},
|
|
"image/bmp": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["bmp"]
|
|
},
|
|
"image/cgm": {
|
|
"source": "iana",
|
|
"extensions": ["cgm"]
|
|
},
|
|
"image/dicom-rle": {
|
|
"source": "iana",
|
|
"extensions": ["drle"]
|
|
},
|
|
"image/emf": {
|
|
"source": "iana",
|
|
"extensions": ["emf"]
|
|
},
|
|
"image/fits": {
|
|
"source": "iana",
|
|
"extensions": ["fits"]
|
|
},
|
|
"image/g3fax": {
|
|
"source": "iana",
|
|
"extensions": ["g3"]
|
|
},
|
|
"image/gif": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["gif"]
|
|
},
|
|
"image/heic": {
|
|
"source": "iana",
|
|
"extensions": ["heic"]
|
|
},
|
|
"image/heic-sequence": {
|
|
"source": "iana",
|
|
"extensions": ["heics"]
|
|
},
|
|
"image/heif": {
|
|
"source": "iana",
|
|
"extensions": ["heif"]
|
|
},
|
|
"image/heif-sequence": {
|
|
"source": "iana",
|
|
"extensions": ["heifs"]
|
|
},
|
|
"image/hej2k": {
|
|
"source": "iana",
|
|
"extensions": ["hej2"]
|
|
},
|
|
"image/hsj2": {
|
|
"source": "iana",
|
|
"extensions": ["hsj2"]
|
|
},
|
|
"image/ief": {
|
|
"source": "iana",
|
|
"extensions": ["ief"]
|
|
},
|
|
"image/jls": {
|
|
"source": "iana",
|
|
"extensions": ["jls"]
|
|
},
|
|
"image/jp2": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["jp2","jpg2"]
|
|
},
|
|
"image/jpeg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["jpeg","jpg","jpe"]
|
|
},
|
|
"image/jph": {
|
|
"source": "iana",
|
|
"extensions": ["jph"]
|
|
},
|
|
"image/jphc": {
|
|
"source": "iana",
|
|
"extensions": ["jhc"]
|
|
},
|
|
"image/jpm": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["jpm"]
|
|
},
|
|
"image/jpx": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["jpx","jpf"]
|
|
},
|
|
"image/jxr": {
|
|
"source": "iana",
|
|
"extensions": ["jxr"]
|
|
},
|
|
"image/jxra": {
|
|
"source": "iana",
|
|
"extensions": ["jxra"]
|
|
},
|
|
"image/jxrs": {
|
|
"source": "iana",
|
|
"extensions": ["jxrs"]
|
|
},
|
|
"image/jxs": {
|
|
"source": "iana",
|
|
"extensions": ["jxs"]
|
|
},
|
|
"image/jxsc": {
|
|
"source": "iana",
|
|
"extensions": ["jxsc"]
|
|
},
|
|
"image/jxsi": {
|
|
"source": "iana",
|
|
"extensions": ["jxsi"]
|
|
},
|
|
"image/jxss": {
|
|
"source": "iana",
|
|
"extensions": ["jxss"]
|
|
},
|
|
"image/ktx": {
|
|
"source": "iana",
|
|
"extensions": ["ktx"]
|
|
},
|
|
"image/naplps": {
|
|
"source": "iana"
|
|
},
|
|
"image/pjpeg": {
|
|
"compressible": false
|
|
},
|
|
"image/png": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["png"]
|
|
},
|
|
"image/prs.btif": {
|
|
"source": "iana",
|
|
"extensions": ["btif"]
|
|
},
|
|
"image/prs.pti": {
|
|
"source": "iana",
|
|
"extensions": ["pti"]
|
|
},
|
|
"image/pwg-raster": {
|
|
"source": "iana"
|
|
},
|
|
"image/sgi": {
|
|
"source": "apache",
|
|
"extensions": ["sgi"]
|
|
},
|
|
"image/svg+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["svg","svgz"]
|
|
},
|
|
"image/t38": {
|
|
"source": "iana",
|
|
"extensions": ["t38"]
|
|
},
|
|
"image/tiff": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["tif","tiff"]
|
|
},
|
|
"image/tiff-fx": {
|
|
"source": "iana",
|
|
"extensions": ["tfx"]
|
|
},
|
|
"image/vnd.adobe.photoshop": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["psd"]
|
|
},
|
|
"image/vnd.airzip.accelerator.azv": {
|
|
"source": "iana",
|
|
"extensions": ["azv"]
|
|
},
|
|
"image/vnd.cns.inf2": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.dece.graphic": {
|
|
"source": "iana",
|
|
"extensions": ["uvi","uvvi","uvg","uvvg"]
|
|
},
|
|
"image/vnd.djvu": {
|
|
"source": "iana",
|
|
"extensions": ["djvu","djv"]
|
|
},
|
|
"image/vnd.dvb.subtitle": {
|
|
"source": "iana",
|
|
"extensions": ["sub"]
|
|
},
|
|
"image/vnd.dwg": {
|
|
"source": "iana",
|
|
"extensions": ["dwg"]
|
|
},
|
|
"image/vnd.dxf": {
|
|
"source": "iana",
|
|
"extensions": ["dxf"]
|
|
},
|
|
"image/vnd.fastbidsheet": {
|
|
"source": "iana",
|
|
"extensions": ["fbs"]
|
|
},
|
|
"image/vnd.fpx": {
|
|
"source": "iana",
|
|
"extensions": ["fpx"]
|
|
},
|
|
"image/vnd.fst": {
|
|
"source": "iana",
|
|
"extensions": ["fst"]
|
|
},
|
|
"image/vnd.fujixerox.edmics-mmr": {
|
|
"source": "iana",
|
|
"extensions": ["mmr"]
|
|
},
|
|
"image/vnd.fujixerox.edmics-rlc": {
|
|
"source": "iana",
|
|
"extensions": ["rlc"]
|
|
},
|
|
"image/vnd.globalgraphics.pgb": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.microsoft.icon": {
|
|
"source": "iana",
|
|
"extensions": ["ico"]
|
|
},
|
|
"image/vnd.mix": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.mozilla.apng": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.ms-dds": {
|
|
"extensions": ["dds"]
|
|
},
|
|
"image/vnd.ms-modi": {
|
|
"source": "iana",
|
|
"extensions": ["mdi"]
|
|
},
|
|
"image/vnd.ms-photo": {
|
|
"source": "apache",
|
|
"extensions": ["wdp"]
|
|
},
|
|
"image/vnd.net-fpx": {
|
|
"source": "iana",
|
|
"extensions": ["npx"]
|
|
},
|
|
"image/vnd.radiance": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.sealed.png": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.gif": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.jpg": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.svf": {
|
|
"source": "iana"
|
|
},
|
|
"image/vnd.tencent.tap": {
|
|
"source": "iana",
|
|
"extensions": ["tap"]
|
|
},
|
|
"image/vnd.valve.source.texture": {
|
|
"source": "iana",
|
|
"extensions": ["vtf"]
|
|
},
|
|
"image/vnd.wap.wbmp": {
|
|
"source": "iana",
|
|
"extensions": ["wbmp"]
|
|
},
|
|
"image/vnd.xiff": {
|
|
"source": "iana",
|
|
"extensions": ["xif"]
|
|
},
|
|
"image/vnd.zbrush.pcx": {
|
|
"source": "iana",
|
|
"extensions": ["pcx"]
|
|
},
|
|
"image/webp": {
|
|
"source": "apache",
|
|
"extensions": ["webp"]
|
|
},
|
|
"image/wmf": {
|
|
"source": "iana",
|
|
"extensions": ["wmf"]
|
|
},
|
|
"image/x-3ds": {
|
|
"source": "apache",
|
|
"extensions": ["3ds"]
|
|
},
|
|
"image/x-cmu-raster": {
|
|
"source": "apache",
|
|
"extensions": ["ras"]
|
|
},
|
|
"image/x-cmx": {
|
|
"source": "apache",
|
|
"extensions": ["cmx"]
|
|
},
|
|
"image/x-freehand": {
|
|
"source": "apache",
|
|
"extensions": ["fh","fhc","fh4","fh5","fh7"]
|
|
},
|
|
"image/x-icon": {
|
|
"source": "apache",
|
|
"compressible": true,
|
|
"extensions": ["ico"]
|
|
},
|
|
"image/x-jng": {
|
|
"source": "nginx",
|
|
"extensions": ["jng"]
|
|
},
|
|
"image/x-mrsid-image": {
|
|
"source": "apache",
|
|
"extensions": ["sid"]
|
|
},
|
|
"image/x-ms-bmp": {
|
|
"source": "nginx",
|
|
"compressible": true,
|
|
"extensions": ["bmp"]
|
|
},
|
|
"image/x-pcx": {
|
|
"source": "apache",
|
|
"extensions": ["pcx"]
|
|
},
|
|
"image/x-pict": {
|
|
"source": "apache",
|
|
"extensions": ["pic","pct"]
|
|
},
|
|
"image/x-portable-anymap": {
|
|
"source": "apache",
|
|
"extensions": ["pnm"]
|
|
},
|
|
"image/x-portable-bitmap": {
|
|
"source": "apache",
|
|
"extensions": ["pbm"]
|
|
},
|
|
"image/x-portable-graymap": {
|
|
"source": "apache",
|
|
"extensions": ["pgm"]
|
|
},
|
|
"image/x-portable-pixmap": {
|
|
"source": "apache",
|
|
"extensions": ["ppm"]
|
|
},
|
|
"image/x-rgb": {
|
|
"source": "apache",
|
|
"extensions": ["rgb"]
|
|
},
|
|
"image/x-tga": {
|
|
"source": "apache",
|
|
"extensions": ["tga"]
|
|
},
|
|
"image/x-xbitmap": {
|
|
"source": "apache",
|
|
"extensions": ["xbm"]
|
|
},
|
|
"image/x-xcf": {
|
|
"compressible": false
|
|
},
|
|
"image/x-xpixmap": {
|
|
"source": "apache",
|
|
"extensions": ["xpm"]
|
|
},
|
|
"image/x-xwindowdump": {
|
|
"source": "apache",
|
|
"extensions": ["xwd"]
|
|
},
|
|
"message/cpim": {
|
|
"source": "iana"
|
|
},
|
|
"message/delivery-status": {
|
|
"source": "iana"
|
|
},
|
|
"message/disposition-notification": {
|
|
"source": "iana",
|
|
"extensions": [
|
|
"disposition-notification"
|
|
]
|
|
},
|
|
"message/external-body": {
|
|
"source": "iana"
|
|
},
|
|
"message/feedback-report": {
|
|
"source": "iana"
|
|
},
|
|
"message/global": {
|
|
"source": "iana",
|
|
"extensions": ["u8msg"]
|
|
},
|
|
"message/global-delivery-status": {
|
|
"source": "iana",
|
|
"extensions": ["u8dsn"]
|
|
},
|
|
"message/global-disposition-notification": {
|
|
"source": "iana",
|
|
"extensions": ["u8mdn"]
|
|
},
|
|
"message/global-headers": {
|
|
"source": "iana",
|
|
"extensions": ["u8hdr"]
|
|
},
|
|
"message/http": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"message/imdn+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"message/news": {
|
|
"source": "iana"
|
|
},
|
|
"message/partial": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"message/rfc822": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["eml","mime"]
|
|
},
|
|
"message/s-http": {
|
|
"source": "iana"
|
|
},
|
|
"message/sip": {
|
|
"source": "iana"
|
|
},
|
|
"message/sipfrag": {
|
|
"source": "iana"
|
|
},
|
|
"message/tracking-status": {
|
|
"source": "iana"
|
|
},
|
|
"message/vnd.si.simp": {
|
|
"source": "iana"
|
|
},
|
|
"message/vnd.wfa.wsc": {
|
|
"source": "iana",
|
|
"extensions": ["wsc"]
|
|
},
|
|
"model/3mf": {
|
|
"source": "iana",
|
|
"extensions": ["3mf"]
|
|
},
|
|
"model/gltf+json": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["gltf"]
|
|
},
|
|
"model/gltf-binary": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["glb"]
|
|
},
|
|
"model/iges": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["igs","iges"]
|
|
},
|
|
"model/mesh": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["msh","mesh","silo"]
|
|
},
|
|
"model/mtl": {
|
|
"source": "iana",
|
|
"extensions": ["mtl"]
|
|
},
|
|
"model/obj": {
|
|
"source": "iana",
|
|
"extensions": ["obj"]
|
|
},
|
|
"model/stl": {
|
|
"source": "iana",
|
|
"extensions": ["stl"]
|
|
},
|
|
"model/vnd.collada+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["dae"]
|
|
},
|
|
"model/vnd.dwf": {
|
|
"source": "iana",
|
|
"extensions": ["dwf"]
|
|
},
|
|
"model/vnd.flatland.3dml": {
|
|
"source": "iana"
|
|
},
|
|
"model/vnd.gdl": {
|
|
"source": "iana",
|
|
"extensions": ["gdl"]
|
|
},
|
|
"model/vnd.gs-gdl": {
|
|
"source": "apache"
|
|
},
|
|
"model/vnd.gs.gdl": {
|
|
"source": "iana"
|
|
},
|
|
"model/vnd.gtw": {
|
|
"source": "iana",
|
|
"extensions": ["gtw"]
|
|
},
|
|
"model/vnd.moml+xml": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"model/vnd.mts": {
|
|
"source": "iana",
|
|
"extensions": ["mts"]
|
|
},
|
|
"model/vnd.opengex": {
|
|
"source": "iana",
|
|
"extensions": ["ogex"]
|
|
},
|
|
"model/vnd.parasolid.transmit.binary": {
|
|
"source": "iana",
|
|
"extensions": ["x_b"]
|
|
},
|
|
"model/vnd.parasolid.transmit.text": {
|
|
"source": "iana",
|
|
"extensions": ["x_t"]
|
|
},
|
|
"model/vnd.rosette.annotated-data-model": {
|
|
"source": "iana"
|
|
},
|
|
"model/vnd.usdz+zip": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["usdz"]
|
|
},
|
|
"model/vnd.valve.source.compiled-map": {
|
|
"source": "iana",
|
|
"extensions": ["bsp"]
|
|
},
|
|
"model/vnd.vtu": {
|
|
"source": "iana",
|
|
"extensions": ["vtu"]
|
|
},
|
|
"model/vrml": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["wrl","vrml"]
|
|
},
|
|
"model/x3d+binary": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["x3db","x3dbz"]
|
|
},
|
|
"model/x3d+fastinfoset": {
|
|
"source": "iana",
|
|
"extensions": ["x3db"]
|
|
},
|
|
"model/x3d+vrml": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["x3dv","x3dvz"]
|
|
},
|
|
"model/x3d+xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["x3d","x3dz"]
|
|
},
|
|
"model/x3d-vrml": {
|
|
"source": "iana",
|
|
"extensions": ["x3dv"]
|
|
},
|
|
"multipart/alternative": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"multipart/appledouble": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/byteranges": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/digest": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/encrypted": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"multipart/form-data": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"multipart/header-set": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/mixed": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/multilingual": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/parallel": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/related": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"multipart/report": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/signed": {
|
|
"source": "iana",
|
|
"compressible": false
|
|
},
|
|
"multipart/vnd.bint.med-plus": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/voice-message": {
|
|
"source": "iana"
|
|
},
|
|
"multipart/x-mixed-replace": {
|
|
"source": "iana"
|
|
},
|
|
"text/1d-interleaved-parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"text/cache-manifest": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["appcache","manifest"]
|
|
},
|
|
"text/calendar": {
|
|
"source": "iana",
|
|
"extensions": ["ics","ifb"]
|
|
},
|
|
"text/calender": {
|
|
"compressible": true
|
|
},
|
|
"text/cmd": {
|
|
"compressible": true
|
|
},
|
|
"text/coffeescript": {
|
|
"extensions": ["coffee","litcoffee"]
|
|
},
|
|
"text/css": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["css"]
|
|
},
|
|
"text/csv": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["csv"]
|
|
},
|
|
"text/csv-schema": {
|
|
"source": "iana"
|
|
},
|
|
"text/directory": {
|
|
"source": "iana"
|
|
},
|
|
"text/dns": {
|
|
"source": "iana"
|
|
},
|
|
"text/ecmascript": {
|
|
"source": "iana"
|
|
},
|
|
"text/encaprtp": {
|
|
"source": "iana"
|
|
},
|
|
"text/enriched": {
|
|
"source": "iana"
|
|
},
|
|
"text/flexfec": {
|
|
"source": "iana"
|
|
},
|
|
"text/fwdred": {
|
|
"source": "iana"
|
|
},
|
|
"text/grammar-ref-list": {
|
|
"source": "iana"
|
|
},
|
|
"text/html": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["html","htm","shtml"]
|
|
},
|
|
"text/jade": {
|
|
"extensions": ["jade"]
|
|
},
|
|
"text/javascript": {
|
|
"source": "iana",
|
|
"compressible": true
|
|
},
|
|
"text/jcr-cnd": {
|
|
"source": "iana"
|
|
},
|
|
"text/jsx": {
|
|
"compressible": true,
|
|
"extensions": ["jsx"]
|
|
},
|
|
"text/less": {
|
|
"compressible": true,
|
|
"extensions": ["less"]
|
|
},
|
|
"text/markdown": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["markdown","md"]
|
|
},
|
|
"text/mathml": {
|
|
"source": "nginx",
|
|
"extensions": ["mml"]
|
|
},
|
|
"text/mdx": {
|
|
"compressible": true,
|
|
"extensions": ["mdx"]
|
|
},
|
|
"text/mizar": {
|
|
"source": "iana"
|
|
},
|
|
"text/n3": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["n3"]
|
|
},
|
|
"text/parameters": {
|
|
"source": "iana",
|
|
"charset": "UTF-8"
|
|
},
|
|
"text/parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"text/plain": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["txt","text","conf","def","list","log","in","ini"]
|
|
},
|
|
"text/provenance-notation": {
|
|
"source": "iana",
|
|
"charset": "UTF-8"
|
|
},
|
|
"text/prs.fallenstein.rst": {
|
|
"source": "iana"
|
|
},
|
|
"text/prs.lines.tag": {
|
|
"source": "iana",
|
|
"extensions": ["dsc"]
|
|
},
|
|
"text/prs.prop.logic": {
|
|
"source": "iana"
|
|
},
|
|
"text/raptorfec": {
|
|
"source": "iana"
|
|
},
|
|
"text/red": {
|
|
"source": "iana"
|
|
},
|
|
"text/rfc822-headers": {
|
|
"source": "iana"
|
|
},
|
|
"text/richtext": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rtx"]
|
|
},
|
|
"text/rtf": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["rtf"]
|
|
},
|
|
"text/rtp-enc-aescm128": {
|
|
"source": "iana"
|
|
},
|
|
"text/rtploopback": {
|
|
"source": "iana"
|
|
},
|
|
"text/rtx": {
|
|
"source": "iana"
|
|
},
|
|
"text/sgml": {
|
|
"source": "iana",
|
|
"extensions": ["sgml","sgm"]
|
|
},
|
|
"text/shex": {
|
|
"extensions": ["shex"]
|
|
},
|
|
"text/slim": {
|
|
"extensions": ["slim","slm"]
|
|
},
|
|
"text/strings": {
|
|
"source": "iana"
|
|
},
|
|
"text/stylus": {
|
|
"extensions": ["stylus","styl"]
|
|
},
|
|
"text/t140": {
|
|
"source": "iana"
|
|
},
|
|
"text/tab-separated-values": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["tsv"]
|
|
},
|
|
"text/troff": {
|
|
"source": "iana",
|
|
"extensions": ["t","tr","roff","man","me","ms"]
|
|
},
|
|
"text/turtle": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"extensions": ["ttl"]
|
|
},
|
|
"text/ulpfec": {
|
|
"source": "iana"
|
|
},
|
|
"text/uri-list": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["uri","uris","urls"]
|
|
},
|
|
"text/vcard": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["vcard"]
|
|
},
|
|
"text/vnd.a": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.abc": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.ascii-art": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.curl": {
|
|
"source": "iana",
|
|
"extensions": ["curl"]
|
|
},
|
|
"text/vnd.curl.dcurl": {
|
|
"source": "apache",
|
|
"extensions": ["dcurl"]
|
|
},
|
|
"text/vnd.curl.mcurl": {
|
|
"source": "apache",
|
|
"extensions": ["mcurl"]
|
|
},
|
|
"text/vnd.curl.scurl": {
|
|
"source": "apache",
|
|
"extensions": ["scurl"]
|
|
},
|
|
"text/vnd.debian.copyright": {
|
|
"source": "iana",
|
|
"charset": "UTF-8"
|
|
},
|
|
"text/vnd.dmclientscript": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.dvb.subtitle": {
|
|
"source": "iana",
|
|
"extensions": ["sub"]
|
|
},
|
|
"text/vnd.esmertec.theme-descriptor": {
|
|
"source": "iana",
|
|
"charset": "UTF-8"
|
|
},
|
|
"text/vnd.ficlab.flt": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.fly": {
|
|
"source": "iana",
|
|
"extensions": ["fly"]
|
|
},
|
|
"text/vnd.fmi.flexstor": {
|
|
"source": "iana",
|
|
"extensions": ["flx"]
|
|
},
|
|
"text/vnd.gml": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.graphviz": {
|
|
"source": "iana",
|
|
"extensions": ["gv"]
|
|
},
|
|
"text/vnd.hgl": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.in3d.3dml": {
|
|
"source": "iana",
|
|
"extensions": ["3dml"]
|
|
},
|
|
"text/vnd.in3d.spot": {
|
|
"source": "iana",
|
|
"extensions": ["spot"]
|
|
},
|
|
"text/vnd.iptc.newsml": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.iptc.nitf": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.latex-z": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.motorola.reflex": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.ms-mediapackage": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.net2phone.commcenter.command": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.radisys.msml-basic-layout": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.senx.warpscript": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.si.uricatalogue": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.sosi": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.sun.j2me.app-descriptor": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"extensions": ["jad"]
|
|
},
|
|
"text/vnd.trolltech.linguist": {
|
|
"source": "iana",
|
|
"charset": "UTF-8"
|
|
},
|
|
"text/vnd.wap.si": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.wap.sl": {
|
|
"source": "iana"
|
|
},
|
|
"text/vnd.wap.wml": {
|
|
"source": "iana",
|
|
"extensions": ["wml"]
|
|
},
|
|
"text/vnd.wap.wmlscript": {
|
|
"source": "iana",
|
|
"extensions": ["wmls"]
|
|
},
|
|
"text/vtt": {
|
|
"source": "iana",
|
|
"charset": "UTF-8",
|
|
"compressible": true,
|
|
"extensions": ["vtt"]
|
|
},
|
|
"text/x-asm": {
|
|
"source": "apache",
|
|
"extensions": ["s","asm"]
|
|
},
|
|
"text/x-c": {
|
|
"source": "apache",
|
|
"extensions": ["c","cc","cxx","cpp","h","hh","dic"]
|
|
},
|
|
"text/x-component": {
|
|
"source": "nginx",
|
|
"extensions": ["htc"]
|
|
},
|
|
"text/x-fortran": {
|
|
"source": "apache",
|
|
"extensions": ["f","for","f77","f90"]
|
|
},
|
|
"text/x-gwt-rpc": {
|
|
"compressible": true
|
|
},
|
|
"text/x-handlebars-template": {
|
|
"extensions": ["hbs"]
|
|
},
|
|
"text/x-java-source": {
|
|
"source": "apache",
|
|
"extensions": ["java"]
|
|
},
|
|
"text/x-jquery-tmpl": {
|
|
"compressible": true
|
|
},
|
|
"text/x-lua": {
|
|
"extensions": ["lua"]
|
|
},
|
|
"text/x-markdown": {
|
|
"compressible": true,
|
|
"extensions": ["mkd"]
|
|
},
|
|
"text/x-nfo": {
|
|
"source": "apache",
|
|
"extensions": ["nfo"]
|
|
},
|
|
"text/x-opml": {
|
|
"source": "apache",
|
|
"extensions": ["opml"]
|
|
},
|
|
"text/x-org": {
|
|
"compressible": true,
|
|
"extensions": ["org"]
|
|
},
|
|
"text/x-pascal": {
|
|
"source": "apache",
|
|
"extensions": ["p","pas"]
|
|
},
|
|
"text/x-processing": {
|
|
"compressible": true,
|
|
"extensions": ["pde"]
|
|
},
|
|
"text/x-sass": {
|
|
"extensions": ["sass"]
|
|
},
|
|
"text/x-scss": {
|
|
"extensions": ["scss"]
|
|
},
|
|
"text/x-setext": {
|
|
"source": "apache",
|
|
"extensions": ["etx"]
|
|
},
|
|
"text/x-sfv": {
|
|
"source": "apache",
|
|
"extensions": ["sfv"]
|
|
},
|
|
"text/x-suse-ymp": {
|
|
"compressible": true,
|
|
"extensions": ["ymp"]
|
|
},
|
|
"text/x-uuencode": {
|
|
"source": "apache",
|
|
"extensions": ["uu"]
|
|
},
|
|
"text/x-vcalendar": {
|
|
"source": "apache",
|
|
"extensions": ["vcs"]
|
|
},
|
|
"text/x-vcard": {
|
|
"source": "apache",
|
|
"extensions": ["vcf"]
|
|
},
|
|
"text/xml": {
|
|
"source": "iana",
|
|
"compressible": true,
|
|
"extensions": ["xml"]
|
|
},
|
|
"text/xml-external-parsed-entity": {
|
|
"source": "iana"
|
|
},
|
|
"text/yaml": {
|
|
"extensions": ["yaml","yml"]
|
|
},
|
|
"video/1d-interleaved-parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"video/3gpp": {
|
|
"source": "iana",
|
|
"extensions": ["3gp","3gpp"]
|
|
},
|
|
"video/3gpp-tt": {
|
|
"source": "iana"
|
|
},
|
|
"video/3gpp2": {
|
|
"source": "iana",
|
|
"extensions": ["3g2"]
|
|
},
|
|
"video/bmpeg": {
|
|
"source": "iana"
|
|
},
|
|
"video/bt656": {
|
|
"source": "iana"
|
|
},
|
|
"video/celb": {
|
|
"source": "iana"
|
|
},
|
|
"video/dv": {
|
|
"source": "iana"
|
|
},
|
|
"video/encaprtp": {
|
|
"source": "iana"
|
|
},
|
|
"video/flexfec": {
|
|
"source": "iana"
|
|
},
|
|
"video/h261": {
|
|
"source": "iana",
|
|
"extensions": ["h261"]
|
|
},
|
|
"video/h263": {
|
|
"source": "iana",
|
|
"extensions": ["h263"]
|
|
},
|
|
"video/h263-1998": {
|
|
"source": "iana"
|
|
},
|
|
"video/h263-2000": {
|
|
"source": "iana"
|
|
},
|
|
"video/h264": {
|
|
"source": "iana",
|
|
"extensions": ["h264"]
|
|
},
|
|
"video/h264-rcdo": {
|
|
"source": "iana"
|
|
},
|
|
"video/h264-svc": {
|
|
"source": "iana"
|
|
},
|
|
"video/h265": {
|
|
"source": "iana"
|
|
},
|
|
"video/iso.segment": {
|
|
"source": "iana"
|
|
},
|
|
"video/jpeg": {
|
|
"source": "iana",
|
|
"extensions": ["jpgv"]
|
|
},
|
|
"video/jpeg2000": {
|
|
"source": "iana"
|
|
},
|
|
"video/jpm": {
|
|
"source": "apache",
|
|
"extensions": ["jpm","jpgm"]
|
|
},
|
|
"video/mj2": {
|
|
"source": "iana",
|
|
"extensions": ["mj2","mjp2"]
|
|
},
|
|
"video/mp1s": {
|
|
"source": "iana"
|
|
},
|
|
"video/mp2p": {
|
|
"source": "iana"
|
|
},
|
|
"video/mp2t": {
|
|
"source": "iana",
|
|
"extensions": ["ts"]
|
|
},
|
|
"video/mp4": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["mp4","mp4v","mpg4"]
|
|
},
|
|
"video/mp4v-es": {
|
|
"source": "iana"
|
|
},
|
|
"video/mpeg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["mpeg","mpg","mpe","m1v","m2v"]
|
|
},
|
|
"video/mpeg4-generic": {
|
|
"source": "iana"
|
|
},
|
|
"video/mpv": {
|
|
"source": "iana"
|
|
},
|
|
"video/nv": {
|
|
"source": "iana"
|
|
},
|
|
"video/ogg": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["ogv"]
|
|
},
|
|
"video/parityfec": {
|
|
"source": "iana"
|
|
},
|
|
"video/pointer": {
|
|
"source": "iana"
|
|
},
|
|
"video/quicktime": {
|
|
"source": "iana",
|
|
"compressible": false,
|
|
"extensions": ["qt","mov"]
|
|
},
|
|
"video/raptorfec": {
|
|
"source": "iana"
|
|
},
|
|
"video/raw": {
|
|
"source": "iana"
|
|
},
|
|
"video/rtp-enc-aescm128": {
|
|
"source": "iana"
|
|
},
|
|
"video/rtploopback": {
|
|
"source": "iana"
|
|
},
|
|
"video/rtx": {
|
|
"source": "iana"
|
|
},
|
|
"video/smpte291": {
|
|
"source": "iana"
|
|
},
|
|
"video/smpte292m": {
|
|
"source": "iana"
|
|
},
|
|
"video/ulpfec": {
|
|
"source": "iana"
|
|
},
|
|
"video/vc1": {
|
|
"source": "iana"
|
|
},
|
|
"video/vc2": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.cctv": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.dece.hd": {
|
|
"source": "iana",
|
|
"extensions": ["uvh","uvvh"]
|
|
},
|
|
"video/vnd.dece.mobile": {
|
|
"source": "iana",
|
|
"extensions": ["uvm","uvvm"]
|
|
},
|
|
"video/vnd.dece.mp4": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.dece.pd": {
|
|
"source": "iana",
|
|
"extensions": ["uvp","uvvp"]
|
|
},
|
|
"video/vnd.dece.sd": {
|
|
"source": "iana",
|
|
"extensions": ["uvs","uvvs"]
|
|
},
|
|
"video/vnd.dece.video": {
|
|
"source": "iana",
|
|
"extensions": ["uvv","uvvv"]
|
|
},
|
|
"video/vnd.directv.mpeg": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.directv.mpeg-tts": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.dlna.mpeg-tts": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.dvb.file": {
|
|
"source": "iana",
|
|
"extensions": ["dvb"]
|
|
},
|
|
"video/vnd.fvt": {
|
|
"source": "iana",
|
|
"extensions": ["fvt"]
|
|
},
|
|
"video/vnd.hns.video": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-1010": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-2005": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-1010": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-2005": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsavc": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsmpeg2": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.motorola.video": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.motorola.videop": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.mpegurl": {
|
|
"source": "iana",
|
|
"extensions": ["mxu","m4u"]
|
|
},
|
|
"video/vnd.ms-playready.media.pyv": {
|
|
"source": "iana",
|
|
"extensions": ["pyv"]
|
|
},
|
|
"video/vnd.nokia.interleaved-multimedia": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.nokia.mp4vr": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.nokia.videovoip": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.objectvideo": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.radgamettools.bink": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.radgamettools.smacker": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg1": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg4": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.sealed.swf": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.sealedmedia.softseal.mov": {
|
|
"source": "iana"
|
|
},
|
|
"video/vnd.uvvu.mp4": {
|
|
"source": "iana",
|
|
"extensions": ["uvu","uvvu"]
|
|
},
|
|
"video/vnd.vivo": {
|
|
"source": "iana",
|
|
"extensions": ["viv"]
|
|
},
|
|
"video/vnd.youtube.yt": {
|
|
"source": "iana"
|
|
},
|
|
"video/vp8": {
|
|
"source": "iana"
|
|
},
|
|
"video/webm": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["webm"]
|
|
},
|
|
"video/x-f4v": {
|
|
"source": "apache",
|
|
"extensions": ["f4v"]
|
|
},
|
|
"video/x-fli": {
|
|
"source": "apache",
|
|
"extensions": ["fli"]
|
|
},
|
|
"video/x-flv": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["flv"]
|
|
},
|
|
"video/x-m4v": {
|
|
"source": "apache",
|
|
"extensions": ["m4v"]
|
|
},
|
|
"video/x-matroska": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["mkv","mk3d","mks"]
|
|
},
|
|
"video/x-mng": {
|
|
"source": "apache",
|
|
"extensions": ["mng"]
|
|
},
|
|
"video/x-ms-asf": {
|
|
"source": "apache",
|
|
"extensions": ["asf","asx"]
|
|
},
|
|
"video/x-ms-vob": {
|
|
"source": "apache",
|
|
"extensions": ["vob"]
|
|
},
|
|
"video/x-ms-wm": {
|
|
"source": "apache",
|
|
"extensions": ["wm"]
|
|
},
|
|
"video/x-ms-wmv": {
|
|
"source": "apache",
|
|
"compressible": false,
|
|
"extensions": ["wmv"]
|
|
},
|
|
"video/x-ms-wmx": {
|
|
"source": "apache",
|
|
"extensions": ["wmx"]
|
|
},
|
|
"video/x-ms-wvx": {
|
|
"source": "apache",
|
|
"extensions": ["wvx"]
|
|
},
|
|
"video/x-msvideo": {
|
|
"source": "apache",
|
|
"extensions": ["avi"]
|
|
},
|
|
"video/x-sgi-movie": {
|
|
"source": "apache",
|
|
"extensions": ["movie"]
|
|
},
|
|
"video/x-smv": {
|
|
"source": "apache",
|
|
"extensions": ["smv"]
|
|
},
|
|
"x-conference/x-cooltalk": {
|
|
"source": "apache",
|
|
"extensions": ["ice"]
|
|
},
|
|
"x-shader/x-fragment": {
|
|
"compressible": true
|
|
},
|
|
"x-shader/x-vertex": {
|
|
"compressible": true
|
|
}
|
|
}
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
/*!
|
|
* mime-db
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* MIT Licensed
|
|
*/
|
|
|
|
/**
|
|
* Module exports.
|
|
*/
|
|
|
|
module.exports = require('./db.json')
|
|
|
|
},{"./db.json":9}],11:[function(require,module,exports){
|
|
/*!
|
|
* mime-types
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
|
|
'use strict'
|
|
|
|
/**
|
|
* Module dependencies.
|
|
* @private
|
|
*/
|
|
|
|
var db = require('mime-db')
|
|
var extname = require('path').extname
|
|
|
|
/**
|
|
* Module variables.
|
|
* @private
|
|
*/
|
|
|
|
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
|
|
var TEXT_TYPE_REGEXP = /^text\//i
|
|
|
|
/**
|
|
* Module exports.
|
|
* @public
|
|
*/
|
|
|
|
exports.charset = charset
|
|
exports.charsets = { lookup: charset }
|
|
exports.contentType = contentType
|
|
exports.extension = extension
|
|
exports.extensions = Object.create(null)
|
|
exports.lookup = lookup
|
|
exports.types = Object.create(null)
|
|
|
|
// Populate the extensions/types maps
|
|
populateMaps(exports.extensions, exports.types)
|
|
|
|
/**
|
|
* Get the default charset for a MIME type.
|
|
*
|
|
* @param {string} type
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function charset (type) {
|
|
if (!type || typeof type !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// TODO: use media-typer
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type)
|
|
var mime = match && db[match[1].toLowerCase()]
|
|
|
|
if (mime && mime.charset) {
|
|
return mime.charset
|
|
}
|
|
|
|
// default text/* to utf-8
|
|
if (match && TEXT_TYPE_REGEXP.test(match[1])) {
|
|
return 'UTF-8'
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* Create a full Content-Type header given a MIME type or extension.
|
|
*
|
|
* @param {string} str
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function contentType (str) {
|
|
// TODO: should this even be in this module?
|
|
if (!str || typeof str !== 'string') {
|
|
return false
|
|
}
|
|
|
|
var mime = str.indexOf('/') === -1
|
|
? exports.lookup(str)
|
|
: str
|
|
|
|
if (!mime) {
|
|
return false
|
|
}
|
|
|
|
// TODO: use content-type or other module
|
|
if (mime.indexOf('charset') === -1) {
|
|
var charset = exports.charset(mime)
|
|
if (charset) mime += '; charset=' + charset.toLowerCase()
|
|
}
|
|
|
|
return mime
|
|
}
|
|
|
|
/**
|
|
* Get the default extension for a MIME type.
|
|
*
|
|
* @param {string} type
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function extension (type) {
|
|
if (!type || typeof type !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// TODO: use media-typer
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type)
|
|
|
|
// get extensions
|
|
var exts = match && exports.extensions[match[1].toLowerCase()]
|
|
|
|
if (!exts || !exts.length) {
|
|
return false
|
|
}
|
|
|
|
return exts[0]
|
|
}
|
|
|
|
/**
|
|
* Lookup the MIME type for a file path/extension.
|
|
*
|
|
* @param {string} path
|
|
* @return {boolean|string}
|
|
*/
|
|
|
|
function lookup (path) {
|
|
if (!path || typeof path !== 'string') {
|
|
return false
|
|
}
|
|
|
|
// get the extension ("ext" or ".ext" or full path)
|
|
var extension = extname('x.' + path)
|
|
.toLowerCase()
|
|
.substr(1)
|
|
|
|
if (!extension) {
|
|
return false
|
|
}
|
|
|
|
return exports.types[extension] || false
|
|
}
|
|
|
|
/**
|
|
* Populate the extensions and types maps.
|
|
* @private
|
|
*/
|
|
|
|
function populateMaps (extensions, types) {
|
|
// source preference (least -> most)
|
|
var preference = ['nginx', 'apache', undefined, 'iana']
|
|
|
|
Object.keys(db).forEach(function forEachMimeType (type) {
|
|
var mime = db[type]
|
|
var exts = mime.extensions
|
|
|
|
if (!exts || !exts.length) {
|
|
return
|
|
}
|
|
|
|
// mime -> extensions
|
|
extensions[type] = exts
|
|
|
|
// extension -> mime
|
|
for (var i = 0; i < exts.length; i++) {
|
|
var extension = exts[i]
|
|
|
|
if (types[extension]) {
|
|
var from = preference.indexOf(db[types[extension]].source)
|
|
var to = preference.indexOf(mime.source)
|
|
|
|
if (types[extension] !== 'application/octet-stream' &&
|
|
(from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
|
|
// skip the remapping
|
|
continue
|
|
}
|
|
}
|
|
|
|
// set the extension -> mime
|
|
types[extension] = type
|
|
}
|
|
})
|
|
}
|
|
|
|
},{"mime-db":10,"path":34}],12:[function(require,module,exports){
|
|
var wrappy = require('wrappy')
|
|
module.exports = wrappy(once)
|
|
module.exports.strict = wrappy(onceStrict)
|
|
|
|
once.proto = once(function () {
|
|
Object.defineProperty(Function.prototype, 'once', {
|
|
value: function () {
|
|
return once(this)
|
|
},
|
|
configurable: true
|
|
})
|
|
|
|
Object.defineProperty(Function.prototype, 'onceStrict', {
|
|
value: function () {
|
|
return onceStrict(this)
|
|
},
|
|
configurable: true
|
|
})
|
|
})
|
|
|
|
function once (fn) {
|
|
var f = function () {
|
|
if (f.called) return f.value
|
|
f.called = true
|
|
return f.value = fn.apply(this, arguments)
|
|
}
|
|
f.called = false
|
|
return f
|
|
}
|
|
|
|
function onceStrict (fn) {
|
|
var f = function () {
|
|
if (f.called)
|
|
throw new Error(f.onceError)
|
|
f.called = true
|
|
return f.value = fn.apply(this, arguments)
|
|
}
|
|
var name = fn.name || 'Function wrapped with `once`'
|
|
f.onceError = name + " shouldn't be called more than once"
|
|
f.called = false
|
|
return f
|
|
}
|
|
|
|
},{"wrappy":23}],13:[function(require,module,exports){
|
|
(function (process,Buffer){
|
|
/*! parse-torrent. MIT License. WebTorrent LLC <https://webtorrent.io/opensource> */
|
|
/* global Blob */
|
|
|
|
const bencode = require('bencode')
|
|
const blobToBuffer = require('blob-to-buffer')
|
|
const fs = require('fs') // browser exclude
|
|
const get = require('simple-get')
|
|
const magnet = require('magnet-uri')
|
|
const path = require('path')
|
|
const sha1 = require('simple-sha1')
|
|
|
|
module.exports = parseTorrent
|
|
module.exports.remote = parseTorrentRemote
|
|
|
|
module.exports.toMagnetURI = magnet.encode
|
|
module.exports.toTorrentFile = encodeTorrentFile
|
|
|
|
/**
|
|
* Parse a torrent identifier (magnet uri, .torrent file, info hash)
|
|
* @param {string|Buffer|Object} torrentId
|
|
* @return {Object}
|
|
*/
|
|
function parseTorrent (torrentId) {
|
|
if (typeof torrentId === 'string' && /^(stream-)?magnet:/.test(torrentId)) {
|
|
// if magnet uri (string)
|
|
const torrentObj = magnet(torrentId)
|
|
|
|
// infoHash won't be defined if a non-bittorrent magnet is passed
|
|
if (!torrentObj.infoHash) {
|
|
throw new Error('Invalid torrent identifier')
|
|
}
|
|
|
|
return torrentObj
|
|
} else if (typeof torrentId === 'string' && (/^[a-f0-9]{40}$/i.test(torrentId) || /^[a-z2-7]{32}$/i.test(torrentId))) {
|
|
// if info hash (hex/base-32 string)
|
|
return magnet(`magnet:?xt=urn:btih:${torrentId}`)
|
|
} else if (Buffer.isBuffer(torrentId) && torrentId.length === 20) {
|
|
// if info hash (buffer)
|
|
return magnet(`magnet:?xt=urn:btih:${torrentId.toString('hex')}`)
|
|
} else if (Buffer.isBuffer(torrentId)) {
|
|
// if .torrent file (buffer)
|
|
return decodeTorrentFile(torrentId) // might throw
|
|
} else if (torrentId && torrentId.infoHash) {
|
|
// if parsed torrent (from `parse-torrent` or `magnet-uri`)
|
|
torrentId.infoHash = torrentId.infoHash.toLowerCase()
|
|
|
|
if (!torrentId.announce) torrentId.announce = []
|
|
|
|
if (typeof torrentId.announce === 'string') {
|
|
torrentId.announce = [torrentId.announce]
|
|
}
|
|
|
|
if (!torrentId.urlList) torrentId.urlList = []
|
|
|
|
return torrentId
|
|
} else {
|
|
throw new Error('Invalid torrent identifier')
|
|
}
|
|
}
|
|
|
|
function parseTorrentRemote (torrentId, cb) {
|
|
let parsedTorrent
|
|
if (typeof cb !== 'function') throw new Error('second argument must be a Function')
|
|
|
|
try {
|
|
parsedTorrent = parseTorrent(torrentId)
|
|
} catch (err) {
|
|
// If torrent fails to parse, it could be a Blob, http/https URL or
|
|
// filesystem path, so don't consider it an error yet.
|
|
}
|
|
|
|
if (parsedTorrent && parsedTorrent.infoHash) {
|
|
process.nextTick(() => {
|
|
cb(null, parsedTorrent)
|
|
})
|
|
} else if (isBlob(torrentId)) {
|
|
blobToBuffer(torrentId, (err, torrentBuf) => {
|
|
if (err) return cb(new Error(`Error converting Blob: ${err.message}`))
|
|
parseOrThrow(torrentBuf)
|
|
})
|
|
} else if (typeof get === 'function' && /^https?:/.test(torrentId)) {
|
|
// http, or https url to torrent file
|
|
get.concat({
|
|
url: torrentId,
|
|
timeout: 30 * 1000,
|
|
headers: { 'user-agent': 'WebTorrent (https://webtorrent.io)' }
|
|
}, (err, res, torrentBuf) => {
|
|
if (err) return cb(new Error(`Error downloading torrent: ${err.message}`))
|
|
parseOrThrow(torrentBuf)
|
|
})
|
|
} else if (typeof fs.readFile === 'function' && typeof torrentId === 'string') {
|
|
// assume it's a filesystem path
|
|
fs.readFile(torrentId, (err, torrentBuf) => {
|
|
if (err) return cb(new Error('Invalid torrent identifier'))
|
|
parseOrThrow(torrentBuf)
|
|
})
|
|
} else {
|
|
process.nextTick(() => {
|
|
cb(new Error('Invalid torrent identifier'))
|
|
})
|
|
}
|
|
|
|
function parseOrThrow (torrentBuf) {
|
|
try {
|
|
parsedTorrent = parseTorrent(torrentBuf)
|
|
} catch (err) {
|
|
return cb(err)
|
|
}
|
|
if (parsedTorrent && parsedTorrent.infoHash) cb(null, parsedTorrent)
|
|
else cb(new Error('Invalid torrent identifier'))
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse a torrent. Throws an exception if the torrent is missing required fields.
|
|
* @param {Buffer|Object} torrent
|
|
* @return {Object} parsed torrent
|
|
*/
|
|
function decodeTorrentFile (torrent) {
|
|
if (Buffer.isBuffer(torrent)) {
|
|
torrent = bencode.decode(torrent)
|
|
}
|
|
|
|
// sanity check
|
|
ensure(torrent.info, 'info')
|
|
ensure(torrent.info['name.utf-8'] || torrent.info.name, 'info.name')
|
|
ensure(torrent.info['piece length'], 'info[\'piece length\']')
|
|
ensure(torrent.info.pieces, 'info.pieces')
|
|
|
|
if (torrent.info.files) {
|
|
torrent.info.files.forEach(file => {
|
|
ensure(typeof file.length === 'number', 'info.files[0].length')
|
|
ensure(file['path.utf-8'] || file.path, 'info.files[0].path')
|
|
})
|
|
} else {
|
|
ensure(typeof torrent.info.length === 'number', 'info.length')
|
|
}
|
|
|
|
const result = {
|
|
info: torrent.info,
|
|
infoBuffer: bencode.encode(torrent.info),
|
|
name: (torrent.info['name.utf-8'] || torrent.info.name).toString(),
|
|
announce: []
|
|
}
|
|
|
|
result.infoHash = sha1.sync(result.infoBuffer)
|
|
result.infoHashBuffer = Buffer.from(result.infoHash, 'hex')
|
|
|
|
if (torrent.info.private !== undefined) result.private = !!torrent.info.private
|
|
|
|
if (torrent['creation date']) result.created = new Date(torrent['creation date'] * 1000)
|
|
if (torrent['created by']) result.createdBy = torrent['created by'].toString()
|
|
|
|
if (Buffer.isBuffer(torrent.comment)) result.comment = torrent.comment.toString()
|
|
|
|
// announce and announce-list will be missing if metadata fetched via ut_metadata
|
|
if (Array.isArray(torrent['announce-list']) && torrent['announce-list'].length > 0) {
|
|
torrent['announce-list'].forEach(urls => {
|
|
urls.forEach(url => {
|
|
result.announce.push(url.toString())
|
|
})
|
|
})
|
|
} else if (torrent.announce) {
|
|
result.announce.push(torrent.announce.toString())
|
|
}
|
|
|
|
// handle url-list (BEP19 / web seeding)
|
|
if (Buffer.isBuffer(torrent['url-list'])) {
|
|
// some clients set url-list to empty string
|
|
torrent['url-list'] = torrent['url-list'].length > 0
|
|
? [torrent['url-list']]
|
|
: []
|
|
}
|
|
result.urlList = (torrent['url-list'] || []).map(url => url.toString())
|
|
|
|
// remove duplicates by converting to Set and back
|
|
result.announce = Array.from(new Set(result.announce))
|
|
result.urlList = Array.from(new Set(result.urlList))
|
|
|
|
const files = torrent.info.files || [torrent.info]
|
|
result.files = files.map((file, i) => {
|
|
const parts = [].concat(result.name, file['path.utf-8'] || file.path || []).map(p => p.toString())
|
|
return {
|
|
path: path.join.apply(null, [path.sep].concat(parts)).slice(1),
|
|
name: parts[parts.length - 1],
|
|
length: file.length,
|
|
offset: files.slice(0, i).reduce(sumLength, 0)
|
|
}
|
|
})
|
|
|
|
result.length = files.reduce(sumLength, 0)
|
|
|
|
const lastFile = result.files[result.files.length - 1]
|
|
|
|
result.pieceLength = torrent.info['piece length']
|
|
result.lastPieceLength = ((lastFile.offset + lastFile.length) % result.pieceLength) || result.pieceLength
|
|
result.pieces = splitPieces(torrent.info.pieces)
|
|
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Convert a parsed torrent object back into a .torrent file buffer.
|
|
* @param {Object} parsed parsed torrent
|
|
* @return {Buffer}
|
|
*/
|
|
function encodeTorrentFile (parsed) {
|
|
const torrent = {
|
|
info: parsed.info
|
|
}
|
|
|
|
torrent['announce-list'] = (parsed.announce || []).map(url => {
|
|
if (!torrent.announce) torrent.announce = url
|
|
url = Buffer.from(url, 'utf8')
|
|
return [url]
|
|
})
|
|
|
|
torrent['url-list'] = parsed.urlList || []
|
|
|
|
if (parsed.private !== undefined) {
|
|
torrent.private = Number(parsed.private)
|
|
}
|
|
|
|
if (parsed.created) {
|
|
torrent['creation date'] = (parsed.created.getTime() / 1000) | 0
|
|
}
|
|
|
|
if (parsed.createdBy) {
|
|
torrent['created by'] = parsed.createdBy
|
|
}
|
|
|
|
if (parsed.comment) {
|
|
torrent.comment = parsed.comment
|
|
}
|
|
|
|
return bencode.encode(torrent)
|
|
}
|
|
|
|
/**
|
|
* Check if `obj` is a W3C `Blob` or `File` object
|
|
* @param {*} obj
|
|
* @return {boolean}
|
|
*/
|
|
function isBlob (obj) {
|
|
return typeof Blob !== 'undefined' && obj instanceof Blob
|
|
}
|
|
|
|
function sumLength (sum, file) {
|
|
return sum + file.length
|
|
}
|
|
|
|
function splitPieces (buf) {
|
|
const pieces = []
|
|
for (let i = 0; i < buf.length; i += 20) {
|
|
pieces.push(buf.slice(i, i + 20).toString('hex'))
|
|
}
|
|
return pieces
|
|
}
|
|
|
|
function ensure (bool, fieldName) {
|
|
if (!bool) throw new Error(`Torrent is missing required field: ${fieldName}`)
|
|
}
|
|
|
|
// Workaround Browserify v13 bug
|
|
// https://github.com/substack/node-browserify/issues/1483
|
|
;(() => { Buffer.alloc(0) })()
|
|
|
|
}).call(this,require('_process'),require("buffer").Buffer)
|
|
},{"_process":35,"bencode":4,"blob-to-buffer":5,"buffer":28,"fs":27,"magnet-uri":8,"path":34,"simple-get":17,"simple-sha1":18}],14:[function(require,module,exports){
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
if(typeof exports === 'object' && typeof module === 'object')
|
|
module.exports = factory();
|
|
else if(typeof define === 'function' && define.amd)
|
|
define([], factory);
|
|
else if(typeof exports === 'object')
|
|
exports["Rusha"] = factory();
|
|
else
|
|
root["Rusha"] = factory();
|
|
})(typeof self !== 'undefined' ? self : this, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 3);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ([
|
|
/* 0 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/* eslint-env commonjs, browser */
|
|
|
|
var RushaCore = __webpack_require__(5);
|
|
|
|
var _require = __webpack_require__(1),
|
|
toHex = _require.toHex,
|
|
ceilHeapSize = _require.ceilHeapSize;
|
|
|
|
var conv = __webpack_require__(6);
|
|
|
|
// Calculate the length of buffer that the sha1 routine uses
|
|
// including the padding.
|
|
var padlen = function (len) {
|
|
for (len += 9; len % 64 > 0; len += 1) {}
|
|
return len;
|
|
};
|
|
|
|
var padZeroes = function (bin, len) {
|
|
var h8 = new Uint8Array(bin.buffer);
|
|
var om = len % 4,
|
|
align = len - om;
|
|
switch (om) {
|
|
case 0:
|
|
h8[align + 3] = 0;
|
|
case 1:
|
|
h8[align + 2] = 0;
|
|
case 2:
|
|
h8[align + 1] = 0;
|
|
case 3:
|
|
h8[align + 0] = 0;
|
|
}
|
|
for (var i = (len >> 2) + 1; i < bin.length; i++) {
|
|
bin[i] = 0;
|
|
}
|
|
};
|
|
|
|
var padData = function (bin, chunkLen, msgLen) {
|
|
bin[chunkLen >> 2] |= 0x80 << 24 - (chunkLen % 4 << 3);
|
|
// To support msgLen >= 2 GiB, use a float division when computing the
|
|
// high 32-bits of the big-endian message length in bits.
|
|
bin[((chunkLen >> 2) + 2 & ~0x0f) + 14] = msgLen / (1 << 29) | 0;
|
|
bin[((chunkLen >> 2) + 2 & ~0x0f) + 15] = msgLen << 3;
|
|
};
|
|
|
|
var getRawDigest = function (heap, padMaxChunkLen) {
|
|
var io = new Int32Array(heap, padMaxChunkLen + 320, 5);
|
|
var out = new Int32Array(5);
|
|
var arr = new DataView(out.buffer);
|
|
arr.setInt32(0, io[0], false);
|
|
arr.setInt32(4, io[1], false);
|
|
arr.setInt32(8, io[2], false);
|
|
arr.setInt32(12, io[3], false);
|
|
arr.setInt32(16, io[4], false);
|
|
return out;
|
|
};
|
|
|
|
var Rusha = function () {
|
|
function Rusha(chunkSize) {
|
|
_classCallCheck(this, Rusha);
|
|
|
|
chunkSize = chunkSize || 64 * 1024;
|
|
if (chunkSize % 64 > 0) {
|
|
throw new Error('Chunk size must be a multiple of 128 bit');
|
|
}
|
|
this._offset = 0;
|
|
this._maxChunkLen = chunkSize;
|
|
this._padMaxChunkLen = padlen(chunkSize);
|
|
// The size of the heap is the sum of:
|
|
// 1. The padded input message size
|
|
// 2. The extended space the algorithm needs (320 byte)
|
|
// 3. The 160 bit state the algoritm uses
|
|
this._heap = new ArrayBuffer(ceilHeapSize(this._padMaxChunkLen + 320 + 20));
|
|
this._h32 = new Int32Array(this._heap);
|
|
this._h8 = new Int8Array(this._heap);
|
|
this._core = new RushaCore({ Int32Array: Int32Array }, {}, this._heap);
|
|
}
|
|
|
|
Rusha.prototype._initState = function _initState(heap, padMsgLen) {
|
|
this._offset = 0;
|
|
var io = new Int32Array(heap, padMsgLen + 320, 5);
|
|
io[0] = 1732584193;
|
|
io[1] = -271733879;
|
|
io[2] = -1732584194;
|
|
io[3] = 271733878;
|
|
io[4] = -1009589776;
|
|
};
|
|
|
|
Rusha.prototype._padChunk = function _padChunk(chunkLen, msgLen) {
|
|
var padChunkLen = padlen(chunkLen);
|
|
var view = new Int32Array(this._heap, 0, padChunkLen >> 2);
|
|
padZeroes(view, chunkLen);
|
|
padData(view, chunkLen, msgLen);
|
|
return padChunkLen;
|
|
};
|
|
|
|
Rusha.prototype._write = function _write(data, chunkOffset, chunkLen, off) {
|
|
conv(data, this._h8, this._h32, chunkOffset, chunkLen, off || 0);
|
|
};
|
|
|
|
Rusha.prototype._coreCall = function _coreCall(data, chunkOffset, chunkLen, msgLen, finalize) {
|
|
var padChunkLen = chunkLen;
|
|
this._write(data, chunkOffset, chunkLen);
|
|
if (finalize) {
|
|
padChunkLen = this._padChunk(chunkLen, msgLen);
|
|
}
|
|
this._core.hash(padChunkLen, this._padMaxChunkLen);
|
|
};
|
|
|
|
Rusha.prototype.rawDigest = function rawDigest(str) {
|
|
var msgLen = str.byteLength || str.length || str.size || 0;
|
|
this._initState(this._heap, this._padMaxChunkLen);
|
|
var chunkOffset = 0,
|
|
chunkLen = this._maxChunkLen;
|
|
for (chunkOffset = 0; msgLen > chunkOffset + chunkLen; chunkOffset += chunkLen) {
|
|
this._coreCall(str, chunkOffset, chunkLen, msgLen, false);
|
|
}
|
|
this._coreCall(str, chunkOffset, msgLen - chunkOffset, msgLen, true);
|
|
return getRawDigest(this._heap, this._padMaxChunkLen);
|
|
};
|
|
|
|
Rusha.prototype.digest = function digest(str) {
|
|
return toHex(this.rawDigest(str).buffer);
|
|
};
|
|
|
|
Rusha.prototype.digestFromString = function digestFromString(str) {
|
|
return this.digest(str);
|
|
};
|
|
|
|
Rusha.prototype.digestFromBuffer = function digestFromBuffer(str) {
|
|
return this.digest(str);
|
|
};
|
|
|
|
Rusha.prototype.digestFromArrayBuffer = function digestFromArrayBuffer(str) {
|
|
return this.digest(str);
|
|
};
|
|
|
|
Rusha.prototype.resetState = function resetState() {
|
|
this._initState(this._heap, this._padMaxChunkLen);
|
|
return this;
|
|
};
|
|
|
|
Rusha.prototype.append = function append(chunk) {
|
|
var chunkOffset = 0;
|
|
var chunkLen = chunk.byteLength || chunk.length || chunk.size || 0;
|
|
var turnOffset = this._offset % this._maxChunkLen;
|
|
var inputLen = void 0;
|
|
|
|
this._offset += chunkLen;
|
|
while (chunkOffset < chunkLen) {
|
|
inputLen = Math.min(chunkLen - chunkOffset, this._maxChunkLen - turnOffset);
|
|
this._write(chunk, chunkOffset, inputLen, turnOffset);
|
|
turnOffset += inputLen;
|
|
chunkOffset += inputLen;
|
|
if (turnOffset === this._maxChunkLen) {
|
|
this._core.hash(this._maxChunkLen, this._padMaxChunkLen);
|
|
turnOffset = 0;
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Rusha.prototype.getState = function getState() {
|
|
var turnOffset = this._offset % this._maxChunkLen;
|
|
var heap = void 0;
|
|
if (!turnOffset) {
|
|
var io = new Int32Array(this._heap, this._padMaxChunkLen + 320, 5);
|
|
heap = io.buffer.slice(io.byteOffset, io.byteOffset + io.byteLength);
|
|
} else {
|
|
heap = this._heap.slice(0);
|
|
}
|
|
return {
|
|
offset: this._offset,
|
|
heap: heap
|
|
};
|
|
};
|
|
|
|
Rusha.prototype.setState = function setState(state) {
|
|
this._offset = state.offset;
|
|
if (state.heap.byteLength === 20) {
|
|
var io = new Int32Array(this._heap, this._padMaxChunkLen + 320, 5);
|
|
io.set(new Int32Array(state.heap));
|
|
} else {
|
|
this._h32.set(new Int32Array(state.heap));
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Rusha.prototype.rawEnd = function rawEnd() {
|
|
var msgLen = this._offset;
|
|
var chunkLen = msgLen % this._maxChunkLen;
|
|
var padChunkLen = this._padChunk(chunkLen, msgLen);
|
|
this._core.hash(padChunkLen, this._padMaxChunkLen);
|
|
var result = getRawDigest(this._heap, this._padMaxChunkLen);
|
|
this._initState(this._heap, this._padMaxChunkLen);
|
|
return result;
|
|
};
|
|
|
|
Rusha.prototype.end = function end() {
|
|
return toHex(this.rawEnd().buffer);
|
|
};
|
|
|
|
return Rusha;
|
|
}();
|
|
|
|
module.exports = Rusha;
|
|
module.exports._core = RushaCore;
|
|
|
|
/***/ }),
|
|
/* 1 */
|
|
/***/ (function(module, exports) {
|
|
|
|
/* eslint-env commonjs, browser */
|
|
|
|
//
|
|
// toHex
|
|
//
|
|
|
|
var precomputedHex = new Array(256);
|
|
for (var i = 0; i < 256; i++) {
|
|
precomputedHex[i] = (i < 0x10 ? '0' : '') + i.toString(16);
|
|
}
|
|
|
|
module.exports.toHex = function (arrayBuffer) {
|
|
var binarray = new Uint8Array(arrayBuffer);
|
|
var res = new Array(arrayBuffer.byteLength);
|
|
for (var _i = 0; _i < res.length; _i++) {
|
|
res[_i] = precomputedHex[binarray[_i]];
|
|
}
|
|
return res.join('');
|
|
};
|
|
|
|
//
|
|
// ceilHeapSize
|
|
//
|
|
|
|
module.exports.ceilHeapSize = function (v) {
|
|
// The asm.js spec says:
|
|
// The heap object's byteLength must be either
|
|
// 2^n for n in [12, 24) or 2^24 * n for n ≥ 1.
|
|
// Also, byteLengths smaller than 2^16 are deprecated.
|
|
var p = 0;
|
|
// If v is smaller than 2^16, the smallest possible solution
|
|
// is 2^16.
|
|
if (v <= 65536) return 65536;
|
|
// If v < 2^24, we round up to 2^n,
|
|
// otherwise we round up to 2^24 * n.
|
|
if (v < 16777216) {
|
|
for (p = 1; p < v; p = p << 1) {}
|
|
} else {
|
|
for (p = 16777216; p < v; p += 16777216) {}
|
|
}
|
|
return p;
|
|
};
|
|
|
|
//
|
|
// isDedicatedWorkerScope
|
|
//
|
|
|
|
module.exports.isDedicatedWorkerScope = function (self) {
|
|
var isRunningInWorker = 'WorkerGlobalScope' in self && self instanceof self.WorkerGlobalScope;
|
|
var isRunningInSharedWorker = 'SharedWorkerGlobalScope' in self && self instanceof self.SharedWorkerGlobalScope;
|
|
var isRunningInServiceWorker = 'ServiceWorkerGlobalScope' in self && self instanceof self.ServiceWorkerGlobalScope;
|
|
|
|
// Detects whether we run inside a dedicated worker or not.
|
|
//
|
|
// We can't just check for `DedicatedWorkerGlobalScope`, since IE11
|
|
// has a bug where it only supports `WorkerGlobalScope`.
|
|
//
|
|
// Therefore, we consider us as running inside a dedicated worker
|
|
// when we are running inside a worker, but not in a shared or service worker.
|
|
//
|
|
// When new types of workers are introduced, we will need to adjust this code.
|
|
return isRunningInWorker && !isRunningInSharedWorker && !isRunningInServiceWorker;
|
|
};
|
|
|
|
/***/ }),
|
|
/* 2 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* eslint-env commonjs, worker */
|
|
|
|
module.exports = function () {
|
|
var Rusha = __webpack_require__(0);
|
|
|
|
var hashData = function (hasher, data, cb) {
|
|
try {
|
|
return cb(null, hasher.digest(data));
|
|
} catch (e) {
|
|
return cb(e);
|
|
}
|
|
};
|
|
|
|
var hashFile = function (hasher, readTotal, blockSize, file, cb) {
|
|
var reader = new self.FileReader();
|
|
reader.onloadend = function onloadend() {
|
|
if (reader.error) {
|
|
return cb(reader.error);
|
|
}
|
|
var buffer = reader.result;
|
|
readTotal += reader.result.byteLength;
|
|
try {
|
|
hasher.append(buffer);
|
|
} catch (e) {
|
|
cb(e);
|
|
return;
|
|
}
|
|
if (readTotal < file.size) {
|
|
hashFile(hasher, readTotal, blockSize, file, cb);
|
|
} else {
|
|
cb(null, hasher.end());
|
|
}
|
|
};
|
|
reader.readAsArrayBuffer(file.slice(readTotal, readTotal + blockSize));
|
|
};
|
|
|
|
var workerBehaviourEnabled = true;
|
|
|
|
self.onmessage = function (event) {
|
|
if (!workerBehaviourEnabled) {
|
|
return;
|
|
}
|
|
|
|
var data = event.data.data,
|
|
file = event.data.file,
|
|
id = event.data.id;
|
|
if (typeof id === 'undefined') return;
|
|
if (!file && !data) return;
|
|
var blockSize = event.data.blockSize || 4 * 1024 * 1024;
|
|
var hasher = new Rusha(blockSize);
|
|
hasher.resetState();
|
|
var done = function (err, hash) {
|
|
if (!err) {
|
|
self.postMessage({ id: id, hash: hash });
|
|
} else {
|
|
self.postMessage({ id: id, error: err.name });
|
|
}
|
|
};
|
|
if (data) hashData(hasher, data, done);
|
|
if (file) hashFile(hasher, 0, blockSize, file, done);
|
|
};
|
|
|
|
return function () {
|
|
workerBehaviourEnabled = false;
|
|
};
|
|
};
|
|
|
|
/***/ }),
|
|
/* 3 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* eslint-env commonjs, browser */
|
|
|
|
var work = __webpack_require__(4);
|
|
var Rusha = __webpack_require__(0);
|
|
var createHash = __webpack_require__(7);
|
|
var runWorker = __webpack_require__(2);
|
|
|
|
var _require = __webpack_require__(1),
|
|
isDedicatedWorkerScope = _require.isDedicatedWorkerScope;
|
|
|
|
var isRunningInDedicatedWorker = typeof self !== 'undefined' && isDedicatedWorkerScope(self);
|
|
|
|
Rusha.disableWorkerBehaviour = isRunningInDedicatedWorker ? runWorker() : function () {};
|
|
|
|
Rusha.createWorker = function () {
|
|
var worker = work(/*require.resolve*/(2));
|
|
var terminate = worker.terminate;
|
|
worker.terminate = function () {
|
|
URL.revokeObjectURL(worker.objectURL);
|
|
terminate.call(worker);
|
|
};
|
|
return worker;
|
|
};
|
|
|
|
Rusha.createHash = createHash;
|
|
|
|
module.exports = Rusha;
|
|
|
|
/***/ }),
|
|
/* 4 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
function webpackBootstrapFunc (modules) {
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId])
|
|
/******/ return installedModules[moduleId].exports;
|
|
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
|
|
/******/ // identity function for calling harmony imports with the correct context
|
|
/******/ __webpack_require__.i = function(value) { return value; };
|
|
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "/";
|
|
|
|
/******/ // on error function for async loading
|
|
/******/ __webpack_require__.oe = function(err) { console.error(err); throw err; };
|
|
|
|
var f = __webpack_require__(__webpack_require__.s = ENTRY_MODULE)
|
|
return f.default || f // try to call default if defined to also support babel esmodule exports
|
|
}
|
|
|
|
var moduleNameReqExp = '[\\.|\\-|\\+|\\w|\/|@]+'
|
|
var dependencyRegExp = '\\((\/\\*.*?\\*\/)?\s?.*?(' + moduleNameReqExp + ').*?\\)' // additional chars when output.pathinfo is true
|
|
|
|
// http://stackoverflow.com/a/2593661/130442
|
|
function quoteRegExp (str) {
|
|
return (str + '').replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&')
|
|
}
|
|
|
|
function getModuleDependencies (sources, module, queueName) {
|
|
var retval = {}
|
|
retval[queueName] = []
|
|
|
|
var fnString = module.toString()
|
|
var wrapperSignature = fnString.match(/^function\s?\(\w+,\s*\w+,\s*(\w+)\)/)
|
|
if (!wrapperSignature) return retval
|
|
var webpackRequireName = wrapperSignature[1]
|
|
|
|
// main bundle deps
|
|
var re = new RegExp('(\\\\n|\\W)' + quoteRegExp(webpackRequireName) + dependencyRegExp, 'g')
|
|
var match
|
|
while ((match = re.exec(fnString))) {
|
|
if (match[3] === 'dll-reference') continue
|
|
retval[queueName].push(match[3])
|
|
}
|
|
|
|
// dll deps
|
|
re = new RegExp('\\(' + quoteRegExp(webpackRequireName) + '\\("(dll-reference\\s(' + moduleNameReqExp + '))"\\)\\)' + dependencyRegExp, 'g')
|
|
while ((match = re.exec(fnString))) {
|
|
if (!sources[match[2]]) {
|
|
retval[queueName].push(match[1])
|
|
sources[match[2]] = __webpack_require__(match[1]).m
|
|
}
|
|
retval[match[2]] = retval[match[2]] || []
|
|
retval[match[2]].push(match[4])
|
|
}
|
|
|
|
return retval
|
|
}
|
|
|
|
function hasValuesInQueues (queues) {
|
|
var keys = Object.keys(queues)
|
|
return keys.reduce(function (hasValues, key) {
|
|
return hasValues || queues[key].length > 0
|
|
}, false)
|
|
}
|
|
|
|
function getRequiredModules (sources, moduleId) {
|
|
var modulesQueue = {
|
|
main: [moduleId]
|
|
}
|
|
var requiredModules = {
|
|
main: []
|
|
}
|
|
var seenModules = {
|
|
main: {}
|
|
}
|
|
|
|
while (hasValuesInQueues(modulesQueue)) {
|
|
var queues = Object.keys(modulesQueue)
|
|
for (var i = 0; i < queues.length; i++) {
|
|
var queueName = queues[i]
|
|
var queue = modulesQueue[queueName]
|
|
var moduleToCheck = queue.pop()
|
|
seenModules[queueName] = seenModules[queueName] || {}
|
|
if (seenModules[queueName][moduleToCheck] || !sources[queueName][moduleToCheck]) continue
|
|
seenModules[queueName][moduleToCheck] = true
|
|
requiredModules[queueName] = requiredModules[queueName] || []
|
|
requiredModules[queueName].push(moduleToCheck)
|
|
var newModules = getModuleDependencies(sources, sources[queueName][moduleToCheck], queueName)
|
|
var newModulesKeys = Object.keys(newModules)
|
|
for (var j = 0; j < newModulesKeys.length; j++) {
|
|
modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]] || []
|
|
modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]].concat(newModules[newModulesKeys[j]])
|
|
}
|
|
}
|
|
}
|
|
|
|
return requiredModules
|
|
}
|
|
|
|
module.exports = function (moduleId, options) {
|
|
options = options || {}
|
|
var sources = {
|
|
main: __webpack_require__.m
|
|
}
|
|
|
|
var requiredModules = options.all ? { main: Object.keys(sources) } : getRequiredModules(sources, moduleId)
|
|
|
|
var src = ''
|
|
|
|
Object.keys(requiredModules).filter(function (m) { return m !== 'main' }).forEach(function (module) {
|
|
var entryModule = 0
|
|
while (requiredModules[module][entryModule]) {
|
|
entryModule++
|
|
}
|
|
requiredModules[module].push(entryModule)
|
|
sources[module][entryModule] = '(function(module, exports, __webpack_require__) { module.exports = __webpack_require__; })'
|
|
src = src + 'var ' + module + ' = (' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(entryModule)) + ')({' + requiredModules[module].map(function (id) { return '' + JSON.stringify(id) + ': ' + sources[module][id].toString() }).join(',') + '});\n'
|
|
})
|
|
|
|
src = src + '(' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(moduleId)) + ')({' + requiredModules.main.map(function (id) { return '' + JSON.stringify(id) + ': ' + sources.main[id].toString() }).join(',') + '})(self);'
|
|
|
|
var blob = new window.Blob([src], { type: 'text/javascript' })
|
|
if (options.bare) { return blob }
|
|
|
|
var URL = window.URL || window.webkitURL || window.mozURL || window.msURL
|
|
|
|
var workerUrl = URL.createObjectURL(blob)
|
|
var worker = new window.Worker(workerUrl)
|
|
worker.objectURL = workerUrl
|
|
|
|
return worker
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
/* 5 */
|
|
/***/ (function(module, exports) {
|
|
|
|
// The low-level RushCore module provides the heart of Rusha,
|
|
// a high-speed sha1 implementation working on an Int32Array heap.
|
|
// At first glance, the implementation seems complicated, however
|
|
// with the SHA1 spec at hand, it is obvious this almost a textbook
|
|
// implementation that has a few functions hand-inlined and a few loops
|
|
// hand-unrolled.
|
|
module.exports = function RushaCore(stdlib$846, foreign$847, heap$848) {
|
|
'use asm';
|
|
var H$849 = new stdlib$846.Int32Array(heap$848);
|
|
function hash$850(k$851, x$852) {
|
|
// k in bytes
|
|
k$851 = k$851 | 0;
|
|
x$852 = x$852 | 0;
|
|
var i$853 = 0, j$854 = 0, y0$855 = 0, z0$856 = 0, y1$857 = 0, z1$858 = 0, y2$859 = 0, z2$860 = 0, y3$861 = 0, z3$862 = 0, y4$863 = 0, z4$864 = 0, t0$865 = 0, t1$866 = 0;
|
|
y0$855 = H$849[x$852 + 320 >> 2] | 0;
|
|
y1$857 = H$849[x$852 + 324 >> 2] | 0;
|
|
y2$859 = H$849[x$852 + 328 >> 2] | 0;
|
|
y3$861 = H$849[x$852 + 332 >> 2] | 0;
|
|
y4$863 = H$849[x$852 + 336 >> 2] | 0;
|
|
for (i$853 = 0; (i$853 | 0) < (k$851 | 0); i$853 = i$853 + 64 | 0) {
|
|
z0$856 = y0$855;
|
|
z1$858 = y1$857;
|
|
z2$860 = y2$859;
|
|
z3$862 = y3$861;
|
|
z4$864 = y4$863;
|
|
for (j$854 = 0; (j$854 | 0) < 64; j$854 = j$854 + 4 | 0) {
|
|
t1$866 = H$849[i$853 + j$854 >> 2] | 0;
|
|
t0$865 = ((y0$855 << 5 | y0$855 >>> 27) + (y1$857 & y2$859 | ~y1$857 & y3$861) | 0) + ((t1$866 + y4$863 | 0) + 1518500249 | 0) | 0;
|
|
y4$863 = y3$861;
|
|
y3$861 = y2$859;
|
|
y2$859 = y1$857 << 30 | y1$857 >>> 2;
|
|
y1$857 = y0$855;
|
|
y0$855 = t0$865;
|
|
H$849[k$851 + j$854 >> 2] = t1$866;
|
|
}
|
|
for (j$854 = k$851 + 64 | 0; (j$854 | 0) < (k$851 + 80 | 0); j$854 = j$854 + 4 | 0) {
|
|
t1$866 = (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) << 1 | (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) >>> 31;
|
|
t0$865 = ((y0$855 << 5 | y0$855 >>> 27) + (y1$857 & y2$859 | ~y1$857 & y3$861) | 0) + ((t1$866 + y4$863 | 0) + 1518500249 | 0) | 0;
|
|
y4$863 = y3$861;
|
|
y3$861 = y2$859;
|
|
y2$859 = y1$857 << 30 | y1$857 >>> 2;
|
|
y1$857 = y0$855;
|
|
y0$855 = t0$865;
|
|
H$849[j$854 >> 2] = t1$866;
|
|
}
|
|
for (j$854 = k$851 + 80 | 0; (j$854 | 0) < (k$851 + 160 | 0); j$854 = j$854 + 4 | 0) {
|
|
t1$866 = (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) << 1 | (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) >>> 31;
|
|
t0$865 = ((y0$855 << 5 | y0$855 >>> 27) + (y1$857 ^ y2$859 ^ y3$861) | 0) + ((t1$866 + y4$863 | 0) + 1859775393 | 0) | 0;
|
|
y4$863 = y3$861;
|
|
y3$861 = y2$859;
|
|
y2$859 = y1$857 << 30 | y1$857 >>> 2;
|
|
y1$857 = y0$855;
|
|
y0$855 = t0$865;
|
|
H$849[j$854 >> 2] = t1$866;
|
|
}
|
|
for (j$854 = k$851 + 160 | 0; (j$854 | 0) < (k$851 + 240 | 0); j$854 = j$854 + 4 | 0) {
|
|
t1$866 = (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) << 1 | (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) >>> 31;
|
|
t0$865 = ((y0$855 << 5 | y0$855 >>> 27) + (y1$857 & y2$859 | y1$857 & y3$861 | y2$859 & y3$861) | 0) + ((t1$866 + y4$863 | 0) - 1894007588 | 0) | 0;
|
|
y4$863 = y3$861;
|
|
y3$861 = y2$859;
|
|
y2$859 = y1$857 << 30 | y1$857 >>> 2;
|
|
y1$857 = y0$855;
|
|
y0$855 = t0$865;
|
|
H$849[j$854 >> 2] = t1$866;
|
|
}
|
|
for (j$854 = k$851 + 240 | 0; (j$854 | 0) < (k$851 + 320 | 0); j$854 = j$854 + 4 | 0) {
|
|
t1$866 = (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) << 1 | (H$849[j$854 - 12 >> 2] ^ H$849[j$854 - 32 >> 2] ^ H$849[j$854 - 56 >> 2] ^ H$849[j$854 - 64 >> 2]) >>> 31;
|
|
t0$865 = ((y0$855 << 5 | y0$855 >>> 27) + (y1$857 ^ y2$859 ^ y3$861) | 0) + ((t1$866 + y4$863 | 0) - 899497514 | 0) | 0;
|
|
y4$863 = y3$861;
|
|
y3$861 = y2$859;
|
|
y2$859 = y1$857 << 30 | y1$857 >>> 2;
|
|
y1$857 = y0$855;
|
|
y0$855 = t0$865;
|
|
H$849[j$854 >> 2] = t1$866;
|
|
}
|
|
y0$855 = y0$855 + z0$856 | 0;
|
|
y1$857 = y1$857 + z1$858 | 0;
|
|
y2$859 = y2$859 + z2$860 | 0;
|
|
y3$861 = y3$861 + z3$862 | 0;
|
|
y4$863 = y4$863 + z4$864 | 0;
|
|
}
|
|
H$849[x$852 + 320 >> 2] = y0$855;
|
|
H$849[x$852 + 324 >> 2] = y1$857;
|
|
H$849[x$852 + 328 >> 2] = y2$859;
|
|
H$849[x$852 + 332 >> 2] = y3$861;
|
|
H$849[x$852 + 336 >> 2] = y4$863;
|
|
}
|
|
return { hash: hash$850 };
|
|
};
|
|
|
|
/***/ }),
|
|
/* 6 */
|
|
/***/ (function(module, exports) {
|
|
|
|
var _this = this;
|
|
|
|
/* eslint-env commonjs, browser */
|
|
|
|
var reader = void 0;
|
|
if (typeof self !== 'undefined' && typeof self.FileReaderSync !== 'undefined') {
|
|
reader = new self.FileReaderSync();
|
|
}
|
|
|
|
// Convert a binary string and write it to the heap.
|
|
// A binary string is expected to only contain char codes < 256.
|
|
var convStr = function (str, H8, H32, start, len, off) {
|
|
var i = void 0,
|
|
om = off % 4,
|
|
lm = (len + om) % 4,
|
|
j = len - lm;
|
|
switch (om) {
|
|
case 0:
|
|
H8[off] = str.charCodeAt(start + 3);
|
|
case 1:
|
|
H8[off + 1 - (om << 1) | 0] = str.charCodeAt(start + 2);
|
|
case 2:
|
|
H8[off + 2 - (om << 1) | 0] = str.charCodeAt(start + 1);
|
|
case 3:
|
|
H8[off + 3 - (om << 1) | 0] = str.charCodeAt(start);
|
|
}
|
|
if (len < lm + (4 - om)) {
|
|
return;
|
|
}
|
|
for (i = 4 - om; i < j; i = i + 4 | 0) {
|
|
H32[off + i >> 2] = str.charCodeAt(start + i) << 24 | str.charCodeAt(start + i + 1) << 16 | str.charCodeAt(start + i + 2) << 8 | str.charCodeAt(start + i + 3);
|
|
}
|
|
switch (lm) {
|
|
case 3:
|
|
H8[off + j + 1 | 0] = str.charCodeAt(start + j + 2);
|
|
case 2:
|
|
H8[off + j + 2 | 0] = str.charCodeAt(start + j + 1);
|
|
case 1:
|
|
H8[off + j + 3 | 0] = str.charCodeAt(start + j);
|
|
}
|
|
};
|
|
|
|
// Convert a buffer or array and write it to the heap.
|
|
// The buffer or array is expected to only contain elements < 256.
|
|
var convBuf = function (buf, H8, H32, start, len, off) {
|
|
var i = void 0,
|
|
om = off % 4,
|
|
lm = (len + om) % 4,
|
|
j = len - lm;
|
|
switch (om) {
|
|
case 0:
|
|
H8[off] = buf[start + 3];
|
|
case 1:
|
|
H8[off + 1 - (om << 1) | 0] = buf[start + 2];
|
|
case 2:
|
|
H8[off + 2 - (om << 1) | 0] = buf[start + 1];
|
|
case 3:
|
|
H8[off + 3 - (om << 1) | 0] = buf[start];
|
|
}
|
|
if (len < lm + (4 - om)) {
|
|
return;
|
|
}
|
|
for (i = 4 - om; i < j; i = i + 4 | 0) {
|
|
H32[off + i >> 2 | 0] = buf[start + i] << 24 | buf[start + i + 1] << 16 | buf[start + i + 2] << 8 | buf[start + i + 3];
|
|
}
|
|
switch (lm) {
|
|
case 3:
|
|
H8[off + j + 1 | 0] = buf[start + j + 2];
|
|
case 2:
|
|
H8[off + j + 2 | 0] = buf[start + j + 1];
|
|
case 1:
|
|
H8[off + j + 3 | 0] = buf[start + j];
|
|
}
|
|
};
|
|
|
|
var convBlob = function (blob, H8, H32, start, len, off) {
|
|
var i = void 0,
|
|
om = off % 4,
|
|
lm = (len + om) % 4,
|
|
j = len - lm;
|
|
var buf = new Uint8Array(reader.readAsArrayBuffer(blob.slice(start, start + len)));
|
|
switch (om) {
|
|
case 0:
|
|
H8[off] = buf[3];
|
|
case 1:
|
|
H8[off + 1 - (om << 1) | 0] = buf[2];
|
|
case 2:
|
|
H8[off + 2 - (om << 1) | 0] = buf[1];
|
|
case 3:
|
|
H8[off + 3 - (om << 1) | 0] = buf[0];
|
|
}
|
|
if (len < lm + (4 - om)) {
|
|
return;
|
|
}
|
|
for (i = 4 - om; i < j; i = i + 4 | 0) {
|
|
H32[off + i >> 2 | 0] = buf[i] << 24 | buf[i + 1] << 16 | buf[i + 2] << 8 | buf[i + 3];
|
|
}
|
|
switch (lm) {
|
|
case 3:
|
|
H8[off + j + 1 | 0] = buf[j + 2];
|
|
case 2:
|
|
H8[off + j + 2 | 0] = buf[j + 1];
|
|
case 1:
|
|
H8[off + j + 3 | 0] = buf[j];
|
|
}
|
|
};
|
|
|
|
module.exports = function (data, H8, H32, start, len, off) {
|
|
if (typeof data === 'string') {
|
|
return convStr(data, H8, H32, start, len, off);
|
|
}
|
|
if (data instanceof Array) {
|
|
return convBuf(data, H8, H32, start, len, off);
|
|
}
|
|
// Safely doing a Buffer check using "this" to avoid Buffer polyfill to be included in the dist
|
|
if (_this && _this.Buffer && _this.Buffer.isBuffer(data)) {
|
|
return convBuf(data, H8, H32, start, len, off);
|
|
}
|
|
if (data instanceof ArrayBuffer) {
|
|
return convBuf(new Uint8Array(data), H8, H32, start, len, off);
|
|
}
|
|
if (data.buffer instanceof ArrayBuffer) {
|
|
return convBuf(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), H8, H32, start, len, off);
|
|
}
|
|
if (data instanceof Blob) {
|
|
return convBlob(data, H8, H32, start, len, off);
|
|
}
|
|
throw new Error('Unsupported data type.');
|
|
};
|
|
|
|
/***/ }),
|
|
/* 7 */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
/* eslint-env commonjs, browser */
|
|
|
|
var Rusha = __webpack_require__(0);
|
|
|
|
var _require = __webpack_require__(1),
|
|
toHex = _require.toHex;
|
|
|
|
var Hash = function () {
|
|
function Hash() {
|
|
_classCallCheck(this, Hash);
|
|
|
|
this._rusha = new Rusha();
|
|
this._rusha.resetState();
|
|
}
|
|
|
|
Hash.prototype.update = function update(data) {
|
|
this._rusha.append(data);
|
|
return this;
|
|
};
|
|
|
|
Hash.prototype.digest = function digest(encoding) {
|
|
var digest = this._rusha.rawEnd().buffer;
|
|
if (!encoding) {
|
|
return digest;
|
|
}
|
|
if (encoding === 'hex') {
|
|
return toHex(digest);
|
|
}
|
|
throw new Error('unsupported digest encoding');
|
|
};
|
|
|
|
return Hash;
|
|
}();
|
|
|
|
module.exports = function () {
|
|
return new Hash();
|
|
};
|
|
|
|
/***/ })
|
|
/******/ ]);
|
|
});
|
|
},{}],15:[function(require,module,exports){
|
|
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
|
/* eslint-disable node/no-deprecated-api */
|
|
var buffer = require('buffer')
|
|
var Buffer = buffer.Buffer
|
|
|
|
// alternative to using Object.keys for old browsers
|
|
function copyProps (src, dst) {
|
|
for (var key in src) {
|
|
dst[key] = src[key]
|
|
}
|
|
}
|
|
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
|
|
module.exports = buffer
|
|
} else {
|
|
// Copy properties from require('buffer')
|
|
copyProps(buffer, exports)
|
|
exports.Buffer = SafeBuffer
|
|
}
|
|
|
|
function SafeBuffer (arg, encodingOrOffset, length) {
|
|
return Buffer(arg, encodingOrOffset, length)
|
|
}
|
|
|
|
SafeBuffer.prototype = Object.create(Buffer.prototype)
|
|
|
|
// Copy static methods from Buffer
|
|
copyProps(Buffer, SafeBuffer)
|
|
|
|
SafeBuffer.from = function (arg, encodingOrOffset, length) {
|
|
if (typeof arg === 'number') {
|
|
throw new TypeError('Argument must not be a number')
|
|
}
|
|
return Buffer(arg, encodingOrOffset, length)
|
|
}
|
|
|
|
SafeBuffer.alloc = function (size, fill, encoding) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('Argument must be a number')
|
|
}
|
|
var buf = Buffer(size)
|
|
if (fill !== undefined) {
|
|
if (typeof encoding === 'string') {
|
|
buf.fill(fill, encoding)
|
|
} else {
|
|
buf.fill(fill)
|
|
}
|
|
} else {
|
|
buf.fill(0)
|
|
}
|
|
return buf
|
|
}
|
|
|
|
SafeBuffer.allocUnsafe = function (size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('Argument must be a number')
|
|
}
|
|
return Buffer(size)
|
|
}
|
|
|
|
SafeBuffer.allocUnsafeSlow = function (size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('Argument must be a number')
|
|
}
|
|
return buffer.SlowBuffer(size)
|
|
}
|
|
|
|
},{"buffer":28}],16:[function(require,module,exports){
|
|
(function (Buffer){
|
|
module.exports = function (stream, cb) {
|
|
var chunks = []
|
|
stream.on('data', function (chunk) {
|
|
chunks.push(chunk)
|
|
})
|
|
stream.once('end', function () {
|
|
if (cb) cb(null, Buffer.concat(chunks))
|
|
cb = null
|
|
})
|
|
stream.once('error', function (err) {
|
|
if (cb) cb(err)
|
|
cb = null
|
|
})
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28}],17:[function(require,module,exports){
|
|
(function (Buffer){
|
|
module.exports = simpleGet
|
|
|
|
const concat = require('simple-concat')
|
|
const decompressResponse = require('decompress-response') // excluded from browser build
|
|
const http = require('http')
|
|
const https = require('https')
|
|
const once = require('once')
|
|
const querystring = require('querystring')
|
|
const url = require('url')
|
|
|
|
const isStream = o => o !== null && typeof o === 'object' && typeof o.pipe === 'function'
|
|
|
|
function simpleGet (opts, cb) {
|
|
opts = Object.assign({ maxRedirects: 10 }, typeof opts === 'string' ? { url: opts } : opts)
|
|
cb = once(cb)
|
|
|
|
if (opts.url) {
|
|
const { hostname, port, protocol, auth, path } = url.parse(opts.url) // eslint-disable-line node/no-deprecated-api
|
|
delete opts.url
|
|
if (!hostname && !port && !protocol && !auth) opts.path = path // Relative redirect
|
|
else Object.assign(opts, { hostname, port, protocol, auth, path }) // Absolute redirect
|
|
}
|
|
|
|
const headers = { 'accept-encoding': 'gzip, deflate' }
|
|
if (opts.headers) Object.keys(opts.headers).forEach(k => (headers[k.toLowerCase()] = opts.headers[k]))
|
|
opts.headers = headers
|
|
|
|
let body
|
|
if (opts.body) {
|
|
body = opts.json && !isStream(opts.body) ? JSON.stringify(opts.body) : opts.body
|
|
} else if (opts.form) {
|
|
body = typeof opts.form === 'string' ? opts.form : querystring.stringify(opts.form)
|
|
opts.headers['content-type'] = 'application/x-www-form-urlencoded'
|
|
}
|
|
|
|
if (body) {
|
|
if (!opts.method) opts.method = 'POST'
|
|
if (!isStream(body)) opts.headers['content-length'] = Buffer.byteLength(body)
|
|
if (opts.json && !opts.form) opts.headers['content-type'] = 'application/json'
|
|
}
|
|
delete opts.body; delete opts.form
|
|
|
|
if (opts.json) opts.headers.accept = 'application/json'
|
|
if (opts.method) opts.method = opts.method.toUpperCase()
|
|
|
|
const protocol = opts.protocol === 'https:' ? https : http // Support http/https urls
|
|
const req = protocol.request(opts, res => {
|
|
if (opts.followRedirects !== false && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
|
|
opts.url = res.headers.location // Follow 3xx redirects
|
|
delete opts.headers.host // Discard `host` header on redirect (see #32)
|
|
res.resume() // Discard response
|
|
|
|
if (opts.method === 'POST' && [301, 302].includes(res.statusCode)) {
|
|
opts.method = 'GET' // On 301/302 redirect, change POST to GET (see #35)
|
|
delete opts.headers['content-length']; delete opts.headers['content-type']
|
|
}
|
|
|
|
if (opts.maxRedirects-- === 0) return cb(new Error('too many redirects'))
|
|
else return simpleGet(opts, cb)
|
|
}
|
|
|
|
const tryUnzip = typeof decompressResponse === 'function' && opts.method !== 'HEAD'
|
|
cb(null, tryUnzip ? decompressResponse(res) : res)
|
|
})
|
|
req.on('timeout', () => {
|
|
req.abort()
|
|
cb(new Error('Request timed out'))
|
|
})
|
|
req.on('error', cb)
|
|
|
|
if (isStream(body)) body.on('error', cb).pipe(req)
|
|
else req.end(body)
|
|
|
|
return req
|
|
}
|
|
|
|
simpleGet.concat = (opts, cb) => {
|
|
return simpleGet(opts, (err, res) => {
|
|
if (err) return cb(err)
|
|
concat(res, (err, data) => {
|
|
if (err) return cb(err)
|
|
if (opts.json) {
|
|
try {
|
|
data = JSON.parse(data.toString())
|
|
} catch (err) {
|
|
return cb(err, res, data)
|
|
}
|
|
}
|
|
cb(null, res, data)
|
|
})
|
|
})
|
|
}
|
|
|
|
;['get', 'post', 'put', 'patch', 'head', 'delete'].forEach(method => {
|
|
simpleGet[method] = (opts, cb) => {
|
|
if (typeof opts === 'string') opts = { url: opts }
|
|
return simpleGet(Object.assign({ method: method.toUpperCase() }, opts), cb)
|
|
}
|
|
})
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28,"decompress-response":26,"http":41,"https":31,"once":12,"querystring":39,"simple-concat":16,"url":61}],18:[function(require,module,exports){
|
|
/* global self */
|
|
|
|
var Rusha = require('rusha')
|
|
var rushaWorkerSha1 = require('./rusha-worker-sha1')
|
|
|
|
var rusha = new Rusha()
|
|
var scope = typeof window !== 'undefined' ? window : self
|
|
var crypto = scope.crypto || scope.msCrypto || {}
|
|
var subtle = crypto.subtle || crypto.webkitSubtle
|
|
|
|
function sha1sync (buf) {
|
|
return rusha.digest(buf)
|
|
}
|
|
|
|
// Browsers throw if they lack support for an algorithm.
|
|
// Promise will be rejected on non-secure origins. (http://goo.gl/lq4gCo)
|
|
try {
|
|
subtle.digest({ name: 'sha-1' }, new Uint8Array()).catch(function () {
|
|
subtle = false
|
|
})
|
|
} catch (err) { subtle = false }
|
|
|
|
function sha1 (buf, cb) {
|
|
if (!subtle) {
|
|
if (typeof window !== 'undefined') {
|
|
rushaWorkerSha1(buf, function onRushaWorkerSha1 (err, hash) {
|
|
if (err) {
|
|
// On error, fallback to synchronous method which cannot fail
|
|
cb(sha1sync(buf))
|
|
return
|
|
}
|
|
|
|
cb(hash)
|
|
})
|
|
} else {
|
|
queueMicrotask(() => cb(sha1sync(buf)))
|
|
}
|
|
return
|
|
}
|
|
|
|
if (typeof buf === 'string') {
|
|
buf = uint8array(buf)
|
|
}
|
|
|
|
subtle.digest({ name: 'sha-1' }, buf)
|
|
.then(function succeed (result) {
|
|
cb(hex(new Uint8Array(result)))
|
|
},
|
|
function fail () {
|
|
// On error, fallback to synchronous method which cannot fail
|
|
cb(sha1sync(buf))
|
|
})
|
|
}
|
|
|
|
function uint8array (s) {
|
|
var l = s.length
|
|
var array = new Uint8Array(l)
|
|
for (var i = 0; i < l; i++) {
|
|
array[i] = s.charCodeAt(i)
|
|
}
|
|
return array
|
|
}
|
|
|
|
function hex (buf) {
|
|
var l = buf.length
|
|
var chars = []
|
|
for (var i = 0; i < l; i++) {
|
|
var bite = buf[i]
|
|
chars.push((bite >>> 4).toString(16))
|
|
chars.push((bite & 0x0f).toString(16))
|
|
}
|
|
return chars.join('')
|
|
}
|
|
|
|
module.exports = sha1
|
|
module.exports.sync = sha1sync
|
|
|
|
},{"./rusha-worker-sha1":19,"rusha":14}],19:[function(require,module,exports){
|
|
var Rusha = require('rusha')
|
|
|
|
var worker
|
|
var nextTaskId
|
|
var cbs
|
|
|
|
function init () {
|
|
worker = Rusha.createWorker()
|
|
nextTaskId = 1
|
|
cbs = {} // taskId -> cb
|
|
|
|
worker.onmessage = function onRushaMessage (e) {
|
|
var taskId = e.data.id
|
|
var cb = cbs[taskId]
|
|
delete cbs[taskId]
|
|
|
|
if (e.data.error != null) {
|
|
cb(new Error('Rusha worker error: ' + e.data.error))
|
|
} else {
|
|
cb(null, e.data.hash)
|
|
}
|
|
}
|
|
}
|
|
|
|
function sha1 (buf, cb) {
|
|
if (!worker) init()
|
|
|
|
cbs[nextTaskId] = cb
|
|
worker.postMessage({ id: nextTaskId, data: buf })
|
|
nextTaskId += 1
|
|
}
|
|
|
|
module.exports = sha1
|
|
|
|
},{"rusha":14}],20:[function(require,module,exports){
|
|
/*
|
|
Copyright (c) 2011, Chris Umbel
|
|
|
|
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 base32 = require('./thirty-two');
|
|
|
|
exports.encode = base32.encode;
|
|
exports.decode = base32.decode;
|
|
|
|
},{"./thirty-two":21}],21:[function(require,module,exports){
|
|
(function (Buffer){
|
|
/*
|
|
Copyright (c) 2011, Chris Umbel
|
|
|
|
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.
|
|
*/
|
|
'use strict';
|
|
|
|
var charTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
|
|
var byteTable = [
|
|
0xff, 0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
|
|
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
|
|
0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
|
|
0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
|
|
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
|
|
0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
|
|
0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff
|
|
];
|
|
|
|
function quintetCount(buff) {
|
|
var quintets = Math.floor(buff.length / 5);
|
|
return buff.length % 5 === 0 ? quintets: quintets + 1;
|
|
}
|
|
|
|
exports.encode = function(plain) {
|
|
if(!Buffer.isBuffer(plain)){
|
|
plain = new Buffer(plain);
|
|
}
|
|
var i = 0;
|
|
var j = 0;
|
|
var shiftIndex = 0;
|
|
var digit = 0;
|
|
var encoded = new Buffer(quintetCount(plain) * 8);
|
|
|
|
/* byte by byte isn't as pretty as quintet by quintet but tests a bit
|
|
faster. will have to revisit. */
|
|
while(i < plain.length) {
|
|
var current = plain[i];
|
|
|
|
if(shiftIndex > 3) {
|
|
digit = current & (0xff >> shiftIndex);
|
|
shiftIndex = (shiftIndex + 5) % 8;
|
|
digit = (digit << shiftIndex) | ((i + 1 < plain.length) ?
|
|
plain[i + 1] : 0) >> (8 - shiftIndex);
|
|
i++;
|
|
} else {
|
|
digit = (current >> (8 - (shiftIndex + 5))) & 0x1f;
|
|
shiftIndex = (shiftIndex + 5) % 8;
|
|
if(shiftIndex === 0) i++;
|
|
}
|
|
|
|
encoded[j] = charTable.charCodeAt(digit);
|
|
j++;
|
|
}
|
|
|
|
for(i = j; i < encoded.length; i++) {
|
|
encoded[i] = 0x3d; //'='.charCodeAt(0)
|
|
}
|
|
|
|
return encoded;
|
|
};
|
|
|
|
exports.decode = function(encoded) {
|
|
var shiftIndex = 0;
|
|
var plainDigit = 0;
|
|
var plainChar;
|
|
var plainPos = 0;
|
|
if(!Buffer.isBuffer(encoded)){
|
|
encoded = new Buffer(encoded);
|
|
}
|
|
var decoded = new Buffer(Math.ceil(encoded.length * 5 / 8));
|
|
|
|
/* byte by byte isn't as pretty as octet by octet but tests a bit
|
|
faster. will have to revisit. */
|
|
for(var i = 0; i < encoded.length; i++) {
|
|
if(encoded[i] === 0x3d){ //'='
|
|
break;
|
|
}
|
|
|
|
var encodedByte = encoded[i] - 0x30;
|
|
|
|
if(encodedByte < byteTable.length) {
|
|
plainDigit = byteTable[encodedByte];
|
|
|
|
if(shiftIndex <= 3) {
|
|
shiftIndex = (shiftIndex + 5) % 8;
|
|
|
|
if(shiftIndex === 0) {
|
|
plainChar |= plainDigit;
|
|
decoded[plainPos] = plainChar;
|
|
plainPos++;
|
|
plainChar = 0;
|
|
} else {
|
|
plainChar |= 0xff & (plainDigit << (8 - shiftIndex));
|
|
}
|
|
} else {
|
|
shiftIndex = (shiftIndex + 5) % 8;
|
|
plainChar |= 0xff & (plainDigit >>> shiftIndex);
|
|
decoded[plainPos] = plainChar;
|
|
plainPos++;
|
|
|
|
plainChar = 0xff & (plainDigit << (8 - shiftIndex));
|
|
}
|
|
} else {
|
|
throw new Error('Invalid input - it is not base32 encoded string');
|
|
}
|
|
}
|
|
|
|
return decoded.slice(0, plainPos);
|
|
};
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"buffer":28}],22:[function(require,module,exports){
|
|
"use strict"
|
|
|
|
function unique_pred(list, compare) {
|
|
var ptr = 1
|
|
, len = list.length
|
|
, a=list[0], b=list[0]
|
|
for(var i=1; i<len; ++i) {
|
|
b = a
|
|
a = list[i]
|
|
if(compare(a, b)) {
|
|
if(i === ptr) {
|
|
ptr++
|
|
continue
|
|
}
|
|
list[ptr++] = a
|
|
}
|
|
}
|
|
list.length = ptr
|
|
return list
|
|
}
|
|
|
|
function unique_eq(list) {
|
|
var ptr = 1
|
|
, len = list.length
|
|
, a=list[0], b = list[0]
|
|
for(var i=1; i<len; ++i, b=a) {
|
|
b = a
|
|
a = list[i]
|
|
if(a !== b) {
|
|
if(i === ptr) {
|
|
ptr++
|
|
continue
|
|
}
|
|
list[ptr++] = a
|
|
}
|
|
}
|
|
list.length = ptr
|
|
return list
|
|
}
|
|
|
|
function unique(list, compare, sorted) {
|
|
if(list.length === 0) {
|
|
return list
|
|
}
|
|
if(compare) {
|
|
if(!sorted) {
|
|
list.sort(compare)
|
|
}
|
|
return unique_pred(list, compare)
|
|
}
|
|
if(!sorted) {
|
|
list.sort()
|
|
}
|
|
return unique_eq(list)
|
|
}
|
|
|
|
module.exports = unique
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
// Returns a wrapper function that returns a wrapped callback
|
|
// The wrapper function should do some stuff, and return a
|
|
// presumably different callback function.
|
|
// This makes sure that own properties are retained, so that
|
|
// decorations and such are not lost along the way.
|
|
module.exports = wrappy
|
|
function wrappy (fn, cb) {
|
|
if (fn && cb) return wrappy(fn)(cb)
|
|
|
|
if (typeof fn !== 'function')
|
|
throw new TypeError('need wrapper function')
|
|
|
|
Object.keys(fn).forEach(function (k) {
|
|
wrapper[k] = fn[k]
|
|
})
|
|
|
|
return wrapper
|
|
|
|
function wrapper() {
|
|
var args = new Array(arguments.length)
|
|
for (var i = 0; i < args.length; i++) {
|
|
args[i] = arguments[i]
|
|
}
|
|
var ret = fn.apply(this, args)
|
|
var cb = args[args.length-1]
|
|
if (typeof ret === 'function' && ret !== cb) {
|
|
Object.keys(cb).forEach(function (k) {
|
|
ret[k] = cb[k]
|
|
})
|
|
}
|
|
return ret
|
|
}
|
|
}
|
|
|
|
},{}],24:[function(require,module,exports){
|
|
const clipboard = require('clipboard');
|
|
const parser = require('parse-torrent');
|
|
const Buffer = require('Buffer');
|
|
const bytes = require('bytes');
|
|
const mime = require('mime-types');
|
|
|
|
var properties = document.getElementById('properties');
|
|
var originalSourceIcon = document.getElementById('originalSourceIcon');
|
|
var name = document.getElementById('name');
|
|
var reset = document.getElementById('reset');
|
|
var created = document.getElementById('created');
|
|
var createdBy = document.getElementById('createdBy');
|
|
var comment = document.getElementById('comment');
|
|
var hash = document.getElementById('hash');
|
|
var addTrackers = document.getElementById('addTrackers');
|
|
var removeTrackers = document.getElementById('removeTrackers');
|
|
var announce = document.getElementById('announce');
|
|
var urlList = document.getElementById('urlList');
|
|
var removeWebseeds = document.getElementById('removeWebseeds');
|
|
var files = document.getElementById('filesBody');
|
|
var copyURL = document.getElementById('copyURL');
|
|
var copyMagnet = document.getElementById('copyMagnet');
|
|
var downloadTorrent = document.getElementById('downloadTorrent');
|
|
var parsed;
|
|
|
|
document.addEventListener('DOMContentLoaded', start);
|
|
|
|
function start() {
|
|
|
|
document.getElementById('magnet').addEventListener('keyup', function(event) {
|
|
event.preventDefault();
|
|
if (event.keyCode === 13) {
|
|
originalSourceIcon.innerHTML = '<span class="fad fa-magnet fa-fw"></span>';
|
|
originalSourceIcon.title = 'Originally sourced from Magnet URL';
|
|
parse(magnet.value);
|
|
}
|
|
});
|
|
|
|
document.getElementById('torrent').addEventListener('change', function(event) {
|
|
event.preventDefault();
|
|
event.target.files[0].arrayBuffer().then(function(arrayBuffer) {
|
|
originalSourceIcon.innerHTML = '<span class="fad fa-file fa-fw"></span>';
|
|
originalSourceIcon.title = 'Originally sourced from Torrent file';
|
|
parse(Buffer.from(arrayBuffer));
|
|
});
|
|
});
|
|
|
|
let copyurl = new clipboard('#copyURL');
|
|
copyurl.on('success', function(e) {
|
|
console.info(e); // TODO: Alert user to success
|
|
});
|
|
copyurl.on('failure', function(e) {
|
|
console.error(e); // TODO: Alert user to error
|
|
});
|
|
|
|
let copymagnet = new clipboard('#copyMagnet');
|
|
copymagnet.on('success', function(e) {
|
|
console.info(e); // TODO: Alert user to success
|
|
});
|
|
copymagnet.on('failure', function(e) {
|
|
console.error(e); // TODO: Alert user to error
|
|
});
|
|
|
|
name.addEventListener('input', propertyChange);
|
|
reset.addEventListener('click', resetProperties);
|
|
createdBy.addEventListener('change', propertyChange);
|
|
comment.addEventListener('input', propertyChange);
|
|
addTrackers.addEventListener('click', addCurrentTrackers);
|
|
removeTrackers.addEventListener('click', removeCurrentTrackers);
|
|
removeWebseeds.addEventListener('click', removeCurrentWebseeds);
|
|
|
|
if (window.location.hash) {
|
|
originalSourceIcon.innerHTML = '<span class="fad fa-link fa-fw"></span>';
|
|
originalSourceIcon.title = 'Originally sourced from Magnet URL in the address bar of this site';
|
|
parse(window.location.hash.split('#')[1]);
|
|
}
|
|
|
|
}
|
|
|
|
function parse(toLoad) {
|
|
try {
|
|
console.info("Attempting parse");
|
|
parsed = parser(toLoad);
|
|
display();
|
|
if (parsed.xs) {
|
|
console.log("Magnet includes xs, attempting remote parse");
|
|
parseRemote(parsed.xs);
|
|
}
|
|
}
|
|
catch(e) {
|
|
console.warn(e);
|
|
console.info("Attempting remote parse");
|
|
parseRemote(toLoad);
|
|
}
|
|
}
|
|
|
|
function parseRemote(toLoad) {
|
|
parser.remote(toLoad, function(err, result) {
|
|
if (err) { // TODO: Display error to user
|
|
console.error(err);
|
|
resetProperties();
|
|
return;
|
|
}
|
|
parsed = result;
|
|
display();
|
|
});
|
|
}
|
|
|
|
function display() {
|
|
|
|
console.log(parsed);
|
|
|
|
resetProperties();
|
|
|
|
name.value = parsed.name || "";
|
|
if (parsed.created) created.value = parsed.created.toISOString().slice(0, 19);
|
|
createdBy.value = parsed.createdBy || "";
|
|
comment.value = parsed.comment || "";
|
|
hash.value = parsed.infoHash;
|
|
|
|
announce.innerHTML = "";
|
|
if (parsed.announce && parsed.announce.length) {
|
|
for (let i = 0; i < parsed.announce.length; i++) {
|
|
let tracker = document.createElement('input');
|
|
tracker.className = 'tracker';
|
|
tracker.type = 'text';
|
|
tracker.value = parsed.announce[i];
|
|
tracker.dataset.index = i;
|
|
tracker.dataset.group = 'announce';
|
|
tracker.addEventListener('input', propertyChange);
|
|
announce.appendChild(tracker);
|
|
}
|
|
} else {
|
|
announce.innerHTML = "<em>No trackers specified in the URL/File provided</em>";
|
|
}
|
|
|
|
urlList.innerHTML = "";
|
|
if (parsed.urlList && parsed.urlList.length) {
|
|
for (let i = 0; i < parsed.urlList.length; i++) {
|
|
let webseed = document.createElement('input');
|
|
webseed.className = 'webseed';
|
|
webseed.type = 'text';
|
|
webseed.value = parsed.urlList[i];
|
|
webseed.dataset.index = i;
|
|
webseed.dataset.group = 'urlList';
|
|
webseed.addEventListener('input', propertyChange);
|
|
urlList.appendChild(webseed);
|
|
}
|
|
} else {
|
|
urlList.innerHTML = "<em>No webseed URLs in the URL/File provided</em>";
|
|
}
|
|
|
|
files.innerHTML = "";
|
|
if (parsed.files && parsed.files.length) {
|
|
downloadTorrent.addEventListener('click', saveTorrent);
|
|
downloadTorrent.disabled = false;
|
|
for (let file of parsed.files) {
|
|
let icon = getFontAwesomeIconForMimetype(mime.lookup(file.name));
|
|
files.appendChild(createFileRow(icon, file.name, file.length));
|
|
}
|
|
files.appendChild(createFileRow('folder-tree', '', parsed.length));
|
|
} else {
|
|
downloadTorrent.removeEventListener('click', saveTorrent);
|
|
downloadTorrent.disabled = true;
|
|
files.innerHTML = "<em>Files information isn't included in the URL/File provided</em>";
|
|
}
|
|
|
|
copyURL.setAttribute('data-clipboard-text', window.location.origin + "#" + parser.toMagnetURI(parsed));
|
|
copyMagnet.setAttribute('data-clipboard-text', parser.toMagnetURI(parsed));
|
|
|
|
properties.style.display = 'block';
|
|
|
|
window.location.hash = parser.toMagnetURI(parsed);
|
|
|
|
if (parsed.name) {
|
|
document.title = "Torrent Parts | " + parsed.name;
|
|
} else {
|
|
document.title = "Torrent Parts | Inspect and edit what's in your Torrent file or Magnet link";
|
|
}
|
|
|
|
}
|
|
|
|
function createFileRow(icon, name, size) {
|
|
let row = document.createElement('tr');
|
|
let iconcell = document.createElement('td');
|
|
iconcell.innerHTML = '<span class="far fa-' + icon + '"></span>';
|
|
row.appendChild(iconcell);
|
|
let namecell = document.createElement('td');
|
|
namecell.innerHTML = name;
|
|
row.appendChild(namecell);
|
|
let totalcell = document.createElement('td');
|
|
totalcell.innerHTML = bytes.format(size, {"decimalPlaces": 1, "unitSeparator": " "});
|
|
row.appendChild(totalcell);
|
|
return row;
|
|
}
|
|
|
|
function getFontAwesomeIconForMimetype(mimetype) {
|
|
if (!mimetype) return 'file';
|
|
switch (true) {
|
|
case mimetype.includes("7z-"):
|
|
case mimetype.includes("iso9660"):
|
|
case mimetype.includes("zip"):
|
|
return 'file-archive';
|
|
case mimetype.includes("audio"):
|
|
return 'file-audio';
|
|
case mimetype.includes("csv"):
|
|
return 'file-csv';
|
|
case mimetype.includes("font"):
|
|
return 'file-contract';
|
|
case mimetype.includes("image"):
|
|
return 'file-image';
|
|
case mimetype.includes("pdf"):
|
|
return 'file-pdf';
|
|
case mimetype.includes("text"):
|
|
case mimetype.includes("subrip"):
|
|
case mimetype.includes("vtt"):
|
|
return 'file-alt';
|
|
case mimetype.includes("video"):
|
|
return 'file-video';
|
|
default:
|
|
return 'file';
|
|
}
|
|
}
|
|
|
|
function propertyChange(e) {
|
|
if (e.target.dataset.group) {
|
|
parsed[e.target.dataset.group][e.target.dataset.index] = e.target.value || "";
|
|
} else {
|
|
parsed[e.target.id] = e.target.value || "";
|
|
}
|
|
updateModified();
|
|
display();
|
|
}
|
|
|
|
function resetProperties() {
|
|
document.getElementById('magnet').value = "";
|
|
document.getElementById('torrent').value = "";
|
|
properties.style.display = 'none';
|
|
name.value = "";
|
|
created.value = "";
|
|
createdBy.value = "";
|
|
comment.value = "";
|
|
hash.value = "";
|
|
announce.innerHTML = "";
|
|
urlList.innerHTML = "";
|
|
files.innerHTML = "";
|
|
window.location.hash = "";
|
|
copyURL.setAttribute('data-clipboard-text', "");
|
|
copyMagnet.setAttribute('data-clipboard-text', "");
|
|
document.title = "Torrent Parts | Inspect and edit what's in your Torrent file or Magnet link";
|
|
}
|
|
|
|
async function addCurrentTrackers() {
|
|
addTrackers.disabled = true;
|
|
addTrackers.classList.add('fa-blink');
|
|
try {
|
|
let response = await fetch("https://newtrackon.com/api/100"); // get trackers with 100% uptime
|
|
let trackers = await response.text();
|
|
parsed.announce = parsed.announce.concat(trackers.split('\n\n'));
|
|
parsed.announce = parsed.announce.filter((v,i) => v && parsed.announce.indexOf(v) === i); // remove duplicates and empties
|
|
updateModified();
|
|
}
|
|
catch(e) {
|
|
console.error(e); // TODO: Alert user to error
|
|
}
|
|
addTrackers.classList.remove('fa-blink');
|
|
addTrackers.disabled = false;
|
|
display();
|
|
}
|
|
|
|
function removeCurrentTrackers() {
|
|
parsed.announce = [];
|
|
updateModified();
|
|
display();
|
|
}
|
|
|
|
function removeCurrentWebseeds() {
|
|
parsed.urlList = [];
|
|
updateModified();
|
|
display();
|
|
}
|
|
|
|
function updateModified() {
|
|
created.value = new Date().toISOString().slice(0, 19);
|
|
parsed.created = new Date();
|
|
createdBy.value = "Torrent Parts <https://torrent.parts/>";
|
|
parsed.createdBy = "Torrent Parts <https://torrent.parts/>";
|
|
}
|
|
|
|
// https://stackoverflow.com/a/36899900/2700296
|
|
function saveTorrent() {
|
|
let data = parser.toTorrentFile(parsed);
|
|
if (data !== null && navigator.msSaveBlob)
|
|
return navigator.msSaveBlob(new Blob([data], { "type": "application/x-bittorrent" }), parsed.name + '.torrent');
|
|
let a = document.createElement('a');
|
|
a.style.display = 'none';
|
|
let url = window.URL.createObjectURL(new Blob([data], { "type": "application/x-bittorrent" }));
|
|
a.setAttribute("href", url);
|
|
a.setAttribute("download", parsed.name + '.torrent');
|
|
document.body.appendChild(a);
|
|
a.click();
|
|
window.URL.revokeObjectURL(url);
|
|
a.remove();
|
|
}
|
|
},{"Buffer":1,"bytes":6,"clipboard":7,"mime-types":11,"parse-torrent":13}],25:[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
|
|
}
|
|
|
|
// Support decoding URL-safe base64 strings, as Node.js does.
|
|
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
|
|
revLookup['-'.charCodeAt(0)] = 62
|
|
revLookup['_'.charCodeAt(0)] = 63
|
|
|
|
function getLens (b64) {
|
|
var len = b64.length
|
|
|
|
if (len % 4 > 0) {
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
}
|
|
|
|
// Trim off extra bytes after placeholder bytes are found
|
|
// See: https://github.com/beatgammit/base64-js/issues/42
|
|
var validLen = b64.indexOf('=')
|
|
if (validLen === -1) validLen = len
|
|
|
|
var placeHoldersLen = validLen === len
|
|
? 0
|
|
: 4 - (validLen % 4)
|
|
|
|
return [validLen, placeHoldersLen]
|
|
}
|
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
function byteLength (b64) {
|
|
var lens = getLens(b64)
|
|
var validLen = lens[0]
|
|
var placeHoldersLen = lens[1]
|
|
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
|
|
}
|
|
|
|
function _byteLength (b64, validLen, placeHoldersLen) {
|
|
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
|
|
}
|
|
|
|
function toByteArray (b64) {
|
|
var tmp
|
|
var lens = getLens(b64)
|
|
var validLen = lens[0]
|
|
var placeHoldersLen = lens[1]
|
|
|
|
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
|
|
|
|
var curByte = 0
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
var len = placeHoldersLen > 0
|
|
? validLen - 4
|
|
: validLen
|
|
|
|
var i
|
|
for (i = 0; i < len; i += 4) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 18) |
|
|
(revLookup[b64.charCodeAt(i + 1)] << 12) |
|
|
(revLookup[b64.charCodeAt(i + 2)] << 6) |
|
|
revLookup[b64.charCodeAt(i + 3)]
|
|
arr[curByte++] = (tmp >> 16) & 0xFF
|
|
arr[curByte++] = (tmp >> 8) & 0xFF
|
|
arr[curByte++] = tmp & 0xFF
|
|
}
|
|
|
|
if (placeHoldersLen === 2) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 2) |
|
|
(revLookup[b64.charCodeAt(i + 1)] >> 4)
|
|
arr[curByte++] = tmp & 0xFF
|
|
}
|
|
|
|
if (placeHoldersLen === 1) {
|
|
tmp =
|
|
(revLookup[b64.charCodeAt(i)] << 10) |
|
|
(revLookup[b64.charCodeAt(i + 1)] << 4) |
|
|
(revLookup[b64.charCodeAt(i + 2)] >> 2)
|
|
arr[curByte++] = (tmp >> 8) & 0xFF
|
|
arr[curByte++] = 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) & 0xFF0000) +
|
|
((uint8[i + 1] << 8) & 0xFF00) +
|
|
(uint8[i + 2] & 0xFF)
|
|
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 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]
|
|
parts.push(
|
|
lookup[tmp >> 2] +
|
|
lookup[(tmp << 4) & 0x3F] +
|
|
'=='
|
|
)
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
|
|
parts.push(
|
|
lookup[tmp >> 10] +
|
|
lookup[(tmp >> 4) & 0x3F] +
|
|
lookup[(tmp << 2) & 0x3F] +
|
|
'='
|
|
)
|
|
}
|
|
|
|
return parts.join('')
|
|
}
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
arguments[4][26][0].apply(exports,arguments)
|
|
},{"dup":26}],28:[function(require,module,exports){
|
|
(function (Buffer){
|
|
/*!
|
|
* The buffer module from node.js, for the browser.
|
|
*
|
|
* @author Feross Aboukhadijeh <https://feross.org>
|
|
* @license MIT
|
|
*/
|
|
/* eslint-disable no-proto */
|
|
|
|
'use strict'
|
|
|
|
var base64 = require('base64-js')
|
|
var ieee754 = require('ieee754')
|
|
|
|
exports.Buffer = Buffer
|
|
exports.SlowBuffer = SlowBuffer
|
|
exports.INSPECT_MAX_BYTES = 50
|
|
|
|
var K_MAX_LENGTH = 0x7fffffff
|
|
exports.kMaxLength = K_MAX_LENGTH
|
|
|
|
/**
|
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
|
* === true Use Uint8Array implementation (fastest)
|
|
* === false Print warning and recommend using `buffer` v4.x which has an 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+.
|
|
*
|
|
* We report that the browser does not support typed arrays if the are not subclassable
|
|
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
|
|
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
|
|
* for __proto__ and has a buggy typed array implementation.
|
|
*/
|
|
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
|
|
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
|
|
typeof console.error === 'function') {
|
|
console.error(
|
|
'This browser lacks typed array (Uint8Array) support which is required by ' +
|
|
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
|
|
)
|
|
}
|
|
|
|
function typedArraySupport () {
|
|
// Can typed array instances can be augmented?
|
|
try {
|
|
var arr = new Uint8Array(1)
|
|
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
|
|
return arr.foo() === 42
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(Buffer.prototype, 'parent', {
|
|
enumerable: true,
|
|
get: function () {
|
|
if (!Buffer.isBuffer(this)) return undefined
|
|
return this.buffer
|
|
}
|
|
})
|
|
|
|
Object.defineProperty(Buffer.prototype, 'offset', {
|
|
enumerable: true,
|
|
get: function () {
|
|
if (!Buffer.isBuffer(this)) return undefined
|
|
return this.byteOffset
|
|
}
|
|
})
|
|
|
|
function createBuffer (length) {
|
|
if (length > K_MAX_LENGTH) {
|
|
throw new RangeError('The value "' + length + '" is invalid for option "size"')
|
|
}
|
|
// Return an augmented `Uint8Array` instance
|
|
var buf = new Uint8Array(length)
|
|
buf.__proto__ = Buffer.prototype
|
|
return buf
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
// Common case.
|
|
if (typeof arg === 'number') {
|
|
if (typeof encodingOrOffset === 'string') {
|
|
throw new TypeError(
|
|
'The "string" argument must be of type string. Received type number'
|
|
)
|
|
}
|
|
return allocUnsafe(arg)
|
|
}
|
|
return from(arg, encodingOrOffset, length)
|
|
}
|
|
|
|
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
|
|
if (typeof Symbol !== 'undefined' && Symbol.species != null &&
|
|
Buffer[Symbol.species] === Buffer) {
|
|
Object.defineProperty(Buffer, Symbol.species, {
|
|
value: null,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: false
|
|
})
|
|
}
|
|
|
|
Buffer.poolSize = 8192 // not used by this implementation
|
|
|
|
function from (value, encodingOrOffset, length) {
|
|
if (typeof value === 'string') {
|
|
return fromString(value, encodingOrOffset)
|
|
}
|
|
|
|
if (ArrayBuffer.isView(value)) {
|
|
return fromArrayLike(value)
|
|
}
|
|
|
|
if (value == null) {
|
|
throw TypeError(
|
|
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
|
|
'or Array-like Object. Received type ' + (typeof value)
|
|
)
|
|
}
|
|
|
|
if (isInstance(value, ArrayBuffer) ||
|
|
(value && isInstance(value.buffer, ArrayBuffer))) {
|
|
return fromArrayBuffer(value, encodingOrOffset, length)
|
|
}
|
|
|
|
if (typeof value === 'number') {
|
|
throw new TypeError(
|
|
'The "value" argument must not be of type number. Received type number'
|
|
)
|
|
}
|
|
|
|
var valueOf = value.valueOf && value.valueOf()
|
|
if (valueOf != null && valueOf !== value) {
|
|
return Buffer.from(valueOf, encodingOrOffset, length)
|
|
}
|
|
|
|
var b = fromObject(value)
|
|
if (b) return b
|
|
|
|
if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
|
|
typeof value[Symbol.toPrimitive] === 'function') {
|
|
return Buffer.from(
|
|
value[Symbol.toPrimitive]('string'), encodingOrOffset, length
|
|
)
|
|
}
|
|
|
|
throw new TypeError(
|
|
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
|
|
'or Array-like Object. Received type ' + (typeof 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(value, encodingOrOffset, length)
|
|
}
|
|
|
|
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
|
|
// https://github.com/feross/buffer/pull/148
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype
|
|
Buffer.__proto__ = Uint8Array
|
|
|
|
function assertSize (size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('"size" argument must be of type number')
|
|
} else if (size < 0) {
|
|
throw new RangeError('The value "' + size + '" is invalid for option "size"')
|
|
}
|
|
}
|
|
|
|
function alloc (size, fill, encoding) {
|
|
assertSize(size)
|
|
if (size <= 0) {
|
|
return createBuffer(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(size).fill(fill, encoding)
|
|
: createBuffer(size).fill(fill)
|
|
}
|
|
return createBuffer(size)
|
|
}
|
|
|
|
/**
|
|
* Creates a new filled Buffer instance.
|
|
* alloc(size[, fill[, encoding]])
|
|
**/
|
|
Buffer.alloc = function (size, fill, encoding) {
|
|
return alloc(size, fill, encoding)
|
|
}
|
|
|
|
function allocUnsafe (size) {
|
|
assertSize(size)
|
|
return createBuffer(size < 0 ? 0 : checked(size) | 0)
|
|
}
|
|
|
|
/**
|
|
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
|
* */
|
|
Buffer.allocUnsafe = function (size) {
|
|
return allocUnsafe(size)
|
|
}
|
|
/**
|
|
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
|
*/
|
|
Buffer.allocUnsafeSlow = function (size) {
|
|
return allocUnsafe(size)
|
|
}
|
|
|
|
function fromString (string, encoding) {
|
|
if (typeof encoding !== 'string' || encoding === '') {
|
|
encoding = 'utf8'
|
|
}
|
|
|
|
if (!Buffer.isEncoding(encoding)) {
|
|
throw new TypeError('Unknown encoding: ' + encoding)
|
|
}
|
|
|
|
var length = byteLength(string, encoding) | 0
|
|
var buf = createBuffer(length)
|
|
|
|
var actual = buf.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')
|
|
buf = buf.slice(0, actual)
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
function fromArrayLike (array) {
|
|
var length = array.length < 0 ? 0 : checked(array.length) | 0
|
|
var buf = createBuffer(length)
|
|
for (var i = 0; i < length; i += 1) {
|
|
buf[i] = array[i] & 255
|
|
}
|
|
return buf
|
|
}
|
|
|
|
function fromArrayBuffer (array, byteOffset, length) {
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
throw new RangeError('"offset" is outside of buffer bounds')
|
|
}
|
|
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
throw new RangeError('"length" is outside of buffer bounds')
|
|
}
|
|
|
|
var buf
|
|
if (byteOffset === undefined && length === undefined) {
|
|
buf = new Uint8Array(array)
|
|
} else if (length === undefined) {
|
|
buf = new Uint8Array(array, byteOffset)
|
|
} else {
|
|
buf = new Uint8Array(array, byteOffset, length)
|
|
}
|
|
|
|
// Return an augmented `Uint8Array` instance
|
|
buf.__proto__ = Buffer.prototype
|
|
return buf
|
|
}
|
|
|
|
function fromObject (obj) {
|
|
if (Buffer.isBuffer(obj)) {
|
|
var len = checked(obj.length) | 0
|
|
var buf = createBuffer(len)
|
|
|
|
if (buf.length === 0) {
|
|
return buf
|
|
}
|
|
|
|
obj.copy(buf, 0, 0, len)
|
|
return buf
|
|
}
|
|
|
|
if (obj.length !== undefined) {
|
|
if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
|
|
return createBuffer(0)
|
|
}
|
|
return fromArrayLike(obj)
|
|
}
|
|
|
|
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
|
|
return fromArrayLike(obj.data)
|
|
}
|
|
}
|
|
|
|
function checked (length) {
|
|
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
|
|
// length is NaN (which is otherwise coerced to zero.)
|
|
if (length >= K_MAX_LENGTH) {
|
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
|
'size: 0x' + K_MAX_LENGTH.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 === true &&
|
|
b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
|
|
}
|
|
|
|
Buffer.compare = function compare (a, b) {
|
|
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
|
|
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
|
|
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
|
throw new TypeError(
|
|
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
|
|
)
|
|
}
|
|
|
|
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 (!Array.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 (isInstance(buf, Uint8Array)) {
|
|
buf = Buffer.from(buf)
|
|
}
|
|
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 (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
|
|
return string.byteLength
|
|
}
|
|
if (typeof string !== 'string') {
|
|
throw new TypeError(
|
|
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
|
|
'Received type ' + typeof string
|
|
)
|
|
}
|
|
|
|
var len = string.length
|
|
var mustMatch = (arguments.length > 2 && arguments[2] === true)
|
|
if (!mustMatch && 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':
|
|
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 mustMatch ? -1 : 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
|
|
}
|
|
}
|
|
}
|
|
|
|
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
|
|
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
|
|
// reliably in a browserify context because there could be multiple different
|
|
// copies of the 'buffer' package in use. This method works even for Buffer
|
|
// instances that were created from another copy of the `buffer` package.
|
|
// See: https://github.com/feross/buffer/issues/154
|
|
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
|
|
if (length === 0) return ''
|
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
|
return slowToString.apply(this, arguments)
|
|
}
|
|
|
|
Buffer.prototype.toLocaleString = Buffer.prototype.toString
|
|
|
|
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
|
|
str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
|
|
if (this.length > max) str += ' ... '
|
|
return '<Buffer ' + str + '>'
|
|
}
|
|
|
|
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
|
if (isInstance(target, Uint8Array)) {
|
|
target = Buffer.from(target, target.offset, target.byteLength)
|
|
}
|
|
if (!Buffer.isBuffer(target)) {
|
|
throw new TypeError(
|
|
'The "target" argument must be one of type Buffer or Uint8Array. ' +
|
|
'Received type ' + (typeof target)
|
|
)
|
|
}
|
|
|
|
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 (numberIsNaN(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 (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
|
|
}
|
|
}
|
|
|
|
var strLen = string.length
|
|
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2
|
|
}
|
|
for (var i = 0; i < length; ++i) {
|
|
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
|
if (numberIsNaN(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
|
|
}
|
|
} 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 = this.subarray(start, end)
|
|
// Return an augmented `Uint8Array` instance
|
|
newBuf.__proto__ = Buffer.prototype
|
|
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) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 1, this.length)
|
|
return this[offset]
|
|
}
|
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return this[offset] | (this[offset + 1] << 8)
|
|
}
|
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 2, this.length)
|
|
return (this[offset] << 8) | this[offset + 1]
|
|
}
|
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
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) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, true, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 4, this.length)
|
|
return ieee754.read(this, offset, false, 23, 4)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkOffset(offset, 8, this.length)
|
|
return ieee754.read(this, offset, true, 52, 8)
|
|
}
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
|
offset = offset >>> 0
|
|
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)
|
|
this[offset] = (value & 0xff)
|
|
return offset + 1
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
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)
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
return offset + 2
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
|
value = +value
|
|
offset = offset >>> 0
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
|
this[offset + 3] = (value >>> 24)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset] = (value & 0xff)
|
|
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)
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
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 (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)
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
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)
|
|
this[offset] = (value >>> 8)
|
|
this[offset + 1] = (value & 0xff)
|
|
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)
|
|
this[offset] = (value & 0xff)
|
|
this[offset + 1] = (value >>> 8)
|
|
this[offset + 2] = (value >>> 16)
|
|
this[offset + 3] = (value >>> 24)
|
|
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
|
|
this[offset] = (value >>> 24)
|
|
this[offset + 1] = (value >>> 16)
|
|
this[offset + 2] = (value >>> 8)
|
|
this[offset + 3] = (value & 0xff)
|
|
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) {
|
|
value = +value
|
|
offset = offset >>> 0
|
|
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) {
|
|
value = +value
|
|
offset = offset >>> 0
|
|
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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
|
|
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('Index out of range')
|
|
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
|
|
|
|
if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
|
|
// Use built-in when available, missing from IE11
|
|
this.copyWithin(targetStart, start, end)
|
|
} else if (this === target && start < targetStart && targetStart < end) {
|
|
// descending copy from end
|
|
for (var i = len - 1; i >= 0; --i) {
|
|
target[i + targetStart] = this[i + start]
|
|
}
|
|
} else {
|
|
Uint8Array.prototype.set.call(
|
|
target,
|
|
this.subarray(start, end),
|
|
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 (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)
|
|
}
|
|
if (val.length === 1) {
|
|
var code = val.charCodeAt(0)
|
|
if ((encoding === 'utf8' && code < 128) ||
|
|
encoding === 'latin1') {
|
|
// Fast path: If `val` fits into a single byte, use that numeric value.
|
|
val = code
|
|
}
|
|
}
|
|
} 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
|
|
: Buffer.from(val, encoding)
|
|
var len = bytes.length
|
|
if (len === 0) {
|
|
throw new TypeError('The value "' + val +
|
|
'" is invalid for argument "value"')
|
|
}
|
|
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 takes equal signs as end of the Base64 encoding
|
|
str = str.split('=')[0]
|
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
|
str = str.trim().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 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
|
|
}
|
|
|
|
// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
|
|
// the `instanceof` check but they should be treated as of that type.
|
|
// See: https://github.com/feross/buffer/issues/166
|
|
function isInstance (obj, type) {
|
|
return obj instanceof type ||
|
|
(obj != null && obj.constructor != null && obj.constructor.name != null &&
|
|
obj.constructor.name === type.name)
|
|
}
|
|
function numberIsNaN (obj) {
|
|
// For IE11 support
|
|
return obj !== obj // eslint-disable-line no-self-compare
|
|
}
|
|
|
|
}).call(this,require("buffer").Buffer)
|
|
},{"base64-js":25,"buffer":28,"ieee754":32}],29:[function(require,module,exports){
|
|
module.exports = {
|
|
"100": "Continue",
|
|
"101": "Switching Protocols",
|
|
"102": "Processing",
|
|
"200": "OK",
|
|
"201": "Created",
|
|
"202": "Accepted",
|
|
"203": "Non-Authoritative Information",
|
|
"204": "No Content",
|
|
"205": "Reset Content",
|
|
"206": "Partial Content",
|
|
"207": "Multi-Status",
|
|
"208": "Already Reported",
|
|
"226": "IM Used",
|
|
"300": "Multiple Choices",
|
|
"301": "Moved Permanently",
|
|
"302": "Found",
|
|
"303": "See Other",
|
|
"304": "Not Modified",
|
|
"305": "Use Proxy",
|
|
"307": "Temporary Redirect",
|
|
"308": "Permanent Redirect",
|
|
"400": "Bad Request",
|
|
"401": "Unauthorized",
|
|
"402": "Payment Required",
|
|
"403": "Forbidden",
|
|
"404": "Not Found",
|
|
"405": "Method Not Allowed",
|
|
"406": "Not Acceptable",
|
|
"407": "Proxy Authentication Required",
|
|
"408": "Request Timeout",
|
|
"409": "Conflict",
|
|
"410": "Gone",
|
|
"411": "Length Required",
|
|
"412": "Precondition Failed",
|
|
"413": "Payload Too Large",
|
|
"414": "URI Too Long",
|
|
"415": "Unsupported Media Type",
|
|
"416": "Range Not Satisfiable",
|
|
"417": "Expectation Failed",
|
|
"418": "I'm a teapot",
|
|
"421": "Misdirected Request",
|
|
"422": "Unprocessable Entity",
|
|
"423": "Locked",
|
|
"424": "Failed Dependency",
|
|
"425": "Unordered Collection",
|
|
"426": "Upgrade Required",
|
|
"428": "Precondition Required",
|
|
"429": "Too Many Requests",
|
|
"431": "Request Header Fields Too Large",
|
|
"451": "Unavailable For Legal Reasons",
|
|
"500": "Internal Server Error",
|
|
"501": "Not Implemented",
|
|
"502": "Bad Gateway",
|
|
"503": "Service Unavailable",
|
|
"504": "Gateway Timeout",
|
|
"505": "HTTP Version Not Supported",
|
|
"506": "Variant Also Negotiates",
|
|
"507": "Insufficient Storage",
|
|
"508": "Loop Detected",
|
|
"509": "Bandwidth Limit Exceeded",
|
|
"510": "Not Extended",
|
|
"511": "Network Authentication Required"
|
|
}
|
|
|
|
},{}],30:[function(require,module,exports){
|
|
// 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 objectCreate = Object.create || objectCreatePolyfill
|
|
var objectKeys = Object.keys || objectKeysPolyfill
|
|
var bind = Function.prototype.bind || functionBindPolyfill
|
|
|
|
function EventEmitter() {
|
|
if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
|
|
this._events = objectCreate(null);
|
|
this._eventsCount = 0;
|
|
}
|
|
|
|
this._maxListeners = this._maxListeners || undefined;
|
|
}
|
|
module.exports = EventEmitter;
|
|
|
|
// Backwards-compat with node 0.10.x
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|
var defaultMaxListeners = 10;
|
|
|
|
var hasDefineProperty;
|
|
try {
|
|
var o = {};
|
|
if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
|
|
hasDefineProperty = o.x === 0;
|
|
} catch (err) { hasDefineProperty = false }
|
|
if (hasDefineProperty) {
|
|
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
|
|
enumerable: true,
|
|
get: function() {
|
|
return defaultMaxListeners;
|
|
},
|
|
set: function(arg) {
|
|
// check whether the input is a positive number (whose value is zero or
|
|
// greater and not a NaN).
|
|
if (typeof arg !== 'number' || arg < 0 || arg !== arg)
|
|
throw new TypeError('"defaultMaxListeners" must be a positive number');
|
|
defaultMaxListeners = arg;
|
|
}
|
|
});
|
|
} else {
|
|
EventEmitter.defaultMaxListeners = defaultMaxListeners;
|
|
}
|
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|
// that to be increased. Set to zero for unlimited.
|
|
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
|
|
if (typeof n !== 'number' || n < 0 || isNaN(n))
|
|
throw new TypeError('"n" argument must be a positive number');
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
|
|
function $getMaxListeners(that) {
|
|
if (that._maxListeners === undefined)
|
|
return EventEmitter.defaultMaxListeners;
|
|
return that._maxListeners;
|
|
}
|
|
|
|
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
|
|
return $getMaxListeners(this);
|
|
};
|
|
|
|
// These standalone emit* functions are used to optimize calling of event
|
|
// handlers for fast cases because emit() itself often has a variable number of
|
|
// arguments and can be deoptimized because of that. These functions always have
|
|
// the same number of arguments and thus do not get deoptimized, so the code
|
|
// inside them can execute faster.
|
|
function emitNone(handler, isFn, self) {
|
|
if (isFn)
|
|
handler.call(self);
|
|
else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
listeners[i].call(self);
|
|
}
|
|
}
|
|
function emitOne(handler, isFn, self, arg1) {
|
|
if (isFn)
|
|
handler.call(self, arg1);
|
|
else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
listeners[i].call(self, arg1);
|
|
}
|
|
}
|
|
function emitTwo(handler, isFn, self, arg1, arg2) {
|
|
if (isFn)
|
|
handler.call(self, arg1, arg2);
|
|
else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
listeners[i].call(self, arg1, arg2);
|
|
}
|
|
}
|
|
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
|
|
if (isFn)
|
|
handler.call(self, arg1, arg2, arg3);
|
|
else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
listeners[i].call(self, arg1, arg2, arg3);
|
|
}
|
|
}
|
|
|
|
function emitMany(handler, isFn, self, args) {
|
|
if (isFn)
|
|
handler.apply(self, args);
|
|
else {
|
|
var len = handler.length;
|
|
var listeners = arrayClone(handler, len);
|
|
for (var i = 0; i < len; ++i)
|
|
listeners[i].apply(self, args);
|
|
}
|
|
}
|
|
|
|
EventEmitter.prototype.emit = function emit(type) {
|
|
var er, handler, len, args, i, events;
|
|
var doError = (type === 'error');
|
|
|
|
events = this._events;
|
|
if (events)
|
|
doError = (doError && events.error == null);
|
|
else if (!doError)
|
|
return false;
|
|
|
|
// If there is no 'error' event listener then throw.
|
|
if (doError) {
|
|
if (arguments.length > 1)
|
|
er = arguments[1];
|
|
if (er instanceof Error) {
|
|
throw er; // Unhandled 'error' event
|
|
} else {
|
|
// At least give some kind of context to the user
|
|
var err = new Error('Unhandled "error" event. (' + er + ')');
|
|
err.context = er;
|
|
throw err;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
handler = events[type];
|
|
|
|
if (!handler)
|
|
return false;
|
|
|
|
var isFn = typeof handler === 'function';
|
|
len = arguments.length;
|
|
switch (len) {
|
|
// fast cases
|
|
case 1:
|
|
emitNone(handler, isFn, this);
|
|
break;
|
|
case 2:
|
|
emitOne(handler, isFn, this, arguments[1]);
|
|
break;
|
|
case 3:
|
|
emitTwo(handler, isFn, this, arguments[1], arguments[2]);
|
|
break;
|
|
case 4:
|
|
emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
|
|
break;
|
|
// slower
|
|
default:
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
emitMany(handler, isFn, this, args);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
function _addListener(target, type, listener, prepend) {
|
|
var m;
|
|
var events;
|
|
var existing;
|
|
|
|
if (typeof listener !== 'function')
|
|
throw new TypeError('"listener" argument must be a function');
|
|
|
|
events = target._events;
|
|
if (!events) {
|
|
events = target._events = objectCreate(null);
|
|
target._eventsCount = 0;
|
|
} else {
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|
// adding it to the listeners, first emit "newListener".
|
|
if (events.newListener) {
|
|
target.emit('newListener', type,
|
|
listener.listener ? listener.listener : listener);
|
|
|
|
// Re-assign `events` because a newListener handler could have caused the
|
|
// this._events to be assigned to a new object
|
|
events = target._events;
|
|
}
|
|
existing = events[type];
|
|
}
|
|
|
|
if (!existing) {
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|
existing = events[type] = listener;
|
|
++target._eventsCount;
|
|
} else {
|
|
if (typeof existing === 'function') {
|
|
// Adding the second element, need to change to array.
|
|
existing = events[type] =
|
|
prepend ? [listener, existing] : [existing, listener];
|
|
} else {
|
|
// If we've already got an array, just append.
|
|
if (prepend) {
|
|
existing.unshift(listener);
|
|
} else {
|
|
existing.push(listener);
|
|
}
|
|
}
|
|
|
|
// Check for listener leak
|
|
if (!existing.warned) {
|
|
m = $getMaxListeners(target);
|
|
if (m && m > 0 && existing.length > m) {
|
|
existing.warned = true;
|
|
var w = new Error('Possible EventEmitter memory leak detected. ' +
|
|
existing.length + ' "' + String(type) + '" listeners ' +
|
|
'added. Use emitter.setMaxListeners() to ' +
|
|
'increase limit.');
|
|
w.name = 'MaxListenersExceededWarning';
|
|
w.emitter = target;
|
|
w.type = type;
|
|
w.count = existing.length;
|
|
if (typeof console === 'object' && console.warn) {
|
|
console.warn('%s: %s', w.name, w.message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
EventEmitter.prototype.addListener = function addListener(type, listener) {
|
|
return _addListener(this, type, listener, false);
|
|
};
|
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
|
EventEmitter.prototype.prependListener =
|
|
function prependListener(type, listener) {
|
|
return _addListener(this, type, listener, true);
|
|
};
|
|
|
|
function onceWrapper() {
|
|
if (!this.fired) {
|
|
this.target.removeListener(this.type, this.wrapFn);
|
|
this.fired = true;
|
|
switch (arguments.length) {
|
|
case 0:
|
|
return this.listener.call(this.target);
|
|
case 1:
|
|
return this.listener.call(this.target, arguments[0]);
|
|
case 2:
|
|
return this.listener.call(this.target, arguments[0], arguments[1]);
|
|
case 3:
|
|
return this.listener.call(this.target, arguments[0], arguments[1],
|
|
arguments[2]);
|
|
default:
|
|
var args = new Array(arguments.length);
|
|
for (var i = 0; i < args.length; ++i)
|
|
args[i] = arguments[i];
|
|
this.listener.apply(this.target, args);
|
|
}
|
|
}
|
|
}
|
|
|
|
function _onceWrap(target, type, listener) {
|
|
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
|
|
var wrapped = bind.call(onceWrapper, state);
|
|
wrapped.listener = listener;
|
|
state.wrapFn = wrapped;
|
|
return wrapped;
|
|
}
|
|
|
|
EventEmitter.prototype.once = function once(type, listener) {
|
|
if (typeof listener !== 'function')
|
|
throw new TypeError('"listener" argument must be a function');
|
|
this.on(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.prependOnceListener =
|
|
function prependOnceListener(type, listener) {
|
|
if (typeof listener !== 'function')
|
|
throw new TypeError('"listener" argument must be a function');
|
|
this.prependListener(type, _onceWrap(this, type, listener));
|
|
return this;
|
|
};
|
|
|
|
// Emits a 'removeListener' event if and only if the listener was removed.
|
|
EventEmitter.prototype.removeListener =
|
|
function removeListener(type, listener) {
|
|
var list, events, position, i, originalListener;
|
|
|
|
if (typeof listener !== 'function')
|
|
throw new TypeError('"listener" argument must be a function');
|
|
|
|
events = this._events;
|
|
if (!events)
|
|
return this;
|
|
|
|
list = events[type];
|
|
if (!list)
|
|
return this;
|
|
|
|
if (list === listener || list.listener === listener) {
|
|
if (--this._eventsCount === 0)
|
|
this._events = objectCreate(null);
|
|
else {
|
|
delete events[type];
|
|
if (events.removeListener)
|
|
this.emit('removeListener', type, list.listener || listener);
|
|
}
|
|
} else if (typeof list !== 'function') {
|
|
position = -1;
|
|
|
|
for (i = list.length - 1; i >= 0; i--) {
|
|
if (list[i] === listener || list[i].listener === listener) {
|
|
originalListener = list[i].listener;
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (position < 0)
|
|
return this;
|
|
|
|
if (position === 0)
|
|
list.shift();
|
|
else
|
|
spliceOne(list, position);
|
|
|
|
if (list.length === 1)
|
|
events[type] = list[0];
|
|
|
|
if (events.removeListener)
|
|
this.emit('removeListener', type, originalListener || listener);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.removeAllListeners =
|
|
function removeAllListeners(type) {
|
|
var listeners, events, i;
|
|
|
|
events = this._events;
|
|
if (!events)
|
|
return this;
|
|
|
|
// not listening for removeListener, no need to emit
|
|
if (!events.removeListener) {
|
|
if (arguments.length === 0) {
|
|
this._events = objectCreate(null);
|
|
this._eventsCount = 0;
|
|
} else if (events[type]) {
|
|
if (--this._eventsCount === 0)
|
|
this._events = objectCreate(null);
|
|
else
|
|
delete events[type];
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// emit removeListener for all listeners on all events
|
|
if (arguments.length === 0) {
|
|
var keys = objectKeys(events);
|
|
var key;
|
|
for (i = 0; i < keys.length; ++i) {
|
|
key = keys[i];
|
|
if (key === 'removeListener') continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners('removeListener');
|
|
this._events = objectCreate(null);
|
|
this._eventsCount = 0;
|
|
return this;
|
|
}
|
|
|
|
listeners = events[type];
|
|
|
|
if (typeof listeners === 'function') {
|
|
this.removeListener(type, listeners);
|
|
} else if (listeners) {
|
|
// LIFO order
|
|
for (i = listeners.length - 1; i >= 0; i--) {
|
|
this.removeListener(type, listeners[i]);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
function _listeners(target, type, unwrap) {
|
|
var events = target._events;
|
|
|
|
if (!events)
|
|
return [];
|
|
|
|
var evlistener = events[type];
|
|
if (!evlistener)
|
|
return [];
|
|
|
|
if (typeof evlistener === 'function')
|
|
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
|
|
|
|
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
|
|
}
|
|
|
|
EventEmitter.prototype.listeners = function listeners(type) {
|
|
return _listeners(this, type, true);
|
|
};
|
|
|
|
EventEmitter.prototype.rawListeners = function rawListeners(type) {
|
|
return _listeners(this, type, false);
|
|
};
|
|
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
if (typeof emitter.listenerCount === 'function') {
|
|
return emitter.listenerCount(type);
|
|
} else {
|
|
return listenerCount.call(emitter, type);
|
|
}
|
|
};
|
|
|
|
EventEmitter.prototype.listenerCount = listenerCount;
|
|
function listenerCount(type) {
|
|
var events = this._events;
|
|
|
|
if (events) {
|
|
var evlistener = events[type];
|
|
|
|
if (typeof evlistener === 'function') {
|
|
return 1;
|
|
} else if (evlistener) {
|
|
return evlistener.length;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
EventEmitter.prototype.eventNames = function eventNames() {
|
|
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
|
|
};
|
|
|
|
// About 1.5x faster than the two-arg version of Array#splice().
|
|
function spliceOne(list, index) {
|
|
for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
|
|
list[i] = list[k];
|
|
list.pop();
|
|
}
|
|
|
|
function arrayClone(arr, n) {
|
|
var copy = new Array(n);
|
|
for (var i = 0; i < n; ++i)
|
|
copy[i] = arr[i];
|
|
return copy;
|
|
}
|
|
|
|
function unwrapListeners(arr) {
|
|
var ret = new Array(arr.length);
|
|
for (var i = 0; i < ret.length; ++i) {
|
|
ret[i] = arr[i].listener || arr[i];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function objectCreatePolyfill(proto) {
|
|
var F = function() {};
|
|
F.prototype = proto;
|
|
return new F;
|
|
}
|
|
function objectKeysPolyfill(obj) {
|
|
var keys = [];
|
|
for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
|
|
keys.push(k);
|
|
}
|
|
return k;
|
|
}
|
|
function functionBindPolyfill(context) {
|
|
var fn = this;
|
|
return function () {
|
|
return fn.apply(context, arguments);
|
|
};
|
|
}
|
|
|
|
},{}],31:[function(require,module,exports){
|
|
var http = require('http')
|
|
var url = require('url')
|
|
|
|
var https = module.exports
|
|
|
|
for (var key in http) {
|
|
if (http.hasOwnProperty(key)) https[key] = http[key]
|
|
}
|
|
|
|
https.request = function (params, cb) {
|
|
params = validateParams(params)
|
|
return http.request.call(this, params, cb)
|
|
}
|
|
|
|
https.get = function (params, cb) {
|
|
params = validateParams(params)
|
|
return http.get.call(this, params, cb)
|
|
}
|
|
|
|
function validateParams (params) {
|
|
if (typeof params === 'string') {
|
|
params = url.parse(params)
|
|
}
|
|
if (!params.protocol) {
|
|
params.protocol = 'https:'
|
|
}
|
|
if (params.protocol !== 'https:') {
|
|
throw new Error('Protocol "' + params.protocol + '" not supported. Expected "https:"')
|
|
}
|
|
return params
|
|
}
|
|
|
|
},{"http":41,"url":61}],32:[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
|
|
}
|
|
|
|
},{}],33:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
if (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) {
|
|
if (superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
}
|
|
|
|
},{}],34:[function(require,module,exports){
|
|
(function (process){
|
|
// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,
|
|
// backported and transplited with Babel, with backwards-compat fixes
|
|
|
|
// 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.
|
|
|
|
// resolves . and .. elements in a path array with directory names there
|
|
// must be no slashes, empty elements, or device names (c:\) in the array
|
|
// (so also no leading and trailing slashes - it does not distinguish
|
|
// relative and absolute paths)
|
|
function normalizeArray(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var last = parts[i];
|
|
if (last === '.') {
|
|
parts.splice(i, 1);
|
|
} else if (last === '..') {
|
|
parts.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
parts.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (allowAboveRoot) {
|
|
for (; up--; up) {
|
|
parts.unshift('..');
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
// path.resolve([from ...], to)
|
|
// posix version
|
|
exports.resolve = function() {
|
|
var resolvedPath = '',
|
|
resolvedAbsolute = false;
|
|
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
var path = (i >= 0) ? arguments[i] : process.cwd();
|
|
|
|
// Skip empty and invalid entries
|
|
if (typeof path !== 'string') {
|
|
throw new TypeError('Arguments to path.resolve must be strings');
|
|
} else if (!path) {
|
|
continue;
|
|
}
|
|
|
|
resolvedPath = path + '/' + resolvedPath;
|
|
resolvedAbsolute = path.charAt(0) === '/';
|
|
}
|
|
|
|
// At this point the path should be resolved to a full absolute path, but
|
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
|
|
// Normalize the path
|
|
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
|
|
return !!p;
|
|
}), !resolvedAbsolute).join('/');
|
|
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
|
};
|
|
|
|
// path.normalize(path)
|
|
// posix version
|
|
exports.normalize = function(path) {
|
|
var isAbsolute = exports.isAbsolute(path),
|
|
trailingSlash = substr(path, -1) === '/';
|
|
|
|
// Normalize the path
|
|
path = normalizeArray(filter(path.split('/'), function(p) {
|
|
return !!p;
|
|
}), !isAbsolute).join('/');
|
|
|
|
if (!path && !isAbsolute) {
|
|
path = '.';
|
|
}
|
|
if (path && trailingSlash) {
|
|
path += '/';
|
|
}
|
|
|
|
return (isAbsolute ? '/' : '') + path;
|
|
};
|
|
|
|
// posix version
|
|
exports.isAbsolute = function(path) {
|
|
return path.charAt(0) === '/';
|
|
};
|
|
|
|
// posix version
|
|
exports.join = function() {
|
|
var paths = Array.prototype.slice.call(arguments, 0);
|
|
return exports.normalize(filter(paths, function(p, index) {
|
|
if (typeof p !== 'string') {
|
|
throw new TypeError('Arguments to path.join must be strings');
|
|
}
|
|
return p;
|
|
}).join('/'));
|
|
};
|
|
|
|
|
|
// path.relative(from, to)
|
|
// posix version
|
|
exports.relative = function(from, to) {
|
|
from = exports.resolve(from).substr(1);
|
|
to = exports.resolve(to).substr(1);
|
|
|
|
function trim(arr) {
|
|
var start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') break;
|
|
}
|
|
|
|
var end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') break;
|
|
}
|
|
|
|
if (start > end) return [];
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
|
|
var fromParts = trim(from.split('/'));
|
|
var toParts = trim(to.split('/'));
|
|
|
|
var length = Math.min(fromParts.length, toParts.length);
|
|
var samePartsLength = length;
|
|
for (var i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var outputParts = [];
|
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
|
|
return outputParts.join('/');
|
|
};
|
|
|
|
exports.sep = '/';
|
|
exports.delimiter = ':';
|
|
|
|
exports.dirname = function (path) {
|
|
if (typeof path !== 'string') path = path + '';
|
|
if (path.length === 0) return '.';
|
|
var code = path.charCodeAt(0);
|
|
var hasRoot = code === 47 /*/*/;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
for (var i = path.length - 1; i >= 1; --i) {
|
|
code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
// We saw the first non-path separator
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
|
|
if (end === -1) return hasRoot ? '/' : '.';
|
|
if (hasRoot && end === 1) {
|
|
// return '//';
|
|
// Backwards-compat fix:
|
|
return '/';
|
|
}
|
|
return path.slice(0, end);
|
|
};
|
|
|
|
function basename(path) {
|
|
if (typeof path !== 'string') path = path + '';
|
|
|
|
var start = 0;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
var i;
|
|
|
|
for (i = path.length - 1; i >= 0; --i) {
|
|
if (path.charCodeAt(i) === 47 /*/*/) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// path component
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
|
|
if (end === -1) return '';
|
|
return path.slice(start, end);
|
|
}
|
|
|
|
// Uses a mixed approach for backwards-compatibility, as ext behavior changed
|
|
// in new Node.js versions, so only basename() above is backported here
|
|
exports.basename = function (path, ext) {
|
|
var f = basename(path);
|
|
if (ext && f.substr(-1 * ext.length) === ext) {
|
|
f = f.substr(0, f.length - ext.length);
|
|
}
|
|
return f;
|
|
};
|
|
|
|
exports.extname = function (path) {
|
|
if (typeof path !== 'string') path = path + '';
|
|
var startDot = -1;
|
|
var startPart = 0;
|
|
var end = -1;
|
|
var matchedSlash = true;
|
|
// Track the state of characters (if any) we see before our first dot and
|
|
// after any path separator we find
|
|
var preDotState = 0;
|
|
for (var i = path.length - 1; i >= 0; --i) {
|
|
var code = path.charCodeAt(i);
|
|
if (code === 47 /*/*/) {
|
|
// If we reached a path separator that was not part of a set of path
|
|
// separators at the end of the string, stop now
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
// We saw the first non-path separator, mark this as the end of our
|
|
// extension
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === 46 /*.*/) {
|
|
// If this is our first dot, mark it as the start of our extension
|
|
if (startDot === -1)
|
|
startDot = i;
|
|
else if (preDotState !== 1)
|
|
preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
// We saw a non-dot and non-path separator before our dot, so we should
|
|
// have a good chance at having a non-empty extension
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
|
|
if (startDot === -1 || end === -1 ||
|
|
// We saw a non-dot character immediately before the dot
|
|
preDotState === 0 ||
|
|
// The (right-most) trimmed path component is exactly '..'
|
|
preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
return '';
|
|
}
|
|
return path.slice(startDot, end);
|
|
};
|
|
|
|
function filter (xs, f) {
|
|
if (xs.filter) return xs.filter(f);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
if (f(xs[i], i, xs)) res.push(xs[i]);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// String.prototype.substr - negative index don't work in IE8
|
|
var substr = 'ab'.substr(-1) === 'b'
|
|
? function (str, start, len) { return str.substr(start, len) }
|
|
: function (str, start, len) {
|
|
if (start < 0) start = str.length + start;
|
|
return str.substr(start, len);
|
|
}
|
|
;
|
|
|
|
}).call(this,require('_process'))
|
|
},{"_process":35}],35:[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.prependListener = noop;
|
|
process.prependOnceListener = noop;
|
|
|
|
process.listeners = function (name) { return [] }
|
|
|
|
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; };
|
|
|
|
},{}],36:[function(require,module,exports){
|
|
(function (global){
|
|
/*! https://mths.be/punycode v1.4.1 by @mathias */
|
|
;(function(root) {
|
|
|
|
/** Detect free variables */
|
|
var freeExports = typeof exports == 'object' && exports &&
|
|
!exports.nodeType && exports;
|
|
var freeModule = typeof module == 'object' && module &&
|
|
!module.nodeType && module;
|
|
var freeGlobal = typeof global == 'object' && global;
|
|
if (
|
|
freeGlobal.global === freeGlobal ||
|
|
freeGlobal.window === freeGlobal ||
|
|
freeGlobal.self === freeGlobal
|
|
) {
|
|
root = freeGlobal;
|
|
}
|
|
|
|
/**
|
|
* The `punycode` object.
|
|
* @name punycode
|
|
* @type Object
|
|
*/
|
|
var punycode,
|
|
|
|
/** Highest positive signed 32-bit float value */
|
|
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
|
|
|
|
/** Bootstring parameters */
|
|
base = 36,
|
|
tMin = 1,
|
|
tMax = 26,
|
|
skew = 38,
|
|
damp = 700,
|
|
initialBias = 72,
|
|
initialN = 128, // 0x80
|
|
delimiter = '-', // '\x2D'
|
|
|
|
/** Regular expressions */
|
|
regexPunycode = /^xn--/,
|
|
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
|
|
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
|
|
|
|
/** Error messages */
|
|
errors = {
|
|
'overflow': 'Overflow: input needs wider integers to process',
|
|
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
|
|
'invalid-input': 'Invalid input'
|
|
},
|
|
|
|
/** Convenience shortcuts */
|
|
baseMinusTMin = base - tMin,
|
|
floor = Math.floor,
|
|
stringFromCharCode = String.fromCharCode,
|
|
|
|
/** Temporary variable */
|
|
key;
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/**
|
|
* A generic error utility function.
|
|
* @private
|
|
* @param {String} type The error type.
|
|
* @returns {Error} Throws a `RangeError` with the applicable error message.
|
|
*/
|
|
function error(type) {
|
|
throw new RangeError(errors[type]);
|
|
}
|
|
|
|
/**
|
|
* A generic `Array#map` utility function.
|
|
* @private
|
|
* @param {Array} array The array to iterate over.
|
|
* @param {Function} callback The function that gets called for every array
|
|
* item.
|
|
* @returns {Array} A new array of values returned by the callback function.
|
|
*/
|
|
function map(array, fn) {
|
|
var length = array.length;
|
|
var result = [];
|
|
while (length--) {
|
|
result[length] = fn(array[length]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* A simple `Array#map`-like wrapper to work with domain name strings or email
|
|
* addresses.
|
|
* @private
|
|
* @param {String} domain The domain name or email address.
|
|
* @param {Function} callback The function that gets called for every
|
|
* character.
|
|
* @returns {Array} A new string of characters returned by the callback
|
|
* function.
|
|
*/
|
|
function mapDomain(string, fn) {
|
|
var parts = string.split('@');
|
|
var result = '';
|
|
if (parts.length > 1) {
|
|
// In email addresses, only the domain name should be punycoded. Leave
|
|
// the local part (i.e. everything up to `@`) intact.
|
|
result = parts[0] + '@';
|
|
string = parts[1];
|
|
}
|
|
// Avoid `split(regex)` for IE8 compatibility. See #17.
|
|
string = string.replace(regexSeparators, '\x2E');
|
|
var labels = string.split('.');
|
|
var encoded = map(labels, fn).join('.');
|
|
return result + encoded;
|
|
}
|
|
|
|
/**
|
|
* Creates an array containing the numeric code points of each Unicode
|
|
* character in the string. While JavaScript uses UCS-2 internally,
|
|
* this function will convert a pair of surrogate halves (each of which
|
|
* UCS-2 exposes as separate characters) into a single code point,
|
|
* matching UTF-16.
|
|
* @see `punycode.ucs2.encode`
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
* @memberOf punycode.ucs2
|
|
* @name decode
|
|
* @param {String} string The Unicode input string (UCS-2).
|
|
* @returns {Array} The new array of code points.
|
|
*/
|
|
function ucs2decode(string) {
|
|
var output = [],
|
|
counter = 0,
|
|
length = string.length,
|
|
value,
|
|
extra;
|
|
while (counter < length) {
|
|
value = string.charCodeAt(counter++);
|
|
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
|
// high surrogate, and there is a next character
|
|
extra = string.charCodeAt(counter++);
|
|
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
|
|
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
|
} else {
|
|
// unmatched surrogate; only append this code unit, in case the next
|
|
// code unit is the high surrogate of a surrogate pair
|
|
output.push(value);
|
|
counter--;
|
|
}
|
|
} else {
|
|
output.push(value);
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
|
|
/**
|
|
* Creates a string based on an array of numeric code points.
|
|
* @see `punycode.ucs2.decode`
|
|
* @memberOf punycode.ucs2
|
|
* @name encode
|
|
* @param {Array} codePoints The array of numeric code points.
|
|
* @returns {String} The new Unicode string (UCS-2).
|
|
*/
|
|
function ucs2encode(array) {
|
|
return map(array, function(value) {
|
|
var output = '';
|
|
if (value > 0xFFFF) {
|
|
value -= 0x10000;
|
|
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
|
|
value = 0xDC00 | value & 0x3FF;
|
|
}
|
|
output += stringFromCharCode(value);
|
|
return output;
|
|
}).join('');
|
|
}
|
|
|
|
/**
|
|
* Converts a basic code point into a digit/integer.
|
|
* @see `digitToBasic()`
|
|
* @private
|
|
* @param {Number} codePoint The basic numeric code point value.
|
|
* @returns {Number} The numeric value of a basic code point (for use in
|
|
* representing integers) in the range `0` to `base - 1`, or `base` if
|
|
* the code point does not represent a value.
|
|
*/
|
|
function basicToDigit(codePoint) {
|
|
if (codePoint - 48 < 10) {
|
|
return codePoint - 22;
|
|
}
|
|
if (codePoint - 65 < 26) {
|
|
return codePoint - 65;
|
|
}
|
|
if (codePoint - 97 < 26) {
|
|
return codePoint - 97;
|
|
}
|
|
return base;
|
|
}
|
|
|
|
/**
|
|
* Converts a digit/integer into a basic code point.
|
|
* @see `basicToDigit()`
|
|
* @private
|
|
* @param {Number} digit The numeric value of a basic code point.
|
|
* @returns {Number} The basic code point whose value (when used for
|
|
* representing integers) is `digit`, which needs to be in the range
|
|
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
|
|
* used; else, the lowercase form is used. The behavior is undefined
|
|
* if `flag` is non-zero and `digit` has no uppercase form.
|
|
*/
|
|
function digitToBasic(digit, flag) {
|
|
// 0..25 map to ASCII a..z or A..Z
|
|
// 26..35 map to ASCII 0..9
|
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
|
}
|
|
|
|
/**
|
|
* Bias adaptation function as per section 3.4 of RFC 3492.
|
|
* https://tools.ietf.org/html/rfc3492#section-3.4
|
|
* @private
|
|
*/
|
|
function adapt(delta, numPoints, firstTime) {
|
|
var k = 0;
|
|
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
|
delta += floor(delta / numPoints);
|
|
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
|
|
delta = floor(delta / baseMinusTMin);
|
|
}
|
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
|
}
|
|
|
|
/**
|
|
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
|
|
* symbols.
|
|
* @memberOf punycode
|
|
* @param {String} input The Punycode string of ASCII-only symbols.
|
|
* @returns {String} The resulting string of Unicode symbols.
|
|
*/
|
|
function decode(input) {
|
|
// Don't use UCS-2
|
|
var output = [],
|
|
inputLength = input.length,
|
|
out,
|
|
i = 0,
|
|
n = initialN,
|
|
bias = initialBias,
|
|
basic,
|
|
j,
|
|
index,
|
|
oldi,
|
|
w,
|
|
k,
|
|
digit,
|
|
t,
|
|
/** Cached calculation results */
|
|
baseMinusT;
|
|
|
|
// Handle the basic code points: let `basic` be the number of input code
|
|
// points before the last delimiter, or `0` if there is none, then copy
|
|
// the first basic code points to the output.
|
|
|
|
basic = input.lastIndexOf(delimiter);
|
|
if (basic < 0) {
|
|
basic = 0;
|
|
}
|
|
|
|
for (j = 0; j < basic; ++j) {
|
|
// if it's not a basic code point
|
|
if (input.charCodeAt(j) >= 0x80) {
|
|
error('not-basic');
|
|
}
|
|
output.push(input.charCodeAt(j));
|
|
}
|
|
|
|
// Main decoding loop: start just after the last delimiter if any basic code
|
|
// points were copied; start at the beginning otherwise.
|
|
|
|
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
|
|
|
|
// `index` is the index of the next character to be consumed.
|
|
// Decode a generalized variable-length integer into `delta`,
|
|
// which gets added to `i`. The overflow checking is easier
|
|
// if we increase `i` as we go, then subtract off its starting
|
|
// value at the end to obtain `delta`.
|
|
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
|
|
|
|
if (index >= inputLength) {
|
|
error('invalid-input');
|
|
}
|
|
|
|
digit = basicToDigit(input.charCodeAt(index++));
|
|
|
|
if (digit >= base || digit > floor((maxInt - i) / w)) {
|
|
error('overflow');
|
|
}
|
|
|
|
i += digit * w;
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
|
|
if (digit < t) {
|
|
break;
|
|
}
|
|
|
|
baseMinusT = base - t;
|
|
if (w > floor(maxInt / baseMinusT)) {
|
|
error('overflow');
|
|
}
|
|
|
|
w *= baseMinusT;
|
|
|
|
}
|
|
|
|
out = output.length + 1;
|
|
bias = adapt(i - oldi, out, oldi == 0);
|
|
|
|
// `i` was supposed to wrap around from `out` to `0`,
|
|
// incrementing `n` each time, so we'll fix that now:
|
|
if (floor(i / out) > maxInt - n) {
|
|
error('overflow');
|
|
}
|
|
|
|
n += floor(i / out);
|
|
i %= out;
|
|
|
|
// Insert `n` at position `i` of the output
|
|
output.splice(i++, 0, n);
|
|
|
|
}
|
|
|
|
return ucs2encode(output);
|
|
}
|
|
|
|
/**
|
|
* Converts a string of Unicode symbols (e.g. a domain name label) to a
|
|
* Punycode string of ASCII-only symbols.
|
|
* @memberOf punycode
|
|
* @param {String} input The string of Unicode symbols.
|
|
* @returns {String} The resulting Punycode string of ASCII-only symbols.
|
|
*/
|
|
function encode(input) {
|
|
var n,
|
|
delta,
|
|
handledCPCount,
|
|
basicLength,
|
|
bias,
|
|
j,
|
|
m,
|
|
q,
|
|
k,
|
|
t,
|
|
currentValue,
|
|
output = [],
|
|
/** `inputLength` will hold the number of code points in `input`. */
|
|
inputLength,
|
|
/** Cached calculation results */
|
|
handledCPCountPlusOne,
|
|
baseMinusT,
|
|
qMinusT;
|
|
|
|
// Convert the input in UCS-2 to Unicode
|
|
input = ucs2decode(input);
|
|
|
|
// Cache the length
|
|
inputLength = input.length;
|
|
|
|
// Initialize the state
|
|
n = initialN;
|
|
delta = 0;
|
|
bias = initialBias;
|
|
|
|
// Handle the basic code points
|
|
for (j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
if (currentValue < 0x80) {
|
|
output.push(stringFromCharCode(currentValue));
|
|
}
|
|
}
|
|
|
|
handledCPCount = basicLength = output.length;
|
|
|
|
// `handledCPCount` is the number of code points that have been handled;
|
|
// `basicLength` is the number of basic code points.
|
|
|
|
// Finish the basic string - if it is not empty - with a delimiter
|
|
if (basicLength) {
|
|
output.push(delimiter);
|
|
}
|
|
|
|
// Main encoding loop:
|
|
while (handledCPCount < inputLength) {
|
|
|
|
// All non-basic code points < n have been handled already. Find the next
|
|
// larger one:
|
|
for (m = maxInt, j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
if (currentValue >= n && currentValue < m) {
|
|
m = currentValue;
|
|
}
|
|
}
|
|
|
|
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
|
|
// but guard against overflow
|
|
handledCPCountPlusOne = handledCPCount + 1;
|
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
|
error('overflow');
|
|
}
|
|
|
|
delta += (m - n) * handledCPCountPlusOne;
|
|
n = m;
|
|
|
|
for (j = 0; j < inputLength; ++j) {
|
|
currentValue = input[j];
|
|
|
|
if (currentValue < n && ++delta > maxInt) {
|
|
error('overflow');
|
|
}
|
|
|
|
if (currentValue == n) {
|
|
// Represent delta as a generalized variable-length integer
|
|
for (q = delta, k = base; /* no condition */; k += base) {
|
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
|
if (q < t) {
|
|
break;
|
|
}
|
|
qMinusT = q - t;
|
|
baseMinusT = base - t;
|
|
output.push(
|
|
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
|
);
|
|
q = floor(qMinusT / baseMinusT);
|
|
}
|
|
|
|
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
|
|
delta = 0;
|
|
++handledCPCount;
|
|
}
|
|
}
|
|
|
|
++delta;
|
|
++n;
|
|
|
|
}
|
|
return output.join('');
|
|
}
|
|
|
|
/**
|
|
* Converts a Punycode string representing a domain name or an email address
|
|
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
|
|
* it doesn't matter if you call it on a string that has already been
|
|
* converted to Unicode.
|
|
* @memberOf punycode
|
|
* @param {String} input The Punycoded domain name or email address to
|
|
* convert to Unicode.
|
|
* @returns {String} The Unicode representation of the given Punycode
|
|
* string.
|
|
*/
|
|
function toUnicode(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexPunycode.test(string)
|
|
? decode(string.slice(4).toLowerCase())
|
|
: string;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Converts a Unicode string representing a domain name or an email address to
|
|
* Punycode. Only the non-ASCII parts of the domain name will be converted,
|
|
* i.e. it doesn't matter if you call it with a domain that's already in
|
|
* ASCII.
|
|
* @memberOf punycode
|
|
* @param {String} input The domain name or email address to convert, as a
|
|
* Unicode string.
|
|
* @returns {String} The Punycode representation of the given domain name or
|
|
* email address.
|
|
*/
|
|
function toASCII(input) {
|
|
return mapDomain(input, function(string) {
|
|
return regexNonASCII.test(string)
|
|
? 'xn--' + encode(string)
|
|
: string;
|
|
});
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/** Define the public API */
|
|
punycode = {
|
|
/**
|
|
* A string representing the current Punycode.js version number.
|
|
* @memberOf punycode
|
|
* @type String
|
|
*/
|
|
'version': '1.4.1',
|
|
/**
|
|
* An object of methods to convert from JavaScript's internal character
|
|
* representation (UCS-2) to Unicode code points, and back.
|
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
|
* @memberOf punycode
|
|
* @type Object
|
|
*/
|
|
'ucs2': {
|
|
'decode': ucs2decode,
|
|
'encode': ucs2encode
|
|
},
|
|
'decode': decode,
|
|
'encode': encode,
|
|
'toASCII': toASCII,
|
|
'toUnicode': toUnicode
|
|
};
|
|
|
|
/** Expose `punycode` */
|
|
// Some AMD build optimizers, like r.js, check for specific condition patterns
|
|
// like the following:
|
|
if (
|
|
typeof define == 'function' &&
|
|
typeof define.amd == 'object' &&
|
|
define.amd
|
|
) {
|
|
define('punycode', function() {
|
|
return punycode;
|
|
});
|
|
} else if (freeExports && freeModule) {
|
|
if (module.exports == freeExports) {
|
|
// in Node.js, io.js, or RingoJS v0.8.0+
|
|
freeModule.exports = punycode;
|
|
} else {
|
|
// in Narwhal or RingoJS v0.7.0-
|
|
for (key in punycode) {
|
|
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
|
|
}
|
|
}
|
|
} else {
|
|
// in Rhino or a web browser
|
|
root.punycode = punycode;
|
|
}
|
|
|
|
}(this));
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],37:[function(require,module,exports){
|
|
// 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.
|
|
|
|
'use strict';
|
|
|
|
// If obj.hasOwnProperty has been overridden, then calling
|
|
// obj.hasOwnProperty(prop) will break.
|
|
// See: https://github.com/joyent/node/issues/1707
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
module.exports = function(qs, sep, eq, options) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
var obj = {};
|
|
|
|
if (typeof qs !== 'string' || qs.length === 0) {
|
|
return obj;
|
|
}
|
|
|
|
var regexp = /\+/g;
|
|
qs = qs.split(sep);
|
|
|
|
var maxKeys = 1000;
|
|
if (options && typeof options.maxKeys === 'number') {
|
|
maxKeys = options.maxKeys;
|
|
}
|
|
|
|
var len = qs.length;
|
|
// maxKeys <= 0 means that we should not limit keys count
|
|
if (maxKeys > 0 && len > maxKeys) {
|
|
len = maxKeys;
|
|
}
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
var x = qs[i].replace(regexp, '%20'),
|
|
idx = x.indexOf(eq),
|
|
kstr, vstr, k, v;
|
|
|
|
if (idx >= 0) {
|
|
kstr = x.substr(0, idx);
|
|
vstr = x.substr(idx + 1);
|
|
} else {
|
|
kstr = x;
|
|
vstr = '';
|
|
}
|
|
|
|
k = decodeURIComponent(kstr);
|
|
v = decodeURIComponent(vstr);
|
|
|
|
if (!hasOwnProperty(obj, k)) {
|
|
obj[k] = v;
|
|
} else if (isArray(obj[k])) {
|
|
obj[k].push(v);
|
|
} else {
|
|
obj[k] = [obj[k], v];
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
var isArray = Array.isArray || function (xs) {
|
|
return Object.prototype.toString.call(xs) === '[object Array]';
|
|
};
|
|
|
|
},{}],38:[function(require,module,exports){
|
|
// 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.
|
|
|
|
'use strict';
|
|
|
|
var stringifyPrimitive = function(v) {
|
|
switch (typeof v) {
|
|
case 'string':
|
|
return v;
|
|
|
|
case 'boolean':
|
|
return v ? 'true' : 'false';
|
|
|
|
case 'number':
|
|
return isFinite(v) ? v : '';
|
|
|
|
default:
|
|
return '';
|
|
}
|
|
};
|
|
|
|
module.exports = function(obj, sep, eq, name) {
|
|
sep = sep || '&';
|
|
eq = eq || '=';
|
|
if (obj === null) {
|
|
obj = undefined;
|
|
}
|
|
|
|
if (typeof obj === 'object') {
|
|
return map(objectKeys(obj), function(k) {
|
|
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
|
|
if (isArray(obj[k])) {
|
|
return map(obj[k], function(v) {
|
|
return ks + encodeURIComponent(stringifyPrimitive(v));
|
|
}).join(sep);
|
|
} else {
|
|
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
|
|
}
|
|
}).join(sep);
|
|
|
|
}
|
|
|
|
if (!name) return '';
|
|
return encodeURIComponent(stringifyPrimitive(name)) + eq +
|
|
encodeURIComponent(stringifyPrimitive(obj));
|
|
};
|
|
|
|
var isArray = Array.isArray || function (xs) {
|
|
return Object.prototype.toString.call(xs) === '[object Array]';
|
|
};
|
|
|
|
function map (xs, f) {
|
|
if (xs.map) return xs.map(f);
|
|
var res = [];
|
|
for (var i = 0; i < xs.length; i++) {
|
|
res.push(f(xs[i], i));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
var objectKeys = Object.keys || function (obj) {
|
|
var res = [];
|
|
for (var key in obj) {
|
|
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
},{}],39:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
exports.decode = exports.parse = require('./decode');
|
|
exports.encode = exports.stringify = require('./encode');
|
|
|
|
},{"./decode":37,"./encode":38}],40:[function(require,module,exports){
|
|
arguments[4][15][0].apply(exports,arguments)
|
|
},{"buffer":28,"dup":15}],41:[function(require,module,exports){
|
|
(function (global){
|
|
var ClientRequest = require('./lib/request')
|
|
var response = require('./lib/response')
|
|
var extend = require('xtend')
|
|
var statusCodes = require('builtin-status-codes')
|
|
var url = require('url')
|
|
|
|
var http = exports
|
|
|
|
http.request = function (opts, cb) {
|
|
if (typeof opts === 'string')
|
|
opts = url.parse(opts)
|
|
else
|
|
opts = extend(opts)
|
|
|
|
// Normally, the page is loaded from http or https, so not specifying a protocol
|
|
// will result in a (valid) protocol-relative url. However, this won't work if
|
|
// the protocol is something else, like 'file:'
|
|
var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''
|
|
|
|
var protocol = opts.protocol || defaultProtocol
|
|
var host = opts.hostname || opts.host
|
|
var port = opts.port
|
|
var path = opts.path || '/'
|
|
|
|
// Necessary for IPv6 addresses
|
|
if (host && host.indexOf(':') !== -1)
|
|
host = '[' + host + ']'
|
|
|
|
// This may be a relative url. The browser should always be able to interpret it correctly.
|
|
opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path
|
|
opts.method = (opts.method || 'GET').toUpperCase()
|
|
opts.headers = opts.headers || {}
|
|
|
|
// Also valid opts.auth, opts.mode
|
|
|
|
var req = new ClientRequest(opts)
|
|
if (cb)
|
|
req.on('response', cb)
|
|
return req
|
|
}
|
|
|
|
http.get = function get (opts, cb) {
|
|
var req = http.request(opts, cb)
|
|
req.end()
|
|
return req
|
|
}
|
|
|
|
http.ClientRequest = ClientRequest
|
|
http.IncomingMessage = response.IncomingMessage
|
|
|
|
http.Agent = function () {}
|
|
http.Agent.defaultMaxSockets = 4
|
|
|
|
http.globalAgent = new http.Agent()
|
|
|
|
http.STATUS_CODES = statusCodes
|
|
|
|
http.METHODS = [
|
|
'CHECKOUT',
|
|
'CONNECT',
|
|
'COPY',
|
|
'DELETE',
|
|
'GET',
|
|
'HEAD',
|
|
'LOCK',
|
|
'M-SEARCH',
|
|
'MERGE',
|
|
'MKACTIVITY',
|
|
'MKCOL',
|
|
'MOVE',
|
|
'NOTIFY',
|
|
'OPTIONS',
|
|
'PATCH',
|
|
'POST',
|
|
'PROPFIND',
|
|
'PROPPATCH',
|
|
'PURGE',
|
|
'PUT',
|
|
'REPORT',
|
|
'SEARCH',
|
|
'SUBSCRIBE',
|
|
'TRACE',
|
|
'UNLOCK',
|
|
'UNSUBSCRIBE'
|
|
]
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./lib/request":43,"./lib/response":44,"builtin-status-codes":29,"url":61,"xtend":64}],42:[function(require,module,exports){
|
|
(function (global){
|
|
exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)
|
|
|
|
exports.writableStream = isFunction(global.WritableStream)
|
|
|
|
exports.abortController = isFunction(global.AbortController)
|
|
|
|
// The xhr request to example.com may violate some restrictive CSP configurations,
|
|
// so if we're running in a browser that supports `fetch`, avoid calling getXHR()
|
|
// and assume support for certain features below.
|
|
var xhr
|
|
function getXHR () {
|
|
// Cache the xhr value
|
|
if (xhr !== undefined) return xhr
|
|
|
|
if (global.XMLHttpRequest) {
|
|
xhr = new global.XMLHttpRequest()
|
|
// If XDomainRequest is available (ie only, where xhr might not work
|
|
// cross domain), use the page location. Otherwise use example.com
|
|
// Note: this doesn't actually make an http request.
|
|
try {
|
|
xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
|
|
} catch(e) {
|
|
xhr = null
|
|
}
|
|
} else {
|
|
// Service workers don't have XHR
|
|
xhr = null
|
|
}
|
|
return xhr
|
|
}
|
|
|
|
function checkTypeSupport (type) {
|
|
var xhr = getXHR()
|
|
if (!xhr) return false
|
|
try {
|
|
xhr.responseType = type
|
|
return xhr.responseType === type
|
|
} catch (e) {}
|
|
return false
|
|
}
|
|
|
|
// If fetch is supported, then arraybuffer will be supported too. Skip calling
|
|
// checkTypeSupport(), since that calls getXHR().
|
|
exports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer')
|
|
|
|
// These next two tests unavoidably show warnings in Chrome. Since fetch will always
|
|
// be used if it's available, just return false for these to avoid the warnings.
|
|
exports.msstream = !exports.fetch && checkTypeSupport('ms-stream')
|
|
exports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer')
|
|
|
|
// If fetch is supported, then overrideMimeType will be supported too. Skip calling
|
|
// getXHR().
|
|
exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)
|
|
|
|
function isFunction (value) {
|
|
return typeof value === 'function'
|
|
}
|
|
|
|
xhr = null // Help gc
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],43:[function(require,module,exports){
|
|
(function (process,global,Buffer){
|
|
var capability = require('./capability')
|
|
var inherits = require('inherits')
|
|
var response = require('./response')
|
|
var stream = require('readable-stream')
|
|
|
|
var IncomingMessage = response.IncomingMessage
|
|
var rStates = response.readyStates
|
|
|
|
function decideMode (preferBinary, useFetch) {
|
|
if (capability.fetch && useFetch) {
|
|
return 'fetch'
|
|
} else if (capability.mozchunkedarraybuffer) {
|
|
return 'moz-chunked-arraybuffer'
|
|
} else if (capability.msstream) {
|
|
return 'ms-stream'
|
|
} else if (capability.arraybuffer && preferBinary) {
|
|
return 'arraybuffer'
|
|
} else {
|
|
return 'text'
|
|
}
|
|
}
|
|
|
|
var ClientRequest = module.exports = function (opts) {
|
|
var self = this
|
|
stream.Writable.call(self)
|
|
|
|
self._opts = opts
|
|
self._body = []
|
|
self._headers = {}
|
|
if (opts.auth)
|
|
self.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'))
|
|
Object.keys(opts.headers).forEach(function (name) {
|
|
self.setHeader(name, opts.headers[name])
|
|
})
|
|
|
|
var preferBinary
|
|
var useFetch = true
|
|
if (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {
|
|
// If the use of XHR should be preferred. Not typically needed.
|
|
useFetch = false
|
|
preferBinary = true
|
|
} else if (opts.mode === 'prefer-streaming') {
|
|
// If streaming is a high priority but binary compatibility and
|
|
// the accuracy of the 'content-type' header aren't
|
|
preferBinary = false
|
|
} else if (opts.mode === 'allow-wrong-content-type') {
|
|
// If streaming is more important than preserving the 'content-type' header
|
|
preferBinary = !capability.overrideMimeType
|
|
} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
|
|
// Use binary if text streaming may corrupt data or the content-type header, or for speed
|
|
preferBinary = true
|
|
} else {
|
|
throw new Error('Invalid value for opts.mode')
|
|
}
|
|
self._mode = decideMode(preferBinary, useFetch)
|
|
self._fetchTimer = null
|
|
|
|
self.on('finish', function () {
|
|
self._onFinish()
|
|
})
|
|
}
|
|
|
|
inherits(ClientRequest, stream.Writable)
|
|
|
|
ClientRequest.prototype.setHeader = function (name, value) {
|
|
var self = this
|
|
var lowerName = name.toLowerCase()
|
|
// This check is not necessary, but it prevents warnings from browsers about setting unsafe
|
|
// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
|
|
// http-browserify did it, so I will too.
|
|
if (unsafeHeaders.indexOf(lowerName) !== -1)
|
|
return
|
|
|
|
self._headers[lowerName] = {
|
|
name: name,
|
|
value: value
|
|
}
|
|
}
|
|
|
|
ClientRequest.prototype.getHeader = function (name) {
|
|
var header = this._headers[name.toLowerCase()]
|
|
if (header)
|
|
return header.value
|
|
return null
|
|
}
|
|
|
|
ClientRequest.prototype.removeHeader = function (name) {
|
|
var self = this
|
|
delete self._headers[name.toLowerCase()]
|
|
}
|
|
|
|
ClientRequest.prototype._onFinish = function () {
|
|
var self = this
|
|
|
|
if (self._destroyed)
|
|
return
|
|
var opts = self._opts
|
|
|
|
var headersObj = self._headers
|
|
var body = null
|
|
if (opts.method !== 'GET' && opts.method !== 'HEAD') {
|
|
body = new Blob(self._body, {
|
|
type: (headersObj['content-type'] || {}).value || ''
|
|
});
|
|
}
|
|
|
|
// create flattened list of headers
|
|
var headersList = []
|
|
Object.keys(headersObj).forEach(function (keyName) {
|
|
var name = headersObj[keyName].name
|
|
var value = headersObj[keyName].value
|
|
if (Array.isArray(value)) {
|
|
value.forEach(function (v) {
|
|
headersList.push([name, v])
|
|
})
|
|
} else {
|
|
headersList.push([name, value])
|
|
}
|
|
})
|
|
|
|
if (self._mode === 'fetch') {
|
|
var signal = null
|
|
if (capability.abortController) {
|
|
var controller = new AbortController()
|
|
signal = controller.signal
|
|
self._fetchAbortController = controller
|
|
|
|
if ('requestTimeout' in opts && opts.requestTimeout !== 0) {
|
|
self._fetchTimer = global.setTimeout(function () {
|
|
self.emit('requestTimeout')
|
|
if (self._fetchAbortController)
|
|
self._fetchAbortController.abort()
|
|
}, opts.requestTimeout)
|
|
}
|
|
}
|
|
|
|
global.fetch(self._opts.url, {
|
|
method: self._opts.method,
|
|
headers: headersList,
|
|
body: body || undefined,
|
|
mode: 'cors',
|
|
credentials: opts.withCredentials ? 'include' : 'same-origin',
|
|
signal: signal
|
|
}).then(function (response) {
|
|
self._fetchResponse = response
|
|
self._connect()
|
|
}, function (reason) {
|
|
global.clearTimeout(self._fetchTimer)
|
|
if (!self._destroyed)
|
|
self.emit('error', reason)
|
|
})
|
|
} else {
|
|
var xhr = self._xhr = new global.XMLHttpRequest()
|
|
try {
|
|
xhr.open(self._opts.method, self._opts.url, true)
|
|
} catch (err) {
|
|
process.nextTick(function () {
|
|
self.emit('error', err)
|
|
})
|
|
return
|
|
}
|
|
|
|
// Can't set responseType on really old browsers
|
|
if ('responseType' in xhr)
|
|
xhr.responseType = self._mode
|
|
|
|
if ('withCredentials' in xhr)
|
|
xhr.withCredentials = !!opts.withCredentials
|
|
|
|
if (self._mode === 'text' && 'overrideMimeType' in xhr)
|
|
xhr.overrideMimeType('text/plain; charset=x-user-defined')
|
|
|
|
if ('requestTimeout' in opts) {
|
|
xhr.timeout = opts.requestTimeout
|
|
xhr.ontimeout = function () {
|
|
self.emit('requestTimeout')
|
|
}
|
|
}
|
|
|
|
headersList.forEach(function (header) {
|
|
xhr.setRequestHeader(header[0], header[1])
|
|
})
|
|
|
|
self._response = null
|
|
xhr.onreadystatechange = function () {
|
|
switch (xhr.readyState) {
|
|
case rStates.LOADING:
|
|
case rStates.DONE:
|
|
self._onXHRProgress()
|
|
break
|
|
}
|
|
}
|
|
// Necessary for streaming in Firefox, since xhr.response is ONLY defined
|
|
// in onprogress, not in onreadystatechange with xhr.readyState = 3
|
|
if (self._mode === 'moz-chunked-arraybuffer') {
|
|
xhr.onprogress = function () {
|
|
self._onXHRProgress()
|
|
}
|
|
}
|
|
|
|
xhr.onerror = function () {
|
|
if (self._destroyed)
|
|
return
|
|
self.emit('error', new Error('XHR error'))
|
|
}
|
|
|
|
try {
|
|
xhr.send(body)
|
|
} catch (err) {
|
|
process.nextTick(function () {
|
|
self.emit('error', err)
|
|
})
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if xhr.status is readable and non-zero, indicating no error.
|
|
* Even though the spec says it should be available in readyState 3,
|
|
* accessing it throws an exception in IE8
|
|
*/
|
|
function statusValid (xhr) {
|
|
try {
|
|
var status = xhr.status
|
|
return (status !== null && status !== 0)
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
ClientRequest.prototype._onXHRProgress = function () {
|
|
var self = this
|
|
|
|
if (!statusValid(self._xhr) || self._destroyed)
|
|
return
|
|
|
|
if (!self._response)
|
|
self._connect()
|
|
|
|
self._response._onXHRProgress()
|
|
}
|
|
|
|
ClientRequest.prototype._connect = function () {
|
|
var self = this
|
|
|
|
if (self._destroyed)
|
|
return
|
|
|
|
self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)
|
|
self._response.on('error', function(err) {
|
|
self.emit('error', err)
|
|
})
|
|
|
|
self.emit('response', self._response)
|
|
}
|
|
|
|
ClientRequest.prototype._write = function (chunk, encoding, cb) {
|
|
var self = this
|
|
|
|
self._body.push(chunk)
|
|
cb()
|
|
}
|
|
|
|
ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
|
|
var self = this
|
|
self._destroyed = true
|
|
global.clearTimeout(self._fetchTimer)
|
|
if (self._response)
|
|
self._response._destroyed = true
|
|
if (self._xhr)
|
|
self._xhr.abort()
|
|
else if (self._fetchAbortController)
|
|
self._fetchAbortController.abort()
|
|
}
|
|
|
|
ClientRequest.prototype.end = function (data, encoding, cb) {
|
|
var self = this
|
|
if (typeof data === 'function') {
|
|
cb = data
|
|
data = undefined
|
|
}
|
|
|
|
stream.Writable.prototype.end.call(self, data, encoding, cb)
|
|
}
|
|
|
|
ClientRequest.prototype.flushHeaders = function () {}
|
|
ClientRequest.prototype.setTimeout = function () {}
|
|
ClientRequest.prototype.setNoDelay = function () {}
|
|
ClientRequest.prototype.setSocketKeepAlive = function () {}
|
|
|
|
// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
|
|
var unsafeHeaders = [
|
|
'accept-charset',
|
|
'accept-encoding',
|
|
'access-control-request-headers',
|
|
'access-control-request-method',
|
|
'connection',
|
|
'content-length',
|
|
'cookie',
|
|
'cookie2',
|
|
'date',
|
|
'dnt',
|
|
'expect',
|
|
'host',
|
|
'keep-alive',
|
|
'origin',
|
|
'referer',
|
|
'te',
|
|
'trailer',
|
|
'transfer-encoding',
|
|
'upgrade',
|
|
'via'
|
|
]
|
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
|
|
},{"./capability":42,"./response":44,"_process":35,"buffer":28,"inherits":33,"readable-stream":59}],44:[function(require,module,exports){
|
|
(function (process,global,Buffer){
|
|
var capability = require('./capability')
|
|
var inherits = require('inherits')
|
|
var stream = require('readable-stream')
|
|
|
|
var rStates = exports.readyStates = {
|
|
UNSENT: 0,
|
|
OPENED: 1,
|
|
HEADERS_RECEIVED: 2,
|
|
LOADING: 3,
|
|
DONE: 4
|
|
}
|
|
|
|
var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {
|
|
var self = this
|
|
stream.Readable.call(self)
|
|
|
|
self._mode = mode
|
|
self.headers = {}
|
|
self.rawHeaders = []
|
|
self.trailers = {}
|
|
self.rawTrailers = []
|
|
|
|
// Fake the 'close' event, but only once 'end' fires
|
|
self.on('end', function () {
|
|
// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
|
|
process.nextTick(function () {
|
|
self.emit('close')
|
|
})
|
|
})
|
|
|
|
if (mode === 'fetch') {
|
|
self._fetchResponse = response
|
|
|
|
self.url = response.url
|
|
self.statusCode = response.status
|
|
self.statusMessage = response.statusText
|
|
|
|
response.headers.forEach(function (header, key){
|
|
self.headers[key.toLowerCase()] = header
|
|
self.rawHeaders.push(key, header)
|
|
})
|
|
|
|
if (capability.writableStream) {
|
|
var writable = new WritableStream({
|
|
write: function (chunk) {
|
|
return new Promise(function (resolve, reject) {
|
|
if (self._destroyed) {
|
|
reject()
|
|
} else if(self.push(Buffer.from(chunk))) {
|
|
resolve()
|
|
} else {
|
|
self._resumeFetch = resolve
|
|
}
|
|
})
|
|
},
|
|
close: function () {
|
|
global.clearTimeout(fetchTimer)
|
|
if (!self._destroyed)
|
|
self.push(null)
|
|
},
|
|
abort: function (err) {
|
|
if (!self._destroyed)
|
|
self.emit('error', err)
|
|
}
|
|
})
|
|
|
|
try {
|
|
response.body.pipeTo(writable).catch(function (err) {
|
|
global.clearTimeout(fetchTimer)
|
|
if (!self._destroyed)
|
|
self.emit('error', err)
|
|
})
|
|
return
|
|
} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this
|
|
}
|
|
// fallback for when writableStream or pipeTo aren't available
|
|
var reader = response.body.getReader()
|
|
function read () {
|
|
reader.read().then(function (result) {
|
|
if (self._destroyed)
|
|
return
|
|
if (result.done) {
|
|
global.clearTimeout(fetchTimer)
|
|
self.push(null)
|
|
return
|
|
}
|
|
self.push(Buffer.from(result.value))
|
|
read()
|
|
}).catch(function (err) {
|
|
global.clearTimeout(fetchTimer)
|
|
if (!self._destroyed)
|
|
self.emit('error', err)
|
|
})
|
|
}
|
|
read()
|
|
} else {
|
|
self._xhr = xhr
|
|
self._pos = 0
|
|
|
|
self.url = xhr.responseURL
|
|
self.statusCode = xhr.status
|
|
self.statusMessage = xhr.statusText
|
|
var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
|
|
headers.forEach(function (header) {
|
|
var matches = header.match(/^([^:]+):\s*(.*)/)
|
|
if (matches) {
|
|
var key = matches[1].toLowerCase()
|
|
if (key === 'set-cookie') {
|
|
if (self.headers[key] === undefined) {
|
|
self.headers[key] = []
|
|
}
|
|
self.headers[key].push(matches[2])
|
|
} else if (self.headers[key] !== undefined) {
|
|
self.headers[key] += ', ' + matches[2]
|
|
} else {
|
|
self.headers[key] = matches[2]
|
|
}
|
|
self.rawHeaders.push(matches[1], matches[2])
|
|
}
|
|
})
|
|
|
|
self._charset = 'x-user-defined'
|
|
if (!capability.overrideMimeType) {
|
|
var mimeType = self.rawHeaders['mime-type']
|
|
if (mimeType) {
|
|
var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
|
|
if (charsetMatch) {
|
|
self._charset = charsetMatch[1].toLowerCase()
|
|
}
|
|
}
|
|
if (!self._charset)
|
|
self._charset = 'utf-8' // best guess
|
|
}
|
|
}
|
|
}
|
|
|
|
inherits(IncomingMessage, stream.Readable)
|
|
|
|
IncomingMessage.prototype._read = function () {
|
|
var self = this
|
|
|
|
var resolve = self._resumeFetch
|
|
if (resolve) {
|
|
self._resumeFetch = null
|
|
resolve()
|
|
}
|
|
}
|
|
|
|
IncomingMessage.prototype._onXHRProgress = function () {
|
|
var self = this
|
|
|
|
var xhr = self._xhr
|
|
|
|
var response = null
|
|
switch (self._mode) {
|
|
case 'text':
|
|
response = xhr.responseText
|
|
if (response.length > self._pos) {
|
|
var newData = response.substr(self._pos)
|
|
if (self._charset === 'x-user-defined') {
|
|
var buffer = Buffer.alloc(newData.length)
|
|
for (var i = 0; i < newData.length; i++)
|
|
buffer[i] = newData.charCodeAt(i) & 0xff
|
|
|
|
self.push(buffer)
|
|
} else {
|
|
self.push(newData, self._charset)
|
|
}
|
|
self._pos = response.length
|
|
}
|
|
break
|
|
case 'arraybuffer':
|
|
if (xhr.readyState !== rStates.DONE || !xhr.response)
|
|
break
|
|
response = xhr.response
|
|
self.push(Buffer.from(new Uint8Array(response)))
|
|
break
|
|
case 'moz-chunked-arraybuffer': // take whole
|
|
response = xhr.response
|
|
if (xhr.readyState !== rStates.LOADING || !response)
|
|
break
|
|
self.push(Buffer.from(new Uint8Array(response)))
|
|
break
|
|
case 'ms-stream':
|
|
response = xhr.response
|
|
if (xhr.readyState !== rStates.LOADING)
|
|
break
|
|
var reader = new global.MSStreamReader()
|
|
reader.onprogress = function () {
|
|
if (reader.result.byteLength > self._pos) {
|
|
self.push(Buffer.from(new Uint8Array(reader.result.slice(self._pos))))
|
|
self._pos = reader.result.byteLength
|
|
}
|
|
}
|
|
reader.onload = function () {
|
|
self.push(null)
|
|
}
|
|
// reader.onerror = ??? // TODO: this
|
|
reader.readAsArrayBuffer(response)
|
|
break
|
|
}
|
|
|
|
// The ms-stream case handles end separately in reader.onload()
|
|
if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
|
|
self.push(null)
|
|
}
|
|
}
|
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
|
|
},{"./capability":42,"_process":35,"buffer":28,"inherits":33,"readable-stream":59}],45:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
|
|
|
|
var codes = {};
|
|
|
|
function createErrorType(code, message, Base) {
|
|
if (!Base) {
|
|
Base = Error;
|
|
}
|
|
|
|
function getMessage(arg1, arg2, arg3) {
|
|
if (typeof message === 'string') {
|
|
return message;
|
|
} else {
|
|
return message(arg1, arg2, arg3);
|
|
}
|
|
}
|
|
|
|
var NodeError =
|
|
/*#__PURE__*/
|
|
function (_Base) {
|
|
_inheritsLoose(NodeError, _Base);
|
|
|
|
function NodeError(arg1, arg2, arg3) {
|
|
return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
|
|
}
|
|
|
|
return NodeError;
|
|
}(Base);
|
|
|
|
NodeError.prototype.name = Base.name;
|
|
NodeError.prototype.code = code;
|
|
codes[code] = NodeError;
|
|
} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
|
|
|
|
|
|
function oneOf(expected, thing) {
|
|
if (Array.isArray(expected)) {
|
|
var len = expected.length;
|
|
expected = expected.map(function (i) {
|
|
return String(i);
|
|
});
|
|
|
|
if (len > 2) {
|
|
return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
|
|
} else if (len === 2) {
|
|
return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(expected[0]);
|
|
}
|
|
} else {
|
|
return "of ".concat(thing, " ").concat(String(expected));
|
|
}
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
|
|
|
|
|
|
function startsWith(str, search, pos) {
|
|
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
|
|
|
|
|
|
function endsWith(str, search, this_len) {
|
|
if (this_len === undefined || this_len > str.length) {
|
|
this_len = str.length;
|
|
}
|
|
|
|
return str.substring(this_len - search.length, this_len) === search;
|
|
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
|
|
|
|
|
|
function includes(str, search, start) {
|
|
if (typeof start !== 'number') {
|
|
start = 0;
|
|
}
|
|
|
|
if (start + search.length > str.length) {
|
|
return false;
|
|
} else {
|
|
return str.indexOf(search, start) !== -1;
|
|
}
|
|
}
|
|
|
|
createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
|
|
return 'The value "' + value + '" is invalid for option "' + name + '"';
|
|
}, TypeError);
|
|
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
|
|
// determiner: 'must be' or 'must not be'
|
|
var determiner;
|
|
|
|
if (typeof expected === 'string' && startsWith(expected, 'not ')) {
|
|
determiner = 'must not be';
|
|
expected = expected.replace(/^not /, '');
|
|
} else {
|
|
determiner = 'must be';
|
|
}
|
|
|
|
var msg;
|
|
|
|
if (endsWith(name, ' argument')) {
|
|
// For cases like 'first argument'
|
|
msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
|
|
} else {
|
|
var type = includes(name, '.') ? 'property' : 'argument';
|
|
msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
|
|
}
|
|
|
|
msg += ". Received type ".concat(typeof actual);
|
|
return msg;
|
|
}, TypeError);
|
|
createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
|
|
createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
|
|
return 'The ' + name + ' method is not implemented';
|
|
});
|
|
createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
|
|
createErrorType('ERR_STREAM_DESTROYED', function (name) {
|
|
return 'Cannot call ' + name + ' after a stream was destroyed';
|
|
});
|
|
createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
|
|
createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
|
|
createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
|
|
createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
|
|
createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
|
|
return 'Unknown encoding: ' + arg;
|
|
}, TypeError);
|
|
createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
|
|
module.exports.codes = codes;
|
|
|
|
},{}],46:[function(require,module,exports){
|
|
(function (process){
|
|
// 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.
|
|
// a duplex stream is just a stream that is both readable and writable.
|
|
// Since JS doesn't have multiple prototypal inheritance, this class
|
|
// prototypally inherits from Readable, and then parasitically from
|
|
// Writable.
|
|
'use strict';
|
|
/*<replacement>*/
|
|
|
|
var objectKeys = Object.keys || function (obj) {
|
|
var keys = [];
|
|
|
|
for (var key in obj) {
|
|
keys.push(key);
|
|
}
|
|
|
|
return keys;
|
|
};
|
|
/*</replacement>*/
|
|
|
|
|
|
module.exports = Duplex;
|
|
|
|
var Readable = require('./_stream_readable');
|
|
|
|
var Writable = require('./_stream_writable');
|
|
|
|
require('inherits')(Duplex, Readable);
|
|
|
|
{
|
|
// Allow the keys array to be GC'ed.
|
|
var keys = objectKeys(Writable.prototype);
|
|
|
|
for (var v = 0; v < keys.length; v++) {
|
|
var method = keys[v];
|
|
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
|
|
}
|
|
}
|
|
|
|
function Duplex(options) {
|
|
if (!(this instanceof Duplex)) return new Duplex(options);
|
|
Readable.call(this, options);
|
|
Writable.call(this, options);
|
|
this.allowHalfOpen = true;
|
|
|
|
if (options) {
|
|
if (options.readable === false) this.readable = false;
|
|
if (options.writable === false) this.writable = false;
|
|
|
|
if (options.allowHalfOpen === false) {
|
|
this.allowHalfOpen = false;
|
|
this.once('end', onend);
|
|
}
|
|
}
|
|
}
|
|
|
|
Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
});
|
|
Object.defineProperty(Duplex.prototype, 'writableBuffer', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState && this._writableState.getBuffer();
|
|
}
|
|
});
|
|
Object.defineProperty(Duplex.prototype, 'writableLength', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState.length;
|
|
}
|
|
}); // the no-half-open enforcer
|
|
|
|
function onend() {
|
|
// If the writable side ended, then we're ok.
|
|
if (this._writableState.ended) return; // no more data can be written.
|
|
// But allow more writes to happen in this tick.
|
|
|
|
process.nextTick(onEndNT, this);
|
|
}
|
|
|
|
function onEndNT(self) {
|
|
self.end();
|
|
}
|
|
|
|
Object.defineProperty(Duplex.prototype, 'destroyed', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
if (this._readableState === undefined || this._writableState === undefined) {
|
|
return false;
|
|
}
|
|
|
|
return this._readableState.destroyed && this._writableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
// we ignore the value if the stream
|
|
// has not been initialized yet
|
|
if (this._readableState === undefined || this._writableState === undefined) {
|
|
return;
|
|
} // backward compatibility, the user is explicitly
|
|
// managing destroyed
|
|
|
|
|
|
this._readableState.destroyed = value;
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
}).call(this,require('_process'))
|
|
},{"./_stream_readable":48,"./_stream_writable":50,"_process":35,"inherits":33}],47:[function(require,module,exports){
|
|
// 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.
|
|
// a passthrough stream.
|
|
// basically just the most minimal sort of Transform stream.
|
|
// Every written chunk gets output as-is.
|
|
'use strict';
|
|
|
|
module.exports = PassThrough;
|
|
|
|
var Transform = require('./_stream_transform');
|
|
|
|
require('inherits')(PassThrough, Transform);
|
|
|
|
function PassThrough(options) {
|
|
if (!(this instanceof PassThrough)) return new PassThrough(options);
|
|
Transform.call(this, options);
|
|
}
|
|
|
|
PassThrough.prototype._transform = function (chunk, encoding, cb) {
|
|
cb(null, chunk);
|
|
};
|
|
},{"./_stream_transform":49,"inherits":33}],48:[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.
|
|
'use strict';
|
|
|
|
module.exports = Readable;
|
|
/*<replacement>*/
|
|
|
|
var Duplex;
|
|
/*</replacement>*/
|
|
|
|
Readable.ReadableState = ReadableState;
|
|
/*<replacement>*/
|
|
|
|
var EE = require('events').EventEmitter;
|
|
|
|
var EElistenerCount = function EElistenerCount(emitter, type) {
|
|
return emitter.listeners(type).length;
|
|
};
|
|
/*</replacement>*/
|
|
|
|
/*<replacement>*/
|
|
|
|
|
|
var Stream = require('./internal/streams/stream');
|
|
/*</replacement>*/
|
|
|
|
|
|
var Buffer = require('buffer').Buffer;
|
|
|
|
var OurUint8Array = global.Uint8Array || function () {};
|
|
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer.from(chunk);
|
|
}
|
|
|
|
function _isUint8Array(obj) {
|
|
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
/*<replacement>*/
|
|
|
|
|
|
var debugUtil = require('util');
|
|
|
|
var debug;
|
|
|
|
if (debugUtil && debugUtil.debuglog) {
|
|
debug = debugUtil.debuglog('stream');
|
|
} else {
|
|
debug = function debug() {};
|
|
}
|
|
/*</replacement>*/
|
|
|
|
|
|
var BufferList = require('./internal/streams/buffer_list');
|
|
|
|
var destroyImpl = require('./internal/streams/destroy');
|
|
|
|
var _require = require('./internal/streams/state'),
|
|
getHighWaterMark = _require.getHighWaterMark;
|
|
|
|
var _require$codes = require('../errors').codes,
|
|
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
|
ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
|
|
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
|
ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
|
|
|
|
|
|
var StringDecoder;
|
|
var createReadableStreamAsyncIterator;
|
|
var from;
|
|
|
|
require('inherits')(Readable, Stream);
|
|
|
|
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
|
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
|
|
|
|
function prependListener(emitter, event, fn) {
|
|
// Sadly this is not cacheable as some libraries bundle their own
|
|
// event emitter implementation with them.
|
|
if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
|
|
// userland ones. NEVER DO THIS. This is here only because this code needs
|
|
// to continue to work with older versions of Node.js that do not include
|
|
// the prependListener() method. The goal is to eventually remove this hack.
|
|
|
|
if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
|
|
}
|
|
|
|
function ReadableState(options, stream, isDuplex) {
|
|
Duplex = Duplex || require('./_stream_duplex');
|
|
options = options || {}; // Duplex streams are both readable and writable, but share
|
|
// the same options object.
|
|
// However, some cases require setting options to different
|
|
// values for the readable and the writable sides of the duplex stream.
|
|
// These options can be provided separately as readableXXX and writableXXX.
|
|
|
|
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
|
|
// make all the buffer merging and length checks go away
|
|
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
|
|
// Note: 0 is a valid value, means "don't call _read preemptively ever"
|
|
|
|
this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
|
|
// linked list can remove elements from the beginning faster than
|
|
// array.shift()
|
|
|
|
this.buffer = new BufferList();
|
|
this.length = 0;
|
|
this.pipes = null;
|
|
this.pipesCount = 0;
|
|
this.flowing = null;
|
|
this.ended = false;
|
|
this.endEmitted = false;
|
|
this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
|
|
// immediately, or on a later tick. We set this to true at first, because
|
|
// any actions that shouldn't happen until "later" should generally also
|
|
// not happen before the first read call.
|
|
|
|
this.sync = true; // whenever we return null, then we set a flag to say
|
|
// that we're awaiting a 'readable' event emission.
|
|
|
|
this.needReadable = false;
|
|
this.emittedReadable = false;
|
|
this.readableListening = false;
|
|
this.resumeScheduled = false;
|
|
this.paused = true; // Should close be emitted on destroy. Defaults to true.
|
|
|
|
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
|
|
|
|
this.autoDestroy = !!options.autoDestroy; // has it been destroyed
|
|
|
|
this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string
|
|
// encoding is 'binary' so we have to make this configurable.
|
|
// Everything else in the universe uses 'utf8', though.
|
|
|
|
this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
|
|
|
|
this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
|
|
|
|
this.readingMore = false;
|
|
this.decoder = null;
|
|
this.encoding = null;
|
|
|
|
if (options.encoding) {
|
|
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
|
|
this.decoder = new StringDecoder(options.encoding);
|
|
this.encoding = options.encoding;
|
|
}
|
|
}
|
|
|
|
function Readable(options) {
|
|
Duplex = Duplex || require('./_stream_duplex');
|
|
if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
|
|
// the ReadableState constructor, at least with V8 6.5
|
|
|
|
var isDuplex = this instanceof Duplex;
|
|
this._readableState = new ReadableState(options, this, isDuplex); // legacy
|
|
|
|
this.readable = true;
|
|
|
|
if (options) {
|
|
if (typeof options.read === 'function') this._read = options.read;
|
|
if (typeof options.destroy === 'function') this._destroy = options.destroy;
|
|
}
|
|
|
|
Stream.call(this);
|
|
}
|
|
|
|
Object.defineProperty(Readable.prototype, 'destroyed', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
if (this._readableState === undefined) {
|
|
return false;
|
|
}
|
|
|
|
return this._readableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
// we ignore the value if the stream
|
|
// has not been initialized yet
|
|
if (!this._readableState) {
|
|
return;
|
|
} // backward compatibility, the user is explicitly
|
|
// managing destroyed
|
|
|
|
|
|
this._readableState.destroyed = value;
|
|
}
|
|
});
|
|
Readable.prototype.destroy = destroyImpl.destroy;
|
|
Readable.prototype._undestroy = destroyImpl.undestroy;
|
|
|
|
Readable.prototype._destroy = function (err, cb) {
|
|
cb(err);
|
|
}; // Manually shove something into the read() buffer.
|
|
// This returns true if the highWaterMark has not been hit yet,
|
|
// similar to how Writable.write() returns true if you should
|
|
// write() some more.
|
|
|
|
|
|
Readable.prototype.push = function (chunk, encoding) {
|
|
var state = this._readableState;
|
|
var skipChunkCheck;
|
|
|
|
if (!state.objectMode) {
|
|
if (typeof chunk === 'string') {
|
|
encoding = encoding || state.defaultEncoding;
|
|
|
|
if (encoding !== state.encoding) {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
encoding = '';
|
|
}
|
|
|
|
skipChunkCheck = true;
|
|
}
|
|
} else {
|
|
skipChunkCheck = true;
|
|
}
|
|
|
|
return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
|
|
}; // Unshift should *always* be something directly out of read()
|
|
|
|
|
|
Readable.prototype.unshift = function (chunk) {
|
|
return readableAddChunk(this, chunk, null, true, false);
|
|
};
|
|
|
|
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
|
|
debug('readableAddChunk', chunk);
|
|
var state = stream._readableState;
|
|
|
|
if (chunk === null) {
|
|
state.reading = false;
|
|
onEofChunk(stream, state);
|
|
} else {
|
|
var er;
|
|
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
|
|
|
|
if (er) {
|
|
errorOrDestroy(stream, er);
|
|
} else if (state.objectMode || chunk && chunk.length > 0) {
|
|
if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
|
|
if (addToFront) {
|
|
if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
|
|
} else if (state.ended) {
|
|
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
|
|
} else if (state.destroyed) {
|
|
return false;
|
|
} else {
|
|
state.reading = false;
|
|
|
|
if (state.decoder && !encoding) {
|
|
chunk = state.decoder.write(chunk);
|
|
if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
|
|
} else {
|
|
addChunk(stream, state, chunk, false);
|
|
}
|
|
}
|
|
} else if (!addToFront) {
|
|
state.reading = false;
|
|
maybeReadMore(stream, state);
|
|
}
|
|
} // We can push more data if we are below the highWaterMark.
|
|
// Also, if we have no data yet, we can stand some more bytes.
|
|
// This is to work around cases where hwm=0, such as the repl.
|
|
|
|
|
|
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
|
|
}
|
|
|
|
function addChunk(stream, state, chunk, addToFront) {
|
|
if (state.flowing && state.length === 0 && !state.sync) {
|
|
state.awaitDrain = 0;
|
|
stream.emit('data', chunk);
|
|
} else {
|
|
// update the buffer info.
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
|
|
if (state.needReadable) emitReadable(stream);
|
|
}
|
|
|
|
maybeReadMore(stream, state);
|
|
}
|
|
|
|
function chunkInvalid(state, chunk) {
|
|
var er;
|
|
|
|
if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
|
|
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
|
|
}
|
|
|
|
return er;
|
|
}
|
|
|
|
Readable.prototype.isPaused = function () {
|
|
return this._readableState.flowing === false;
|
|
}; // backwards compatibility.
|
|
|
|
|
|
Readable.prototype.setEncoding = function (enc) {
|
|
if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
|
|
var decoder = new StringDecoder(enc);
|
|
this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
|
|
|
|
this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
|
|
|
|
var p = this._readableState.buffer.head;
|
|
var content = '';
|
|
|
|
while (p !== null) {
|
|
content += decoder.write(p.data);
|
|
p = p.next;
|
|
}
|
|
|
|
this._readableState.buffer.clear();
|
|
|
|
if (content !== '') this._readableState.buffer.push(content);
|
|
this._readableState.length = content.length;
|
|
return this;
|
|
}; // Don't raise the hwm > 1GB
|
|
|
|
|
|
var MAX_HWM = 0x40000000;
|
|
|
|
function computeNewHighWaterMark(n) {
|
|
if (n >= MAX_HWM) {
|
|
// TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
|
|
n = MAX_HWM;
|
|
} else {
|
|
// Get the next highest power of 2 to prevent increasing hwm excessively in
|
|
// tiny amounts
|
|
n--;
|
|
n |= n >>> 1;
|
|
n |= n >>> 2;
|
|
n |= n >>> 4;
|
|
n |= n >>> 8;
|
|
n |= n >>> 16;
|
|
n++;
|
|
}
|
|
|
|
return n;
|
|
} // This function is designed to be inlinable, so please take care when making
|
|
// changes to the function body.
|
|
|
|
|
|
function howMuchToRead(n, state) {
|
|
if (n <= 0 || state.length === 0 && state.ended) return 0;
|
|
if (state.objectMode) return 1;
|
|
|
|
if (n !== n) {
|
|
// Only flow one buffer at a time
|
|
if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
|
|
} // If we're asking for more than the current hwm, then raise the hwm.
|
|
|
|
|
|
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
|
|
if (n <= state.length) return n; // Don't have enough
|
|
|
|
if (!state.ended) {
|
|
state.needReadable = true;
|
|
return 0;
|
|
}
|
|
|
|
return state.length;
|
|
} // you can override either this method, or the async _read(n) below.
|
|
|
|
|
|
Readable.prototype.read = function (n) {
|
|
debug('read', n);
|
|
n = parseInt(n, 10);
|
|
var state = this._readableState;
|
|
var nOrig = n;
|
|
if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
|
|
// already have a bunch of data in the buffer, then just trigger
|
|
// the 'readable' event and move on.
|
|
|
|
if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
|
|
debug('read: emitReadable', state.length, state.ended);
|
|
if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
|
|
return null;
|
|
}
|
|
|
|
n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
|
|
|
|
if (n === 0 && state.ended) {
|
|
if (state.length === 0) endReadable(this);
|
|
return null;
|
|
} // All the actual chunk generation logic needs to be
|
|
// *below* the call to _read. The reason is that in certain
|
|
// synthetic stream cases, such as passthrough streams, _read
|
|
// may be a completely synchronous operation which may change
|
|
// the state of the read buffer, providing enough data when
|
|
// before there was *not* enough.
|
|
//
|
|
// So, the steps are:
|
|
// 1. Figure out what the state of things will be after we do
|
|
// a read from the buffer.
|
|
//
|
|
// 2. If that resulting state will trigger a _read, then call _read.
|
|
// Note that this may be asynchronous, or synchronous. Yes, it is
|
|
// deeply ugly to write APIs this way, but that still doesn't mean
|
|
// that the Readable class should behave improperly, as streams are
|
|
// designed to be sync/async agnostic.
|
|
// Take note if the _read call is sync or async (ie, if the read call
|
|
// has returned yet), so that we know whether or not it's safe to emit
|
|
// 'readable' etc.
|
|
//
|
|
// 3. Actually pull the requested chunks out of the buffer and return.
|
|
// if we need a readable event, then we need to do some reading.
|
|
|
|
|
|
var doRead = state.needReadable;
|
|
debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
|
|
|
|
if (state.length === 0 || state.length - n < state.highWaterMark) {
|
|
doRead = true;
|
|
debug('length less than watermark', doRead);
|
|
} // however, if we've ended, then there's no point, and if we're already
|
|
// reading, then it's unnecessary.
|
|
|
|
|
|
if (state.ended || state.reading) {
|
|
doRead = false;
|
|
debug('reading or ended', doRead);
|
|
} else if (doRead) {
|
|
debug('do read');
|
|
state.reading = true;
|
|
state.sync = true; // if the length is currently zero, then we *need* a readable event.
|
|
|
|
if (state.length === 0) state.needReadable = true; // call internal read method
|
|
|
|
this._read(state.highWaterMark);
|
|
|
|
state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
|
|
// and we need to re-evaluate how much data we can return to the user.
|
|
|
|
if (!state.reading) n = howMuchToRead(nOrig, state);
|
|
}
|
|
|
|
var ret;
|
|
if (n > 0) ret = fromList(n, state);else ret = null;
|
|
|
|
if (ret === null) {
|
|
state.needReadable = state.length <= state.highWaterMark;
|
|
n = 0;
|
|
} else {
|
|
state.length -= n;
|
|
state.awaitDrain = 0;
|
|
}
|
|
|
|
if (state.length === 0) {
|
|
// If we have nothing in the buffer, then we want to know
|
|
// as soon as we *do* get something into the buffer.
|
|
if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
|
|
|
|
if (nOrig !== n && state.ended) endReadable(this);
|
|
}
|
|
|
|
if (ret !== null) this.emit('data', ret);
|
|
return ret;
|
|
};
|
|
|
|
function onEofChunk(stream, state) {
|
|
debug('onEofChunk');
|
|
if (state.ended) return;
|
|
|
|
if (state.decoder) {
|
|
var chunk = state.decoder.end();
|
|
|
|
if (chunk && chunk.length) {
|
|
state.buffer.push(chunk);
|
|
state.length += state.objectMode ? 1 : chunk.length;
|
|
}
|
|
}
|
|
|
|
state.ended = true;
|
|
|
|
if (state.sync) {
|
|
// if we are sync, wait until next tick to emit the data.
|
|
// Otherwise we risk emitting data in the flow()
|
|
// the readable code triggers during a read() call
|
|
emitReadable(stream);
|
|
} else {
|
|
// emit 'readable' now to make sure it gets picked up.
|
|
state.needReadable = false;
|
|
|
|
if (!state.emittedReadable) {
|
|
state.emittedReadable = true;
|
|
emitReadable_(stream);
|
|
}
|
|
}
|
|
} // Don't emit readable right away in sync mode, because this can trigger
|
|
// another read() call => stack overflow. This way, it might trigger
|
|
// a nextTick recursion warning, but that's not so bad.
|
|
|
|
|
|
function emitReadable(stream) {
|
|
var state = stream._readableState;
|
|
debug('emitReadable', state.needReadable, state.emittedReadable);
|
|
state.needReadable = false;
|
|
|
|
if (!state.emittedReadable) {
|
|
debug('emitReadable', state.flowing);
|
|
state.emittedReadable = true;
|
|
process.nextTick(emitReadable_, stream);
|
|
}
|
|
}
|
|
|
|
function emitReadable_(stream) {
|
|
var state = stream._readableState;
|
|
debug('emitReadable_', state.destroyed, state.length, state.ended);
|
|
|
|
if (!state.destroyed && (state.length || state.ended)) {
|
|
stream.emit('readable');
|
|
state.emittedReadable = false;
|
|
} // The stream needs another readable event if
|
|
// 1. It is not flowing, as the flow mechanism will take
|
|
// care of it.
|
|
// 2. It is not ended.
|
|
// 3. It is below the highWaterMark, so we can schedule
|
|
// another readable later.
|
|
|
|
|
|
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
|
|
flow(stream);
|
|
} // at this point, the user has presumably seen the 'readable' event,
|
|
// and called read() to consume some data. that may have triggered
|
|
// in turn another _read(n) call, in which case reading = true if
|
|
// it's in progress.
|
|
// However, if we're not ended, or reading, and the length < hwm,
|
|
// then go ahead and try to read some more preemptively.
|
|
|
|
|
|
function maybeReadMore(stream, state) {
|
|
if (!state.readingMore) {
|
|
state.readingMore = true;
|
|
process.nextTick(maybeReadMore_, stream, state);
|
|
}
|
|
}
|
|
|
|
function maybeReadMore_(stream, state) {
|
|
// Attempt to read more data if we should.
|
|
//
|
|
// The conditions for reading more data are (one of):
|
|
// - Not enough data buffered (state.length < state.highWaterMark). The loop
|
|
// is responsible for filling the buffer with enough data if such data
|
|
// is available. If highWaterMark is 0 and we are not in the flowing mode
|
|
// we should _not_ attempt to buffer any extra data. We'll get more data
|
|
// when the stream consumer calls read() instead.
|
|
// - No data in the buffer, and the stream is in flowing mode. In this mode
|
|
// the loop below is responsible for ensuring read() is called. Failing to
|
|
// call read here would abort the flow and there's no other mechanism for
|
|
// continuing the flow if the stream consumer has just subscribed to the
|
|
// 'data' event.
|
|
//
|
|
// In addition to the above conditions to keep reading data, the following
|
|
// conditions prevent the data from being read:
|
|
// - The stream has ended (state.ended).
|
|
// - There is already a pending 'read' operation (state.reading). This is a
|
|
// case where the the stream has called the implementation defined _read()
|
|
// method, but they are processing the call asynchronously and have _not_
|
|
// called push() with new data. In this case we skip performing more
|
|
// read()s. The execution ends in this method again after the _read() ends
|
|
// up calling push() with more data.
|
|
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
|
|
var len = state.length;
|
|
debug('maybeReadMore read 0');
|
|
stream.read(0);
|
|
if (len === state.length) // didn't get any data, stop spinning.
|
|
break;
|
|
}
|
|
|
|
state.readingMore = false;
|
|
} // abstract method. to be overridden in specific implementation classes.
|
|
// call cb(er, data) where data is <= n in length.
|
|
// for virtual (non-string, non-buffer) streams, "length" is somewhat
|
|
// arbitrary, and perhaps not very meaningful.
|
|
|
|
|
|
Readable.prototype._read = function (n) {
|
|
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
|
|
};
|
|
|
|
Readable.prototype.pipe = function (dest, pipeOpts) {
|
|
var src = this;
|
|
var state = this._readableState;
|
|
|
|
switch (state.pipesCount) {
|
|
case 0:
|
|
state.pipes = dest;
|
|
break;
|
|
|
|
case 1:
|
|
state.pipes = [state.pipes, dest];
|
|
break;
|
|
|
|
default:
|
|
state.pipes.push(dest);
|
|
break;
|
|
}
|
|
|
|
state.pipesCount += 1;
|
|
debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
|
|
var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
|
|
var endFn = doEnd ? onend : unpipe;
|
|
if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
|
|
dest.on('unpipe', onunpipe);
|
|
|
|
function onunpipe(readable, unpipeInfo) {
|
|
debug('onunpipe');
|
|
|
|
if (readable === src) {
|
|
if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
|
|
unpipeInfo.hasUnpiped = true;
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
|
|
function onend() {
|
|
debug('onend');
|
|
dest.end();
|
|
} // when the dest drains, it reduces the awaitDrain counter
|
|
// on the source. This would be more elegant with a .once()
|
|
// handler in flow(), but adding and removing repeatedly is
|
|
// too slow.
|
|
|
|
|
|
var ondrain = pipeOnDrain(src);
|
|
dest.on('drain', ondrain);
|
|
var cleanedUp = false;
|
|
|
|
function cleanup() {
|
|
debug('cleanup'); // cleanup event handlers once the pipe is broken
|
|
|
|
dest.removeListener('close', onclose);
|
|
dest.removeListener('finish', onfinish);
|
|
dest.removeListener('drain', ondrain);
|
|
dest.removeListener('error', onerror);
|
|
dest.removeListener('unpipe', onunpipe);
|
|
src.removeListener('end', onend);
|
|
src.removeListener('end', unpipe);
|
|
src.removeListener('data', ondata);
|
|
cleanedUp = true; // if the reader is waiting for a drain event from this
|
|
// specific writer, then it would cause it to never start
|
|
// flowing again.
|
|
// So, if this is awaiting a drain, then we just call it now.
|
|
// If we don't know, then assume that we are waiting for one.
|
|
|
|
if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
|
|
}
|
|
|
|
src.on('data', ondata);
|
|
|
|
function ondata(chunk) {
|
|
debug('ondata');
|
|
var ret = dest.write(chunk);
|
|
debug('dest.write', ret);
|
|
|
|
if (ret === false) {
|
|
// If the user unpiped during `dest.write()`, it is possible
|
|
// to get stuck in a permanently paused state if that write
|
|
// also returned false.
|
|
// => Check whether `dest` is still a piping destination.
|
|
if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
|
|
debug('false write response, pause', state.awaitDrain);
|
|
state.awaitDrain++;
|
|
}
|
|
|
|
src.pause();
|
|
}
|
|
} // if the dest has an error, then stop piping into it.
|
|
// however, don't suppress the throwing behavior for this.
|
|
|
|
|
|
function onerror(er) {
|
|
debug('onerror', er);
|
|
unpipe();
|
|
dest.removeListener('error', onerror);
|
|
if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
|
|
} // Make sure our error handler is attached before userland ones.
|
|
|
|
|
|
prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
|
|
|
|
function onclose() {
|
|
dest.removeListener('finish', onfinish);
|
|
unpipe();
|
|
}
|
|
|
|
dest.once('close', onclose);
|
|
|
|
function onfinish() {
|
|
debug('onfinish');
|
|
dest.removeListener('close', onclose);
|
|
unpipe();
|
|
}
|
|
|
|
dest.once('finish', onfinish);
|
|
|
|
function unpipe() {
|
|
debug('unpipe');
|
|
src.unpipe(dest);
|
|
} // tell the dest that it's being piped to
|
|
|
|
|
|
dest.emit('pipe', src); // start the flow if it hasn't been started already.
|
|
|
|
if (!state.flowing) {
|
|
debug('pipe resume');
|
|
src.resume();
|
|
}
|
|
|
|
return dest;
|
|
};
|
|
|
|
function pipeOnDrain(src) {
|
|
return function pipeOnDrainFunctionResult() {
|
|
var state = src._readableState;
|
|
debug('pipeOnDrain', state.awaitDrain);
|
|
if (state.awaitDrain) state.awaitDrain--;
|
|
|
|
if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
|
|
state.flowing = true;
|
|
flow(src);
|
|
}
|
|
};
|
|
}
|
|
|
|
Readable.prototype.unpipe = function (dest) {
|
|
var state = this._readableState;
|
|
var unpipeInfo = {
|
|
hasUnpiped: false
|
|
}; // if we're not piping anywhere, then do nothing.
|
|
|
|
if (state.pipesCount === 0) return this; // just one destination. most common case.
|
|
|
|
if (state.pipesCount === 1) {
|
|
// passed in one, but it's not the right one.
|
|
if (dest && dest !== state.pipes) return this;
|
|
if (!dest) dest = state.pipes; // got a match.
|
|
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
if (dest) dest.emit('unpipe', this, unpipeInfo);
|
|
return this;
|
|
} // slow case. multiple pipe destinations.
|
|
|
|
|
|
if (!dest) {
|
|
// remove all.
|
|
var dests = state.pipes;
|
|
var len = state.pipesCount;
|
|
state.pipes = null;
|
|
state.pipesCount = 0;
|
|
state.flowing = false;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
dests[i].emit('unpipe', this, {
|
|
hasUnpiped: false
|
|
});
|
|
}
|
|
|
|
return this;
|
|
} // try to find the right one.
|
|
|
|
|
|
var index = indexOf(state.pipes, dest);
|
|
if (index === -1) return this;
|
|
state.pipes.splice(index, 1);
|
|
state.pipesCount -= 1;
|
|
if (state.pipesCount === 1) state.pipes = state.pipes[0];
|
|
dest.emit('unpipe', this, unpipeInfo);
|
|
return this;
|
|
}; // set up data events if they are asked for
|
|
// Ensure readable listeners eventually get something
|
|
|
|
|
|
Readable.prototype.on = function (ev, fn) {
|
|
var res = Stream.prototype.on.call(this, ev, fn);
|
|
var state = this._readableState;
|
|
|
|
if (ev === 'data') {
|
|
// update readableListening so that resume() may be a no-op
|
|
// a few lines down. This is needed to support once('readable').
|
|
state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
|
|
|
|
if (state.flowing !== false) this.resume();
|
|
} else if (ev === 'readable') {
|
|
if (!state.endEmitted && !state.readableListening) {
|
|
state.readableListening = state.needReadable = true;
|
|
state.flowing = false;
|
|
state.emittedReadable = false;
|
|
debug('on readable', state.length, state.reading);
|
|
|
|
if (state.length) {
|
|
emitReadable(this);
|
|
} else if (!state.reading) {
|
|
process.nextTick(nReadingNextTick, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
Readable.prototype.addListener = Readable.prototype.on;
|
|
|
|
Readable.prototype.removeListener = function (ev, fn) {
|
|
var res = Stream.prototype.removeListener.call(this, ev, fn);
|
|
|
|
if (ev === 'readable') {
|
|
// We need to check if there is someone still listening to
|
|
// readable and reset the state. However this needs to happen
|
|
// after readable has been emitted but before I/O (nextTick) to
|
|
// support once('readable', fn) cycles. This means that calling
|
|
// resume within the same tick will have no
|
|
// effect.
|
|
process.nextTick(updateReadableListening, this);
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
Readable.prototype.removeAllListeners = function (ev) {
|
|
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
|
|
|
|
if (ev === 'readable' || ev === undefined) {
|
|
// We need to check if there is someone still listening to
|
|
// readable and reset the state. However this needs to happen
|
|
// after readable has been emitted but before I/O (nextTick) to
|
|
// support once('readable', fn) cycles. This means that calling
|
|
// resume within the same tick will have no
|
|
// effect.
|
|
process.nextTick(updateReadableListening, this);
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
function updateReadableListening(self) {
|
|
var state = self._readableState;
|
|
state.readableListening = self.listenerCount('readable') > 0;
|
|
|
|
if (state.resumeScheduled && !state.paused) {
|
|
// flowing needs to be set to true now, otherwise
|
|
// the upcoming resume will not flow.
|
|
state.flowing = true; // crude way to check if we should resume
|
|
} else if (self.listenerCount('data') > 0) {
|
|
self.resume();
|
|
}
|
|
}
|
|
|
|
function nReadingNextTick(self) {
|
|
debug('readable nexttick read 0');
|
|
self.read(0);
|
|
} // pause() and resume() are remnants of the legacy readable stream API
|
|
// If the user uses them, then switch into old mode.
|
|
|
|
|
|
Readable.prototype.resume = function () {
|
|
var state = this._readableState;
|
|
|
|
if (!state.flowing) {
|
|
debug('resume'); // we flow only if there is no one listening
|
|
// for readable, but we still have to call
|
|
// resume()
|
|
|
|
state.flowing = !state.readableListening;
|
|
resume(this, state);
|
|
}
|
|
|
|
state.paused = false;
|
|
return this;
|
|
};
|
|
|
|
function resume(stream, state) {
|
|
if (!state.resumeScheduled) {
|
|
state.resumeScheduled = true;
|
|
process.nextTick(resume_, stream, state);
|
|
}
|
|
}
|
|
|
|
function resume_(stream, state) {
|
|
debug('resume', state.reading);
|
|
|
|
if (!state.reading) {
|
|
stream.read(0);
|
|
}
|
|
|
|
state.resumeScheduled = false;
|
|
stream.emit('resume');
|
|
flow(stream);
|
|
if (state.flowing && !state.reading) stream.read(0);
|
|
}
|
|
|
|
Readable.prototype.pause = function () {
|
|
debug('call pause flowing=%j', this._readableState.flowing);
|
|
|
|
if (this._readableState.flowing !== false) {
|
|
debug('pause');
|
|
this._readableState.flowing = false;
|
|
this.emit('pause');
|
|
}
|
|
|
|
this._readableState.paused = true;
|
|
return this;
|
|
};
|
|
|
|
function flow(stream) {
|
|
var state = stream._readableState;
|
|
debug('flow', state.flowing);
|
|
|
|
while (state.flowing && stream.read() !== null) {
|
|
;
|
|
}
|
|
} // wrap an old-style stream as the async data source.
|
|
// This is *not* part of the readable stream interface.
|
|
// It is an ugly unfortunate mess of history.
|
|
|
|
|
|
Readable.prototype.wrap = function (stream) {
|
|
var _this = this;
|
|
|
|
var state = this._readableState;
|
|
var paused = false;
|
|
stream.on('end', function () {
|
|
debug('wrapped end');
|
|
|
|
if (state.decoder && !state.ended) {
|
|
var chunk = state.decoder.end();
|
|
if (chunk && chunk.length) _this.push(chunk);
|
|
}
|
|
|
|
_this.push(null);
|
|
});
|
|
stream.on('data', function (chunk) {
|
|
debug('wrapped data');
|
|
if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
|
|
|
|
if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
|
|
|
|
var ret = _this.push(chunk);
|
|
|
|
if (!ret) {
|
|
paused = true;
|
|
stream.pause();
|
|
}
|
|
}); // proxy all the other methods.
|
|
// important when wrapping filters and duplexes.
|
|
|
|
for (var i in stream) {
|
|
if (this[i] === undefined && typeof stream[i] === 'function') {
|
|
this[i] = function methodWrap(method) {
|
|
return function methodWrapReturnFunction() {
|
|
return stream[method].apply(stream, arguments);
|
|
};
|
|
}(i);
|
|
}
|
|
} // proxy certain important events.
|
|
|
|
|
|
for (var n = 0; n < kProxyEvents.length; n++) {
|
|
stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
|
|
} // when we try to consume some more bytes, simply unpause the
|
|
// underlying stream.
|
|
|
|
|
|
this._read = function (n) {
|
|
debug('wrapped _read', n);
|
|
|
|
if (paused) {
|
|
paused = false;
|
|
stream.resume();
|
|
}
|
|
};
|
|
|
|
return this;
|
|
};
|
|
|
|
if (typeof Symbol === 'function') {
|
|
Readable.prototype[Symbol.asyncIterator] = function () {
|
|
if (createReadableStreamAsyncIterator === undefined) {
|
|
createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');
|
|
}
|
|
|
|
return createReadableStreamAsyncIterator(this);
|
|
};
|
|
}
|
|
|
|
Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._readableState.highWaterMark;
|
|
}
|
|
});
|
|
Object.defineProperty(Readable.prototype, 'readableBuffer', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._readableState && this._readableState.buffer;
|
|
}
|
|
});
|
|
Object.defineProperty(Readable.prototype, 'readableFlowing', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._readableState.flowing;
|
|
},
|
|
set: function set(state) {
|
|
if (this._readableState) {
|
|
this._readableState.flowing = state;
|
|
}
|
|
}
|
|
}); // exposed for testing purposes only.
|
|
|
|
Readable._fromList = fromList;
|
|
Object.defineProperty(Readable.prototype, 'readableLength', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._readableState.length;
|
|
}
|
|
}); // Pluck off n bytes from an array of buffers.
|
|
// Length is the combined lengths of all the buffers in the list.
|
|
// This function is designed to be inlinable, so please take care when making
|
|
// changes to the function body.
|
|
|
|
function fromList(n, state) {
|
|
// nothing buffered
|
|
if (state.length === 0) return null;
|
|
var ret;
|
|
if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
|
|
// read it all, truncate the list
|
|
if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
|
|
state.buffer.clear();
|
|
} else {
|
|
// read part of list
|
|
ret = state.buffer.consume(n, state.decoder);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function endReadable(stream) {
|
|
var state = stream._readableState;
|
|
debug('endReadable', state.endEmitted);
|
|
|
|
if (!state.endEmitted) {
|
|
state.ended = true;
|
|
process.nextTick(endReadableNT, state, stream);
|
|
}
|
|
}
|
|
|
|
function endReadableNT(state, stream) {
|
|
debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
|
|
|
|
if (!state.endEmitted && state.length === 0) {
|
|
state.endEmitted = true;
|
|
stream.readable = false;
|
|
stream.emit('end');
|
|
|
|
if (state.autoDestroy) {
|
|
// In case of duplex streams we need a way to detect
|
|
// if the writable side is ready for autoDestroy as well
|
|
var wState = stream._writableState;
|
|
|
|
if (!wState || wState.autoDestroy && wState.finished) {
|
|
stream.destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeof Symbol === 'function') {
|
|
Readable.from = function (iterable, opts) {
|
|
if (from === undefined) {
|
|
from = require('./internal/streams/from');
|
|
}
|
|
|
|
return from(Readable, iterable, opts);
|
|
};
|
|
}
|
|
|
|
function indexOf(xs, x) {
|
|
for (var i = 0, l = xs.length; i < l; i++) {
|
|
if (xs[i] === x) return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"../errors":45,"./_stream_duplex":46,"./internal/streams/async_iterator":51,"./internal/streams/buffer_list":52,"./internal/streams/destroy":53,"./internal/streams/from":55,"./internal/streams/state":57,"./internal/streams/stream":58,"_process":35,"buffer":28,"events":30,"inherits":33,"string_decoder/":60,"util":26}],49:[function(require,module,exports){
|
|
// 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.
|
|
// a transform stream is a readable/writable stream where you do
|
|
// something with the data. Sometimes it's called a "filter",
|
|
// but that's not a great name for it, since that implies a thing where
|
|
// some bits pass through, and others are simply ignored. (That would
|
|
// be a valid example of a transform, of course.)
|
|
//
|
|
// While the output is causally related to the input, it's not a
|
|
// necessarily symmetric or synchronous transformation. For example,
|
|
// a zlib stream might take multiple plain-text writes(), and then
|
|
// emit a single compressed chunk some time in the future.
|
|
//
|
|
// Here's how this works:
|
|
//
|
|
// The Transform stream has all the aspects of the readable and writable
|
|
// stream classes. When you write(chunk), that calls _write(chunk,cb)
|
|
// internally, and returns false if there's a lot of pending writes
|
|
// buffered up. When you call read(), that calls _read(n) until
|
|
// there's enough pending readable data buffered up.
|
|
//
|
|
// In a transform stream, the written data is placed in a buffer. When
|
|
// _read(n) is called, it transforms the queued up data, calling the
|
|
// buffered _write cb's as it consumes chunks. If consuming a single
|
|
// written chunk would result in multiple output chunks, then the first
|
|
// outputted bit calls the readcb, and subsequent chunks just go into
|
|
// the read buffer, and will cause it to emit 'readable' if necessary.
|
|
//
|
|
// This way, back-pressure is actually determined by the reading side,
|
|
// since _read has to be called to start processing a new chunk. However,
|
|
// a pathological inflate type of transform can cause excessive buffering
|
|
// here. For example, imagine a stream where every byte of input is
|
|
// interpreted as an integer from 0-255, and then results in that many
|
|
// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
|
|
// 1kb of data being output. In this case, you could write a very small
|
|
// amount of input, and end up with a very large amount of output. In
|
|
// such a pathological inflating mechanism, there'd be no way to tell
|
|
// the system to stop doing the transform. A single 4MB write could
|
|
// cause the system to run out of memory.
|
|
//
|
|
// However, even in such a pathological case, only a single written chunk
|
|
// would be consumed, and then the rest would wait (un-transformed) until
|
|
// the results of the previous transformed chunk were consumed.
|
|
'use strict';
|
|
|
|
module.exports = Transform;
|
|
|
|
var _require$codes = require('../errors').codes,
|
|
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
|
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
|
ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
|
|
ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
|
|
|
|
var Duplex = require('./_stream_duplex');
|
|
|
|
require('inherits')(Transform, Duplex);
|
|
|
|
function afterTransform(er, data) {
|
|
var ts = this._transformState;
|
|
ts.transforming = false;
|
|
var cb = ts.writecb;
|
|
|
|
if (cb === null) {
|
|
return this.emit('error', new ERR_MULTIPLE_CALLBACK());
|
|
}
|
|
|
|
ts.writechunk = null;
|
|
ts.writecb = null;
|
|
if (data != null) // single equals check for both `null` and `undefined`
|
|
this.push(data);
|
|
cb(er);
|
|
var rs = this._readableState;
|
|
rs.reading = false;
|
|
|
|
if (rs.needReadable || rs.length < rs.highWaterMark) {
|
|
this._read(rs.highWaterMark);
|
|
}
|
|
}
|
|
|
|
function Transform(options) {
|
|
if (!(this instanceof Transform)) return new Transform(options);
|
|
Duplex.call(this, options);
|
|
this._transformState = {
|
|
afterTransform: afterTransform.bind(this),
|
|
needTransform: false,
|
|
transforming: false,
|
|
writecb: null,
|
|
writechunk: null,
|
|
writeencoding: null
|
|
}; // start out asking for a readable event once data is transformed.
|
|
|
|
this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
|
|
// that Readable wants before the first _read call, so unset the
|
|
// sync guard flag.
|
|
|
|
this._readableState.sync = false;
|
|
|
|
if (options) {
|
|
if (typeof options.transform === 'function') this._transform = options.transform;
|
|
if (typeof options.flush === 'function') this._flush = options.flush;
|
|
} // When the writable side finishes, then flush out anything remaining.
|
|
|
|
|
|
this.on('prefinish', prefinish);
|
|
}
|
|
|
|
function prefinish() {
|
|
var _this = this;
|
|
|
|
if (typeof this._flush === 'function' && !this._readableState.destroyed) {
|
|
this._flush(function (er, data) {
|
|
done(_this, er, data);
|
|
});
|
|
} else {
|
|
done(this, null, null);
|
|
}
|
|
}
|
|
|
|
Transform.prototype.push = function (chunk, encoding) {
|
|
this._transformState.needTransform = false;
|
|
return Duplex.prototype.push.call(this, chunk, encoding);
|
|
}; // This is the part where you do stuff!
|
|
// override this function in implementation classes.
|
|
// 'chunk' is an input chunk.
|
|
//
|
|
// Call `push(newChunk)` to pass along transformed output
|
|
// to the readable side. You may call 'push' zero or more times.
|
|
//
|
|
// Call `cb(err)` when you are done with this chunk. If you pass
|
|
// an error, then that'll put the hurt on the whole operation. If you
|
|
// never call cb(), then you'll never get another chunk.
|
|
|
|
|
|
Transform.prototype._transform = function (chunk, encoding, cb) {
|
|
cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
|
|
};
|
|
|
|
Transform.prototype._write = function (chunk, encoding, cb) {
|
|
var ts = this._transformState;
|
|
ts.writecb = cb;
|
|
ts.writechunk = chunk;
|
|
ts.writeencoding = encoding;
|
|
|
|
if (!ts.transforming) {
|
|
var rs = this._readableState;
|
|
if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
|
|
}
|
|
}; // Doesn't matter what the args are here.
|
|
// _transform does all the work.
|
|
// That we got here means that the readable side wants more data.
|
|
|
|
|
|
Transform.prototype._read = function (n) {
|
|
var ts = this._transformState;
|
|
|
|
if (ts.writechunk !== null && !ts.transforming) {
|
|
ts.transforming = true;
|
|
|
|
this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
|
|
} else {
|
|
// mark that we need a transform, so that any data that comes in
|
|
// will get processed, now that we've asked for it.
|
|
ts.needTransform = true;
|
|
}
|
|
};
|
|
|
|
Transform.prototype._destroy = function (err, cb) {
|
|
Duplex.prototype._destroy.call(this, err, function (err2) {
|
|
cb(err2);
|
|
});
|
|
};
|
|
|
|
function done(stream, er, data) {
|
|
if (er) return stream.emit('error', er);
|
|
if (data != null) // single equals check for both `null` and `undefined`
|
|
stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
|
|
// if there's nothing in the write buffer, then that means
|
|
// that nothing more will ever be provided
|
|
|
|
if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
|
|
if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
|
|
return stream.push(null);
|
|
}
|
|
},{"../errors":45,"./_stream_duplex":46,"inherits":33}],50:[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.
|
|
// A bit simpler than readable streams.
|
|
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
|
|
// the drain event emission and buffering.
|
|
'use strict';
|
|
|
|
module.exports = Writable;
|
|
/* <replacement> */
|
|
|
|
function WriteReq(chunk, encoding, cb) {
|
|
this.chunk = chunk;
|
|
this.encoding = encoding;
|
|
this.callback = cb;
|
|
this.next = null;
|
|
} // It seems a linked list but it is not
|
|
// there will be only 2 of these for each stream
|
|
|
|
|
|
function CorkedRequest(state) {
|
|
var _this = this;
|
|
|
|
this.next = null;
|
|
this.entry = null;
|
|
|
|
this.finish = function () {
|
|
onCorkedFinish(_this, state);
|
|
};
|
|
}
|
|
/* </replacement> */
|
|
|
|
/*<replacement>*/
|
|
|
|
|
|
var Duplex;
|
|
/*</replacement>*/
|
|
|
|
Writable.WritableState = WritableState;
|
|
/*<replacement>*/
|
|
|
|
var internalUtil = {
|
|
deprecate: require('util-deprecate')
|
|
};
|
|
/*</replacement>*/
|
|
|
|
/*<replacement>*/
|
|
|
|
var Stream = require('./internal/streams/stream');
|
|
/*</replacement>*/
|
|
|
|
|
|
var Buffer = require('buffer').Buffer;
|
|
|
|
var OurUint8Array = global.Uint8Array || function () {};
|
|
|
|
function _uint8ArrayToBuffer(chunk) {
|
|
return Buffer.from(chunk);
|
|
}
|
|
|
|
function _isUint8Array(obj) {
|
|
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
|
}
|
|
|
|
var destroyImpl = require('./internal/streams/destroy');
|
|
|
|
var _require = require('./internal/streams/state'),
|
|
getHighWaterMark = _require.getHighWaterMark;
|
|
|
|
var _require$codes = require('../errors').codes,
|
|
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
|
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
|
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
|
ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
|
|
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
|
|
ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
|
|
ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
|
|
ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
|
|
|
|
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
|
|
|
require('inherits')(Writable, Stream);
|
|
|
|
function nop() {}
|
|
|
|
function WritableState(options, stream, isDuplex) {
|
|
Duplex = Duplex || require('./_stream_duplex');
|
|
options = options || {}; // Duplex streams are both readable and writable, but share
|
|
// the same options object.
|
|
// However, some cases require setting options to different
|
|
// values for the readable and the writable sides of the duplex stream,
|
|
// e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
|
|
|
|
if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
|
|
// contains buffers or objects.
|
|
|
|
this.objectMode = !!options.objectMode;
|
|
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
|
|
// Note: 0 is a valid value, means that we always return false if
|
|
// the entire buffer is not flushed immediately on write()
|
|
|
|
this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
|
|
|
|
this.finalCalled = false; // drain event flag.
|
|
|
|
this.needDrain = false; // at the start of calling end()
|
|
|
|
this.ending = false; // when end() has been called, and returned
|
|
|
|
this.ended = false; // when 'finish' is emitted
|
|
|
|
this.finished = false; // has it been destroyed
|
|
|
|
this.destroyed = false; // should we decode strings into buffers before passing to _write?
|
|
// this is here so that some node-core streams can optimize string
|
|
// handling at a lower level.
|
|
|
|
var noDecode = options.decodeStrings === false;
|
|
this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string
|
|
// encoding is 'binary' so we have to make this configurable.
|
|
// Everything else in the universe uses 'utf8', though.
|
|
|
|
this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
|
|
// of how much we're waiting to get pushed to some underlying
|
|
// socket or file.
|
|
|
|
this.length = 0; // a flag to see when we're in the middle of a write.
|
|
|
|
this.writing = false; // when true all writes will be buffered until .uncork() call
|
|
|
|
this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
|
|
// or on a later tick. We set this to true at first, because any
|
|
// actions that shouldn't happen until "later" should generally also
|
|
// not happen before the first write call.
|
|
|
|
this.sync = true; // a flag to know if we're processing previously buffered items, which
|
|
// may call the _write() callback in the same tick, so that we don't
|
|
// end up in an overlapped onwrite situation.
|
|
|
|
this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
|
|
|
|
this.onwrite = function (er) {
|
|
onwrite(stream, er);
|
|
}; // the callback that the user supplies to write(chunk,encoding,cb)
|
|
|
|
|
|
this.writecb = null; // the amount that is being written when _write is called.
|
|
|
|
this.writelen = 0;
|
|
this.bufferedRequest = null;
|
|
this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
|
|
// this must be 0 before 'finish' can be emitted
|
|
|
|
this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
|
|
// This is relevant for synchronous Transform streams
|
|
|
|
this.prefinished = false; // True if the error was already emitted and should not be thrown again
|
|
|
|
this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
|
|
|
|
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
|
|
|
|
this.autoDestroy = !!options.autoDestroy; // count buffered requests
|
|
|
|
this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
|
|
// one allocated and free to use, and we maintain at most two
|
|
|
|
this.corkedRequestsFree = new CorkedRequest(this);
|
|
}
|
|
|
|
WritableState.prototype.getBuffer = function getBuffer() {
|
|
var current = this.bufferedRequest;
|
|
var out = [];
|
|
|
|
while (current) {
|
|
out.push(current);
|
|
current = current.next;
|
|
}
|
|
|
|
return out;
|
|
};
|
|
|
|
(function () {
|
|
try {
|
|
Object.defineProperty(WritableState.prototype, 'buffer', {
|
|
get: internalUtil.deprecate(function writableStateBufferGetter() {
|
|
return this.getBuffer();
|
|
}, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
|
|
});
|
|
} catch (_) {}
|
|
})(); // Test _writableState for inheritance to account for Duplex streams,
|
|
// whose prototype chain only points to Readable.
|
|
|
|
|
|
var realHasInstance;
|
|
|
|
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
|
|
realHasInstance = Function.prototype[Symbol.hasInstance];
|
|
Object.defineProperty(Writable, Symbol.hasInstance, {
|
|
value: function value(object) {
|
|
if (realHasInstance.call(this, object)) return true;
|
|
if (this !== Writable) return false;
|
|
return object && object._writableState instanceof WritableState;
|
|
}
|
|
});
|
|
} else {
|
|
realHasInstance = function realHasInstance(object) {
|
|
return object instanceof this;
|
|
};
|
|
}
|
|
|
|
function Writable(options) {
|
|
Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.
|
|
// `realHasInstance` is necessary because using plain `instanceof`
|
|
// would return false, as no `_writableState` property is attached.
|
|
// Trying to use the custom `instanceof` for Writable here will also break the
|
|
// Node.js LazyTransform implementation, which has a non-trivial getter for
|
|
// `_writableState` that would lead to infinite recursion.
|
|
// Checking for a Stream.Duplex instance is faster here instead of inside
|
|
// the WritableState constructor, at least with V8 6.5
|
|
|
|
var isDuplex = this instanceof Duplex;
|
|
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
|
|
this._writableState = new WritableState(options, this, isDuplex); // legacy.
|
|
|
|
this.writable = true;
|
|
|
|
if (options) {
|
|
if (typeof options.write === 'function') this._write = options.write;
|
|
if (typeof options.writev === 'function') this._writev = options.writev;
|
|
if (typeof options.destroy === 'function') this._destroy = options.destroy;
|
|
if (typeof options.final === 'function') this._final = options.final;
|
|
}
|
|
|
|
Stream.call(this);
|
|
} // Otherwise people can pipe Writable streams, which is just wrong.
|
|
|
|
|
|
Writable.prototype.pipe = function () {
|
|
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
|
|
};
|
|
|
|
function writeAfterEnd(stream, cb) {
|
|
var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
|
|
|
|
errorOrDestroy(stream, er);
|
|
process.nextTick(cb, er);
|
|
} // Checks that a user-supplied chunk is valid, especially for the particular
|
|
// mode the stream is in. Currently this means that `null` is never accepted
|
|
// and undefined/non-string values are only allowed in object mode.
|
|
|
|
|
|
function validChunk(stream, state, chunk, cb) {
|
|
var er;
|
|
|
|
if (chunk === null) {
|
|
er = new ERR_STREAM_NULL_VALUES();
|
|
} else if (typeof chunk !== 'string' && !state.objectMode) {
|
|
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
|
|
}
|
|
|
|
if (er) {
|
|
errorOrDestroy(stream, er);
|
|
process.nextTick(cb, er);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Writable.prototype.write = function (chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
var ret = false;
|
|
|
|
var isBuf = !state.objectMode && _isUint8Array(chunk);
|
|
|
|
if (isBuf && !Buffer.isBuffer(chunk)) {
|
|
chunk = _uint8ArrayToBuffer(chunk);
|
|
}
|
|
|
|
if (typeof encoding === 'function') {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
|
|
if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
|
|
if (typeof cb !== 'function') cb = nop;
|
|
if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
|
|
state.pendingcb++;
|
|
ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Writable.prototype.cork = function () {
|
|
this._writableState.corked++;
|
|
};
|
|
|
|
Writable.prototype.uncork = function () {
|
|
var state = this._writableState;
|
|
|
|
if (state.corked) {
|
|
state.corked--;
|
|
if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
|
|
}
|
|
};
|
|
|
|
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
|
|
// node::ParseEncoding() requires lower case.
|
|
if (typeof encoding === 'string') encoding = encoding.toLowerCase();
|
|
if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
|
|
this._writableState.defaultEncoding = encoding;
|
|
return this;
|
|
};
|
|
|
|
Object.defineProperty(Writable.prototype, 'writableBuffer', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState && this._writableState.getBuffer();
|
|
}
|
|
});
|
|
|
|
function decodeChunk(state, chunk, encoding) {
|
|
if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
|
|
chunk = Buffer.from(chunk, encoding);
|
|
}
|
|
|
|
return chunk;
|
|
}
|
|
|
|
Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState.highWaterMark;
|
|
}
|
|
}); // if we're already writing something, then just put this
|
|
// in the queue, and wait our turn. Otherwise, call _write
|
|
// If we return false, then we need a drain event, so set that flag.
|
|
|
|
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
|
|
if (!isBuf) {
|
|
var newChunk = decodeChunk(state, chunk, encoding);
|
|
|
|
if (chunk !== newChunk) {
|
|
isBuf = true;
|
|
encoding = 'buffer';
|
|
chunk = newChunk;
|
|
}
|
|
}
|
|
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
state.length += len;
|
|
var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
|
|
|
|
if (!ret) state.needDrain = true;
|
|
|
|
if (state.writing || state.corked) {
|
|
var last = state.lastBufferedRequest;
|
|
state.lastBufferedRequest = {
|
|
chunk: chunk,
|
|
encoding: encoding,
|
|
isBuf: isBuf,
|
|
callback: cb,
|
|
next: null
|
|
};
|
|
|
|
if (last) {
|
|
last.next = state.lastBufferedRequest;
|
|
} else {
|
|
state.bufferedRequest = state.lastBufferedRequest;
|
|
}
|
|
|
|
state.bufferedRequestCount += 1;
|
|
} else {
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
|
|
state.writelen = len;
|
|
state.writecb = cb;
|
|
state.writing = true;
|
|
state.sync = true;
|
|
if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
|
|
state.sync = false;
|
|
}
|
|
|
|
function onwriteError(stream, state, sync, er, cb) {
|
|
--state.pendingcb;
|
|
|
|
if (sync) {
|
|
// defer the callback if we are being called synchronously
|
|
// to avoid piling up things on the stack
|
|
process.nextTick(cb, er); // this can emit finish, and it will always happen
|
|
// after error
|
|
|
|
process.nextTick(finishMaybe, stream, state);
|
|
stream._writableState.errorEmitted = true;
|
|
errorOrDestroy(stream, er);
|
|
} else {
|
|
// the caller expect this to happen before if
|
|
// it is async
|
|
cb(er);
|
|
stream._writableState.errorEmitted = true;
|
|
errorOrDestroy(stream, er); // this can emit finish, but finish must
|
|
// always follow error
|
|
|
|
finishMaybe(stream, state);
|
|
}
|
|
}
|
|
|
|
function onwriteStateUpdate(state) {
|
|
state.writing = false;
|
|
state.writecb = null;
|
|
state.length -= state.writelen;
|
|
state.writelen = 0;
|
|
}
|
|
|
|
function onwrite(stream, er) {
|
|
var state = stream._writableState;
|
|
var sync = state.sync;
|
|
var cb = state.writecb;
|
|
if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
|
|
onwriteStateUpdate(state);
|
|
if (er) onwriteError(stream, state, sync, er, cb);else {
|
|
// Check if we're actually ready to finish, but don't emit yet
|
|
var finished = needFinish(state) || stream.destroyed;
|
|
|
|
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
|
|
clearBuffer(stream, state);
|
|
}
|
|
|
|
if (sync) {
|
|
process.nextTick(afterWrite, stream, state, finished, cb);
|
|
} else {
|
|
afterWrite(stream, state, finished, cb);
|
|
}
|
|
}
|
|
}
|
|
|
|
function afterWrite(stream, state, finished, cb) {
|
|
if (!finished) onwriteDrain(stream, state);
|
|
state.pendingcb--;
|
|
cb();
|
|
finishMaybe(stream, state);
|
|
} // Must force callback to be called on nextTick, so that we don't
|
|
// emit 'drain' before the write() consumer gets the 'false' return
|
|
// value, and has a chance to attach a 'drain' listener.
|
|
|
|
|
|
function onwriteDrain(stream, state) {
|
|
if (state.length === 0 && state.needDrain) {
|
|
state.needDrain = false;
|
|
stream.emit('drain');
|
|
}
|
|
} // if there's something in the buffer waiting, then process it
|
|
|
|
|
|
function clearBuffer(stream, state) {
|
|
state.bufferProcessing = true;
|
|
var entry = state.bufferedRequest;
|
|
|
|
if (stream._writev && entry && entry.next) {
|
|
// Fast case, write everything using _writev()
|
|
var l = state.bufferedRequestCount;
|
|
var buffer = new Array(l);
|
|
var holder = state.corkedRequestsFree;
|
|
holder.entry = entry;
|
|
var count = 0;
|
|
var allBuffers = true;
|
|
|
|
while (entry) {
|
|
buffer[count] = entry;
|
|
if (!entry.isBuf) allBuffers = false;
|
|
entry = entry.next;
|
|
count += 1;
|
|
}
|
|
|
|
buffer.allBuffers = allBuffers;
|
|
doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
|
|
// as the hot path ends with doWrite
|
|
|
|
state.pendingcb++;
|
|
state.lastBufferedRequest = null;
|
|
|
|
if (holder.next) {
|
|
state.corkedRequestsFree = holder.next;
|
|
holder.next = null;
|
|
} else {
|
|
state.corkedRequestsFree = new CorkedRequest(state);
|
|
}
|
|
|
|
state.bufferedRequestCount = 0;
|
|
} else {
|
|
// Slow case, write chunks one-by-one
|
|
while (entry) {
|
|
var chunk = entry.chunk;
|
|
var encoding = entry.encoding;
|
|
var cb = entry.callback;
|
|
var len = state.objectMode ? 1 : chunk.length;
|
|
doWrite(stream, state, false, len, chunk, encoding, cb);
|
|
entry = entry.next;
|
|
state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
|
|
// it means that we need to wait until it does.
|
|
// also, that means that the chunk and cb are currently
|
|
// being processed, so move the buffer counter past them.
|
|
|
|
if (state.writing) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (entry === null) state.lastBufferedRequest = null;
|
|
}
|
|
|
|
state.bufferedRequest = entry;
|
|
state.bufferProcessing = false;
|
|
}
|
|
|
|
Writable.prototype._write = function (chunk, encoding, cb) {
|
|
cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
|
|
};
|
|
|
|
Writable.prototype._writev = null;
|
|
|
|
Writable.prototype.end = function (chunk, encoding, cb) {
|
|
var state = this._writableState;
|
|
|
|
if (typeof chunk === 'function') {
|
|
cb = chunk;
|
|
chunk = null;
|
|
encoding = null;
|
|
} else if (typeof encoding === 'function') {
|
|
cb = encoding;
|
|
encoding = null;
|
|
}
|
|
|
|
if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
|
|
|
|
if (state.corked) {
|
|
state.corked = 1;
|
|
this.uncork();
|
|
} // ignore unnecessary end() calls.
|
|
|
|
|
|
if (!state.ending) endWritable(this, state, cb);
|
|
return this;
|
|
};
|
|
|
|
Object.defineProperty(Writable.prototype, 'writableLength', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
return this._writableState.length;
|
|
}
|
|
});
|
|
|
|
function needFinish(state) {
|
|
return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
|
|
}
|
|
|
|
function callFinal(stream, state) {
|
|
stream._final(function (err) {
|
|
state.pendingcb--;
|
|
|
|
if (err) {
|
|
errorOrDestroy(stream, err);
|
|
}
|
|
|
|
state.prefinished = true;
|
|
stream.emit('prefinish');
|
|
finishMaybe(stream, state);
|
|
});
|
|
}
|
|
|
|
function prefinish(stream, state) {
|
|
if (!state.prefinished && !state.finalCalled) {
|
|
if (typeof stream._final === 'function' && !state.destroyed) {
|
|
state.pendingcb++;
|
|
state.finalCalled = true;
|
|
process.nextTick(callFinal, stream, state);
|
|
} else {
|
|
state.prefinished = true;
|
|
stream.emit('prefinish');
|
|
}
|
|
}
|
|
}
|
|
|
|
function finishMaybe(stream, state) {
|
|
var need = needFinish(state);
|
|
|
|
if (need) {
|
|
prefinish(stream, state);
|
|
|
|
if (state.pendingcb === 0) {
|
|
state.finished = true;
|
|
stream.emit('finish');
|
|
|
|
if (state.autoDestroy) {
|
|
// In case of duplex streams we need a way to detect
|
|
// if the readable side is ready for autoDestroy as well
|
|
var rState = stream._readableState;
|
|
|
|
if (!rState || rState.autoDestroy && rState.endEmitted) {
|
|
stream.destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return need;
|
|
}
|
|
|
|
function endWritable(stream, state, cb) {
|
|
state.ending = true;
|
|
finishMaybe(stream, state);
|
|
|
|
if (cb) {
|
|
if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
|
|
}
|
|
|
|
state.ended = true;
|
|
stream.writable = false;
|
|
}
|
|
|
|
function onCorkedFinish(corkReq, state, err) {
|
|
var entry = corkReq.entry;
|
|
corkReq.entry = null;
|
|
|
|
while (entry) {
|
|
var cb = entry.callback;
|
|
state.pendingcb--;
|
|
cb(err);
|
|
entry = entry.next;
|
|
} // reuse the free corkReq.
|
|
|
|
|
|
state.corkedRequestsFree.next = corkReq;
|
|
}
|
|
|
|
Object.defineProperty(Writable.prototype, 'destroyed', {
|
|
// making it explicit this property is not enumerable
|
|
// because otherwise some prototype manipulation in
|
|
// userland will fail
|
|
enumerable: false,
|
|
get: function get() {
|
|
if (this._writableState === undefined) {
|
|
return false;
|
|
}
|
|
|
|
return this._writableState.destroyed;
|
|
},
|
|
set: function set(value) {
|
|
// we ignore the value if the stream
|
|
// has not been initialized yet
|
|
if (!this._writableState) {
|
|
return;
|
|
} // backward compatibility, the user is explicitly
|
|
// managing destroyed
|
|
|
|
|
|
this._writableState.destroyed = value;
|
|
}
|
|
});
|
|
Writable.prototype.destroy = destroyImpl.destroy;
|
|
Writable.prototype._undestroy = destroyImpl.undestroy;
|
|
|
|
Writable.prototype._destroy = function (err, cb) {
|
|
cb(err);
|
|
};
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"../errors":45,"./_stream_duplex":46,"./internal/streams/destroy":53,"./internal/streams/state":57,"./internal/streams/stream":58,"_process":35,"buffer":28,"inherits":33,"util-deprecate":63}],51:[function(require,module,exports){
|
|
(function (process){
|
|
'use strict';
|
|
|
|
var _Object$setPrototypeO;
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
var finished = require('./end-of-stream');
|
|
|
|
var kLastResolve = Symbol('lastResolve');
|
|
var kLastReject = Symbol('lastReject');
|
|
var kError = Symbol('error');
|
|
var kEnded = Symbol('ended');
|
|
var kLastPromise = Symbol('lastPromise');
|
|
var kHandlePromise = Symbol('handlePromise');
|
|
var kStream = Symbol('stream');
|
|
|
|
function createIterResult(value, done) {
|
|
return {
|
|
value: value,
|
|
done: done
|
|
};
|
|
}
|
|
|
|
function readAndResolve(iter) {
|
|
var resolve = iter[kLastResolve];
|
|
|
|
if (resolve !== null) {
|
|
var data = iter[kStream].read(); // we defer if data is null
|
|
// we can be expecting either 'end' or
|
|
// 'error'
|
|
|
|
if (data !== null) {
|
|
iter[kLastPromise] = null;
|
|
iter[kLastResolve] = null;
|
|
iter[kLastReject] = null;
|
|
resolve(createIterResult(data, false));
|
|
}
|
|
}
|
|
}
|
|
|
|
function onReadable(iter) {
|
|
// we wait for the next tick, because it might
|
|
// emit an error with process.nextTick
|
|
process.nextTick(readAndResolve, iter);
|
|
}
|
|
|
|
function wrapForNext(lastPromise, iter) {
|
|
return function (resolve, reject) {
|
|
lastPromise.then(function () {
|
|
if (iter[kEnded]) {
|
|
resolve(createIterResult(undefined, true));
|
|
return;
|
|
}
|
|
|
|
iter[kHandlePromise](resolve, reject);
|
|
}, reject);
|
|
};
|
|
}
|
|
|
|
var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
|
|
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
|
|
get stream() {
|
|
return this[kStream];
|
|
},
|
|
|
|
next: function next() {
|
|
var _this = this;
|
|
|
|
// if we have detected an error in the meanwhile
|
|
// reject straight away
|
|
var error = this[kError];
|
|
|
|
if (error !== null) {
|
|
return Promise.reject(error);
|
|
}
|
|
|
|
if (this[kEnded]) {
|
|
return Promise.resolve(createIterResult(undefined, true));
|
|
}
|
|
|
|
if (this[kStream].destroyed) {
|
|
// We need to defer via nextTick because if .destroy(err) is
|
|
// called, the error will be emitted via nextTick, and
|
|
// we cannot guarantee that there is no error lingering around
|
|
// waiting to be emitted.
|
|
return new Promise(function (resolve, reject) {
|
|
process.nextTick(function () {
|
|
if (_this[kError]) {
|
|
reject(_this[kError]);
|
|
} else {
|
|
resolve(createIterResult(undefined, true));
|
|
}
|
|
});
|
|
});
|
|
} // if we have multiple next() calls
|
|
// we will wait for the previous Promise to finish
|
|
// this logic is optimized to support for await loops,
|
|
// where next() is only called once at a time
|
|
|
|
|
|
var lastPromise = this[kLastPromise];
|
|
var promise;
|
|
|
|
if (lastPromise) {
|
|
promise = new Promise(wrapForNext(lastPromise, this));
|
|
} else {
|
|
// fast path needed to support multiple this.push()
|
|
// without triggering the next() queue
|
|
var data = this[kStream].read();
|
|
|
|
if (data !== null) {
|
|
return Promise.resolve(createIterResult(data, false));
|
|
}
|
|
|
|
promise = new Promise(this[kHandlePromise]);
|
|
}
|
|
|
|
this[kLastPromise] = promise;
|
|
return promise;
|
|
}
|
|
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
|
|
return this;
|
|
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
|
|
var _this2 = this;
|
|
|
|
// destroy(err, cb) is a private API
|
|
// we can guarantee we have that here, because we control the
|
|
// Readable class this is attached to
|
|
return new Promise(function (resolve, reject) {
|
|
_this2[kStream].destroy(null, function (err) {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
resolve(createIterResult(undefined, true));
|
|
});
|
|
});
|
|
}), _Object$setPrototypeO), AsyncIteratorPrototype);
|
|
|
|
var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
|
|
var _Object$create;
|
|
|
|
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
|
|
value: stream,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kLastResolve, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kLastReject, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kError, {
|
|
value: null,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kEnded, {
|
|
value: stream._readableState.endEmitted,
|
|
writable: true
|
|
}), _defineProperty(_Object$create, kHandlePromise, {
|
|
value: function value(resolve, reject) {
|
|
var data = iterator[kStream].read();
|
|
|
|
if (data) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
resolve(createIterResult(data, false));
|
|
} else {
|
|
iterator[kLastResolve] = resolve;
|
|
iterator[kLastReject] = reject;
|
|
}
|
|
},
|
|
writable: true
|
|
}), _Object$create));
|
|
iterator[kLastPromise] = null;
|
|
finished(stream, function (err) {
|
|
if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
|
|
var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
|
|
// returned by next() and store the error
|
|
|
|
if (reject !== null) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
reject(err);
|
|
}
|
|
|
|
iterator[kError] = err;
|
|
return;
|
|
}
|
|
|
|
var resolve = iterator[kLastResolve];
|
|
|
|
if (resolve !== null) {
|
|
iterator[kLastPromise] = null;
|
|
iterator[kLastResolve] = null;
|
|
iterator[kLastReject] = null;
|
|
resolve(createIterResult(undefined, true));
|
|
}
|
|
|
|
iterator[kEnded] = true;
|
|
});
|
|
stream.on('readable', onReadable.bind(null, iterator));
|
|
return iterator;
|
|
};
|
|
|
|
module.exports = createReadableStreamAsyncIterator;
|
|
}).call(this,require('_process'))
|
|
},{"./end-of-stream":54,"_process":35}],52:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
|
|
|
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
|
|
|
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
var _require = require('buffer'),
|
|
Buffer = _require.Buffer;
|
|
|
|
var _require2 = require('util'),
|
|
inspect = _require2.inspect;
|
|
|
|
var custom = inspect && inspect.custom || 'inspect';
|
|
|
|
function copyBuffer(src, target, offset) {
|
|
Buffer.prototype.copy.call(src, target, offset);
|
|
}
|
|
|
|
module.exports =
|
|
/*#__PURE__*/
|
|
function () {
|
|
function BufferList() {
|
|
_classCallCheck(this, BufferList);
|
|
|
|
this.head = null;
|
|
this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
|
|
_createClass(BufferList, [{
|
|
key: "push",
|
|
value: function push(v) {
|
|
var entry = {
|
|
data: v,
|
|
next: null
|
|
};
|
|
if (this.length > 0) this.tail.next = entry;else this.head = entry;
|
|
this.tail = entry;
|
|
++this.length;
|
|
}
|
|
}, {
|
|
key: "unshift",
|
|
value: function unshift(v) {
|
|
var entry = {
|
|
data: v,
|
|
next: this.head
|
|
};
|
|
if (this.length === 0) this.tail = entry;
|
|
this.head = entry;
|
|
++this.length;
|
|
}
|
|
}, {
|
|
key: "shift",
|
|
value: function shift() {
|
|
if (this.length === 0) return;
|
|
var ret = this.head.data;
|
|
if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
|
|
--this.length;
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "clear",
|
|
value: function clear() {
|
|
this.head = this.tail = null;
|
|
this.length = 0;
|
|
}
|
|
}, {
|
|
key: "join",
|
|
value: function join(s) {
|
|
if (this.length === 0) return '';
|
|
var p = this.head;
|
|
var ret = '' + p.data;
|
|
|
|
while (p = p.next) {
|
|
ret += s + p.data;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "concat",
|
|
value: function concat(n) {
|
|
if (this.length === 0) return Buffer.alloc(0);
|
|
var ret = Buffer.allocUnsafe(n >>> 0);
|
|
var p = this.head;
|
|
var i = 0;
|
|
|
|
while (p) {
|
|
copyBuffer(p.data, ret, i);
|
|
i += p.data.length;
|
|
p = p.next;
|
|
}
|
|
|
|
return ret;
|
|
} // Consumes a specified amount of bytes or characters from the buffered data.
|
|
|
|
}, {
|
|
key: "consume",
|
|
value: function consume(n, hasStrings) {
|
|
var ret;
|
|
|
|
if (n < this.head.data.length) {
|
|
// `slice` is the same for buffers and strings.
|
|
ret = this.head.data.slice(0, n);
|
|
this.head.data = this.head.data.slice(n);
|
|
} else if (n === this.head.data.length) {
|
|
// First chunk is a perfect match.
|
|
ret = this.shift();
|
|
} else {
|
|
// Result spans more than one buffer.
|
|
ret = hasStrings ? this._getString(n) : this._getBuffer(n);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: "first",
|
|
value: function first() {
|
|
return this.head.data;
|
|
} // Consumes a specified amount of characters from the buffered data.
|
|
|
|
}, {
|
|
key: "_getString",
|
|
value: function _getString(n) {
|
|
var p = this.head;
|
|
var c = 1;
|
|
var ret = p.data;
|
|
n -= ret.length;
|
|
|
|
while (p = p.next) {
|
|
var str = p.data;
|
|
var nb = n > str.length ? str.length : n;
|
|
if (nb === str.length) ret += str;else ret += str.slice(0, n);
|
|
n -= nb;
|
|
|
|
if (n === 0) {
|
|
if (nb === str.length) {
|
|
++c;
|
|
if (p.next) this.head = p.next;else this.head = this.tail = null;
|
|
} else {
|
|
this.head = p;
|
|
p.data = str.slice(nb);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
++c;
|
|
}
|
|
|
|
this.length -= c;
|
|
return ret;
|
|
} // Consumes a specified amount of bytes from the buffered data.
|
|
|
|
}, {
|
|
key: "_getBuffer",
|
|
value: function _getBuffer(n) {
|
|
var ret = Buffer.allocUnsafe(n);
|
|
var p = this.head;
|
|
var c = 1;
|
|
p.data.copy(ret);
|
|
n -= p.data.length;
|
|
|
|
while (p = p.next) {
|
|
var buf = p.data;
|
|
var nb = n > buf.length ? buf.length : n;
|
|
buf.copy(ret, ret.length - n, 0, nb);
|
|
n -= nb;
|
|
|
|
if (n === 0) {
|
|
if (nb === buf.length) {
|
|
++c;
|
|
if (p.next) this.head = p.next;else this.head = this.tail = null;
|
|
} else {
|
|
this.head = p;
|
|
p.data = buf.slice(nb);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
++c;
|
|
}
|
|
|
|
this.length -= c;
|
|
return ret;
|
|
} // Make sure the linked list only shows the minimal necessary information.
|
|
|
|
}, {
|
|
key: custom,
|
|
value: function value(_, options) {
|
|
return inspect(this, _objectSpread({}, options, {
|
|
// Only inspect one level.
|
|
depth: 0,
|
|
// It should not recurse.
|
|
customInspect: false
|
|
}));
|
|
}
|
|
}]);
|
|
|
|
return BufferList;
|
|
}();
|
|
},{"buffer":28,"util":26}],53:[function(require,module,exports){
|
|
(function (process){
|
|
'use strict'; // undocumented cb() API, needed for core, not for public API
|
|
|
|
function destroy(err, cb) {
|
|
var _this = this;
|
|
|
|
var readableDestroyed = this._readableState && this._readableState.destroyed;
|
|
var writableDestroyed = this._writableState && this._writableState.destroyed;
|
|
|
|
if (readableDestroyed || writableDestroyed) {
|
|
if (cb) {
|
|
cb(err);
|
|
} else if (err) {
|
|
if (!this._writableState) {
|
|
process.nextTick(emitErrorNT, this, err);
|
|
} else if (!this._writableState.errorEmitted) {
|
|
this._writableState.errorEmitted = true;
|
|
process.nextTick(emitErrorNT, this, err);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
} // we set destroyed to true before firing error callbacks in order
|
|
// to make it re-entrance safe in case destroy() is called within callbacks
|
|
|
|
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = true;
|
|
} // if this is a duplex stream mark the writable part as destroyed as well
|
|
|
|
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = true;
|
|
}
|
|
|
|
this._destroy(err || null, function (err) {
|
|
if (!cb && err) {
|
|
if (!_this._writableState) {
|
|
process.nextTick(emitErrorAndCloseNT, _this, err);
|
|
} else if (!_this._writableState.errorEmitted) {
|
|
_this._writableState.errorEmitted = true;
|
|
process.nextTick(emitErrorAndCloseNT, _this, err);
|
|
} else {
|
|
process.nextTick(emitCloseNT, _this);
|
|
}
|
|
} else if (cb) {
|
|
process.nextTick(emitCloseNT, _this);
|
|
cb(err);
|
|
} else {
|
|
process.nextTick(emitCloseNT, _this);
|
|
}
|
|
});
|
|
|
|
return this;
|
|
}
|
|
|
|
function emitErrorAndCloseNT(self, err) {
|
|
emitErrorNT(self, err);
|
|
emitCloseNT(self);
|
|
}
|
|
|
|
function emitCloseNT(self) {
|
|
if (self._writableState && !self._writableState.emitClose) return;
|
|
if (self._readableState && !self._readableState.emitClose) return;
|
|
self.emit('close');
|
|
}
|
|
|
|
function undestroy() {
|
|
if (this._readableState) {
|
|
this._readableState.destroyed = false;
|
|
this._readableState.reading = false;
|
|
this._readableState.ended = false;
|
|
this._readableState.endEmitted = false;
|
|
}
|
|
|
|
if (this._writableState) {
|
|
this._writableState.destroyed = false;
|
|
this._writableState.ended = false;
|
|
this._writableState.ending = false;
|
|
this._writableState.finalCalled = false;
|
|
this._writableState.prefinished = false;
|
|
this._writableState.finished = false;
|
|
this._writableState.errorEmitted = false;
|
|
}
|
|
}
|
|
|
|
function emitErrorNT(self, err) {
|
|
self.emit('error', err);
|
|
}
|
|
|
|
function errorOrDestroy(stream, err) {
|
|
// We have tests that rely on errors being emitted
|
|
// in the same tick, so changing this is semver major.
|
|
// For now when you opt-in to autoDestroy we allow
|
|
// the error to be emitted nextTick. In a future
|
|
// semver major update we should change the default to this.
|
|
var rState = stream._readableState;
|
|
var wState = stream._writableState;
|
|
if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
|
|
}
|
|
|
|
module.exports = {
|
|
destroy: destroy,
|
|
undestroy: undestroy,
|
|
errorOrDestroy: errorOrDestroy
|
|
};
|
|
}).call(this,require('_process'))
|
|
},{"_process":35}],54:[function(require,module,exports){
|
|
// Ported from https://github.com/mafintosh/end-of-stream with
|
|
// permission from the author, Mathias Buus (@mafintosh).
|
|
'use strict';
|
|
|
|
var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;
|
|
|
|
function once(callback) {
|
|
var called = false;
|
|
return function () {
|
|
if (called) return;
|
|
called = true;
|
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
callback.apply(this, args);
|
|
};
|
|
}
|
|
|
|
function noop() {}
|
|
|
|
function isRequest(stream) {
|
|
return stream.setHeader && typeof stream.abort === 'function';
|
|
}
|
|
|
|
function eos(stream, opts, callback) {
|
|
if (typeof opts === 'function') return eos(stream, null, opts);
|
|
if (!opts) opts = {};
|
|
callback = once(callback || noop);
|
|
var readable = opts.readable || opts.readable !== false && stream.readable;
|
|
var writable = opts.writable || opts.writable !== false && stream.writable;
|
|
|
|
var onlegacyfinish = function onlegacyfinish() {
|
|
if (!stream.writable) onfinish();
|
|
};
|
|
|
|
var writableEnded = stream._writableState && stream._writableState.finished;
|
|
|
|
var onfinish = function onfinish() {
|
|
writable = false;
|
|
writableEnded = true;
|
|
if (!readable) callback.call(stream);
|
|
};
|
|
|
|
var readableEnded = stream._readableState && stream._readableState.endEmitted;
|
|
|
|
var onend = function onend() {
|
|
readable = false;
|
|
readableEnded = true;
|
|
if (!writable) callback.call(stream);
|
|
};
|
|
|
|
var onerror = function onerror(err) {
|
|
callback.call(stream, err);
|
|
};
|
|
|
|
var onclose = function onclose() {
|
|
var err;
|
|
|
|
if (readable && !readableEnded) {
|
|
if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
|
return callback.call(stream, err);
|
|
}
|
|
|
|
if (writable && !writableEnded) {
|
|
if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
|
return callback.call(stream, err);
|
|
}
|
|
};
|
|
|
|
var onrequest = function onrequest() {
|
|
stream.req.on('finish', onfinish);
|
|
};
|
|
|
|
if (isRequest(stream)) {
|
|
stream.on('complete', onfinish);
|
|
stream.on('abort', onclose);
|
|
if (stream.req) onrequest();else stream.on('request', onrequest);
|
|
} else if (writable && !stream._writableState) {
|
|
// legacy streams
|
|
stream.on('end', onlegacyfinish);
|
|
stream.on('close', onlegacyfinish);
|
|
}
|
|
|
|
stream.on('end', onend);
|
|
stream.on('finish', onfinish);
|
|
if (opts.error !== false) stream.on('error', onerror);
|
|
stream.on('close', onclose);
|
|
return function () {
|
|
stream.removeListener('complete', onfinish);
|
|
stream.removeListener('abort', onclose);
|
|
stream.removeListener('request', onrequest);
|
|
if (stream.req) stream.req.removeListener('finish', onfinish);
|
|
stream.removeListener('end', onlegacyfinish);
|
|
stream.removeListener('close', onlegacyfinish);
|
|
stream.removeListener('finish', onfinish);
|
|
stream.removeListener('end', onend);
|
|
stream.removeListener('error', onerror);
|
|
stream.removeListener('close', onclose);
|
|
};
|
|
}
|
|
|
|
module.exports = eos;
|
|
},{"../../../errors":45}],55:[function(require,module,exports){
|
|
module.exports = function () {
|
|
throw new Error('Readable.from is not available in the browser')
|
|
};
|
|
|
|
},{}],56:[function(require,module,exports){
|
|
// Ported from https://github.com/mafintosh/pump with
|
|
// permission from the author, Mathias Buus (@mafintosh).
|
|
'use strict';
|
|
|
|
var eos;
|
|
|
|
function once(callback) {
|
|
var called = false;
|
|
return function () {
|
|
if (called) return;
|
|
called = true;
|
|
callback.apply(void 0, arguments);
|
|
};
|
|
}
|
|
|
|
var _require$codes = require('../../../errors').codes,
|
|
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
|
|
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
|
|
|
|
function noop(err) {
|
|
// Rethrow the error if it exists to avoid swallowing it
|
|
if (err) throw err;
|
|
}
|
|
|
|
function isRequest(stream) {
|
|
return stream.setHeader && typeof stream.abort === 'function';
|
|
}
|
|
|
|
function destroyer(stream, reading, writing, callback) {
|
|
callback = once(callback);
|
|
var closed = false;
|
|
stream.on('close', function () {
|
|
closed = true;
|
|
});
|
|
if (eos === undefined) eos = require('./end-of-stream');
|
|
eos(stream, {
|
|
readable: reading,
|
|
writable: writing
|
|
}, function (err) {
|
|
if (err) return callback(err);
|
|
closed = true;
|
|
callback();
|
|
});
|
|
var destroyed = false;
|
|
return function (err) {
|
|
if (closed) return;
|
|
if (destroyed) return;
|
|
destroyed = true; // request.destroy just do .end - .abort is what we want
|
|
|
|
if (isRequest(stream)) return stream.abort();
|
|
if (typeof stream.destroy === 'function') return stream.destroy();
|
|
callback(err || new ERR_STREAM_DESTROYED('pipe'));
|
|
};
|
|
}
|
|
|
|
function call(fn) {
|
|
fn();
|
|
}
|
|
|
|
function pipe(from, to) {
|
|
return from.pipe(to);
|
|
}
|
|
|
|
function popCallback(streams) {
|
|
if (!streams.length) return noop;
|
|
if (typeof streams[streams.length - 1] !== 'function') return noop;
|
|
return streams.pop();
|
|
}
|
|
|
|
function pipeline() {
|
|
for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
streams[_key] = arguments[_key];
|
|
}
|
|
|
|
var callback = popCallback(streams);
|
|
if (Array.isArray(streams[0])) streams = streams[0];
|
|
|
|
if (streams.length < 2) {
|
|
throw new ERR_MISSING_ARGS('streams');
|
|
}
|
|
|
|
var error;
|
|
var destroys = streams.map(function (stream, i) {
|
|
var reading = i < streams.length - 1;
|
|
var writing = i > 0;
|
|
return destroyer(stream, reading, writing, function (err) {
|
|
if (!error) error = err;
|
|
if (err) destroys.forEach(call);
|
|
if (reading) return;
|
|
destroys.forEach(call);
|
|
callback(error);
|
|
});
|
|
});
|
|
return streams.reduce(pipe);
|
|
}
|
|
|
|
module.exports = pipeline;
|
|
},{"../../../errors":45,"./end-of-stream":54}],57:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;
|
|
|
|
function highWaterMarkFrom(options, isDuplex, duplexKey) {
|
|
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
|
|
}
|
|
|
|
function getHighWaterMark(state, options, duplexKey, isDuplex) {
|
|
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
|
|
|
|
if (hwm != null) {
|
|
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
|
|
var name = isDuplex ? duplexKey : 'highWaterMark';
|
|
throw new ERR_INVALID_OPT_VALUE(name, hwm);
|
|
}
|
|
|
|
return Math.floor(hwm);
|
|
} // Default value
|
|
|
|
|
|
return state.objectMode ? 16 : 16 * 1024;
|
|
}
|
|
|
|
module.exports = {
|
|
getHighWaterMark: getHighWaterMark
|
|
};
|
|
},{"../../../errors":45}],58:[function(require,module,exports){
|
|
module.exports = require('events').EventEmitter;
|
|
|
|
},{"events":30}],59:[function(require,module,exports){
|
|
exports = module.exports = require('./lib/_stream_readable.js');
|
|
exports.Stream = exports;
|
|
exports.Readable = exports;
|
|
exports.Writable = require('./lib/_stream_writable.js');
|
|
exports.Duplex = require('./lib/_stream_duplex.js');
|
|
exports.Transform = require('./lib/_stream_transform.js');
|
|
exports.PassThrough = require('./lib/_stream_passthrough.js');
|
|
exports.finished = require('./lib/internal/streams/end-of-stream.js');
|
|
exports.pipeline = require('./lib/internal/streams/pipeline.js');
|
|
|
|
},{"./lib/_stream_duplex.js":46,"./lib/_stream_passthrough.js":47,"./lib/_stream_readable.js":48,"./lib/_stream_transform.js":49,"./lib/_stream_writable.js":50,"./lib/internal/streams/end-of-stream.js":54,"./lib/internal/streams/pipeline.js":56}],60:[function(require,module,exports){
|
|
// 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.
|
|
|
|
'use strict';
|
|
|
|
/*<replacement>*/
|
|
|
|
var Buffer = require('safe-buffer').Buffer;
|
|
/*</replacement>*/
|
|
|
|
var isEncoding = Buffer.isEncoding || function (encoding) {
|
|
encoding = '' + encoding;
|
|
switch (encoding && encoding.toLowerCase()) {
|
|
case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
};
|
|
|
|
function _normalizeEncoding(enc) {
|
|
if (!enc) return 'utf8';
|
|
var retried;
|
|
while (true) {
|
|
switch (enc) {
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return 'utf8';
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return 'utf16le';
|
|
case 'latin1':
|
|
case 'binary':
|
|
return 'latin1';
|
|
case 'base64':
|
|
case 'ascii':
|
|
case 'hex':
|
|
return enc;
|
|
default:
|
|
if (retried) return; // undefined
|
|
enc = ('' + enc).toLowerCase();
|
|
retried = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Do not cache `Buffer.isEncoding` when checking encoding names as some
|
|
// modules monkey-patch it to support additional encodings
|
|
function normalizeEncoding(enc) {
|
|
var nenc = _normalizeEncoding(enc);
|
|
if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
|
|
return nenc || enc;
|
|
}
|
|
|
|
// StringDecoder provides an interface for efficiently splitting a series of
|
|
// buffers into a series of JS strings without breaking apart multi-byte
|
|
// characters.
|
|
exports.StringDecoder = StringDecoder;
|
|
function StringDecoder(encoding) {
|
|
this.encoding = normalizeEncoding(encoding);
|
|
var nb;
|
|
switch (this.encoding) {
|
|
case 'utf16le':
|
|
this.text = utf16Text;
|
|
this.end = utf16End;
|
|
nb = 4;
|
|
break;
|
|
case 'utf8':
|
|
this.fillLast = utf8FillLast;
|
|
nb = 4;
|
|
break;
|
|
case 'base64':
|
|
this.text = base64Text;
|
|
this.end = base64End;
|
|
nb = 3;
|
|
break;
|
|
default:
|
|
this.write = simpleWrite;
|
|
this.end = simpleEnd;
|
|
return;
|
|
}
|
|
this.lastNeed = 0;
|
|
this.lastTotal = 0;
|
|
this.lastChar = Buffer.allocUnsafe(nb);
|
|
}
|
|
|
|
StringDecoder.prototype.write = function (buf) {
|
|
if (buf.length === 0) return '';
|
|
var r;
|
|
var i;
|
|
if (this.lastNeed) {
|
|
r = this.fillLast(buf);
|
|
if (r === undefined) return '';
|
|
i = this.lastNeed;
|
|
this.lastNeed = 0;
|
|
} else {
|
|
i = 0;
|
|
}
|
|
if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
|
|
return r || '';
|
|
};
|
|
|
|
StringDecoder.prototype.end = utf8End;
|
|
|
|
// Returns only complete characters in a Buffer
|
|
StringDecoder.prototype.text = utf8Text;
|
|
|
|
// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
|
|
StringDecoder.prototype.fillLast = function (buf) {
|
|
if (this.lastNeed <= buf.length) {
|
|
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
|
|
this.lastNeed -= buf.length;
|
|
};
|
|
|
|
// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
|
|
// continuation byte. If an invalid byte is detected, -2 is returned.
|
|
function utf8CheckByte(byte) {
|
|
if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
|
|
return byte >> 6 === 0x02 ? -1 : -2;
|
|
}
|
|
|
|
// Checks at most 3 bytes at the end of a Buffer in order to detect an
|
|
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
|
|
// needed to complete the UTF-8 character (if applicable) are returned.
|
|
function utf8CheckIncomplete(self, buf, i) {
|
|
var j = buf.length - 1;
|
|
if (j < i) return 0;
|
|
var nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0) self.lastNeed = nb - 1;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2) return 0;
|
|
nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0) self.lastNeed = nb - 2;
|
|
return nb;
|
|
}
|
|
if (--j < i || nb === -2) return 0;
|
|
nb = utf8CheckByte(buf[j]);
|
|
if (nb >= 0) {
|
|
if (nb > 0) {
|
|
if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
|
|
}
|
|
return nb;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Validates as many continuation bytes for a multi-byte UTF-8 character as
|
|
// needed or are available. If we see a non-continuation byte where we expect
|
|
// one, we "replace" the validated continuation bytes we've seen so far with
|
|
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
|
|
// behavior. The continuation byte check is included three times in the case
|
|
// where all of the continuation bytes for a character exist in the same buffer.
|
|
// It is also done this way as a slight performance increase instead of using a
|
|
// loop.
|
|
function utf8CheckExtraBytes(self, buf, p) {
|
|
if ((buf[0] & 0xC0) !== 0x80) {
|
|
self.lastNeed = 0;
|
|
return '\ufffd';
|
|
}
|
|
if (self.lastNeed > 1 && buf.length > 1) {
|
|
if ((buf[1] & 0xC0) !== 0x80) {
|
|
self.lastNeed = 1;
|
|
return '\ufffd';
|
|
}
|
|
if (self.lastNeed > 2 && buf.length > 2) {
|
|
if ((buf[2] & 0xC0) !== 0x80) {
|
|
self.lastNeed = 2;
|
|
return '\ufffd';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
|
|
function utf8FillLast(buf) {
|
|
var p = this.lastTotal - this.lastNeed;
|
|
var r = utf8CheckExtraBytes(this, buf, p);
|
|
if (r !== undefined) return r;
|
|
if (this.lastNeed <= buf.length) {
|
|
buf.copy(this.lastChar, p, 0, this.lastNeed);
|
|
return this.lastChar.toString(this.encoding, 0, this.lastTotal);
|
|
}
|
|
buf.copy(this.lastChar, p, 0, buf.length);
|
|
this.lastNeed -= buf.length;
|
|
}
|
|
|
|
// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
|
|
// partial character, the character's bytes are buffered until the required
|
|
// number of bytes are available.
|
|
function utf8Text(buf, i) {
|
|
var total = utf8CheckIncomplete(this, buf, i);
|
|
if (!this.lastNeed) return buf.toString('utf8', i);
|
|
this.lastTotal = total;
|
|
var end = buf.length - (total - this.lastNeed);
|
|
buf.copy(this.lastChar, 0, end);
|
|
return buf.toString('utf8', i, end);
|
|
}
|
|
|
|
// For UTF-8, a replacement character is added when ending on a partial
|
|
// character.
|
|
function utf8End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : '';
|
|
if (this.lastNeed) return r + '\ufffd';
|
|
return r;
|
|
}
|
|
|
|
// UTF-16LE typically needs two bytes per character, but even if we have an even
|
|
// number of bytes available, we need to check if we end on a leading/high
|
|
// surrogate. In that case, we need to wait for the next two bytes in order to
|
|
// decode the last character properly.
|
|
function utf16Text(buf, i) {
|
|
if ((buf.length - i) % 2 === 0) {
|
|
var r = buf.toString('utf16le', i);
|
|
if (r) {
|
|
var c = r.charCodeAt(r.length - 1);
|
|
if (c >= 0xD800 && c <= 0xDBFF) {
|
|
this.lastNeed = 2;
|
|
this.lastTotal = 4;
|
|
this.lastChar[0] = buf[buf.length - 2];
|
|
this.lastChar[1] = buf[buf.length - 1];
|
|
return r.slice(0, -1);
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
this.lastNeed = 1;
|
|
this.lastTotal = 2;
|
|
this.lastChar[0] = buf[buf.length - 1];
|
|
return buf.toString('utf16le', i, buf.length - 1);
|
|
}
|
|
|
|
// For UTF-16LE we do not explicitly append special replacement characters if we
|
|
// end on a partial character, we simply let v8 handle that.
|
|
function utf16End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : '';
|
|
if (this.lastNeed) {
|
|
var end = this.lastTotal - this.lastNeed;
|
|
return r + this.lastChar.toString('utf16le', 0, end);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
function base64Text(buf, i) {
|
|
var n = (buf.length - i) % 3;
|
|
if (n === 0) return buf.toString('base64', i);
|
|
this.lastNeed = 3 - n;
|
|
this.lastTotal = 3;
|
|
if (n === 1) {
|
|
this.lastChar[0] = buf[buf.length - 1];
|
|
} else {
|
|
this.lastChar[0] = buf[buf.length - 2];
|
|
this.lastChar[1] = buf[buf.length - 1];
|
|
}
|
|
return buf.toString('base64', i, buf.length - n);
|
|
}
|
|
|
|
function base64End(buf) {
|
|
var r = buf && buf.length ? this.write(buf) : '';
|
|
if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
|
|
return r;
|
|
}
|
|
|
|
// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
|
|
function simpleWrite(buf) {
|
|
return buf.toString(this.encoding);
|
|
}
|
|
|
|
function simpleEnd(buf) {
|
|
return buf && buf.length ? this.write(buf) : '';
|
|
}
|
|
},{"safe-buffer":40}],61:[function(require,module,exports){
|
|
// 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.
|
|
|
|
'use strict';
|
|
|
|
var punycode = require('punycode');
|
|
var util = require('./util');
|
|
|
|
exports.parse = urlParse;
|
|
exports.resolve = urlResolve;
|
|
exports.resolveObject = urlResolveObject;
|
|
exports.format = urlFormat;
|
|
|
|
exports.Url = Url;
|
|
|
|
function Url() {
|
|
this.protocol = null;
|
|
this.slashes = null;
|
|
this.auth = null;
|
|
this.host = null;
|
|
this.port = null;
|
|
this.hostname = null;
|
|
this.hash = null;
|
|
this.search = null;
|
|
this.query = null;
|
|
this.pathname = null;
|
|
this.path = null;
|
|
this.href = null;
|
|
}
|
|
|
|
// Reference: RFC 3986, RFC 1808, RFC 2396
|
|
|
|
// define these here so at least they only have to be
|
|
// compiled once on the first module load.
|
|
var protocolPattern = /^([a-z0-9.+-]+:)/i,
|
|
portPattern = /:[0-9]*$/,
|
|
|
|
// Special case for a simple path URL
|
|
simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
|
|
|
|
// RFC 2396: characters reserved for delimiting URLs.
|
|
// We actually just auto-escape these.
|
|
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
|
|
|
|
// RFC 2396: characters not allowed for various reasons.
|
|
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
|
|
|
|
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
|
|
autoEscape = ['\''].concat(unwise),
|
|
// Characters that are never ever allowed in a hostname.
|
|
// Note that any invalid chars are also handled, but these
|
|
// are the ones that are *expected* to be seen, so we fast-path
|
|
// them.
|
|
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
|
|
hostEndingChars = ['/', '?', '#'],
|
|
hostnameMaxLen = 255,
|
|
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
|
|
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
|
|
// protocols that can allow "unsafe" and "unwise" chars.
|
|
unsafeProtocol = {
|
|
'javascript': true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that never have a hostname.
|
|
hostlessProtocol = {
|
|
'javascript': true,
|
|
'javascript:': true
|
|
},
|
|
// protocols that always contain a // bit.
|
|
slashedProtocol = {
|
|
'http': true,
|
|
'https': true,
|
|
'ftp': true,
|
|
'gopher': true,
|
|
'file': true,
|
|
'http:': true,
|
|
'https:': true,
|
|
'ftp:': true,
|
|
'gopher:': true,
|
|
'file:': true
|
|
},
|
|
querystring = require('querystring');
|
|
|
|
function urlParse(url, parseQueryString, slashesDenoteHost) {
|
|
if (url && util.isObject(url) && url instanceof Url) return url;
|
|
|
|
var u = new Url;
|
|
u.parse(url, parseQueryString, slashesDenoteHost);
|
|
return u;
|
|
}
|
|
|
|
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
|
|
if (!util.isString(url)) {
|
|
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
|
|
}
|
|
|
|
// Copy chrome, IE, opera backslash-handling behavior.
|
|
// Back slashes before the query string get converted to forward slashes
|
|
// See: https://code.google.com/p/chromium/issues/detail?id=25916
|
|
var queryIndex = url.indexOf('?'),
|
|
splitter =
|
|
(queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
|
|
uSplit = url.split(splitter),
|
|
slashRegex = /\\/g;
|
|
uSplit[0] = uSplit[0].replace(slashRegex, '/');
|
|
url = uSplit.join(splitter);
|
|
|
|
var rest = url;
|
|
|
|
// trim before proceeding.
|
|
// This is to support parse stuff like " http://foo.com \n"
|
|
rest = rest.trim();
|
|
|
|
if (!slashesDenoteHost && url.split('#').length === 1) {
|
|
// Try fast path regexp
|
|
var simplePath = simplePathPattern.exec(rest);
|
|
if (simplePath) {
|
|
this.path = rest;
|
|
this.href = rest;
|
|
this.pathname = simplePath[1];
|
|
if (simplePath[2]) {
|
|
this.search = simplePath[2];
|
|
if (parseQueryString) {
|
|
this.query = querystring.parse(this.search.substr(1));
|
|
} else {
|
|
this.query = this.search.substr(1);
|
|
}
|
|
} else if (parseQueryString) {
|
|
this.search = '';
|
|
this.query = {};
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
|
|
var proto = protocolPattern.exec(rest);
|
|
if (proto) {
|
|
proto = proto[0];
|
|
var lowerProto = proto.toLowerCase();
|
|
this.protocol = lowerProto;
|
|
rest = rest.substr(proto.length);
|
|
}
|
|
|
|
// figure out if it's got a host
|
|
// user@server is *always* interpreted as a hostname, and url
|
|
// resolution will treat //foo/bar as host=foo,path=bar because that's
|
|
// how the browser resolves relative URLs.
|
|
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
|
|
var slashes = rest.substr(0, 2) === '//';
|
|
if (slashes && !(proto && hostlessProtocol[proto])) {
|
|
rest = rest.substr(2);
|
|
this.slashes = true;
|
|
}
|
|
}
|
|
|
|
if (!hostlessProtocol[proto] &&
|
|
(slashes || (proto && !slashedProtocol[proto]))) {
|
|
|
|
// there's a hostname.
|
|
// the first instance of /, ?, ;, or # ends the host.
|
|
//
|
|
// If there is an @ in the hostname, then non-host chars *are* allowed
|
|
// to the left of the last @ sign, unless some host-ending character
|
|
// comes *before* the @-sign.
|
|
// URLs are obnoxious.
|
|
//
|
|
// ex:
|
|
// http://a@b@c/ => user:a@b host:c
|
|
// http://a@b?@c => user:a host:c path:/?@c
|
|
|
|
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
|
|
// Review our test case against browsers more comprehensively.
|
|
|
|
// find the first instance of any hostEndingChars
|
|
var hostEnd = -1;
|
|
for (var i = 0; i < hostEndingChars.length; i++) {
|
|
var hec = rest.indexOf(hostEndingChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
|
hostEnd = hec;
|
|
}
|
|
|
|
// at this point, either we have an explicit point where the
|
|
// auth portion cannot go past, or the last @ char is the decider.
|
|
var auth, atSign;
|
|
if (hostEnd === -1) {
|
|
// atSign can be anywhere.
|
|
atSign = rest.lastIndexOf('@');
|
|
} else {
|
|
// atSign must be in auth portion.
|
|
// http://a@b/c@d => host:b auth:a path:/c@d
|
|
atSign = rest.lastIndexOf('@', hostEnd);
|
|
}
|
|
|
|
// Now we have a portion which is definitely the auth.
|
|
// Pull that off.
|
|
if (atSign !== -1) {
|
|
auth = rest.slice(0, atSign);
|
|
rest = rest.slice(atSign + 1);
|
|
this.auth = decodeURIComponent(auth);
|
|
}
|
|
|
|
// the host is the remaining to the left of the first non-host char
|
|
hostEnd = -1;
|
|
for (var i = 0; i < nonHostChars.length; i++) {
|
|
var hec = rest.indexOf(nonHostChars[i]);
|
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
|
hostEnd = hec;
|
|
}
|
|
// if we still have not hit it, then the entire thing is a host.
|
|
if (hostEnd === -1)
|
|
hostEnd = rest.length;
|
|
|
|
this.host = rest.slice(0, hostEnd);
|
|
rest = rest.slice(hostEnd);
|
|
|
|
// pull out port.
|
|
this.parseHost();
|
|
|
|
// we've indicated that there is a hostname,
|
|
// so even if it's empty, it has to be present.
|
|
this.hostname = this.hostname || '';
|
|
|
|
// if hostname begins with [ and ends with ]
|
|
// assume that it's an IPv6 address.
|
|
var ipv6Hostname = this.hostname[0] === '[' &&
|
|
this.hostname[this.hostname.length - 1] === ']';
|
|
|
|
// validate a little.
|
|
if (!ipv6Hostname) {
|
|
var hostparts = this.hostname.split(/\./);
|
|
for (var i = 0, l = hostparts.length; i < l; i++) {
|
|
var part = hostparts[i];
|
|
if (!part) continue;
|
|
if (!part.match(hostnamePartPattern)) {
|
|
var newpart = '';
|
|
for (var j = 0, k = part.length; j < k; j++) {
|
|
if (part.charCodeAt(j) > 127) {
|
|
// we replace non-ASCII char with a temporary placeholder
|
|
// we need this to make sure size of hostname is not
|
|
// broken by replacing non-ASCII by nothing
|
|
newpart += 'x';
|
|
} else {
|
|
newpart += part[j];
|
|
}
|
|
}
|
|
// we test again with ASCII char only
|
|
if (!newpart.match(hostnamePartPattern)) {
|
|
var validParts = hostparts.slice(0, i);
|
|
var notHost = hostparts.slice(i + 1);
|
|
var bit = part.match(hostnamePartStart);
|
|
if (bit) {
|
|
validParts.push(bit[1]);
|
|
notHost.unshift(bit[2]);
|
|
}
|
|
if (notHost.length) {
|
|
rest = '/' + notHost.join('.') + rest;
|
|
}
|
|
this.hostname = validParts.join('.');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.hostname.length > hostnameMaxLen) {
|
|
this.hostname = '';
|
|
} else {
|
|
// hostnames are always lower case.
|
|
this.hostname = this.hostname.toLowerCase();
|
|
}
|
|
|
|
if (!ipv6Hostname) {
|
|
// IDNA Support: Returns a punycoded representation of "domain".
|
|
// It only converts parts of the domain name that
|
|
// have non-ASCII characters, i.e. it doesn't matter if
|
|
// you call it with a domain that already is ASCII-only.
|
|
this.hostname = punycode.toASCII(this.hostname);
|
|
}
|
|
|
|
var p = this.port ? ':' + this.port : '';
|
|
var h = this.hostname || '';
|
|
this.host = h + p;
|
|
this.href += this.host;
|
|
|
|
// strip [ and ] from the hostname
|
|
// the host field still retains them, though
|
|
if (ipv6Hostname) {
|
|
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
|
|
if (rest[0] !== '/') {
|
|
rest = '/' + rest;
|
|
}
|
|
}
|
|
}
|
|
|
|
// now rest is set to the post-host stuff.
|
|
// chop off any delim chars.
|
|
if (!unsafeProtocol[lowerProto]) {
|
|
|
|
// First, make 100% sure that any "autoEscape" chars get
|
|
// escaped, even if encodeURIComponent doesn't think they
|
|
// need to be.
|
|
for (var i = 0, l = autoEscape.length; i < l; i++) {
|
|
var ae = autoEscape[i];
|
|
if (rest.indexOf(ae) === -1)
|
|
continue;
|
|
var esc = encodeURIComponent(ae);
|
|
if (esc === ae) {
|
|
esc = escape(ae);
|
|
}
|
|
rest = rest.split(ae).join(esc);
|
|
}
|
|
}
|
|
|
|
|
|
// chop off from the tail first.
|
|
var hash = rest.indexOf('#');
|
|
if (hash !== -1) {
|
|
// got a fragment string.
|
|
this.hash = rest.substr(hash);
|
|
rest = rest.slice(0, hash);
|
|
}
|
|
var qm = rest.indexOf('?');
|
|
if (qm !== -1) {
|
|
this.search = rest.substr(qm);
|
|
this.query = rest.substr(qm + 1);
|
|
if (parseQueryString) {
|
|
this.query = querystring.parse(this.query);
|
|
}
|
|
rest = rest.slice(0, qm);
|
|
} else if (parseQueryString) {
|
|
// no query string, but parseQueryString still requested
|
|
this.search = '';
|
|
this.query = {};
|
|
}
|
|
if (rest) this.pathname = rest;
|
|
if (slashedProtocol[lowerProto] &&
|
|
this.hostname && !this.pathname) {
|
|
this.pathname = '/';
|
|
}
|
|
|
|
//to support http.request
|
|
if (this.pathname || this.search) {
|
|
var p = this.pathname || '';
|
|
var s = this.search || '';
|
|
this.path = p + s;
|
|
}
|
|
|
|
// finally, reconstruct the href based on what has been validated.
|
|
this.href = this.format();
|
|
return this;
|
|
};
|
|
|
|
// format a parsed object into a url string
|
|
function urlFormat(obj) {
|
|
// ensure it's an object, and not a string url.
|
|
// If it's an obj, this is a no-op.
|
|
// this way, you can call url_format() on strings
|
|
// to clean up potentially wonky urls.
|
|
if (util.isString(obj)) obj = urlParse(obj);
|
|
if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
|
|
return obj.format();
|
|
}
|
|
|
|
Url.prototype.format = function() {
|
|
var auth = this.auth || '';
|
|
if (auth) {
|
|
auth = encodeURIComponent(auth);
|
|
auth = auth.replace(/%3A/i, ':');
|
|
auth += '@';
|
|
}
|
|
|
|
var protocol = this.protocol || '',
|
|
pathname = this.pathname || '',
|
|
hash = this.hash || '',
|
|
host = false,
|
|
query = '';
|
|
|
|
if (this.host) {
|
|
host = auth + this.host;
|
|
} else if (this.hostname) {
|
|
host = auth + (this.hostname.indexOf(':') === -1 ?
|
|
this.hostname :
|
|
'[' + this.hostname + ']');
|
|
if (this.port) {
|
|
host += ':' + this.port;
|
|
}
|
|
}
|
|
|
|
if (this.query &&
|
|
util.isObject(this.query) &&
|
|
Object.keys(this.query).length) {
|
|
query = querystring.stringify(this.query);
|
|
}
|
|
|
|
var search = this.search || (query && ('?' + query)) || '';
|
|
|
|
if (protocol && protocol.substr(-1) !== ':') protocol += ':';
|
|
|
|
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
|
|
// unless they had them to begin with.
|
|
if (this.slashes ||
|
|
(!protocol || slashedProtocol[protocol]) && host !== false) {
|
|
host = '//' + (host || '');
|
|
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
|
|
} else if (!host) {
|
|
host = '';
|
|
}
|
|
|
|
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
|
|
if (search && search.charAt(0) !== '?') search = '?' + search;
|
|
|
|
pathname = pathname.replace(/[?#]/g, function(match) {
|
|
return encodeURIComponent(match);
|
|
});
|
|
search = search.replace('#', '%23');
|
|
|
|
return protocol + host + pathname + search + hash;
|
|
};
|
|
|
|
function urlResolve(source, relative) {
|
|
return urlParse(source, false, true).resolve(relative);
|
|
}
|
|
|
|
Url.prototype.resolve = function(relative) {
|
|
return this.resolveObject(urlParse(relative, false, true)).format();
|
|
};
|
|
|
|
function urlResolveObject(source, relative) {
|
|
if (!source) return relative;
|
|
return urlParse(source, false, true).resolveObject(relative);
|
|
}
|
|
|
|
Url.prototype.resolveObject = function(relative) {
|
|
if (util.isString(relative)) {
|
|
var rel = new Url();
|
|
rel.parse(relative, false, true);
|
|
relative = rel;
|
|
}
|
|
|
|
var result = new Url();
|
|
var tkeys = Object.keys(this);
|
|
for (var tk = 0; tk < tkeys.length; tk++) {
|
|
var tkey = tkeys[tk];
|
|
result[tkey] = this[tkey];
|
|
}
|
|
|
|
// hash is always overridden, no matter what.
|
|
// even href="" will remove it.
|
|
result.hash = relative.hash;
|
|
|
|
// if the relative url is empty, then there's nothing left to do here.
|
|
if (relative.href === '') {
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
// hrefs like //foo/bar always cut to the protocol.
|
|
if (relative.slashes && !relative.protocol) {
|
|
// take everything except the protocol from relative
|
|
var rkeys = Object.keys(relative);
|
|
for (var rk = 0; rk < rkeys.length; rk++) {
|
|
var rkey = rkeys[rk];
|
|
if (rkey !== 'protocol')
|
|
result[rkey] = relative[rkey];
|
|
}
|
|
|
|
//urlParse appends trailing / to urls like http://www.example.com
|
|
if (slashedProtocol[result.protocol] &&
|
|
result.hostname && !result.pathname) {
|
|
result.path = result.pathname = '/';
|
|
}
|
|
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (relative.protocol && relative.protocol !== result.protocol) {
|
|
// if it's a known url protocol, then changing
|
|
// the protocol does weird things
|
|
// first, if it's not file:, then we MUST have a host,
|
|
// and if there was a path
|
|
// to begin with, then we MUST have a path.
|
|
// if it is file:, then the host is dropped,
|
|
// because that's known to be hostless.
|
|
// anything else is assumed to be absolute.
|
|
if (!slashedProtocol[relative.protocol]) {
|
|
var keys = Object.keys(relative);
|
|
for (var v = 0; v < keys.length; v++) {
|
|
var k = keys[v];
|
|
result[k] = relative[k];
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
result.protocol = relative.protocol;
|
|
if (!relative.host && !hostlessProtocol[relative.protocol]) {
|
|
var relPath = (relative.pathname || '').split('/');
|
|
while (relPath.length && !(relative.host = relPath.shift()));
|
|
if (!relative.host) relative.host = '';
|
|
if (!relative.hostname) relative.hostname = '';
|
|
if (relPath[0] !== '') relPath.unshift('');
|
|
if (relPath.length < 2) relPath.unshift('');
|
|
result.pathname = relPath.join('/');
|
|
} else {
|
|
result.pathname = relative.pathname;
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
result.host = relative.host || '';
|
|
result.auth = relative.auth;
|
|
result.hostname = relative.hostname || relative.host;
|
|
result.port = relative.port;
|
|
// to support http.request
|
|
if (result.pathname || result.search) {
|
|
var p = result.pathname || '';
|
|
var s = result.search || '';
|
|
result.path = p + s;
|
|
}
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
|
|
isRelAbs = (
|
|
relative.host ||
|
|
relative.pathname && relative.pathname.charAt(0) === '/'
|
|
),
|
|
mustEndAbs = (isRelAbs || isSourceAbs ||
|
|
(result.host && relative.pathname)),
|
|
removeAllDots = mustEndAbs,
|
|
srcPath = result.pathname && result.pathname.split('/') || [],
|
|
relPath = relative.pathname && relative.pathname.split('/') || [],
|
|
psychotic = result.protocol && !slashedProtocol[result.protocol];
|
|
|
|
// if the url is a non-slashed url, then relative
|
|
// links like ../.. should be able
|
|
// to crawl up to the hostname, as well. This is strange.
|
|
// result.protocol has already been set by now.
|
|
// Later on, put the first path part into the host field.
|
|
if (psychotic) {
|
|
result.hostname = '';
|
|
result.port = null;
|
|
if (result.host) {
|
|
if (srcPath[0] === '') srcPath[0] = result.host;
|
|
else srcPath.unshift(result.host);
|
|
}
|
|
result.host = '';
|
|
if (relative.protocol) {
|
|
relative.hostname = null;
|
|
relative.port = null;
|
|
if (relative.host) {
|
|
if (relPath[0] === '') relPath[0] = relative.host;
|
|
else relPath.unshift(relative.host);
|
|
}
|
|
relative.host = null;
|
|
}
|
|
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
|
|
}
|
|
|
|
if (isRelAbs) {
|
|
// it's absolute.
|
|
result.host = (relative.host || relative.host === '') ?
|
|
relative.host : result.host;
|
|
result.hostname = (relative.hostname || relative.hostname === '') ?
|
|
relative.hostname : result.hostname;
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
srcPath = relPath;
|
|
// fall through to the dot-handling below.
|
|
} else if (relPath.length) {
|
|
// it's relative
|
|
// throw away the existing file, and take the new path instead.
|
|
if (!srcPath) srcPath = [];
|
|
srcPath.pop();
|
|
srcPath = srcPath.concat(relPath);
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
} else if (!util.isNullOrUndefined(relative.search)) {
|
|
// just pull out the search.
|
|
// like href='?foo'.
|
|
// Put this after the other two cases because it simplifies the booleans
|
|
if (psychotic) {
|
|
result.hostname = result.host = srcPath.shift();
|
|
//occationaly the auth can get stuck only in host
|
|
//this especially happens in cases like
|
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ?
|
|
result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.host = result.hostname = authInHost.shift();
|
|
}
|
|
}
|
|
result.search = relative.search;
|
|
result.query = relative.query;
|
|
//to support http.request
|
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
|
|
result.path = (result.pathname ? result.pathname : '') +
|
|
(result.search ? result.search : '');
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
if (!srcPath.length) {
|
|
// no path at all. easy.
|
|
// we've already handled the other stuff above.
|
|
result.pathname = null;
|
|
//to support http.request
|
|
if (result.search) {
|
|
result.path = '/' + result.search;
|
|
} else {
|
|
result.path = null;
|
|
}
|
|
result.href = result.format();
|
|
return result;
|
|
}
|
|
|
|
// if a url ENDs in . or .., then it must get a trailing slash.
|
|
// however, if it ends in anything else non-slashy,
|
|
// then it must NOT get a trailing slash.
|
|
var last = srcPath.slice(-1)[0];
|
|
var hasTrailingSlash = (
|
|
(result.host || relative.host || srcPath.length > 1) &&
|
|
(last === '.' || last === '..') || last === '');
|
|
|
|
// strip single dots, resolve double dots to parent dir
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
var up = 0;
|
|
for (var i = srcPath.length; i >= 0; i--) {
|
|
last = srcPath[i];
|
|
if (last === '.') {
|
|
srcPath.splice(i, 1);
|
|
} else if (last === '..') {
|
|
srcPath.splice(i, 1);
|
|
up++;
|
|
} else if (up) {
|
|
srcPath.splice(i, 1);
|
|
up--;
|
|
}
|
|
}
|
|
|
|
// if the path is allowed to go above the root, restore leading ..s
|
|
if (!mustEndAbs && !removeAllDots) {
|
|
for (; up--; up) {
|
|
srcPath.unshift('..');
|
|
}
|
|
}
|
|
|
|
if (mustEndAbs && srcPath[0] !== '' &&
|
|
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
|
|
srcPath.push('');
|
|
}
|
|
|
|
var isAbsolute = srcPath[0] === '' ||
|
|
(srcPath[0] && srcPath[0].charAt(0) === '/');
|
|
|
|
// put the host back
|
|
if (psychotic) {
|
|
result.hostname = result.host = isAbsolute ? '' :
|
|
srcPath.length ? srcPath.shift() : '';
|
|
//occationaly the auth can get stuck only in host
|
|
//this especially happens in cases like
|
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
|
var authInHost = result.host && result.host.indexOf('@') > 0 ?
|
|
result.host.split('@') : false;
|
|
if (authInHost) {
|
|
result.auth = authInHost.shift();
|
|
result.host = result.hostname = authInHost.shift();
|
|
}
|
|
}
|
|
|
|
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
|
|
|
|
if (mustEndAbs && !isAbsolute) {
|
|
srcPath.unshift('');
|
|
}
|
|
|
|
if (!srcPath.length) {
|
|
result.pathname = null;
|
|
result.path = null;
|
|
} else {
|
|
result.pathname = srcPath.join('/');
|
|
}
|
|
|
|
//to support request.http
|
|
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
|
|
result.path = (result.pathname ? result.pathname : '') +
|
|
(result.search ? result.search : '');
|
|
}
|
|
result.auth = relative.auth || result.auth;
|
|
result.slashes = result.slashes || relative.slashes;
|
|
result.href = result.format();
|
|
return result;
|
|
};
|
|
|
|
Url.prototype.parseHost = function() {
|
|
var host = this.host;
|
|
var port = portPattern.exec(host);
|
|
if (port) {
|
|
port = port[0];
|
|
if (port !== ':') {
|
|
this.port = port.substr(1);
|
|
}
|
|
host = host.substr(0, host.length - port.length);
|
|
}
|
|
if (host) this.hostname = host;
|
|
};
|
|
|
|
},{"./util":62,"punycode":36,"querystring":39}],62:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = {
|
|
isString: function(arg) {
|
|
return typeof(arg) === 'string';
|
|
},
|
|
isObject: function(arg) {
|
|
return typeof(arg) === 'object' && arg !== null;
|
|
},
|
|
isNull: function(arg) {
|
|
return arg === null;
|
|
},
|
|
isNullOrUndefined: function(arg) {
|
|
return arg == null;
|
|
}
|
|
};
|
|
|
|
},{}],63:[function(require,module,exports){
|
|
(function (global){
|
|
|
|
/**
|
|
* Module exports.
|
|
*/
|
|
|
|
module.exports = deprecate;
|
|
|
|
/**
|
|
* Mark that a method should not be used.
|
|
* Returns a modified function which warns once by default.
|
|
*
|
|
* If `localStorage.noDeprecation = true` is set, then it is a no-op.
|
|
*
|
|
* If `localStorage.throwDeprecation = true` is set, then deprecated functions
|
|
* will throw an Error when invoked.
|
|
*
|
|
* If `localStorage.traceDeprecation = true` is set, then deprecated functions
|
|
* will invoke `console.trace()` instead of `console.error()`.
|
|
*
|
|
* @param {Function} fn - the function to deprecate
|
|
* @param {String} msg - the string to print to the console when `fn` is invoked
|
|
* @returns {Function} a new "deprecated" version of `fn`
|
|
* @api public
|
|
*/
|
|
|
|
function deprecate (fn, msg) {
|
|
if (config('noDeprecation')) {
|
|
return fn;
|
|
}
|
|
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (config('throwDeprecation')) {
|
|
throw new Error(msg);
|
|
} else if (config('traceDeprecation')) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.warn(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
}
|
|
|
|
/**
|
|
* Checks `localStorage` for boolean values for the given `name`.
|
|
*
|
|
* @param {String} name
|
|
* @returns {Boolean}
|
|
* @api private
|
|
*/
|
|
|
|
function config (name) {
|
|
// accessing global.localStorage can trigger a DOMException in sandboxed iframes
|
|
try {
|
|
if (!global.localStorage) return false;
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
var val = global.localStorage[name];
|
|
if (null == val) return false;
|
|
return String(val).toLowerCase() === 'true';
|
|
}
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],64:[function(require,module,exports){
|
|
module.exports = extend
|
|
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
|
function extend() {
|
|
var target = {}
|
|
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var source = arguments[i]
|
|
|
|
for (var key in source) {
|
|
if (hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key]
|
|
}
|
|
}
|
|
}
|
|
|
|
return target
|
|
}
|
|
|
|
},{}]},{},[24]);
|