/*! * HTMLMinifier v4.0.0 (https://kangax.github.io/html-minifier/) * Copyright 2010-2019 Juriy "kangax" Zaytsev * Licensed under the MIT license */ let globalMinify; require = (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) { "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; for (var 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(""); } }, {} ], 2: [function(require, module, exports) {}, {}], 3: [ function(require, module, exports) { arguments[4][2][0].apply(exports, arguments); }, { dup: 2 } ], 4: [ function(require, module, exports) { (function(Buffer) { /*! * The buffer module from node.js, for the browser. * * @author Feross Aboukhadijeh * @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.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.4028234663852886e38, -3.4028234663852886e38 ); } 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.7976931348623157e308, -1.7976931348623157e308 ); } 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": 1, buffer: 4, ieee754: 105 } ], 5: [ 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" }; }, {} ], 6: [ function(require, module, exports) { module.exports = require("./lib/clean"); }, { "./lib/clean": 7 } ], 7: [ function(require, module, exports) { (function(process) { /** * Clean-css - https://github.com/jakubpawlowicz/clean-css * Released under the terms of MIT license * * Copyright (C) 2017 JakubPawlowicz.com */ var level0Optimize = require("./optimizer/level-0/optimize"); var level1Optimize = require("./optimizer/level-1/optimize"); var level2Optimize = require("./optimizer/level-2/optimize"); var validator = require("./optimizer/validator"); var compatibilityFrom = require("./options/compatibility"); var fetchFrom = require("./options/fetch"); var formatFrom = require("./options/format").formatFrom; var inlineFrom = require("./options/inline"); var inlineRequestFrom = require("./options/inline-request"); var inlineTimeoutFrom = require("./options/inline-timeout"); var OptimizationLevel = require("./options/optimization-level") .OptimizationLevel; var optimizationLevelFrom = require("./options/optimization-level") .optimizationLevelFrom; var rebaseFrom = require("./options/rebase"); var rebaseToFrom = require("./options/rebase-to"); var inputSourceMapTracker = require("./reader/input-source-map-tracker"); var readSources = require("./reader/read-sources"); var serializeStyles = require("./writer/simple"); var serializeStylesAndSourceMap = require("./writer/source-maps"); var CleanCSS = (module.exports = function CleanCSS(options) { options = options || {}; this.options = { compatibility: compatibilityFrom(options.compatibility), fetch: fetchFrom(options.fetch), format: formatFrom(options.format), inline: inlineFrom(options.inline), inlineRequest: inlineRequestFrom(options.inlineRequest), inlineTimeout: inlineTimeoutFrom(options.inlineTimeout), level: optimizationLevelFrom(options.level), rebase: rebaseFrom(options.rebase), rebaseTo: rebaseToFrom(options.rebaseTo), returnPromise: !!options.returnPromise, sourceMap: !!options.sourceMap, sourceMapInlineSources: !!options.sourceMapInlineSources }; }); // for compatibility with optimize-css-assets-webpack-plugin CleanCSS.process = function(input, opts) { var cleanCss; var optsTo = opts.to; delete opts.to; cleanCss = new CleanCSS( Object.assign({ returnPromise: true, rebaseTo: optsTo }, opts) ); return cleanCss.minify(input).then(function(output) { return { css: output.styles }; }); }; CleanCSS.prototype.minify = function( input, maybeSourceMap, maybeCallback ) { var options = this.options; if (options.returnPromise) { return new Promise(function(resolve, reject) { minify(input, options, maybeSourceMap, function( errors, output ) { return errors ? reject(errors) : resolve(output); }); }); } else { return minify(input, options, maybeSourceMap, maybeCallback); } }; function minify(input, options, maybeSourceMap, maybeCallback) { var sourceMap = typeof maybeSourceMap != "function" ? maybeSourceMap : null; var callback = typeof maybeCallback == "function" ? maybeCallback : typeof maybeSourceMap == "function" ? maybeSourceMap : null; var context = { stats: { efficiency: 0, minifiedSize: 0, originalSize: 0, startedAt: Date.now(), timeSpent: 0 }, cache: { specificity: {} }, errors: [], inlinedStylesheets: [], inputSourceMapTracker: inputSourceMapTracker(), localOnly: !callback, options: options, source: null, sourcesContent: {}, validator: validator(options.compatibility), warnings: [] }; if (sourceMap) { context.inputSourceMapTracker.track(undefined, sourceMap); } return runner(context.localOnly)(function() { return readSources(input, context, function(tokens) { var serialize = context.options.sourceMap ? serializeStylesAndSourceMap : serializeStyles; var optimizedTokens = optimize(tokens, context); var optimizedStyles = serialize(optimizedTokens, context); var output = withMetadata(optimizedStyles, context); return callback ? callback( context.errors.length > 0 ? context.errors : null, output ) : output; }); }); } function runner(localOnly) { // to always execute code asynchronously when a callback is given // more at blog.izs.me/post/59142742143/designing-apis-for-asynchrony return localOnly ? function(callback) { return callback(); } : process.nextTick; } function optimize(tokens, context) { var optimized; optimized = level0Optimize(tokens, context); optimized = OptimizationLevel.One in context.options.level ? level1Optimize(tokens, context) : tokens; optimized = OptimizationLevel.Two in context.options.level ? level2Optimize(tokens, context, true) : optimized; return optimized; } function withMetadata(output, context) { output.stats = calculateStatsFrom(output.styles, context); output.errors = context.errors; output.inlinedStylesheets = context.inlinedStylesheets; output.warnings = context.warnings; return output; } function calculateStatsFrom(styles, context) { var finishedAt = Date.now(); var timeSpent = finishedAt - context.stats.startedAt; delete context.stats.startedAt; context.stats.timeSpent = timeSpent; context.stats.efficiency = 1 - styles.length / context.stats.originalSize; context.stats.minifiedSize = styles.length; return context.stats; } }.call(this, require("_process"))); }, { "./optimizer/level-0/optimize": 9, "./optimizer/level-1/optimize": 10, "./optimizer/level-2/optimize": 29, "./optimizer/validator": 57, "./options/compatibility": 59, "./options/fetch": 60, "./options/format": 61, "./options/inline": 64, "./options/inline-request": 62, "./options/inline-timeout": 63, "./options/optimization-level": 65, "./options/rebase": 67, "./options/rebase-to": 66, "./reader/input-source-map-tracker": 71, "./reader/read-sources": 77, "./writer/simple": 99, "./writer/source-maps": 100, _process: 112 } ], 8: [ function(require, module, exports) { var Hack = { ASTERISK: "asterisk", BANG: "bang", BACKSLASH: "backslash", UNDERSCORE: "underscore" }; module.exports = Hack; }, {} ], 9: [ function(require, module, exports) { function level0Optimize(tokens) { // noop as level 0 means no optimizations! return tokens; } module.exports = level0Optimize; }, {} ], 10: [ function(require, module, exports) { var shortenHex = require("./shorten-hex"); var shortenHsl = require("./shorten-hsl"); var shortenRgb = require("./shorten-rgb"); var sortSelectors = require("./sort-selectors"); var tidyRules = require("./tidy-rules"); var tidyBlock = require("./tidy-block"); var tidyAtRule = require("./tidy-at-rule"); var Hack = require("../hack"); var removeUnused = require("../remove-unused"); var restoreFromOptimizing = require("../restore-from-optimizing"); var wrapForOptimizing = require("../wrap-for-optimizing").all; var OptimizationLevel = require("../../options/optimization-level") .OptimizationLevel; var Token = require("../../tokenizer/token"); var Marker = require("../../tokenizer/marker"); var formatPosition = require("../../utils/format-position"); var split = require("../../utils/split"); var serializeRules = require("../../writer/one-time").rules; var IgnoreProperty = "ignore-property"; var CHARSET_TOKEN = "@charset"; var CHARSET_REGEXP = new RegExp("^" + CHARSET_TOKEN, "i"); var DEFAULT_ROUNDING_PRECISION = require("../../options/rounding-precision") .DEFAULT; var WHOLE_PIXEL_VALUE = /(?:^|\s|\()(-?\d+)px/; var TIME_VALUE = /^(\-?[\d\.]+)(m?s)$/; var HEX_VALUE_PATTERN = /[0-9a-f]/i; var PROPERTY_NAME_PATTERN = /^(?:\-chrome\-|\-[\w\-]+\w|\w[\w\-]+\w|\-\-\S+)$/; var IMPORT_PREFIX_PATTERN = /^@import/i; var QUOTED_PATTERN = /^('.*'|".*")$/; var QUOTED_BUT_SAFE_PATTERN = /^['"][a-zA-Z][a-zA-Z\d\-_]+['"]$/; var URL_PREFIX_PATTERN = /^url\(/i; var VARIABLE_NAME_PATTERN = /^--\S+$/; function isNegative(value) { return value && value[1][0] == "-" && parseFloat(value[1]) < 0; } function isQuoted(value) { return QUOTED_PATTERN.test(value); } function isUrl(value) { return URL_PREFIX_PATTERN.test(value); } function normalizeUrl(value) { return value .replace(URL_PREFIX_PATTERN, "url(") .replace(/\\?\n|\\?\r\n/g, ""); } function optimizeBackground(property) { var values = property.value; if (values.length == 1 && values[0][1] == "none") { values[0][1] = "0 0"; } if (values.length == 1 && values[0][1] == "transparent") { values[0][1] = "0 0"; } } function optimizeBorderRadius(property) { var values = property.value; var spliceAt; if ( values.length == 3 && values[1][1] == "/" && values[0][1] == values[2][1] ) { spliceAt = 1; } else if ( values.length == 5 && values[2][1] == "/" && values[0][1] == values[3][1] && values[1][1] == values[4][1] ) { spliceAt = 2; } else if ( values.length == 7 && values[3][1] == "/" && values[0][1] == values[4][1] && values[1][1] == values[5][1] && values[2][1] == values[6][1] ) { spliceAt = 3; } else if ( values.length == 9 && values[4][1] == "/" && values[0][1] == values[5][1] && values[1][1] == values[6][1] && values[2][1] == values[7][1] && values[3][1] == values[8][1] ) { spliceAt = 4; } if (spliceAt) { property.value.splice(spliceAt); property.dirty = true; } } function optimizeColors(name, value, compatibility) { if ( value.indexOf("#") === -1 && value.indexOf("rgb") == -1 && value.indexOf("hsl") == -1 ) { return shortenHex(value); } value = value .replace(/rgb\((\-?\d+),(\-?\d+),(\-?\d+)\)/g, function( match, red, green, blue ) { return shortenRgb(red, green, blue); }) .replace(/hsl\((-?\d+),(-?\d+)%?,(-?\d+)%?\)/g, function( match, hue, saturation, lightness ) { return shortenHsl(hue, saturation, lightness); }) .replace(/(^|[^='"])#([0-9a-f]{6})/gi, function( match, prefix, color, at, inputValue ) { var suffix = inputValue[at + match.length]; if (suffix && HEX_VALUE_PATTERN.test(suffix)) { return match; } else if ( color[0] == color[1] && color[2] == color[3] && color[4] == color[5] ) { return ( prefix + "#" + color[0] + color[2] + color[4] ).toLowerCase(); } else { return (prefix + "#" + color).toLowerCase(); } }) .replace(/(^|[^='"])#([0-9a-f]{3})/gi, function( match, prefix, color ) { return prefix + "#" + color.toLowerCase(); }) .replace(/(rgb|rgba|hsl|hsla)\(([^\)]+)\)/g, function( match, colorFunction, colorDef ) { var tokens = colorDef.split(","); var applies = (colorFunction == "hsl" && tokens.length == 3) || (colorFunction == "hsla" && tokens.length == 4) || (colorFunction == "rgb" && tokens.length == 3 && colorDef.indexOf("%") > 0) || (colorFunction == "rgba" && tokens.length == 4 && colorDef.indexOf("%") > 0); if (!applies) { return match; } if (tokens[1].indexOf("%") == -1) { tokens[1] += "%"; } if (tokens[2].indexOf("%") == -1) { tokens[2] += "%"; } return colorFunction + "(" + tokens.join(",") + ")"; }); if ( compatibility.colors.opacity && name.indexOf("background") == -1 ) { value = value.replace(/(?:rgba|hsla)\(0,0%?,0%?,0\)/g, function( match ) { if ( split(value, ",") .pop() .indexOf("gradient(") > -1 ) { return match; } return "transparent"; }); } return shortenHex(value); } function optimizeFilter(property) { if (property.value.length == 1) { property.value[0][1] = property.value[0][1].replace( /progid:DXImageTransform\.Microsoft\.(Alpha|Chroma)(\W)/, function(match, filter, suffix) { return filter.toLowerCase() + suffix; } ); } property.value[0][1] = property.value[0][1] .replace(/,(\S)/g, ", $1") .replace(/ ?= ?/g, "="); } function optimizeFontWeight(property, atIndex) { var value = property.value[atIndex][1]; if (value == "normal") { value = "400"; } else if (value == "bold") { value = "700"; } property.value[atIndex][1] = value; } function optimizeMultipleZeros(property) { var values = property.value; var spliceAt; if ( values.length == 4 && values[0][1] === "0" && values[1][1] === "0" && values[2][1] === "0" && values[3][1] === "0" ) { if (property.name.indexOf("box-shadow") > -1) { spliceAt = 2; } else { spliceAt = 1; } } if (spliceAt) { property.value.splice(spliceAt); property.dirty = true; } } function optimizeOutline(property) { var values = property.value; if (values.length == 1 && values[0][1] == "none") { values[0][1] = "0"; } } function optimizePixelLengths(_, value, compatibility) { if (!WHOLE_PIXEL_VALUE.test(value)) { return value; } return value.replace(WHOLE_PIXEL_VALUE, function(match, val) { var newValue; var intVal = parseInt(val); if (intVal === 0) { return match; } if ( compatibility.properties.shorterLengthUnits && compatibility.units.pt && (intVal * 3) % 4 === 0 ) { newValue = (intVal * 3) / 4 + "pt"; } if ( compatibility.properties.shorterLengthUnits && compatibility.units.pc && intVal % 16 === 0 ) { newValue = intVal / 16 + "pc"; } if ( compatibility.properties.shorterLengthUnits && compatibility.units.in && intVal % 96 === 0 ) { newValue = intVal / 96 + "in"; } if (newValue) { newValue = match.substring(0, match.indexOf(val)) + newValue; } return newValue && newValue.length < match.length ? newValue : match; }); } function optimizePrecision(_, value, precisionOptions) { if (!precisionOptions.enabled || value.indexOf(".") === -1) { return value; } return value .replace(precisionOptions.decimalPointMatcher, "$1$2$3") .replace(precisionOptions.zeroMatcher, function( match, integerPart, fractionPart, unit ) { var multiplier = precisionOptions.units[unit].multiplier; var parsedInteger = parseInt(integerPart); var integer = isNaN(parsedInteger) ? 0 : parsedInteger; var fraction = parseFloat(fractionPart); return ( Math.round((integer + fraction) * multiplier) / multiplier + unit ); }); } function optimizeTimeUnits(_, value) { if (!TIME_VALUE.test(value)) return value; return value.replace(TIME_VALUE, function(match, val, unit) { var newValue; if (unit == "ms") { newValue = parseInt(val) / 1000 + "s"; } else if (unit == "s") { newValue = parseFloat(val) * 1000 + "ms"; } return newValue.length < match.length ? newValue : match; }); } function optimizeUnits(name, value, unitsRegexp) { if ( /^(?:\-moz\-calc|\-webkit\-calc|calc|rgb|hsl|rgba|hsla)\(/.test( value ) ) { return value; } if ( name == "flex" || name == "-ms-flex" || name == "-webkit-flex" || name == "flex-basis" || name == "-webkit-flex-basis" ) { return value; } if ( value.indexOf("%") > 0 && (name == "height" || name == "max-height" || name == "width" || name == "max-width") ) { return value; } return value .replace(unitsRegexp, "$1" + "0" + "$2") .replace(unitsRegexp, "$1" + "0" + "$2"); } function optimizeWhitespace(name, value) { if ( name.indexOf("filter") > -1 || value.indexOf(" ") == -1 || value.indexOf("expression") === 0 ) { return value; } if ( value.indexOf(Marker.SINGLE_QUOTE) > -1 || value.indexOf(Marker.DOUBLE_QUOTE) > -1 ) { return value; } value = value.replace(/\s+/g, " "); if (value.indexOf("calc") > -1) { value = value.replace(/\) ?\/ ?/g, ")/ "); } return value .replace(/(\(;?)\s+/g, "$1") .replace(/\s+(;?\))/g, "$1") .replace(/, /g, ","); } function optimizeZeroDegUnit(_, value) { if (value.indexOf("0deg") == -1) { return value; } return value.replace(/\(0deg\)/g, "(0)"); } function optimizeZeroUnits(name, value) { if (value.indexOf("0") == -1) { return value; } if (value.indexOf("-") > -1) { value = value .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, "$10$2") .replace(/([^\w\d\-]|^)\-0([^\.]|$)/g, "$10$2"); } return value .replace(/(^|\s)0+([1-9])/g, "$1$2") .replace(/(^|\D)\.0+(\D|$)/g, "$10$2") .replace(/(^|\D)\.0+(\D|$)/g, "$10$2") .replace(/\.([1-9]*)0+(\D|$)/g, function( match, nonZeroPart, suffix ) { return (nonZeroPart.length > 0 ? "." : "") + nonZeroPart + suffix; }) .replace(/(^|\D)0\.(\d)/g, "$1.$2"); } function removeQuotes(name, value) { if ( name == "content" || name.indexOf("font-variation-settings") > -1 || name.indexOf("font-feature-settings") > -1 || name.indexOf("grid-") > -1 ) { return value; } return QUOTED_BUT_SAFE_PATTERN.test(value) ? value.substring(1, value.length - 1) : value; } function removeUrlQuotes(value) { return /^url\(['"].+['"]\)$/.test(value) && !/^url\(['"].*[\*\s\(\)'"].*['"]\)$/.test(value) && !/^url\(['"]data:[^;]+;charset/.test(value) ? value.replace(/["']/g, "") : value; } function transformValue( propertyName, propertyValue, rule, transformCallback ) { var selector = serializeRules(rule); var transformedValue = transformCallback( propertyName, propertyValue, selector ); if (transformedValue === undefined) { return propertyValue; } else if (transformedValue === false) { return IgnoreProperty; } else { return transformedValue; } } // function optimizeBody(rule, properties, context) { var options = context.options; var levelOptions = options.level[OptimizationLevel.One]; var property, name, type, value; var valueIsUrl; var propertyToken; var _properties = wrapForOptimizing(properties, true); propertyLoop: for (var i = 0, l = _properties.length; i < l; i++) { property = _properties[i]; name = property.name; if (!PROPERTY_NAME_PATTERN.test(name)) { propertyToken = property.all[property.position]; context.warnings.push( "Invalid property name '" + name + "' at " + formatPosition(propertyToken[1][2][0]) + ". Ignoring." ); property.unused = true; } if (property.value.length === 0) { propertyToken = property.all[property.position]; context.warnings.push( "Empty property '" + name + "' at " + formatPosition(propertyToken[1][2][0]) + ". Ignoring." ); property.unused = true; } if ( property.hack && (((property.hack[0] == Hack.ASTERISK || property.hack[0] == Hack.UNDERSCORE) && !options.compatibility.properties.iePrefixHack) || (property.hack[0] == Hack.BACKSLASH && !options.compatibility.properties.ieSuffixHack) || (property.hack[0] == Hack.BANG && !options.compatibility.properties.ieBangHack)) ) { property.unused = true; } if ( levelOptions.removeNegativePaddings && name.indexOf("padding") === 0 && (isNegative(property.value[0]) || isNegative(property.value[1]) || isNegative(property.value[2]) || isNegative(property.value[3])) ) { property.unused = true; } if ( !options.compatibility.properties.ieFilters && isLegacyFilter(property) ) { property.unused = true; } if (property.unused) { continue; } if (property.block) { optimizeBody(rule, property.value[0][1], context); continue; } if (VARIABLE_NAME_PATTERN.test(name)) { continue; } for (var j = 0, m = property.value.length; j < m; j++) { type = property.value[j][0]; value = property.value[j][1]; valueIsUrl = isUrl(value); if (type == Token.PROPERTY_BLOCK) { property.unused = true; context.warnings.push( "Invalid value token at " + formatPosition(value[0][1][2][0]) + ". Ignoring." ); break; } if (valueIsUrl && !context.validator.isUrl(value)) { property.unused = true; context.warnings.push( "Broken URL '" + value + "' at " + formatPosition(property.value[j][2][0]) + ". Ignoring." ); break; } if (valueIsUrl) { value = levelOptions.normalizeUrls ? normalizeUrl(value) : value; value = !options.compatibility.properties.urlQuotes ? removeUrlQuotes(value) : value; } else if (isQuoted(value)) { value = levelOptions.removeQuotes ? removeQuotes(name, value) : value; } else { value = levelOptions.removeWhitespace ? optimizeWhitespace(name, value) : value; value = optimizePrecision(name, value, options.precision); value = optimizePixelLengths( name, value, options.compatibility ); value = levelOptions.replaceTimeUnits ? optimizeTimeUnits(name, value) : value; value = levelOptions.replaceZeroUnits ? optimizeZeroUnits(name, value) : value; if (options.compatibility.properties.zeroUnits) { value = optimizeZeroDegUnit(name, value); value = optimizeUnits(name, value, options.unitsRegexp); } if (options.compatibility.properties.colors) { value = optimizeColors(name, value, options.compatibility); } } value = transformValue(name, value, rule, levelOptions.transform); if (value === IgnoreProperty) { property.unused = true; continue propertyLoop; } property.value[j][1] = value; } if (levelOptions.replaceMultipleZeros) { optimizeMultipleZeros(property); } if (name == "background" && levelOptions.optimizeBackground) { optimizeBackground(property); } else if ( name.indexOf("border") === 0 && name.indexOf("radius") > 0 && levelOptions.optimizeBorderRadius ) { optimizeBorderRadius(property); } else if ( name == "filter" && levelOptions.optimizeFilter && options.compatibility.properties.ieFilters ) { optimizeFilter(property); } else if ( name == "font-weight" && levelOptions.optimizeFontWeight ) { optimizeFontWeight(property, 0); } else if (name == "outline" && levelOptions.optimizeOutline) { optimizeOutline(property); } } restoreFromOptimizing(_properties); removeUnused(_properties); removeComments(properties, options); } function removeComments(tokens, options) { var token; var i; for (i = 0; i < tokens.length; i++) { token = tokens[i]; if (token[0] != Token.COMMENT) { continue; } optimizeComment(token, options); if (token[1].length === 0) { tokens.splice(i, 1); i--; } } } function optimizeComment(token, options) { if ( token[1][2] == Marker.EXCLAMATION && (options.level[OptimizationLevel.One].specialComments == "all" || options.commentsKept < options.level[OptimizationLevel.One].specialComments) ) { options.commentsKept++; return; } token[1] = []; } function cleanupCharsets(tokens) { var hasCharset = false; for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; if (token[0] != Token.AT_RULE) continue; if (!CHARSET_REGEXP.test(token[1])) continue; if (hasCharset || token[1].indexOf(CHARSET_TOKEN) == -1) { tokens.splice(i, 1); i--; l--; } else { hasCharset = true; tokens.splice(i, 1); tokens.unshift([ Token.AT_RULE, token[1].replace(CHARSET_REGEXP, CHARSET_TOKEN) ]); } } } function buildUnitRegexp(options) { var units = ["px", "em", "ex", "cm", "mm", "in", "pt", "pc", "%"]; var otherUnits = ["ch", "rem", "vh", "vm", "vmax", "vmin", "vw"]; otherUnits.forEach(function(unit) { if (options.compatibility.units[unit]) { units.push(unit); } }); return new RegExp( "(^|\\s|\\(|,)0(?:" + units.join("|") + ")(\\W|$)", "g" ); } function buildPrecisionOptions(roundingPrecision) { var precisionOptions = { matcher: null, units: {} }; var optimizable = []; var unit; var value; for (unit in roundingPrecision) { value = roundingPrecision[unit]; if (value != DEFAULT_ROUNDING_PRECISION) { precisionOptions.units[unit] = {}; precisionOptions.units[unit].value = value; precisionOptions.units[unit].multiplier = Math.pow(10, value); optimizable.push(unit); } } if (optimizable.length > 0) { precisionOptions.enabled = true; precisionOptions.decimalPointMatcher = new RegExp( "(\\d)\\.($|" + optimizable.join("|") + ")($|W)", "g" ); precisionOptions.zeroMatcher = new RegExp( "(\\d*)(\\.\\d+)(" + optimizable.join("|") + ")", "g" ); } return precisionOptions; } function isImport(token) { return IMPORT_PREFIX_PATTERN.test(token[1]); } function isLegacyFilter(property) { var value; if (property.name == "filter" || property.name == "-ms-filter") { value = property.value[0][1]; return ( value.indexOf("progid") > -1 || value.indexOf("alpha") === 0 || value.indexOf("chroma") === 0 ); } else { return false; } } function level1Optimize(tokens, context) { var options = context.options; var levelOptions = options.level[OptimizationLevel.One]; var ie7Hack = options.compatibility.selectors.ie7Hack; var adjacentSpace = options.compatibility.selectors.adjacentSpace; var spaceAfterClosingBrace = options.compatibility.properties.spaceAfterClosingBrace; var format = options.format; var mayHaveCharset = false; var afterRules = false; options.unitsRegexp = options.unitsRegexp || buildUnitRegexp(options); options.precision = options.precision || buildPrecisionOptions(levelOptions.roundingPrecision); options.commentsKept = options.commentsKept || 0; for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; switch (token[0]) { case Token.AT_RULE: token[1] = isImport(token) && afterRules ? "" : token[1]; token[1] = levelOptions.tidyAtRules ? tidyAtRule(token[1]) : token[1]; mayHaveCharset = true; break; case Token.AT_RULE_BLOCK: optimizeBody(token[1], token[2], context); afterRules = true; break; case Token.NESTED_BLOCK: token[1] = levelOptions.tidyBlockScopes ? tidyBlock(token[1], spaceAfterClosingBrace) : token[1]; level1Optimize(token[2], context); afterRules = true; break; case Token.COMMENT: optimizeComment(token, options); break; case Token.RULE: token[1] = levelOptions.tidySelectors ? tidyRules( token[1], !ie7Hack, adjacentSpace, format, context.warnings ) : token[1]; token[1] = token[1].length > 1 ? sortSelectors( token[1], levelOptions.selectorsSortingMethod ) : token[1]; optimizeBody(token[1], token[2], context); afterRules = true; break; } if ( (token[0] == Token.COMMENT && token[1].length === 0) || (levelOptions.removeEmpty && (token[1].length === 0 || (token[2] && token[2].length === 0))) ) { tokens.splice(i, 1); i--; l--; } } if (levelOptions.cleanupCharsets && mayHaveCharset) { cleanupCharsets(tokens); } return tokens; } module.exports = level1Optimize; }, { "../../options/optimization-level": 65, "../../options/rounding-precision": 68, "../../tokenizer/marker": 83, "../../tokenizer/token": 84, "../../utils/format-position": 87, "../../utils/split": 96, "../../writer/one-time": 98, "../hack": 8, "../remove-unused": 55, "../restore-from-optimizing": 56, "../wrap-for-optimizing": 58, "./shorten-hex": 11, "./shorten-hsl": 12, "./shorten-rgb": 13, "./sort-selectors": 14, "./tidy-at-rule": 15, "./tidy-block": 16, "./tidy-rules": 17 } ], 11: [ function(require, module, exports) { var COLORS = { aliceblue: "#f0f8ff", antiquewhite: "#faebd7", aqua: "#0ff", aquamarine: "#7fffd4", azure: "#f0ffff", beige: "#f5f5dc", bisque: "#ffe4c4", black: "#000", blanchedalmond: "#ffebcd", blue: "#00f", blueviolet: "#8a2be2", brown: "#a52a2a", burlywood: "#deb887", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", cornflowerblue: "#6495ed", cornsilk: "#fff8dc", crimson: "#dc143c", cyan: "#0ff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkgray: "#a9a9a9", darkgreen: "#006400", darkgrey: "#a9a9a9", darkkhaki: "#bdb76b", darkmagenta: "#8b008b", darkolivegreen: "#556b2f", darkorange: "#ff8c00", darkorchid: "#9932cc", darkred: "#8b0000", darksalmon: "#e9967a", darkseagreen: "#8fbc8f", darkslateblue: "#483d8b", darkslategray: "#2f4f4f", darkslategrey: "#2f4f4f", darkturquoise: "#00ced1", darkviolet: "#9400d3", deeppink: "#ff1493", deepskyblue: "#00bfff", dimgray: "#696969", dimgrey: "#696969", dodgerblue: "#1e90ff", firebrick: "#b22222", floralwhite: "#fffaf0", forestgreen: "#228b22", fuchsia: "#f0f", gainsboro: "#dcdcdc", ghostwhite: "#f8f8ff", gold: "#ffd700", goldenrod: "#daa520", gray: "#808080", green: "#008000", greenyellow: "#adff2f", grey: "#808080", honeydew: "#f0fff0", hotpink: "#ff69b4", indianred: "#cd5c5c", indigo: "#4b0082", ivory: "#fffff0", khaki: "#f0e68c", lavender: "#e6e6fa", lavenderblush: "#fff0f5", lawngreen: "#7cfc00", lemonchiffon: "#fffacd", lightblue: "#add8e6", lightcoral: "#f08080", lightcyan: "#e0ffff", lightgoldenrodyellow: "#fafad2", lightgray: "#d3d3d3", lightgreen: "#90ee90", lightgrey: "#d3d3d3", lightpink: "#ffb6c1", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", lightskyblue: "#87cefa", lightslategray: "#778899", lightslategrey: "#778899", lightsteelblue: "#b0c4de", lightyellow: "#ffffe0", lime: "#0f0", limegreen: "#32cd32", linen: "#faf0e6", magenta: "#ff00ff", maroon: "#800000", mediumaquamarine: "#66cdaa", mediumblue: "#0000cd", mediumorchid: "#ba55d3", mediumpurple: "#9370db", mediumseagreen: "#3cb371", mediumslateblue: "#7b68ee", mediumspringgreen: "#00fa9a", mediumturquoise: "#48d1cc", mediumvioletred: "#c71585", midnightblue: "#191970", mintcream: "#f5fffa", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", navajowhite: "#ffdead", navy: "#000080", oldlace: "#fdf5e6", olive: "#808000", olivedrab: "#6b8e23", orange: "#ffa500", orangered: "#ff4500", orchid: "#da70d6", palegoldenrod: "#eee8aa", palegreen: "#98fb98", paleturquoise: "#afeeee", palevioletred: "#db7093", papayawhip: "#ffefd5", peachpuff: "#ffdab9", peru: "#cd853f", pink: "#ffc0cb", plum: "#dda0dd", powderblue: "#b0e0e6", purple: "#800080", rebeccapurple: "#663399", red: "#f00", rosybrown: "#bc8f8f", royalblue: "#4169e1", saddlebrown: "#8b4513", salmon: "#fa8072", sandybrown: "#f4a460", seagreen: "#2e8b57", seashell: "#fff5ee", sienna: "#a0522d", silver: "#c0c0c0", skyblue: "#87ceeb", slateblue: "#6a5acd", slategray: "#708090", slategrey: "#708090", snow: "#fffafa", springgreen: "#00ff7f", steelblue: "#4682b4", tan: "#d2b48c", teal: "#008080", thistle: "#d8bfd8", tomato: "#ff6347", turquoise: "#40e0d0", violet: "#ee82ee", wheat: "#f5deb3", white: "#fff", whitesmoke: "#f5f5f5", yellow: "#ff0", yellowgreen: "#9acd32" }; var toHex = {}; var toName = {}; for (var name in COLORS) { var hex = COLORS[name]; if (name.length < hex.length) { toName[hex] = name; } else { toHex[name] = hex; } } var toHexPattern = new RegExp( "(^| |,|\\))(" + Object.keys(toHex).join("|") + ")( |,|\\)|$)", "ig" ); var toNamePattern = new RegExp( "(" + Object.keys(toName).join("|") + ")([^a-f0-9]|$)", "ig" ); function hexConverter(match, prefix, colorValue, suffix) { return prefix + toHex[colorValue.toLowerCase()] + suffix; } function nameConverter(match, colorValue, suffix) { return toName[colorValue.toLowerCase()] + suffix; } function shortenHex(value) { var hasHex = value.indexOf("#") > -1; var shortened = value.replace(toHexPattern, hexConverter); if (shortened != value) { shortened = shortened.replace(toHexPattern, hexConverter); } return hasHex ? shortened.replace(toNamePattern, nameConverter) : shortened; } module.exports = shortenHex; }, {} ], 12: [ function(require, module, exports) { // HSL to RGB converter. Both methods adapted from: // http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript function hslToRgb(h, s, l) { var r, g, b; // normalize hue orientation b/w 0 and 360 degrees h = h % 360; if (h < 0) h += 360; h = ~~h / 360; if (s < 0) s = 0; else if (s > 100) s = 100; s = ~~s / 100; if (l < 0) l = 0; else if (l > 100) l = 100; l = ~~l / 100; if (s === 0) { r = g = b = l; // achromatic } else { var q = l < 0.5 ? l * (1 + s) : l + s - l * s; var p = 2 * l - q; r = hueToRgb(p, q, h + 1 / 3); g = hueToRgb(p, q, h); b = hueToRgb(p, q, h - 1 / 3); } return [~~(r * 255), ~~(g * 255), ~~(b * 255)]; } function hueToRgb(p, q, t) { if (t < 0) t += 1; if (t > 1) t -= 1; if (t < 1 / 6) return p + (q - p) * 6 * t; if (t < 1 / 2) return q; if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6; return p; } function shortenHsl(hue, saturation, lightness) { var asRgb = hslToRgb(hue, saturation, lightness); var redAsHex = asRgb[0].toString(16); var greenAsHex = asRgb[1].toString(16); var blueAsHex = asRgb[2].toString(16); return ( "#" + ((redAsHex.length == 1 ? "0" : "") + redAsHex) + ((greenAsHex.length == 1 ? "0" : "") + greenAsHex) + ((blueAsHex.length == 1 ? "0" : "") + blueAsHex) ); } module.exports = shortenHsl; }, {} ], 13: [ function(require, module, exports) { function shortenRgb(red, green, blue) { var normalizedRed = Math.max(0, Math.min(parseInt(red), 255)); var normalizedGreen = Math.max(0, Math.min(parseInt(green), 255)); var normalizedBlue = Math.max(0, Math.min(parseInt(blue), 255)); // Credit: Asen http://jsbin.com/UPUmaGOc/2/edit?js,console return ( "#" + ( "00000" + ( (normalizedRed << 16) | (normalizedGreen << 8) | normalizedBlue ).toString(16) ).slice(-6) ); } module.exports = shortenRgb; }, {} ], 14: [ function(require, module, exports) { var naturalCompare = require("../../utils/natural-compare"); function naturalSorter(scope1, scope2) { return naturalCompare(scope1[1], scope2[1]); } function standardSorter(scope1, scope2) { return scope1[1] > scope2[1] ? 1 : -1; } function sortSelectors(selectors, method) { switch (method) { case "natural": return selectors.sort(naturalSorter); case "standard": return selectors.sort(standardSorter); case "none": case false: return selectors; } } module.exports = sortSelectors; }, { "../../utils/natural-compare": 94 } ], 15: [ function(require, module, exports) { function tidyAtRule(value) { return value .replace(/\s+/g, " ") .replace(/url\(\s+/g, "url(") .replace(/\s+\)/g, ")") .trim(); } module.exports = tidyAtRule; }, {} ], 16: [ function(require, module, exports) { var SUPPORTED_COMPACT_BLOCK_MATCHER = /^@media\W/; function tidyBlock(values, spaceAfterClosingBrace) { var withoutSpaceAfterClosingBrace; var i; for (i = values.length - 1; i >= 0; i--) { withoutSpaceAfterClosingBrace = !spaceAfterClosingBrace && SUPPORTED_COMPACT_BLOCK_MATCHER.test(values[i][1]); values[i][1] = values[i][1] .replace(/\n|\r\n/g, " ") .replace(/\s+/g, " ") .replace(/(,|:|\() /g, "$1") .replace(/ \)/g, ")") .replace(/'([a-zA-Z][a-zA-Z\d\-_]+)'/, "$1") .replace(/"([a-zA-Z][a-zA-Z\d\-_]+)"/, "$1") .replace(withoutSpaceAfterClosingBrace ? /\) /g : null, ")"); } return values; } module.exports = tidyBlock; }, {} ], 17: [ function(require, module, exports) { var Spaces = require("../../options/format").Spaces; var Marker = require("../../tokenizer/marker"); var formatPosition = require("../../utils/format-position"); var CASE_ATTRIBUTE_PATTERN = /[\s"'][iI]\s*\]/; var CASE_RESTORE_PATTERN = /([\d\w])([iI])\]/g; var DOUBLE_QUOTE_CASE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"([iI])/g; var DOUBLE_QUOTE_PATTERN = /="([a-zA-Z][a-zA-Z\d\-_]+)"(\s|\])/g; var HTML_COMMENT_PATTERN = /^(?:(?:)\s*)+/; var SINGLE_QUOTE_CASE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'([iI])/g; var SINGLE_QUOTE_PATTERN = /='([a-zA-Z][a-zA-Z\d\-_]+)'(\s|\])/g; var RELATION_PATTERN = /[>\+~]/; var WHITESPACE_PATTERN = /\s/; var ASTERISK_PLUS_HTML_HACK = "*+html "; var ASTERISK_FIRST_CHILD_PLUS_HTML_HACK = "*:first-child+html "; var LESS_THAN = "<"; function hasInvalidCharacters(value) { var isEscaped; var isInvalid = false; var character; var isQuote = false; var i, l; for (i = 0, l = value.length; i < l; i++) { character = value[i]; if (isEscaped) { // continue as always } else if ( character == Marker.SINGLE_QUOTE || character == Marker.DOUBLE_QUOTE ) { isQuote = !isQuote; } else if ( !isQuote && (character == Marker.CLOSE_CURLY_BRACKET || character == Marker.EXCLAMATION || character == LESS_THAN || character == Marker.SEMICOLON) ) { isInvalid = true; break; } else if ( !isQuote && i === 0 && RELATION_PATTERN.test(character) ) { isInvalid = true; break; } isEscaped = character == Marker.BACK_SLASH; } return isInvalid; } function removeWhitespace(value, format) { var stripped = []; var character; var isNewLineNix; var isNewLineWin; var isEscaped; var wasEscaped; var isQuoted; var isSingleQuoted; var isDoubleQuoted; var isAttribute; var isRelation; var isWhitespace; var roundBracketLevel = 0; var wasRelation = false; var wasWhitespace = false; var withCaseAttribute = CASE_ATTRIBUTE_PATTERN.test(value); var spaceAroundRelation = format && format.spaces[Spaces.AroundSelectorRelation]; var i, l; for (i = 0, l = value.length; i < l; i++) { character = value[i]; isNewLineNix = character == Marker.NEW_LINE_NIX; isNewLineWin = character == Marker.NEW_LINE_NIX && value[i - 1] == Marker.CARRIAGE_RETURN; isQuoted = isSingleQuoted || isDoubleQuoted; isRelation = !isAttribute && !isEscaped && roundBracketLevel === 0 && RELATION_PATTERN.test(character); isWhitespace = WHITESPACE_PATTERN.test(character); if (wasEscaped && isQuoted && isNewLineWin) { // swallow escaped new windows lines in comments stripped.pop(); stripped.pop(); } else if (isEscaped && isQuoted && isNewLineNix) { // swallow escaped new *nix lines in comments stripped.pop(); } else if (isEscaped) { stripped.push(character); } else if (character == Marker.OPEN_SQUARE_BRACKET && !isQuoted) { stripped.push(character); isAttribute = true; } else if (character == Marker.CLOSE_SQUARE_BRACKET && !isQuoted) { stripped.push(character); isAttribute = false; } else if (character == Marker.OPEN_ROUND_BRACKET && !isQuoted) { stripped.push(character); roundBracketLevel++; } else if (character == Marker.CLOSE_ROUND_BRACKET && !isQuoted) { stripped.push(character); roundBracketLevel--; } else if (character == Marker.SINGLE_QUOTE && !isQuoted) { stripped.push(character); isSingleQuoted = true; } else if (character == Marker.DOUBLE_QUOTE && !isQuoted) { stripped.push(character); isDoubleQuoted = true; } else if (character == Marker.SINGLE_QUOTE && isQuoted) { stripped.push(character); isSingleQuoted = false; } else if (character == Marker.DOUBLE_QUOTE && isQuoted) { stripped.push(character); isDoubleQuoted = false; } else if (isWhitespace && wasRelation && !spaceAroundRelation) { continue; } else if (!isWhitespace && wasRelation && spaceAroundRelation) { stripped.push(Marker.SPACE); stripped.push(character); } else if ( isWhitespace && (isAttribute || roundBracketLevel > 0) && !isQuoted ) { // skip space } else if (isWhitespace && wasWhitespace && !isQuoted) { // skip extra space } else if ( (isNewLineWin || isNewLineNix) && (isAttribute || roundBracketLevel > 0) && isQuoted ) { // skip newline } else if (isRelation && wasWhitespace && !spaceAroundRelation) { stripped.pop(); stripped.push(character); } else if (isRelation && !wasWhitespace && spaceAroundRelation) { stripped.push(Marker.SPACE); stripped.push(character); } else if (isWhitespace) { stripped.push(Marker.SPACE); } else { stripped.push(character); } wasEscaped = isEscaped; isEscaped = character == Marker.BACK_SLASH; wasRelation = isRelation; wasWhitespace = isWhitespace; } return withCaseAttribute ? stripped.join("").replace(CASE_RESTORE_PATTERN, "$1 $2]") : stripped.join(""); } function removeQuotes(value) { if (value.indexOf("'") == -1 && value.indexOf('"') == -1) { return value; } return value .replace(SINGLE_QUOTE_CASE_PATTERN, "=$1 $2") .replace(SINGLE_QUOTE_PATTERN, "=$1$2") .replace(DOUBLE_QUOTE_CASE_PATTERN, "=$1 $2") .replace(DOUBLE_QUOTE_PATTERN, "=$1$2"); } function tidyRules( rules, removeUnsupported, adjacentSpace, format, warnings ) { var list = []; var repeated = []; function removeHTMLComment(rule, match) { warnings.push( "HTML comment '" + match + "' at " + formatPosition(rule[2][0]) + ". Removing." ); return ""; } for (var i = 0, l = rules.length; i < l; i++) { var rule = rules[i]; var reduced = rule[1]; reduced = reduced.replace( HTML_COMMENT_PATTERN, removeHTMLComment.bind(null, rule) ); if (hasInvalidCharacters(reduced)) { warnings.push( "Invalid selector '" + rule[1] + "' at " + formatPosition(rule[2][0]) + ". Ignoring." ); continue; } reduced = removeWhitespace(reduced, format); reduced = removeQuotes(reduced); if (adjacentSpace && reduced.indexOf("nav") > 0) { reduced = reduced.replace(/\+nav(\S|$)/, "+ nav$1"); } if ( removeUnsupported && reduced.indexOf(ASTERISK_PLUS_HTML_HACK) > -1 ) { continue; } if ( removeUnsupported && reduced.indexOf(ASTERISK_FIRST_CHILD_PLUS_HTML_HACK) > -1 ) { continue; } if (reduced.indexOf("*") > -1) { reduced = reduced .replace(/\*([:#\.\[])/g, "$1") .replace(/^(\:first\-child)?\+html/, "*$1+html"); } if (repeated.indexOf(reduced) > -1) { continue; } rule[1] = reduced; repeated.push(reduced); list.push(rule); } if (list.length == 1 && list[0][1].length === 0) { warnings.push( "Empty selector '" + list[0][1] + "' at " + formatPosition(list[0][2][0]) + ". Ignoring." ); list = []; } return list; } module.exports = tidyRules; }, { "../../options/format": 61, "../../tokenizer/marker": 83, "../../utils/format-position": 87 } ], 18: [ function(require, module, exports) { var InvalidPropertyError = require("./invalid-property-error"); var wrapSingle = require("../wrap-for-optimizing").single; var Token = require("../../tokenizer/token"); var Marker = require("../../tokenizer/marker"); var formatPosition = require("../../utils/format-position"); function _anyIsInherit(values) { var i, l; for (i = 0, l = values.length; i < l; i++) { if (values[i][1] == "inherit") { return true; } } return false; } function _colorFilter(validator) { return function(value) { return ( value[1] == "invert" || validator.isColor(value[1]) || validator.isPrefixed(value[1]) ); }; } function _styleFilter(validator) { return function(value) { return ( value[1] != "inherit" && validator.isStyleKeyword(value[1]) && !validator.isColorFunction(value[1]) ); }; } function _wrapDefault(name, property, compactable) { var descriptor = compactable[name]; if (descriptor.doubleValues && descriptor.defaultValue.length == 2) { return wrapSingle([ Token.PROPERTY, [Token.PROPERTY_NAME, name], [Token.PROPERTY_VALUE, descriptor.defaultValue[0]], [Token.PROPERTY_VALUE, descriptor.defaultValue[1]] ]); } else if ( descriptor.doubleValues && descriptor.defaultValue.length == 1 ) { return wrapSingle([ Token.PROPERTY, [Token.PROPERTY_NAME, name], [Token.PROPERTY_VALUE, descriptor.defaultValue[0]] ]); } else { return wrapSingle([ Token.PROPERTY, [Token.PROPERTY_NAME, name], [Token.PROPERTY_VALUE, descriptor.defaultValue] ]); } } function _widthFilter(validator) { return function(value) { return ( value[1] != "inherit" && (validator.isWidth(value[1]) || (validator.isUnit(value[1]) && !validator.isDynamicUnit(value[1]))) && !validator.isStyleKeyword(value[1]) && !validator.isColorFunction(value[1]) ); }; } function animation(property, compactable, validator) { var duration = _wrapDefault( property.name + "-duration", property, compactable ); var timing = _wrapDefault( property.name + "-timing-function", property, compactable ); var delay = _wrapDefault( property.name + "-delay", property, compactable ); var iteration = _wrapDefault( property.name + "-iteration-count", property, compactable ); var direction = _wrapDefault( property.name + "-direction", property, compactable ); var fill = _wrapDefault( property.name + "-fill-mode", property, compactable ); var play = _wrapDefault( property.name + "-play-state", property, compactable ); var name = _wrapDefault( property.name + "-name", property, compactable ); var components = [ duration, timing, delay, iteration, direction, fill, play, name ]; var values = property.value; var value; var durationSet = false; var timingSet = false; var delaySet = false; var iterationSet = false; var directionSet = false; var fillSet = false; var playSet = false; var nameSet = false; var i; var l; if (property.value.length == 1 && property.value[0][1] == "inherit") { duration.value = timing.value = delay.value = iteration.value = direction.value = fill.value = play.value = name.value = property.value; return components; } if (values.length > 1 && _anyIsInherit(values)) { throw new InvalidPropertyError( "Invalid animation values at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } for (i = 0, l = values.length; i < l; i++) { value = values[i]; if (validator.isTime(value[1]) && !durationSet) { duration.value = [value]; durationSet = true; } else if (validator.isTime(value[1]) && !delaySet) { delay.value = [value]; delaySet = true; } else if ( (validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet ) { timing.value = [value]; timingSet = true; } else if ( (validator.isAnimationIterationCountKeyword(value[1]) || validator.isPositiveNumber(value[1])) && !iterationSet ) { iteration.value = [value]; iterationSet = true; } else if ( validator.isAnimationDirectionKeyword(value[1]) && !directionSet ) { direction.value = [value]; directionSet = true; } else if ( validator.isAnimationFillModeKeyword(value[1]) && !fillSet ) { fill.value = [value]; fillSet = true; } else if ( validator.isAnimationPlayStateKeyword(value[1]) && !playSet ) { play.value = [value]; playSet = true; } else if ( (validator.isAnimationNameKeyword(value[1]) || validator.isIdentifier(value[1])) && !nameSet ) { name.value = [value]; nameSet = true; } else { throw new InvalidPropertyError( "Invalid animation value at " + formatPosition(value[2][0]) + ". Ignoring." ); } } return components; } function background(property, compactable, validator) { var image = _wrapDefault("background-image", property, compactable); var position = _wrapDefault( "background-position", property, compactable ); var size = _wrapDefault("background-size", property, compactable); var repeat = _wrapDefault("background-repeat", property, compactable); var attachment = _wrapDefault( "background-attachment", property, compactable ); var origin = _wrapDefault("background-origin", property, compactable); var clip = _wrapDefault("background-clip", property, compactable); var color = _wrapDefault("background-color", property, compactable); var components = [ image, position, size, repeat, attachment, origin, clip, color ]; var values = property.value; var positionSet = false; var clipSet = false; var originSet = false; var repeatSet = false; var anyValueSet = false; if (property.value.length == 1 && property.value[0][1] == "inherit") { // NOTE: 'inherit' is not a valid value for background-attachment color.value = image.value = repeat.value = position.value = size.value = origin.value = clip.value = property.value; return components; } if (property.value.length == 1 && property.value[0][1] == "0 0") { return components; } for (var i = values.length - 1; i >= 0; i--) { var value = values[i]; if (validator.isBackgroundAttachmentKeyword(value[1])) { attachment.value = [value]; anyValueSet = true; } else if ( validator.isBackgroundClipKeyword(value[1]) || validator.isBackgroundOriginKeyword(value[1]) ) { if (clipSet) { origin.value = [value]; originSet = true; } else { clip.value = [value]; clipSet = true; } anyValueSet = true; } else if (validator.isBackgroundRepeatKeyword(value[1])) { if (repeatSet) { repeat.value.unshift(value); } else { repeat.value = [value]; repeatSet = true; } anyValueSet = true; } else if ( validator.isBackgroundPositionKeyword(value[1]) || validator.isBackgroundSizeKeyword(value[1]) || validator.isUnit(value[1]) || validator.isDynamicUnit(value[1]) ) { if (i > 0) { var previousValue = values[i - 1]; if (previousValue[1] == Marker.FORWARD_SLASH) { size.value = [value]; } else if (i > 1 && values[i - 2][1] == Marker.FORWARD_SLASH) { size.value = [previousValue, value]; i -= 2; } else { if (!positionSet) position.value = []; position.value.unshift(value); positionSet = true; } } else { if (!positionSet) position.value = []; position.value.unshift(value); positionSet = true; } anyValueSet = true; } else if ( (color.value[0][1] == compactable[color.name].defaultValue || color.value[0][1] == "none") && (validator.isColor(value[1]) || validator.isPrefixed(value[1])) ) { color.value = [value]; anyValueSet = true; } else if ( validator.isUrl(value[1]) || validator.isFunction(value[1]) ) { image.value = [value]; anyValueSet = true; } } if (clipSet && !originSet) origin.value = clip.value.slice(0); if (!anyValueSet) { throw new InvalidPropertyError( "Invalid background value at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } return components; } function borderRadius(property, compactable) { var values = property.value; var splitAt = -1; for (var i = 0, l = values.length; i < l; i++) { if (values[i][1] == Marker.FORWARD_SLASH) { splitAt = i; break; } } if (splitAt === 0 || splitAt === values.length - 1) { throw new InvalidPropertyError( "Invalid border-radius value at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } var target = _wrapDefault(property.name, property, compactable); target.value = splitAt > -1 ? values.slice(0, splitAt) : values.slice(0); target.components = fourValues(target, compactable); var remainder = _wrapDefault(property.name, property, compactable); remainder.value = splitAt > -1 ? values.slice(splitAt + 1) : values.slice(0); remainder.components = fourValues(remainder, compactable); for (var j = 0; j < 4; j++) { target.components[j].multiplex = true; target.components[j].value = target.components[j].value.concat( remainder.components[j].value ); } return target.components; } function font(property, compactable, validator) { var style = _wrapDefault("font-style", property, compactable); var variant = _wrapDefault("font-variant", property, compactable); var weight = _wrapDefault("font-weight", property, compactable); var stretch = _wrapDefault("font-stretch", property, compactable); var size = _wrapDefault("font-size", property, compactable); var height = _wrapDefault("line-height", property, compactable); var family = _wrapDefault("font-family", property, compactable); var components = [ style, variant, weight, stretch, size, height, family ]; var values = property.value; var fuzzyMatched = 4; // style, variant, weight, and stretch var index = 0; var isStretchSet = false; var isStretchValid; var isStyleSet = false; var isStyleValid; var isVariantSet = false; var isVariantValid; var isWeightSet = false; var isWeightValid; var isSizeSet = false; var appendableFamilyName = false; if (!values[index]) { throw new InvalidPropertyError( "Missing font values at " + formatPosition(property.all[property.position][1][2][0]) + ". Ignoring." ); } if (values.length == 1 && values[0][1] == "inherit") { style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values; return components; } if ( values.length == 1 && (validator.isFontKeyword(values[0][1]) || validator.isGlobal(values[0][1]) || validator.isPrefixed(values[0][1])) ) { values[0][1] = Marker.INTERNAL + values[0][1]; style.value = variant.value = weight.value = stretch.value = size.value = height.value = family.value = values; return components; } if ( values.length < 2 || !_anyIsFontSize(values, validator) || !_anyIsFontFamily(values, validator) ) { throw new InvalidPropertyError( "Invalid font values at " + formatPosition(property.all[property.position][1][2][0]) + ". Ignoring." ); } if (values.length > 1 && _anyIsInherit(values)) { throw new InvalidPropertyError( "Invalid font values at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } // fuzzy match style, variant, weight, and stretch on first elements while (index < fuzzyMatched) { isStretchValid = validator.isFontStretchKeyword(values[index][1]) || validator.isGlobal(values[index][1]); isStyleValid = validator.isFontStyleKeyword(values[index][1]) || validator.isGlobal(values[index][1]); isVariantValid = validator.isFontVariantKeyword(values[index][1]) || validator.isGlobal(values[index][1]); isWeightValid = validator.isFontWeightKeyword(values[index][1]) || validator.isGlobal(values[index][1]); if (isStyleValid && !isStyleSet) { style.value = [values[index]]; isStyleSet = true; } else if (isVariantValid && !isVariantSet) { variant.value = [values[index]]; isVariantSet = true; } else if (isWeightValid && !isWeightSet) { weight.value = [values[index]]; isWeightSet = true; } else if (isStretchValid && !isStretchSet) { stretch.value = [values[index]]; isStretchSet = true; } else if ( (isStyleValid && isStyleSet) || (isVariantValid && isVariantSet) || (isWeightValid && isWeightSet) || (isStretchValid && isStretchSet) ) { throw new InvalidPropertyError( "Invalid font style / variant / weight / stretch value at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } else { break; } index++; } // now comes font-size ... if ( validator.isFontSizeKeyword(values[index][1]) || (validator.isUnit(values[index][1]) && !validator.isDynamicUnit(values[index][1])) ) { size.value = [values[index]]; isSizeSet = true; index++; } else { throw new InvalidPropertyError( "Missing font size at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } if (!values[index]) { throw new InvalidPropertyError( "Missing font family at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } // ... and perhaps line-height if ( isSizeSet && values[index] && values[index][1] == Marker.FORWARD_SLASH && values[index + 1] && (validator.isLineHeightKeyword(values[index + 1][1]) || validator.isUnit(values[index + 1][1]) || validator.isNumber(values[index + 1][1])) ) { height.value = [values[index + 1]]; index++; index++; } // ... and whatever comes next is font-family family.value = []; while (values[index]) { if (values[index][1] == Marker.COMMA) { appendableFamilyName = false; } else { if (appendableFamilyName) { family.value[family.value.length - 1][1] += Marker.SPACE + values[index][1]; } else { family.value.push(values[index]); } appendableFamilyName = true; } index++; } if (family.value.length === 0) { throw new InvalidPropertyError( "Missing font family at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } return components; } function _anyIsFontSize(values, validator) { var value; var i, l; for (i = 0, l = values.length; i < l; i++) { value = values[i]; if ( validator.isFontSizeKeyword(value[1]) || (validator.isUnit(value[1]) && !validator.isDynamicUnit(value[1])) || validator.isFunction(value[1]) ) { return true; } } return false; } function _anyIsFontFamily(values, validator) { var value; var i, l; for (i = 0, l = values.length; i < l; i++) { value = values[i]; if (validator.isIdentifier(value[1])) { return true; } } return false; } function fourValues(property, compactable) { var componentNames = compactable[property.name].components; var components = []; var value = property.value; if (value.length < 1) return []; if (value.length < 2) value[1] = value[0].slice(0); if (value.length < 3) value[2] = value[0].slice(0); if (value.length < 4) value[3] = value[1].slice(0); for (var i = componentNames.length - 1; i >= 0; i--) { var component = wrapSingle([ Token.PROPERTY, [Token.PROPERTY_NAME, componentNames[i]] ]); component.value = [value[i]]; components.unshift(component); } return components; } function multiplex(splitWith) { return function(property, compactable, validator) { var splitsAt = []; var values = property.value; var i, j, l, m; // find split commas for (i = 0, l = values.length; i < l; i++) { if (values[i][1] == ",") splitsAt.push(i); } if (splitsAt.length === 0) return splitWith(property, compactable, validator); var splitComponents = []; // split over commas, and into components for (i = 0, l = splitsAt.length; i <= l; i++) { var from = i === 0 ? 0 : splitsAt[i - 1] + 1; var to = i < l ? splitsAt[i] : values.length; var _property = _wrapDefault( property.name, property, compactable ); _property.value = values.slice(from, to); splitComponents.push( splitWith(_property, compactable, validator) ); } var components = splitComponents[0]; // group component values from each split for (i = 0, l = components.length; i < l; i++) { components[i].multiplex = true; for (j = 1, m = splitComponents.length; j < m; j++) { components[i].value.push([Token.PROPERTY_VALUE, Marker.COMMA]); Array.prototype.push.apply( components[i].value, splitComponents[j][i].value ); } } return components; }; } function listStyle(property, compactable, validator) { var type = _wrapDefault("list-style-type", property, compactable); var position = _wrapDefault( "list-style-position", property, compactable ); var image = _wrapDefault("list-style-image", property, compactable); var components = [type, position, image]; if (property.value.length == 1 && property.value[0][1] == "inherit") { type.value = position.value = image.value = [property.value[0]]; return components; } var values = property.value.slice(0); var total = values.length; var index = 0; // `image` first... for (index = 0, total = values.length; index < total; index++) { if (validator.isUrl(values[index][1]) || values[index][1] == "0") { image.value = [values[index]]; values.splice(index, 1); break; } } // ... then `position` for (index = 0, total = values.length; index < total; index++) { if (validator.isListStylePositionKeyword(values[index][1])) { position.value = [values[index]]; values.splice(index, 1); break; } } // ... and what's left is a `type` if ( values.length > 0 && (validator.isListStyleTypeKeyword(values[0][1]) || validator.isIdentifier(values[0][1])) ) { type.value = [values[0]]; } return components; } function transition(property, compactable, validator) { var prop = _wrapDefault( property.name + "-property", property, compactable ); var duration = _wrapDefault( property.name + "-duration", property, compactable ); var timing = _wrapDefault( property.name + "-timing-function", property, compactable ); var delay = _wrapDefault( property.name + "-delay", property, compactable ); var components = [prop, duration, timing, delay]; var values = property.value; var value; var durationSet = false; var delaySet = false; var propSet = false; var timingSet = false; var i; var l; if (property.value.length == 1 && property.value[0][1] == "inherit") { prop.value = duration.value = timing.value = delay.value = property.value; return components; } if (values.length > 1 && _anyIsInherit(values)) { throw new InvalidPropertyError( "Invalid animation values at " + formatPosition(values[0][2][0]) + ". Ignoring." ); } for (i = 0, l = values.length; i < l; i++) { value = values[i]; if (validator.isTime(value[1]) && !durationSet) { duration.value = [value]; durationSet = true; } else if (validator.isTime(value[1]) && !delaySet) { delay.value = [value]; delaySet = true; } else if ( (validator.isGlobal(value[1]) || validator.isTimingFunction(value[1])) && !timingSet ) { timing.value = [value]; timingSet = true; } else if (validator.isIdentifier(value[1]) && !propSet) { prop.value = [value]; propSet = true; } else { throw new InvalidPropertyError( "Invalid animation value at " + formatPosition(value[2][0]) + ". Ignoring." ); } } return components; } function widthStyleColor(property, compactable, validator) { var descriptor = compactable[property.name]; var components = [ _wrapDefault(descriptor.components[0], property, compactable), _wrapDefault(descriptor.components[1], property, compactable), _wrapDefault(descriptor.components[2], property, compactable) ]; var color, style, width; for (var i = 0; i < 3; i++) { var component = components[i]; if (component.name.indexOf("color") > 0) color = component; else if (component.name.indexOf("style") > 0) style = component; else width = component; } if ( (property.value.length == 1 && property.value[0][1] == "inherit") || (property.value.length == 3 && property.value[0][1] == "inherit" && property.value[1][1] == "inherit" && property.value[2][1] == "inherit") ) { color.value = style.value = width.value = [property.value[0]]; return components; } var values = property.value.slice(0); var match, matches; // NOTE: usually users don't follow the required order of parts in this shorthand, // so we'll try to parse it caring as little about order as possible if (values.length > 0) { matches = values.filter(_widthFilter(validator)); match = matches.length > 1 && (matches[0][1] == "none" || matches[0][1] == "auto") ? matches[1] : matches[0]; if (match) { width.value = [match]; values.splice(values.indexOf(match), 1); } } if (values.length > 0) { match = values.filter(_styleFilter(validator))[0]; if (match) { style.value = [match]; values.splice(values.indexOf(match), 1); } } if (values.length > 0) { match = values.filter(_colorFilter(validator))[0]; if (match) { color.value = [match]; values.splice(values.indexOf(match), 1); } } return components; } module.exports = { animation: animation, background: background, border: widthStyleColor, borderRadius: borderRadius, font: font, fourValues: fourValues, listStyle: listStyle, multiplex: multiplex, outline: widthStyleColor, transition: transition }; }, { "../../tokenizer/marker": 83, "../../tokenizer/token": 84, "../../utils/format-position": 87, "../wrap-for-optimizing": 58, "./invalid-property-error": 23 } ], 19: [ function(require, module, exports) { var understandable = require("./properties/understandable"); function animationIterationCount(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return ( validator.isAnimationIterationCountKeyword(value2) || validator.isPositiveNumber(value2) ); } function animationName(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return ( validator.isAnimationNameKeyword(value2) || validator.isIdentifier(value2) ); } function areSameFunction(validator, value1, value2) { if (!validator.isFunction(value1) || !validator.isFunction(value2)) { return false; } var function1Name = value1.substring(0, value1.indexOf("(")); var function2Name = value2.substring(0, value2.indexOf("(")); return function1Name === function2Name; } function backgroundPosition(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if ( validator.isBackgroundPositionKeyword(value2) || validator.isGlobal(value2) ) { return true; } return unit(validator, value1, value2); } function backgroundSize(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if ( validator.isBackgroundSizeKeyword(value2) || validator.isGlobal(value2) ) { return true; } return unit(validator, value1, value2); } function color(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isColor(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if ( !validator.colorOpacity && (validator.isRgbColor(value1) || validator.isHslColor(value1)) ) { return false; } else if ( !validator.colorOpacity && (validator.isRgbColor(value2) || validator.isHslColor(value2)) ) { return false; } else if (validator.isColor(value1) && validator.isColor(value2)) { return true; } return sameFunctionOrValue(validator, value1, value2); } function components(overrideCheckers) { return function(validator, value1, value2, position) { return overrideCheckers[position](validator, value1, value2); }; } function fontFamily(validator, value1, value2) { return understandable(validator, value1, value2, 0, true); } function image(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isImage(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if (validator.isImage(value2)) { return true; } else if (validator.isImage(value1)) { return false; } return sameFunctionOrValue(validator, value1, value2); } function keyword(propertyName) { return function(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isKeyword(propertyName)(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return validator.isKeyword(propertyName)(value2); }; } function keywordWithGlobal(propertyName) { return function(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return ( validator.isKeyword(propertyName)(value2) || validator.isGlobal(value2) ); }; } function propertyName(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isIdentifier(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return validator.isIdentifier(value2); } function sameFunctionOrValue(validator, value1, value2) { return areSameFunction(validator, value1, value2) ? true : value1 === value2; } function textShadow(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !( validator.isUnit(value2) || validator.isColor(value2) || validator.isGlobal(value2) ) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return ( validator.isUnit(value2) || validator.isColor(value2) || validator.isGlobal(value2) ); } function time(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isTime(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if (validator.isTime(value1) && !validator.isTime(value2)) { return false; } else if (validator.isTime(value2)) { return true; } else if (validator.isTime(value1)) { return false; } else if ( validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2) ) { return true; } return sameFunctionOrValue(validator, value1, value2); } function timingFunction(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !(validator.isTimingFunction(value2) || validator.isGlobal(value2)) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return ( validator.isTimingFunction(value2) || validator.isGlobal(value2) ); } function unit(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isUnit(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if (validator.isUnit(value1) && !validator.isUnit(value2)) { return false; } else if (validator.isUnit(value2)) { return true; } else if (validator.isUnit(value1)) { return false; } else if ( validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2) ) { return true; } return sameFunctionOrValue(validator, value1, value2); } function unitOrKeywordWithGlobal(propertyName) { var byKeyword = keywordWithGlobal(propertyName); return function(validator, value1, value2) { return ( unit(validator, value1, value2) || byKeyword(validator, value1, value2) ); }; } function unitOrNumber(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !(validator.isUnit(value2) || validator.isNumber(value2)) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } else if ( (validator.isUnit(value1) || validator.isNumber(value1)) && !(validator.isUnit(value2) || validator.isNumber(value2)) ) { return false; } else if (validator.isUnit(value2) || validator.isNumber(value2)) { return true; } else if (validator.isUnit(value1) || validator.isNumber(value1)) { return false; } else if ( validator.isFunction(value1) && !validator.isPrefixed(value1) && validator.isFunction(value2) && !validator.isPrefixed(value2) ) { return true; } return sameFunctionOrValue(validator, value1, value2); } function zIndex(validator, value1, value2) { if ( !understandable(validator, value1, value2, 0, true) && !validator.isZIndex(value2) ) { return false; } else if ( validator.isVariable(value1) && validator.isVariable(value2) ) { return true; } return validator.isZIndex(value2); } module.exports = { generic: { color: color, components: components, image: image, propertyName: propertyName, time: time, timingFunction: timingFunction, unit: unit, unitOrNumber: unitOrNumber }, property: { animationDirection: keywordWithGlobal("animation-direction"), animationFillMode: keyword("animation-fill-mode"), animationIterationCount: animationIterationCount, animationName: animationName, animationPlayState: keywordWithGlobal("animation-play-state"), backgroundAttachment: keyword("background-attachment"), backgroundClip: keywordWithGlobal("background-clip"), backgroundOrigin: keyword("background-origin"), backgroundPosition: backgroundPosition, backgroundRepeat: keyword("background-repeat"), backgroundSize: backgroundSize, bottom: unitOrKeywordWithGlobal("bottom"), borderCollapse: keyword("border-collapse"), borderStyle: keywordWithGlobal("*-style"), clear: keywordWithGlobal("clear"), cursor: keywordWithGlobal("cursor"), display: keywordWithGlobal("display"), float: keywordWithGlobal("float"), left: unitOrKeywordWithGlobal("left"), fontFamily: fontFamily, fontStretch: keywordWithGlobal("font-stretch"), fontStyle: keywordWithGlobal("font-style"), fontVariant: keywordWithGlobal("font-variant"), fontWeight: keywordWithGlobal("font-weight"), listStyleType: keywordWithGlobal("list-style-type"), listStylePosition: keywordWithGlobal("list-style-position"), outlineStyle: keywordWithGlobal("*-style"), overflow: keywordWithGlobal("overflow"), position: keywordWithGlobal("position"), right: unitOrKeywordWithGlobal("right"), textAlign: keywordWithGlobal("text-align"), textDecoration: keywordWithGlobal("text-decoration"), textOverflow: keywordWithGlobal("text-overflow"), textShadow: textShadow, top: unitOrKeywordWithGlobal("top"), transform: sameFunctionOrValue, verticalAlign: unitOrKeywordWithGlobal("vertical-align"), visibility: keywordWithGlobal("visibility"), whiteSpace: keywordWithGlobal("white-space"), zIndex: zIndex } }; }, { "./properties/understandable": 40 } ], 20: [ function(require, module, exports) { var wrapSingle = require("../wrap-for-optimizing").single; var Token = require("../../tokenizer/token"); function deep(property) { var cloned = shallow(property); for (var i = property.components.length - 1; i >= 0; i--) { var component = shallow(property.components[i]); component.value = property.components[i].value.slice(0); cloned.components.unshift(component); } cloned.dirty = true; cloned.value = property.value.slice(0); return cloned; } function shallow(property) { var cloned = wrapSingle([ Token.PROPERTY, [Token.PROPERTY_NAME, property.name] ]); cloned.important = property.important; cloned.hack = property.hack; cloned.unused = false; return cloned; } module.exports = { deep: deep, shallow: shallow }; }, { "../../tokenizer/token": 84, "../wrap-for-optimizing": 58 } ], 21: [ function(require, module, exports) { // Contains the interpretation of CSS properties, as used by the property optimizer var breakUp = require("./break-up"); var canOverride = require("./can-override"); var restore = require("./restore"); var override = require("../../utils/override"); // Properties to process // Extend this object in order to add support for more properties in the optimizer. // // Each key in this object represents a CSS property and should be an object. // Such an object contains properties that describe how the represented CSS property should be handled. // Possible options: // // * components: array (Only specify for shorthand properties.) // Contains the names of the granular properties this shorthand compacts. // // * canOverride: function // Returns whether two tokens of this property can be merged with each other. // This property has no meaning for shorthands. // // * defaultValue: string // Specifies the default value of the property according to the CSS standard. // For shorthand, this is used when every component is set to its default value, therefore it should be the shortest possible default value of all the components. // // * shortestValue: string // Specifies the shortest possible value the property can possibly have. // (Falls back to defaultValue if unspecified.) // // * breakUp: function (Only specify for shorthand properties.) // Breaks the shorthand up to its components. // // * restore: function (Only specify for shorthand properties.) // Puts the shorthand together from its components. // var compactable = { animation: { canOverride: canOverride.generic.components([ canOverride.generic.time, canOverride.generic.timingFunction, canOverride.generic.time, canOverride.property.animationIterationCount, canOverride.property.animationDirection, canOverride.property.animationFillMode, canOverride.property.animationPlayState, canOverride.property.animationName ]), components: [ "animation-duration", "animation-timing-function", "animation-delay", "animation-iteration-count", "animation-direction", "animation-fill-mode", "animation-play-state", "animation-name" ], breakUp: breakUp.multiplex(breakUp.animation), defaultValue: "none", restore: restore.multiplex(restore.withoutDefaults), shorthand: true, vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-delay": { canOverride: canOverride.generic.time, componentOf: ["animation"], defaultValue: "0s", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-direction": { canOverride: canOverride.property.animationDirection, componentOf: ["animation"], defaultValue: "normal", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-duration": { canOverride: canOverride.generic.time, componentOf: ["animation"], defaultValue: "0s", intoMultiplexMode: "real", keepUnlessDefault: "animation-delay", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-fill-mode": { canOverride: canOverride.property.animationFillMode, componentOf: ["animation"], defaultValue: "none", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-iteration-count": { canOverride: canOverride.property.animationIterationCount, componentOf: ["animation"], defaultValue: "1", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-name": { canOverride: canOverride.property.animationName, componentOf: ["animation"], defaultValue: "none", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-play-state": { canOverride: canOverride.property.animationPlayState, componentOf: ["animation"], defaultValue: "running", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "animation-timing-function": { canOverride: canOverride.generic.timingFunction, componentOf: ["animation"], defaultValue: "ease", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, background: { canOverride: canOverride.generic.components([ canOverride.generic.image, canOverride.property.backgroundPosition, canOverride.property.backgroundSize, canOverride.property.backgroundRepeat, canOverride.property.backgroundAttachment, canOverride.property.backgroundOrigin, canOverride.property.backgroundClip, canOverride.generic.color ]), components: [ "background-image", "background-position", "background-size", "background-repeat", "background-attachment", "background-origin", "background-clip", "background-color" ], breakUp: breakUp.multiplex(breakUp.background), defaultValue: "0 0", restore: restore.multiplex(restore.background), shortestValue: "0", shorthand: true }, "background-attachment": { canOverride: canOverride.property.backgroundAttachment, componentOf: ["background"], defaultValue: "scroll", intoMultiplexMode: "real" }, "background-clip": { canOverride: canOverride.property.backgroundClip, componentOf: ["background"], defaultValue: "border-box", intoMultiplexMode: "real", shortestValue: "border-box" }, "background-color": { canOverride: canOverride.generic.color, componentOf: ["background"], defaultValue: "transparent", intoMultiplexMode: "real", // otherwise real color will turn into default since color appears in last multiplex only multiplexLastOnly: true, nonMergeableValue: "none", shortestValue: "red" }, "background-image": { canOverride: canOverride.generic.image, componentOf: ["background"], defaultValue: "none", intoMultiplexMode: "default" }, "background-origin": { canOverride: canOverride.property.backgroundOrigin, componentOf: ["background"], defaultValue: "padding-box", intoMultiplexMode: "real", shortestValue: "border-box" }, "background-position": { canOverride: canOverride.property.backgroundPosition, componentOf: ["background"], defaultValue: ["0", "0"], doubleValues: true, intoMultiplexMode: "real", shortestValue: "0" }, "background-repeat": { canOverride: canOverride.property.backgroundRepeat, componentOf: ["background"], defaultValue: ["repeat"], doubleValues: true, intoMultiplexMode: "real" }, "background-size": { canOverride: canOverride.property.backgroundSize, componentOf: ["background"], defaultValue: ["auto"], doubleValues: true, intoMultiplexMode: "real", shortestValue: "0 0" }, bottom: { canOverride: canOverride.property.bottom, defaultValue: "auto" }, border: { breakUp: breakUp.border, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.property.borderStyle, canOverride.generic.color ]), components: ["border-width", "border-style", "border-color"], defaultValue: "none", overridesShorthands: [ "border-bottom", "border-left", "border-right", "border-top" ], restore: restore.withoutDefaults, shorthand: true, shorthandComponents: true }, "border-bottom": { breakUp: breakUp.border, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.property.borderStyle, canOverride.generic.color ]), components: [ "border-bottom-width", "border-bottom-style", "border-bottom-color" ], defaultValue: "none", restore: restore.withoutDefaults, shorthand: true }, "border-bottom-color": { canOverride: canOverride.generic.color, componentOf: ["border-bottom", "border-color"], defaultValue: "none" }, "border-bottom-left-radius": { canOverride: canOverride.generic.unit, componentOf: ["border-radius"], defaultValue: "0", vendorPrefixes: ["-moz-", "-o-"] }, "border-bottom-right-radius": { canOverride: canOverride.generic.unit, componentOf: ["border-radius"], defaultValue: "0", vendorPrefixes: ["-moz-", "-o-"] }, "border-bottom-style": { canOverride: canOverride.property.borderStyle, componentOf: ["border-bottom", "border-style"], defaultValue: "none" }, "border-bottom-width": { canOverride: canOverride.generic.unit, componentOf: ["border-bottom", "border-width"], defaultValue: "medium", oppositeTo: "border-top-width", shortestValue: "0" }, "border-collapse": { canOverride: canOverride.property.borderCollapse, defaultValue: "separate" }, "border-color": { breakUp: breakUp.fourValues, canOverride: canOverride.generic.components([ canOverride.generic.color, canOverride.generic.color, canOverride.generic.color, canOverride.generic.color ]), componentOf: ["border"], components: [ "border-top-color", "border-right-color", "border-bottom-color", "border-left-color" ], defaultValue: "none", restore: restore.fourValues, shortestValue: "red", shorthand: true }, "border-left": { breakUp: breakUp.border, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.property.borderStyle, canOverride.generic.color ]), components: [ "border-left-width", "border-left-style", "border-left-color" ], defaultValue: "none", restore: restore.withoutDefaults, shorthand: true }, "border-left-color": { canOverride: canOverride.generic.color, componentOf: ["border-color", "border-left"], defaultValue: "none" }, "border-left-style": { canOverride: canOverride.property.borderStyle, componentOf: ["border-left", "border-style"], defaultValue: "none" }, "border-left-width": { canOverride: canOverride.generic.unit, componentOf: ["border-left", "border-width"], defaultValue: "medium", oppositeTo: "border-right-width", shortestValue: "0" }, "border-radius": { breakUp: breakUp.borderRadius, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit ]), components: [ "border-top-left-radius", "border-top-right-radius", "border-bottom-right-radius", "border-bottom-left-radius" ], defaultValue: "0", restore: restore.borderRadius, shorthand: true, vendorPrefixes: ["-moz-", "-o-"] }, "border-right": { breakUp: breakUp.border, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.property.borderStyle, canOverride.generic.color ]), components: [ "border-right-width", "border-right-style", "border-right-color" ], defaultValue: "none", restore: restore.withoutDefaults, shorthand: true }, "border-right-color": { canOverride: canOverride.generic.color, componentOf: ["border-color", "border-right"], defaultValue: "none" }, "border-right-style": { canOverride: canOverride.property.borderStyle, componentOf: ["border-right", "border-style"], defaultValue: "none" }, "border-right-width": { canOverride: canOverride.generic.unit, componentOf: ["border-right", "border-width"], defaultValue: "medium", oppositeTo: "border-left-width", shortestValue: "0" }, "border-style": { breakUp: breakUp.fourValues, canOverride: canOverride.generic.components([ canOverride.property.borderStyle, canOverride.property.borderStyle, canOverride.property.borderStyle, canOverride.property.borderStyle ]), componentOf: ["border"], components: [ "border-top-style", "border-right-style", "border-bottom-style", "border-left-style" ], defaultValue: "none", restore: restore.fourValues, shorthand: true }, "border-top": { breakUp: breakUp.border, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.property.borderStyle, canOverride.generic.color ]), components: [ "border-top-width", "border-top-style", "border-top-color" ], defaultValue: "none", restore: restore.withoutDefaults, shorthand: true }, "border-top-color": { canOverride: canOverride.generic.color, componentOf: ["border-color", "border-top"], defaultValue: "none" }, "border-top-left-radius": { canOverride: canOverride.generic.unit, componentOf: ["border-radius"], defaultValue: "0", vendorPrefixes: ["-moz-", "-o-"] }, "border-top-right-radius": { canOverride: canOverride.generic.unit, componentOf: ["border-radius"], defaultValue: "0", vendorPrefixes: ["-moz-", "-o-"] }, "border-top-style": { canOverride: canOverride.property.borderStyle, componentOf: ["border-style", "border-top"], defaultValue: "none" }, "border-top-width": { canOverride: canOverride.generic.unit, componentOf: ["border-top", "border-width"], defaultValue: "medium", oppositeTo: "border-bottom-width", shortestValue: "0" }, "border-width": { breakUp: breakUp.fourValues, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit ]), componentOf: ["border"], components: [ "border-top-width", "border-right-width", "border-bottom-width", "border-left-width" ], defaultValue: "medium", restore: restore.fourValues, shortestValue: "0", shorthand: true }, clear: { canOverride: canOverride.property.clear, defaultValue: "none" }, color: { canOverride: canOverride.generic.color, defaultValue: "transparent", shortestValue: "red" }, cursor: { canOverride: canOverride.property.cursor, defaultValue: "auto" }, display: { canOverride: canOverride.property.display }, float: { canOverride: canOverride.property.float, defaultValue: "none" }, font: { breakUp: breakUp.font, canOverride: canOverride.generic.components([ canOverride.property.fontStyle, canOverride.property.fontVariant, canOverride.property.fontWeight, canOverride.property.fontStretch, canOverride.generic.unit, canOverride.generic.unit, canOverride.property.fontFamily ]), components: [ "font-style", "font-variant", "font-weight", "font-stretch", "font-size", "line-height", "font-family" ], restore: restore.font, shorthand: true }, "font-family": { canOverride: canOverride.property.fontFamily, defaultValue: "user|agent|specific" }, "font-size": { canOverride: canOverride.generic.unit, defaultValue: "medium", shortestValue: "0" }, "font-stretch": { canOverride: canOverride.property.fontStretch, defaultValue: "normal" }, "font-style": { canOverride: canOverride.property.fontStyle, defaultValue: "normal" }, "font-variant": { canOverride: canOverride.property.fontVariant, defaultValue: "normal" }, "font-weight": { canOverride: canOverride.property.fontWeight, defaultValue: "normal", shortestValue: "400" }, height: { canOverride: canOverride.generic.unit, defaultValue: "auto", shortestValue: "0" }, left: { canOverride: canOverride.property.left, defaultValue: "auto" }, "line-height": { canOverride: canOverride.generic.unitOrNumber, defaultValue: "normal", shortestValue: "0" }, "list-style": { canOverride: canOverride.generic.components([ canOverride.property.listStyleType, canOverride.property.listStylePosition, canOverride.property.listStyleImage ]), components: [ "list-style-type", "list-style-position", "list-style-image" ], breakUp: breakUp.listStyle, restore: restore.withoutDefaults, defaultValue: "outside", // can't use 'disc' because that'd override default 'decimal' for
    shortestValue: "none", shorthand: true }, "list-style-image": { canOverride: canOverride.generic.image, componentOf: ["list-style"], defaultValue: "none" }, "list-style-position": { canOverride: canOverride.property.listStylePosition, componentOf: ["list-style"], defaultValue: "outside", shortestValue: "inside" }, "list-style-type": { canOverride: canOverride.property.listStyleType, componentOf: ["list-style"], // NOTE: we can't tell the real default value here, it's 'disc' for
      and 'decimal' for
        // this is a hack, but it doesn't matter because this value will be either overridden or // it will disappear at the final step anyway defaultValue: "decimal|disc", shortestValue: "none" }, margin: { breakUp: breakUp.fourValues, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit ]), components: [ "margin-top", "margin-right", "margin-bottom", "margin-left" ], defaultValue: "0", restore: restore.fourValues, shorthand: true }, "margin-bottom": { canOverride: canOverride.generic.unit, componentOf: ["margin"], defaultValue: "0", oppositeTo: "margin-top" }, "margin-left": { canOverride: canOverride.generic.unit, componentOf: ["margin"], defaultValue: "0", oppositeTo: "margin-right" }, "margin-right": { canOverride: canOverride.generic.unit, componentOf: ["margin"], defaultValue: "0", oppositeTo: "margin-left" }, "margin-top": { canOverride: canOverride.generic.unit, componentOf: ["margin"], defaultValue: "0", oppositeTo: "margin-bottom" }, outline: { canOverride: canOverride.generic.components([ canOverride.generic.color, canOverride.property.outlineStyle, canOverride.generic.unit ]), components: ["outline-color", "outline-style", "outline-width"], breakUp: breakUp.outline, restore: restore.withoutDefaults, defaultValue: "0", shorthand: true }, "outline-color": { canOverride: canOverride.generic.color, componentOf: ["outline"], defaultValue: "invert", shortestValue: "red" }, "outline-style": { canOverride: canOverride.property.outlineStyle, componentOf: ["outline"], defaultValue: "none" }, "outline-width": { canOverride: canOverride.generic.unit, componentOf: ["outline"], defaultValue: "medium", shortestValue: "0" }, overflow: { canOverride: canOverride.property.overflow, defaultValue: "visible" }, "overflow-x": { canOverride: canOverride.property.overflow, defaultValue: "visible" }, "overflow-y": { canOverride: canOverride.property.overflow, defaultValue: "visible" }, padding: { breakUp: breakUp.fourValues, canOverride: canOverride.generic.components([ canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit, canOverride.generic.unit ]), components: [ "padding-top", "padding-right", "padding-bottom", "padding-left" ], defaultValue: "0", restore: restore.fourValues, shorthand: true }, "padding-bottom": { canOverride: canOverride.generic.unit, componentOf: ["padding"], defaultValue: "0", oppositeTo: "padding-top" }, "padding-left": { canOverride: canOverride.generic.unit, componentOf: ["padding"], defaultValue: "0", oppositeTo: "padding-right" }, "padding-right": { canOverride: canOverride.generic.unit, componentOf: ["padding"], defaultValue: "0", oppositeTo: "padding-left" }, "padding-top": { canOverride: canOverride.generic.unit, componentOf: ["padding"], defaultValue: "0", oppositeTo: "padding-bottom" }, position: { canOverride: canOverride.property.position, defaultValue: "static" }, right: { canOverride: canOverride.property.right, defaultValue: "auto" }, "text-align": { canOverride: canOverride.property.textAlign, // NOTE: we can't tell the real default value here, as it depends on default text direction // this is a hack, but it doesn't matter because this value will be either overridden or // it will disappear anyway defaultValue: "left|right" }, "text-decoration": { canOverride: canOverride.property.textDecoration, defaultValue: "none" }, "text-overflow": { canOverride: canOverride.property.textOverflow, defaultValue: "none" }, "text-shadow": { canOverride: canOverride.property.textShadow, defaultValue: "none" }, top: { canOverride: canOverride.property.top, defaultValue: "auto" }, transform: { canOverride: canOverride.property.transform, vendorPrefixes: ["-moz-", "-ms-", "-webkit-"] }, transition: { breakUp: breakUp.multiplex(breakUp.transition), canOverride: canOverride.generic.components([ canOverride.property.transitionProperty, canOverride.generic.time, canOverride.generic.timingFunction, canOverride.generic.time ]), components: [ "transition-property", "transition-duration", "transition-timing-function", "transition-delay" ], defaultValue: "none", restore: restore.multiplex(restore.withoutDefaults), shorthand: true, vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "transition-delay": { canOverride: canOverride.generic.time, componentOf: ["transition"], defaultValue: "0s", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "transition-duration": { canOverride: canOverride.generic.time, componentOf: ["transition"], defaultValue: "0s", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "transition-property": { canOverride: canOverride.generic.propertyName, componentOf: ["transition"], defaultValue: "all", intoMultiplexMode: "placeholder", placeholderValue: "_", // it's a short value that won't match any property and still be a valid `transition-property` vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "transition-timing-function": { canOverride: canOverride.generic.timingFunction, componentOf: ["transition"], defaultValue: "ease", intoMultiplexMode: "real", vendorPrefixes: ["-moz-", "-o-", "-webkit-"] }, "vertical-align": { canOverride: canOverride.property.verticalAlign, defaultValue: "baseline" }, visibility: { canOverride: canOverride.property.visibility, defaultValue: "visible" }, "white-space": { canOverride: canOverride.property.whiteSpace, defaultValue: "normal" }, width: { canOverride: canOverride.generic.unit, defaultValue: "auto", shortestValue: "0" }, "z-index": { canOverride: canOverride.property.zIndex, defaultValue: "auto" } }; function cloneDescriptor(propertyName, prefix) { var clonedDescriptor = override(compactable[propertyName], {}); if ("componentOf" in clonedDescriptor) { clonedDescriptor.componentOf = clonedDescriptor.componentOf.map( function(shorthandName) { return prefix + shorthandName; } ); } if ("components" in clonedDescriptor) { clonedDescriptor.components = clonedDescriptor.components.map( function(longhandName) { return prefix + longhandName; } ); } if ("keepUnlessDefault" in clonedDescriptor) { clonedDescriptor.keepUnlessDefault = prefix + clonedDescriptor.keepUnlessDefault; } return clonedDescriptor; } // generate vendor-prefixed properties var vendorPrefixedCompactable = {}; for (var propertyName in compactable) { var descriptor = compactable[propertyName]; if (!("vendorPrefixes" in descriptor)) { continue; } for (var i = 0; i < descriptor.vendorPrefixes.length; i++) { var prefix = descriptor.vendorPrefixes[i]; var clonedDescriptor = cloneDescriptor(propertyName, prefix); delete clonedDescriptor.vendorPrefixes; vendorPrefixedCompactable[prefix + propertyName] = clonedDescriptor; } delete descriptor.vendorPrefixes; } module.exports = override(compactable, vendorPrefixedCompactable); }, { "../../utils/override": 95, "./break-up": 18, "./can-override": 19, "./restore": 49 } ], 22: [ function(require, module, exports) { // This extractor is used in level 2 optimizations // IMPORTANT: Mind Token class and this code is not related! // Properties will be tokenized in one step, see #429 var Token = require("../../tokenizer/token"); var serializeRules = require("../../writer/one-time").rules; var serializeValue = require("../../writer/one-time").value; function extractProperties(token) { var properties = []; var inSpecificSelector; var property; var name; var value; var i, l; if (token[0] == Token.RULE) { inSpecificSelector = !/[\.\+>~]/.test(serializeRules(token[1])); for (i = 0, l = token[2].length; i < l; i++) { property = token[2][i]; if (property[0] != Token.PROPERTY) continue; name = property[1][1]; if (name.length === 0) continue; if (name.indexOf("--") === 0) continue; value = serializeValue(property, i); properties.push([ name, value, findNameRoot(name), token[2][i], name + ":" + value, token[1], inSpecificSelector ]); } } else if (token[0] == Token.NESTED_BLOCK) { for (i = 0, l = token[2].length; i < l; i++) { properties = properties.concat(extractProperties(token[2][i])); } } return properties; } function findNameRoot(name) { if (name == "list-style") return name; if (name.indexOf("-radius") > 0) return "border-radius"; if ( name == "border-collapse" || name == "border-spacing" || name == "border-image" ) return name; if (name.indexOf("border-") === 0 && /^border\-\w+\-\w+$/.test(name)) return name.match(/border\-\w+/)[0]; if (name.indexOf("border-") === 0 && /^border\-\w+$/.test(name)) return "border"; if (name.indexOf("text-") === 0) return name; if (name == "-chrome-") return name; return name .replace(/^\-\w+\-/, "") .match(/([a-zA-Z]+)/)[0] .toLowerCase(); } module.exports = extractProperties; }, { "../../tokenizer/token": 84, "../../writer/one-time": 98 } ], 23: [ function(require, module, exports) { function InvalidPropertyError(message) { this.name = "InvalidPropertyError"; this.message = message; this.stack = new Error().stack; } InvalidPropertyError.prototype = Object.create(Error.prototype); InvalidPropertyError.prototype.constructor = InvalidPropertyError; module.exports = InvalidPropertyError; }, {} ], 24: [ function(require, module, exports) { var Marker = require("../../tokenizer/marker"); var split = require("../../utils/split"); var DEEP_SELECTOR_PATTERN = /\/deep\//; var DOUBLE_COLON_PATTERN = /^::/; var NOT_PSEUDO = ":not"; var PSEUDO_CLASSES_WITH_ARGUMENTS = [ ":dir", ":lang", ":not", ":nth-child", ":nth-last-child", ":nth-last-of-type", ":nth-of-type" ]; var RELATION_PATTERN = /[>\+~]/; var UNMIXABLE_PSEUDO_CLASSES = [ ":after", ":before", ":first-letter", ":first-line", ":lang" ]; var UNMIXABLE_PSEUDO_ELEMENTS = [ "::after", "::before", "::first-letter", "::first-line" ]; var Level = { DOUBLE_QUOTE: "double-quote", SINGLE_QUOTE: "single-quote", ROOT: "root" }; function isMergeable( selector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) { var singleSelectors = split(selector, Marker.COMMA); var singleSelector; var i, l; for (i = 0, l = singleSelectors.length; i < l; i++) { singleSelector = singleSelectors[i]; if ( singleSelector.length === 0 || isDeepSelector(singleSelector) || (singleSelector.indexOf(Marker.COLON) > -1 && !areMergeable( singleSelector, extractPseudoFrom(singleSelector), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging )) ) { return false; } } return true; } function isDeepSelector(selector) { return DEEP_SELECTOR_PATTERN.test(selector); } function extractPseudoFrom(selector) { var list = []; var character; var buffer = []; var level = Level.ROOT; var roundBracketLevel = 0; var isQuoted; var isEscaped; var isPseudo = false; var isRelation; var wasColon = false; var index; var len; for (index = 0, len = selector.length; index < len; index++) { character = selector[index]; isRelation = !isEscaped && RELATION_PATTERN.test(character); isQuoted = level == Level.DOUBLE_QUOTE || level == Level.SINGLE_QUOTE; if (isEscaped) { buffer.push(character); } else if ( character == Marker.DOUBLE_QUOTE && level == Level.ROOT ) { buffer.push(character); level = Level.DOUBLE_QUOTE; } else if ( character == Marker.DOUBLE_QUOTE && level == Level.DOUBLE_QUOTE ) { buffer.push(character); level = Level.ROOT; } else if ( character == Marker.SINGLE_QUOTE && level == Level.ROOT ) { buffer.push(character); level = Level.SINGLE_QUOTE; } else if ( character == Marker.SINGLE_QUOTE && level == Level.SINGLE_QUOTE ) { buffer.push(character); level = Level.ROOT; } else if (isQuoted) { buffer.push(character); } else if (character == Marker.OPEN_ROUND_BRACKET) { buffer.push(character); roundBracketLevel++; } else if ( character == Marker.CLOSE_ROUND_BRACKET && roundBracketLevel == 1 && isPseudo ) { buffer.push(character); list.push(buffer.join("")); roundBracketLevel--; buffer = []; isPseudo = false; } else if (character == Marker.CLOSE_ROUND_BRACKET) { buffer.push(character); roundBracketLevel--; } else if ( character == Marker.COLON && roundBracketLevel === 0 && isPseudo && !wasColon ) { list.push(buffer.join("")); buffer = []; buffer.push(character); } else if ( character == Marker.COLON && roundBracketLevel === 0 && !wasColon ) { buffer = []; buffer.push(character); isPseudo = true; } else if ( character == Marker.SPACE && roundBracketLevel === 0 && isPseudo ) { list.push(buffer.join("")); buffer = []; isPseudo = false; } else if (isRelation && roundBracketLevel === 0 && isPseudo) { list.push(buffer.join("")); buffer = []; isPseudo = false; } else { buffer.push(character); } isEscaped = character == Marker.BACK_SLASH; wasColon = character == Marker.COLON; } if (buffer.length > 0 && isPseudo) { list.push(buffer.join("")); } return list; } function areMergeable( selector, matches, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) { return ( areAllowed( matches, mergeablePseudoClasses, mergeablePseudoElements ) && needArguments(matches) && (matches.length < 2 || !someIncorrectlyChained(selector, matches)) && (matches.length < 2 || (multiplePseudoMerging && allMixable(matches))) ); } function areAllowed( matches, mergeablePseudoClasses, mergeablePseudoElements ) { var match; var name; var i, l; for (i = 0, l = matches.length; i < l; i++) { match = matches[i]; name = match.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ? match.substring(0, match.indexOf(Marker.OPEN_ROUND_BRACKET)) : match; if ( mergeablePseudoClasses.indexOf(name) === -1 && mergeablePseudoElements.indexOf(name) === -1 ) { return false; } } return true; } function needArguments(matches) { var match; var name; var bracketOpensAt; var hasArguments; var i, l; for (i = 0, l = matches.length; i < l; i++) { match = matches[i]; bracketOpensAt = match.indexOf(Marker.OPEN_ROUND_BRACKET); hasArguments = bracketOpensAt > -1; name = hasArguments ? match.substring(0, bracketOpensAt) : match; if ( hasArguments && PSEUDO_CLASSES_WITH_ARGUMENTS.indexOf(name) == -1 ) { return false; } if ( !hasArguments && PSEUDO_CLASSES_WITH_ARGUMENTS.indexOf(name) > -1 ) { return false; } } return true; } function someIncorrectlyChained(selector, matches) { var positionInSelector = 0; var match; var matchAt; var nextMatch; var nextMatchAt; var name; var nextName; var areChained; var i, l; for (i = 0, l = matches.length; i < l; i++) { match = matches[i]; nextMatch = matches[i + 1]; if (!nextMatch) { break; } matchAt = selector.indexOf(match, positionInSelector); nextMatchAt = selector.indexOf(match, matchAt + 1); positionInSelector = nextMatchAt; areChained = matchAt + match.length == nextMatchAt; if (areChained) { name = match.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ? match.substring(0, match.indexOf(Marker.OPEN_ROUND_BRACKET)) : match; nextName = nextMatch.indexOf(Marker.OPEN_ROUND_BRACKET) > -1 ? nextMatch.substring( 0, nextMatch.indexOf(Marker.OPEN_ROUND_BRACKET) ) : nextMatch; if (name != NOT_PSEUDO || nextName != NOT_PSEUDO) { return true; } } } return false; } function allMixable(matches) { var unmixableMatches = 0; var match; var i, l; for (i = 0, l = matches.length; i < l; i++) { match = matches[i]; if (isPseudoElement(match)) { unmixableMatches += UNMIXABLE_PSEUDO_ELEMENTS.indexOf(match) > -1 ? 1 : 0; } else { unmixableMatches += UNMIXABLE_PSEUDO_CLASSES.indexOf(match) > -1 ? 1 : 0; } if (unmixableMatches > 1) { return false; } } return true; } function isPseudoElement(pseudo) { return DOUBLE_COLON_PATTERN.test(pseudo); } module.exports = isMergeable; }, { "../../tokenizer/marker": 83, "../../utils/split": 96 } ], 25: [ function(require, module, exports) { var isMergeable = require("./is-mergeable"); var optimizeProperties = require("./properties/optimize"); var sortSelectors = require("../level-1/sort-selectors"); var tidyRules = require("../level-1/tidy-rules"); var OptimizationLevel = require("../../options/optimization-level") .OptimizationLevel; var serializeBody = require("../../writer/one-time").body; var serializeRules = require("../../writer/one-time").rules; var Token = require("../../tokenizer/token"); function mergeAdjacent(tokens, context) { var lastToken = [null, [], []]; var options = context.options; var adjacentSpace = options.compatibility.selectors.adjacentSpace; var selectorsSortingMethod = options.level[OptimizationLevel.One].selectorsSortingMethod; var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses; var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements; var mergeLimit = options.compatibility.selectors.mergeLimit; var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging; for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; if (token[0] != Token.RULE) { lastToken = [null, [], []]; continue; } if ( lastToken[0] == Token.RULE && serializeRules(token[1]) == serializeRules(lastToken[1]) ) { Array.prototype.push.apply(lastToken[2], token[2]); optimizeProperties(lastToken[2], true, true, context); token[2] = []; } else if ( lastToken[0] == Token.RULE && serializeBody(token[2]) == serializeBody(lastToken[2]) && isMergeable( serializeRules(token[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) && isMergeable( serializeRules(lastToken[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) && lastToken[1].length < mergeLimit ) { lastToken[1] = tidyRules( lastToken[1].concat(token[1]), false, adjacentSpace, false, context.warnings ); lastToken[1] = lastToken.length > 1 ? sortSelectors(lastToken[1], selectorsSortingMethod) : lastToken[1]; token[2] = []; } else { lastToken = token; } } } module.exports = mergeAdjacent; }, { "../../options/optimization-level": 65, "../../tokenizer/token": 84, "../../writer/one-time": 98, "../level-1/sort-selectors": 14, "../level-1/tidy-rules": 17, "./is-mergeable": 24, "./properties/optimize": 36 } ], 26: [ function(require, module, exports) { var canReorder = require("./reorderable").canReorder; var canReorderSingle = require("./reorderable").canReorderSingle; var extractProperties = require("./extract-properties"); var rulesOverlap = require("./rules-overlap"); var serializeRules = require("../../writer/one-time").rules; var OptimizationLevel = require("../../options/optimization-level") .OptimizationLevel; var Token = require("../../tokenizer/token"); function mergeMediaQueries(tokens, context) { var mergeSemantically = context.options.level[OptimizationLevel.Two].mergeSemantically; var specificityCache = context.cache.specificity; var candidates = {}; var reduced = []; for (var i = tokens.length - 1; i >= 0; i--) { var token = tokens[i]; if (token[0] != Token.NESTED_BLOCK) { continue; } var key = serializeRules(token[1]); var candidate = candidates[key]; if (!candidate) { candidate = []; candidates[key] = candidate; } candidate.push(i); } for (var name in candidates) { var positions = candidates[name]; positionLoop: for (var j = positions.length - 1; j > 0; j--) { var positionOne = positions[j]; var tokenOne = tokens[positionOne]; var positionTwo = positions[j - 1]; var tokenTwo = tokens[positionTwo]; directionLoop: for ( var direction = 1; direction >= -1; direction -= 2 ) { var topToBottom = direction == 1; var from = topToBottom ? positionOne + 1 : positionTwo - 1; var to = topToBottom ? positionTwo : positionOne; var delta = topToBottom ? 1 : -1; var source = topToBottom ? tokenOne : tokenTwo; var target = topToBottom ? tokenTwo : tokenOne; var movedProperties = extractProperties(source); while (from != to) { var traversedProperties = extractProperties(tokens[from]); from += delta; if ( mergeSemantically && allSameRulePropertiesCanBeReordered( movedProperties, traversedProperties, specificityCache ) ) { continue; } if ( !canReorder( movedProperties, traversedProperties, specificityCache ) ) continue directionLoop; } target[2] = topToBottom ? source[2].concat(target[2]) : target[2].concat(source[2]); source[2] = []; reduced.push(target); continue positionLoop; } } } return reduced; } function allSameRulePropertiesCanBeReordered( movedProperties, traversedProperties, specificityCache ) { var movedProperty; var movedRule; var traversedProperty; var traversedRule; var i, l; var j, m; for (i = 0, l = movedProperties.length; i < l; i++) { movedProperty = movedProperties[i]; movedRule = movedProperty[5]; for (j = 0, m = traversedProperties.length; j < m; j++) { traversedProperty = traversedProperties[j]; traversedRule = traversedProperty[5]; if ( rulesOverlap(movedRule, traversedRule, true) && !canReorderSingle( movedProperty, traversedProperty, specificityCache ) ) { return false; } } } return true; } module.exports = mergeMediaQueries; }, { "../../options/optimization-level": 65, "../../tokenizer/token": 84, "../../writer/one-time": 98, "./extract-properties": 22, "./reorderable": 47, "./rules-overlap": 51 } ], 27: [ function(require, module, exports) { var isMergeable = require("./is-mergeable"); var sortSelectors = require("../level-1/sort-selectors"); var tidyRules = require("../level-1/tidy-rules"); var OptimizationLevel = require("../../options/optimization-level") .OptimizationLevel; var serializeBody = require("../../writer/one-time").body; var serializeRules = require("../../writer/one-time").rules; var Token = require("../../tokenizer/token"); function unsafeSelector(value) { return /\.|\*| :/.test(value); } function isBemElement(token) { var asString = serializeRules(token[1]); return asString.indexOf("__") > -1 || asString.indexOf("--") > -1; } function withoutModifier(selector) { return selector.replace(/--[^ ,>\+~:]+/g, ""); } function removeAnyUnsafeElements(left, candidates) { var leftSelector = withoutModifier(serializeRules(left[1])); for (var body in candidates) { var right = candidates[body]; var rightSelector = withoutModifier(serializeRules(right[1])); if ( rightSelector.indexOf(leftSelector) > -1 || leftSelector.indexOf(rightSelector) > -1 ) delete candidates[body]; } } function mergeNonAdjacentByBody(tokens, context) { var options = context.options; var mergeSemantically = options.level[OptimizationLevel.Two].mergeSemantically; var adjacentSpace = options.compatibility.selectors.adjacentSpace; var selectorsSortingMethod = options.level[OptimizationLevel.One].selectorsSortingMethod; var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses; var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements; var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging; var candidates = {}; for (var i = tokens.length - 1; i >= 0; i--) { var token = tokens[i]; if (token[0] != Token.RULE) continue; if ( token[2].length > 0 && (!mergeSemantically && unsafeSelector(serializeRules(token[1]))) ) candidates = {}; if (token[2].length > 0 && mergeSemantically && isBemElement(token)) removeAnyUnsafeElements(token, candidates); var candidateBody = serializeBody(token[2]); var oldToken = candidates[candidateBody]; if ( oldToken && isMergeable( serializeRules(token[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) && isMergeable( serializeRules(oldToken[1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) ) { if (token[2].length > 0) { token[1] = tidyRules( oldToken[1].concat(token[1]), false, adjacentSpace, false, context.warnings ); token[1] = token[1].length > 1 ? sortSelectors(token[1], selectorsSortingMethod) : token[1]; } else { token[1] = oldToken[1].concat(token[1]); } oldToken[2] = []; candidates[candidateBody] = null; } candidates[serializeBody(token[2])] = token; } } module.exports = mergeNonAdjacentByBody; }, { "../../options/optimization-level": 65, "../../tokenizer/token": 84, "../../writer/one-time": 98, "../level-1/sort-selectors": 14, "../level-1/tidy-rules": 17, "./is-mergeable": 24 } ], 28: [ function(require, module, exports) { var canReorder = require("./reorderable").canReorder; var extractProperties = require("./extract-properties"); var optimizeProperties = require("./properties/optimize"); var serializeRules = require("../../writer/one-time").rules; var Token = require("../../tokenizer/token"); function mergeNonAdjacentBySelector(tokens, context) { var specificityCache = context.cache.specificity; var allSelectors = {}; var repeatedSelectors = []; var i; for (i = tokens.length - 1; i >= 0; i--) { if (tokens[i][0] != Token.RULE) continue; if (tokens[i][2].length === 0) continue; var selector = serializeRules(tokens[i][1]); allSelectors[selector] = [i].concat(allSelectors[selector] || []); if (allSelectors[selector].length == 2) repeatedSelectors.push(selector); } for (i = repeatedSelectors.length - 1; i >= 0; i--) { var positions = allSelectors[repeatedSelectors[i]]; selectorIterator: for (var j = positions.length - 1; j > 0; j--) { var positionOne = positions[j - 1]; var tokenOne = tokens[positionOne]; var positionTwo = positions[j]; var tokenTwo = tokens[positionTwo]; directionIterator: for ( var direction = 1; direction >= -1; direction -= 2 ) { var topToBottom = direction == 1; var from = topToBottom ? positionOne + 1 : positionTwo - 1; var to = topToBottom ? positionTwo : positionOne; var delta = topToBottom ? 1 : -1; var moved = topToBottom ? tokenOne : tokenTwo; var target = topToBottom ? tokenTwo : tokenOne; var movedProperties = extractProperties(moved); while (from != to) { var traversedProperties = extractProperties(tokens[from]); from += delta; // traversed then moved as we move selectors towards the start var reorderable = topToBottom ? canReorder( movedProperties, traversedProperties, specificityCache ) : canReorder( traversedProperties, movedProperties, specificityCache ); if (!reorderable && !topToBottom) continue selectorIterator; if (!reorderable && topToBottom) continue directionIterator; } if (topToBottom) { Array.prototype.push.apply(moved[2], target[2]); target[2] = moved[2]; } else { Array.prototype.push.apply(target[2], moved[2]); } optimizeProperties(target[2], true, true, context); moved[2] = []; } } } } module.exports = mergeNonAdjacentBySelector; }, { "../../tokenizer/token": 84, "../../writer/one-time": 98, "./extract-properties": 22, "./properties/optimize": 36, "./reorderable": 47 } ], 29: [ function(require, module, exports) { var mergeAdjacent = require("./merge-adjacent"); var mergeMediaQueries = require("./merge-media-queries"); var mergeNonAdjacentByBody = require("./merge-non-adjacent-by-body"); var mergeNonAdjacentBySelector = require("./merge-non-adjacent-by-selector"); var reduceNonAdjacent = require("./reduce-non-adjacent"); var removeDuplicateFontAtRules = require("./remove-duplicate-font-at-rules"); var removeDuplicateMediaQueries = require("./remove-duplicate-media-queries"); var removeDuplicates = require("./remove-duplicates"); var removeUnusedAtRules = require("./remove-unused-at-rules"); var restructure = require("./restructure"); var optimizeProperties = require("./properties/optimize"); var OptimizationLevel = require("../../options/optimization-level") .OptimizationLevel; var Token = require("../../tokenizer/token"); function removeEmpty(tokens) { for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; var isEmpty = false; switch (token[0]) { case Token.RULE: isEmpty = token[1].length === 0 || token[2].length === 0; break; case Token.NESTED_BLOCK: removeEmpty(token[2]); isEmpty = token[2].length === 0; break; case Token.AT_RULE: isEmpty = token[1].length === 0; break; case Token.AT_RULE_BLOCK: isEmpty = token[2].length === 0; } if (isEmpty) { tokens.splice(i, 1); i--; l--; } } } function recursivelyOptimizeBlocks(tokens, context) { for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; if (token[0] == Token.NESTED_BLOCK) { var isKeyframes = /@(-moz-|-o-|-webkit-)?keyframes/.test( token[1][0][1] ); level2Optimize(token[2], context, !isKeyframes); } } } function recursivelyOptimizeProperties(tokens, context) { for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; switch (token[0]) { case Token.RULE: optimizeProperties(token[2], true, true, context); break; case Token.NESTED_BLOCK: recursivelyOptimizeProperties(token[2], context); } } } function level2Optimize(tokens, context, withRestructuring) { var levelOptions = context.options.level[OptimizationLevel.Two]; var reduced; var i; recursivelyOptimizeBlocks(tokens, context); recursivelyOptimizeProperties(tokens, context); if (levelOptions.removeDuplicateRules) { removeDuplicates(tokens, context); } if (levelOptions.mergeAdjacentRules) { mergeAdjacent(tokens, context); } if (levelOptions.reduceNonAdjacentRules) { reduceNonAdjacent(tokens, context); } if ( levelOptions.mergeNonAdjacentRules && levelOptions.mergeNonAdjacentRules != "body" ) { mergeNonAdjacentBySelector(tokens, context); } if ( levelOptions.mergeNonAdjacentRules && levelOptions.mergeNonAdjacentRules != "selector" ) { mergeNonAdjacentByBody(tokens, context); } if ( levelOptions.restructureRules && levelOptions.mergeAdjacentRules && withRestructuring ) { restructure(tokens, context); mergeAdjacent(tokens, context); } if ( levelOptions.restructureRules && !levelOptions.mergeAdjacentRules && withRestructuring ) { restructure(tokens, context); } if (levelOptions.removeDuplicateFontRules) { removeDuplicateFontAtRules(tokens, context); } if (levelOptions.removeDuplicateMediaBlocks) { removeDuplicateMediaQueries(tokens, context); } if (levelOptions.removeUnusedAtRules) { removeUnusedAtRules(tokens, context); } if (levelOptions.mergeMedia) { reduced = mergeMediaQueries(tokens, context); for (i = reduced.length - 1; i >= 0; i--) { level2Optimize(reduced[i][2], context, false); } } if (levelOptions.removeEmpty) { removeEmpty(tokens); } return tokens; } module.exports = level2Optimize; }, { "../../options/optimization-level": 65, "../../tokenizer/token": 84, "./merge-adjacent": 25, "./merge-media-queries": 26, "./merge-non-adjacent-by-body": 27, "./merge-non-adjacent-by-selector": 28, "./properties/optimize": 36, "./reduce-non-adjacent": 42, "./remove-duplicate-font-at-rules": 43, "./remove-duplicate-media-queries": 44, "./remove-duplicates": 45, "./remove-unused-at-rules": 46, "./restructure": 50 } ], 30: [ function(require, module, exports) { var Marker = require("../../../tokenizer/marker"); function everyValuesPair(fn, left, right) { var leftSize = left.value.length; var rightSize = right.value.length; var total = Math.max(leftSize, rightSize); var lowerBound = Math.min(leftSize, rightSize) - 1; var leftValue; var rightValue; var position; for (position = 0; position < total; position++) { leftValue = (left.value[position] && left.value[position][1]) || leftValue; rightValue = (right.value[position] && right.value[position][1]) || rightValue; if (leftValue == Marker.COMMA || rightValue == Marker.COMMA) { continue; } if (!fn(leftValue, rightValue, position, position <= lowerBound)) { return false; } } return true; } module.exports = everyValuesPair; }, { "../../../tokenizer/marker": 83 } ], 31: [ function(require, module, exports) { var compactable = require("../compactable"); function findComponentIn(shorthand, longhand) { var comparator = nameComparator(longhand); return ( findInDirectComponents(shorthand, comparator) || findInSubComponents(shorthand, comparator) ); } function nameComparator(to) { return function(property) { return to.name === property.name; }; } function findInDirectComponents(shorthand, comparator) { return shorthand.components.filter(comparator)[0]; } function findInSubComponents(shorthand, comparator) { var shorthandComponent; var longhandMatch; var i, l; if (!compactable[shorthand.name].shorthandComponents) { return; } for (i = 0, l = shorthand.components.length; i < l; i++) { shorthandComponent = shorthand.components[i]; longhandMatch = findInDirectComponents( shorthandComponent, comparator ); if (longhandMatch) { return longhandMatch; } } return; } module.exports = findComponentIn; }, { "../compactable": 21 } ], 32: [ function(require, module, exports) { function hasInherit(property) { for (var i = property.value.length - 1; i >= 0; i--) { if (property.value[i][1] == "inherit") return true; } return false; } module.exports = hasInherit; }, {} ], 33: [ function(require, module, exports) { var compactable = require("../compactable"); function isComponentOf(property1, property2, shallow) { return ( isDirectComponentOf(property1, property2) || (!shallow && !!compactable[property1.name].shorthandComponents && isSubComponentOf(property1, property2)) ); } function isDirectComponentOf(property1, property2) { var descriptor = compactable[property1.name]; return ( "components" in descriptor && descriptor.components.indexOf(property2.name) > -1 ); } function isSubComponentOf(property1, property2) { return property1.components.some(function(component) { return isDirectComponentOf(component, property2); }); } module.exports = isComponentOf; }, { "../compactable": 21 } ], 34: [ function(require, module, exports) { var Marker = require("../../../tokenizer/marker"); function isMergeableShorthand(shorthand) { if (shorthand.name != "font") { return true; } return shorthand.value[0][1].indexOf(Marker.INTERNAL) == -1; } module.exports = isMergeableShorthand; }, { "../../../tokenizer/marker": 83 } ], 35: [ function(require, module, exports) { var everyValuesPair = require("./every-values-pair"); var hasInherit = require("./has-inherit"); var populateComponents = require("./populate-components"); var compactable = require("../compactable"); var deepClone = require("../clone").deep; var restoreWithComponents = require("../restore-with-components"); var restoreFromOptimizing = require("../../restore-from-optimizing"); var wrapSingle = require("../../wrap-for-optimizing").single; var serializeBody = require("../../../writer/one-time").body; var Token = require("../../../tokenizer/token"); function mergeIntoShorthands(properties, validator) { var candidates = {}; var descriptor; var componentOf; var property; var i, l; var j, m; // there is no shorthand property made up of less than 3 longhands if (properties.length < 3) { return; } for (i = 0, l = properties.length; i < l; i++) { property = properties[i]; descriptor = compactable[property.name]; if (property.unused) { continue; } if (property.hack) { continue; } if (property.block) { continue; } invalidateOrCompact(properties, i, candidates, validator); if (descriptor && descriptor.componentOf) { for (j = 0, m = descriptor.componentOf.length; j < m; j++) { componentOf = descriptor.componentOf[j]; candidates[componentOf] = candidates[componentOf] || {}; candidates[componentOf][property.name] = property; } } } invalidateOrCompact(properties, i, candidates, validator); } function invalidateOrCompact( properties, position, candidates, validator ) { var invalidatedBy = properties[position]; var shorthandName; var shorthandDescriptor; var candidateComponents; for (shorthandName in candidates) { if ( undefined !== invalidatedBy && shorthandName == invalidatedBy.name ) { continue; } shorthandDescriptor = compactable[shorthandName]; candidateComponents = candidates[shorthandName]; if ( invalidatedBy && invalidates(candidates, shorthandName, invalidatedBy) ) { delete candidates[shorthandName]; continue; } if ( shorthandDescriptor.components.length > Object.keys(candidateComponents).length ) { continue; } if (mixedImportance(candidateComponents)) { continue; } if (!overridable(candidateComponents, shorthandName, validator)) { continue; } if (!mergeable(candidateComponents)) { continue; } if (mixedInherit(candidateComponents)) { replaceWithInheritBestFit( properties, candidateComponents, shorthandName, validator ); } else { replaceWithShorthand( properties, candidateComponents, shorthandName, validator ); } } } function invalidates(candidates, shorthandName, invalidatedBy) { var shorthandDescriptor = compactable[shorthandName]; var invalidatedByDescriptor = compactable[invalidatedBy.name]; var componentName; if ( "overridesShorthands" in shorthandDescriptor && shorthandDescriptor.overridesShorthands.indexOf( invalidatedBy.name ) > -1 ) { return true; } if ( invalidatedByDescriptor && "componentOf" in invalidatedByDescriptor ) { for (componentName in candidates[shorthandName]) { if ( invalidatedByDescriptor.componentOf.indexOf(componentName) > -1 ) { return true; } } } return false; } function mixedImportance(components) { var important; var componentName; for (componentName in components) { if ( undefined !== important && components[componentName].important != important ) { return true; } important = components[componentName].important; } return false; } function overridable(components, shorthandName, validator) { var descriptor = compactable[shorthandName]; var newValuePlaceholder = [ Token.PROPERTY, [Token.PROPERTY_NAME, shorthandName], [Token.PROPERTY_VALUE, descriptor.defaultValue] ]; var newProperty = wrapSingle(newValuePlaceholder); var component; var mayOverride; var i, l; populateComponents([newProperty], validator, []); for (i = 0, l = descriptor.components.length; i < l; i++) { component = components[descriptor.components[i]]; mayOverride = compactable[component.name].canOverride; if ( !everyValuesPair( mayOverride.bind(null, validator), newProperty.components[i], component ) ) { return false; } } return true; } function mergeable(components) { var lastCount = null; var currentCount; var componentName; var component; var descriptor; var values; for (componentName in components) { component = components[componentName]; descriptor = compactable[componentName]; if (!("restore" in descriptor)) { continue; } restoreFromOptimizing( [component.all[component.position]], restoreWithComponents ); values = descriptor.restore(component, compactable); currentCount = values.length; if (lastCount !== null && currentCount !== lastCount) { return false; } lastCount = currentCount; } return true; } function mixedInherit(components) { var componentName; var lastValue = null; var currentValue; for (componentName in components) { currentValue = hasInherit(components[componentName]); if (lastValue !== null && lastValue !== currentValue) { return true; } lastValue = currentValue; } return false; } function replaceWithInheritBestFit( properties, candidateComponents, shorthandName, validator ) { var viaLonghands = buildSequenceWithInheritLonghands( candidateComponents, shorthandName, validator ); var viaShorthand = buildSequenceWithInheritShorthand( candidateComponents, shorthandName, validator ); var longhandTokensSequence = viaLonghands[0]; var shorthandTokensSequence = viaShorthand[0]; var isLonghandsShorter = serializeBody(longhandTokensSequence).length < serializeBody(shorthandTokensSequence).length; var newTokensSequence = isLonghandsShorter ? longhandTokensSequence : shorthandTokensSequence; var newProperty = isLonghandsShorter ? viaLonghands[1] : viaShorthand[1]; var newComponents = isLonghandsShorter ? viaLonghands[2] : viaShorthand[2]; var all = candidateComponents[Object.keys(candidateComponents)[0]].all; var componentName; var oldComponent; var newComponent; var newToken; newProperty.position = all.length; newProperty.shorthand = true; newProperty.dirty = true; newProperty.all = all; newProperty.all.push(newTokensSequence[0]); properties.push(newProperty); for (componentName in candidateComponents) { oldComponent = candidateComponents[componentName]; oldComponent.unused = true; if (oldComponent.name in newComponents) { newComponent = newComponents[oldComponent.name]; newToken = findTokenIn(newTokensSequence, componentName); newComponent.position = all.length; newComponent.all = all; newComponent.all.push(newToken); properties.push(newComponent); } } } function buildSequenceWithInheritLonghands( components, shorthandName, validator ) { var tokensSequence = []; var inheritComponents = {}; var nonInheritComponents = {}; var descriptor = compactable[shorthandName]; var shorthandToken = [ Token.PROPERTY, [Token.PROPERTY_NAME, shorthandName], [Token.PROPERTY_VALUE, descriptor.defaultValue] ]; var newProperty = wrapSingle(shorthandToken); var component; var longhandToken; var newComponent; var nameMetadata; var i, l; populateComponents([newProperty], validator, []); for (i = 0, l = descriptor.components.length; i < l; i++) { component = components[descriptor.components[i]]; if (hasInherit(component)) { longhandToken = component.all[component.position].slice(0, 2); Array.prototype.push.apply(longhandToken, component.value); tokensSequence.push(longhandToken); newComponent = deepClone(component); newComponent.value = inferComponentValue( components, newComponent.name ); newProperty.components[i] = newComponent; inheritComponents[component.name] = deepClone(component); } else { newComponent = deepClone(component); newComponent.all = component.all; newProperty.components[i] = newComponent; nonInheritComponents[component.name] = component; } } nameMetadata = joinMetadata(nonInheritComponents, 1); shorthandToken[1].push(nameMetadata); restoreFromOptimizing([newProperty], restoreWithComponents); shorthandToken = shorthandToken.slice(0, 2); Array.prototype.push.apply(shorthandToken, newProperty.value); tokensSequence.unshift(shorthandToken); return [tokensSequence, newProperty, inheritComponents]; } function inferComponentValue(components, propertyName) { var descriptor = compactable[propertyName]; if ("oppositeTo" in descriptor) { return components[descriptor.oppositeTo].value; } else { return [[Token.PROPERTY_VALUE, descriptor.defaultValue]]; } } function joinMetadata(components, at) { var metadata = []; var component; var originalValue; var componentMetadata; var componentName; for (componentName in components) { component = components[componentName]; originalValue = component.all[component.position]; componentMetadata = originalValue[at][originalValue[at].length - 1]; Array.prototype.push.apply(metadata, componentMetadata); } return metadata.sort(metadataSorter); } function metadataSorter(metadata1, metadata2) { var line1 = metadata1[0]; var line2 = metadata2[0]; var column1 = metadata1[1]; var column2 = metadata2[1]; if (line1 < line2) { return -1; } else if (line1 === line2) { return column1 < column2 ? -1 : 1; } else { return 1; } } function buildSequenceWithInheritShorthand( components, shorthandName, validator ) { var tokensSequence = []; var inheritComponents = {}; var nonInheritComponents = {}; var descriptor = compactable[shorthandName]; var shorthandToken = [ Token.PROPERTY, [Token.PROPERTY_NAME, shorthandName], [Token.PROPERTY_VALUE, "inherit"] ]; var newProperty = wrapSingle(shorthandToken); var component; var longhandToken; var nameMetadata; var valueMetadata; var i, l; populateComponents([newProperty], validator, []); for (i = 0, l = descriptor.components.length; i < l; i++) { component = components[descriptor.components[i]]; if (hasInherit(component)) { inheritComponents[component.name] = component; } else { longhandToken = component.all[component.position].slice(0, 2); Array.prototype.push.apply(longhandToken, component.value); tokensSequence.push(longhandToken); nonInheritComponents[component.name] = deepClone(component); } } nameMetadata = joinMetadata(inheritComponents, 1); shorthandToken[1].push(nameMetadata); valueMetadata = joinMetadata(inheritComponents, 2); shorthandToken[2].push(valueMetadata); tokensSequence.unshift(shorthandToken); return [tokensSequence, newProperty, nonInheritComponents]; } function findTokenIn(tokens, componentName) { var i, l; for (i = 0, l = tokens.length; i < l; i++) { if (tokens[i][1][1] == componentName) { return tokens[i]; } } } function replaceWithShorthand( properties, candidateComponents, shorthandName, validator ) { var descriptor = compactable[shorthandName]; var nameMetadata; var valueMetadata; var newValuePlaceholder = [ Token.PROPERTY, [Token.PROPERTY_NAME, shorthandName], [Token.PROPERTY_VALUE, descriptor.defaultValue] ]; var all; var newProperty = wrapSingle(newValuePlaceholder); newProperty.shorthand = true; newProperty.dirty = true; populateComponents([newProperty], validator, []); for (var i = 0, l = descriptor.components.length; i < l; i++) { var component = candidateComponents[descriptor.components[i]]; newProperty.components[i] = deepClone(component); newProperty.important = component.important; all = component.all; } for (var componentName in candidateComponents) { candidateComponents[componentName].unused = true; } nameMetadata = joinMetadata(candidateComponents, 1); newValuePlaceholder[1].push(nameMetadata); valueMetadata = joinMetadata(candidateComponents, 2); newValuePlaceholder[2].push(valueMetadata); newProperty.position = all.length; newProperty.all = all; newProperty.all.push(newValuePlaceholder); properties.push(newProperty); } module.exports = mergeIntoShorthands; }, { "../../../tokenizer/token": 84, "../../../writer/one-time": 98, "../../restore-from-optimizing": 56, "../../wrap-for-optimizing": 58, "../clone": 20, "../compactable": 21, "../restore-with-components": 48, "./every-values-pair": 30, "./has-inherit": 32, "./populate-components": 39 } ], 36: [ function(require, module, exports) { var mergeIntoShorthands = require("./merge-into-shorthands"); var overrideProperties = require("./override-properties"); var populateComponents = require("./populate-components"); var restoreWithComponents = require("../restore-with-components"); var wrapForOptimizing = require("../../wrap-for-optimizing").all; var removeUnused = require("../../remove-unused"); var restoreFromOptimizing = require("../../restore-from-optimizing"); var OptimizationLevel = require("../../../options/optimization-level") .OptimizationLevel; function optimizeProperties( properties, withOverriding, withMerging, context ) { var levelOptions = context.options.level[OptimizationLevel.Two]; var _properties = wrapForOptimizing( properties, false, levelOptions.skipProperties ); var _property; var i, l; populateComponents(_properties, context.validator, context.warnings); for (i = 0, l = _properties.length; i < l; i++) { _property = _properties[i]; if (_property.block) { optimizeProperties( _property.value[0][1], withOverriding, withMerging, context ); } } if (withMerging && levelOptions.mergeIntoShorthands) { mergeIntoShorthands(_properties, context.validator); } if (withOverriding && levelOptions.overrideProperties) { overrideProperties( _properties, withMerging, context.options.compatibility, context.validator ); } restoreFromOptimizing(_properties, restoreWithComponents); removeUnused(_properties); } module.exports = optimizeProperties; }, { "../../../options/optimization-level": 65, "../../remove-unused": 55, "../../restore-from-optimizing": 56, "../../wrap-for-optimizing": 58, "../restore-with-components": 48, "./merge-into-shorthands": 35, "./override-properties": 37, "./populate-components": 39 } ], 37: [ function(require, module, exports) { var hasInherit = require("./has-inherit"); var everyValuesPair = require("./every-values-pair"); var findComponentIn = require("./find-component-in"); var isComponentOf = require("./is-component-of"); var isMergeableShorthand = require("./is-mergeable-shorthand"); var overridesNonComponentShorthand = require("./overrides-non-component-shorthand"); var sameVendorPrefixesIn = require("./vendor-prefixes").same; var compactable = require("../compactable"); var deepClone = require("../clone").deep; var restoreWithComponents = require("../restore-with-components"); var shallowClone = require("../clone").shallow; var restoreFromOptimizing = require("../../restore-from-optimizing"); var Token = require("../../../tokenizer/token"); var Marker = require("../../../tokenizer/marker"); var serializeProperty = require("../../../writer/one-time").property; function wouldBreakCompatibility(property, validator) { for (var i = 0; i < property.components.length; i++) { var component = property.components[i]; var descriptor = compactable[component.name]; var canOverride = (descriptor && descriptor.canOverride) || canOverride.sameValue; var _component = shallowClone(component); _component.value = [ [Token.PROPERTY_VALUE, descriptor.defaultValue] ]; if ( !everyValuesPair( canOverride.bind(null, validator), _component, component ) ) { return true; } } return false; } function overrideIntoMultiplex(property, by) { by.unused = true; turnIntoMultiplex(by, multiplexSize(property)); property.value = by.value; } function overrideByMultiplex(property, by) { by.unused = true; property.multiplex = true; property.value = by.value; } function overrideSimple(property, by) { by.unused = true; property.value = by.value; } function override(property, by) { if (by.multiplex) overrideByMultiplex(property, by); else if (property.multiplex) overrideIntoMultiplex(property, by); else overrideSimple(property, by); } function overrideShorthand(property, by) { by.unused = true; for (var i = 0, l = property.components.length; i < l; i++) { override( property.components[i], by.components[i], property.multiplex ); } } function turnIntoMultiplex(property, size) { property.multiplex = true; if (compactable[property.name].shorthand) { turnShorthandValueIntoMultiplex(property, size); } else { turnLonghandValueIntoMultiplex(property, size); } } function turnShorthandValueIntoMultiplex(property, size) { var component; var i, l; for (i = 0, l = property.components.length; i < l; i++) { component = property.components[i]; if (!component.multiplex) { turnLonghandValueIntoMultiplex(component, size); } } } function turnLonghandValueIntoMultiplex(property, size) { var descriptor = compactable[property.name]; var withRealValue = descriptor.intoMultiplexMode == "real"; var withValue = descriptor.intoMultiplexMode == "real" ? property.value.slice(0) : descriptor.intoMultiplexMode == "placeholder" ? descriptor.placeholderValue : descriptor.defaultValue; var i = multiplexSize(property); var j; var m = withValue.length; for (; i < size; i++) { property.value.push([Token.PROPERTY_VALUE, Marker.COMMA]); if (Array.isArray(withValue)) { for (j = 0; j < m; j++) { property.value.push( withRealValue ? withValue[j] : [Token.PROPERTY_VALUE, withValue[j]] ); } } else { property.value.push( withRealValue ? withValue : [Token.PROPERTY_VALUE, withValue] ); } } } function multiplexSize(component) { var size = 0; for (var i = 0, l = component.value.length; i < l; i++) { if (component.value[i][1] == Marker.COMMA) size++; } return size + 1; } function lengthOf(property) { var fakeAsArray = [ Token.PROPERTY, [Token.PROPERTY_NAME, property.name] ].concat(property.value); return serializeProperty([fakeAsArray], 0).length; } function moreSameShorthands(properties, startAt, name) { // Since we run the main loop in `compactOverrides` backwards, at this point some // properties may not be marked as unused. // We should consider reverting the order if possible var count = 0; for (var i = startAt; i >= 0; i--) { if (properties[i].name == name && !properties[i].unused) count++; if (count > 1) break; } return count > 1; } function overridingFunction(shorthand, validator) { for (var i = 0, l = shorthand.components.length; i < l; i++) { if ( !anyValue(validator.isUrl, shorthand.components[i]) && anyValue(validator.isFunction, shorthand.components[i]) ) { return true; } } return false; } function anyValue(fn, property) { for (var i = 0, l = property.value.length; i < l; i++) { if (property.value[i][1] == Marker.COMMA) continue; if (fn(property.value[i][1])) return true; } return false; } function wouldResultInLongerValue(left, right) { if ( (!left.multiplex && !right.multiplex) || (left.multiplex && right.multiplex) ) return false; var multiplex = left.multiplex ? left : right; var simple = left.multiplex ? right : left; var component; var multiplexClone = deepClone(multiplex); restoreFromOptimizing([multiplexClone], restoreWithComponents); var simpleClone = deepClone(simple); restoreFromOptimizing([simpleClone], restoreWithComponents); var lengthBefore = lengthOf(multiplexClone) + 1 + lengthOf(simpleClone); if (left.multiplex) { component = findComponentIn(multiplexClone, simpleClone); overrideIntoMultiplex(component, simpleClone); } else { component = findComponentIn(simpleClone, multiplexClone); turnIntoMultiplex(simpleClone, multiplexSize(multiplexClone)); overrideByMultiplex(component, multiplexClone); } restoreFromOptimizing([simpleClone], restoreWithComponents); var lengthAfter = lengthOf(simpleClone); return lengthBefore <= lengthAfter; } function isCompactable(property) { return property.name in compactable; } function noneOverrideHack(left, right) { return ( !left.multiplex && (left.name == "background" || left.name == "background-image") && right.multiplex && (right.name == "background" || right.name == "background-image") && anyLayerIsNone(right.value) ); } function anyLayerIsNone(values) { var layers = intoLayers(values); for (var i = 0, l = layers.length; i < l; i++) { if (layers[i].length == 1 && layers[i][0][1] == "none") return true; } return false; } function intoLayers(values) { var layers = []; for (var i = 0, layer = [], l = values.length; i < l; i++) { var value = values[i]; if (value[1] == Marker.COMMA) { layers.push(layer); layer = []; } else { layer.push(value); } } layers.push(layer); return layers; } function overrideProperties( properties, withMerging, compatibility, validator ) { var mayOverride, right, left, component; var overriddenComponents; var overriddenComponent; var overridingComponent; var overridable; var i, j, k; propertyLoop: for (i = properties.length - 1; i >= 0; i--) { right = properties[i]; if (!isCompactable(right)) continue; if (right.block) continue; mayOverride = compactable[right.name].canOverride; traverseLoop: for (j = i - 1; j >= 0; j--) { left = properties[j]; if (!isCompactable(left)) continue; if (left.block) continue; if (left.unused || right.unused) continue; if ( (left.hack && !right.hack && !right.important) || (!left.hack && !left.important && right.hack) ) continue; if ( left.important == right.important && left.hack[0] != right.hack[0] ) continue; if ( left.important == right.important && (left.hack[0] != right.hack[0] || (left.hack[1] && left.hack[1] != right.hack[1])) ) continue; if (hasInherit(right)) continue; if (noneOverrideHack(left, right)) continue; if (right.shorthand && isComponentOf(right, left)) { // maybe `left` can be overridden by `right` which is a shorthand? if (!right.important && left.important) continue; if (!sameVendorPrefixesIn([left], right.components)) continue; if ( !anyValue(validator.isFunction, left) && overridingFunction(right, validator) ) continue; if (!isMergeableShorthand(right)) { left.unused = true; continue; } component = findComponentIn(right, left); mayOverride = compactable[left.name].canOverride; if ( everyValuesPair( mayOverride.bind(null, validator), left, component ) ) { left.unused = true; } } else if ( right.shorthand && overridesNonComponentShorthand(right, left) ) { // `right` is a shorthand while `left` can be overriden by it, think `border` and `border-top` if (!right.important && left.important) { continue; } if (!sameVendorPrefixesIn([left], right.components)) { continue; } if ( !anyValue(validator.isFunction, left) && overridingFunction(right, validator) ) { continue; } overriddenComponents = left.shorthand ? left.components : [left]; for (k = overriddenComponents.length - 1; k >= 0; k--) { overriddenComponent = overriddenComponents[k]; overridingComponent = findComponentIn( right, overriddenComponent ); mayOverride = compactable[overriddenComponent.name].canOverride; if ( !everyValuesPair( mayOverride.bind(null, validator), left, overridingComponent ) ) { continue traverseLoop; } } left.unused = true; } else if ( withMerging && left.shorthand && !right.shorthand && isComponentOf(left, right, true) ) { // maybe `right` can be pulled into `left` which is a shorthand? if (right.important && !left.important) continue; if (!right.important && left.important) { right.unused = true; continue; } // Pending more clever algorithm in #527 if (moreSameShorthands(properties, i - 1, left.name)) continue; if (overridingFunction(left, validator)) continue; if (!isMergeableShorthand(left)) continue; component = findComponentIn(left, right); if ( everyValuesPair( mayOverride.bind(null, validator), component, right ) ) { var disabledBackgroundMerging = (!compatibility.properties.backgroundClipMerging && component.name.indexOf("background-clip") > -1) || (!compatibility.properties.backgroundOriginMerging && component.name.indexOf("background-origin") > -1) || (!compatibility.properties.backgroundSizeMerging && component.name.indexOf("background-size") > -1); var nonMergeableValue = compactable[right.name].nonMergeableValue === right.value[0][1]; if (disabledBackgroundMerging || nonMergeableValue) continue; if ( !compatibility.properties.merging && wouldBreakCompatibility(left, validator) ) continue; if ( component.value[0][1] != right.value[0][1] && (hasInherit(left) || hasInherit(right)) ) continue; if (wouldResultInLongerValue(left, right)) continue; if (!left.multiplex && right.multiplex) turnIntoMultiplex(left, multiplexSize(right)); override(component, right); left.dirty = true; } } else if ( withMerging && left.shorthand && right.shorthand && left.name == right.name ) { // merge if all components can be merged if (!left.multiplex && right.multiplex) continue; if (!right.important && left.important) { right.unused = true; continue propertyLoop; } if (right.important && !left.important) { left.unused = true; continue; } if (!isMergeableShorthand(right)) { left.unused = true; continue; } for (k = left.components.length - 1; k >= 0; k--) { var leftComponent = left.components[k]; var rightComponent = right.components[k]; mayOverride = compactable[leftComponent.name].canOverride; if ( !everyValuesPair( mayOverride.bind(null, validator), leftComponent, rightComponent ) ) continue propertyLoop; } overrideShorthand(left, right); left.dirty = true; } else if ( withMerging && left.shorthand && right.shorthand && isComponentOf(left, right) ) { // border is a shorthand but any of its components is a shorthand too if (!left.important && right.important) continue; component = findComponentIn(left, right); mayOverride = compactable[right.name].canOverride; if ( !everyValuesPair( mayOverride.bind(null, validator), component, right ) ) continue; if (left.important && !right.important) { right.unused = true; continue; } var rightRestored = compactable[right.name].restore( right, compactable ); if (rightRestored.length > 1) continue; component = findComponentIn(left, right); override(component, right); right.dirty = true; } else if (left.name == right.name) { // two non-shorthands should be merged based on understandability overridable = true; if (right.shorthand) { for ( k = right.components.length - 1; k >= 0 && overridable; k-- ) { overriddenComponent = left.components[k]; overridingComponent = right.components[k]; mayOverride = compactable[overridingComponent.name].canOverride; overridable = overridable && everyValuesPair( mayOverride.bind(null, validator), overriddenComponent, overridingComponent ); } } else { mayOverride = compactable[right.name].canOverride; overridable = everyValuesPair( mayOverride.bind(null, validator), left, right ); } if (left.important && !right.important && overridable) { right.unused = true; continue; } if (!left.important && right.important && overridable) { left.unused = true; continue; } if (!overridable) { continue; } left.unused = true; } } } } module.exports = overrideProperties; }, { "../../../tokenizer/marker": 83, "../../../tokenizer/token": 84, "../../../writer/one-time": 98, "../../restore-from-optimizing": 56, "../clone": 20, "../compactable": 21, "../restore-with-components": 48, "./every-values-pair": 30, "./find-component-in": 31, "./has-inherit": 32, "./is-component-of": 33, "./is-mergeable-shorthand": 34, "./overrides-non-component-shorthand": 38, "./vendor-prefixes": 41 } ], 38: [ function(require, module, exports) { var compactable = require("../compactable"); function overridesNonComponentShorthand(property1, property2) { return ( property1.name in compactable && "overridesShorthands" in compactable[property1.name] && compactable[property1.name].overridesShorthands.indexOf( property2.name ) > -1 ); } module.exports = overridesNonComponentShorthand; }, { "../compactable": 21 } ], 39: [ function(require, module, exports) { var compactable = require("../compactable"); var InvalidPropertyError = require("../invalid-property-error"); function populateComponents(properties, validator, warnings) { var component; var j, m; for (var i = properties.length - 1; i >= 0; i--) { var property = properties[i]; var descriptor = compactable[property.name]; if (descriptor && descriptor.shorthand) { property.shorthand = true; property.dirty = true; try { property.components = descriptor.breakUp( property, compactable, validator ); if (descriptor.shorthandComponents) { for (j = 0, m = property.components.length; j < m; j++) { component = property.components[j]; component.components = compactable[component.name].breakUp( component, compactable, validator ); } } } catch (e) { if (e instanceof InvalidPropertyError) { property.components = []; // this will set property.unused to true below warnings.push(e.message); } else { throw e; } } if (property.components.length > 0) property.multiplex = property.components[0].multiplex; else property.unused = true; } } } module.exports = populateComponents; }, { "../compactable": 21, "../invalid-property-error": 23 } ], 40: [ function(require, module, exports) { var sameVendorPrefixes = require("./vendor-prefixes").same; function understandable( validator, value1, value2, _position, isPaired ) { if (!sameVendorPrefixes(value1, value2)) { return false; } if ( isPaired && validator.isVariable(value1) !== validator.isVariable(value2) ) { return false; } return true; } module.exports = understandable; }, { "./vendor-prefixes": 41 } ], 41: [ function(require, module, exports) { var VENDOR_PREFIX_PATTERN = /(?:^|\W)(\-\w+\-)/g; function unique(value) { var prefixes = []; var match; while ((match = VENDOR_PREFIX_PATTERN.exec(value)) !== null) { if (prefixes.indexOf(match[0]) == -1) { prefixes.push(match[0]); } } return prefixes; } function same(value1, value2) { return ( unique(value1) .sort() .join(",") == unique(value2) .sort() .join(",") ); } module.exports = { unique: unique, same: same }; }, {} ], 42: [ function(require, module, exports) { var isMergeable = require("./is-mergeable"); var optimizeProperties = require("./properties/optimize"); var cloneArray = require("../../utils/clone-array"); var Token = require("../../tokenizer/token"); var serializeBody = require("../../writer/one-time").body; var serializeRules = require("../../writer/one-time").rules; function reduceNonAdjacent(tokens, context) { var options = context.options; var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses; var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements; var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging; var candidates = {}; var repeated = []; for (var i = tokens.length - 1; i >= 0; i--) { var token = tokens[i]; if (token[0] != Token.RULE) { continue; } else if (token[2].length === 0) { continue; } var selectorAsString = serializeRules(token[1]); var isComplexAndNotSpecial = token[1].length > 1 && isMergeable( selectorAsString, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ); var wrappedSelectors = wrappedSelectorsFrom(token[1]); var selectors = isComplexAndNotSpecial ? [selectorAsString].concat(wrappedSelectors) : [selectorAsString]; for (var j = 0, m = selectors.length; j < m; j++) { var selector = selectors[j]; if (!candidates[selector]) candidates[selector] = []; else repeated.push(selector); candidates[selector].push({ where: i, list: wrappedSelectors, isPartial: isComplexAndNotSpecial && j > 0, isComplex: isComplexAndNotSpecial && j === 0 }); } } reduceSimpleNonAdjacentCases( tokens, repeated, candidates, options, context ); reduceComplexNonAdjacentCases(tokens, candidates, options, context); } function wrappedSelectorsFrom(list) { var wrapped = []; for (var i = 0; i < list.length; i++) { wrapped.push([list[i][1]]); } return wrapped; } function reduceSimpleNonAdjacentCases( tokens, repeated, candidates, options, context ) { function filterOut(idx, bodies) { return data[idx].isPartial && bodies.length === 0; } function reduceBody(token, newBody, processedCount, tokenIdx) { if (!data[processedCount - tokenIdx - 1].isPartial) token[2] = newBody; } for (var i = 0, l = repeated.length; i < l; i++) { var selector = repeated[i]; var data = candidates[selector]; reduceSelector( tokens, data, { filterOut: filterOut, callback: reduceBody }, options, context ); } } function reduceComplexNonAdjacentCases( tokens, candidates, options, context ) { var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses; var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements; var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging; var localContext = {}; function filterOut(idx) { return localContext.data[idx].where < localContext.intoPosition; } function collectReducedBodies( token, newBody, processedCount, tokenIdx ) { if (tokenIdx === 0) localContext.reducedBodies.push(newBody); } allSelectors: for (var complexSelector in candidates) { var into = candidates[complexSelector]; if (!into[0].isComplex) continue; var intoPosition = into[into.length - 1].where; var intoToken = tokens[intoPosition]; var reducedBodies = []; var selectors = isMergeable( complexSelector, mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) ? into[0].list : [complexSelector]; localContext.intoPosition = intoPosition; localContext.reducedBodies = reducedBodies; for (var j = 0, m = selectors.length; j < m; j++) { var selector = selectors[j]; var data = candidates[selector]; if (data.length < 2) continue allSelectors; localContext.data = data; reduceSelector( tokens, data, { filterOut: filterOut, callback: collectReducedBodies }, options, context ); if ( serializeBody(reducedBodies[reducedBodies.length - 1]) != serializeBody(reducedBodies[0]) ) continue allSelectors; } intoToken[2] = reducedBodies[0]; } } function reduceSelector(tokens, data, context, options, outerContext) { var bodies = []; var bodiesAsList = []; var processedTokens = []; for (var j = data.length - 1; j >= 0; j--) { if (context.filterOut(j, bodies)) continue; var where = data[j].where; var token = tokens[where]; var clonedBody = cloneArray(token[2]); bodies = bodies.concat(clonedBody); bodiesAsList.push(clonedBody); processedTokens.push(where); } optimizeProperties(bodies, true, false, outerContext); var processedCount = processedTokens.length; var propertyIdx = bodies.length - 1; var tokenIdx = processedCount - 1; while (tokenIdx >= 0) { if ( (tokenIdx === 0 || (bodies[propertyIdx] && bodiesAsList[tokenIdx].indexOf(bodies[propertyIdx]) > -1)) && propertyIdx > -1 ) { propertyIdx--; continue; } var newBody = bodies.splice(propertyIdx + 1); context.callback( tokens[processedTokens[tokenIdx]], newBody, processedCount, tokenIdx ); tokenIdx--; } } module.exports = reduceNonAdjacent; }, { "../../tokenizer/token": 84, "../../utils/clone-array": 86, "../../writer/one-time": 98, "./is-mergeable": 24, "./properties/optimize": 36 } ], 43: [ function(require, module, exports) { var Token = require("../../tokenizer/token"); var serializeAll = require("../../writer/one-time").all; var FONT_FACE_SCOPE = "@font-face"; function removeDuplicateFontAtRules(tokens) { var fontAtRules = []; var token; var key; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; if ( token[0] != Token.AT_RULE_BLOCK && token[1][0][1] != FONT_FACE_SCOPE ) { continue; } key = serializeAll([token]); if (fontAtRules.indexOf(key) > -1) { token[2] = []; } else { fontAtRules.push(key); } } } module.exports = removeDuplicateFontAtRules; }, { "../../tokenizer/token": 84, "../../writer/one-time": 98 } ], 44: [ function(require, module, exports) { var Token = require("../../tokenizer/token"); var serializeAll = require("../../writer/one-time").all; var serializeRules = require("../../writer/one-time").rules; function removeDuplicateMediaQueries(tokens) { var candidates = {}; var candidate; var token; var key; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; if (token[0] != Token.NESTED_BLOCK) { continue; } key = serializeRules(token[1]) + "%" + serializeAll(token[2]); candidate = candidates[key]; if (candidate) { candidate[2] = []; } candidates[key] = token; } } module.exports = removeDuplicateMediaQueries; }, { "../../tokenizer/token": 84, "../../writer/one-time": 98 } ], 45: [ function(require, module, exports) { var Token = require("../../tokenizer/token"); var serializeBody = require("../../writer/one-time").body; var serializeRules = require("../../writer/one-time").rules; function removeDuplicates(tokens) { var matched = {}; var moreThanOnce = []; var id, token; var body, bodies; for (var i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; if (token[0] != Token.RULE) continue; id = serializeRules(token[1]); if (matched[id] && matched[id].length == 1) moreThanOnce.push(id); else matched[id] = matched[id] || []; matched[id].push(i); } for (i = 0, l = moreThanOnce.length; i < l; i++) { id = moreThanOnce[i]; bodies = []; for (var j = matched[id].length - 1; j >= 0; j--) { token = tokens[matched[id][j]]; body = serializeBody(token[2]); if (bodies.indexOf(body) > -1) token[2] = []; else bodies.push(body); } } } module.exports = removeDuplicates; }, { "../../tokenizer/token": 84, "../../writer/one-time": 98 } ], 46: [ function(require, module, exports) { var populateComponents = require("./properties/populate-components"); var wrapForOptimizing = require("../wrap-for-optimizing").single; var restoreFromOptimizing = require("../restore-from-optimizing"); var Token = require("../../tokenizer/token"); var animationNameRegex = /^(\-moz\-|\-o\-|\-webkit\-)?animation-name$/; var animationRegex = /^(\-moz\-|\-o\-|\-webkit\-)?animation$/; var keyframeRegex = /^@(\-moz\-|\-o\-|\-webkit\-)?keyframes /; var importantRegex = /\s{0,31}!important$/; var optionalMatchingQuotesRegex = /^(['"]?)(.*)\1$/; function normalize(value) { return value .replace(optionalMatchingQuotesRegex, "$2") .replace(importantRegex, ""); } function removeUnusedAtRules(tokens, context) { removeUnusedAtRule( tokens, matchCounterStyle, markCounterStylesAsUsed, context ); removeUnusedAtRule( tokens, matchFontFace, markFontFacesAsUsed, context ); removeUnusedAtRule( tokens, matchKeyframe, markKeyframesAsUsed, context ); removeUnusedAtRule( tokens, matchNamespace, markNamespacesAsUsed, context ); } function removeUnusedAtRule( tokens, matchCallback, markCallback, context ) { var atRules = {}; var atRule; var atRuleTokens; var atRuleToken; var zeroAt; var i, l; for (i = 0, l = tokens.length; i < l; i++) { matchCallback(tokens[i], atRules); } if (Object.keys(atRules).length === 0) { return; } markUsedAtRules(tokens, markCallback, atRules, context); for (atRule in atRules) { atRuleTokens = atRules[atRule]; for (i = 0, l = atRuleTokens.length; i < l; i++) { atRuleToken = atRuleTokens[i]; zeroAt = atRuleToken[0] == Token.AT_RULE ? 1 : 2; atRuleToken[zeroAt] = []; } } } function markUsedAtRules(tokens, markCallback, atRules, context) { var boundMarkCallback = markCallback(atRules); var i, l; for (i = 0, l = tokens.length; i < l; i++) { switch (tokens[i][0]) { case Token.RULE: boundMarkCallback(tokens[i], context); break; case Token.NESTED_BLOCK: markUsedAtRules(tokens[i][2], markCallback, atRules, context); } } } function matchCounterStyle(token, atRules) { var match; if ( token[0] == Token.AT_RULE_BLOCK && token[1][0][1].indexOf("@counter-style") === 0 ) { match = token[1][0][1].split(" ")[1]; atRules[match] = atRules[match] || []; atRules[match].push(token); } } function markCounterStylesAsUsed(atRules) { return function(token, context) { var property; var wrappedProperty; var i, l; for (i = 0, l = token[2].length; i < l; i++) { property = token[2][i]; if (property[1][1] == "list-style") { wrappedProperty = wrapForOptimizing(property); populateComponents( [wrappedProperty], context.validator, context.warnings ); if (wrappedProperty.components[0].value[0][1] in atRules) { delete atRules[property[2][1]]; } restoreFromOptimizing([wrappedProperty]); } if ( property[1][1] == "list-style-type" && property[2][1] in atRules ) { delete atRules[property[2][1]]; } } }; } function matchFontFace(token, atRules) { var property; var match; var i, l; if ( token[0] == Token.AT_RULE_BLOCK && token[1][0][1] == "@font-face" ) { for (i = 0, l = token[2].length; i < l; i++) { property = token[2][i]; if (property[1][1] == "font-family") { match = normalize(property[2][1].toLowerCase()); atRules[match] = atRules[match] || []; atRules[match].push(token); break; } } } } function markFontFacesAsUsed(atRules) { return function(token, context) { var property; var wrappedProperty; var component; var normalizedMatch; var i, l; var j, m; for (i = 0, l = token[2].length; i < l; i++) { property = token[2][i]; if (property[1][1] == "font") { wrappedProperty = wrapForOptimizing(property); populateComponents( [wrappedProperty], context.validator, context.warnings ); component = wrappedProperty.components[6]; for (j = 0, m = component.value.length; j < m; j++) { normalizedMatch = normalize( component.value[j][1].toLowerCase() ); if (normalizedMatch in atRules) { delete atRules[normalizedMatch]; } } restoreFromOptimizing([wrappedProperty]); } if (property[1][1] == "font-family") { for (j = 2, m = property.length; j < m; j++) { normalizedMatch = normalize(property[j][1].toLowerCase()); if (normalizedMatch in atRules) { delete atRules[normalizedMatch]; } } } } }; } function matchKeyframe(token, atRules) { var match; if ( token[0] == Token.NESTED_BLOCK && keyframeRegex.test(token[1][0][1]) ) { match = token[1][0][1].split(" ")[1]; atRules[match] = atRules[match] || []; atRules[match].push(token); } } function markKeyframesAsUsed(atRules) { return function(token, context) { var property; var wrappedProperty; var component; var i, l; var j, m; for (i = 0, l = token[2].length; i < l; i++) { property = token[2][i]; if (animationRegex.test(property[1][1])) { wrappedProperty = wrapForOptimizing(property); populateComponents( [wrappedProperty], context.validator, context.warnings ); component = wrappedProperty.components[7]; for (j = 0, m = component.value.length; j < m; j++) { if (component.value[j][1] in atRules) { delete atRules[component.value[j][1]]; } } restoreFromOptimizing([wrappedProperty]); } if (animationNameRegex.test(property[1][1])) { for (j = 2, m = property.length; j < m; j++) { if (property[j][1] in atRules) { delete atRules[property[j][1]]; } } } } }; } function matchNamespace(token, atRules) { var match; if ( token[0] == Token.AT_RULE && token[1].indexOf("@namespace") === 0 ) { match = token[1].split(" ")[1]; atRules[match] = atRules[match] || []; atRules[match].push(token); } } function markNamespacesAsUsed(atRules) { var namespaceRegex = new RegExp( Object.keys(atRules).join("\\||") + "\\|", "g" ); return function(token) { var match; var scope; var normalizedMatch; var i, l; var j, m; for (i = 0, l = token[1].length; i < l; i++) { scope = token[1][i]; match = scope[1].match(namespaceRegex); for (j = 0, m = match.length; j < m; j++) { normalizedMatch = match[j].substring(0, match[j].length - 1); if (normalizedMatch in atRules) { delete atRules[normalizedMatch]; } } } }; } module.exports = removeUnusedAtRules; }, { "../../tokenizer/token": 84, "../restore-from-optimizing": 56, "../wrap-for-optimizing": 58, "./properties/populate-components": 39 } ], 47: [ function(require, module, exports) { // TODO: it'd be great to merge it with the other canReorder functionality var rulesOverlap = require("./rules-overlap"); var specificitiesOverlap = require("./specificities-overlap"); var FLEX_PROPERTIES = /align\-items|box\-align|box\-pack|flex|justify/; var BORDER_PROPERTIES = /^border\-(top|right|bottom|left|color|style|width|radius)/; function canReorder(left, right, cache) { for (var i = right.length - 1; i >= 0; i--) { for (var j = left.length - 1; j >= 0; j--) { if (!canReorderSingle(left[j], right[i], cache)) return false; } } return true; } function canReorderSingle(left, right, cache) { var leftName = left[0]; var leftValue = left[1]; var leftNameRoot = left[2]; var leftSelector = left[5]; var leftInSpecificSelector = left[6]; var rightName = right[0]; var rightValue = right[1]; var rightNameRoot = right[2]; var rightSelector = right[5]; var rightInSpecificSelector = right[6]; if ( (leftName == "font" && rightName == "line-height") || (rightName == "font" && leftName == "line-height") ) return false; if (FLEX_PROPERTIES.test(leftName) && FLEX_PROPERTIES.test(rightName)) return false; if ( leftNameRoot == rightNameRoot && unprefixed(leftName) == unprefixed(rightName) && vendorPrefixed(leftName) ^ vendorPrefixed(rightName) ) return false; if ( leftNameRoot == "border" && BORDER_PROPERTIES.test(rightNameRoot) && (leftName == "border" || leftName == rightNameRoot || (leftValue != rightValue && sameBorderComponent(leftName, rightName))) ) return false; if ( rightNameRoot == "border" && BORDER_PROPERTIES.test(leftNameRoot) && (rightName == "border" || rightName == leftNameRoot || (leftValue != rightValue && sameBorderComponent(leftName, rightName))) ) return false; if ( leftNameRoot == "border" && rightNameRoot == "border" && leftName != rightName && ((isSideBorder(leftName) && isStyleBorder(rightName)) || (isStyleBorder(leftName) && isSideBorder(rightName))) ) return false; if (leftNameRoot != rightNameRoot) return true; if ( leftName == rightName && leftNameRoot == rightNameRoot && (leftValue == rightValue || withDifferentVendorPrefix(leftValue, rightValue)) ) return true; if ( leftName != rightName && leftNameRoot == rightNameRoot && leftName != leftNameRoot && rightName != rightNameRoot ) return true; if ( leftName != rightName && leftNameRoot == rightNameRoot && leftValue == rightValue ) return true; if ( rightInSpecificSelector && leftInSpecificSelector && !inheritable(leftNameRoot) && !inheritable(rightNameRoot) && !rulesOverlap(rightSelector, leftSelector, false) ) return true; if (!specificitiesOverlap(leftSelector, rightSelector, cache)) return true; return false; } function vendorPrefixed(name) { return /^\-(?:moz|webkit|ms|o)\-/.test(name); } function unprefixed(name) { return name.replace(/^\-(?:moz|webkit|ms|o)\-/, ""); } function sameBorderComponent(name1, name2) { return name1.split("-").pop() == name2.split("-").pop(); } function isSideBorder(name) { return ( name == "border-top" || name == "border-right" || name == "border-bottom" || name == "border-left" ); } function isStyleBorder(name) { return ( name == "border-color" || name == "border-style" || name == "border-width" ); } function withDifferentVendorPrefix(value1, value2) { return ( vendorPrefixed(value1) && vendorPrefixed(value2) && value1.split("-")[1] != value2.split("-")[2] ); } function inheritable(name) { // According to http://www.w3.org/TR/CSS21/propidx.html // Others will be catched by other, preceeding rules return ( name == "font" || name == "line-height" || name == "list-style" ); } module.exports = { canReorder: canReorder, canReorderSingle: canReorderSingle }; }, { "./rules-overlap": 51, "./specificities-overlap": 52 } ], 48: [ function(require, module, exports) { var compactable = require("./compactable"); function restoreWithComponents(property) { var descriptor = compactable[property.name]; if (descriptor && descriptor.shorthand) { return descriptor.restore(property, compactable); } else { return property.value; } } module.exports = restoreWithComponents; }, { "./compactable": 21 } ], 49: [ function(require, module, exports) { var shallowClone = require("./clone").shallow; var Token = require("../../tokenizer/token"); var Marker = require("../../tokenizer/marker"); function isInheritOnly(values) { for (var i = 0, l = values.length; i < l; i++) { var value = values[i][1]; if ( value != "inherit" && value != Marker.COMMA && value != Marker.FORWARD_SLASH ) return false; } return true; } function background(property, compactable, lastInMultiplex) { var components = property.components; var restored = []; var needsOne, needsBoth; function restoreValue(component) { Array.prototype.unshift.apply(restored, component.value); } function isDefaultValue(component) { var descriptor = compactable[component.name]; if ( descriptor.doubleValues && descriptor.defaultValue.length == 1 ) { return ( component.value[0][1] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][1] == descriptor.defaultValue[0] : true) ); } else if ( descriptor.doubleValues && descriptor.defaultValue.length != 1 ) { return ( component.value[0][1] == descriptor.defaultValue[0] && (component.value[1] ? component.value[1][1] : component.value[0][1]) == descriptor.defaultValue[1] ); } else { return component.value[0][1] == descriptor.defaultValue; } } for (var i = components.length - 1; i >= 0; i--) { var component = components[i]; var isDefault = isDefaultValue(component); if (component.name == "background-clip") { var originComponent = components[i - 1]; var isOriginDefault = isDefaultValue(originComponent); needsOne = component.value[0][1] == originComponent.value[0][1]; needsBoth = !needsOne && ((isOriginDefault && !isDefault) || (!isOriginDefault && !isDefault) || (!isOriginDefault && isDefault && component.value[0][1] != originComponent.value[0][1])); if (needsOne) { restoreValue(originComponent); } else if (needsBoth) { restoreValue(component); restoreValue(originComponent); } i--; } else if (component.name == "background-size") { var positionComponent = components[i - 1]; var isPositionDefault = isDefaultValue(positionComponent); needsOne = !isPositionDefault && isDefault; needsBoth = !needsOne && ((isPositionDefault && !isDefault) || (!isPositionDefault && !isDefault)); if (needsOne) { restoreValue(positionComponent); } else if (needsBoth) { restoreValue(component); restored.unshift([Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]); restoreValue(positionComponent); } else if (positionComponent.value.length == 1) { restoreValue(positionComponent); } i--; } else { if ( isDefault || (compactable[component.name].multiplexLastOnly && !lastInMultiplex) ) continue; restoreValue(component); } } if ( restored.length === 0 && property.value.length == 1 && property.value[0][1] == "0" ) restored.push(property.value[0]); if (restored.length === 0) restored.push([ Token.PROPERTY_VALUE, compactable[property.name].defaultValue ]); if (isInheritOnly(restored)) return [restored[0]]; return restored; } function borderRadius(property, compactable) { if (property.multiplex) { var horizontal = shallowClone(property); var vertical = shallowClone(property); for (var i = 0; i < 4; i++) { var component = property.components[i]; var horizontalComponent = shallowClone(property); horizontalComponent.value = [component.value[0]]; horizontal.components.push(horizontalComponent); var verticalComponent = shallowClone(property); // FIXME: only shorthand compactor (see breakup#borderRadius) knows that border radius // longhands have two values, whereas tokenizer does not care about populating 2nd value // if it's missing, hence this fallback verticalComponent.value = [ component.value[1] || component.value[0] ]; vertical.components.push(verticalComponent); } var horizontalValues = fourValues(horizontal, compactable); var verticalValues = fourValues(vertical, compactable); if ( horizontalValues.length == verticalValues.length && horizontalValues[0][1] == verticalValues[0][1] && (horizontalValues.length > 1 ? horizontalValues[1][1] == verticalValues[1][1] : true) && (horizontalValues.length > 2 ? horizontalValues[2][1] == verticalValues[2][1] : true) && (horizontalValues.length > 3 ? horizontalValues[3][1] == verticalValues[3][1] : true) ) { return horizontalValues; } else { return horizontalValues .concat([[Token.PROPERTY_VALUE, Marker.FORWARD_SLASH]]) .concat(verticalValues); } } else { return fourValues(property, compactable); } } function font(property, compactable) { var components = property.components; var restored = []; var component; var componentIndex = 0; var fontFamilyIndex = 0; if (property.value[0][1].indexOf(Marker.INTERNAL) === 0) { property.value[0][1] = property.value[0][1].substring( Marker.INTERNAL.length ); return property.value; } // first four components are optional while (componentIndex < 4) { component = components[componentIndex]; if ( component.value[0][1] != compactable[component.name].defaultValue ) { Array.prototype.push.apply(restored, component.value); } componentIndex++; } // then comes font-size Array.prototype.push.apply( restored, components[componentIndex].value ); componentIndex++; // then may come line-height if ( components[componentIndex].value[0][1] != compactable[components[componentIndex].name].defaultValue ) { Array.prototype.push.apply(restored, [ [Token.PROPERTY_VALUE, Marker.FORWARD_SLASH] ]); Array.prototype.push.apply( restored, components[componentIndex].value ); } componentIndex++; // then comes font-family while (components[componentIndex].value[fontFamilyIndex]) { restored.push(components[componentIndex].value[fontFamilyIndex]); if (components[componentIndex].value[fontFamilyIndex + 1]) { restored.push([Token.PROPERTY_VALUE, Marker.COMMA]); } fontFamilyIndex++; } if (isInheritOnly(restored)) { return [restored[0]]; } return restored; } function fourValues(property) { var components = property.components; var value1 = components[0].value[0]; var value2 = components[1].value[0]; var value3 = components[2].value[0]; var value4 = components[3].value[0]; if ( value1[1] == value2[1] && value1[1] == value3[1] && value1[1] == value4[1] ) { return [value1]; } else if (value1[1] == value3[1] && value2[1] == value4[1]) { return [value1, value2]; } else if (value2[1] == value4[1]) { return [value1, value2, value3]; } else { return [value1, value2, value3, value4]; } } function multiplex(restoreWith) { return function(property, compactable) { if (!property.multiplex) return restoreWith(property, compactable, true); var multiplexSize = 0; var restored = []; var componentMultiplexSoFar = {}; var i, l; // At this point we don't know what's the multiplex size, e.g. how many background layers are there for (i = 0, l = property.components[0].value.length; i < l; i++) { if (property.components[0].value[i][1] == Marker.COMMA) multiplexSize++; } for (i = 0; i <= multiplexSize; i++) { var _property = shallowClone(property); // We split multiplex into parts and restore them one by one for (var j = 0, m = property.components.length; j < m; j++) { var componentToClone = property.components[j]; var _component = shallowClone(componentToClone); _property.components.push(_component); // The trick is some properties has more than one value, so we iterate over values looking for // a multiplex separator - a comma for ( var k = componentMultiplexSoFar[_component.name] || 0, n = componentToClone.value.length; k < n; k++ ) { if (componentToClone.value[k][1] == Marker.COMMA) { componentMultiplexSoFar[_component.name] = k + 1; break; } _component.value.push(componentToClone.value[k]); } } // No we can restore shorthand value var lastInMultiplex = i == multiplexSize; var _restored = restoreWith( _property, compactable, lastInMultiplex ); Array.prototype.push.apply(restored, _restored); if (i < multiplexSize) restored.push([Token.PROPERTY_VALUE, Marker.COMMA]); } return restored; }; } function withoutDefaults(property, compactable) { var components = property.components; var restored = []; for (var i = components.length - 1; i >= 0; i--) { var component = components[i]; var descriptor = compactable[component.name]; if ( component.value[0][1] != descriptor.defaultValue || ("keepUnlessDefault" in descriptor && !isDefault( components, compactable, descriptor.keepUnlessDefault )) ) { restored.unshift(component.value[0]); } } if (restored.length === 0) restored.push([ Token.PROPERTY_VALUE, compactable[property.name].defaultValue ]); if (isInheritOnly(restored)) return [restored[0]]; return restored; } function isDefault(components, compactable, propertyName) { var component; var i, l; for (i = 0, l = components.length; i < l; i++) { component = components[i]; if ( component.name == propertyName && component.value[0][1] == compactable[propertyName].defaultValue ) { return true; } } return false; } module.exports = { background: background, borderRadius: borderRadius, font: font, fourValues: fourValues, multiplex: multiplex, withoutDefaults: withoutDefaults }; }, { "../../tokenizer/marker": 83, "../../tokenizer/token": 84, "./clone": 20 } ], 50: [ function(require, module, exports) { var canReorderSingle = require("./reorderable").canReorderSingle; var extractProperties = require("./extract-properties"); var isMergeable = require("./is-mergeable"); var tidyRuleDuplicates = require("./tidy-rule-duplicates"); var Token = require("../../tokenizer/token"); var cloneArray = require("../../utils/clone-array"); var serializeBody = require("../../writer/one-time").body; var serializeRules = require("../../writer/one-time").rules; function naturalSorter(a, b) { return a > b ? 1 : -1; } function cloneAndMergeSelectors(propertyA, propertyB) { var cloned = cloneArray(propertyA); cloned[5] = cloned[5].concat(propertyB[5]); return cloned; } function restructure(tokens, context) { var options = context.options; var mergeablePseudoClasses = options.compatibility.selectors.mergeablePseudoClasses; var mergeablePseudoElements = options.compatibility.selectors.mergeablePseudoElements; var mergeLimit = options.compatibility.selectors.mergeLimit; var multiplePseudoMerging = options.compatibility.selectors.multiplePseudoMerging; var specificityCache = context.cache.specificity; var movableTokens = {}; var movedProperties = []; var multiPropertyMoveCache = {}; var movedToBeDropped = []; var maxCombinationsLevel = 2; var ID_JOIN_CHARACTER = "%"; function sendToMultiPropertyMoveCache( position, movedProperty, allFits ) { for (var i = allFits.length - 1; i >= 0; i--) { var fit = allFits[i][0]; var id = addToCache(movedProperty, fit); if ( multiPropertyMoveCache[id].length > 1 && processMultiPropertyMove(position, multiPropertyMoveCache[id]) ) { removeAllMatchingFromCache(id); break; } } } function addToCache(movedProperty, fit) { var id = cacheId(fit); multiPropertyMoveCache[id] = multiPropertyMoveCache[id] || []; multiPropertyMoveCache[id].push([movedProperty, fit]); return id; } function removeAllMatchingFromCache(matchId) { var matchSelectors = matchId.split(ID_JOIN_CHARACTER); var forRemoval = []; var i; for (var id in multiPropertyMoveCache) { var selectors = id.split(ID_JOIN_CHARACTER); for (i = selectors.length - 1; i >= 0; i--) { if (matchSelectors.indexOf(selectors[i]) > -1) { forRemoval.push(id); break; } } } for (i = forRemoval.length - 1; i >= 0; i--) { delete multiPropertyMoveCache[forRemoval[i]]; } } function cacheId(cachedTokens) { var id = []; for (var i = 0, l = cachedTokens.length; i < l; i++) { id.push(serializeRules(cachedTokens[i][1])); } return id.join(ID_JOIN_CHARACTER); } function tokensToMerge(sourceTokens) { var uniqueTokensWithBody = []; var mergeableTokens = []; for (var i = sourceTokens.length - 1; i >= 0; i--) { if ( !isMergeable( serializeRules(sourceTokens[i][1]), mergeablePseudoClasses, mergeablePseudoElements, multiplePseudoMerging ) ) { continue; } mergeableTokens.unshift(sourceTokens[i]); if ( sourceTokens[i][2].length > 0 && uniqueTokensWithBody.indexOf(sourceTokens[i]) == -1 ) uniqueTokensWithBody.push(sourceTokens[i]); } return uniqueTokensWithBody.length > 1 ? mergeableTokens : []; } function shortenIfPossible(position, movedProperty) { var name = movedProperty[0]; var value = movedProperty[1]; var key = movedProperty[4]; var valueSize = name.length + value.length + 1; var allSelectors = []; var qualifiedTokens = []; var mergeableTokens = tokensToMerge(movableTokens[key]); if (mergeableTokens.length < 2) return; var allFits = findAllFits(mergeableTokens, valueSize, 1); var bestFit = allFits[0]; if (bestFit[1] > 0) return sendToMultiPropertyMoveCache( position, movedProperty, allFits ); for (var i = bestFit[0].length - 1; i >= 0; i--) { allSelectors = bestFit[0][i][1].concat(allSelectors); qualifiedTokens.unshift(bestFit[0][i]); } allSelectors = tidyRuleDuplicates(allSelectors); dropAsNewTokenAt( position, [movedProperty], allSelectors, qualifiedTokens ); } function fitSorter(fit1, fit2) { return fit1[1] > fit2[1] ? 1 : fit1[1] == fit2[1] ? 0 : -1; } function findAllFits(mergeableTokens, propertySize, propertiesCount) { var combinations = allCombinations( mergeableTokens, propertySize, propertiesCount, maxCombinationsLevel - 1 ); return combinations.sort(fitSorter); } function allCombinations( tokensVariant, propertySize, propertiesCount, level ) { var differenceVariants = [ [ tokensVariant, sizeDifference(tokensVariant, propertySize, propertiesCount) ] ]; if (tokensVariant.length > 2 && level > 0) { for (var i = tokensVariant.length - 1; i >= 0; i--) { var subVariant = Array.prototype.slice.call(tokensVariant, 0); subVariant.splice(i, 1); differenceVariants = differenceVariants.concat( allCombinations( subVariant, propertySize, propertiesCount, level - 1 ) ); } } return differenceVariants; } function sizeDifference( tokensVariant, propertySize, propertiesCount ) { var allSelectorsSize = 0; for (var i = tokensVariant.length - 1; i >= 0; i--) { allSelectorsSize += tokensVariant[i][2].length > propertiesCount ? serializeRules(tokensVariant[i][1]).length : -1; } return ( allSelectorsSize - (tokensVariant.length - 1) * propertySize + 1 ); } function dropAsNewTokenAt( position, properties, allSelectors, mergeableTokens ) { var i, j, k, m; var allProperties = []; for (i = mergeableTokens.length - 1; i >= 0; i--) { var mergeableToken = mergeableTokens[i]; for (j = mergeableToken[2].length - 1; j >= 0; j--) { var mergeableProperty = mergeableToken[2][j]; for (k = 0, m = properties.length; k < m; k++) { var property = properties[k]; var mergeablePropertyName = mergeableProperty[1][1]; var propertyName = property[0]; var propertyBody = property[4]; if ( mergeablePropertyName == propertyName && serializeBody([mergeableProperty]) == propertyBody ) { mergeableToken[2].splice(j, 1); break; } } } } for (i = properties.length - 1; i >= 0; i--) { allProperties.unshift(properties[i][3]); } var newToken = [Token.RULE, allSelectors, allProperties]; tokens.splice(position, 0, newToken); } function dropPropertiesAt(position, movedProperty) { var key = movedProperty[4]; var toMove = movableTokens[key]; if (toMove && toMove.length > 1) { if (!shortenMultiMovesIfPossible(position, movedProperty)) shortenIfPossible(position, movedProperty); } } function shortenMultiMovesIfPossible(position, movedProperty) { var candidates = []; var propertiesAndMergableTokens = []; var key = movedProperty[4]; var j, k; var mergeableTokens = tokensToMerge(movableTokens[key]); if (mergeableTokens.length < 2) return; movableLoop: for (var value in movableTokens) { var tokensList = movableTokens[value]; for (j = mergeableTokens.length - 1; j >= 0; j--) { if (tokensList.indexOf(mergeableTokens[j]) == -1) continue movableLoop; } candidates.push(value); } if (candidates.length < 2) return false; for (j = candidates.length - 1; j >= 0; j--) { for (k = movedProperties.length - 1; k >= 0; k--) { if (movedProperties[k][4] == candidates[j]) { propertiesAndMergableTokens.unshift([ movedProperties[k], mergeableTokens ]); break; } } } return processMultiPropertyMove( position, propertiesAndMergableTokens ); } function processMultiPropertyMove( position, propertiesAndMergableTokens ) { var valueSize = 0; var properties = []; var property; for (var i = propertiesAndMergableTokens.length - 1; i >= 0; i--) { property = propertiesAndMergableTokens[i][0]; var fullValue = property[4]; valueSize += fullValue.length + (i > 0 ? 1 : 0); properties.push(property); } var mergeableTokens = propertiesAndMergableTokens[0][1]; var bestFit = findAllFits( mergeableTokens, valueSize, properties.length )[0]; if (bestFit[1] > 0) return false; var allSelectors = []; var qualifiedTokens = []; for (i = bestFit[0].length - 1; i >= 0; i--) { allSelectors = bestFit[0][i][1].concat(allSelectors); qualifiedTokens.unshift(bestFit[0][i]); } allSelectors = tidyRuleDuplicates(allSelectors); dropAsNewTokenAt( position, properties, allSelectors, qualifiedTokens ); for (i = properties.length - 1; i >= 0; i--) { property = properties[i]; var index = movedProperties.indexOf(property); delete movableTokens[property[4]]; if (index > -1 && movedToBeDropped.indexOf(index) == -1) movedToBeDropped.push(index); } return true; } function boundToAnotherPropertyInCurrrentToken( property, movedProperty, token ) { var propertyName = property[0]; var movedPropertyName = movedProperty[0]; if (propertyName != movedPropertyName) return false; var key = movedProperty[4]; var toMove = movableTokens[key]; return toMove && toMove.indexOf(token) > -1; } for (var i = tokens.length - 1; i >= 0; i--) { var token = tokens[i]; var isRule; var j, k, m; var samePropertyAt; if (token[0] == Token.RULE) { isRule = true; } else if (token[0] == Token.NESTED_BLOCK) { isRule = false; } else { continue; } // We cache movedProperties.length as it may change in the loop var movedCount = movedProperties.length; var properties = extractProperties(token); movedToBeDropped = []; var unmovableInCurrentToken = []; for (j = properties.length - 1; j >= 0; j--) { for (k = j - 1; k >= 0; k--) { if ( !canReorderSingle( properties[j], properties[k], specificityCache ) ) { unmovableInCurrentToken.push(j); break; } } } for (j = properties.length - 1; j >= 0; j--) { var property = properties[j]; var movedSameProperty = false; for (k = 0; k < movedCount; k++) { var movedProperty = movedProperties[k]; if ( movedToBeDropped.indexOf(k) == -1 && ((!canReorderSingle( property, movedProperty, specificityCache ) && !boundToAnotherPropertyInCurrrentToken( property, movedProperty, token )) || (movableTokens[movedProperty[4]] && movableTokens[movedProperty[4]].length === mergeLimit)) ) { dropPropertiesAt(i + 1, movedProperty, token); if (movedToBeDropped.indexOf(k) == -1) { movedToBeDropped.push(k); delete movableTokens[movedProperty[4]]; } } if (!movedSameProperty) { movedSameProperty = property[0] == movedProperty[0] && property[1] == movedProperty[1]; if (movedSameProperty) { samePropertyAt = k; } } } if (!isRule || unmovableInCurrentToken.indexOf(j) > -1) continue; var key = property[4]; if ( movedSameProperty && movedProperties[samePropertyAt][5].length + property[5].length > mergeLimit ) { dropPropertiesAt(i + 1, movedProperties[samePropertyAt]); movedProperties.splice(samePropertyAt, 1); movableTokens[key] = [token]; movedSameProperty = false; } else { movableTokens[key] = movableTokens[key] || []; movableTokens[key].push(token); } if (movedSameProperty) { movedProperties[samePropertyAt] = cloneAndMergeSelectors( movedProperties[samePropertyAt], property ); } else { movedProperties.push(property); } } movedToBeDropped = movedToBeDropped.sort(naturalSorter); for (j = 0, m = movedToBeDropped.length; j < m; j++) { var dropAt = movedToBeDropped[j] - j; movedProperties.splice(dropAt, 1); } } var position = tokens[0] && tokens[0][0] == Token.AT_RULE && tokens[0][1].indexOf("@charset") === 0 ? 1 : 0; for (; position < tokens.length - 1; position++) { var isImportRule = tokens[position][0] === Token.AT_RULE && tokens[position][1].indexOf("@import") === 0; var isComment = tokens[position][0] === Token.COMMENT; if (!(isImportRule || isComment)) break; } for (i = 0; i < movedProperties.length; i++) { dropPropertiesAt(position, movedProperties[i]); } } module.exports = restructure; }, { "../../tokenizer/token": 84, "../../utils/clone-array": 86, "../../writer/one-time": 98, "./extract-properties": 22, "./is-mergeable": 24, "./reorderable": 47, "./tidy-rule-duplicates": 54 } ], 51: [ function(require, module, exports) { var MODIFIER_PATTERN = /\-\-.+$/; function rulesOverlap(rule1, rule2, bemMode) { var scope1; var scope2; var i, l; var j, m; for (i = 0, l = rule1.length; i < l; i++) { scope1 = rule1[i][1]; for (j = 0, m = rule2.length; j < m; j++) { scope2 = rule2[j][1]; if (scope1 == scope2) { return true; } if ( bemMode && withoutModifiers(scope1) == withoutModifiers(scope2) ) { return true; } } } return false; } function withoutModifiers(scope) { return scope.replace(MODIFIER_PATTERN, ""); } module.exports = rulesOverlap; }, {} ], 52: [ function(require, module, exports) { var specificity = require("./specificity"); function specificitiesOverlap(selector1, selector2, cache) { var specificity1; var specificity2; var i, l; var j, m; for (i = 0, l = selector1.length; i < l; i++) { specificity1 = findSpecificity(selector1[i][1], cache); for (j = 0, m = selector2.length; j < m; j++) { specificity2 = findSpecificity(selector2[j][1], cache); if ( specificity1[0] === specificity2[0] && specificity1[1] === specificity2[1] && specificity1[2] === specificity2[2] ) { return true; } } } return false; } function findSpecificity(selector, cache) { var value; if (!(selector in cache)) { cache[selector] = value = specificity(selector); } return value || cache[selector]; } module.exports = specificitiesOverlap; }, { "./specificity": 53 } ], 53: [ function(require, module, exports) { var Marker = require("../../tokenizer/marker"); var Selector = { ADJACENT_SIBLING: "+", DESCENDANT: ">", DOT: ".", HASH: "#", NON_ADJACENT_SIBLING: "~", PSEUDO: ":" }; var LETTER_PATTERN = /[a-zA-Z]/; var NOT_PREFIX = ":not("; var SEPARATOR_PATTERN = /[\s,\(>~\+]/; function specificity(selector) { var result = [0, 0, 0]; var character; var isEscaped; var isSingleQuoted; var isDoubleQuoted; var roundBracketLevel = 0; var couldIntroduceNewTypeSelector; var withinNotPseudoClass = false; var wasPseudoClass = false; var i, l; for (i = 0, l = selector.length; i < l; i++) { character = selector[i]; if (isEscaped) { // noop } else if ( character == Marker.SINGLE_QUOTE && !isDoubleQuoted && !isSingleQuoted ) { isSingleQuoted = true; } else if ( character == Marker.SINGLE_QUOTE && !isDoubleQuoted && isSingleQuoted ) { isSingleQuoted = false; } else if ( character == Marker.DOUBLE_QUOTE && !isDoubleQuoted && !isSingleQuoted ) { isDoubleQuoted = true; } else if ( character == Marker.DOUBLE_QUOTE && isDoubleQuoted && !isSingleQuoted ) { isDoubleQuoted = false; } else if (isSingleQuoted || isDoubleQuoted) { continue; } else if (roundBracketLevel > 0 && !withinNotPseudoClass) { // noop } else if (character == Marker.OPEN_ROUND_BRACKET) { roundBracketLevel++; } else if ( character == Marker.CLOSE_ROUND_BRACKET && roundBracketLevel == 1 ) { roundBracketLevel--; withinNotPseudoClass = false; } else if (character == Marker.CLOSE_ROUND_BRACKET) { roundBracketLevel--; } else if (character == Selector.HASH) { result[0]++; } else if ( character == Selector.DOT || character == Marker.OPEN_SQUARE_BRACKET ) { result[1]++; } else if ( character == Selector.PSEUDO && !wasPseudoClass && !isNotPseudoClass(selector, i) ) { result[1]++; withinNotPseudoClass = false; } else if (character == Selector.PSEUDO) { withinNotPseudoClass = true; } else if ( (i === 0 || couldIntroduceNewTypeSelector) && LETTER_PATTERN.test(character) ) { result[2]++; } isEscaped = character == Marker.BACK_SLASH; wasPseudoClass = character == Selector.PSEUDO; couldIntroduceNewTypeSelector = !isEscaped && SEPARATOR_PATTERN.test(character); } return result; } function isNotPseudoClass(selector, index) { return selector.indexOf(NOT_PREFIX, index) === index; } module.exports = specificity; }, { "../../tokenizer/marker": 83 } ], 54: [ function(require, module, exports) { function ruleSorter(s1, s2) { return s1[1] > s2[1] ? 1 : -1; } function tidyRuleDuplicates(rules) { var list = []; var repeated = []; for (var i = 0, l = rules.length; i < l; i++) { var rule = rules[i]; if (repeated.indexOf(rule[1]) == -1) { repeated.push(rule[1]); list.push(rule); } } return list.sort(ruleSorter); } module.exports = tidyRuleDuplicates; }, {} ], 55: [ function(require, module, exports) { function removeUnused(properties) { for (var i = properties.length - 1; i >= 0; i--) { var property = properties[i]; if (property.unused) { property.all.splice(property.position, 1); } } } module.exports = removeUnused; }, {} ], 56: [ function(require, module, exports) { var Hack = require("./hack"); var Marker = require("../tokenizer/marker"); var ASTERISK_HACK = "*"; var BACKSLASH_HACK = "\\"; var IMPORTANT_TOKEN = "!important"; var UNDERSCORE_HACK = "_"; var BANG_HACK = "!ie"; function restoreFromOptimizing(properties, restoreCallback) { var property; var restored; var current; var i; for (i = properties.length - 1; i >= 0; i--) { property = properties[i]; if (property.unused) { continue; } if (!property.dirty && !property.important && !property.hack) { continue; } if (restoreCallback) { restored = restoreCallback(property); property.value = restored; } else { restored = property.value; } if (property.important) { restoreImportant(property); } if (property.hack) { restoreHack(property); } if ("all" in property) { current = property.all[property.position]; current[1][1] = property.name; current.splice(2, current.length - 1); Array.prototype.push.apply(current, restored); } } } function restoreImportant(property) { property.value[property.value.length - 1][1] += IMPORTANT_TOKEN; } function restoreHack(property) { if (property.hack[0] == Hack.UNDERSCORE) { property.name = UNDERSCORE_HACK + property.name; } else if (property.hack[0] == Hack.ASTERISK) { property.name = ASTERISK_HACK + property.name; } else if (property.hack[0] == Hack.BACKSLASH) { property.value[property.value.length - 1][1] += BACKSLASH_HACK + property.hack[1]; } else if (property.hack[0] == Hack.BANG) { property.value[property.value.length - 1][1] += Marker.SPACE + BANG_HACK; } } module.exports = restoreFromOptimizing; }, { "../tokenizer/marker": 83, "./hack": 8 } ], 57: [ function(require, module, exports) { var functionNoVendorRegexStr = "[A-Z]+(\\-|[A-Z]|[0-9])+\\(.*?\\)"; var functionVendorRegexStr = "\\-(\\-|[A-Z]|[0-9])+\\(.*?\\)"; var variableRegexStr = "var\\(\\-\\-[^\\)]+\\)"; var functionAnyRegexStr = "(" + variableRegexStr + "|" + functionNoVendorRegexStr + "|" + functionVendorRegexStr + ")"; var calcRegex = new RegExp( "^(\\-moz\\-|\\-webkit\\-)?calc\\([^\\)]+\\)$", "i" ); var decimalRegex = /[0-9]/; var functionAnyRegex = new RegExp("^" + functionAnyRegexStr + "$", "i"); var hslColorRegex = /^hsl\(\s{0,31}[\-\.]?\d+\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+%\s{0,31}\)|hsla\(\s{0,31}[\-\.]?\d+\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+%\s{0,31},\s{0,31}\.?\d+\s{0,31}\)$/; var identifierRegex = /^(\-[a-z0-9_][a-z0-9\-_]*|[a-z][a-z0-9\-_]*)$/i; var namedEntityRegex = /^[a-z]+$/i; var prefixRegex = /^-([a-z0-9]|-)*$/i; var rgbColorRegex = /^rgb\(\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31}\)|rgba\(\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\d]{1,3}\s{0,31},\s{0,31}[\.\d]+\s{0,31}\)$/; var timingFunctionRegex = /^(cubic\-bezier|steps)\([^\)]+\)$/; var validTimeUnits = ["ms", "s"]; var urlRegex = /^url\([\s\S]+\)$/i; var variableRegex = new RegExp("^" + variableRegexStr + "$", "i"); var eightValueColorRegex = /^#[0-9a-f]{8}$/i; var fourValueColorRegex = /^#[0-9a-f]{4}$/i; var sixValueColorRegex = /^#[0-9a-f]{6}$/i; var threeValueColorRegex = /^#[0-9a-f]{3}$/i; var DECIMAL_DOT = "."; var MINUS_SIGN = "-"; var PLUS_SIGN = "+"; var Keywords = { "^": ["inherit", "initial", "unset"], "*-style": [ "auto", "dashed", "dotted", "double", "groove", "hidden", "inset", "none", "outset", "ridge", "solid" ], "*-timing-function": [ "ease", "ease-in", "ease-in-out", "ease-out", "linear", "step-end", "step-start" ], "animation-direction": [ "alternate", "alternate-reverse", "normal", "reverse" ], "animation-fill-mode": ["backwards", "both", "forwards", "none"], "animation-iteration-count": ["infinite"], "animation-name": ["none"], "animation-play-state": ["paused", "running"], "background-attachment": ["fixed", "inherit", "local", "scroll"], "background-clip": [ "border-box", "content-box", "inherit", "padding-box", "text" ], "background-origin": [ "border-box", "content-box", "inherit", "padding-box" ], "background-position": ["bottom", "center", "left", "right", "top"], "background-repeat": [ "no-repeat", "inherit", "repeat", "repeat-x", "repeat-y", "round", "space" ], "background-size": ["auto", "cover", "contain"], "border-collapse": ["collapse", "inherit", "separate"], bottom: ["auto"], clear: ["both", "left", "none", "right"], color: ["transparent"], cursor: [ "all-scroll", "auto", "col-resize", "crosshair", "default", "e-resize", "help", "move", "n-resize", "ne-resize", "no-drop", "not-allowed", "nw-resize", "pointer", "progress", "row-resize", "s-resize", "se-resize", "sw-resize", "text", "vertical-text", "w-resize", "wait" ], display: [ "block", "inline", "inline-block", "inline-table", "list-item", "none", "table", "table-caption", "table-cell", "table-column", "table-column-group", "table-footer-group", "table-header-group", "table-row", "table-row-group" ], float: ["left", "none", "right"], left: ["auto"], font: [ "caption", "icon", "menu", "message-box", "small-caption", "status-bar", "unset" ], "font-size": [ "large", "larger", "medium", "small", "smaller", "x-large", "x-small", "xx-large", "xx-small" ], "font-stretch": [ "condensed", "expanded", "extra-condensed", "extra-expanded", "normal", "semi-condensed", "semi-expanded", "ultra-condensed", "ultra-expanded" ], "font-style": ["italic", "normal", "oblique"], "font-variant": ["normal", "small-caps"], "font-weight": [ "100", "200", "300", "400", "500", "600", "700", "800", "900", "bold", "bolder", "lighter", "normal" ], "line-height": ["normal"], "list-style-position": ["inside", "outside"], "list-style-type": [ "armenian", "circle", "decimal", "decimal-leading-zero", "disc", "decimal|disc", // this is the default value of list-style-type, see comment in compactable.js "georgian", "lower-alpha", "lower-greek", "lower-latin", "lower-roman", "none", "square", "upper-alpha", "upper-latin", "upper-roman" ], overflow: ["auto", "hidden", "scroll", "visible"], position: ["absolute", "fixed", "relative", "static"], right: ["auto"], "text-align": [ "center", "justify", "left", "left|right", // this is the default value of list-style-type, see comment in compactable.js "right" ], "text-decoration": ["line-through", "none", "overline", "underline"], "text-overflow": ["clip", "ellipsis"], top: ["auto"], "vertical-align": [ "baseline", "bottom", "middle", "sub", "super", "text-bottom", "text-top", "top" ], visibility: ["collapse", "hidden", "visible"], "white-space": ["normal", "nowrap", "pre"], width: ["inherit", "initial", "medium", "thick", "thin"] }; var Units = [ "%", "ch", "cm", "em", "ex", "in", "mm", "pc", "pt", "px", "rem", "vh", "vm", "vmax", "vmin", "vw" ]; function isColor(value) { return ( value != "auto" && (isKeyword("color")(value) || isHexColor(value) || isColorFunction(value) || isNamedEntity(value)) ); } function isColorFunction(value) { return isRgbColor(value) || isHslColor(value); } function isDynamicUnit(value) { return calcRegex.test(value); } function isFunction(value) { return functionAnyRegex.test(value); } function isHexColor(value) { return ( threeValueColorRegex.test(value) || fourValueColorRegex.test(value) || sixValueColorRegex.test(value) || eightValueColorRegex.test(value) ); } function isHslColor(value) { return hslColorRegex.test(value); } function isIdentifier(value) { return identifierRegex.test(value); } function isImage(value) { return value == "none" || value == "inherit" || isUrl(value); } function isKeyword(propertyName) { return function(value) { return Keywords[propertyName].indexOf(value) > -1; }; } function isNamedEntity(value) { return namedEntityRegex.test(value); } function isNumber(value) { return scanForNumber(value) == value.length; } function isRgbColor(value) { return rgbColorRegex.test(value); } function isPrefixed(value) { return prefixRegex.test(value); } function isPositiveNumber(value) { return isNumber(value) && parseFloat(value) >= 0; } function isVariable(value) { return variableRegex.test(value); } function isTime(value) { var numberUpTo = scanForNumber(value); return ( (numberUpTo == value.length && parseInt(value) === 0) || (numberUpTo > -1 && validTimeUnits.indexOf(value.slice(numberUpTo + 1)) > -1) ); } function isTimingFunction() { var isTimingFunctionKeyword = isKeyword("*-timing-function"); return function(value) { return ( isTimingFunctionKeyword(value) || timingFunctionRegex.test(value) ); }; } function isUnit(validUnits, value) { var numberUpTo = scanForNumber(value); return ( (numberUpTo == value.length && parseInt(value) === 0) || (numberUpTo > -1 && validUnits.indexOf(value.slice(numberUpTo + 1)) > -1) || value == "auto" || value == "inherit" ); } function isUrl(value) { return urlRegex.test(value); } function isZIndex(value) { return value == "auto" || isNumber(value) || isKeyword("^")(value); } function scanForNumber(value) { var hasDot = false; var hasSign = false; var character; var i, l; for (i = 0, l = value.length; i < l; i++) { character = value[i]; if ( i === 0 && (character == PLUS_SIGN || character == MINUS_SIGN) ) { hasSign = true; } else if ( i > 0 && hasSign && (character == PLUS_SIGN || character == MINUS_SIGN) ) { return i - 1; } else if (character == DECIMAL_DOT && !hasDot) { hasDot = true; } else if (character == DECIMAL_DOT && hasDot) { return i - 1; } else if (decimalRegex.test(character)) { continue; } else { return i - 1; } } return i; } function validator(compatibility) { var validUnits = Units.slice(0).filter(function(value) { return ( !(value in compatibility.units) || compatibility.units[value] === true ); }); return { colorOpacity: compatibility.colors.opacity, isAnimationDirectionKeyword: isKeyword("animation-direction"), isAnimationFillModeKeyword: isKeyword("animation-fill-mode"), isAnimationIterationCountKeyword: isKeyword( "animation-iteration-count" ), isAnimationNameKeyword: isKeyword("animation-name"), isAnimationPlayStateKeyword: isKeyword("animation-play-state"), isTimingFunction: isTimingFunction(), isBackgroundAttachmentKeyword: isKeyword("background-attachment"), isBackgroundClipKeyword: isKeyword("background-clip"), isBackgroundOriginKeyword: isKeyword("background-origin"), isBackgroundPositionKeyword: isKeyword("background-position"), isBackgroundRepeatKeyword: isKeyword("background-repeat"), isBackgroundSizeKeyword: isKeyword("background-size"), isColor: isColor, isColorFunction: isColorFunction, isDynamicUnit: isDynamicUnit, isFontKeyword: isKeyword("font"), isFontSizeKeyword: isKeyword("font-size"), isFontStretchKeyword: isKeyword("font-stretch"), isFontStyleKeyword: isKeyword("font-style"), isFontVariantKeyword: isKeyword("font-variant"), isFontWeightKeyword: isKeyword("font-weight"), isFunction: isFunction, isGlobal: isKeyword("^"), isHslColor: isHslColor, isIdentifier: isIdentifier, isImage: isImage, isKeyword: isKeyword, isLineHeightKeyword: isKeyword("line-height"), isListStylePositionKeyword: isKeyword("list-style-position"), isListStyleTypeKeyword: isKeyword("list-style-type"), isNumber: isNumber, isPrefixed: isPrefixed, isPositiveNumber: isPositiveNumber, isRgbColor: isRgbColor, isStyleKeyword: isKeyword("*-style"), isTime: isTime, isUnit: isUnit.bind(null, validUnits), isUrl: isUrl, isVariable: isVariable, isWidth: isKeyword("width"), isZIndex: isZIndex }; } module.exports = validator; }, {} ], 58: [ function(require, module, exports) { var Hack = require("./hack"); var Marker = require("../tokenizer/marker"); var Token = require("../tokenizer/token"); var Match = { ASTERISK: "*", BACKSLASH: "\\", BANG: "!", BANG_SUFFIX_PATTERN: /!\w+$/, IMPORTANT_TOKEN: "!important", IMPORTANT_TOKEN_PATTERN: new RegExp("!important$", "i"), IMPORTANT_WORD: "important", IMPORTANT_WORD_PATTERN: new RegExp("important$", "i"), SUFFIX_BANG_PATTERN: /!$/, UNDERSCORE: "_", VARIABLE_REFERENCE_PATTERN: /var\(--.+\)$/ }; function wrapAll(properties, includeVariable, skipProperties) { var wrapped = []; var single; var property; var i; for (i = properties.length - 1; i >= 0; i--) { property = properties[i]; if (property[0] != Token.PROPERTY) { continue; } if (!includeVariable && someVariableReferences(property)) { continue; } if (skipProperties && skipProperties.indexOf(property[1][1]) > -1) { continue; } single = wrapSingle(property); single.all = properties; single.position = i; wrapped.unshift(single); } return wrapped; } function someVariableReferences(property) { var i, l; var value; // skipping `property` and property name tokens for (i = 2, l = property.length; i < l; i++) { value = property[i]; if (value[0] != Token.PROPERTY_VALUE) { continue; } if (isVariableReference(value[1])) { return true; } } return false; } function isVariableReference(value) { return Match.VARIABLE_REFERENCE_PATTERN.test(value); } function isMultiplex(property) { var value; var i, l; for (i = 3, l = property.length; i < l; i++) { value = property[i]; if ( value[0] == Token.PROPERTY_VALUE && (value[1] == Marker.COMMA || value[1] == Marker.FORWARD_SLASH) ) { return true; } } return false; } function hackFrom(property) { var match = false; var name = property[1][1]; var lastValue = property[property.length - 1]; if (name[0] == Match.UNDERSCORE) { match = [Hack.UNDERSCORE]; } else if (name[0] == Match.ASTERISK) { match = [Hack.ASTERISK]; } else if ( lastValue[1][0] == Match.BANG && !lastValue[1].match(Match.IMPORTANT_WORD_PATTERN) ) { match = [Hack.BANG]; } else if ( lastValue[1].indexOf(Match.BANG) > 0 && !lastValue[1].match(Match.IMPORTANT_WORD_PATTERN) && Match.BANG_SUFFIX_PATTERN.test(lastValue[1]) ) { match = [Hack.BANG]; } else if ( lastValue[1].indexOf(Match.BACKSLASH) > 0 && lastValue[1].indexOf(Match.BACKSLASH) == lastValue[1].length - Match.BACKSLASH.length - 1 ) { match = [ Hack.BACKSLASH, lastValue[1].substring(lastValue[1].indexOf(Match.BACKSLASH) + 1) ]; } else if ( lastValue[1].indexOf(Match.BACKSLASH) === 0 && lastValue[1].length == 2 ) { match = [Hack.BACKSLASH, lastValue[1].substring(1)]; } return match; } function isImportant(property) { if (property.length < 3) return false; var lastValue = property[property.length - 1]; if (Match.IMPORTANT_TOKEN_PATTERN.test(lastValue[1])) { return true; } else if ( Match.IMPORTANT_WORD_PATTERN.test(lastValue[1]) && Match.SUFFIX_BANG_PATTERN.test(property[property.length - 2][1]) ) { return true; } return false; } function stripImportant(property) { var lastValue = property[property.length - 1]; var oneButLastValue = property[property.length - 2]; if (Match.IMPORTANT_TOKEN_PATTERN.test(lastValue[1])) { lastValue[1] = lastValue[1].replace( Match.IMPORTANT_TOKEN_PATTERN, "" ); } else { lastValue[1] = lastValue[1].replace( Match.IMPORTANT_WORD_PATTERN, "" ); oneButLastValue[1] = oneButLastValue[1].replace( Match.SUFFIX_BANG_PATTERN, "" ); } if (lastValue[1].length === 0) { property.pop(); } if (oneButLastValue[1].length === 0) { property.pop(); } } function stripPrefixHack(property) { property[1][1] = property[1][1].substring(1); } function stripSuffixHack(property, hackFrom) { var lastValue = property[property.length - 1]; lastValue[1] = lastValue[1] .substring( 0, lastValue[1].indexOf( hackFrom[0] == Hack.BACKSLASH ? Match.BACKSLASH : Match.BANG ) ) .trim(); if (lastValue[1].length === 0) { property.pop(); } } function wrapSingle(property) { var importantProperty = isImportant(property); if (importantProperty) { stripImportant(property); } var whichHack = hackFrom(property); if ( whichHack[0] == Hack.ASTERISK || whichHack[0] == Hack.UNDERSCORE ) { stripPrefixHack(property); } else if ( whichHack[0] == Hack.BACKSLASH || whichHack[0] == Hack.BANG ) { stripSuffixHack(property, whichHack); } return { block: property[2] && property[2][0] == Token.PROPERTY_BLOCK, components: [], dirty: false, hack: whichHack, important: importantProperty, name: property[1][1], multiplex: property.length > 3 ? isMultiplex(property) : false, position: 0, shorthand: false, unused: false, value: property.slice(2) }; } module.exports = { all: wrapAll, single: wrapSingle }; }, { "../tokenizer/marker": 83, "../tokenizer/token": 84, "./hack": 8 } ], 59: [ function(require, module, exports) { var DEFAULTS = { "*": { colors: { opacity: true // rgba / hsla }, properties: { backgroundClipMerging: true, // background-clip to shorthand backgroundOriginMerging: true, // background-origin to shorthand backgroundSizeMerging: true, // background-size to shorthand colors: true, // any kind of color transformations, like `#ff00ff` to `#f0f` or `#fff` into `red` ieBangHack: false, // !ie suffix hacks on IE<8 ieFilters: false, // whether to preserve `filter` and `-ms-filter` properties iePrefixHack: false, // underscore / asterisk prefix hacks on IE ieSuffixHack: false, // \9 suffix hacks on IE6-9 merging: true, // merging properties into one shorterLengthUnits: false, // optimize pixel units into `pt`, `pc` or `in` units spaceAfterClosingBrace: true, // 'url() no-repeat' to 'url()no-repeat' urlQuotes: false, // whether to wrap content of `url()` into quotes or not zeroUnits: true // 0[unit] -> 0 }, selectors: { adjacentSpace: false, // div+ nav Android stock browser hack ie7Hack: false, // *+html hack mergeablePseudoClasses: [ ":active", ":after", ":before", ":empty", ":checked", ":disabled", ":empty", ":enabled", ":first-child", ":first-letter", ":first-line", ":first-of-type", ":focus", ":hover", ":lang", ":last-child", ":last-of-type", ":link", ":not", ":nth-child", ":nth-last-child", ":nth-last-of-type", ":nth-of-type", ":only-child", ":only-of-type", ":root", ":target", ":visited" ], // selectors with these pseudo-classes can be merged as these are universally supported mergeablePseudoElements: [ "::after", "::before", "::first-letter", "::first-line" ], // selectors with these pseudo-elements can be merged as these are universally supported mergeLimit: 8191, // number of rules that can be safely merged together multiplePseudoMerging: true }, units: { ch: true, in: true, pc: true, pt: true, rem: true, vh: true, vm: true, // vm is vmin on IE9+ see https://developer.mozilla.org/en-US/docs/Web/CSS/length vmax: true, vmin: true, vw: true } } }; DEFAULTS.ie11 = DEFAULTS["*"]; DEFAULTS.ie10 = DEFAULTS["*"]; DEFAULTS.ie9 = merge(DEFAULTS["*"], { properties: { ieFilters: true, ieSuffixHack: true } }); DEFAULTS.ie8 = merge(DEFAULTS.ie9, { colors: { opacity: false }, properties: { backgroundClipMerging: false, backgroundOriginMerging: false, backgroundSizeMerging: false, iePrefixHack: true, merging: false }, selectors: { mergeablePseudoClasses: [ ":after", ":before", ":first-child", ":first-letter", ":focus", ":hover", ":visited" ], mergeablePseudoElements: [] }, units: { ch: false, rem: false, vh: false, vm: false, vmax: false, vmin: false, vw: false } }); DEFAULTS.ie7 = merge(DEFAULTS.ie8, { properties: { ieBangHack: true }, selectors: { ie7Hack: true, mergeablePseudoClasses: [ ":first-child", ":first-letter", ":hover", ":visited" ] } }); function compatibilityFrom(source) { return merge(DEFAULTS["*"], calculateSource(source)); } function merge(source, target) { for (var key in source) { var value = source[key]; if (typeof value === "object" && !Array.isArray(value)) { target[key] = merge(value, target[key] || {}); } else { target[key] = key in target ? target[key] : value; } } return target; } function calculateSource(source) { if (typeof source == "object") return source; if (!/[,\+\-]/.test(source)) return DEFAULTS[source] || DEFAULTS["*"]; var parts = source.split(","); var template = parts[0] in DEFAULTS ? DEFAULTS[parts.shift()] : DEFAULTS["*"]; source = {}; parts.forEach(function(part) { var isAdd = part[0] == "+"; var key = part.substring(1).split("."); var group = key[0]; var option = key[1]; source[group] = source[group] || {}; source[group][option] = isAdd; }); return merge(template, source); } module.exports = compatibilityFrom; }, {} ], 60: [ function(require, module, exports) { var loadRemoteResource = require("../reader/load-remote-resource"); function fetchFrom(callback) { return callback || loadRemoteResource; } module.exports = fetchFrom; }, { "../reader/load-remote-resource": 74 } ], 61: [ function(require, module, exports) { var systemLineBreak = require("os").EOL; var override = require("../utils/override"); var Breaks = { AfterAtRule: "afterAtRule", AfterBlockBegins: "afterBlockBegins", AfterBlockEnds: "afterBlockEnds", AfterComment: "afterComment", AfterProperty: "afterProperty", AfterRuleBegins: "afterRuleBegins", AfterRuleEnds: "afterRuleEnds", BeforeBlockEnds: "beforeBlockEnds", BetweenSelectors: "betweenSelectors" }; var BreakWith = { CarriageReturnLineFeed: "\r\n", LineFeed: "\n", System: systemLineBreak }; var IndentWith = { Space: " ", Tab: "\t" }; var Spaces = { AroundSelectorRelation: "aroundSelectorRelation", BeforeBlockBegins: "beforeBlockBegins", BeforeValue: "beforeValue" }; var DEFAULTS = { breaks: breaks(false), breakWith: BreakWith.System, indentBy: 0, indentWith: IndentWith.Space, spaces: spaces(false), wrapAt: false, semicolonAfterLastProperty: false }; var BEAUTIFY_ALIAS = "beautify"; var KEEP_BREAKS_ALIAS = "keep-breaks"; var OPTION_SEPARATOR = ";"; var OPTION_NAME_VALUE_SEPARATOR = ":"; var HASH_VALUES_OPTION_SEPARATOR = ","; var HASH_VALUES_NAME_VALUE_SEPARATOR = "="; var FALSE_KEYWORD_1 = "false"; var FALSE_KEYWORD_2 = "off"; var TRUE_KEYWORD_1 = "true"; var TRUE_KEYWORD_2 = "on"; function breaks(value) { var breakOptions = {}; breakOptions[Breaks.AfterAtRule] = value; breakOptions[Breaks.AfterBlockBegins] = value; breakOptions[Breaks.AfterBlockEnds] = value; breakOptions[Breaks.AfterComment] = value; breakOptions[Breaks.AfterProperty] = value; breakOptions[Breaks.AfterRuleBegins] = value; breakOptions[Breaks.AfterRuleEnds] = value; breakOptions[Breaks.BeforeBlockEnds] = value; breakOptions[Breaks.BetweenSelectors] = value; return breakOptions; } function spaces(value) { var spaceOptions = {}; spaceOptions[Spaces.AroundSelectorRelation] = value; spaceOptions[Spaces.BeforeBlockBegins] = value; spaceOptions[Spaces.BeforeValue] = value; return spaceOptions; } function formatFrom(source) { if (source === undefined || source === false) { return false; } if (typeof source == "object" && "breakWith" in source) { source = override(source, { breakWith: mapBreakWith(source.breakWith) }); } if (typeof source == "object" && "indentBy" in source) { source = override(source, { indentBy: parseInt(source.indentBy) }); } if (typeof source == "object" && "indentWith" in source) { source = override(source, { indentWith: mapIndentWith(source.indentWith) }); } if (typeof source == "object") { return override(DEFAULTS, source); } if (typeof source == "object") { return override(DEFAULTS, source); } if (typeof source == "string" && source == BEAUTIFY_ALIAS) { return override(DEFAULTS, { breaks: breaks(true), indentBy: 2, spaces: spaces(true) }); } if (typeof source == "string" && source == KEEP_BREAKS_ALIAS) { return override(DEFAULTS, { breaks: { afterAtRule: true, afterBlockBegins: true, afterBlockEnds: true, afterComment: true, afterRuleEnds: true, beforeBlockEnds: true } }); } if (typeof source == "string") { return override(DEFAULTS, toHash(source)); } return DEFAULTS; } function toHash(string) { return string .split(OPTION_SEPARATOR) .reduce(function(accumulator, directive) { var parts = directive.split(OPTION_NAME_VALUE_SEPARATOR); var name = parts[0]; var value = parts[1]; if (name == "breaks" || name == "spaces") { accumulator[name] = hashValuesToHash(value); } else if (name == "indentBy" || name == "wrapAt") { accumulator[name] = parseInt(value); } else if (name == "indentWith") { accumulator[name] = mapIndentWith(value); } else if (name == "breakWith") { accumulator[name] = mapBreakWith(value); } return accumulator; }, {}); } function hashValuesToHash(string) { return string .split(HASH_VALUES_OPTION_SEPARATOR) .reduce(function(accumulator, directive) { var parts = directive.split(HASH_VALUES_NAME_VALUE_SEPARATOR); var name = parts[0]; var value = parts[1]; accumulator[name] = normalizeValue(value); return accumulator; }, {}); } function normalizeValue(value) { switch (value) { case FALSE_KEYWORD_1: case FALSE_KEYWORD_2: return false; case TRUE_KEYWORD_1: case TRUE_KEYWORD_2: return true; default: return value; } } function mapBreakWith(value) { switch (value) { case "windows": case "crlf": case BreakWith.CarriageReturnLineFeed: return BreakWith.CarriageReturnLineFeed; case "unix": case "lf": case BreakWith.LineFeed: return BreakWith.LineFeed; default: return systemLineBreak; } } function mapIndentWith(value) { switch (value) { case "space": return IndentWith.Space; case "tab": return IndentWith.Tab; default: return value; } } module.exports = { Breaks: Breaks, Spaces: Spaces, formatFrom: formatFrom }; }, { "../utils/override": 95, os: 109 } ], 62: [ function(require, module, exports) { (function(process) { var url = require("url"); var override = require("../utils/override"); function inlineRequestFrom(option) { return override( /* jshint camelcase: false */ proxyOptionsFrom( process.env.HTTP_PROXY || process.env.http_proxy ), option || {} ); } function proxyOptionsFrom(httpProxy) { return httpProxy ? { hostname: url.parse(httpProxy).hostname, port: parseInt(url.parse(httpProxy).port) } : {}; } module.exports = inlineRequestFrom; }.call(this, require("_process"))); }, { "../utils/override": 95, _process: 112, url: 162 } ], 63: [ function(require, module, exports) { var DEFAULT_TIMEOUT = 5000; function inlineTimeoutFrom(option) { return option || DEFAULT_TIMEOUT; } module.exports = inlineTimeoutFrom; }, {} ], 64: [ function(require, module, exports) { function inlineOptionsFrom(rules) { if (Array.isArray(rules)) { return rules; } if (rules === false) { return ["none"]; } return undefined === rules ? ["local"] : rules.split(","); } module.exports = inlineOptionsFrom; }, {} ], 65: [ function(require, module, exports) { var roundingPrecisionFrom = require("./rounding-precision") .roundingPrecisionFrom; var override = require("../utils/override"); var OptimizationLevel = { Zero: "0", One: "1", Two: "2" }; var DEFAULTS = {}; DEFAULTS[OptimizationLevel.Zero] = {}; DEFAULTS[OptimizationLevel.One] = { cleanupCharsets: true, normalizeUrls: true, optimizeBackground: true, optimizeBorderRadius: true, optimizeFilter: true, optimizeFontWeight: true, optimizeOutline: true, removeEmpty: true, removeNegativePaddings: true, removeQuotes: true, removeWhitespace: true, replaceMultipleZeros: true, replaceTimeUnits: true, replaceZeroUnits: true, roundingPrecision: roundingPrecisionFrom(undefined), selectorsSortingMethod: "standard", specialComments: "all", tidyAtRules: true, tidyBlockScopes: true, tidySelectors: true, transform: noop }; DEFAULTS[OptimizationLevel.Two] = { mergeAdjacentRules: true, mergeIntoShorthands: true, mergeMedia: true, mergeNonAdjacentRules: true, mergeSemantically: false, overrideProperties: true, removeEmpty: true, reduceNonAdjacentRules: true, removeDuplicateFontRules: true, removeDuplicateMediaBlocks: true, removeDuplicateRules: true, removeUnusedAtRules: false, restructureRules: false, skipProperties: [] }; var ALL_KEYWORD_1 = "*"; var ALL_KEYWORD_2 = "all"; var FALSE_KEYWORD_1 = "false"; var FALSE_KEYWORD_2 = "off"; var TRUE_KEYWORD_1 = "true"; var TRUE_KEYWORD_2 = "on"; var LIST_VALUE_SEPARATOR = ","; var OPTION_SEPARATOR = ";"; var OPTION_VALUE_SEPARATOR = ":"; function noop() {} function optimizationLevelFrom(source) { var level = override(DEFAULTS, {}); var Zero = OptimizationLevel.Zero; var One = OptimizationLevel.One; var Two = OptimizationLevel.Two; if (undefined === source) { delete level[Two]; return level; } if (typeof source == "string") { source = parseInt(source); } if (typeof source == "number" && source === parseInt(Two)) { return level; } if (typeof source == "number" && source === parseInt(One)) { delete level[Two]; return level; } if (typeof source == "number" && source === parseInt(Zero)) { delete level[Two]; delete level[One]; return level; } if (typeof source == "object") { source = covertValuesToHashes(source); } if (One in source && "roundingPrecision" in source[One]) { source[One].roundingPrecision = roundingPrecisionFrom( source[One].roundingPrecision ); } if ( Two in source && "skipProperties" in source[Two] && typeof source[Two].skipProperties == "string" ) { source[Two].skipProperties = source[Two].skipProperties.split( LIST_VALUE_SEPARATOR ); } if (Zero in source || One in source || Two in source) { level[Zero] = override(level[Zero], source[Zero]); } if (One in source && ALL_KEYWORD_1 in source[One]) { level[One] = override( level[One], defaults(One, normalizeValue(source[One][ALL_KEYWORD_1])) ); delete source[One][ALL_KEYWORD_1]; } if (One in source && ALL_KEYWORD_2 in source[One]) { level[One] = override( level[One], defaults(One, normalizeValue(source[One][ALL_KEYWORD_2])) ); delete source[One][ALL_KEYWORD_2]; } if (One in source || Two in source) { level[One] = override(level[One], source[One]); } else { delete level[One]; } if (Two in source && ALL_KEYWORD_1 in source[Two]) { level[Two] = override( level[Two], defaults(Two, normalizeValue(source[Two][ALL_KEYWORD_1])) ); delete source[Two][ALL_KEYWORD_1]; } if (Two in source && ALL_KEYWORD_2 in source[Two]) { level[Two] = override( level[Two], defaults(Two, normalizeValue(source[Two][ALL_KEYWORD_2])) ); delete source[Two][ALL_KEYWORD_2]; } if (Two in source) { level[Two] = override(level[Two], source[Two]); } else { delete level[Two]; } return level; } function defaults(level, value) { var options = override(DEFAULTS[level], {}); var key; for (key in options) { if (typeof options[key] == "boolean") { options[key] = value; } } return options; } function normalizeValue(value) { switch (value) { case FALSE_KEYWORD_1: case FALSE_KEYWORD_2: return false; case TRUE_KEYWORD_1: case TRUE_KEYWORD_2: return true; default: return value; } } function covertValuesToHashes(source) { var clonedSource = override(source, {}); var level; var i; for (i = 0; i <= 2; i++) { level = "" + i; if ( level in clonedSource && (clonedSource[level] === undefined || clonedSource[level] === false) ) { delete clonedSource[level]; } if (level in clonedSource && clonedSource[level] === true) { clonedSource[level] = {}; } if ( level in clonedSource && typeof clonedSource[level] == "string" ) { clonedSource[level] = covertToHash(clonedSource[level], level); } } return clonedSource; } function covertToHash(asString, level) { return asString .split(OPTION_SEPARATOR) .reduce(function(accumulator, directive) { var parts = directive.split(OPTION_VALUE_SEPARATOR); var name = parts[0]; var value = parts[1]; var normalizedValue = normalizeValue(value); if (ALL_KEYWORD_1 == name || ALL_KEYWORD_2 == name) { accumulator = override( accumulator, defaults(level, normalizedValue) ); } else { accumulator[name] = normalizedValue; } return accumulator; }, {}); } module.exports = { OptimizationLevel: OptimizationLevel, optimizationLevelFrom: optimizationLevelFrom }; }, { "../utils/override": 95, "./rounding-precision": 68 } ], 66: [ function(require, module, exports) { (function(process) { var path = require("path"); function rebaseToFrom(option) { return option ? path.resolve(option) : process.cwd(); } module.exports = rebaseToFrom; }.call(this, require("_process"))); }, { _process: 112, path: 110 } ], 67: [ function(require, module, exports) { function rebaseFrom(rebaseOption) { return undefined === rebaseOption ? true : !!rebaseOption; } module.exports = rebaseFrom; }, {} ], 68: [ function(require, module, exports) { var override = require("../utils/override"); var INTEGER_PATTERN = /^\d+$/; var ALL_UNITS = ["*", "all"]; var DEFAULT_PRECISION = "off"; // all precision changes are disabled var DIRECTIVES_SEPARATOR = ","; // e.g. *=5,px=3 var DIRECTIVE_VALUE_SEPARATOR = "="; // e.g. *=5 function roundingPrecisionFrom(source) { return override( defaults(DEFAULT_PRECISION), buildPrecisionFrom(source) ); } function defaults(value) { return { ch: value, cm: value, em: value, ex: value, in: value, mm: value, pc: value, pt: value, px: value, q: value, rem: value, vh: value, vmax: value, vmin: value, vw: value, "%": value }; } function buildPrecisionFrom(source) { if (source === null || source === undefined) { return {}; } if (typeof source == "boolean") { return {}; } if (typeof source == "number" && source == -1) { return defaults(DEFAULT_PRECISION); } if (typeof source == "number") { return defaults(source); } if (typeof source == "string" && INTEGER_PATTERN.test(source)) { return defaults(parseInt(source)); } if (typeof source == "string" && source == DEFAULT_PRECISION) { return defaults(DEFAULT_PRECISION); } if (typeof source == "object") { return source; } return source .split(DIRECTIVES_SEPARATOR) .reduce(function(accumulator, directive) { var directiveParts = directive.split(DIRECTIVE_VALUE_SEPARATOR); var name = directiveParts[0]; var value = parseInt(directiveParts[1]); if (isNaN(value) || value == -1) { value = DEFAULT_PRECISION; } if (ALL_UNITS.indexOf(name) > -1) { accumulator = override(accumulator, defaults(value)); } else { accumulator[name] = value; } return accumulator; }, {}); } module.exports = { DEFAULT: DEFAULT_PRECISION, roundingPrecisionFrom: roundingPrecisionFrom }; }, { "../utils/override": 95 } ], 69: [ function(require, module, exports) { (function(global, Buffer) { var fs = require("fs"); var path = require("path"); var isAllowedResource = require("./is-allowed-resource"); var matchDataUri = require("./match-data-uri"); var rebaseLocalMap = require("./rebase-local-map"); var rebaseRemoteMap = require("./rebase-remote-map"); var Token = require("../tokenizer/token"); var hasProtocol = require("../utils/has-protocol"); var isDataUriResource = require("../utils/is-data-uri-resource"); var isRemoteResource = require("../utils/is-remote-resource"); var MAP_MARKER_PATTERN = /^\/\*# sourceMappingURL=(\S+) \*\/$/; function applySourceMaps(tokens, context, callback) { var applyContext = { callback: callback, fetch: context.options.fetch, index: 0, inline: context.options.inline, inlineRequest: context.options.inlineRequest, inlineTimeout: context.options.inlineTimeout, inputSourceMapTracker: context.inputSourceMapTracker, localOnly: context.localOnly, processedTokens: [], rebaseTo: context.options.rebaseTo, sourceTokens: tokens, warnings: context.warnings }; return context.options.sourceMap && tokens.length > 0 ? doApplySourceMaps(applyContext) : callback(tokens); } function doApplySourceMaps(applyContext) { var singleSourceTokens = []; var lastSource = findTokenSource(applyContext.sourceTokens[0]); var source; var token; var l; for ( l = applyContext.sourceTokens.length; applyContext.index < l; applyContext.index++ ) { token = applyContext.sourceTokens[applyContext.index]; source = findTokenSource(token); if (source != lastSource) { singleSourceTokens = []; lastSource = source; } singleSourceTokens.push(token); applyContext.processedTokens.push(token); if ( token[0] == Token.COMMENT && MAP_MARKER_PATTERN.test(token[1]) ) { return fetchAndApplySourceMap( token[1], source, singleSourceTokens, applyContext ); } } return applyContext.callback(applyContext.processedTokens); } function findTokenSource(token) { var scope; var metadata; if (token[0] == Token.AT_RULE || token[0] == Token.COMMENT) { metadata = token[2][0]; } else { scope = token[1][0]; metadata = scope[2][0]; } return metadata[2]; } function fetchAndApplySourceMap( sourceMapComment, source, singleSourceTokens, applyContext ) { return extractInputSourceMapFrom( sourceMapComment, applyContext, function(inputSourceMap) { if (inputSourceMap) { applyContext.inputSourceMapTracker.track( source, inputSourceMap ); applySourceMapRecursively( singleSourceTokens, applyContext.inputSourceMapTracker ); } applyContext.index++; return doApplySourceMaps(applyContext); } ); } function extractInputSourceMapFrom( sourceMapComment, applyContext, whenSourceMapReady ) { var uri = MAP_MARKER_PATTERN.exec(sourceMapComment)[1]; var absoluteUri; var sourceMap; var rebasedMap; if (isDataUriResource(uri)) { sourceMap = extractInputSourceMapFromDataUri(uri); return whenSourceMapReady(sourceMap); } else if (isRemoteResource(uri)) { return loadInputSourceMapFromRemoteUri( uri, applyContext, function(sourceMap) { var parsedMap; if (sourceMap) { parsedMap = JSON.parse(sourceMap); rebasedMap = rebaseRemoteMap(parsedMap, uri); whenSourceMapReady(rebasedMap); } else { whenSourceMapReady(null); } } ); } else { // at this point `uri` is already rebased, see lib/reader/rebase.js#rebaseSourceMapComment // it is rebased to be consistent with rebasing other URIs // however here we need to resolve it back to read it from disk absoluteUri = path.resolve(applyContext.rebaseTo, uri); sourceMap = loadInputSourceMapFromLocalUri( absoluteUri, applyContext ); if (sourceMap) { rebasedMap = rebaseLocalMap( sourceMap, absoluteUri, applyContext.rebaseTo ); return whenSourceMapReady(rebasedMap); } else { return whenSourceMapReady(null); } } } function extractInputSourceMapFromDataUri(uri) { var dataUriMatch = matchDataUri(uri); var charset = dataUriMatch[2] ? dataUriMatch[2].split(/[=;]/)[2] : "us-ascii"; var encoding = dataUriMatch[3] ? dataUriMatch[3].split(";")[1] : "utf8"; var data = encoding == "utf8" ? global.unescape(dataUriMatch[4]) : dataUriMatch[4]; var buffer = new Buffer(data, encoding); buffer.charset = charset; return JSON.parse(buffer.toString()); } function loadInputSourceMapFromRemoteUri( uri, applyContext, whenLoaded ) { var isAllowed = isAllowedResource(uri, true, applyContext.inline); var isRuntimeResource = !hasProtocol(uri); if (applyContext.localOnly) { applyContext.warnings.push( 'Cannot fetch remote resource from "' + uri + '" as no callback given.' ); return whenLoaded(null); } else if (isRuntimeResource) { applyContext.warnings.push( 'Cannot fetch "' + uri + '" as no protocol given.' ); return whenLoaded(null); } else if (!isAllowed) { applyContext.warnings.push( 'Cannot fetch "' + uri + '" as resource is not allowed.' ); return whenLoaded(null); } applyContext.fetch( uri, applyContext.inlineRequest, applyContext.inlineTimeout, function(error, body) { if (error) { applyContext.warnings.push( 'Missing source map at "' + uri + '" - ' + error ); return whenLoaded(null); } whenLoaded(body); } ); } function loadInputSourceMapFromLocalUri(uri, applyContext) { var isAllowed = isAllowedResource(uri, false, applyContext.inline); var sourceMap; if (!fs.existsSync(uri) || !fs.statSync(uri).isFile()) { applyContext.warnings.push( 'Ignoring local source map at "' + uri + '" as resource is missing.' ); return null; } else if (!isAllowed) { applyContext.warnings.push( 'Cannot fetch "' + uri + '" as resource is not allowed.' ); return null; } sourceMap = fs.readFileSync(uri, "utf-8"); return JSON.parse(sourceMap); } function applySourceMapRecursively(tokens, inputSourceMapTracker) { var token; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; switch (token[0]) { case Token.AT_RULE: applySourceMapTo(token, inputSourceMapTracker); break; case Token.AT_RULE_BLOCK: applySourceMapRecursively(token[1], inputSourceMapTracker); applySourceMapRecursively(token[2], inputSourceMapTracker); break; case Token.AT_RULE_BLOCK_SCOPE: applySourceMapTo(token, inputSourceMapTracker); break; case Token.NESTED_BLOCK: applySourceMapRecursively(token[1], inputSourceMapTracker); applySourceMapRecursively(token[2], inputSourceMapTracker); break; case Token.NESTED_BLOCK_SCOPE: applySourceMapTo(token, inputSourceMapTracker); break; case Token.COMMENT: applySourceMapTo(token, inputSourceMapTracker); break; case Token.PROPERTY: applySourceMapRecursively(token, inputSourceMapTracker); break; case Token.PROPERTY_BLOCK: applySourceMapRecursively(token[1], inputSourceMapTracker); break; case Token.PROPERTY_NAME: applySourceMapTo(token, inputSourceMapTracker); break; case Token.PROPERTY_VALUE: applySourceMapTo(token, inputSourceMapTracker); break; case Token.RULE: applySourceMapRecursively(token[1], inputSourceMapTracker); applySourceMapRecursively(token[2], inputSourceMapTracker); break; case Token.RULE_SCOPE: applySourceMapTo(token, inputSourceMapTracker); } } return tokens; } function applySourceMapTo(token, inputSourceMapTracker) { var value = token[1]; var metadata = token[2]; var newMetadata = []; var i, l; for (i = 0, l = metadata.length; i < l; i++) { newMetadata.push( inputSourceMapTracker.originalPositionFor( metadata[i], value.length ) ); } token[2] = newMetadata; } module.exports = applySourceMaps; }.call( this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}, require("buffer").Buffer )); }, { "../tokenizer/token": 84, "../utils/has-protocol": 88, "../utils/is-data-uri-resource": 89, "../utils/is-remote-resource": 93, "./is-allowed-resource": 72, "./match-data-uri": 75, "./rebase-local-map": 78, "./rebase-remote-map": 79, buffer: 4, fs: 3, path: 110 } ], 70: [ function(require, module, exports) { var split = require("../utils/split"); var BRACE_PREFIX = /^\(/; var BRACE_SUFFIX = /\)$/; var IMPORT_PREFIX_PATTERN = /^@import/i; var QUOTE_PREFIX_PATTERN = /['"]\s*/; var QUOTE_SUFFIX_PATTERN = /\s*['"]/; var URL_PREFIX_PATTERN = /^url\(\s*/i; var URL_SUFFIX_PATTERN = /\s*\)/i; function extractImportUrlAndMedia(atRuleValue) { var uri; var mediaQuery; var stripped; var parts; stripped = atRuleValue .replace(IMPORT_PREFIX_PATTERN, "") .trim() .replace(URL_PREFIX_PATTERN, "(") .replace(URL_SUFFIX_PATTERN, ")") .replace(QUOTE_PREFIX_PATTERN, "") .replace(QUOTE_SUFFIX_PATTERN, ""); parts = split(stripped, " "); uri = parts[0].replace(BRACE_PREFIX, "").replace(BRACE_SUFFIX, ""); mediaQuery = parts.slice(1).join(" "); return [uri, mediaQuery]; } module.exports = extractImportUrlAndMedia; }, { "../utils/split": 96 } ], 71: [ function(require, module, exports) { var SourceMapConsumer = require("source-map").SourceMapConsumer; function inputSourceMapTracker() { var maps = {}; return { all: all.bind(null, maps), isTracking: isTracking.bind(null, maps), originalPositionFor: originalPositionFor.bind(null, maps), track: track.bind(null, maps) }; } function all(maps) { return maps; } function isTracking(maps, source) { return source in maps; } function originalPositionFor(maps, metadata, range, selectorFallbacks) { var line = metadata[0]; var column = metadata[1]; var source = metadata[2]; var position = { line: line, column: column + range }; var originalPosition; while (!originalPosition && position.column > column) { position.column--; originalPosition = maps[source].originalPositionFor(position); } if (!originalPosition || originalPosition.column < 0) { return metadata; } if ( originalPosition.line === null && line > 1 && selectorFallbacks > 0 ) { return originalPositionFor( maps, [line - 1, column, source], range, selectorFallbacks - 1 ); } return originalPosition.line !== null ? toMetadata(originalPosition) : metadata; } function toMetadata(asHash) { return [asHash.line, asHash.column, asHash.source]; } function track(maps, source, data) { maps[source] = new SourceMapConsumer(data); } module.exports = inputSourceMapTracker; }, { "source-map": 155 } ], 72: [ function(require, module, exports) { var path = require("path"); var url = require("url"); var isRemoteResource = require("../utils/is-remote-resource"); var hasProtocol = require("../utils/has-protocol"); var HTTP_PROTOCOL = "http:"; function isAllowedResource(uri, isRemote, rules) { var match; var absoluteUri; var allowed = isRemote ? false : true; var rule; var isNegated; var normalizedRule; var i; if (rules.length === 0) { return false; } if (isRemote && !hasProtocol(uri)) { uri = HTTP_PROTOCOL + uri; } match = isRemote ? url.parse(uri).host : uri; absoluteUri = isRemote ? uri : path.resolve(uri); for (i = 0; i < rules.length; i++) { rule = rules[i]; isNegated = rule[0] == "!"; normalizedRule = rule.substring(1); if (isNegated && isRemote && isRemoteRule(normalizedRule)) { allowed = allowed && !isAllowedResource(uri, true, [normalizedRule]); } else if ( isNegated && !isRemote && !isRemoteRule(normalizedRule) ) { allowed = allowed && !isAllowedResource(uri, false, [normalizedRule]); } else if (isNegated) { allowed = allowed && true; } else if (rule == "all") { allowed = true; } else if (isRemote && rule == "local") { allowed = allowed || false; } else if (isRemote && rule == "remote") { allowed = true; } else if (!isRemote && rule == "remote") { allowed = false; } else if (!isRemote && rule == "local") { allowed = true; } else if (rule === match) { allowed = true; } else if (rule === uri) { allowed = true; } else if (isRemote && absoluteUri.indexOf(rule) === 0) { allowed = true; } else if ( !isRemote && absoluteUri.indexOf(path.resolve(rule)) === 0 ) { allowed = true; } else if (isRemote != isRemoteRule(normalizedRule)) { allowed = allowed && true; } else { allowed = false; } } return allowed; } function isRemoteRule(rule) { return ( isRemoteResource(rule) || url.parse(HTTP_PROTOCOL + "//" + rule).host == rule ); } module.exports = isAllowedResource; }, { "../utils/has-protocol": 88, "../utils/is-remote-resource": 93, path: 110, url: 162 } ], 73: [ function(require, module, exports) { var fs = require("fs"); var path = require("path"); var isAllowedResource = require("./is-allowed-resource"); var hasProtocol = require("../utils/has-protocol"); var isRemoteResource = require("../utils/is-remote-resource"); function loadOriginalSources(context, callback) { var loadContext = { callback: callback, fetch: context.options.fetch, index: 0, inline: context.options.inline, inlineRequest: context.options.inlineRequest, inlineTimeout: context.options.inlineTimeout, localOnly: context.localOnly, rebaseTo: context.options.rebaseTo, sourcesContent: context.sourcesContent, uriToSource: uriToSourceMapping( context.inputSourceMapTracker.all() ), warnings: context.warnings }; return context.options.sourceMap && context.options.sourceMapInlineSources ? doLoadOriginalSources(loadContext) : callback(); } function uriToSourceMapping(allSourceMapConsumers) { var mapping = {}; var consumer; var uri; var source; var i, l; for (source in allSourceMapConsumers) { consumer = allSourceMapConsumers[source]; for (i = 0, l = consumer.sources.length; i < l; i++) { uri = consumer.sources[i]; source = consumer.sourceContentFor(uri, true); mapping[uri] = source; } } return mapping; } function doLoadOriginalSources(loadContext) { var uris = Object.keys(loadContext.uriToSource); var uri; var source; var total; for ( total = uris.length; loadContext.index < total; loadContext.index++ ) { uri = uris[loadContext.index]; source = loadContext.uriToSource[uri]; if (source) { loadContext.sourcesContent[uri] = source; } else { return loadOriginalSource(uri, loadContext); } } return loadContext.callback(); } function loadOriginalSource(uri, loadContext) { var content; if (isRemoteResource(uri)) { return loadOriginalSourceFromRemoteUri(uri, loadContext, function( content ) { loadContext.index++; loadContext.sourcesContent[uri] = content; return doLoadOriginalSources(loadContext); }); } else { content = loadOriginalSourceFromLocalUri(uri, loadContext); loadContext.index++; loadContext.sourcesContent[uri] = content; return doLoadOriginalSources(loadContext); } } function loadOriginalSourceFromRemoteUri(uri, loadContext, whenLoaded) { var isAllowed = isAllowedResource(uri, true, loadContext.inline); var isRuntimeResource = !hasProtocol(uri); if (loadContext.localOnly) { loadContext.warnings.push( 'Cannot fetch remote resource from "' + uri + '" as no callback given.' ); return whenLoaded(null); } else if (isRuntimeResource) { loadContext.warnings.push( 'Cannot fetch "' + uri + '" as no protocol given.' ); return whenLoaded(null); } else if (!isAllowed) { loadContext.warnings.push( 'Cannot fetch "' + uri + '" as resource is not allowed.' ); return whenLoaded(null); } loadContext.fetch( uri, loadContext.inlineRequest, loadContext.inlineTimeout, function(error, content) { if (error) { loadContext.warnings.push( 'Missing original source at "' + uri + '" - ' + error ); } whenLoaded(content); } ); } function loadOriginalSourceFromLocalUri(relativeUri, loadContext) { var isAllowed = isAllowedResource( relativeUri, false, loadContext.inline ); var absoluteUri = path.resolve(loadContext.rebaseTo, relativeUri); if ( !fs.existsSync(absoluteUri) || !fs.statSync(absoluteUri).isFile() ) { loadContext.warnings.push( 'Ignoring local source map at "' + absoluteUri + '" as resource is missing.' ); return null; } else if (!isAllowed) { loadContext.warnings.push( 'Cannot fetch "' + absoluteUri + '" as resource is not allowed.' ); return null; } return fs.readFileSync(absoluteUri, "utf8"); } module.exports = loadOriginalSources; }, { "../utils/has-protocol": 88, "../utils/is-remote-resource": 93, "./is-allowed-resource": 72, fs: 3, path: 110 } ], 74: [ function(require, module, exports) { var http = require("http"); var https = require("https"); var url = require("url"); var isHttpResource = require("../utils/is-http-resource"); var isHttpsResource = require("../utils/is-https-resource"); var override = require("../utils/override"); var HTTP_PROTOCOL = "http:"; function loadRemoteResource( uri, inlineRequest, inlineTimeout, callback ) { var proxyProtocol = inlineRequest.protocol || inlineRequest.hostname; var errorHandled = false; var requestOptions; var fetch; requestOptions = override(url.parse(uri), inlineRequest || {}); if (inlineRequest.hostname !== undefined) { // overwrite as we always expect a http proxy currently requestOptions.protocol = inlineRequest.protocol || HTTP_PROTOCOL; requestOptions.path = requestOptions.href; } fetch = (proxyProtocol && !isHttpsResource(proxyProtocol)) || isHttpResource(uri) ? http.get : https.get; fetch(requestOptions, function(res) { var chunks = []; var movedUri; if (errorHandled) { return; } if (res.statusCode < 200 || res.statusCode > 399) { return callback(res.statusCode, null); } else if (res.statusCode > 299) { movedUri = url.resolve(uri, res.headers.location); return loadRemoteResource( movedUri, inlineRequest, inlineTimeout, callback ); } res.on("data", function(chunk) { chunks.push(chunk.toString()); }); res.on("end", function() { var body = chunks.join(""); callback(null, body); }); }) .on("error", function(res) { if (errorHandled) { return; } errorHandled = true; callback(res.message, null); }) .on("timeout", function() { if (errorHandled) { return; } errorHandled = true; callback("timeout", null); }) .setTimeout(inlineTimeout); } module.exports = loadRemoteResource; }, { "../utils/is-http-resource": 90, "../utils/is-https-resource": 91, "../utils/override": 95, http: 156, https: 104, url: 162 } ], 75: [ function(require, module, exports) { var DATA_URI_PATTERN = /^data:(\S*?)?(;charset=[^;]+)?(;[^,]+?)?,(.+)/; function matchDataUri(uri) { return DATA_URI_PATTERN.exec(uri); } module.exports = matchDataUri; }, {} ], 76: [ function(require, module, exports) { var UNIX_SEPARATOR = "/"; var WINDOWS_SEPARATOR_PATTERN = /\\/g; function normalizePath(path) { return path.replace(WINDOWS_SEPARATOR_PATTERN, UNIX_SEPARATOR); } module.exports = normalizePath; }, {} ], 77: [ function(require, module, exports) { (function(Buffer, process) { var fs = require("fs"); var path = require("path"); var applySourceMaps = require("./apply-source-maps"); var extractImportUrlAndMedia = require("./extract-import-url-and-media"); var isAllowedResource = require("./is-allowed-resource"); var loadOriginalSources = require("./load-original-sources"); var normalizePath = require("./normalize-path"); var rebase = require("./rebase"); var rebaseLocalMap = require("./rebase-local-map"); var rebaseRemoteMap = require("./rebase-remote-map"); var restoreImport = require("./restore-import"); var tokenize = require("../tokenizer/tokenize"); var Token = require("../tokenizer/token"); var Marker = require("../tokenizer/marker"); var hasProtocol = require("../utils/has-protocol"); var isImport = require("../utils/is-import"); var isRemoteResource = require("../utils/is-remote-resource"); var UNKNOWN_URI = "uri:unknown"; function readSources(input, context, callback) { return doReadSources(input, context, function(tokens) { return applySourceMaps(tokens, context, function() { return loadOriginalSources(context, function() { return callback(tokens); }); }); }); } function doReadSources(input, context, callback) { if (typeof input == "string") { return fromString(input, context, callback); } else if (Buffer.isBuffer(input)) { return fromString(input.toString(), context, callback); } else if (Array.isArray(input)) { return fromArray(input, context, callback); } else if (typeof input == "object") { return fromHash(input, context, callback); } } function fromString(input, context, callback) { context.source = undefined; context.sourcesContent[undefined] = input; context.stats.originalSize += input.length; return fromStyles( input, context, { inline: context.options.inline }, callback ); } function fromArray(input, context, callback) { var inputAsImports = input.reduce(function(accumulator, uriOrHash) { if (typeof uriOrHash === "string") { return addStringSource(uriOrHash, accumulator); } else { return addHashSource(uriOrHash, context, accumulator); } }, []); return fromStyles( inputAsImports.join(""), context, { inline: ["all"] }, callback ); } function fromHash(input, context, callback) { var inputAsImports = addHashSource(input, context, []); return fromStyles( inputAsImports.join(""), context, { inline: ["all"] }, callback ); } function addStringSource(input, imports) { imports.push(restoreAsImport(normalizeUri(input))); return imports; } function addHashSource(input, context, imports) { var uri; var normalizedUri; var source; for (uri in input) { source = input[uri]; normalizedUri = normalizeUri(uri); imports.push(restoreAsImport(normalizedUri)); context.sourcesContent[normalizedUri] = source.styles; if (source.sourceMap) { trackSourceMap(source.sourceMap, normalizedUri, context); } } return imports; } function normalizeUri(uri) { var currentPath = path.resolve(""); var absoluteUri; var relativeToCurrentPath; var normalizedUri; if (isRemoteResource(uri)) { return uri; } absoluteUri = path.isAbsolute(uri) ? uri : path.resolve(uri); relativeToCurrentPath = path.relative(currentPath, absoluteUri); normalizedUri = normalizePath(relativeToCurrentPath); return normalizedUri; } function trackSourceMap(sourceMap, uri, context) { var parsedMap = typeof sourceMap == "string" ? JSON.parse(sourceMap) : sourceMap; var rebasedMap = isRemoteResource(uri) ? rebaseRemoteMap(parsedMap, uri) : rebaseLocalMap( parsedMap, uri || UNKNOWN_URI, context.options.rebaseTo ); context.inputSourceMapTracker.track(uri, rebasedMap); } function restoreAsImport(uri) { return restoreImport("url(" + uri + ")", "") + Marker.SEMICOLON; } function fromStyles(styles, context, parentInlinerContext, callback) { var tokens; var rebaseConfig = {}; if (!context.source) { rebaseConfig.fromBase = path.resolve(""); rebaseConfig.toBase = context.options.rebaseTo; } else if (isRemoteResource(context.source)) { rebaseConfig.fromBase = context.source; rebaseConfig.toBase = context.source; } else if (path.isAbsolute(context.source)) { rebaseConfig.fromBase = path.dirname(context.source); rebaseConfig.toBase = context.options.rebaseTo; } else { rebaseConfig.fromBase = path.dirname( path.resolve(context.source) ); rebaseConfig.toBase = context.options.rebaseTo; } tokens = tokenize(styles, context); tokens = rebase( tokens, context.options.rebase, context.validator, rebaseConfig ); return allowsAnyImports(parentInlinerContext.inline) ? inline(tokens, context, parentInlinerContext, callback) : callback(tokens); } function allowsAnyImports(inline) { return !(inline.length == 1 && inline[0] == "none"); } function inline( tokens, externalContext, parentInlinerContext, callback ) { var inlinerContext = { afterContent: false, callback: callback, errors: externalContext.errors, externalContext: externalContext, fetch: externalContext.options.fetch, inlinedStylesheets: parentInlinerContext.inlinedStylesheets || externalContext.inlinedStylesheets, inline: parentInlinerContext.inline, inlineRequest: externalContext.options.inlineRequest, inlineTimeout: externalContext.options.inlineTimeout, isRemote: parentInlinerContext.isRemote || false, localOnly: externalContext.localOnly, outputTokens: [], rebaseTo: externalContext.options.rebaseTo, sourceTokens: tokens, warnings: externalContext.warnings }; return doInlineImports(inlinerContext); } function doInlineImports(inlinerContext) { var token; var i, l; for (i = 0, l = inlinerContext.sourceTokens.length; i < l; i++) { token = inlinerContext.sourceTokens[i]; if (token[0] == Token.AT_RULE && isImport(token[1])) { inlinerContext.sourceTokens.splice(0, i); return inlineStylesheet(token, inlinerContext); } else if ( token[0] == Token.AT_RULE || token[0] == Token.COMMENT ) { inlinerContext.outputTokens.push(token); } else { inlinerContext.outputTokens.push(token); inlinerContext.afterContent = true; } } inlinerContext.sourceTokens = []; return inlinerContext.callback(inlinerContext.outputTokens); } function inlineStylesheet(token, inlinerContext) { var uriAndMediaQuery = extractImportUrlAndMedia(token[1]); var uri = uriAndMediaQuery[0]; var mediaQuery = uriAndMediaQuery[1]; var metadata = token[2]; return isRemoteResource(uri) ? inlineRemoteStylesheet( uri, mediaQuery, metadata, inlinerContext ) : inlineLocalStylesheet( uri, mediaQuery, metadata, inlinerContext ); } function inlineRemoteStylesheet( uri, mediaQuery, metadata, inlinerContext ) { var isAllowed = isAllowedResource(uri, true, inlinerContext.inline); var originalUri = uri; var isLoaded = uri in inlinerContext.externalContext.sourcesContent; var isRuntimeResource = !hasProtocol(uri); if (inlinerContext.inlinedStylesheets.indexOf(uri) > -1) { inlinerContext.warnings.push( 'Ignoring remote @import of "' + uri + '" as it has already been imported.' ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } else if ( inlinerContext.localOnly && inlinerContext.afterContent ) { inlinerContext.warnings.push( 'Ignoring remote @import of "' + uri + '" as no callback given and after other content.' ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } else if (isRuntimeResource) { inlinerContext.warnings.push( 'Skipping remote @import of "' + uri + '" as no protocol given.' ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( inlinerContext.sourceTokens.slice(0, 1) ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } else if (inlinerContext.localOnly && !isLoaded) { inlinerContext.warnings.push( 'Skipping remote @import of "' + uri + '" as no callback given.' ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( inlinerContext.sourceTokens.slice(0, 1) ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } else if (!isAllowed && inlinerContext.afterContent) { inlinerContext.warnings.push( 'Ignoring remote @import of "' + uri + '" as resource is not allowed and after other content.' ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } else if (!isAllowed) { inlinerContext.warnings.push( 'Skipping remote @import of "' + uri + '" as resource is not allowed.' ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( inlinerContext.sourceTokens.slice(0, 1) ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } inlinerContext.inlinedStylesheets.push(uri); function whenLoaded(error, importedStyles) { if (error) { inlinerContext.errors.push( 'Broken @import declaration of "' + uri + '" - ' + error ); return process.nextTick(function() { inlinerContext.outputTokens = inlinerContext.outputTokens.concat( inlinerContext.sourceTokens.slice(0, 1) ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); doInlineImports(inlinerContext); }); } inlinerContext.inline = inlinerContext.externalContext.options.inline; inlinerContext.isRemote = true; inlinerContext.externalContext.source = originalUri; inlinerContext.externalContext.sourcesContent[ uri ] = importedStyles; inlinerContext.externalContext.stats.originalSize += importedStyles.length; return fromStyles( importedStyles, inlinerContext.externalContext, inlinerContext, function(importedTokens) { importedTokens = wrapInMedia( importedTokens, mediaQuery, metadata ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( importedTokens ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } ); } return isLoaded ? whenLoaded( null, inlinerContext.externalContext.sourcesContent[uri] ) : inlinerContext.fetch( uri, inlinerContext.inlineRequest, inlinerContext.inlineTimeout, whenLoaded ); } function inlineLocalStylesheet( uri, mediaQuery, metadata, inlinerContext ) { var currentPath = path.resolve(""); var absoluteUri = path.isAbsolute(uri) ? path.resolve( currentPath, uri[0] == "/" ? uri.substring(1) : uri ) : path.resolve(inlinerContext.rebaseTo, uri); var relativeToCurrentPath = path.relative(currentPath, absoluteUri); var importedStyles; var isAllowed = isAllowedResource( uri, false, inlinerContext.inline ); var normalizedPath = normalizePath(relativeToCurrentPath); var isLoaded = normalizedPath in inlinerContext.externalContext.sourcesContent; if (inlinerContext.inlinedStylesheets.indexOf(absoluteUri) > -1) { inlinerContext.warnings.push( 'Ignoring local @import of "' + uri + '" as it has already been imported.' ); } else if ( !isLoaded && (!fs.existsSync(absoluteUri) || !fs.statSync(absoluteUri).isFile()) ) { inlinerContext.errors.push( 'Ignoring local @import of "' + uri + '" as resource is missing.' ); } else if (!isAllowed && inlinerContext.afterContent) { inlinerContext.warnings.push( 'Ignoring local @import of "' + uri + '" as resource is not allowed and after other content.' ); } else if (inlinerContext.afterContent) { inlinerContext.warnings.push( 'Ignoring local @import of "' + uri + '" as after other content.' ); } else if (!isAllowed) { inlinerContext.warnings.push( 'Skipping local @import of "' + uri + '" as resource is not allowed.' ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( inlinerContext.sourceTokens.slice(0, 1) ); } else { importedStyles = isLoaded ? inlinerContext.externalContext.sourcesContent[normalizedPath] : fs.readFileSync(absoluteUri, "utf-8"); inlinerContext.inlinedStylesheets.push(absoluteUri); inlinerContext.inline = inlinerContext.externalContext.options.inline; inlinerContext.externalContext.source = normalizedPath; inlinerContext.externalContext.sourcesContent[ normalizedPath ] = importedStyles; inlinerContext.externalContext.stats.originalSize += importedStyles.length; return fromStyles( importedStyles, inlinerContext.externalContext, inlinerContext, function(importedTokens) { importedTokens = wrapInMedia( importedTokens, mediaQuery, metadata ); inlinerContext.outputTokens = inlinerContext.outputTokens.concat( importedTokens ); inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice( 1 ); return doInlineImports(inlinerContext); } ); } inlinerContext.sourceTokens = inlinerContext.sourceTokens.slice(1); return doInlineImports(inlinerContext); } function wrapInMedia(tokens, mediaQuery, metadata) { if (mediaQuery) { return [ [ Token.NESTED_BLOCK, [ [Token.NESTED_BLOCK_SCOPE, "@media " + mediaQuery, metadata] ], tokens ] ]; } else { return tokens; } } module.exports = readSources; }.call( this, { isBuffer: require("../../../is-buffer/index.js") }, require("_process") )); }, { "../../../is-buffer/index.js": 107, "../tokenizer/marker": 83, "../tokenizer/token": 84, "../tokenizer/tokenize": 85, "../utils/has-protocol": 88, "../utils/is-import": 92, "../utils/is-remote-resource": 93, "./apply-source-maps": 69, "./extract-import-url-and-media": 70, "./is-allowed-resource": 72, "./load-original-sources": 73, "./normalize-path": 76, "./rebase": 80, "./rebase-local-map": 78, "./rebase-remote-map": 79, "./restore-import": 81, _process: 112, fs: 3, path: 110 } ], 78: [ function(require, module, exports) { var path = require("path"); function rebaseLocalMap(sourceMap, sourceUri, rebaseTo) { var currentPath = path.resolve(""); var absoluteUri = path.resolve(currentPath, sourceUri); var absoluteUriDirectory = path.dirname(absoluteUri); sourceMap.sources = sourceMap.sources.map(function(source) { return path.relative( rebaseTo, path.resolve(absoluteUriDirectory, source) ); }); return sourceMap; } module.exports = rebaseLocalMap; }, { path: 110 } ], 79: [ function(require, module, exports) { var path = require("path"); var url = require("url"); function rebaseRemoteMap(sourceMap, sourceUri) { var sourceDirectory = path.dirname(sourceUri); sourceMap.sources = sourceMap.sources.map(function(source) { return url.resolve(sourceDirectory, source); }); return sourceMap; } module.exports = rebaseRemoteMap; }, { path: 110, url: 162 } ], 80: [ function(require, module, exports) { var extractImportUrlAndMedia = require("./extract-import-url-and-media"); var restoreImport = require("./restore-import"); var rewriteUrl = require("./rewrite-url"); var Token = require("../tokenizer/token"); var isImport = require("../utils/is-import"); var SOURCE_MAP_COMMENT_PATTERN = /^\/\*# sourceMappingURL=(\S+) \*\/$/; function rebase(tokens, rebaseAll, validator, rebaseConfig) { return rebaseAll ? rebaseEverything(tokens, validator, rebaseConfig) : rebaseAtRules(tokens, validator, rebaseConfig); } function rebaseEverything(tokens, validator, rebaseConfig) { var token; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; switch (token[0]) { case Token.AT_RULE: rebaseAtRule(token, validator, rebaseConfig); break; case Token.AT_RULE_BLOCK: rebaseProperties(token[2], validator, rebaseConfig); break; case Token.COMMENT: rebaseSourceMapComment(token, rebaseConfig); break; case Token.NESTED_BLOCK: rebaseEverything(token[2], validator, rebaseConfig); break; case Token.RULE: rebaseProperties(token[2], validator, rebaseConfig); break; } } return tokens; } function rebaseAtRules(tokens, validator, rebaseConfig) { var token; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; switch (token[0]) { case Token.AT_RULE: rebaseAtRule(token, validator, rebaseConfig); break; } } return tokens; } function rebaseAtRule(token, validator, rebaseConfig) { if (!isImport(token[1])) { return; } var uriAndMediaQuery = extractImportUrlAndMedia(token[1]); var newUrl = rewriteUrl(uriAndMediaQuery[0], rebaseConfig); var mediaQuery = uriAndMediaQuery[1]; token[1] = restoreImport(newUrl, mediaQuery); } function rebaseSourceMapComment(token, rebaseConfig) { var matches = SOURCE_MAP_COMMENT_PATTERN.exec(token[1]); if (matches && matches[1].indexOf("data:") === -1) { token[1] = token[1].replace( matches[1], rewriteUrl(matches[1], rebaseConfig, true) ); } } function rebaseProperties(properties, validator, rebaseConfig) { var property; var value; var i, l; var j, m; for (i = 0, l = properties.length; i < l; i++) { property = properties[i]; for ( j = 2 /* 0 is Token.PROPERTY, 1 is name */, m = property.length; j < m; j++ ) { value = property[j][1]; if (validator.isUrl(value)) { property[j][1] = rewriteUrl(value, rebaseConfig); } } } } module.exports = rebase; }, { "../tokenizer/token": 84, "../utils/is-import": 92, "./extract-import-url-and-media": 70, "./restore-import": 81, "./rewrite-url": 82 } ], 81: [ function(require, module, exports) { function restoreImport(uri, mediaQuery) { return ("@import " + uri + " " + mediaQuery).trim(); } module.exports = restoreImport; }, {} ], 82: [ function(require, module, exports) { (function(process) { var path = require("path"); var url = require("url"); var DOUBLE_QUOTE = '"'; var SINGLE_QUOTE = "'"; var URL_PREFIX = "url("; var URL_SUFFIX = ")"; var QUOTE_PREFIX_PATTERN = /^["']/; var QUOTE_SUFFIX_PATTERN = /["']$/; var ROUND_BRACKETS_PATTERN = /[\(\)]/; var URL_PREFIX_PATTERN = /^url\(/i; var URL_SUFFIX_PATTERN = /\)$/; var WHITESPACE_PATTERN = /\s/; var isWindows = process.platform == "win32"; function rebase(uri, rebaseConfig) { if (!rebaseConfig) { return uri; } if (isAbsolute(uri) && !isRemote(rebaseConfig.toBase)) { return uri; } if (isRemote(uri) || isSVGMarker(uri) || isInternal(uri)) { return uri; } if (isData(uri)) { return "'" + uri + "'"; } if (isRemote(rebaseConfig.toBase)) { return url.resolve(rebaseConfig.toBase, uri); } return rebaseConfig.absolute ? normalize(absolute(uri, rebaseConfig)) : normalize(relative(uri, rebaseConfig)); } function isAbsolute(uri) { return path.isAbsolute(uri); } function isSVGMarker(uri) { return uri[0] == "#"; } function isInternal(uri) { return /^\w+:\w+/.test(uri); } function isRemote(uri) { return /^[^:]+?:\/\//.test(uri) || uri.indexOf("//") === 0; } function isData(uri) { return uri.indexOf("data:") === 0; } function absolute(uri, rebaseConfig) { return path .resolve(path.join(rebaseConfig.fromBase || "", uri)) .replace(rebaseConfig.toBase, ""); } function relative(uri, rebaseConfig) { return path.relative( rebaseConfig.toBase, path.join(rebaseConfig.fromBase || "", uri) ); } function normalize(uri) { return isWindows ? uri.replace(/\\/g, "/") : uri; } function quoteFor(unquotedUrl) { if (unquotedUrl.indexOf(SINGLE_QUOTE) > -1) { return DOUBLE_QUOTE; } else if (unquotedUrl.indexOf(DOUBLE_QUOTE) > -1) { return SINGLE_QUOTE; } else if ( hasWhitespace(unquotedUrl) || hasRoundBrackets(unquotedUrl) ) { return SINGLE_QUOTE; } else { return ""; } } function hasWhitespace(url) { return WHITESPACE_PATTERN.test(url); } function hasRoundBrackets(url) { return ROUND_BRACKETS_PATTERN.test(url); } function rewriteUrl(originalUrl, rebaseConfig, pathOnly) { var strippedUrl = originalUrl .replace(URL_PREFIX_PATTERN, "") .replace(URL_SUFFIX_PATTERN, "") .trim(); var unquotedUrl = strippedUrl .replace(QUOTE_PREFIX_PATTERN, "") .replace(QUOTE_SUFFIX_PATTERN, "") .trim(); var quote = strippedUrl[0] == SINGLE_QUOTE || strippedUrl[0] == DOUBLE_QUOTE ? strippedUrl[0] : quoteFor(unquotedUrl); return pathOnly ? rebase(unquotedUrl, rebaseConfig) : URL_PREFIX + quote + rebase(unquotedUrl, rebaseConfig) + quote + URL_SUFFIX; } module.exports = rewriteUrl; }.call(this, require("_process"))); }, { _process: 112, path: 110, url: 162 } ], 83: [ function(require, module, exports) { var Marker = { ASTERISK: "*", AT: "@", BACK_SLASH: "\\", CARRIAGE_RETURN: "\r", CLOSE_CURLY_BRACKET: "}", CLOSE_ROUND_BRACKET: ")", CLOSE_SQUARE_BRACKET: "]", COLON: ":", COMMA: ",", DOUBLE_QUOTE: '"', EXCLAMATION: "!", FORWARD_SLASH: "/", INTERNAL: "-clean-css-", NEW_LINE_NIX: "\n", OPEN_CURLY_BRACKET: "{", OPEN_ROUND_BRACKET: "(", OPEN_SQUARE_BRACKET: "[", SEMICOLON: ";", SINGLE_QUOTE: "'", SPACE: " ", TAB: "\t", UNDERSCORE: "_" }; module.exports = Marker; }, {} ], 84: [ function(require, module, exports) { var Token = { AT_RULE: "at-rule", // e.g. `@import`, `@charset` AT_RULE_BLOCK: "at-rule-block", // e.g. `@font-face{...}` AT_RULE_BLOCK_SCOPE: "at-rule-block-scope", // e.g. `@font-face` COMMENT: "comment", // e.g. `/* comment */` NESTED_BLOCK: "nested-block", // e.g. `@media screen{...}`, `@keyframes animation {...}` NESTED_BLOCK_SCOPE: "nested-block-scope", // e.g. `@media`, `@keyframes` PROPERTY: "property", // e.g. `color:red` PROPERTY_BLOCK: "property-block", // e.g. `--var:{color:red}` PROPERTY_NAME: "property-name", // e.g. `color` PROPERTY_VALUE: "property-value", // e.g. `red` RAW: "raw", // e.g. anything between /* clean-css ignore:start */ and /* clean-css ignore:end */ comments RULE: "rule", // e.g `div > a{...}` RULE_SCOPE: "rule-scope" // e.g `div > a` }; module.exports = Token; }, {} ], 85: [ function(require, module, exports) { var Marker = require("./marker"); var Token = require("./token"); var formatPosition = require("../utils/format-position"); var Level = { BLOCK: "block", COMMENT: "comment", DOUBLE_QUOTE: "double-quote", RULE: "rule", SINGLE_QUOTE: "single-quote" }; var AT_RULES = ["@charset", "@import"]; var BLOCK_RULES = [ "@-moz-document", "@document", "@-moz-keyframes", "@-ms-keyframes", "@-o-keyframes", "@-webkit-keyframes", "@keyframes", "@media", "@supports" ]; var IGNORE_END_COMMENT_PATTERN = /\/\* clean\-css ignore:end \*\/$/; var IGNORE_START_COMMENT_PATTERN = /^\/\* clean\-css ignore:start \*\//; var PAGE_MARGIN_BOXES = [ "@bottom-center", "@bottom-left", "@bottom-left-corner", "@bottom-right", "@bottom-right-corner", "@left-bottom", "@left-middle", "@left-top", "@right-bottom", "@right-middle", "@right-top", "@top-center", "@top-left", "@top-left-corner", "@top-right", "@top-right-corner" ]; var EXTRA_PAGE_BOXES = [ "@footnote", "@footnotes", "@left", "@page-float-bottom", "@page-float-top", "@right" ]; var REPEAT_PATTERN = /^\[\s{0,31}\d+\s{0,31}\]$/; var RULE_WORD_SEPARATOR_PATTERN = /[\s\(]/; var TAIL_BROKEN_VALUE_PATTERN = /[\s|\}]*$/; function tokenize(source, externalContext) { var internalContext = { level: Level.BLOCK, position: { source: externalContext.source || undefined, line: 1, column: 0, index: 0 } }; return intoTokens(source, externalContext, internalContext, false); } function intoTokens( source, externalContext, internalContext, isNested ) { var allTokens = []; var newTokens = allTokens; var lastToken; var ruleToken; var ruleTokens = []; var propertyToken; var metadata; var metadatas = []; var level = internalContext.level; var levels = []; var buffer = []; var buffers = []; var serializedBuffer; var serializedBufferPart; var roundBracketLevel = 0; var isQuoted; var isSpace; var isNewLineNix; var isNewLineWin; var isCarriageReturn; var isCommentStart; var wasCommentStart = false; var isCommentEnd; var wasCommentEnd = false; var isCommentEndMarker; var isEscaped; var wasEscaped = false; var isRaw = false; var seekingValue = false; var seekingPropertyBlockClosing = false; var position = internalContext.position; var lastCommentStartAt; for (; position.index < source.length; position.index++) { var character = source[position.index]; isQuoted = level == Level.SINGLE_QUOTE || level == Level.DOUBLE_QUOTE; isSpace = character == Marker.SPACE || character == Marker.TAB; isNewLineNix = character == Marker.NEW_LINE_NIX; isNewLineWin = character == Marker.NEW_LINE_NIX && source[position.index - 1] == Marker.CARRIAGE_RETURN; isCarriageReturn = character == Marker.CARRIAGE_RETURN && source[position.index + 1] && source[position.index + 1] != Marker.NEW_LINE_NIX; isCommentStart = !wasCommentEnd && level != Level.COMMENT && !isQuoted && character == Marker.ASTERISK && source[position.index - 1] == Marker.FORWARD_SLASH; isCommentEndMarker = !wasCommentStart && !isQuoted && character == Marker.FORWARD_SLASH && source[position.index - 1] == Marker.ASTERISK; isCommentEnd = level == Level.COMMENT && isCommentEndMarker; roundBracketLevel = Math.max(roundBracketLevel, 0); metadata = buffer.length === 0 ? [position.line, position.column, position.source] : metadata; if (isEscaped) { // previous character was a backslash buffer.push(character); } else if (!isCommentEnd && level == Level.COMMENT) { buffer.push(character); } else if (!isCommentStart && !isCommentEnd && isRaw) { buffer.push(character); } else if ( isCommentStart && (level == Level.BLOCK || level == Level.RULE) && buffer.length > 1 ) { // comment start within block preceded by some content, e.g. div/*<-- metadatas.push(metadata); buffer.push(character); buffers.push(buffer.slice(0, buffer.length - 2)); buffer = buffer.slice(buffer.length - 2); metadata = [position.line, position.column - 1, position.source]; levels.push(level); level = Level.COMMENT; } else if (isCommentStart) { // comment start, e.g. /*<-- levels.push(level); level = Level.COMMENT; buffer.push(character); } else if (isCommentEnd && isIgnoreStartComment(buffer)) { // ignore:start comment end, e.g. /* clean-css ignore:start */<-- serializedBuffer = buffer.join("").trim() + character; lastToken = [ Token.COMMENT, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]; newTokens.push(lastToken); isRaw = true; metadata = metadatas.pop() || null; buffer = buffers.pop() || []; } else if (isCommentEnd && isIgnoreEndComment(buffer)) { // ignore:start comment end, e.g. /* clean-css ignore:end */<-- serializedBuffer = buffer.join("") + character; lastCommentStartAt = serializedBuffer.lastIndexOf( Marker.FORWARD_SLASH + Marker.ASTERISK ); serializedBufferPart = serializedBuffer.substring( 0, lastCommentStartAt ); lastToken = [ Token.RAW, serializedBufferPart, [ originalMetadata( metadata, serializedBufferPart, externalContext ) ] ]; newTokens.push(lastToken); serializedBufferPart = serializedBuffer.substring( lastCommentStartAt ); metadata = [ position.line, position.column - serializedBufferPart.length + 1, position.source ]; lastToken = [ Token.COMMENT, serializedBufferPart, [ originalMetadata( metadata, serializedBufferPart, externalContext ) ] ]; newTokens.push(lastToken); isRaw = false; level = levels.pop(); metadata = metadatas.pop() || null; buffer = buffers.pop() || []; } else if (isCommentEnd) { // comment end, e.g. /* comment */<-- serializedBuffer = buffer.join("").trim() + character; lastToken = [ Token.COMMENT, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]; newTokens.push(lastToken); level = levels.pop(); metadata = metadatas.pop() || null; buffer = buffers.pop() || []; } else if ( isCommentEndMarker && source[position.index + 1] != Marker.ASTERISK ) { externalContext.warnings.push( "Unexpected '*/' at " + formatPosition([ position.line, position.column, position.source ]) + "." ); buffer = []; } else if (character == Marker.SINGLE_QUOTE && !isQuoted) { // single quotation start, e.g. a[href^='https<-- levels.push(level); level = Level.SINGLE_QUOTE; buffer.push(character); } else if ( character == Marker.SINGLE_QUOTE && level == Level.SINGLE_QUOTE ) { // single quotation end, e.g. a[href^='https'<-- level = levels.pop(); buffer.push(character); } else if (character == Marker.DOUBLE_QUOTE && !isQuoted) { // double quotation start, e.g. a[href^="<-- levels.push(level); level = Level.DOUBLE_QUOTE; buffer.push(character); } else if ( character == Marker.DOUBLE_QUOTE && level == Level.DOUBLE_QUOTE ) { // double quotation end, e.g. a[href^="https"<-- level = levels.pop(); buffer.push(character); } else if ( !isCommentStart && !isCommentEnd && character != Marker.CLOSE_ROUND_BRACKET && character != Marker.OPEN_ROUND_BRACKET && level != Level.COMMENT && !isQuoted && roundBracketLevel > 0 ) { // character inside any function, e.g. hsla(.<-- buffer.push(character); } else if ( character == Marker.OPEN_ROUND_BRACKET && !isQuoted && level != Level.COMMENT && !seekingValue ) { // round open bracket, e.g. @import url(<-- buffer.push(character); roundBracketLevel++; } else if ( character == Marker.CLOSE_ROUND_BRACKET && !isQuoted && level != Level.COMMENT && !seekingValue ) { // round open bracket, e.g. @import url(test.css)<-- buffer.push(character); roundBracketLevel--; } else if ( character == Marker.SEMICOLON && level == Level.BLOCK && buffer[0] == Marker.AT ) { // semicolon ending rule at block level, e.g. @import '...';<-- serializedBuffer = buffer.join("").trim(); allTokens.push([ Token.AT_RULE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); buffer = []; } else if ( character == Marker.COMMA && level == Level.BLOCK && ruleToken ) { // comma separator at block level, e.g. a,div,<-- serializedBuffer = buffer.join("").trim(); ruleToken[1].push([ tokenScopeFrom(ruleToken[0]), serializedBuffer, [ originalMetadata( metadata, serializedBuffer, externalContext, ruleToken[1].length ) ] ]); buffer = []; } else if ( character == Marker.COMMA && level == Level.BLOCK && tokenTypeFrom(buffer) == Token.AT_RULE ) { // comma separator at block level, e.g. @import url(...) screen,<-- // keep iterating as end semicolon will create the token buffer.push(character); } else if (character == Marker.COMMA && level == Level.BLOCK) { // comma separator at block level, e.g. a,<-- ruleToken = [tokenTypeFrom(buffer), [], []]; serializedBuffer = buffer.join("").trim(); ruleToken[1].push([ tokenScopeFrom(ruleToken[0]), serializedBuffer, [ originalMetadata( metadata, serializedBuffer, externalContext, 0 ) ] ]); buffer = []; } else if ( character == Marker.OPEN_CURLY_BRACKET && level == Level.BLOCK && ruleToken && ruleToken[0] == Token.NESTED_BLOCK ) { // open brace opening at-rule at block level, e.g. @media{<-- serializedBuffer = buffer.join("").trim(); ruleToken[1].push([ Token.NESTED_BLOCK_SCOPE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); allTokens.push(ruleToken); levels.push(level); position.column++; position.index++; buffer = []; ruleToken[2] = intoTokens( source, externalContext, internalContext, true ); ruleToken = null; } else if ( character == Marker.OPEN_CURLY_BRACKET && level == Level.BLOCK && tokenTypeFrom(buffer) == Token.NESTED_BLOCK ) { // open brace opening at-rule at block level, e.g. @media{<-- serializedBuffer = buffer.join("").trim(); ruleToken = ruleToken || [Token.NESTED_BLOCK, [], []]; ruleToken[1].push([ Token.NESTED_BLOCK_SCOPE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); allTokens.push(ruleToken); levels.push(level); position.column++; position.index++; buffer = []; ruleToken[2] = intoTokens( source, externalContext, internalContext, true ); ruleToken = null; } else if ( character == Marker.OPEN_CURLY_BRACKET && level == Level.BLOCK ) { // open brace opening rule at block level, e.g. div{<-- serializedBuffer = buffer.join("").trim(); ruleToken = ruleToken || [tokenTypeFrom(buffer), [], []]; ruleToken[1].push([ tokenScopeFrom(ruleToken[0]), serializedBuffer, [ originalMetadata( metadata, serializedBuffer, externalContext, ruleToken[1].length ) ] ]); newTokens = ruleToken[2]; allTokens.push(ruleToken); levels.push(level); level = Level.RULE; buffer = []; } else if ( character == Marker.OPEN_CURLY_BRACKET && level == Level.RULE && seekingValue ) { // open brace opening rule at rule level, e.g. div{--variable:{<-- ruleTokens.push(ruleToken); ruleToken = [Token.PROPERTY_BLOCK, []]; propertyToken.push(ruleToken); newTokens = ruleToken[1]; levels.push(level); level = Level.RULE; seekingValue = false; } else if ( character == Marker.OPEN_CURLY_BRACKET && level == Level.RULE && isPageMarginBox(buffer) ) { // open brace opening page-margin box at rule level, e.g. @page{@top-center{<-- serializedBuffer = buffer.join("").trim(); ruleTokens.push(ruleToken); ruleToken = [Token.AT_RULE_BLOCK, [], []]; ruleToken[1].push([ Token.AT_RULE_BLOCK_SCOPE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); newTokens.push(ruleToken); newTokens = ruleToken[2]; levels.push(level); level = Level.RULE; buffer = []; } else if ( character == Marker.COLON && level == Level.RULE && !seekingValue ) { // colon at rule level, e.g. a{color:<-- serializedBuffer = buffer.join("").trim(); propertyToken = [ Token.PROPERTY, [ Token.PROPERTY_NAME, serializedBuffer, [ originalMetadata( metadata, serializedBuffer, externalContext ) ] ] ]; newTokens.push(propertyToken); seekingValue = true; buffer = []; } else if ( character == Marker.SEMICOLON && level == Level.RULE && propertyToken && ruleTokens.length > 0 && buffer.length > 0 && buffer[0] == Marker.AT ) { // semicolon at rule level for at-rule, e.g. a{--color:{@apply(--other-color);<-- serializedBuffer = buffer.join("").trim(); ruleToken[1].push([ Token.AT_RULE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); buffer = []; } else if ( character == Marker.SEMICOLON && level == Level.RULE && propertyToken && buffer.length > 0 ) { // semicolon at rule level, e.g. a{color:red;<-- serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken = null; seekingValue = false; buffer = []; } else if ( character == Marker.SEMICOLON && level == Level.RULE && propertyToken && buffer.length === 0 ) { // semicolon after bracketed value at rule level, e.g. a{color:rgb(...);<-- propertyToken = null; seekingValue = false; } else if ( character == Marker.SEMICOLON && level == Level.RULE && buffer.length > 0 && buffer[0] == Marker.AT ) { // semicolon for at-rule at rule level, e.g. a{@apply(--variable);<-- serializedBuffer = buffer.join(""); newTokens.push([ Token.AT_RULE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); seekingValue = false; buffer = []; } else if ( character == Marker.SEMICOLON && level == Level.RULE && seekingPropertyBlockClosing ) { // close brace after a property block at rule level, e.g. a{--custom:{color:red;};<-- seekingPropertyBlockClosing = false; buffer = []; } else if ( character == Marker.SEMICOLON && level == Level.RULE && buffer.length === 0 ) { // stray semicolon at rule level, e.g. a{;<-- // noop } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && propertyToken && seekingValue && buffer.length > 0 && ruleTokens.length > 0 ) { // close brace at rule level, e.g. a{--color:{color:red}<-- serializedBuffer = buffer.join(""); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken = null; ruleToken = ruleTokens.pop(); newTokens = ruleToken[2]; level = levels.pop(); seekingValue = false; buffer = []; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && propertyToken && buffer.length > 0 && buffer[0] == Marker.AT && ruleTokens.length > 0 ) { // close brace at rule level for at-rule, e.g. a{--color:{@apply(--other-color)}<-- serializedBuffer = buffer.join(""); ruleToken[1].push([ Token.AT_RULE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken = null; ruleToken = ruleTokens.pop(); newTokens = ruleToken[2]; level = levels.pop(); seekingValue = false; buffer = []; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && propertyToken && ruleTokens.length > 0 ) { // close brace at rule level after space, e.g. a{--color:{color:red }<-- propertyToken = null; ruleToken = ruleTokens.pop(); newTokens = ruleToken[2]; level = levels.pop(); seekingValue = false; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && propertyToken && buffer.length > 0 ) { // close brace at rule level, e.g. a{color:red}<-- serializedBuffer = buffer.join(""); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken = null; ruleToken = ruleTokens.pop(); newTokens = allTokens; level = levels.pop(); seekingValue = false; buffer = []; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && buffer.length > 0 && buffer[0] == Marker.AT ) { // close brace after at-rule at rule level, e.g. a{@apply(--variable)}<-- propertyToken = null; ruleToken = null; serializedBuffer = buffer.join("").trim(); newTokens.push([ Token.AT_RULE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); newTokens = allTokens; level = levels.pop(); seekingValue = false; buffer = []; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE && levels[levels.length - 1] == Level.RULE ) { // close brace after a property block at rule level, e.g. a{--custom:{color:red;}<-- propertyToken = null; ruleToken = ruleTokens.pop(); newTokens = ruleToken[2]; level = levels.pop(); seekingValue = false; seekingPropertyBlockClosing = true; buffer = []; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.RULE ) { // close brace after a rule, e.g. a{color:red;}<-- propertyToken = null; ruleToken = null; newTokens = allTokens; level = levels.pop(); seekingValue = false; } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.BLOCK && !isNested && position.index <= source.length - 1 ) { // stray close brace at block level, e.g. a{color:red}color:blue}<-- externalContext.warnings.push( "Unexpected '}' at " + formatPosition([ position.line, position.column, position.source ]) + "." ); buffer.push(character); } else if ( character == Marker.CLOSE_CURLY_BRACKET && level == Level.BLOCK ) { // close brace at block level, e.g. @media screen {...}<-- break; } else if ( character == Marker.OPEN_ROUND_BRACKET && level == Level.RULE && seekingValue ) { // round open bracket, e.g. a{color:hsla(<-- buffer.push(character); roundBracketLevel++; } else if ( character == Marker.CLOSE_ROUND_BRACKET && level == Level.RULE && seekingValue && roundBracketLevel == 1 ) { // round close bracket, e.g. a{color:hsla(0,0%,0%)<-- buffer.push(character); serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); roundBracketLevel--; buffer = []; } else if ( character == Marker.CLOSE_ROUND_BRACKET && level == Level.RULE && seekingValue ) { // round close bracket within other brackets, e.g. a{width:calc((10rem / 2)<-- buffer.push(character); roundBracketLevel--; } else if ( character == Marker.FORWARD_SLASH && source[position.index + 1] != Marker.ASTERISK && level == Level.RULE && seekingValue && buffer.length > 0 ) { // forward slash within a property, e.g. a{background:url(image.png) 0 0/<-- serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken.push([ Token.PROPERTY_VALUE, character, [[position.line, position.column, position.source]] ]); buffer = []; } else if ( character == Marker.FORWARD_SLASH && source[position.index + 1] != Marker.ASTERISK && level == Level.RULE && seekingValue ) { // forward slash within a property after space, e.g. a{background:url(image.png) 0 0 /<-- propertyToken.push([ Token.PROPERTY_VALUE, character, [[position.line, position.column, position.source]] ]); buffer = []; } else if ( character == Marker.COMMA && level == Level.RULE && seekingValue && buffer.length > 0 ) { // comma within a property, e.g. a{background:url(image.png),<-- serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); propertyToken.push([ Token.PROPERTY_VALUE, character, [[position.line, position.column, position.source]] ]); buffer = []; } else if ( character == Marker.COMMA && level == Level.RULE && seekingValue ) { // comma within a property after space, e.g. a{background:url(image.png) ,<-- propertyToken.push([ Token.PROPERTY_VALUE, character, [[position.line, position.column, position.source]] ]); buffer = []; } else if ( character == Marker.CLOSE_SQUARE_BRACKET && propertyToken && propertyToken.length > 1 && buffer.length > 0 && isRepeatToken(buffer) ) { buffer.push(character); serializedBuffer = buffer.join("").trim(); propertyToken[propertyToken.length - 1][1] += serializedBuffer; buffer = []; } else if ( (isSpace || (isNewLineNix && !isNewLineWin)) && level == Level.RULE && seekingValue && propertyToken && buffer.length > 0 ) { // space or *nix newline within property, e.g. a{margin:0 <-- serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); buffer = []; } else if ( isNewLineWin && level == Level.RULE && seekingValue && propertyToken && buffer.length > 1 ) { // win newline within property, e.g. a{margin:0\r\n<-- serializedBuffer = buffer.join("").trim(); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); buffer = []; } else if (isNewLineWin && level == Level.RULE && seekingValue) { // win newline buffer = []; } else if (buffer.length == 1 && isNewLineWin) { // ignore windows newline which is composed of two characters buffer.pop(); } else if ( buffer.length > 0 || (!isSpace && !isNewLineNix && !isNewLineWin && !isCarriageReturn) ) { // any character buffer.push(character); } wasEscaped = isEscaped; isEscaped = !wasEscaped && character == Marker.BACK_SLASH; wasCommentStart = isCommentStart; wasCommentEnd = isCommentEnd; position.line = isNewLineWin || isNewLineNix || isCarriageReturn ? position.line + 1 : position.line; position.column = isNewLineWin || isNewLineNix || isCarriageReturn ? 0 : position.column + 1; } if (seekingValue) { externalContext.warnings.push( "Missing '}' at " + formatPosition([ position.line, position.column, position.source ]) + "." ); } if (seekingValue && buffer.length > 0) { serializedBuffer = buffer .join("") .replace(TAIL_BROKEN_VALUE_PATTERN, ""); propertyToken.push([ Token.PROPERTY_VALUE, serializedBuffer, [originalMetadata(metadata, serializedBuffer, externalContext)] ]); buffer = []; } if (buffer.length > 0) { externalContext.warnings.push( "Invalid character(s) '" + buffer.join("") + "' at " + formatPosition(metadata) + ". Ignoring." ); } return allTokens; } function isIgnoreStartComment(buffer) { return IGNORE_START_COMMENT_PATTERN.test( buffer.join("") + Marker.FORWARD_SLASH ); } function isIgnoreEndComment(buffer) { return IGNORE_END_COMMENT_PATTERN.test( buffer.join("") + Marker.FORWARD_SLASH ); } function originalMetadata( metadata, value, externalContext, selectorFallbacks ) { var source = metadata[2]; return externalContext.inputSourceMapTracker.isTracking(source) ? externalContext.inputSourceMapTracker.originalPositionFor( metadata, value.length, selectorFallbacks ) : metadata; } function tokenTypeFrom(buffer) { var isAtRule = buffer[0] == Marker.AT || buffer[0] == Marker.UNDERSCORE; var ruleWord = buffer.join("").split(RULE_WORD_SEPARATOR_PATTERN)[0]; if (isAtRule && BLOCK_RULES.indexOf(ruleWord) > -1) { return Token.NESTED_BLOCK; } else if (isAtRule && AT_RULES.indexOf(ruleWord) > -1) { return Token.AT_RULE; } else if (isAtRule) { return Token.AT_RULE_BLOCK; } else { return Token.RULE; } } function tokenScopeFrom(tokenType) { if (tokenType == Token.RULE) { return Token.RULE_SCOPE; } else if (tokenType == Token.NESTED_BLOCK) { return Token.NESTED_BLOCK_SCOPE; } else if (tokenType == Token.AT_RULE_BLOCK) { return Token.AT_RULE_BLOCK_SCOPE; } } function isPageMarginBox(buffer) { var serializedBuffer = buffer.join("").trim(); return ( PAGE_MARGIN_BOXES.indexOf(serializedBuffer) > -1 || EXTRA_PAGE_BOXES.indexOf(serializedBuffer) > -1 ); } function isRepeatToken(buffer) { return REPEAT_PATTERN.test( buffer.join("") + Marker.CLOSE_SQUARE_BRACKET ); } module.exports = tokenize; }, { "../utils/format-position": 87, "./marker": 83, "./token": 84 } ], 86: [ function(require, module, exports) { function cloneArray(array) { var cloned = array.slice(0); for (var i = 0, l = cloned.length; i < l; i++) { if (Array.isArray(cloned[i])) cloned[i] = cloneArray(cloned[i]); } return cloned; } module.exports = cloneArray; }, {} ], 87: [ function(require, module, exports) { function formatPosition(metadata) { var line = metadata[0]; var column = metadata[1]; var source = metadata[2]; return source ? source + ":" + line + ":" + column : line + ":" + column; } module.exports = formatPosition; }, {} ], 88: [ function(require, module, exports) { var NO_PROTOCOL_RESOURCE_PATTERN = /^\/\//; function hasProtocol(uri) { return !NO_PROTOCOL_RESOURCE_PATTERN.test(uri); } module.exports = hasProtocol; }, {} ], 89: [ function(require, module, exports) { var DATA_URI_PATTERN = /^data:(\S*?)?(;charset=[^;]+)?(;[^,]+?)?,(.+)/; function isDataUriResource(uri) { return DATA_URI_PATTERN.test(uri); } module.exports = isDataUriResource; }, {} ], 90: [ function(require, module, exports) { var HTTP_RESOURCE_PATTERN = /^http:\/\//; function isHttpResource(uri) { return HTTP_RESOURCE_PATTERN.test(uri); } module.exports = isHttpResource; }, {} ], 91: [ function(require, module, exports) { var HTTPS_RESOURCE_PATTERN = /^https:\/\//; function isHttpsResource(uri) { return HTTPS_RESOURCE_PATTERN.test(uri); } module.exports = isHttpsResource; }, {} ], 92: [ function(require, module, exports) { var IMPORT_PREFIX_PATTERN = /^@import/i; function isImport(value) { return IMPORT_PREFIX_PATTERN.test(value); } module.exports = isImport; }, {} ], 93: [ function(require, module, exports) { var REMOTE_RESOURCE_PATTERN = /^(\w+:\/\/|\/\/)/; function isRemoteResource(uri) { return REMOTE_RESOURCE_PATTERN.test(uri); } module.exports = isRemoteResource; }, {} ], 94: [ function(require, module, exports) { // adapted from http://nedbatchelder.com/blog/200712.html#e20071211T054956 var NUMBER_PATTERN = /([0-9]+)/; function naturalCompare(value1, value2) { var keys1 = ("" + value1).split(NUMBER_PATTERN).map(tryParseInt); var keys2 = ("" + value2).split(NUMBER_PATTERN).map(tryParseInt); var key1; var key2; var compareFirst = Math.min(keys1.length, keys2.length); var i, l; for (i = 0, l = compareFirst; i < l; i++) { key1 = keys1[i]; key2 = keys2[i]; if (key1 != key2) { return key1 > key2 ? 1 : -1; } } return keys1.length > keys2.length ? 1 : keys1.length == keys2.length ? 0 : -1; } function tryParseInt(value) { return "" + parseInt(value) == value ? parseInt(value) : value; } module.exports = naturalCompare; }, {} ], 95: [ function(require, module, exports) { function override(source1, source2) { var target = {}; var key1; var key2; var item; for (key1 in source1) { item = source1[key1]; if (Array.isArray(item)) { target[key1] = item.slice(0); } else if (typeof item == "object" && item !== null) { target[key1] = override(item, {}); } else { target[key1] = item; } } for (key2 in source2) { item = source2[key2]; if (key2 in target && Array.isArray(item)) { target[key2] = item.slice(0); } else if ( key2 in target && typeof item == "object" && item !== null ) { target[key2] = override(target[key2], item); } else { target[key2] = item; } } return target; } module.exports = override; }, {} ], 96: [ function(require, module, exports) { var Marker = require("../tokenizer/marker"); function split(value, separator) { var openLevel = Marker.OPEN_ROUND_BRACKET; var closeLevel = Marker.CLOSE_ROUND_BRACKET; var level = 0; var cursor = 0; var lastStart = 0; var lastValue; var lastCharacter; var len = value.length; var parts = []; if (value.indexOf(separator) == -1) { return [value]; } if (value.indexOf(openLevel) == -1) { return value.split(separator); } while (cursor < len) { if (value[cursor] == openLevel) { level++; } else if (value[cursor] == closeLevel) { level--; } if ( level === 0 && cursor > 0 && cursor + 1 < len && value[cursor] == separator ) { parts.push(value.substring(lastStart, cursor)); lastStart = cursor + 1; } cursor++; } if (lastStart < cursor + 1) { lastValue = value.substring(lastStart); lastCharacter = lastValue[lastValue.length - 1]; if (lastCharacter == separator) { lastValue = lastValue.substring(0, lastValue.length - 1); } parts.push(lastValue); } return parts; } module.exports = split; }, { "../tokenizer/marker": 83 } ], 97: [ function(require, module, exports) { var emptyCharacter = ""; var Breaks = require("../options/format").Breaks; var Spaces = require("../options/format").Spaces; var Marker = require("../tokenizer/marker"); var Token = require("../tokenizer/token"); function supportsAfterClosingBrace(token) { return ( token[1][1] == "background" || token[1][1] == "transform" || token[1][1] == "src" ); } function afterClosingBrace(token, valueIndex) { return ( token[valueIndex][1][token[valueIndex][1].length - 1] == Marker.CLOSE_ROUND_BRACKET ); } function afterComma(token, valueIndex) { return token[valueIndex][1] == Marker.COMMA; } function afterSlash(token, valueIndex) { return token[valueIndex][1] == Marker.FORWARD_SLASH; } function beforeComma(token, valueIndex) { return ( token[valueIndex + 1] && token[valueIndex + 1][1] == Marker.COMMA ); } function beforeSlash(token, valueIndex) { return ( token[valueIndex + 1] && token[valueIndex + 1][1] == Marker.FORWARD_SLASH ); } function inFilter(token) { return token[1][1] == "filter" || token[1][1] == "-ms-filter"; } function disallowsSpace(context, token, valueIndex) { return ( (!context.spaceAfterClosingBrace && supportsAfterClosingBrace(token) && afterClosingBrace(token, valueIndex)) || beforeSlash(token, valueIndex) || afterSlash(token, valueIndex) || beforeComma(token, valueIndex) || afterComma(token, valueIndex) ); } function rules(context, tokens) { var store = context.store; for (var i = 0, l = tokens.length; i < l; i++) { store(context, tokens[i]); if (i < l - 1) { store(context, comma(context)); } } } function body(context, tokens) { var lastPropertyAt = lastPropertyIndex(tokens); for (var i = 0, l = tokens.length; i < l; i++) { property(context, tokens, i, lastPropertyAt); } } function lastPropertyIndex(tokens) { var index = tokens.length - 1; for (; index >= 0; index--) { if (tokens[index][0] != Token.COMMENT) { break; } } return index; } function property(context, tokens, position, lastPropertyAt) { var store = context.store; var token = tokens[position]; var isPropertyBlock = token[2][0] == Token.PROPERTY_BLOCK; var needsSemicolon; if (context.format) { if (context.format.semicolonAfterLastProperty || isPropertyBlock) { needsSemicolon = true; } else if (position < lastPropertyAt) { needsSemicolon = true; } else { needsSemicolon = false; } } else { needsSemicolon = position < lastPropertyAt || isPropertyBlock; } var isLast = position === lastPropertyAt; switch (token[0]) { case Token.AT_RULE: store(context, token); store(context, semicolon(context, Breaks.AfterProperty, false)); break; case Token.AT_RULE_BLOCK: rules(context, token[1]); store(context, openBrace(context, Breaks.AfterRuleBegins, true)); body(context, token[2]); store( context, closeBrace(context, Breaks.AfterRuleEnds, false, isLast) ); break; case Token.COMMENT: store(context, token); break; case Token.PROPERTY: store(context, token[1]); store(context, colon(context)); value(context, token); store( context, needsSemicolon ? semicolon(context, Breaks.AfterProperty, isLast) : emptyCharacter ); break; case Token.RAW: store(context, token); } } function value(context, token) { var store = context.store; var j, m; if (token[2][0] == Token.PROPERTY_BLOCK) { store(context, openBrace(context, Breaks.AfterBlockBegins, false)); body(context, token[2][1]); store( context, closeBrace(context, Breaks.AfterBlockEnds, false, true) ); } else { for (j = 2, m = token.length; j < m; j++) { store(context, token[j]); if ( j < m - 1 && (inFilter(token) || !disallowsSpace(context, token, j)) ) { store(context, Marker.SPACE); } } } } function allowsBreak(context, where) { return context.format && context.format.breaks[where]; } function allowsSpace(context, where) { return context.format && context.format.spaces[where]; } function openBrace(context, where, needsPrefixSpace) { if (context.format) { context.indentBy += context.format.indentBy; context.indentWith = context.format.indentWith.repeat( context.indentBy ); return ( (needsPrefixSpace && allowsSpace(context, Spaces.BeforeBlockBegins) ? Marker.SPACE : emptyCharacter) + Marker.OPEN_CURLY_BRACKET + (allowsBreak(context, where) ? context.format.breakWith : emptyCharacter) + context.indentWith ); } else { return Marker.OPEN_CURLY_BRACKET; } } function closeBrace(context, where, beforeBlockEnd, isLast) { if (context.format) { context.indentBy -= context.format.indentBy; context.indentWith = context.format.indentWith.repeat( context.indentBy ); return ( (allowsBreak(context, Breaks.AfterProperty) || (beforeBlockEnd && allowsBreak(context, Breaks.BeforeBlockEnds)) ? context.format.breakWith : emptyCharacter) + context.indentWith + Marker.CLOSE_CURLY_BRACKET + (isLast ? emptyCharacter : (allowsBreak(context, where) ? context.format.breakWith : emptyCharacter) + context.indentWith) ); } else { return Marker.CLOSE_CURLY_BRACKET; } } function colon(context) { return context.format ? Marker.COLON + (allowsSpace(context, Spaces.BeforeValue) ? Marker.SPACE : emptyCharacter) : Marker.COLON; } function semicolon(context, where, isLast) { return context.format ? Marker.SEMICOLON + (isLast || !allowsBreak(context, where) ? emptyCharacter : context.format.breakWith + context.indentWith) : Marker.SEMICOLON; } function comma(context) { return context.format ? Marker.COMMA + (allowsBreak(context, Breaks.BetweenSelectors) ? context.format.breakWith : emptyCharacter) + context.indentWith : Marker.COMMA; } function all(context, tokens) { var store = context.store; var token; var isLast; var i, l; for (i = 0, l = tokens.length; i < l; i++) { token = tokens[i]; isLast = i == l - 1; switch (token[0]) { case Token.AT_RULE: store(context, token); store(context, semicolon(context, Breaks.AfterAtRule, isLast)); break; case Token.AT_RULE_BLOCK: rules(context, token[1]); store( context, openBrace(context, Breaks.AfterRuleBegins, true) ); body(context, token[2]); store( context, closeBrace(context, Breaks.AfterRuleEnds, false, isLast) ); break; case Token.NESTED_BLOCK: rules(context, token[1]); store( context, openBrace(context, Breaks.AfterBlockBegins, true) ); all(context, token[2]); store( context, closeBrace(context, Breaks.AfterBlockEnds, true, isLast) ); break; case Token.COMMENT: store(context, token); store( context, allowsBreak(context, Breaks.AfterComment) ? context.format.breakWith : emptyCharacter ); break; case Token.RAW: store(context, token); break; case Token.RULE: rules(context, token[1]); store( context, openBrace(context, Breaks.AfterRuleBegins, true) ); body(context, token[2]); store( context, closeBrace(context, Breaks.AfterRuleEnds, false, isLast) ); break; } } } module.exports = { all: all, body: body, property: property, rules: rules, value: value }; }, { "../options/format": 61, "../tokenizer/marker": 83, "../tokenizer/token": 84 } ], 98: [ function(require, module, exports) { var helpers = require("./helpers"); function store(serializeContext, token) { serializeContext.output.push( typeof token == "string" ? token : token[1] ); } function context() { var newContext = { output: [], store: store }; return newContext; } function all(tokens) { var oneTimeContext = context(); helpers.all(oneTimeContext, tokens); return oneTimeContext.output.join(""); } function body(tokens) { var oneTimeContext = context(); helpers.body(oneTimeContext, tokens); return oneTimeContext.output.join(""); } function property(tokens, position) { var oneTimeContext = context(); helpers.property(oneTimeContext, tokens, position, true); return oneTimeContext.output.join(""); } function rules(tokens) { var oneTimeContext = context(); helpers.rules(oneTimeContext, tokens); return oneTimeContext.output.join(""); } function value(tokens) { var oneTimeContext = context(); helpers.value(oneTimeContext, tokens); return oneTimeContext.output.join(""); } module.exports = { all: all, body: body, property: property, rules: rules, value: value }; }, { "./helpers": 97 } ], 99: [ function(require, module, exports) { var all = require("./helpers").all; function store(serializeContext, token) { var value = typeof token == "string" ? token : token[1]; var wrap = serializeContext.wrap; wrap(serializeContext, value); track(serializeContext, value); serializeContext.output.push(value); } function wrap(serializeContext, value) { if ( serializeContext.column + value.length > serializeContext.format.wrapAt ) { track(serializeContext, serializeContext.format.breakWith); serializeContext.output.push(serializeContext.format.breakWith); } } function track(serializeContext, value) { var parts = value.split("\n"); serializeContext.line += parts.length - 1; serializeContext.column = parts.length > 1 ? 0 : serializeContext.column + parts.pop().length; } function serializeStyles(tokens, context) { var serializeContext = { column: 0, format: context.options.format, indentBy: 0, indentWith: "", line: 1, output: [], spaceAfterClosingBrace: context.options.compatibility.properties.spaceAfterClosingBrace, store: store, wrap: context.options.format.wrapAt ? wrap : function() { /* noop */ } }; all(serializeContext, tokens); return { styles: serializeContext.output.join("") }; } module.exports = serializeStyles; }, { "./helpers": 97 } ], 100: [ function(require, module, exports) { (function(process) { var SourceMapGenerator = require("source-map").SourceMapGenerator; var all = require("./helpers").all; var isRemoteResource = require("../utils/is-remote-resource"); var isWindows = process.platform == "win32"; var NIX_SEPARATOR_PATTERN = /\//g; var UNKNOWN_SOURCE = "$stdin"; var WINDOWS_SEPARATOR = "\\"; function store(serializeContext, element) { var fromString = typeof element == "string"; var value = fromString ? element : element[1]; var mappings = fromString ? null : element[2]; var wrap = serializeContext.wrap; wrap(serializeContext, value); track(serializeContext, value, mappings); serializeContext.output.push(value); } function wrap(serializeContext, value) { if ( serializeContext.column + value.length > serializeContext.format.wrapAt ) { track(serializeContext, serializeContext.format.breakWith, false); serializeContext.output.push(serializeContext.format.breakWith); } } function track(serializeContext, value, mappings) { var parts = value.split("\n"); if (mappings) { trackAllMappings(serializeContext, mappings); } serializeContext.line += parts.length - 1; serializeContext.column = parts.length > 1 ? 0 : serializeContext.column + parts.pop().length; } function trackAllMappings(serializeContext, mappings) { for (var i = 0, l = mappings.length; i < l; i++) { trackMapping(serializeContext, mappings[i]); } } function trackMapping(serializeContext, mapping) { var line = mapping[0]; var column = mapping[1]; var originalSource = mapping[2]; var source = originalSource; var storedSource = source || UNKNOWN_SOURCE; if (isWindows && source && !isRemoteResource(source)) { storedSource = source.replace( NIX_SEPARATOR_PATTERN, WINDOWS_SEPARATOR ); } serializeContext.outputMap.addMapping({ generated: { line: serializeContext.line, column: serializeContext.column }, source: storedSource, original: { line: line, column: column } }); if ( serializeContext.inlineSources && originalSource in serializeContext.sourcesContent ) { serializeContext.outputMap.setSourceContent( storedSource, serializeContext.sourcesContent[originalSource] ); } } function serializeStylesAndSourceMap(tokens, context) { var serializeContext = { column: 0, format: context.options.format, indentBy: 0, indentWith: "", inlineSources: context.options.sourceMapInlineSources, line: 1, output: [], outputMap: new SourceMapGenerator(), sourcesContent: context.sourcesContent, spaceAfterClosingBrace: context.options.compatibility.properties.spaceAfterClosingBrace, store: store, wrap: context.options.format.wrapAt ? wrap : function() { /* noop */ } }; all(serializeContext, tokens); return { sourceMap: serializeContext.outputMap, styles: serializeContext.output.join("") }; } module.exports = serializeStylesAndSourceMap; }.call(this, require("_process"))); }, { "../utils/is-remote-resource": 93, "./helpers": 97, _process: 112, "source-map": 155 } ], 101: [ function(require, module, exports) { (function(Buffer) { // 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. // NOTE: These type checking functions intentionally don't use `instanceof` // because it is fragile and can be easily faked with `Object.create()`. function isArray(arg) { if (Array.isArray) { return Array.isArray(arg); } return objectToString(arg) === "[object Array]"; } exports.isArray = isArray; function isBoolean(arg) { return typeof arg === "boolean"; } exports.isBoolean = isBoolean; function isNull(arg) { return arg === null; } exports.isNull = isNull; function isNullOrUndefined(arg) { return arg == null; } exports.isNullOrUndefined = isNullOrUndefined; function isNumber(arg) { return typeof arg === "number"; } exports.isNumber = isNumber; function isString(arg) { return typeof arg === "string"; } exports.isString = isString; function isSymbol(arg) { return typeof arg === "symbol"; } exports.isSymbol = isSymbol; function isUndefined(arg) { return arg === void 0; } exports.isUndefined = isUndefined; function isRegExp(re) { return objectToString(re) === "[object RegExp]"; } exports.isRegExp = isRegExp; function isObject(arg) { return typeof arg === "object" && arg !== null; } exports.isObject = isObject; function isDate(d) { return objectToString(d) === "[object Date]"; } exports.isDate = isDate; function isError(e) { return objectToString(e) === "[object Error]" || e instanceof Error; } exports.isError = isError; function isFunction(arg) { return typeof arg === "function"; } exports.isFunction = isFunction; function isPrimitive(arg) { return ( arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol typeof arg === "undefined" ); } exports.isPrimitive = isPrimitive; exports.isBuffer = Buffer.isBuffer; function objectToString(o) { return Object.prototype.toString.call(o); } }.call(this, { isBuffer: require("../../is-buffer/index.js") })); }, { "../../is-buffer/index.js": 107 } ], 102: [ 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); }; } }, {} ], 103: [ function(require, module, exports) { (function(global) { /*! https://mths.be/he v1.2.0 by @mathias | MIT license */ (function(root) { // Detect free variables `exports`. var freeExports = typeof exports == "object" && exports; // Detect free variable `module`. var freeModule = typeof module == "object" && module && module.exports == freeExports && module; // Detect free variable `global`, from Node.js or Browserified code, // and use it as `root`. var freeGlobal = typeof global == "object" && global; if ( freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal ) { root = freeGlobal; } /*--------------------------------------------------------------------------*/ // All astral symbols. var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; // All ASCII symbols (not just printable ASCII) except those listed in the // first column of the overrides table. // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides var regexAsciiWhitelist = /[\x01-\x7F]/g; // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or // code points listed in the first column of the overrides table on // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides. var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g; var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g; var encodeMap = { "\xAD": "shy", "\u200C": "zwnj", "\u200D": "zwj", "\u200E": "lrm", "\u2063": "ic", "\u2062": "it", "\u2061": "af", "\u200F": "rlm", "\u200B": "ZeroWidthSpace", "\u2060": "NoBreak", "\u0311": "DownBreve", "\u20DB": "tdot", "\u20DC": "DotDot", "\t": "Tab", "\n": "NewLine", "\u2008": "puncsp", "\u205F": "MediumSpace", "\u2009": "thinsp", "\u200A": "hairsp", "\u2004": "emsp13", "\u2002": "ensp", "\u2005": "emsp14", "\u2003": "emsp", "\u2007": "numsp", "\xA0": "nbsp", "\u205F\u200A": "ThickSpace", "\u203E": "oline", _: "lowbar", "\u2010": "dash", "\u2013": "ndash", "\u2014": "mdash", "\u2015": "horbar", ",": "comma", ";": "semi", "\u204F": "bsemi", ":": "colon", "\u2A74": "Colone", "!": "excl", "\xA1": "iexcl", "?": "quest", "\xBF": "iquest", ".": "period", "\u2025": "nldr", "\u2026": "mldr", "\xB7": "middot", "'": "apos", "\u2018": "lsquo", "\u2019": "rsquo", "\u201A": "sbquo", "\u2039": "lsaquo", "\u203A": "rsaquo", '"': "quot", "\u201C": "ldquo", "\u201D": "rdquo", "\u201E": "bdquo", "\xAB": "laquo", "\xBB": "raquo", "(": "lpar", ")": "rpar", "[": "lsqb", "]": "rsqb", "{": "lcub", "}": "rcub", "\u2308": "lceil", "\u2309": "rceil", "\u230A": "lfloor", "\u230B": "rfloor", "\u2985": "lopar", "\u2986": "ropar", "\u298B": "lbrke", "\u298C": "rbrke", "\u298D": "lbrkslu", "\u298E": "rbrksld", "\u298F": "lbrksld", "\u2990": "rbrkslu", "\u2991": "langd", "\u2992": "rangd", "\u2993": "lparlt", "\u2994": "rpargt", "\u2995": "gtlPar", "\u2996": "ltrPar", "\u27E6": "lobrk", "\u27E7": "robrk", "\u27E8": "lang", "\u27E9": "rang", "\u27EA": "Lang", "\u27EB": "Rang", "\u27EC": "loang", "\u27ED": "roang", "\u2772": "lbbrk", "\u2773": "rbbrk", "\u2016": "Vert", "\xA7": "sect", "\xB6": "para", "@": "commat", "*": "ast", "/": "sol", undefined: null, "&": "amp", "#": "num", "%": "percnt", "\u2030": "permil", "\u2031": "pertenk", "\u2020": "dagger", "\u2021": "Dagger", "\u2022": "bull", "\u2043": "hybull", "\u2032": "prime", "\u2033": "Prime", "\u2034": "tprime", "\u2057": "qprime", "\u2035": "bprime", "\u2041": "caret", "`": "grave", "\xB4": "acute", "\u02DC": "tilde", "^": "Hat", "\xAF": "macr", "\u02D8": "breve", "\u02D9": "dot", "\xA8": "die", "\u02DA": "ring", "\u02DD": "dblac", "\xB8": "cedil", "\u02DB": "ogon", ˆ: "circ", ˇ: "caron", "\xB0": "deg", "\xA9": "copy", "\xAE": "reg", "\u2117": "copysr", "\u2118": "wp", "\u211E": "rx", "\u2127": "mho", "\u2129": "iiota", "\u2190": "larr", "\u219A": "nlarr", "\u2192": "rarr", "\u219B": "nrarr", "\u2191": "uarr", "\u2193": "darr", "\u2194": "harr", "\u21AE": "nharr", "\u2195": "varr", "\u2196": "nwarr", "\u2197": "nearr", "\u2198": "searr", "\u2199": "swarr", "\u219D": "rarrw", "\u219D\u0338": "nrarrw", "\u219E": "Larr", "\u219F": "Uarr", "\u21A0": "Rarr", "\u21A1": "Darr", "\u21A2": "larrtl", "\u21A3": "rarrtl", "\u21A4": "mapstoleft", "\u21A5": "mapstoup", "\u21A6": "map", "\u21A7": "mapstodown", "\u21A9": "larrhk", "\u21AA": "rarrhk", "\u21AB": "larrlp", "\u21AC": "rarrlp", "\u21AD": "harrw", "\u21B0": "lsh", "\u21B1": "rsh", "\u21B2": "ldsh", "\u21B3": "rdsh", "\u21B5": "crarr", "\u21B6": "cularr", "\u21B7": "curarr", "\u21BA": "olarr", "\u21BB": "orarr", "\u21BC": "lharu", "\u21BD": "lhard", "\u21BE": "uharr", "\u21BF": "uharl", "\u21C0": "rharu", "\u21C1": "rhard", "\u21C2": "dharr", "\u21C3": "dharl", "\u21C4": "rlarr", "\u21C5": "udarr", "\u21C6": "lrarr", "\u21C7": "llarr", "\u21C8": "uuarr", "\u21C9": "rrarr", "\u21CA": "ddarr", "\u21CB": "lrhar", "\u21CC": "rlhar", "\u21D0": "lArr", "\u21CD": "nlArr", "\u21D1": "uArr", "\u21D2": "rArr", "\u21CF": "nrArr", "\u21D3": "dArr", "\u21D4": "iff", "\u21CE": "nhArr", "\u21D5": "vArr", "\u21D6": "nwArr", "\u21D7": "neArr", "\u21D8": "seArr", "\u21D9": "swArr", "\u21DA": "lAarr", "\u21DB": "rAarr", "\u21DD": "zigrarr", "\u21E4": "larrb", "\u21E5": "rarrb", "\u21F5": "duarr", "\u21FD": "loarr", "\u21FE": "roarr", "\u21FF": "hoarr", "\u2200": "forall", "\u2201": "comp", "\u2202": "part", "\u2202\u0338": "npart", "\u2203": "exist", "\u2204": "nexist", "\u2205": "empty", "\u2207": "Del", "\u2208": "in", "\u2209": "notin", "\u220B": "ni", "\u220C": "notni", "\u03F6": "bepsi", "\u220F": "prod", "\u2210": "coprod", "\u2211": "sum", "+": "plus", "\xB1": "pm", "\xF7": "div", "\xD7": "times", "<": "lt", "\u226E": "nlt", "<\u20D2": "nvlt", "=": "equals", "\u2260": "ne", "=\u20E5": "bne", "\u2A75": "Equal", ">": "gt", "\u226F": "ngt", ">\u20D2": "nvgt", "\xAC": "not", "|": "vert", "\xA6": "brvbar", "\u2212": "minus", "\u2213": "mp", "\u2214": "plusdo", "\u2044": "frasl", "\u2216": "setmn", "\u2217": "lowast", "\u2218": "compfn", "\u221A": "Sqrt", "\u221D": "prop", "\u221E": "infin", "\u221F": "angrt", "\u2220": "ang", "\u2220\u20D2": "nang", "\u2221": "angmsd", "\u2222": "angsph", "\u2223": "mid", "\u2224": "nmid", "\u2225": "par", "\u2226": "npar", "\u2227": "and", "\u2228": "or", "\u2229": "cap", "\u2229\uFE00": "caps", "\u222A": "cup", "\u222A\uFE00": "cups", "\u222B": "int", "\u222C": "Int", "\u222D": "tint", "\u2A0C": "qint", "\u222E": "oint", "\u222F": "Conint", "\u2230": "Cconint", "\u2231": "cwint", "\u2232": "cwconint", "\u2233": "awconint", "\u2234": "there4", "\u2235": "becaus", "\u2236": "ratio", "\u2237": "Colon", "\u2238": "minusd", "\u223A": "mDDot", "\u223B": "homtht", "\u223C": "sim", "\u2241": "nsim", "\u223C\u20D2": "nvsim", "\u223D": "bsim", "\u223D\u0331": "race", "\u223E": "ac", "\u223E\u0333": "acE", "\u223F": "acd", "\u2240": "wr", "\u2242": "esim", "\u2242\u0338": "nesim", "\u2243": "sime", "\u2244": "nsime", "\u2245": "cong", "\u2247": "ncong", "\u2246": "simne", "\u2248": "ap", "\u2249": "nap", "\u224A": "ape", "\u224B": "apid", "\u224B\u0338": "napid", "\u224C": "bcong", "\u224D": "CupCap", "\u226D": "NotCupCap", "\u224D\u20D2": "nvap", "\u224E": "bump", "\u224E\u0338": "nbump", "\u224F": "bumpe", "\u224F\u0338": "nbumpe", "\u2250": "doteq", "\u2250\u0338": "nedot", "\u2251": "eDot", "\u2252": "efDot", "\u2253": "erDot", "\u2254": "colone", "\u2255": "ecolon", "\u2256": "ecir", "\u2257": "cire", "\u2259": "wedgeq", "\u225A": "veeeq", "\u225C": "trie", "\u225F": "equest", "\u2261": "equiv", "\u2262": "nequiv", "\u2261\u20E5": "bnequiv", "\u2264": "le", "\u2270": "nle", "\u2264\u20D2": "nvle", "\u2265": "ge", "\u2271": "nge", "\u2265\u20D2": "nvge", "\u2266": "lE", "\u2266\u0338": "nlE", "\u2267": "gE", "\u2267\u0338": "ngE", "\u2268\uFE00": "lvnE", "\u2268": "lnE", "\u2269": "gnE", "\u2269\uFE00": "gvnE", "\u226A": "ll", "\u226A\u0338": "nLtv", "\u226A\u20D2": "nLt", "\u226B": "gg", "\u226B\u0338": "nGtv", "\u226B\u20D2": "nGt", "\u226C": "twixt", "\u2272": "lsim", "\u2274": "nlsim", "\u2273": "gsim", "\u2275": "ngsim", "\u2276": "lg", "\u2278": "ntlg", "\u2277": "gl", "\u2279": "ntgl", "\u227A": "pr", "\u2280": "npr", "\u227B": "sc", "\u2281": "nsc", "\u227C": "prcue", "\u22E0": "nprcue", "\u227D": "sccue", "\u22E1": "nsccue", "\u227E": "prsim", "\u227F": "scsim", "\u227F\u0338": "NotSucceedsTilde", "\u2282": "sub", "\u2284": "nsub", "\u2282\u20D2": "vnsub", "\u2283": "sup", "\u2285": "nsup", "\u2283\u20D2": "vnsup", "\u2286": "sube", "\u2288": "nsube", "\u2287": "supe", "\u2289": "nsupe", "\u228A\uFE00": "vsubne", "\u228A": "subne", "\u228B\uFE00": "vsupne", "\u228B": "supne", "\u228D": "cupdot", "\u228E": "uplus", "\u228F": "sqsub", "\u228F\u0338": "NotSquareSubset", "\u2290": "sqsup", "\u2290\u0338": "NotSquareSuperset", "\u2291": "sqsube", "\u22E2": "nsqsube", "\u2292": "sqsupe", "\u22E3": "nsqsupe", "\u2293": "sqcap", "\u2293\uFE00": "sqcaps", "\u2294": "sqcup", "\u2294\uFE00": "sqcups", "\u2295": "oplus", "\u2296": "ominus", "\u2297": "otimes", "\u2298": "osol", "\u2299": "odot", "\u229A": "ocir", "\u229B": "oast", "\u229D": "odash", "\u229E": "plusb", "\u229F": "minusb", "\u22A0": "timesb", "\u22A1": "sdotb", "\u22A2": "vdash", "\u22AC": "nvdash", "\u22A3": "dashv", "\u22A4": "top", "\u22A5": "bot", "\u22A7": "models", "\u22A8": "vDash", "\u22AD": "nvDash", "\u22A9": "Vdash", "\u22AE": "nVdash", "\u22AA": "Vvdash", "\u22AB": "VDash", "\u22AF": "nVDash", "\u22B0": "prurel", "\u22B2": "vltri", "\u22EA": "nltri", "\u22B3": "vrtri", "\u22EB": "nrtri", "\u22B4": "ltrie", "\u22EC": "nltrie", "\u22B4\u20D2": "nvltrie", "\u22B5": "rtrie", "\u22ED": "nrtrie", "\u22B5\u20D2": "nvrtrie", "\u22B6": "origof", "\u22B7": "imof", "\u22B8": "mumap", "\u22B9": "hercon", "\u22BA": "intcal", "\u22BB": "veebar", "\u22BD": "barvee", "\u22BE": "angrtvb", "\u22BF": "lrtri", "\u22C0": "Wedge", "\u22C1": "Vee", "\u22C2": "xcap", "\u22C3": "xcup", "\u22C4": "diam", "\u22C5": "sdot", "\u22C6": "Star", "\u22C7": "divonx", "\u22C8": "bowtie", "\u22C9": "ltimes", "\u22CA": "rtimes", "\u22CB": "lthree", "\u22CC": "rthree", "\u22CD": "bsime", "\u22CE": "cuvee", "\u22CF": "cuwed", "\u22D0": "Sub", "\u22D1": "Sup", "\u22D2": "Cap", "\u22D3": "Cup", "\u22D4": "fork", "\u22D5": "epar", "\u22D6": "ltdot", "\u22D7": "gtdot", "\u22D8": "Ll", "\u22D8\u0338": "nLl", "\u22D9": "Gg", "\u22D9\u0338": "nGg", "\u22DA\uFE00": "lesg", "\u22DA": "leg", "\u22DB": "gel", "\u22DB\uFE00": "gesl", "\u22DE": "cuepr", "\u22DF": "cuesc", "\u22E6": "lnsim", "\u22E7": "gnsim", "\u22E8": "prnsim", "\u22E9": "scnsim", "\u22EE": "vellip", "\u22EF": "ctdot", "\u22F0": "utdot", "\u22F1": "dtdot", "\u22F2": "disin", "\u22F3": "isinsv", "\u22F4": "isins", "\u22F5": "isindot", "\u22F5\u0338": "notindot", "\u22F6": "notinvc", "\u22F7": "notinvb", "\u22F9": "isinE", "\u22F9\u0338": "notinE", "\u22FA": "nisd", "\u22FB": "xnis", "\u22FC": "nis", "\u22FD": "notnivc", "\u22FE": "notnivb", "\u2305": "barwed", "\u2306": "Barwed", "\u230C": "drcrop", "\u230D": "dlcrop", "\u230E": "urcrop", "\u230F": "ulcrop", "\u2310": "bnot", "\u2312": "profline", "\u2313": "profsurf", "\u2315": "telrec", "\u2316": "target", "\u231C": "ulcorn", "\u231D": "urcorn", "\u231E": "dlcorn", "\u231F": "drcorn", "\u2322": "frown", "\u2323": "smile", "\u232D": "cylcty", "\u232E": "profalar", "\u2336": "topbot", "\u233D": "ovbar", "\u233F": "solbar", "\u237C": "angzarr", "\u23B0": "lmoust", "\u23B1": "rmoust", "\u23B4": "tbrk", "\u23B5": "bbrk", "\u23B6": "bbrktbrk", "\u23DC": "OverParenthesis", "\u23DD": "UnderParenthesis", "\u23DE": "OverBrace", "\u23DF": "UnderBrace", "\u23E2": "trpezium", "\u23E7": "elinters", "\u2423": "blank", "\u2500": "boxh", "\u2502": "boxv", "\u250C": "boxdr", "\u2510": "boxdl", "\u2514": "boxur", "\u2518": "boxul", "\u251C": "boxvr", "\u2524": "boxvl", "\u252C": "boxhd", "\u2534": "boxhu", "\u253C": "boxvh", "\u2550": "boxH", "\u2551": "boxV", "\u2552": "boxdR", "\u2553": "boxDr", "\u2554": "boxDR", "\u2555": "boxdL", "\u2556": "boxDl", "\u2557": "boxDL", "\u2558": "boxuR", "\u2559": "boxUr", "\u255A": "boxUR", "\u255B": "boxuL", "\u255C": "boxUl", "\u255D": "boxUL", "\u255E": "boxvR", "\u255F": "boxVr", "\u2560": "boxVR", "\u2561": "boxvL", "\u2562": "boxVl", "\u2563": "boxVL", "\u2564": "boxHd", "\u2565": "boxhD", "\u2566": "boxHD", "\u2567": "boxHu", "\u2568": "boxhU", "\u2569": "boxHU", "\u256A": "boxvH", "\u256B": "boxVh", "\u256C": "boxVH", "\u2580": "uhblk", "\u2584": "lhblk", "\u2588": "block", "\u2591": "blk14", "\u2592": "blk12", "\u2593": "blk34", "\u25A1": "squ", "\u25AA": "squf", "\u25AB": "EmptyVerySmallSquare", "\u25AD": "rect", "\u25AE": "marker", "\u25B1": "fltns", "\u25B3": "xutri", "\u25B4": "utrif", "\u25B5": "utri", "\u25B8": "rtrif", "\u25B9": "rtri", "\u25BD": "xdtri", "\u25BE": "dtrif", "\u25BF": "dtri", "\u25C2": "ltrif", "\u25C3": "ltri", "\u25CA": "loz", "\u25CB": "cir", "\u25EC": "tridot", "\u25EF": "xcirc", "\u25F8": "ultri", "\u25F9": "urtri", "\u25FA": "lltri", "\u25FB": "EmptySmallSquare", "\u25FC": "FilledSmallSquare", "\u2605": "starf", "\u2606": "star", "\u260E": "phone", "\u2640": "female", "\u2642": "male", "\u2660": "spades", "\u2663": "clubs", "\u2665": "hearts", "\u2666": "diams", "\u266A": "sung", "\u2713": "check", "\u2717": "cross", "\u2720": "malt", "\u2736": "sext", "\u2758": "VerticalSeparator", "\u27C8": "bsolhsub", "\u27C9": "suphsol", "\u27F5": "xlarr", "\u27F6": "xrarr", "\u27F7": "xharr", "\u27F8": "xlArr", "\u27F9": "xrArr", "\u27FA": "xhArr", "\u27FC": "xmap", "\u27FF": "dzigrarr", "\u2902": "nvlArr", "\u2903": "nvrArr", "\u2904": "nvHarr", "\u2905": "Map", "\u290C": "lbarr", "\u290D": "rbarr", "\u290E": "lBarr", "\u290F": "rBarr", "\u2910": "RBarr", "\u2911": "DDotrahd", "\u2912": "UpArrowBar", "\u2913": "DownArrowBar", "\u2916": "Rarrtl", "\u2919": "latail", "\u291A": "ratail", "\u291B": "lAtail", "\u291C": "rAtail", "\u291D": "larrfs", "\u291E": "rarrfs", "\u291F": "larrbfs", "\u2920": "rarrbfs", "\u2923": "nwarhk", "\u2924": "nearhk", "\u2925": "searhk", "\u2926": "swarhk", "\u2927": "nwnear", "\u2928": "toea", "\u2929": "tosa", "\u292A": "swnwar", "\u2933": "rarrc", "\u2933\u0338": "nrarrc", "\u2935": "cudarrr", "\u2936": "ldca", "\u2937": "rdca", "\u2938": "cudarrl", "\u2939": "larrpl", "\u293C": "curarrm", "\u293D": "cularrp", "\u2945": "rarrpl", "\u2948": "harrcir", "\u2949": "Uarrocir", "\u294A": "lurdshar", "\u294B": "ldrushar", "\u294E": "LeftRightVector", "\u294F": "RightUpDownVector", "\u2950": "DownLeftRightVector", "\u2951": "LeftUpDownVector", "\u2952": "LeftVectorBar", "\u2953": "RightVectorBar", "\u2954": "RightUpVectorBar", "\u2955": "RightDownVectorBar", "\u2956": "DownLeftVectorBar", "\u2957": "DownRightVectorBar", "\u2958": "LeftUpVectorBar", "\u2959": "LeftDownVectorBar", "\u295A": "LeftTeeVector", "\u295B": "RightTeeVector", "\u295C": "RightUpTeeVector", "\u295D": "RightDownTeeVector", "\u295E": "DownLeftTeeVector", "\u295F": "DownRightTeeVector", "\u2960": "LeftUpTeeVector", "\u2961": "LeftDownTeeVector", "\u2962": "lHar", "\u2963": "uHar", "\u2964": "rHar", "\u2965": "dHar", "\u2966": "luruhar", "\u2967": "ldrdhar", "\u2968": "ruluhar", "\u2969": "rdldhar", "\u296A": "lharul", "\u296B": "llhard", "\u296C": "rharul", "\u296D": "lrhard", "\u296E": "udhar", "\u296F": "duhar", "\u2970": "RoundImplies", "\u2971": "erarr", "\u2972": "simrarr", "\u2973": "larrsim", "\u2974": "rarrsim", "\u2975": "rarrap", "\u2976": "ltlarr", "\u2978": "gtrarr", "\u2979": "subrarr", "\u297B": "suplarr", "\u297C": "lfisht", "\u297D": "rfisht", "\u297E": "ufisht", "\u297F": "dfisht", "\u299A": "vzigzag", "\u299C": "vangrt", "\u299D": "angrtvbd", "\u29A4": "ange", "\u29A5": "range", "\u29A6": "dwangle", "\u29A7": "uwangle", "\u29A8": "angmsdaa", "\u29A9": "angmsdab", "\u29AA": "angmsdac", "\u29AB": "angmsdad", "\u29AC": "angmsdae", "\u29AD": "angmsdaf", "\u29AE": "angmsdag", "\u29AF": "angmsdah", "\u29B0": "bemptyv", "\u29B1": "demptyv", "\u29B2": "cemptyv", "\u29B3": "raemptyv", "\u29B4": "laemptyv", "\u29B5": "ohbar", "\u29B6": "omid", "\u29B7": "opar", "\u29B9": "operp", "\u29BB": "olcross", "\u29BC": "odsold", "\u29BE": "olcir", "\u29BF": "ofcir", "\u29C0": "olt", "\u29C1": "ogt", "\u29C2": "cirscir", "\u29C3": "cirE", "\u29C4": "solb", "\u29C5": "bsolb", "\u29C9": "boxbox", "\u29CD": "trisb", "\u29CE": "rtriltri", "\u29CF": "LeftTriangleBar", "\u29CF\u0338": "NotLeftTriangleBar", "\u29D0": "RightTriangleBar", "\u29D0\u0338": "NotRightTriangleBar", "\u29DC": "iinfin", "\u29DD": "infintie", "\u29DE": "nvinfin", "\u29E3": "eparsl", "\u29E4": "smeparsl", "\u29E5": "eqvparsl", "\u29EB": "lozf", "\u29F4": "RuleDelayed", "\u29F6": "dsol", "\u2A00": "xodot", "\u2A01": "xoplus", "\u2A02": "xotime", "\u2A04": "xuplus", "\u2A06": "xsqcup", "\u2A0D": "fpartint", "\u2A10": "cirfnint", "\u2A11": "awint", "\u2A12": "rppolint", "\u2A13": "scpolint", "\u2A14": "npolint", "\u2A15": "pointint", "\u2A16": "quatint", "\u2A17": "intlarhk", "\u2A22": "pluscir", "\u2A23": "plusacir", "\u2A24": "simplus", "\u2A25": "plusdu", "\u2A26": "plussim", "\u2A27": "plustwo", "\u2A29": "mcomma", "\u2A2A": "minusdu", "\u2A2D": "loplus", "\u2A2E": "roplus", "\u2A2F": "Cross", "\u2A30": "timesd", "\u2A31": "timesbar", "\u2A33": "smashp", "\u2A34": "lotimes", "\u2A35": "rotimes", "\u2A36": "otimesas", "\u2A37": "Otimes", "\u2A38": "odiv", "\u2A39": "triplus", "\u2A3A": "triminus", "\u2A3B": "tritime", "\u2A3C": "iprod", "\u2A3F": "amalg", "\u2A40": "capdot", "\u2A42": "ncup", "\u2A43": "ncap", "\u2A44": "capand", "\u2A45": "cupor", "\u2A46": "cupcap", "\u2A47": "capcup", "\u2A48": "cupbrcap", "\u2A49": "capbrcup", "\u2A4A": "cupcup", "\u2A4B": "capcap", "\u2A4C": "ccups", "\u2A4D": "ccaps", "\u2A50": "ccupssm", "\u2A53": "And", "\u2A54": "Or", "\u2A55": "andand", "\u2A56": "oror", "\u2A57": "orslope", "\u2A58": "andslope", "\u2A5A": "andv", "\u2A5B": "orv", "\u2A5C": "andd", "\u2A5D": "ord", "\u2A5F": "wedbar", "\u2A66": "sdote", "\u2A6A": "simdot", "\u2A6D": "congdot", "\u2A6D\u0338": "ncongdot", "\u2A6E": "easter", "\u2A6F": "apacir", "\u2A70": "apE", "\u2A70\u0338": "napE", "\u2A71": "eplus", "\u2A72": "pluse", "\u2A73": "Esim", "\u2A77": "eDDot", "\u2A78": "equivDD", "\u2A79": "ltcir", "\u2A7A": "gtcir", "\u2A7B": "ltquest", "\u2A7C": "gtquest", "\u2A7D": "les", "\u2A7D\u0338": "nles", "\u2A7E": "ges", "\u2A7E\u0338": "nges", "\u2A7F": "lesdot", "\u2A80": "gesdot", "\u2A81": "lesdoto", "\u2A82": "gesdoto", "\u2A83": "lesdotor", "\u2A84": "gesdotol", "\u2A85": "lap", "\u2A86": "gap", "\u2A87": "lne", "\u2A88": "gne", "\u2A89": "lnap", "\u2A8A": "gnap", "\u2A8B": "lEg", "\u2A8C": "gEl", "\u2A8D": "lsime", "\u2A8E": "gsime", "\u2A8F": "lsimg", "\u2A90": "gsiml", "\u2A91": "lgE", "\u2A92": "glE", "\u2A93": "lesges", "\u2A94": "gesles", "\u2A95": "els", "\u2A96": "egs", "\u2A97": "elsdot", "\u2A98": "egsdot", "\u2A99": "el", "\u2A9A": "eg", "\u2A9D": "siml", "\u2A9E": "simg", "\u2A9F": "simlE", "\u2AA0": "simgE", "\u2AA1": "LessLess", "\u2AA1\u0338": "NotNestedLessLess", "\u2AA2": "GreaterGreater", "\u2AA2\u0338": "NotNestedGreaterGreater", "\u2AA4": "glj", "\u2AA5": "gla", "\u2AA6": "ltcc", "\u2AA7": "gtcc", "\u2AA8": "lescc", "\u2AA9": "gescc", "\u2AAA": "smt", "\u2AAB": "lat", "\u2AAC": "smte", "\u2AAC\uFE00": "smtes", "\u2AAD": "late", "\u2AAD\uFE00": "lates", "\u2AAE": "bumpE", "\u2AAF": "pre", "\u2AAF\u0338": "npre", "\u2AB0": "sce", "\u2AB0\u0338": "nsce", "\u2AB3": "prE", "\u2AB4": "scE", "\u2AB5": "prnE", "\u2AB6": "scnE", "\u2AB7": "prap", "\u2AB8": "scap", "\u2AB9": "prnap", "\u2ABA": "scnap", "\u2ABB": "Pr", "\u2ABC": "Sc", "\u2ABD": "subdot", "\u2ABE": "supdot", "\u2ABF": "subplus", "\u2AC0": "supplus", "\u2AC1": "submult", "\u2AC2": "supmult", "\u2AC3": "subedot", "\u2AC4": "supedot", "\u2AC5": "subE", "\u2AC5\u0338": "nsubE", "\u2AC6": "supE", "\u2AC6\u0338": "nsupE", "\u2AC7": "subsim", "\u2AC8": "supsim", "\u2ACB\uFE00": "vsubnE", "\u2ACB": "subnE", "\u2ACC\uFE00": "vsupnE", "\u2ACC": "supnE", "\u2ACF": "csub", "\u2AD0": "csup", "\u2AD1": "csube", "\u2AD2": "csupe", "\u2AD3": "subsup", "\u2AD4": "supsub", "\u2AD5": "subsub", "\u2AD6": "supsup", "\u2AD7": "suphsub", "\u2AD8": "supdsub", "\u2AD9": "forkv", "\u2ADA": "topfork", "\u2ADB": "mlcp", "\u2AE4": "Dashv", "\u2AE6": "Vdashl", "\u2AE7": "Barv", "\u2AE8": "vBar", "\u2AE9": "vBarv", "\u2AEB": "Vbar", "\u2AEC": "Not", "\u2AED": "bNot", "\u2AEE": "rnmid", "\u2AEF": "cirmid", "\u2AF0": "midcir", "\u2AF1": "topcir", "\u2AF2": "nhpar", "\u2AF3": "parsim", "\u2AFD": "parsl", "\u2AFD\u20E5": "nparsl", "\u266D": "flat", "\u266E": "natur", "\u266F": "sharp", "\xA4": "curren", "\xA2": "cent", $: "dollar", "\xA3": "pound", "\xA5": "yen", "\u20AC": "euro", "\xB9": "sup1", "\xBD": "half", "\u2153": "frac13", "\xBC": "frac14", "\u2155": "frac15", "\u2159": "frac16", "\u215B": "frac18", "\xB2": "sup2", "\u2154": "frac23", "\u2156": "frac25", "\xB3": "sup3", "\xBE": "frac34", "\u2157": "frac35", "\u215C": "frac38", "\u2158": "frac45", "\u215A": "frac56", "\u215D": "frac58", "\u215E": "frac78", "\uD835\uDCB6": "ascr", "\uD835\uDD52": "aopf", "\uD835\uDD1E": "afr", "\uD835\uDD38": "Aopf", "\uD835\uDD04": "Afr", "\uD835\uDC9C": "Ascr", ª: "ordf", á: "aacute", Á: "Aacute", à: "agrave", À: "Agrave", ă: "abreve", Ă: "Abreve", â: "acirc", Â: "Acirc", å: "aring", Å: "angst", ä: "auml", Ä: "Auml", ã: "atilde", Ã: "Atilde", ą: "aogon", Ą: "Aogon", ā: "amacr", Ā: "Amacr", æ: "aelig", Æ: "AElig", "\uD835\uDCB7": "bscr", "\uD835\uDD53": "bopf", "\uD835\uDD1F": "bfr", "\uD835\uDD39": "Bopf", ℬ: "Bscr", "\uD835\uDD05": "Bfr", "\uD835\uDD20": "cfr", "\uD835\uDCB8": "cscr", "\uD835\uDD54": "copf", ℭ: "Cfr", "\uD835\uDC9E": "Cscr", ℂ: "Copf", ć: "cacute", Ć: "Cacute", ĉ: "ccirc", Ĉ: "Ccirc", č: "ccaron", Č: "Ccaron", ċ: "cdot", Ċ: "Cdot", ç: "ccedil", Ç: "Ccedil", "\u2105": "incare", "\uD835\uDD21": "dfr", ⅆ: "dd", "\uD835\uDD55": "dopf", "\uD835\uDCB9": "dscr", "\uD835\uDC9F": "Dscr", "\uD835\uDD07": "Dfr", ⅅ: "DD", "\uD835\uDD3B": "Dopf", ď: "dcaron", Ď: "Dcaron", đ: "dstrok", Đ: "Dstrok", ð: "eth", Ð: "ETH", ⅇ: "ee", ℯ: "escr", "\uD835\uDD22": "efr", "\uD835\uDD56": "eopf", ℰ: "Escr", "\uD835\uDD08": "Efr", "\uD835\uDD3C": "Eopf", é: "eacute", É: "Eacute", è: "egrave", È: "Egrave", ê: "ecirc", Ê: "Ecirc", ě: "ecaron", Ě: "Ecaron", ë: "euml", Ë: "Euml", ė: "edot", Ė: "Edot", ę: "eogon", Ę: "Eogon", ē: "emacr", Ē: "Emacr", "\uD835\uDD23": "ffr", "\uD835\uDD57": "fopf", "\uD835\uDCBB": "fscr", "\uD835\uDD09": "Ffr", "\uD835\uDD3D": "Fopf", ℱ: "Fscr", ff: "fflig", ffi: "ffilig", ffl: "ffllig", fi: "filig", fj: "fjlig", fl: "fllig", ƒ: "fnof", ℊ: "gscr", "\uD835\uDD58": "gopf", "\uD835\uDD24": "gfr", "\uD835\uDCA2": "Gscr", "\uD835\uDD3E": "Gopf", "\uD835\uDD0A": "Gfr", ǵ: "gacute", ğ: "gbreve", Ğ: "Gbreve", ĝ: "gcirc", Ĝ: "Gcirc", ġ: "gdot", Ġ: "Gdot", Ģ: "Gcedil", "\uD835\uDD25": "hfr", ℎ: "planckh", "\uD835\uDCBD": "hscr", "\uD835\uDD59": "hopf", ℋ: "Hscr", ℌ: "Hfr", ℍ: "Hopf", ĥ: "hcirc", Ĥ: "Hcirc", ℏ: "hbar", ħ: "hstrok", Ħ: "Hstrok", "\uD835\uDD5A": "iopf", "\uD835\uDD26": "ifr", "\uD835\uDCBE": "iscr", ⅈ: "ii", "\uD835\uDD40": "Iopf", ℐ: "Iscr", ℑ: "Im", í: "iacute", Í: "Iacute", ì: "igrave", Ì: "Igrave", î: "icirc", Î: "Icirc", ï: "iuml", Ï: "Iuml", ĩ: "itilde", Ĩ: "Itilde", İ: "Idot", į: "iogon", Į: "Iogon", ī: "imacr", Ī: "Imacr", ij: "ijlig", IJ: "IJlig", ı: "imath", "\uD835\uDCBF": "jscr", "\uD835\uDD5B": "jopf", "\uD835\uDD27": "jfr", "\uD835\uDCA5": "Jscr", "\uD835\uDD0D": "Jfr", "\uD835\uDD41": "Jopf", ĵ: "jcirc", Ĵ: "Jcirc", ȷ: "jmath", "\uD835\uDD5C": "kopf", "\uD835\uDCC0": "kscr", "\uD835\uDD28": "kfr", "\uD835\uDCA6": "Kscr", "\uD835\uDD42": "Kopf", "\uD835\uDD0E": "Kfr", ķ: "kcedil", Ķ: "Kcedil", "\uD835\uDD29": "lfr", "\uD835\uDCC1": "lscr", ℓ: "ell", "\uD835\uDD5D": "lopf", ℒ: "Lscr", "\uD835\uDD0F": "Lfr", "\uD835\uDD43": "Lopf", ĺ: "lacute", Ĺ: "Lacute", ľ: "lcaron", Ľ: "Lcaron", ļ: "lcedil", Ļ: "Lcedil", ł: "lstrok", Ł: "Lstrok", ŀ: "lmidot", Ŀ: "Lmidot", "\uD835\uDD2A": "mfr", "\uD835\uDD5E": "mopf", "\uD835\uDCC2": "mscr", "\uD835\uDD10": "Mfr", "\uD835\uDD44": "Mopf", ℳ: "Mscr", "\uD835\uDD2B": "nfr", "\uD835\uDD5F": "nopf", "\uD835\uDCC3": "nscr", ℕ: "Nopf", "\uD835\uDCA9": "Nscr", "\uD835\uDD11": "Nfr", ń: "nacute", Ń: "Nacute", ň: "ncaron", Ň: "Ncaron", ñ: "ntilde", Ñ: "Ntilde", ņ: "ncedil", Ņ: "Ncedil", "\u2116": "numero", ŋ: "eng", Ŋ: "ENG", "\uD835\uDD60": "oopf", "\uD835\uDD2C": "ofr", ℴ: "oscr", "\uD835\uDCAA": "Oscr", "\uD835\uDD12": "Ofr", "\uD835\uDD46": "Oopf", º: "ordm", ó: "oacute", Ó: "Oacute", ò: "ograve", Ò: "Ograve", ô: "ocirc", Ô: "Ocirc", ö: "ouml", Ö: "Ouml", ő: "odblac", Ő: "Odblac", õ: "otilde", Õ: "Otilde", ø: "oslash", Ø: "Oslash", ō: "omacr", Ō: "Omacr", œ: "oelig", Œ: "OElig", "\uD835\uDD2D": "pfr", "\uD835\uDCC5": "pscr", "\uD835\uDD61": "popf", ℙ: "Popf", "\uD835\uDD13": "Pfr", "\uD835\uDCAB": "Pscr", "\uD835\uDD62": "qopf", "\uD835\uDD2E": "qfr", "\uD835\uDCC6": "qscr", "\uD835\uDCAC": "Qscr", "\uD835\uDD14": "Qfr", ℚ: "Qopf", ĸ: "kgreen", "\uD835\uDD2F": "rfr", "\uD835\uDD63": "ropf", "\uD835\uDCC7": "rscr", ℛ: "Rscr", ℜ: "Re", ℝ: "Ropf", ŕ: "racute", Ŕ: "Racute", ř: "rcaron", Ř: "Rcaron", ŗ: "rcedil", Ŗ: "Rcedil", "\uD835\uDD64": "sopf", "\uD835\uDCC8": "sscr", "\uD835\uDD30": "sfr", "\uD835\uDD4A": "Sopf", "\uD835\uDD16": "Sfr", "\uD835\uDCAE": "Sscr", "\u24C8": "oS", ś: "sacute", Ś: "Sacute", ŝ: "scirc", Ŝ: "Scirc", š: "scaron", Š: "Scaron", ş: "scedil", Ş: "Scedil", ß: "szlig", "\uD835\uDD31": "tfr", "\uD835\uDCC9": "tscr", "\uD835\uDD65": "topf", "\uD835\uDCAF": "Tscr", "\uD835\uDD17": "Tfr", "\uD835\uDD4B": "Topf", ť: "tcaron", Ť: "Tcaron", ţ: "tcedil", Ţ: "Tcedil", "\u2122": "trade", ŧ: "tstrok", Ŧ: "Tstrok", "\uD835\uDCCA": "uscr", "\uD835\uDD66": "uopf", "\uD835\uDD32": "ufr", "\uD835\uDD4C": "Uopf", "\uD835\uDD18": "Ufr", "\uD835\uDCB0": "Uscr", ú: "uacute", Ú: "Uacute", ù: "ugrave", Ù: "Ugrave", ŭ: "ubreve", Ŭ: "Ubreve", û: "ucirc", Û: "Ucirc", ů: "uring", Ů: "Uring", ü: "uuml", Ü: "Uuml", ű: "udblac", Ű: "Udblac", ũ: "utilde", Ũ: "Utilde", ų: "uogon", Ų: "Uogon", ū: "umacr", Ū: "Umacr", "\uD835\uDD33": "vfr", "\uD835\uDD67": "vopf", "\uD835\uDCCB": "vscr", "\uD835\uDD19": "Vfr", "\uD835\uDD4D": "Vopf", "\uD835\uDCB1": "Vscr", "\uD835\uDD68": "wopf", "\uD835\uDCCC": "wscr", "\uD835\uDD34": "wfr", "\uD835\uDCB2": "Wscr", "\uD835\uDD4E": "Wopf", "\uD835\uDD1A": "Wfr", ŵ: "wcirc", Ŵ: "Wcirc", "\uD835\uDD35": "xfr", "\uD835\uDCCD": "xscr", "\uD835\uDD69": "xopf", "\uD835\uDD4F": "Xopf", "\uD835\uDD1B": "Xfr", "\uD835\uDCB3": "Xscr", "\uD835\uDD36": "yfr", "\uD835\uDCCE": "yscr", "\uD835\uDD6A": "yopf", "\uD835\uDCB4": "Yscr", "\uD835\uDD1C": "Yfr", "\uD835\uDD50": "Yopf", ý: "yacute", Ý: "Yacute", ŷ: "ycirc", Ŷ: "Ycirc", ÿ: "yuml", Ÿ: "Yuml", "\uD835\uDCCF": "zscr", "\uD835\uDD37": "zfr", "\uD835\uDD6B": "zopf", ℨ: "Zfr", ℤ: "Zopf", "\uD835\uDCB5": "Zscr", ź: "zacute", Ź: "Zacute", ž: "zcaron", Ž: "Zcaron", ż: "zdot", Ż: "Zdot", Ƶ: "imped", þ: "thorn", Þ: "THORN", ʼn: "napos", α: "alpha", Α: "Alpha", β: "beta", Β: "Beta", γ: "gamma", Γ: "Gamma", δ: "delta", Δ: "Delta", ε: "epsi", ϵ: "epsiv", Ε: "Epsilon", ϝ: "gammad", Ϝ: "Gammad", ζ: "zeta", Ζ: "Zeta", η: "eta", Η: "Eta", θ: "theta", ϑ: "thetav", Θ: "Theta", ι: "iota", Ι: "Iota", κ: "kappa", ϰ: "kappav", Κ: "Kappa", λ: "lambda", Λ: "Lambda", μ: "mu", µ: "micro", Μ: "Mu", ν: "nu", Ν: "Nu", ξ: "xi", Ξ: "Xi", ο: "omicron", Ο: "Omicron", π: "pi", ϖ: "piv", Π: "Pi", ρ: "rho", ϱ: "rhov", Ρ: "Rho", σ: "sigma", Σ: "Sigma", ς: "sigmaf", τ: "tau", Τ: "Tau", υ: "upsi", Υ: "Upsilon", ϒ: "Upsi", φ: "phi", ϕ: "phiv", Φ: "Phi", χ: "chi", Χ: "Chi", ψ: "psi", Ψ: "Psi", ω: "omega", Ω: "ohm", а: "acy", А: "Acy", б: "bcy", Б: "Bcy", в: "vcy", В: "Vcy", г: "gcy", Г: "Gcy", ѓ: "gjcy", Ѓ: "GJcy", д: "dcy", Д: "Dcy", ђ: "djcy", Ђ: "DJcy", е: "iecy", Е: "IEcy", ё: "iocy", Ё: "IOcy", є: "jukcy", Є: "Jukcy", ж: "zhcy", Ж: "ZHcy", з: "zcy", З: "Zcy", ѕ: "dscy", Ѕ: "DScy", и: "icy", И: "Icy", і: "iukcy", І: "Iukcy", ї: "yicy", Ї: "YIcy", й: "jcy", Й: "Jcy", ј: "jsercy", Ј: "Jsercy", к: "kcy", К: "Kcy", ќ: "kjcy", Ќ: "KJcy", л: "lcy", Л: "Lcy", љ: "ljcy", Љ: "LJcy", м: "mcy", М: "Mcy", н: "ncy", Н: "Ncy", њ: "njcy", Њ: "NJcy", о: "ocy", О: "Ocy", п: "pcy", П: "Pcy", р: "rcy", Р: "Rcy", с: "scy", С: "Scy", т: "tcy", Т: "Tcy", ћ: "tshcy", Ћ: "TSHcy", у: "ucy", У: "Ucy", ў: "ubrcy", Ў: "Ubrcy", ф: "fcy", Ф: "Fcy", х: "khcy", Х: "KHcy", ц: "tscy", Ц: "TScy", ч: "chcy", Ч: "CHcy", џ: "dzcy", Џ: "DZcy", ш: "shcy", Ш: "SHcy", щ: "shchcy", Щ: "SHCHcy", ъ: "hardcy", Ъ: "HARDcy", ы: "ycy", Ы: "Ycy", ь: "softcy", Ь: "SOFTcy", э: "ecy", Э: "Ecy", ю: "yucy", Ю: "YUcy", я: "yacy", Я: "YAcy", ℵ: "aleph", ℶ: "beth", ℷ: "gimel", ℸ: "daleth" }; var regexEscape = /["&'<>`]/g; var escapeMap = { '"': """, "&": "&", "'": "'", "<": "<", // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the // following is not strictly necessary unless it’s part of a tag or an // unquoted attribute value. We’re only escaping it to support those // situations, and for XML support. ">": ">", // In Internet Explorer ≤ 8, the backtick character can be used // to break out of (un)quoted attribute values or HTML comments. // See http://html5sec.org/#102, http://html5sec.org/#108, and // http://html5sec.org/#133. "`": "`" }; var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/; var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g; var decodeMap = { aacute: "\xE1", Aacute: "\xC1", abreve: "\u0103", Abreve: "\u0102", ac: "\u223E", acd: "\u223F", acE: "\u223E\u0333", acirc: "\xE2", Acirc: "\xC2", acute: "\xB4", acy: "\u0430", Acy: "\u0410", aelig: "\xE6", AElig: "\xC6", af: "\u2061", afr: "\uD835\uDD1E", Afr: "\uD835\uDD04", agrave: "\xE0", Agrave: "\xC0", alefsym: "\u2135", aleph: "\u2135", alpha: "\u03B1", Alpha: "\u0391", amacr: "\u0101", Amacr: "\u0100", amalg: "\u2A3F", amp: "&", AMP: "&", and: "\u2227", And: "\u2A53", andand: "\u2A55", andd: "\u2A5C", andslope: "\u2A58", andv: "\u2A5A", ang: "\u2220", ange: "\u29A4", angle: "\u2220", angmsd: "\u2221", angmsdaa: "\u29A8", angmsdab: "\u29A9", angmsdac: "\u29AA", angmsdad: "\u29AB", angmsdae: "\u29AC", angmsdaf: "\u29AD", angmsdag: "\u29AE", angmsdah: "\u29AF", angrt: "\u221F", angrtvb: "\u22BE", angrtvbd: "\u299D", angsph: "\u2222", angst: "\xC5", angzarr: "\u237C", aogon: "\u0105", Aogon: "\u0104", aopf: "\uD835\uDD52", Aopf: "\uD835\uDD38", ap: "\u2248", apacir: "\u2A6F", ape: "\u224A", apE: "\u2A70", apid: "\u224B", apos: "'", ApplyFunction: "\u2061", approx: "\u2248", approxeq: "\u224A", aring: "\xE5", Aring: "\xC5", ascr: "\uD835\uDCB6", Ascr: "\uD835\uDC9C", Assign: "\u2254", ast: "*", asymp: "\u2248", asympeq: "\u224D", atilde: "\xE3", Atilde: "\xC3", auml: "\xE4", Auml: "\xC4", awconint: "\u2233", awint: "\u2A11", backcong: "\u224C", backepsilon: "\u03F6", backprime: "\u2035", backsim: "\u223D", backsimeq: "\u22CD", Backslash: "\u2216", Barv: "\u2AE7", barvee: "\u22BD", barwed: "\u2305", Barwed: "\u2306", barwedge: "\u2305", bbrk: "\u23B5", bbrktbrk: "\u23B6", bcong: "\u224C", bcy: "\u0431", Bcy: "\u0411", bdquo: "\u201E", becaus: "\u2235", because: "\u2235", Because: "\u2235", bemptyv: "\u29B0", bepsi: "\u03F6", bernou: "\u212C", Bernoullis: "\u212C", beta: "\u03B2", Beta: "\u0392", beth: "\u2136", between: "\u226C", bfr: "\uD835\uDD1F", Bfr: "\uD835\uDD05", bigcap: "\u22C2", bigcirc: "\u25EF", bigcup: "\u22C3", bigodot: "\u2A00", bigoplus: "\u2A01", bigotimes: "\u2A02", bigsqcup: "\u2A06", bigstar: "\u2605", bigtriangledown: "\u25BD", bigtriangleup: "\u25B3", biguplus: "\u2A04", bigvee: "\u22C1", bigwedge: "\u22C0", bkarow: "\u290D", blacklozenge: "\u29EB", blacksquare: "\u25AA", blacktriangle: "\u25B4", blacktriangledown: "\u25BE", blacktriangleleft: "\u25C2", blacktriangleright: "\u25B8", blank: "\u2423", blk12: "\u2592", blk14: "\u2591", blk34: "\u2593", block: "\u2588", bne: "=\u20E5", bnequiv: "\u2261\u20E5", bnot: "\u2310", bNot: "\u2AED", bopf: "\uD835\uDD53", Bopf: "\uD835\uDD39", bot: "\u22A5", bottom: "\u22A5", bowtie: "\u22C8", boxbox: "\u29C9", boxdl: "\u2510", boxdL: "\u2555", boxDl: "\u2556", boxDL: "\u2557", boxdr: "\u250C", boxdR: "\u2552", boxDr: "\u2553", boxDR: "\u2554", boxh: "\u2500", boxH: "\u2550", boxhd: "\u252C", boxhD: "\u2565", boxHd: "\u2564", boxHD: "\u2566", boxhu: "\u2534", boxhU: "\u2568", boxHu: "\u2567", boxHU: "\u2569", boxminus: "\u229F", boxplus: "\u229E", boxtimes: "\u22A0", boxul: "\u2518", boxuL: "\u255B", boxUl: "\u255C", boxUL: "\u255D", boxur: "\u2514", boxuR: "\u2558", boxUr: "\u2559", boxUR: "\u255A", boxv: "\u2502", boxV: "\u2551", boxvh: "\u253C", boxvH: "\u256A", boxVh: "\u256B", boxVH: "\u256C", boxvl: "\u2524", boxvL: "\u2561", boxVl: "\u2562", boxVL: "\u2563", boxvr: "\u251C", boxvR: "\u255E", boxVr: "\u255F", boxVR: "\u2560", bprime: "\u2035", breve: "\u02D8", Breve: "\u02D8", brvbar: "\xA6", bscr: "\uD835\uDCB7", Bscr: "\u212C", bsemi: "\u204F", bsim: "\u223D", bsime: "\u22CD", bsol: "\\", bsolb: "\u29C5", bsolhsub: "\u27C8", bull: "\u2022", bullet: "\u2022", bump: "\u224E", bumpe: "\u224F", bumpE: "\u2AAE", bumpeq: "\u224F", Bumpeq: "\u224E", cacute: "\u0107", Cacute: "\u0106", cap: "\u2229", Cap: "\u22D2", capand: "\u2A44", capbrcup: "\u2A49", capcap: "\u2A4B", capcup: "\u2A47", capdot: "\u2A40", CapitalDifferentialD: "\u2145", caps: "\u2229\uFE00", caret: "\u2041", caron: "\u02C7", Cayleys: "\u212D", ccaps: "\u2A4D", ccaron: "\u010D", Ccaron: "\u010C", ccedil: "\xE7", Ccedil: "\xC7", ccirc: "\u0109", Ccirc: "\u0108", Cconint: "\u2230", ccups: "\u2A4C", ccupssm: "\u2A50", cdot: "\u010B", Cdot: "\u010A", cedil: "\xB8", Cedilla: "\xB8", cemptyv: "\u29B2", cent: "\xA2", centerdot: "\xB7", CenterDot: "\xB7", cfr: "\uD835\uDD20", Cfr: "\u212D", chcy: "\u0447", CHcy: "\u0427", check: "\u2713", checkmark: "\u2713", chi: "\u03C7", Chi: "\u03A7", cir: "\u25CB", circ: "\u02C6", circeq: "\u2257", circlearrowleft: "\u21BA", circlearrowright: "\u21BB", circledast: "\u229B", circledcirc: "\u229A", circleddash: "\u229D", CircleDot: "\u2299", circledR: "\xAE", circledS: "\u24C8", CircleMinus: "\u2296", CirclePlus: "\u2295", CircleTimes: "\u2297", cire: "\u2257", cirE: "\u29C3", cirfnint: "\u2A10", cirmid: "\u2AEF", cirscir: "\u29C2", ClockwiseContourIntegral: "\u2232", CloseCurlyDoubleQuote: "\u201D", CloseCurlyQuote: "\u2019", clubs: "\u2663", clubsuit: "\u2663", colon: ":", Colon: "\u2237", colone: "\u2254", Colone: "\u2A74", coloneq: "\u2254", comma: ",", commat: "@", comp: "\u2201", compfn: "\u2218", complement: "\u2201", complexes: "\u2102", cong: "\u2245", congdot: "\u2A6D", Congruent: "\u2261", conint: "\u222E", Conint: "\u222F", ContourIntegral: "\u222E", copf: "\uD835\uDD54", Copf: "\u2102", coprod: "\u2210", Coproduct: "\u2210", copy: "\xA9", COPY: "\xA9", copysr: "\u2117", CounterClockwiseContourIntegral: "\u2233", crarr: "\u21B5", cross: "\u2717", Cross: "\u2A2F", cscr: "\uD835\uDCB8", Cscr: "\uD835\uDC9E", csub: "\u2ACF", csube: "\u2AD1", csup: "\u2AD0", csupe: "\u2AD2", ctdot: "\u22EF", cudarrl: "\u2938", cudarrr: "\u2935", cuepr: "\u22DE", cuesc: "\u22DF", cularr: "\u21B6", cularrp: "\u293D", cup: "\u222A", Cup: "\u22D3", cupbrcap: "\u2A48", cupcap: "\u2A46", CupCap: "\u224D", cupcup: "\u2A4A", cupdot: "\u228D", cupor: "\u2A45", cups: "\u222A\uFE00", curarr: "\u21B7", curarrm: "\u293C", curlyeqprec: "\u22DE", curlyeqsucc: "\u22DF", curlyvee: "\u22CE", curlywedge: "\u22CF", curren: "\xA4", curvearrowleft: "\u21B6", curvearrowright: "\u21B7", cuvee: "\u22CE", cuwed: "\u22CF", cwconint: "\u2232", cwint: "\u2231", cylcty: "\u232D", dagger: "\u2020", Dagger: "\u2021", daleth: "\u2138", darr: "\u2193", dArr: "\u21D3", Darr: "\u21A1", dash: "\u2010", dashv: "\u22A3", Dashv: "\u2AE4", dbkarow: "\u290F", dblac: "\u02DD", dcaron: "\u010F", Dcaron: "\u010E", dcy: "\u0434", Dcy: "\u0414", dd: "\u2146", DD: "\u2145", ddagger: "\u2021", ddarr: "\u21CA", DDotrahd: "\u2911", ddotseq: "\u2A77", deg: "\xB0", Del: "\u2207", delta: "\u03B4", Delta: "\u0394", demptyv: "\u29B1", dfisht: "\u297F", dfr: "\uD835\uDD21", Dfr: "\uD835\uDD07", dHar: "\u2965", dharl: "\u21C3", dharr: "\u21C2", DiacriticalAcute: "\xB4", DiacriticalDot: "\u02D9", DiacriticalDoubleAcute: "\u02DD", DiacriticalGrave: "`", DiacriticalTilde: "\u02DC", diam: "\u22C4", diamond: "\u22C4", Diamond: "\u22C4", diamondsuit: "\u2666", diams: "\u2666", die: "\xA8", DifferentialD: "\u2146", digamma: "\u03DD", disin: "\u22F2", div: "\xF7", divide: "\xF7", divideontimes: "\u22C7", divonx: "\u22C7", djcy: "\u0452", DJcy: "\u0402", dlcorn: "\u231E", dlcrop: "\u230D", dollar: "$", dopf: "\uD835\uDD55", Dopf: "\uD835\uDD3B", dot: "\u02D9", Dot: "\xA8", DotDot: "\u20DC", doteq: "\u2250", doteqdot: "\u2251", DotEqual: "\u2250", dotminus: "\u2238", dotplus: "\u2214", dotsquare: "\u22A1", doublebarwedge: "\u2306", DoubleContourIntegral: "\u222F", DoubleDot: "\xA8", DoubleDownArrow: "\u21D3", DoubleLeftArrow: "\u21D0", DoubleLeftRightArrow: "\u21D4", DoubleLeftTee: "\u2AE4", DoubleLongLeftArrow: "\u27F8", DoubleLongLeftRightArrow: "\u27FA", DoubleLongRightArrow: "\u27F9", DoubleRightArrow: "\u21D2", DoubleRightTee: "\u22A8", DoubleUpArrow: "\u21D1", DoubleUpDownArrow: "\u21D5", DoubleVerticalBar: "\u2225", downarrow: "\u2193", Downarrow: "\u21D3", DownArrow: "\u2193", DownArrowBar: "\u2913", DownArrowUpArrow: "\u21F5", DownBreve: "\u0311", downdownarrows: "\u21CA", downharpoonleft: "\u21C3", downharpoonright: "\u21C2", DownLeftRightVector: "\u2950", DownLeftTeeVector: "\u295E", DownLeftVector: "\u21BD", DownLeftVectorBar: "\u2956", DownRightTeeVector: "\u295F", DownRightVector: "\u21C1", DownRightVectorBar: "\u2957", DownTee: "\u22A4", DownTeeArrow: "\u21A7", drbkarow: "\u2910", drcorn: "\u231F", drcrop: "\u230C", dscr: "\uD835\uDCB9", Dscr: "\uD835\uDC9F", dscy: "\u0455", DScy: "\u0405", dsol: "\u29F6", dstrok: "\u0111", Dstrok: "\u0110", dtdot: "\u22F1", dtri: "\u25BF", dtrif: "\u25BE", duarr: "\u21F5", duhar: "\u296F", dwangle: "\u29A6", dzcy: "\u045F", DZcy: "\u040F", dzigrarr: "\u27FF", eacute: "\xE9", Eacute: "\xC9", easter: "\u2A6E", ecaron: "\u011B", Ecaron: "\u011A", ecir: "\u2256", ecirc: "\xEA", Ecirc: "\xCA", ecolon: "\u2255", ecy: "\u044D", Ecy: "\u042D", eDDot: "\u2A77", edot: "\u0117", eDot: "\u2251", Edot: "\u0116", ee: "\u2147", efDot: "\u2252", efr: "\uD835\uDD22", Efr: "\uD835\uDD08", eg: "\u2A9A", egrave: "\xE8", Egrave: "\xC8", egs: "\u2A96", egsdot: "\u2A98", el: "\u2A99", Element: "\u2208", elinters: "\u23E7", ell: "\u2113", els: "\u2A95", elsdot: "\u2A97", emacr: "\u0113", Emacr: "\u0112", empty: "\u2205", emptyset: "\u2205", EmptySmallSquare: "\u25FB", emptyv: "\u2205", EmptyVerySmallSquare: "\u25AB", emsp: "\u2003", emsp13: "\u2004", emsp14: "\u2005", eng: "\u014B", ENG: "\u014A", ensp: "\u2002", eogon: "\u0119", Eogon: "\u0118", eopf: "\uD835\uDD56", Eopf: "\uD835\uDD3C", epar: "\u22D5", eparsl: "\u29E3", eplus: "\u2A71", epsi: "\u03B5", epsilon: "\u03B5", Epsilon: "\u0395", epsiv: "\u03F5", eqcirc: "\u2256", eqcolon: "\u2255", eqsim: "\u2242", eqslantgtr: "\u2A96", eqslantless: "\u2A95", Equal: "\u2A75", equals: "=", EqualTilde: "\u2242", equest: "\u225F", Equilibrium: "\u21CC", equiv: "\u2261", equivDD: "\u2A78", eqvparsl: "\u29E5", erarr: "\u2971", erDot: "\u2253", escr: "\u212F", Escr: "\u2130", esdot: "\u2250", esim: "\u2242", Esim: "\u2A73", eta: "\u03B7", Eta: "\u0397", eth: "\xF0", ETH: "\xD0", euml: "\xEB", Euml: "\xCB", euro: "\u20AC", excl: "!", exist: "\u2203", Exists: "\u2203", expectation: "\u2130", exponentiale: "\u2147", ExponentialE: "\u2147", fallingdotseq: "\u2252", fcy: "\u0444", Fcy: "\u0424", female: "\u2640", ffilig: "\uFB03", fflig: "\uFB00", ffllig: "\uFB04", ffr: "\uD835\uDD23", Ffr: "\uD835\uDD09", filig: "\uFB01", FilledSmallSquare: "\u25FC", FilledVerySmallSquare: "\u25AA", fjlig: "fj", flat: "\u266D", fllig: "\uFB02", fltns: "\u25B1", fnof: "\u0192", fopf: "\uD835\uDD57", Fopf: "\uD835\uDD3D", forall: "\u2200", ForAll: "\u2200", fork: "\u22D4", forkv: "\u2AD9", Fouriertrf: "\u2131", fpartint: "\u2A0D", frac12: "\xBD", frac13: "\u2153", frac14: "\xBC", frac15: "\u2155", frac16: "\u2159", frac18: "\u215B", frac23: "\u2154", frac25: "\u2156", frac34: "\xBE", frac35: "\u2157", frac38: "\u215C", frac45: "\u2158", frac56: "\u215A", frac58: "\u215D", frac78: "\u215E", frasl: "\u2044", frown: "\u2322", fscr: "\uD835\uDCBB", Fscr: "\u2131", gacute: "\u01F5", gamma: "\u03B3", Gamma: "\u0393", gammad: "\u03DD", Gammad: "\u03DC", gap: "\u2A86", gbreve: "\u011F", Gbreve: "\u011E", Gcedil: "\u0122", gcirc: "\u011D", Gcirc: "\u011C", gcy: "\u0433", Gcy: "\u0413", gdot: "\u0121", Gdot: "\u0120", ge: "\u2265", gE: "\u2267", gel: "\u22DB", gEl: "\u2A8C", geq: "\u2265", geqq: "\u2267", geqslant: "\u2A7E", ges: "\u2A7E", gescc: "\u2AA9", gesdot: "\u2A80", gesdoto: "\u2A82", gesdotol: "\u2A84", gesl: "\u22DB\uFE00", gesles: "\u2A94", gfr: "\uD835\uDD24", Gfr: "\uD835\uDD0A", gg: "\u226B", Gg: "\u22D9", ggg: "\u22D9", gimel: "\u2137", gjcy: "\u0453", GJcy: "\u0403", gl: "\u2277", gla: "\u2AA5", glE: "\u2A92", glj: "\u2AA4", gnap: "\u2A8A", gnapprox: "\u2A8A", gne: "\u2A88", gnE: "\u2269", gneq: "\u2A88", gneqq: "\u2269", gnsim: "\u22E7", gopf: "\uD835\uDD58", Gopf: "\uD835\uDD3E", grave: "`", GreaterEqual: "\u2265", GreaterEqualLess: "\u22DB", GreaterFullEqual: "\u2267", GreaterGreater: "\u2AA2", GreaterLess: "\u2277", GreaterSlantEqual: "\u2A7E", GreaterTilde: "\u2273", gscr: "\u210A", Gscr: "\uD835\uDCA2", gsim: "\u2273", gsime: "\u2A8E", gsiml: "\u2A90", gt: ">", Gt: "\u226B", GT: ">", gtcc: "\u2AA7", gtcir: "\u2A7A", gtdot: "\u22D7", gtlPar: "\u2995", gtquest: "\u2A7C", gtrapprox: "\u2A86", gtrarr: "\u2978", gtrdot: "\u22D7", gtreqless: "\u22DB", gtreqqless: "\u2A8C", gtrless: "\u2277", gtrsim: "\u2273", gvertneqq: "\u2269\uFE00", gvnE: "\u2269\uFE00", Hacek: "\u02C7", hairsp: "\u200A", half: "\xBD", hamilt: "\u210B", hardcy: "\u044A", HARDcy: "\u042A", harr: "\u2194", hArr: "\u21D4", harrcir: "\u2948", harrw: "\u21AD", Hat: "^", hbar: "\u210F", hcirc: "\u0125", Hcirc: "\u0124", hearts: "\u2665", heartsuit: "\u2665", hellip: "\u2026", hercon: "\u22B9", hfr: "\uD835\uDD25", Hfr: "\u210C", HilbertSpace: "\u210B", hksearow: "\u2925", hkswarow: "\u2926", hoarr: "\u21FF", homtht: "\u223B", hookleftarrow: "\u21A9", hookrightarrow: "\u21AA", hopf: "\uD835\uDD59", Hopf: "\u210D", horbar: "\u2015", HorizontalLine: "\u2500", hscr: "\uD835\uDCBD", Hscr: "\u210B", hslash: "\u210F", hstrok: "\u0127", Hstrok: "\u0126", HumpDownHump: "\u224E", HumpEqual: "\u224F", hybull: "\u2043", hyphen: "\u2010", iacute: "\xED", Iacute: "\xCD", ic: "\u2063", icirc: "\xEE", Icirc: "\xCE", icy: "\u0438", Icy: "\u0418", Idot: "\u0130", iecy: "\u0435", IEcy: "\u0415", iexcl: "\xA1", iff: "\u21D4", ifr: "\uD835\uDD26", Ifr: "\u2111", igrave: "\xEC", Igrave: "\xCC", ii: "\u2148", iiiint: "\u2A0C", iiint: "\u222D", iinfin: "\u29DC", iiota: "\u2129", ijlig: "\u0133", IJlig: "\u0132", Im: "\u2111", imacr: "\u012B", Imacr: "\u012A", image: "\u2111", ImaginaryI: "\u2148", imagline: "\u2110", imagpart: "\u2111", imath: "\u0131", imof: "\u22B7", imped: "\u01B5", Implies: "\u21D2", in: "\u2208", incare: "\u2105", infin: "\u221E", infintie: "\u29DD", inodot: "\u0131", int: "\u222B", Int: "\u222C", intcal: "\u22BA", integers: "\u2124", Integral: "\u222B", intercal: "\u22BA", Intersection: "\u22C2", intlarhk: "\u2A17", intprod: "\u2A3C", InvisibleComma: "\u2063", InvisibleTimes: "\u2062", iocy: "\u0451", IOcy: "\u0401", iogon: "\u012F", Iogon: "\u012E", iopf: "\uD835\uDD5A", Iopf: "\uD835\uDD40", iota: "\u03B9", Iota: "\u0399", iprod: "\u2A3C", iquest: "\xBF", iscr: "\uD835\uDCBE", Iscr: "\u2110", isin: "\u2208", isindot: "\u22F5", isinE: "\u22F9", isins: "\u22F4", isinsv: "\u22F3", isinv: "\u2208", it: "\u2062", itilde: "\u0129", Itilde: "\u0128", iukcy: "\u0456", Iukcy: "\u0406", iuml: "\xEF", Iuml: "\xCF", jcirc: "\u0135", Jcirc: "\u0134", jcy: "\u0439", Jcy: "\u0419", jfr: "\uD835\uDD27", Jfr: "\uD835\uDD0D", jmath: "\u0237", jopf: "\uD835\uDD5B", Jopf: "\uD835\uDD41", jscr: "\uD835\uDCBF", Jscr: "\uD835\uDCA5", jsercy: "\u0458", Jsercy: "\u0408", jukcy: "\u0454", Jukcy: "\u0404", kappa: "\u03BA", Kappa: "\u039A", kappav: "\u03F0", kcedil: "\u0137", Kcedil: "\u0136", kcy: "\u043A", Kcy: "\u041A", kfr: "\uD835\uDD28", Kfr: "\uD835\uDD0E", kgreen: "\u0138", khcy: "\u0445", KHcy: "\u0425", kjcy: "\u045C", KJcy: "\u040C", kopf: "\uD835\uDD5C", Kopf: "\uD835\uDD42", kscr: "\uD835\uDCC0", Kscr: "\uD835\uDCA6", lAarr: "\u21DA", lacute: "\u013A", Lacute: "\u0139", laemptyv: "\u29B4", lagran: "\u2112", lambda: "\u03BB", Lambda: "\u039B", lang: "\u27E8", Lang: "\u27EA", langd: "\u2991", langle: "\u27E8", lap: "\u2A85", Laplacetrf: "\u2112", laquo: "\xAB", larr: "\u2190", lArr: "\u21D0", Larr: "\u219E", larrb: "\u21E4", larrbfs: "\u291F", larrfs: "\u291D", larrhk: "\u21A9", larrlp: "\u21AB", larrpl: "\u2939", larrsim: "\u2973", larrtl: "\u21A2", lat: "\u2AAB", latail: "\u2919", lAtail: "\u291B", late: "\u2AAD", lates: "\u2AAD\uFE00", lbarr: "\u290C", lBarr: "\u290E", lbbrk: "\u2772", lbrace: "{", lbrack: "[", lbrke: "\u298B", lbrksld: "\u298F", lbrkslu: "\u298D", lcaron: "\u013E", Lcaron: "\u013D", lcedil: "\u013C", Lcedil: "\u013B", lceil: "\u2308", lcub: "{", lcy: "\u043B", Lcy: "\u041B", ldca: "\u2936", ldquo: "\u201C", ldquor: "\u201E", ldrdhar: "\u2967", ldrushar: "\u294B", ldsh: "\u21B2", le: "\u2264", lE: "\u2266", LeftAngleBracket: "\u27E8", leftarrow: "\u2190", Leftarrow: "\u21D0", LeftArrow: "\u2190", LeftArrowBar: "\u21E4", LeftArrowRightArrow: "\u21C6", leftarrowtail: "\u21A2", LeftCeiling: "\u2308", LeftDoubleBracket: "\u27E6", LeftDownTeeVector: "\u2961", LeftDownVector: "\u21C3", LeftDownVectorBar: "\u2959", LeftFloor: "\u230A", leftharpoondown: "\u21BD", leftharpoonup: "\u21BC", leftleftarrows: "\u21C7", leftrightarrow: "\u2194", Leftrightarrow: "\u21D4", LeftRightArrow: "\u2194", leftrightarrows: "\u21C6", leftrightharpoons: "\u21CB", leftrightsquigarrow: "\u21AD", LeftRightVector: "\u294E", LeftTee: "\u22A3", LeftTeeArrow: "\u21A4", LeftTeeVector: "\u295A", leftthreetimes: "\u22CB", LeftTriangle: "\u22B2", LeftTriangleBar: "\u29CF", LeftTriangleEqual: "\u22B4", LeftUpDownVector: "\u2951", LeftUpTeeVector: "\u2960", LeftUpVector: "\u21BF", LeftUpVectorBar: "\u2958", LeftVector: "\u21BC", LeftVectorBar: "\u2952", leg: "\u22DA", lEg: "\u2A8B", leq: "\u2264", leqq: "\u2266", leqslant: "\u2A7D", les: "\u2A7D", lescc: "\u2AA8", lesdot: "\u2A7F", lesdoto: "\u2A81", lesdotor: "\u2A83", lesg: "\u22DA\uFE00", lesges: "\u2A93", lessapprox: "\u2A85", lessdot: "\u22D6", lesseqgtr: "\u22DA", lesseqqgtr: "\u2A8B", LessEqualGreater: "\u22DA", LessFullEqual: "\u2266", LessGreater: "\u2276", lessgtr: "\u2276", LessLess: "\u2AA1", lesssim: "\u2272", LessSlantEqual: "\u2A7D", LessTilde: "\u2272", lfisht: "\u297C", lfloor: "\u230A", lfr: "\uD835\uDD29", Lfr: "\uD835\uDD0F", lg: "\u2276", lgE: "\u2A91", lHar: "\u2962", lhard: "\u21BD", lharu: "\u21BC", lharul: "\u296A", lhblk: "\u2584", ljcy: "\u0459", LJcy: "\u0409", ll: "\u226A", Ll: "\u22D8", llarr: "\u21C7", llcorner: "\u231E", Lleftarrow: "\u21DA", llhard: "\u296B", lltri: "\u25FA", lmidot: "\u0140", Lmidot: "\u013F", lmoust: "\u23B0", lmoustache: "\u23B0", lnap: "\u2A89", lnapprox: "\u2A89", lne: "\u2A87", lnE: "\u2268", lneq: "\u2A87", lneqq: "\u2268", lnsim: "\u22E6", loang: "\u27EC", loarr: "\u21FD", lobrk: "\u27E6", longleftarrow: "\u27F5", Longleftarrow: "\u27F8", LongLeftArrow: "\u27F5", longleftrightarrow: "\u27F7", Longleftrightarrow: "\u27FA", LongLeftRightArrow: "\u27F7", longmapsto: "\u27FC", longrightarrow: "\u27F6", Longrightarrow: "\u27F9", LongRightArrow: "\u27F6", looparrowleft: "\u21AB", looparrowright: "\u21AC", lopar: "\u2985", lopf: "\uD835\uDD5D", Lopf: "\uD835\uDD43", loplus: "\u2A2D", lotimes: "\u2A34", lowast: "\u2217", lowbar: "_", LowerLeftArrow: "\u2199", LowerRightArrow: "\u2198", loz: "\u25CA", lozenge: "\u25CA", lozf: "\u29EB", lpar: "(", lparlt: "\u2993", lrarr: "\u21C6", lrcorner: "\u231F", lrhar: "\u21CB", lrhard: "\u296D", lrm: "\u200E", lrtri: "\u22BF", lsaquo: "\u2039", lscr: "\uD835\uDCC1", Lscr: "\u2112", lsh: "\u21B0", Lsh: "\u21B0", lsim: "\u2272", lsime: "\u2A8D", lsimg: "\u2A8F", lsqb: "[", lsquo: "\u2018", lsquor: "\u201A", lstrok: "\u0142", Lstrok: "\u0141", lt: "<", Lt: "\u226A", LT: "<", ltcc: "\u2AA6", ltcir: "\u2A79", ltdot: "\u22D6", lthree: "\u22CB", ltimes: "\u22C9", ltlarr: "\u2976", ltquest: "\u2A7B", ltri: "\u25C3", ltrie: "\u22B4", ltrif: "\u25C2", ltrPar: "\u2996", lurdshar: "\u294A", luruhar: "\u2966", lvertneqq: "\u2268\uFE00", lvnE: "\u2268\uFE00", macr: "\xAF", male: "\u2642", malt: "\u2720", maltese: "\u2720", map: "\u21A6", Map: "\u2905", mapsto: "\u21A6", mapstodown: "\u21A7", mapstoleft: "\u21A4", mapstoup: "\u21A5", marker: "\u25AE", mcomma: "\u2A29", mcy: "\u043C", Mcy: "\u041C", mdash: "\u2014", mDDot: "\u223A", measuredangle: "\u2221", MediumSpace: "\u205F", Mellintrf: "\u2133", mfr: "\uD835\uDD2A", Mfr: "\uD835\uDD10", mho: "\u2127", micro: "\xB5", mid: "\u2223", midast: "*", midcir: "\u2AF0", middot: "\xB7", minus: "\u2212", minusb: "\u229F", minusd: "\u2238", minusdu: "\u2A2A", MinusPlus: "\u2213", mlcp: "\u2ADB", mldr: "\u2026", mnplus: "\u2213", models: "\u22A7", mopf: "\uD835\uDD5E", Mopf: "\uD835\uDD44", mp: "\u2213", mscr: "\uD835\uDCC2", Mscr: "\u2133", mstpos: "\u223E", mu: "\u03BC", Mu: "\u039C", multimap: "\u22B8", mumap: "\u22B8", nabla: "\u2207", nacute: "\u0144", Nacute: "\u0143", nang: "\u2220\u20D2", nap: "\u2249", napE: "\u2A70\u0338", napid: "\u224B\u0338", napos: "\u0149", napprox: "\u2249", natur: "\u266E", natural: "\u266E", naturals: "\u2115", nbsp: "\xA0", nbump: "\u224E\u0338", nbumpe: "\u224F\u0338", ncap: "\u2A43", ncaron: "\u0148", Ncaron: "\u0147", ncedil: "\u0146", Ncedil: "\u0145", ncong: "\u2247", ncongdot: "\u2A6D\u0338", ncup: "\u2A42", ncy: "\u043D", Ncy: "\u041D", ndash: "\u2013", ne: "\u2260", nearhk: "\u2924", nearr: "\u2197", neArr: "\u21D7", nearrow: "\u2197", nedot: "\u2250\u0338", NegativeMediumSpace: "\u200B", NegativeThickSpace: "\u200B", NegativeThinSpace: "\u200B", NegativeVeryThinSpace: "\u200B", nequiv: "\u2262", nesear: "\u2928", nesim: "\u2242\u0338", NestedGreaterGreater: "\u226B", NestedLessLess: "\u226A", NewLine: "\n", nexist: "\u2204", nexists: "\u2204", nfr: "\uD835\uDD2B", Nfr: "\uD835\uDD11", nge: "\u2271", ngE: "\u2267\u0338", ngeq: "\u2271", ngeqq: "\u2267\u0338", ngeqslant: "\u2A7E\u0338", nges: "\u2A7E\u0338", nGg: "\u22D9\u0338", ngsim: "\u2275", ngt: "\u226F", nGt: "\u226B\u20D2", ngtr: "\u226F", nGtv: "\u226B\u0338", nharr: "\u21AE", nhArr: "\u21CE", nhpar: "\u2AF2", ni: "\u220B", nis: "\u22FC", nisd: "\u22FA", niv: "\u220B", njcy: "\u045A", NJcy: "\u040A", nlarr: "\u219A", nlArr: "\u21CD", nldr: "\u2025", nle: "\u2270", nlE: "\u2266\u0338", nleftarrow: "\u219A", nLeftarrow: "\u21CD", nleftrightarrow: "\u21AE", nLeftrightarrow: "\u21CE", nleq: "\u2270", nleqq: "\u2266\u0338", nleqslant: "\u2A7D\u0338", nles: "\u2A7D\u0338", nless: "\u226E", nLl: "\u22D8\u0338", nlsim: "\u2274", nlt: "\u226E", nLt: "\u226A\u20D2", nltri: "\u22EA", nltrie: "\u22EC", nLtv: "\u226A\u0338", nmid: "\u2224", NoBreak: "\u2060", NonBreakingSpace: "\xA0", nopf: "\uD835\uDD5F", Nopf: "\u2115", not: "\xAC", Not: "\u2AEC", NotCongruent: "\u2262", NotCupCap: "\u226D", NotDoubleVerticalBar: "\u2226", NotElement: "\u2209", NotEqual: "\u2260", NotEqualTilde: "\u2242\u0338", NotExists: "\u2204", NotGreater: "\u226F", NotGreaterEqual: "\u2271", NotGreaterFullEqual: "\u2267\u0338", NotGreaterGreater: "\u226B\u0338", NotGreaterLess: "\u2279", NotGreaterSlantEqual: "\u2A7E\u0338", NotGreaterTilde: "\u2275", NotHumpDownHump: "\u224E\u0338", NotHumpEqual: "\u224F\u0338", notin: "\u2209", notindot: "\u22F5\u0338", notinE: "\u22F9\u0338", notinva: "\u2209", notinvb: "\u22F7", notinvc: "\u22F6", NotLeftTriangle: "\u22EA", NotLeftTriangleBar: "\u29CF\u0338", NotLeftTriangleEqual: "\u22EC", NotLess: "\u226E", NotLessEqual: "\u2270", NotLessGreater: "\u2278", NotLessLess: "\u226A\u0338", NotLessSlantEqual: "\u2A7D\u0338", NotLessTilde: "\u2274", NotNestedGreaterGreater: "\u2AA2\u0338", NotNestedLessLess: "\u2AA1\u0338", notni: "\u220C", notniva: "\u220C", notnivb: "\u22FE", notnivc: "\u22FD", NotPrecedes: "\u2280", NotPrecedesEqual: "\u2AAF\u0338", NotPrecedesSlantEqual: "\u22E0", NotReverseElement: "\u220C", NotRightTriangle: "\u22EB", NotRightTriangleBar: "\u29D0\u0338", NotRightTriangleEqual: "\u22ED", NotSquareSubset: "\u228F\u0338", NotSquareSubsetEqual: "\u22E2", NotSquareSuperset: "\u2290\u0338", NotSquareSupersetEqual: "\u22E3", NotSubset: "\u2282\u20D2", NotSubsetEqual: "\u2288", NotSucceeds: "\u2281", NotSucceedsEqual: "\u2AB0\u0338", NotSucceedsSlantEqual: "\u22E1", NotSucceedsTilde: "\u227F\u0338", NotSuperset: "\u2283\u20D2", NotSupersetEqual: "\u2289", NotTilde: "\u2241", NotTildeEqual: "\u2244", NotTildeFullEqual: "\u2247", NotTildeTilde: "\u2249", NotVerticalBar: "\u2224", npar: "\u2226", nparallel: "\u2226", nparsl: "\u2AFD\u20E5", npart: "\u2202\u0338", npolint: "\u2A14", npr: "\u2280", nprcue: "\u22E0", npre: "\u2AAF\u0338", nprec: "\u2280", npreceq: "\u2AAF\u0338", nrarr: "\u219B", nrArr: "\u21CF", nrarrc: "\u2933\u0338", nrarrw: "\u219D\u0338", nrightarrow: "\u219B", nRightarrow: "\u21CF", nrtri: "\u22EB", nrtrie: "\u22ED", nsc: "\u2281", nsccue: "\u22E1", nsce: "\u2AB0\u0338", nscr: "\uD835\uDCC3", Nscr: "\uD835\uDCA9", nshortmid: "\u2224", nshortparallel: "\u2226", nsim: "\u2241", nsime: "\u2244", nsimeq: "\u2244", nsmid: "\u2224", nspar: "\u2226", nsqsube: "\u22E2", nsqsupe: "\u22E3", nsub: "\u2284", nsube: "\u2288", nsubE: "\u2AC5\u0338", nsubset: "\u2282\u20D2", nsubseteq: "\u2288", nsubseteqq: "\u2AC5\u0338", nsucc: "\u2281", nsucceq: "\u2AB0\u0338", nsup: "\u2285", nsupe: "\u2289", nsupE: "\u2AC6\u0338", nsupset: "\u2283\u20D2", nsupseteq: "\u2289", nsupseteqq: "\u2AC6\u0338", ntgl: "\u2279", ntilde: "\xF1", Ntilde: "\xD1", ntlg: "\u2278", ntriangleleft: "\u22EA", ntrianglelefteq: "\u22EC", ntriangleright: "\u22EB", ntrianglerighteq: "\u22ED", nu: "\u03BD", Nu: "\u039D", num: "#", numero: "\u2116", numsp: "\u2007", nvap: "\u224D\u20D2", nvdash: "\u22AC", nvDash: "\u22AD", nVdash: "\u22AE", nVDash: "\u22AF", nvge: "\u2265\u20D2", nvgt: ">\u20D2", nvHarr: "\u2904", nvinfin: "\u29DE", nvlArr: "\u2902", nvle: "\u2264\u20D2", nvlt: "<\u20D2", nvltrie: "\u22B4\u20D2", nvrArr: "\u2903", nvrtrie: "\u22B5\u20D2", nvsim: "\u223C\u20D2", nwarhk: "\u2923", nwarr: "\u2196", nwArr: "\u21D6", nwarrow: "\u2196", nwnear: "\u2927", oacute: "\xF3", Oacute: "\xD3", oast: "\u229B", ocir: "\u229A", ocirc: "\xF4", Ocirc: "\xD4", ocy: "\u043E", Ocy: "\u041E", odash: "\u229D", odblac: "\u0151", Odblac: "\u0150", odiv: "\u2A38", odot: "\u2299", odsold: "\u29BC", oelig: "\u0153", OElig: "\u0152", ofcir: "\u29BF", ofr: "\uD835\uDD2C", Ofr: "\uD835\uDD12", ogon: "\u02DB", ograve: "\xF2", Ograve: "\xD2", ogt: "\u29C1", ohbar: "\u29B5", ohm: "\u03A9", oint: "\u222E", olarr: "\u21BA", olcir: "\u29BE", olcross: "\u29BB", oline: "\u203E", olt: "\u29C0", omacr: "\u014D", Omacr: "\u014C", omega: "\u03C9", Omega: "\u03A9", omicron: "\u03BF", Omicron: "\u039F", omid: "\u29B6", ominus: "\u2296", oopf: "\uD835\uDD60", Oopf: "\uD835\uDD46", opar: "\u29B7", OpenCurlyDoubleQuote: "\u201C", OpenCurlyQuote: "\u2018", operp: "\u29B9", oplus: "\u2295", or: "\u2228", Or: "\u2A54", orarr: "\u21BB", ord: "\u2A5D", order: "\u2134", orderof: "\u2134", ordf: "\xAA", ordm: "\xBA", origof: "\u22B6", oror: "\u2A56", orslope: "\u2A57", orv: "\u2A5B", oS: "\u24C8", oscr: "\u2134", Oscr: "\uD835\uDCAA", oslash: "\xF8", Oslash: "\xD8", osol: "\u2298", otilde: "\xF5", Otilde: "\xD5", otimes: "\u2297", Otimes: "\u2A37", otimesas: "\u2A36", ouml: "\xF6", Ouml: "\xD6", ovbar: "\u233D", OverBar: "\u203E", OverBrace: "\u23DE", OverBracket: "\u23B4", OverParenthesis: "\u23DC", par: "\u2225", para: "\xB6", parallel: "\u2225", parsim: "\u2AF3", parsl: "\u2AFD", part: "\u2202", PartialD: "\u2202", pcy: "\u043F", Pcy: "\u041F", percnt: "%", period: ".", permil: "\u2030", perp: "\u22A5", pertenk: "\u2031", pfr: "\uD835\uDD2D", Pfr: "\uD835\uDD13", phi: "\u03C6", Phi: "\u03A6", phiv: "\u03D5", phmmat: "\u2133", phone: "\u260E", pi: "\u03C0", Pi: "\u03A0", pitchfork: "\u22D4", piv: "\u03D6", planck: "\u210F", planckh: "\u210E", plankv: "\u210F", plus: "+", plusacir: "\u2A23", plusb: "\u229E", pluscir: "\u2A22", plusdo: "\u2214", plusdu: "\u2A25", pluse: "\u2A72", PlusMinus: "\xB1", plusmn: "\xB1", plussim: "\u2A26", plustwo: "\u2A27", pm: "\xB1", Poincareplane: "\u210C", pointint: "\u2A15", popf: "\uD835\uDD61", Popf: "\u2119", pound: "\xA3", pr: "\u227A", Pr: "\u2ABB", prap: "\u2AB7", prcue: "\u227C", pre: "\u2AAF", prE: "\u2AB3", prec: "\u227A", precapprox: "\u2AB7", preccurlyeq: "\u227C", Precedes: "\u227A", PrecedesEqual: "\u2AAF", PrecedesSlantEqual: "\u227C", PrecedesTilde: "\u227E", preceq: "\u2AAF", precnapprox: "\u2AB9", precneqq: "\u2AB5", precnsim: "\u22E8", precsim: "\u227E", prime: "\u2032", Prime: "\u2033", primes: "\u2119", prnap: "\u2AB9", prnE: "\u2AB5", prnsim: "\u22E8", prod: "\u220F", Product: "\u220F", profalar: "\u232E", profline: "\u2312", profsurf: "\u2313", prop: "\u221D", Proportion: "\u2237", Proportional: "\u221D", propto: "\u221D", prsim: "\u227E", prurel: "\u22B0", pscr: "\uD835\uDCC5", Pscr: "\uD835\uDCAB", psi: "\u03C8", Psi: "\u03A8", puncsp: "\u2008", qfr: "\uD835\uDD2E", Qfr: "\uD835\uDD14", qint: "\u2A0C", qopf: "\uD835\uDD62", Qopf: "\u211A", qprime: "\u2057", qscr: "\uD835\uDCC6", Qscr: "\uD835\uDCAC", quaternions: "\u210D", quatint: "\u2A16", quest: "?", questeq: "\u225F", quot: '"', QUOT: '"', rAarr: "\u21DB", race: "\u223D\u0331", racute: "\u0155", Racute: "\u0154", radic: "\u221A", raemptyv: "\u29B3", rang: "\u27E9", Rang: "\u27EB", rangd: "\u2992", range: "\u29A5", rangle: "\u27E9", raquo: "\xBB", rarr: "\u2192", rArr: "\u21D2", Rarr: "\u21A0", rarrap: "\u2975", rarrb: "\u21E5", rarrbfs: "\u2920", rarrc: "\u2933", rarrfs: "\u291E", rarrhk: "\u21AA", rarrlp: "\u21AC", rarrpl: "\u2945", rarrsim: "\u2974", rarrtl: "\u21A3", Rarrtl: "\u2916", rarrw: "\u219D", ratail: "\u291A", rAtail: "\u291C", ratio: "\u2236", rationals: "\u211A", rbarr: "\u290D", rBarr: "\u290F", RBarr: "\u2910", rbbrk: "\u2773", rbrace: "}", rbrack: "]", rbrke: "\u298C", rbrksld: "\u298E", rbrkslu: "\u2990", rcaron: "\u0159", Rcaron: "\u0158", rcedil: "\u0157", Rcedil: "\u0156", rceil: "\u2309", rcub: "}", rcy: "\u0440", Rcy: "\u0420", rdca: "\u2937", rdldhar: "\u2969", rdquo: "\u201D", rdquor: "\u201D", rdsh: "\u21B3", Re: "\u211C", real: "\u211C", realine: "\u211B", realpart: "\u211C", reals: "\u211D", rect: "\u25AD", reg: "\xAE", REG: "\xAE", ReverseElement: "\u220B", ReverseEquilibrium: "\u21CB", ReverseUpEquilibrium: "\u296F", rfisht: "\u297D", rfloor: "\u230B", rfr: "\uD835\uDD2F", Rfr: "\u211C", rHar: "\u2964", rhard: "\u21C1", rharu: "\u21C0", rharul: "\u296C", rho: "\u03C1", Rho: "\u03A1", rhov: "\u03F1", RightAngleBracket: "\u27E9", rightarrow: "\u2192", Rightarrow: "\u21D2", RightArrow: "\u2192", RightArrowBar: "\u21E5", RightArrowLeftArrow: "\u21C4", rightarrowtail: "\u21A3", RightCeiling: "\u2309", RightDoubleBracket: "\u27E7", RightDownTeeVector: "\u295D", RightDownVector: "\u21C2", RightDownVectorBar: "\u2955", RightFloor: "\u230B", rightharpoondown: "\u21C1", rightharpoonup: "\u21C0", rightleftarrows: "\u21C4", rightleftharpoons: "\u21CC", rightrightarrows: "\u21C9", rightsquigarrow: "\u219D", RightTee: "\u22A2", RightTeeArrow: "\u21A6", RightTeeVector: "\u295B", rightthreetimes: "\u22CC", RightTriangle: "\u22B3", RightTriangleBar: "\u29D0", RightTriangleEqual: "\u22B5", RightUpDownVector: "\u294F", RightUpTeeVector: "\u295C", RightUpVector: "\u21BE", RightUpVectorBar: "\u2954", RightVector: "\u21C0", RightVectorBar: "\u2953", ring: "\u02DA", risingdotseq: "\u2253", rlarr: "\u21C4", rlhar: "\u21CC", rlm: "\u200F", rmoust: "\u23B1", rmoustache: "\u23B1", rnmid: "\u2AEE", roang: "\u27ED", roarr: "\u21FE", robrk: "\u27E7", ropar: "\u2986", ropf: "\uD835\uDD63", Ropf: "\u211D", roplus: "\u2A2E", rotimes: "\u2A35", RoundImplies: "\u2970", rpar: ")", rpargt: "\u2994", rppolint: "\u2A12", rrarr: "\u21C9", Rrightarrow: "\u21DB", rsaquo: "\u203A", rscr: "\uD835\uDCC7", Rscr: "\u211B", rsh: "\u21B1", Rsh: "\u21B1", rsqb: "]", rsquo: "\u2019", rsquor: "\u2019", rthree: "\u22CC", rtimes: "\u22CA", rtri: "\u25B9", rtrie: "\u22B5", rtrif: "\u25B8", rtriltri: "\u29CE", RuleDelayed: "\u29F4", ruluhar: "\u2968", rx: "\u211E", sacute: "\u015B", Sacute: "\u015A", sbquo: "\u201A", sc: "\u227B", Sc: "\u2ABC", scap: "\u2AB8", scaron: "\u0161", Scaron: "\u0160", sccue: "\u227D", sce: "\u2AB0", scE: "\u2AB4", scedil: "\u015F", Scedil: "\u015E", scirc: "\u015D", Scirc: "\u015C", scnap: "\u2ABA", scnE: "\u2AB6", scnsim: "\u22E9", scpolint: "\u2A13", scsim: "\u227F", scy: "\u0441", Scy: "\u0421", sdot: "\u22C5", sdotb: "\u22A1", sdote: "\u2A66", searhk: "\u2925", searr: "\u2198", seArr: "\u21D8", searrow: "\u2198", sect: "\xA7", semi: ";", seswar: "\u2929", setminus: "\u2216", setmn: "\u2216", sext: "\u2736", sfr: "\uD835\uDD30", Sfr: "\uD835\uDD16", sfrown: "\u2322", sharp: "\u266F", shchcy: "\u0449", SHCHcy: "\u0429", shcy: "\u0448", SHcy: "\u0428", ShortDownArrow: "\u2193", ShortLeftArrow: "\u2190", shortmid: "\u2223", shortparallel: "\u2225", ShortRightArrow: "\u2192", ShortUpArrow: "\u2191", shy: "\xAD", sigma: "\u03C3", Sigma: "\u03A3", sigmaf: "\u03C2", sigmav: "\u03C2", sim: "\u223C", simdot: "\u2A6A", sime: "\u2243", simeq: "\u2243", simg: "\u2A9E", simgE: "\u2AA0", siml: "\u2A9D", simlE: "\u2A9F", simne: "\u2246", simplus: "\u2A24", simrarr: "\u2972", slarr: "\u2190", SmallCircle: "\u2218", smallsetminus: "\u2216", smashp: "\u2A33", smeparsl: "\u29E4", smid: "\u2223", smile: "\u2323", smt: "\u2AAA", smte: "\u2AAC", smtes: "\u2AAC\uFE00", softcy: "\u044C", SOFTcy: "\u042C", sol: "/", solb: "\u29C4", solbar: "\u233F", sopf: "\uD835\uDD64", Sopf: "\uD835\uDD4A", spades: "\u2660", spadesuit: "\u2660", spar: "\u2225", sqcap: "\u2293", sqcaps: "\u2293\uFE00", sqcup: "\u2294", sqcups: "\u2294\uFE00", Sqrt: "\u221A", sqsub: "\u228F", sqsube: "\u2291", sqsubset: "\u228F", sqsubseteq: "\u2291", sqsup: "\u2290", sqsupe: "\u2292", sqsupset: "\u2290", sqsupseteq: "\u2292", squ: "\u25A1", square: "\u25A1", Square: "\u25A1", SquareIntersection: "\u2293", SquareSubset: "\u228F", SquareSubsetEqual: "\u2291", SquareSuperset: "\u2290", SquareSupersetEqual: "\u2292", SquareUnion: "\u2294", squarf: "\u25AA", squf: "\u25AA", srarr: "\u2192", sscr: "\uD835\uDCC8", Sscr: "\uD835\uDCAE", ssetmn: "\u2216", ssmile: "\u2323", sstarf: "\u22C6", star: "\u2606", Star: "\u22C6", starf: "\u2605", straightepsilon: "\u03F5", straightphi: "\u03D5", strns: "\xAF", sub: "\u2282", Sub: "\u22D0", subdot: "\u2ABD", sube: "\u2286", subE: "\u2AC5", subedot: "\u2AC3", submult: "\u2AC1", subne: "\u228A", subnE: "\u2ACB", subplus: "\u2ABF", subrarr: "\u2979", subset: "\u2282", Subset: "\u22D0", subseteq: "\u2286", subseteqq: "\u2AC5", SubsetEqual: "\u2286", subsetneq: "\u228A", subsetneqq: "\u2ACB", subsim: "\u2AC7", subsub: "\u2AD5", subsup: "\u2AD3", succ: "\u227B", succapprox: "\u2AB8", succcurlyeq: "\u227D", Succeeds: "\u227B", SucceedsEqual: "\u2AB0", SucceedsSlantEqual: "\u227D", SucceedsTilde: "\u227F", succeq: "\u2AB0", succnapprox: "\u2ABA", succneqq: "\u2AB6", succnsim: "\u22E9", succsim: "\u227F", SuchThat: "\u220B", sum: "\u2211", Sum: "\u2211", sung: "\u266A", sup: "\u2283", Sup: "\u22D1", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", supdot: "\u2ABE", supdsub: "\u2AD8", supe: "\u2287", supE: "\u2AC6", supedot: "\u2AC4", Superset: "\u2283", SupersetEqual: "\u2287", suphsol: "\u27C9", suphsub: "\u2AD7", suplarr: "\u297B", supmult: "\u2AC2", supne: "\u228B", supnE: "\u2ACC", supplus: "\u2AC0", supset: "\u2283", Supset: "\u22D1", supseteq: "\u2287", supseteqq: "\u2AC6", supsetneq: "\u228B", supsetneqq: "\u2ACC", supsim: "\u2AC8", supsub: "\u2AD4", supsup: "\u2AD6", swarhk: "\u2926", swarr: "\u2199", swArr: "\u21D9", swarrow: "\u2199", swnwar: "\u292A", szlig: "\xDF", Tab: "\t", target: "\u2316", tau: "\u03C4", Tau: "\u03A4", tbrk: "\u23B4", tcaron: "\u0165", Tcaron: "\u0164", tcedil: "\u0163", Tcedil: "\u0162", tcy: "\u0442", Tcy: "\u0422", tdot: "\u20DB", telrec: "\u2315", tfr: "\uD835\uDD31", Tfr: "\uD835\uDD17", there4: "\u2234", therefore: "\u2234", Therefore: "\u2234", theta: "\u03B8", Theta: "\u0398", thetasym: "\u03D1", thetav: "\u03D1", thickapprox: "\u2248", thicksim: "\u223C", ThickSpace: "\u205F\u200A", thinsp: "\u2009", ThinSpace: "\u2009", thkap: "\u2248", thksim: "\u223C", thorn: "\xFE", THORN: "\xDE", tilde: "\u02DC", Tilde: "\u223C", TildeEqual: "\u2243", TildeFullEqual: "\u2245", TildeTilde: "\u2248", times: "\xD7", timesb: "\u22A0", timesbar: "\u2A31", timesd: "\u2A30", tint: "\u222D", toea: "\u2928", top: "\u22A4", topbot: "\u2336", topcir: "\u2AF1", topf: "\uD835\uDD65", Topf: "\uD835\uDD4B", topfork: "\u2ADA", tosa: "\u2929", tprime: "\u2034", trade: "\u2122", TRADE: "\u2122", triangle: "\u25B5", triangledown: "\u25BF", triangleleft: "\u25C3", trianglelefteq: "\u22B4", triangleq: "\u225C", triangleright: "\u25B9", trianglerighteq: "\u22B5", tridot: "\u25EC", trie: "\u225C", triminus: "\u2A3A", TripleDot: "\u20DB", triplus: "\u2A39", trisb: "\u29CD", tritime: "\u2A3B", trpezium: "\u23E2", tscr: "\uD835\uDCC9", Tscr: "\uD835\uDCAF", tscy: "\u0446", TScy: "\u0426", tshcy: "\u045B", TSHcy: "\u040B", tstrok: "\u0167", Tstrok: "\u0166", twixt: "\u226C", twoheadleftarrow: "\u219E", twoheadrightarrow: "\u21A0", uacute: "\xFA", Uacute: "\xDA", uarr: "\u2191", uArr: "\u21D1", Uarr: "\u219F", Uarrocir: "\u2949", ubrcy: "\u045E", Ubrcy: "\u040E", ubreve: "\u016D", Ubreve: "\u016C", ucirc: "\xFB", Ucirc: "\xDB", ucy: "\u0443", Ucy: "\u0423", udarr: "\u21C5", udblac: "\u0171", Udblac: "\u0170", udhar: "\u296E", ufisht: "\u297E", ufr: "\uD835\uDD32", Ufr: "\uD835\uDD18", ugrave: "\xF9", Ugrave: "\xD9", uHar: "\u2963", uharl: "\u21BF", uharr: "\u21BE", uhblk: "\u2580", ulcorn: "\u231C", ulcorner: "\u231C", ulcrop: "\u230F", ultri: "\u25F8", umacr: "\u016B", Umacr: "\u016A", uml: "\xA8", UnderBar: "_", UnderBrace: "\u23DF", UnderBracket: "\u23B5", UnderParenthesis: "\u23DD", Union: "\u22C3", UnionPlus: "\u228E", uogon: "\u0173", Uogon: "\u0172", uopf: "\uD835\uDD66", Uopf: "\uD835\uDD4C", uparrow: "\u2191", Uparrow: "\u21D1", UpArrow: "\u2191", UpArrowBar: "\u2912", UpArrowDownArrow: "\u21C5", updownarrow: "\u2195", Updownarrow: "\u21D5", UpDownArrow: "\u2195", UpEquilibrium: "\u296E", upharpoonleft: "\u21BF", upharpoonright: "\u21BE", uplus: "\u228E", UpperLeftArrow: "\u2196", UpperRightArrow: "\u2197", upsi: "\u03C5", Upsi: "\u03D2", upsih: "\u03D2", upsilon: "\u03C5", Upsilon: "\u03A5", UpTee: "\u22A5", UpTeeArrow: "\u21A5", upuparrows: "\u21C8", urcorn: "\u231D", urcorner: "\u231D", urcrop: "\u230E", uring: "\u016F", Uring: "\u016E", urtri: "\u25F9", uscr: "\uD835\uDCCA", Uscr: "\uD835\uDCB0", utdot: "\u22F0", utilde: "\u0169", Utilde: "\u0168", utri: "\u25B5", utrif: "\u25B4", uuarr: "\u21C8", uuml: "\xFC", Uuml: "\xDC", uwangle: "\u29A7", vangrt: "\u299C", varepsilon: "\u03F5", varkappa: "\u03F0", varnothing: "\u2205", varphi: "\u03D5", varpi: "\u03D6", varpropto: "\u221D", varr: "\u2195", vArr: "\u21D5", varrho: "\u03F1", varsigma: "\u03C2", varsubsetneq: "\u228A\uFE00", varsubsetneqq: "\u2ACB\uFE00", varsupsetneq: "\u228B\uFE00", varsupsetneqq: "\u2ACC\uFE00", vartheta: "\u03D1", vartriangleleft: "\u22B2", vartriangleright: "\u22B3", vBar: "\u2AE8", Vbar: "\u2AEB", vBarv: "\u2AE9", vcy: "\u0432", Vcy: "\u0412", vdash: "\u22A2", vDash: "\u22A8", Vdash: "\u22A9", VDash: "\u22AB", Vdashl: "\u2AE6", vee: "\u2228", Vee: "\u22C1", veebar: "\u22BB", veeeq: "\u225A", vellip: "\u22EE", verbar: "|", Verbar: "\u2016", vert: "|", Vert: "\u2016", VerticalBar: "\u2223", VerticalLine: "|", VerticalSeparator: "\u2758", VerticalTilde: "\u2240", VeryThinSpace: "\u200A", vfr: "\uD835\uDD33", Vfr: "\uD835\uDD19", vltri: "\u22B2", vnsub: "\u2282\u20D2", vnsup: "\u2283\u20D2", vopf: "\uD835\uDD67", Vopf: "\uD835\uDD4D", vprop: "\u221D", vrtri: "\u22B3", vscr: "\uD835\uDCCB", Vscr: "\uD835\uDCB1", vsubne: "\u228A\uFE00", vsubnE: "\u2ACB\uFE00", vsupne: "\u228B\uFE00", vsupnE: "\u2ACC\uFE00", Vvdash: "\u22AA", vzigzag: "\u299A", wcirc: "\u0175", Wcirc: "\u0174", wedbar: "\u2A5F", wedge: "\u2227", Wedge: "\u22C0", wedgeq: "\u2259", weierp: "\u2118", wfr: "\uD835\uDD34", Wfr: "\uD835\uDD1A", wopf: "\uD835\uDD68", Wopf: "\uD835\uDD4E", wp: "\u2118", wr: "\u2240", wreath: "\u2240", wscr: "\uD835\uDCCC", Wscr: "\uD835\uDCB2", xcap: "\u22C2", xcirc: "\u25EF", xcup: "\u22C3", xdtri: "\u25BD", xfr: "\uD835\uDD35", Xfr: "\uD835\uDD1B", xharr: "\u27F7", xhArr: "\u27FA", xi: "\u03BE", Xi: "\u039E", xlarr: "\u27F5", xlArr: "\u27F8", xmap: "\u27FC", xnis: "\u22FB", xodot: "\u2A00", xopf: "\uD835\uDD69", Xopf: "\uD835\uDD4F", xoplus: "\u2A01", xotime: "\u2A02", xrarr: "\u27F6", xrArr: "\u27F9", xscr: "\uD835\uDCCD", Xscr: "\uD835\uDCB3", xsqcup: "\u2A06", xuplus: "\u2A04", xutri: "\u25B3", xvee: "\u22C1", xwedge: "\u22C0", yacute: "\xFD", Yacute: "\xDD", yacy: "\u044F", YAcy: "\u042F", ycirc: "\u0177", Ycirc: "\u0176", ycy: "\u044B", Ycy: "\u042B", yen: "\xA5", yfr: "\uD835\uDD36", Yfr: "\uD835\uDD1C", yicy: "\u0457", YIcy: "\u0407", yopf: "\uD835\uDD6A", Yopf: "\uD835\uDD50", yscr: "\uD835\uDCCE", Yscr: "\uD835\uDCB4", yucy: "\u044E", YUcy: "\u042E", yuml: "\xFF", Yuml: "\u0178", zacute: "\u017A", Zacute: "\u0179", zcaron: "\u017E", Zcaron: "\u017D", zcy: "\u0437", Zcy: "\u0417", zdot: "\u017C", Zdot: "\u017B", zeetrf: "\u2128", ZeroWidthSpace: "\u200B", zeta: "\u03B6", Zeta: "\u0396", zfr: "\uD835\uDD37", Zfr: "\u2128", zhcy: "\u0436", ZHcy: "\u0416", zigrarr: "\u21DD", zopf: "\uD835\uDD6B", Zopf: "\u2124", zscr: "\uD835\uDCCF", Zscr: "\uD835\uDCB5", zwj: "\u200D", zwnj: "\u200C" }; var decodeMapLegacy = { aacute: "\xE1", Aacute: "\xC1", acirc: "\xE2", Acirc: "\xC2", acute: "\xB4", aelig: "\xE6", AElig: "\xC6", agrave: "\xE0", Agrave: "\xC0", amp: "&", AMP: "&", aring: "\xE5", Aring: "\xC5", atilde: "\xE3", Atilde: "\xC3", auml: "\xE4", Auml: "\xC4", brvbar: "\xA6", ccedil: "\xE7", Ccedil: "\xC7", cedil: "\xB8", cent: "\xA2", copy: "\xA9", COPY: "\xA9", curren: "\xA4", deg: "\xB0", divide: "\xF7", eacute: "\xE9", Eacute: "\xC9", ecirc: "\xEA", Ecirc: "\xCA", egrave: "\xE8", Egrave: "\xC8", eth: "\xF0", ETH: "\xD0", euml: "\xEB", Euml: "\xCB", frac12: "\xBD", frac14: "\xBC", frac34: "\xBE", gt: ">", GT: ">", iacute: "\xED", Iacute: "\xCD", icirc: "\xEE", Icirc: "\xCE", iexcl: "\xA1", igrave: "\xEC", Igrave: "\xCC", iquest: "\xBF", iuml: "\xEF", Iuml: "\xCF", laquo: "\xAB", lt: "<", LT: "<", macr: "\xAF", micro: "\xB5", middot: "\xB7", nbsp: "\xA0", not: "\xAC", ntilde: "\xF1", Ntilde: "\xD1", oacute: "\xF3", Oacute: "\xD3", ocirc: "\xF4", Ocirc: "\xD4", ograve: "\xF2", Ograve: "\xD2", ordf: "\xAA", ordm: "\xBA", oslash: "\xF8", Oslash: "\xD8", otilde: "\xF5", Otilde: "\xD5", ouml: "\xF6", Ouml: "\xD6", para: "\xB6", plusmn: "\xB1", pound: "\xA3", quot: '"', QUOT: '"', raquo: "\xBB", reg: "\xAE", REG: "\xAE", sect: "\xA7", shy: "\xAD", sup1: "\xB9", sup2: "\xB2", sup3: "\xB3", szlig: "\xDF", thorn: "\xFE", THORN: "\xDE", times: "\xD7", uacute: "\xFA", Uacute: "\xDA", ucirc: "\xFB", Ucirc: "\xDB", ugrave: "\xF9", Ugrave: "\xD9", uml: "\xA8", uuml: "\xFC", Uuml: "\xDC", yacute: "\xFD", Yacute: "\xDD", yen: "\xA5", yuml: "\xFF" }; var decodeMapNumeric = { "0": "\uFFFD", "128": "\u20AC", "130": "\u201A", "131": "\u0192", "132": "\u201E", "133": "\u2026", "134": "\u2020", "135": "\u2021", "136": "\u02C6", "137": "\u2030", "138": "\u0160", "139": "\u2039", "140": "\u0152", "142": "\u017D", "145": "\u2018", "146": "\u2019", "147": "\u201C", "148": "\u201D", "149": "\u2022", "150": "\u2013", "151": "\u2014", "152": "\u02DC", "153": "\u2122", "154": "\u0161", "155": "\u203A", "156": "\u0153", "158": "\u017E", "159": "\u0178" }; var invalidReferenceCodePoints = [ 1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 64976, 64977, 64978, 64979, 64980, 64981, 64982, 64983, 64984, 64985, 64986, 64987, 64988, 64989, 64990, 64991, 64992, 64993, 64994, 64995, 64996, 64997, 64998, 64999, 65000, 65001, 65002, 65003, 65004, 65005, 65006, 65007, 65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214, 393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894, 720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574, 1048575, 1114110, 1114111 ]; /*--------------------------------------------------------------------------*/ var stringFromCharCode = String.fromCharCode; var object = {}; var hasOwnProperty = object.hasOwnProperty; var has = function(object, propertyName) { return hasOwnProperty.call(object, propertyName); }; var contains = function(array, value) { var index = -1; var length = array.length; while (++index < length) { if (array[index] == value) { return true; } } return false; }; var merge = function(options, defaults) { if (!options) { return defaults; } var result = {}; var key; for (key in defaults) { // A `hasOwnProperty` check is not needed here, since only recognized // option names are used anyway. Any others are ignored. result[key] = has(options, key) ? options[key] : defaults[key]; } return result; }; // Modified version of `ucs2encode`; see https://mths.be/punycode. var codePointToSymbol = function(codePoint, strict) { var output = ""; if ( (codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff ) { // See issue #4: // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD // REPLACEMENT CHARACTER.” if (strict) { parseError( "character reference outside the permissible Unicode range" ); } return "\uFFFD"; } if (has(decodeMapNumeric, codePoint)) { if (strict) { parseError("disallowed character reference"); } return decodeMapNumeric[codePoint]; } if (strict && contains(invalidReferenceCodePoints, codePoint)) { parseError("disallowed character reference"); } if (codePoint > 0xffff) { codePoint -= 0x10000; output += stringFromCharCode( ((codePoint >>> 10) & 0x3ff) | 0xd800 ); codePoint = 0xdc00 | (codePoint & 0x3ff); } output += stringFromCharCode(codePoint); return output; }; var hexEscape = function(codePoint) { return "&#x" + codePoint.toString(16).toUpperCase() + ";"; }; var decEscape = function(codePoint) { return "&#" + codePoint + ";"; }; var parseError = function(message) { throw Error("Parse error: " + message); }; /*--------------------------------------------------------------------------*/ var encode = function(string, options) { options = merge(options, encode.options); var strict = options.strict; if (strict && regexInvalidRawCodePoint.test(string)) { parseError("forbidden code point"); } var encodeEverything = options.encodeEverything; var useNamedReferences = options.useNamedReferences; var allowUnsafeSymbols = options.allowUnsafeSymbols; var escapeCodePoint = options.decimal ? decEscape : hexEscape; var escapeBmpSymbol = function(symbol) { return escapeCodePoint(symbol.charCodeAt(0)); }; if (encodeEverything) { // Encode ASCII symbols. string = string.replace(regexAsciiWhitelist, function(symbol) { // Use named references if requested & possible. if (useNamedReferences && has(encodeMap, symbol)) { return "&" + encodeMap[symbol] + ";"; } return escapeBmpSymbol(symbol); }); // Shorten a few escapes that represent two symbols, of which at least one // is within the ASCII range. if (useNamedReferences) { string = string .replace(/>\u20D2/g, ">⃒") .replace(/<\u20D2/g, "<⃒") .replace(/fj/g, "fj"); } // Encode non-ASCII symbols. if (useNamedReferences) { // Encode non-ASCII symbols that can be replaced with a named reference. string = string.replace(regexEncodeNonAscii, function( string ) { // Note: there is no need to check `has(encodeMap, string)` here. return "&" + encodeMap[string] + ";"; }); } // Note: any remaining non-ASCII symbols are handled outside of the `if`. } else if (useNamedReferences) { // Apply named character references. // Encode `<>"'&` using named character references. if (!allowUnsafeSymbols) { string = string.replace(regexEscape, function(string) { return "&" + encodeMap[string] + ";"; // no need to check `has()` here }); } // Shorten escapes that represent two symbols, of which at least one is // `<>"'&`. string = string .replace(/>\u20D2/g, ">⃒") .replace(/<\u20D2/g, "<⃒"); // Encode non-ASCII symbols that can be replaced with a named reference. string = string.replace(regexEncodeNonAscii, function(string) { // Note: there is no need to check `has(encodeMap, string)` here. return "&" + encodeMap[string] + ";"; }); } else if (!allowUnsafeSymbols) { // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled // using named character references. string = string.replace(regexEscape, escapeBmpSymbol); } return ( string // Encode astral symbols. .replace(regexAstralSymbols, function($0) { // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae var high = $0.charCodeAt(0); var low = $0.charCodeAt(1); var codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000; return escapeCodePoint(codePoint); }) // Encode any remaining BMP symbols that are not printable ASCII symbols // using a hexadecimal escape. .replace(regexBmpWhitelist, escapeBmpSymbol) ); }; // Expose default options (so they can be overridden globally). encode.options = { allowUnsafeSymbols: false, encodeEverything: false, strict: false, useNamedReferences: false, decimal: false }; var decode = function(html, options) { options = merge(options, decode.options); var strict = options.strict; if (strict && regexInvalidEntity.test(html)) { parseError("malformed character reference"); } return html.replace(regexDecode, function( $0, $1, $2, $3, $4, $5, $6, $7, $8 ) { var codePoint; var semicolon; var decDigits; var hexDigits; var reference; var next; if ($1) { reference = $1; // Note: there is no need to check `has(decodeMap, reference)`. return decodeMap[reference]; } if ($2) { // Decode named character references without trailing `;`, e.g. `&`. // This is only a parse error if it gets converted to `&`, or if it is // followed by `=` in an attribute context. reference = $2; next = $3; if (next && options.isAttributeValue) { if (strict && next == "=") { parseError("`&` did not start a character reference"); } return $0; } else { if (strict) { parseError( "named character reference was not terminated by a semicolon" ); } // Note: there is no need to check `has(decodeMapLegacy, reference)`. return decodeMapLegacy[reference] + (next || ""); } } if ($4) { // Decode decimal escapes, e.g. `𝌆`. decDigits = $4; semicolon = $5; if (strict && !semicolon) { parseError( "character reference was not terminated by a semicolon" ); } codePoint = parseInt(decDigits, 10); return codePointToSymbol(codePoint, strict); } if ($6) { // Decode hexadecimal escapes, e.g. `𝌆`. hexDigits = $6; semicolon = $7; if (strict && !semicolon) { parseError( "character reference was not terminated by a semicolon" ); } codePoint = parseInt(hexDigits, 16); return codePointToSymbol(codePoint, strict); } // If we’re still here, `if ($7)` is implied; it’s an ambiguous // ampersand for sure. https://mths.be/notes/ambiguous-ampersands if (strict) { parseError( "named character reference was not terminated by a semicolon" ); } return $0; }); }; // Expose default options (so they can be overridden globally). decode.options = { isAttributeValue: false, strict: false }; var escape = function(string) { return string.replace(regexEscape, function($0) { // Note: there is no need to check `has(escapeMap, $0)` here. return escapeMap[$0]; }); }; /*--------------------------------------------------------------------------*/ var he = { version: "1.2.0", encode: encode, decode: decode, escape: escape, unescape: decode }; // 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(function() { return he; }); } else if (freeExports && !freeExports.nodeType) { if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+ freeModule.exports = he; } else { // in Narwhal or RingoJS v0.7.0- for (var key in he) { has(he, key) && (freeExports[key] = he[key]); } } } else { // in Rhino or a web browser root.he = he; } })(this); }.call( this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {} )); }, {} ], 104: [ 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: 156, url: 162 } ], 105: [ 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; }; }, {} ], 106: [ function(require, module, exports) { if (typeof Object.create === "function") { // implementation from standard node.js 'util' module module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor; ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } }); }; } else { // old school shim for old browsers module.exports = function inherits(ctor, superCtor) { ctor.super_ = superCtor; var TempCtor = function() {}; TempCtor.prototype = superCtor.prototype; ctor.prototype = new TempCtor(); ctor.prototype.constructor = ctor; }; } }, {} ], 107: [ function(require, module, exports) { /*! * Determine if an object is a Buffer * * @author Feross Aboukhadijeh * @license MIT */ // The _isBuffer check is for Safari 5-7 support, because it's missing // Object.prototype.constructor. Remove this eventually module.exports = function(obj) { return ( obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer) ); }; function isBuffer(obj) { return ( !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj) ); } // For Node v0.10 support. Remove this eventually. function isSlowBuffer(obj) { return ( typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0)) ); } }, {} ], 108: [ function(require, module, exports) { var toString = {}.toString; module.exports = Array.isArray || function(arr) { return toString.call(arr) == "[object Array]"; }; }, {} ], 109: [ function(require, module, exports) { exports.endianness = function() { return "LE"; }; exports.hostname = function() { if (typeof location !== "undefined") { return location.hostname; } else return ""; }; exports.loadavg = function() { return []; }; exports.uptime = function() { return 0; }; exports.freemem = function() { return Number.MAX_VALUE; }; exports.totalmem = function() { return Number.MAX_VALUE; }; exports.cpus = function() { return []; }; exports.type = function() { return "Browser"; }; exports.release = function() { if (typeof navigator !== "undefined") { return navigator.appVersion; } return ""; }; exports.networkInterfaces = exports.getNetworkInterfaces = function() { return {}; }; exports.arch = function() { return "javascript"; }; exports.platform = function() { return "browser"; }; exports.tmpdir = exports.tmpDir = function() { return "/tmp"; }; exports.EOL = "\n"; exports.homedir = function() { return "/"; }; }, {} ], 110: [ 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: 112 } ], 111: [ function(require, module, exports) { (function(process) { "use strict"; if ( !process.version || process.version.indexOf("v0.") === 0 || (process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) ) { module.exports = { nextTick: nextTick }; } else { module.exports = process; } function nextTick(fn, arg1, arg2, arg3) { if (typeof fn !== "function") { throw new TypeError('"callback" argument must be a function'); } var len = arguments.length; var args, i; switch (len) { case 0: case 1: return process.nextTick(fn); case 2: return process.nextTick(function afterTickOne() { fn.call(null, arg1); }); case 3: return process.nextTick(function afterTickTwo() { fn.call(null, arg1, arg2); }); case 4: return process.nextTick(function afterTickThree() { fn.call(null, arg1, arg2, arg3); }); default: args = new Array(len - 1); i = 0; while (i < args.length) { args[i++] = arguments[i]; } return process.nextTick(function afterTick() { fn.apply(null, args); }); } } }.call(this, require("_process"))); }, { _process: 112 } ], 112: [ 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; }; }, {} ], 113: [ 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 * @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 state to , // 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 * @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 : {} )); }, {} ], 114: [ 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]"; }; }, {} ], 115: [ 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; }; }, {} ], 116: [ function(require, module, exports) { "use strict"; exports.decode = exports.parse = require("./decode"); exports.encode = exports.stringify = require("./encode"); }, { "./decode": 114, "./encode": 115 } ], 117: [ 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 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"; /**/ var pna = require("process-nextick-args"); /**/ /**/ var objectKeys = Object.keys || function(obj) { var keys = []; for (var key in obj) { keys.push(key); } return keys; }; /**/ module.exports = Duplex; /**/ var util = require("core-util-is"); util.inherits = require("inherits"); /**/ var Readable = require("./_stream_readable"); var Writable = require("./_stream_writable"); util.inherits(Duplex, Readable); { // avoid scope creep, the keys array can then be collected 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); if (options && options.readable === false) this.readable = false; if (options && options.writable === false) this.writable = false; this.allowHalfOpen = true; if (options && 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() { return this._writableState.highWaterMark; } }); // the no-half-open enforcer function onend() { // if we allow half-open state, or if the writable side ended, // then we're ok. if (this.allowHalfOpen || this._writableState.ended) return; // no more data can be written. // But allow more writes to happen in this tick. pna.nextTick(onEndNT, this); } function onEndNT(self) { self.end(); } Object.defineProperty(Duplex.prototype, "destroyed", { get: function() { if ( this._readableState === undefined || this._writableState === undefined ) { return false; } return ( this._readableState.destroyed && this._writableState.destroyed ); }, set: function(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; } }); Duplex.prototype._destroy = function(err, cb) { this.push(null); this.end(); pna.nextTick(cb, err); }; }, { "./_stream_readable": 119, "./_stream_writable": 121, "core-util-is": 101, inherits: 106, "process-nextick-args": 111 } ], 118: [ 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"); /**/ var util = require("core-util-is"); util.inherits = require("inherits"); /**/ util.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": 120, "core-util-is": 101, inherits: 106 } ], 119: [ 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"; /**/ var pna = require("process-nextick-args"); /**/ module.exports = Readable; /**/ var isArray = require("isarray"); /**/ /**/ var Duplex; /**/ Readable.ReadableState = ReadableState; /**/ var EE = require("events").EventEmitter; var EElistenerCount = function(emitter, type) { return emitter.listeners(type).length; }; /**/ /**/ var Stream = require("./internal/streams/stream"); /**/ /**/ var Buffer = require("safe-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 util = require("core-util-is"); util.inherits = require("inherits"); /**/ /**/ var debugUtil = require("util"); var debug = void 0; if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog("stream"); } else { debug = function() {}; } /**/ var BufferList = require("./internal/streams/BufferList"); var destroyImpl = require("./internal/streams/destroy"); var StringDecoder; util.inherits(Readable, Stream); 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 (isArray(emitter._events[event])) emitter._events[event].unshift(fn); else emitter._events[event] = [fn, emitter._events[event]]; } function ReadableState(options, stream) { 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. var 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" var hwm = options.highWaterMark; var readableHwm = options.readableHighWaterMark; var defaultHwm = this.objectMode ? 16 : 16 * 1024; if (hwm || hwm === 0) this.highWaterMark = hwm; else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm; else this.highWaterMark = defaultHwm; // cast to ints. this.highWaterMark = Math.floor(this.highWaterMark); // 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; // 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); this._readableState = new ReadableState(options, this); // 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", { get: function() { if (this._readableState === undefined) { return false; } return this._readableState.destroyed; }, set: function(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) { this.push(null); 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 ) { var state = stream._readableState; if (chunk === null) { state.reading = false; onEofChunk(stream, state); } else { var er; if (!skipChunkCheck) er = chunkInvalid(state, chunk); if (er) { stream.emit("error", 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) stream.emit( "error", new Error("stream.unshift() after end event") ); else addChunk(stream, state, chunk, true); } else if (state.ended) { stream.emit("error", new Error("stream.push() after EOF")); } 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; } } return needMoreData(state); } function addChunk(stream, state, chunk, addToFront) { if (state.flowing && state.length === 0 && !state.sync) { stream.emit("data", chunk); stream.read(0); } 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 TypeError("Invalid non-string/buffer chunk"); } return er; } // if it's past the high water mark, we can push in some more. // 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. Also, if the push() triggered a // readable event, and the user called read(largeNumber) such that // needReadable was set, then we ought to push more, so that another // 'readable' event will be triggered. function needMoreData(state) { return ( !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0) ); } Readable.prototype.isPaused = function() { return this._readableState.flowing === false; }; // backwards compatibility. Readable.prototype.setEncoding = function(enc) { if (!StringDecoder) StringDecoder = require("string_decoder/").StringDecoder; this._readableState.decoder = new StringDecoder(enc); this._readableState.encoding = enc; return this; }; // Don't raise the hwm > 8MB var MAX_HWM = 0x800000; function computeNewHighWaterMark(n) { if (n >= MAX_HWM) { 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.length >= state.highWaterMark || 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 = true; n = 0; } else { state.length -= n; } 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) { 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; // emit 'readable' now to make sure it gets picked up. 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; state.needReadable = false; if (!state.emittedReadable) { debug("emitReadable", state.flowing); state.emittedReadable = true; if (state.sync) pna.nextTick(emitReadable_, stream); else emitReadable_(stream); } } function emitReadable_(stream) { debug("emit readable"); stream.emit("readable"); 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; pna.nextTick(maybeReadMore_, stream, state); } } function maybeReadMore_(stream, state) { var len = state.length; while ( !state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark ) { debug("maybeReadMore read 0"); stream.read(0); if (len === state.length) // didn't get any data, stop spinning. break; else len = state.length; } 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) { this.emit("error", new Error("_read() is not implemented")); }; 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) pna.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(); } // If the user pushes more data while we're writing to dest then we'll end up // in ondata again. However, we only want to increase awaitDrain once because // dest will only emit one 'drain' event for the multiple writes. // => Introduce a guard on increasing awaitDrain. var increasedAwaitDrain = false; src.on("data", ondata); function ondata(chunk) { debug("ondata"); increasedAwaitDrain = false; var ret = dest.write(chunk); if (false === ret && !increasedAwaitDrain) { // 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", src._readableState.awaitDrain ); src._readableState.awaitDrain++; increasedAwaitDrain = true; } 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) dest.emit("error", 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() { 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, unpipeInfo); } 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); if (ev === "data") { // Start flowing on next tick if stream isn't explicitly paused if (this._readableState.flowing !== false) this.resume(); } else if (ev === "readable") { var state = this._readableState; if (!state.endEmitted && !state.readableListening) { state.readableListening = state.needReadable = true; state.emittedReadable = false; if (!state.reading) { pna.nextTick(nReadingNextTick, this); } else if (state.length) { emitReadable(this); } } } return res; }; Readable.prototype.addListener = Readable.prototype.on; 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"); state.flowing = true; resume(this, state); } return this; }; function resume(stream, state) { if (!state.resumeScheduled) { state.resumeScheduled = true; pna.nextTick(resume_, stream, state); } } function resume_(stream, state) { if (!state.reading) { debug("resume read 0"); stream.read(0); } state.resumeScheduled = false; state.awaitDrain = 0; 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 (false !== this._readableState.flowing) { debug("pause"); this._readableState.flowing = false; this.emit("pause"); } 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(method) { return function() { 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; }; 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() { return this._readableState.highWaterMark; } }); // exposed for testing purposes only. Readable._fromList = fromList; // 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.head.data; else ret = state.buffer.concat(state.length); state.buffer.clear(); } else { // read part of list ret = fromListPartial(n, state.buffer, state.decoder); } return ret; } // Extracts only enough buffered data to satisfy the amount requested. // This function is designed to be inlinable, so please take care when making // changes to the function body. function fromListPartial(n, list, hasStrings) { var ret; if (n < list.head.data.length) { // slice is the same for buffers and strings ret = list.head.data.slice(0, n); list.head.data = list.head.data.slice(n); } else if (n === list.head.data.length) { // first chunk is a perfect match ret = list.shift(); } else { // result spans more than one buffer ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); } return ret; } // Copies a specified amount of characters from the list of buffered data // chunks. // This function is designed to be inlinable, so please take care when making // changes to the function body. function copyFromBufferString(n, list) { var p = list.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) list.head = p.next; else list.head = list.tail = null; } else { list.head = p; p.data = str.slice(nb); } break; } ++c; } list.length -= c; return ret; } // Copies a specified amount of bytes from the list of buffered data chunks. // This function is designed to be inlinable, so please take care when making // changes to the function body. function copyFromBuffer(n, list) { var ret = Buffer.allocUnsafe(n); var p = list.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) list.head = p.next; else list.head = list.tail = null; } else { list.head = p; p.data = buf.slice(nb); } break; } ++c; } list.length -= c; return ret; } function endReadable(stream) { var state = stream._readableState; // If we get here before consuming all the bytes, then that is a // bug in node. Should never happen. if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); if (!state.endEmitted) { state.ended = true; pna.nextTick(endReadableNT, state, stream); } } function endReadableNT(state, stream) { // Check that we didn't get one last unshift. if (!state.endEmitted && state.length === 0) { state.endEmitted = true; stream.readable = false; stream.emit("end"); } } 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 : {} )); }, { "./_stream_duplex": 117, "./internal/streams/BufferList": 122, "./internal/streams/destroy": 123, "./internal/streams/stream": 124, _process: 112, "core-util-is": 101, events: 102, inherits: 106, isarray: 108, "process-nextick-args": 111, "safe-buffer": 144, "string_decoder/": 125, util: 2 } ], 120: [ 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 Duplex = require("./_stream_duplex"); /**/ var util = require("core-util-is"); util.inherits = require("inherits"); /**/ util.inherits(Transform, Duplex); function afterTransform(er, data) { var ts = this._transformState; ts.transforming = false; var cb = ts.writecb; if (!cb) { return this.emit( "error", new Error("write callback called multiple times") ); } 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._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) { throw new Error("_transform() is not implemented"); }; 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.writecb && !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) { var _this2 = this; Duplex.prototype._destroy.call(this, err, function(err2) { cb(err2); _this2.emit("close"); }); }; 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); // if there's nothing in the write buffer, then that means // that nothing more will ever be provided if (stream._writableState.length) throw new Error("Calling transform done when ws.length != 0"); if (stream._transformState.transforming) throw new Error("Calling transform done when still transforming"); return stream.push(null); } }, { "./_stream_duplex": 117, "core-util-is": 101, inherits: 106 } ], 121: [ function(require, module, exports) { (function(process, global, setImmediate) { // 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"; /**/ var pna = require("process-nextick-args"); /**/ module.exports = Writable; /* */ 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); }; } /* */ /**/ var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; /**/ /**/ var Duplex; /**/ Writable.WritableState = WritableState; /**/ var util = require("core-util-is"); util.inherits = require("inherits"); /**/ /**/ var internalUtil = { deprecate: require("util-deprecate") }; /**/ /**/ var Stream = require("./internal/streams/stream"); /**/ /**/ var Buffer = require("safe-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"); util.inherits(Writable, Stream); function nop() {} function WritableState(options, stream) { 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. var 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() var hwm = options.highWaterMark; var writableHwm = options.writableHighWaterMark; var defaultHwm = this.objectMode ? 16 : 16 * 1024; if (hwm || hwm === 0) this.highWaterMark = hwm; else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm; else this.highWaterMark = defaultHwm; // cast to ints. this.highWaterMark = Math.floor(this.highWaterMark); // 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; // 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() { 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(object) { if (realHasInstance.call(this, object)) return true; if (this !== Writable) return false; return object && object._writableState instanceof WritableState; } }); } else { realHasInstance = function(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. if ( !realHasInstance.call(Writable, this) && !(this instanceof Duplex) ) { return new Writable(options); } this._writableState = new WritableState(options, this); // 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() { this.emit("error", new Error("Cannot pipe, not readable")); }; function writeAfterEnd(stream, cb) { var er = new Error("write after end"); // TODO: defer error events consistently everywhere, not just the cb stream.emit("error", er); pna.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 valid = true; var er = false; if (chunk === null) { er = new TypeError("May not write null values to stream"); } else if ( typeof chunk !== "string" && chunk !== undefined && !state.objectMode ) { er = new TypeError("Invalid non-string/buffer chunk"); } if (er) { stream.emit("error", er); pna.nextTick(cb, er); valid = false; } return valid; } 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.ended) 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() { var state = this._writableState; state.corked++; }; Writable.prototype.uncork = function() { var state = this._writableState; if (state.corked) { state.corked--; if ( !state.writing && !state.corked && !state.finished && !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 TypeError("Unknown encoding: " + encoding); this._writableState.defaultEncoding = encoding; return this; }; 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() { 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 (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 pna.nextTick(cb, er); // this can emit finish, and it will always happen // after error pna.nextTick(finishMaybe, stream, state); stream._writableState.errorEmitted = true; stream.emit("error", er); } else { // the caller expect this to happen before if // it is async cb(er); stream._writableState.errorEmitted = true; stream.emit("error", 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; 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); if ( !finished && !state.corked && !state.bufferProcessing && state.bufferedRequest ) { clearBuffer(stream, state); } if (sync) { /**/ asyncWrite(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 Error("_write() is not implemented")); }; 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 && !state.finished) endWritable(this, state, cb); }; 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) { stream.emit("error", 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.pendingcb++; state.finalCalled = true; pna.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"); } } return need; } function endWritable(stream, state, cb) { state.ending = true; finishMaybe(stream, state); if (cb) { if (state.finished) pna.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; } if (state.corkedRequestsFree) { state.corkedRequestsFree.next = corkReq; } else { state.corkedRequestsFree = corkReq; } } Object.defineProperty(Writable.prototype, "destroyed", { get: function() { if (this._writableState === undefined) { return false; } return this._writableState.destroyed; }, set: function(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) { this.end(); cb(err); }; }.call( this, require("_process"), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}, require("timers").setImmediate )); }, { "./_stream_duplex": 117, "./internal/streams/destroy": 123, "./internal/streams/stream": 124, _process: 112, "core-util-is": 101, inherits: 106, "process-nextick-args": 111, "safe-buffer": 144, timers: 160, "util-deprecate": 164 } ], 122: [ function(require, module, exports) { "use strict"; function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } var Buffer = require("safe-buffer").Buffer; var util = require("util"); function copyBuffer(src, target, offset) { src.copy(target, offset); } module.exports = (function() { function BufferList() { _classCallCheck(this, BufferList); this.head = null; this.tail = null; this.length = 0; } BufferList.prototype.push = 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; }; BufferList.prototype.unshift = function unshift(v) { var entry = { data: v, next: this.head }; if (this.length === 0) this.tail = entry; this.head = entry; ++this.length; }; BufferList.prototype.shift = 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; }; BufferList.prototype.clear = function clear() { this.head = this.tail = null; this.length = 0; }; BufferList.prototype.join = 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; }; BufferList.prototype.concat = function concat(n) { if (this.length === 0) return Buffer.alloc(0); if (this.length === 1) return this.head.data; 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; }; return BufferList; })(); if (util && util.inspect && util.inspect.custom) { module.exports.prototype[util.inspect.custom] = function() { var obj = util.inspect({ length: this.length }); return this.constructor.name + " " + obj; }; } }, { "safe-buffer": 144, util: 2 } ], 123: [ function(require, module, exports) { "use strict"; /**/ var pna = require("process-nextick-args"); /**/ // 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 && (!this._writableState || !this._writableState.errorEmitted) ) { pna.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) { pna.nextTick(emitErrorNT, _this, err); if (_this._writableState) { _this._writableState.errorEmitted = true; } } else if (cb) { cb(err); } }); return this; } 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.finished = false; this._writableState.errorEmitted = false; } } function emitErrorNT(self, err) { self.emit("error", err); } module.exports = { destroy: destroy, undestroy: undestroy }; }, { "process-nextick-args": 111 } ], 124: [ function(require, module, exports) { module.exports = require("events").EventEmitter; }, { events: 102 } ], 125: [ 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 Buffer = require("safe-buffer").Buffer; /**/ 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": 144 } ], 126: [ 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"); }, { "./lib/_stream_duplex.js": 117, "./lib/_stream_passthrough.js": 118, "./lib/_stream_readable.js": 119, "./lib/_stream_transform.js": 120, "./lib/_stream_writable.js": 121 } ], 127: [ function(require, module, exports) { "use strict"; module.exports = { // Output ABSOLUTE: "absolute", PATH_RELATIVE: "pathRelative", ROOT_RELATIVE: "rootRelative", SHORTEST: "shortest" }; }, {} ], 128: [ function(require, module, exports) { "use strict"; var constants = require("./constants"); function formatAuth(urlObj, options) { if ( urlObj.auth && !options.removeAuth && (urlObj.extra.relation.maximumHost || options.output === constants.ABSOLUTE) ) { return urlObj.auth + "@"; } return ""; } function formatHash(urlObj, options) { return urlObj.hash ? urlObj.hash : ""; } function formatHost(urlObj, options) { if ( urlObj.host.full && (urlObj.extra.relation.maximumAuth || options.output === constants.ABSOLUTE) ) { return urlObj.host.full; } return ""; } function formatPath(urlObj, options) { var str = ""; var absolutePath = urlObj.path.absolute.string; var relativePath = urlObj.path.relative.string; var resource = showResource(urlObj, options); if ( urlObj.extra.relation.maximumHost || options.output === constants.ABSOLUTE || options.output === constants.ROOT_RELATIVE ) { str = absolutePath; } else if ( (relativePath.length <= absolutePath.length && options.output === constants.SHORTEST) || options.output === constants.PATH_RELATIVE ) { str = relativePath; if (str === "") { var query = showQuery(urlObj, options) && !!getQuery(urlObj, options); if (urlObj.extra.relation.maximumPath && !resource) { str = "./"; } else if ( urlObj.extra.relation.overridesQuery && !resource && !query ) { str = "./"; } } } else { str = absolutePath; } if ( str === "/" && !resource && options.removeRootTrailingSlash && (!urlObj.extra.relation.minimumPort || options.output === constants.ABSOLUTE) ) { str = ""; } return str; } function formatPort(urlObj, options) { if ( urlObj.port && !urlObj.extra.portIsDefault && urlObj.extra.relation.maximumHost ) { return ":" + urlObj.port; } return ""; } function formatQuery(urlObj, options) { return showQuery(urlObj, options) ? getQuery(urlObj, options) : ""; } function formatResource(urlObj, options) { return showResource(urlObj, options) ? urlObj.resource : ""; } function formatScheme(urlObj, options) { var str = ""; if ( urlObj.extra.relation.maximumHost || options.output === constants.ABSOLUTE ) { if ( !urlObj.extra.relation.minimumScheme || !options.schemeRelative || options.output === constants.ABSOLUTE ) { str += urlObj.scheme + "://"; } else { str += "//"; } } return str; } function formatUrl(urlObj, options) { var url = ""; url += formatScheme(urlObj, options); url += formatAuth(urlObj, options); url += formatHost(urlObj, options); url += formatPort(urlObj, options); url += formatPath(urlObj, options); url += formatResource(urlObj, options); url += formatQuery(urlObj, options); url += formatHash(urlObj, options); return url; } function getQuery(urlObj, options) { var stripQuery = options.removeEmptyQueries && urlObj.extra.relation.minimumPort; return urlObj.query.string[stripQuery ? "stripped" : "full"]; } function showQuery(urlObj, options) { return ( !urlObj.extra.relation.minimumQuery || options.output === constants.ABSOLUTE || options.output === constants.ROOT_RELATIVE ); } function showResource(urlObj, options) { var removeIndex = options.removeDirectoryIndexes && urlObj.extra.resourceIsIndex; var removeMatchingResource = urlObj.extra.relation.minimumResource && options.output !== constants.ABSOLUTE && options.output !== constants.ROOT_RELATIVE; return !!urlObj.resource && !removeMatchingResource && !removeIndex; } module.exports = formatUrl; }, { "./constants": 127 } ], 129: [ function(require, module, exports) { "use strict"; var constants = require("./constants"); var formatUrl = require("./format"); var getOptions = require("./options"); var objUtils = require("./util/object"); var parseUrl = require("./parse"); var relateUrl = require("./relate"); function RelateUrl(from, options) { this.options = getOptions(options, { defaultPorts: { ftp: 21, http: 80, https: 443 }, directoryIndexes: ["index.html"], ignore_www: false, output: RelateUrl.SHORTEST, rejectedSchemes: ["data", "javascript", "mailto"], removeAuth: false, removeDirectoryIndexes: true, removeEmptyQueries: false, removeRootTrailingSlash: true, schemeRelative: true, site: undefined, slashesDenoteHost: true }); this.from = parseUrl.from(from, this.options, null); } /* Usage: instance=new RelateUrl(); instance.relate(); */ RelateUrl.prototype.relate = function(from, to, options) { // relate(to,options) if (objUtils.isPlainObject(to)) { options = to; to = from; from = null; } // relate(to) else if (!to) { to = from; from = null; } options = getOptions(options, this.options); from = from || options.site; from = parseUrl.from(from, options, this.from); if (!from || !from.href) { throw new Error("from value not defined."); } else if (from.extra.hrefInfo.minimumPathOnly) { throw new Error( "from value supplied is not absolute: " + from.href ); } to = parseUrl.to(to, options); if (to.valid === false) return to.href; to = relateUrl(from, to, options); to = formatUrl(to, options); return to; }; /* Usage: RelateUrl.relate(); */ RelateUrl.relate = function(from, to, options) { return new RelateUrl().relate(from, to, options); }; // Make constants accessible from API objUtils.shallowMerge(RelateUrl, constants); module.exports = RelateUrl; }, { "./constants": 127, "./format": 128, "./options": 130, "./parse": 133, "./relate": 140, "./util/object": 142 } ], 130: [ function(require, module, exports) { "use strict"; var objUtils = require("./util/object"); function getOptions(options, defaults) { if (objUtils.isPlainObject(options)) { var newOptions = {}; for (var i in defaults) { if (defaults.hasOwnProperty(i)) { if (options[i] !== undefined) { newOptions[i] = mergeOption(options[i], defaults[i]); } else { newOptions[i] = defaults[i]; } } } return newOptions; } else { return defaults; } } function mergeOption(newValues, defaultValues) { if (defaultValues instanceof Object && newValues instanceof Object) { if (defaultValues instanceof Array && newValues instanceof Array) { return defaultValues.concat(newValues); } else { return objUtils.shallowMerge(newValues, defaultValues); } } return newValues; } module.exports = getOptions; }, { "./util/object": 142 } ], 131: [ function(require, module, exports) { "use strict"; function parseHost(urlObj, options) { // TWEAK :: condition only for speed optimization if (options.ignore_www) { var host = urlObj.host.full; if (host) { var stripped = host; if (host.indexOf("www.") === 0) { stripped = host.substr(4); } urlObj.host.stripped = stripped; } } } module.exports = parseHost; }, {} ], 132: [ function(require, module, exports) { "use strict"; function hrefInfo(urlObj) { var minimumPathOnly = !urlObj.scheme && !urlObj.auth && !urlObj.host.full && !urlObj.port; var minimumResourceOnly = minimumPathOnly && !urlObj.path.absolute.string; var minimumQueryOnly = minimumResourceOnly && !urlObj.resource; var minimumHashOnly = minimumQueryOnly && !urlObj.query.string.full.length; var empty = minimumHashOnly && !urlObj.hash; urlObj.extra.hrefInfo.minimumPathOnly = minimumPathOnly; urlObj.extra.hrefInfo.minimumResourceOnly = minimumResourceOnly; urlObj.extra.hrefInfo.minimumQueryOnly = minimumQueryOnly; urlObj.extra.hrefInfo.minimumHashOnly = minimumHashOnly; urlObj.extra.hrefInfo.empty = empty; } module.exports = hrefInfo; }, {} ], 133: [ function(require, module, exports) { "use strict"; var hrefInfo = require("./hrefInfo"); var parseHost = require("./host"); var parsePath = require("./path"); var parsePort = require("./port"); var parseQuery = require("./query"); var parseUrlString = require("./urlstring"); var pathUtils = require("../util/path"); function parseFromUrl(url, options, fallback) { if (url) { var urlObj = parseUrl(url, options); // Because the following occurs in the relate stage for "to" URLs, // such had to be mostly duplicated here var pathArray = pathUtils.resolveDotSegments( urlObj.path.absolute.array ); urlObj.path.absolute.array = pathArray; urlObj.path.absolute.string = "/" + pathUtils.join(pathArray); return urlObj; } else { return fallback; } } function parseUrl(url, options) { var urlObj = parseUrlString(url, options); if (urlObj.valid === false) return urlObj; parseHost(urlObj, options); parsePort(urlObj, options); parsePath(urlObj, options); parseQuery(urlObj, options); hrefInfo(urlObj); return urlObj; } module.exports = { from: parseFromUrl, to: parseUrl }; }, { "../util/path": 143, "./host": 131, "./hrefInfo": 132, "./path": 134, "./port": 135, "./query": 136, "./urlstring": 137 } ], 134: [ function(require, module, exports) { "use strict"; function isDirectoryIndex(resource, options) { var verdict = false; options.directoryIndexes.every(function(index) { if (index === resource) { verdict = true; return false; } return true; }); return verdict; } function parsePath(urlObj, options) { var path = urlObj.path.absolute.string; if (path) { var lastSlash = path.lastIndexOf("/"); if (lastSlash > -1) { if (++lastSlash < path.length) { var resource = path.substr(lastSlash); if (resource !== "." && resource !== "..") { urlObj.resource = resource; path = path.substr(0, lastSlash); } else { path += "/"; } } urlObj.path.absolute.string = path; urlObj.path.absolute.array = splitPath(path); } else if (path === "." || path === "..") { // "..?var", "..#anchor", etc ... not "..index.html" path += "/"; urlObj.path.absolute.string = path; urlObj.path.absolute.array = splitPath(path); } else { // Resource-only urlObj.resource = path; urlObj.path.absolute.string = null; } urlObj.extra.resourceIsIndex = isDirectoryIndex( urlObj.resource, options ); } // Else: query/hash-only or empty } function splitPath(path) { // TWEAK :: condition only for speed optimization if (path !== "/") { var cleaned = []; path.split("/").forEach(function(dir) { // Cleanup -- splitting "/dir/" becomes ["","dir",""] if (dir !== "") { cleaned.push(dir); } }); return cleaned; } else { // Faster to skip the above block and just create an array return []; } } module.exports = parsePath; }, {} ], 135: [ function(require, module, exports) { "use strict"; function parsePort(urlObj, options) { var defaultPort = -1; for (var i in options.defaultPorts) { if (i === urlObj.scheme && options.defaultPorts.hasOwnProperty(i)) { defaultPort = options.defaultPorts[i]; break; } } if (defaultPort > -1) { // Force same type as urlObj.port defaultPort = defaultPort.toString(); if (urlObj.port === null) { urlObj.port = defaultPort; } urlObj.extra.portIsDefault = urlObj.port === defaultPort; } } module.exports = parsePort; }, {} ], 136: [ function(require, module, exports) { "use strict"; var hasOwnProperty = Object.prototype.hasOwnProperty; function parseQuery(urlObj, options) { urlObj.query.string.full = stringify(urlObj.query.object, false); // TWEAK :: condition only for speed optimization if (options.removeEmptyQueries) { urlObj.query.string.stripped = stringify(urlObj.query.object, true); } } function stringify(queryObj, removeEmptyQueries) { var count = 0; var str = ""; for (var i in queryObj) { if (i !== "" && hasOwnProperty.call(queryObj, i) === true) { var value = queryObj[i]; if (value !== "" || !removeEmptyQueries) { str += ++count === 1 ? "?" : "&"; i = encodeURIComponent(i); if (value !== "") { str += i + "=" + encodeURIComponent(value).replace(/%20/g, "+"); } else { str += i; } } } } return str; } module.exports = parseQuery; }, {} ], 137: [ function(require, module, exports) { "use strict"; var _parseUrl = require("url").parse; /* Customize the URL object that Node generates because: * necessary data for later * urlObj.host is useless * urlObj.hostname is too long * urlObj.path is useless * urlObj.pathname is too long * urlObj.protocol is inaccurate; should be called "scheme" * urlObj.search is mostly useless */ function clean(urlObj) { var scheme = urlObj.protocol; if (scheme) { // Remove ":" suffix if (scheme.indexOf(":") === scheme.length - 1) { scheme = scheme.substr(0, scheme.length - 1); } } urlObj.host = { // TODO :: unescape(encodeURIComponent(s)) ? ... http://ecmanaut.blogspot.ca/2006/07/encoding-decoding-utf8-in-javascript.html full: urlObj.hostname, stripped: null }; urlObj.path = { absolute: { array: null, string: urlObj.pathname }, relative: { array: null, string: null } }; urlObj.query = { object: urlObj.query, string: { full: null, stripped: null } }; urlObj.extra = { hrefInfo: { minimumPathOnly: null, minimumResourceOnly: null, minimumQueryOnly: null, minimumHashOnly: null, empty: null, separatorOnlyQuery: urlObj.search === "?" }, portIsDefault: null, relation: { maximumScheme: null, maximumAuth: null, maximumHost: null, maximumPort: null, maximumPath: null, maximumResource: null, maximumQuery: null, maximumHash: null, minimumScheme: null, minimumAuth: null, minimumHost: null, minimumPort: null, minimumPath: null, minimumResource: null, minimumQuery: null, minimumHash: null, overridesQuery: null }, resourceIsIndex: null, slashes: urlObj.slashes }; urlObj.resource = null; urlObj.scheme = scheme; delete urlObj.hostname; delete urlObj.pathname; delete urlObj.protocol; delete urlObj.search; delete urlObj.slashes; return urlObj; } function validScheme(url, options) { var valid = true; options.rejectedSchemes.every(function(rejectedScheme) { valid = !(url.indexOf(rejectedScheme + ":") === 0); // Break loop return valid; }); return valid; } function parseUrlString(url, options) { if (validScheme(url, options)) { return clean(_parseUrl(url, true, options.slashesDenoteHost)); } else { return { href: url, valid: false }; } } module.exports = parseUrlString; }, { url: 162 } ], 138: [ function(require, module, exports) { "use strict"; var findRelation = require("./findRelation"); var objUtils = require("../util/object"); var pathUtils = require("../util/path"); function absolutize(urlObj, siteUrlObj, options) { findRelation.upToPath(urlObj, siteUrlObj, options); // Fill in relative URLs if (urlObj.extra.relation.minimumScheme) urlObj.scheme = siteUrlObj.scheme; if (urlObj.extra.relation.minimumAuth) urlObj.auth = siteUrlObj.auth; if (urlObj.extra.relation.minimumHost) urlObj.host = objUtils.clone(siteUrlObj.host); if (urlObj.extra.relation.minimumPort) copyPort(urlObj, siteUrlObj); if (urlObj.extra.relation.minimumScheme) copyPath(urlObj, siteUrlObj); // Check remaining relativeness now that path has been copied and/or resolved findRelation.pathOn(urlObj, siteUrlObj, options); // Fill in relative URLs if (urlObj.extra.relation.minimumResource) copyResource(urlObj, siteUrlObj); if (urlObj.extra.relation.minimumQuery) urlObj.query = objUtils.clone(siteUrlObj.query); if (urlObj.extra.relation.minimumHash) urlObj.hash = siteUrlObj.hash; } /* Get an absolute path that's relative to site url. */ function copyPath(urlObj, siteUrlObj) { if ( urlObj.extra.relation.maximumHost || !urlObj.extra.hrefInfo.minimumResourceOnly ) { var pathArray = urlObj.path.absolute.array; var pathString = "/"; // If not erroneous URL if (pathArray) { // If is relative path if ( urlObj.extra.hrefInfo.minimumPathOnly && urlObj.path.absolute.string.indexOf("/") !== 0 ) { // Append path to site path pathArray = siteUrlObj.path.absolute.array.concat(pathArray); } pathArray = pathUtils.resolveDotSegments(pathArray); pathString += pathUtils.join(pathArray); } else { pathArray = []; } urlObj.path.absolute.array = pathArray; urlObj.path.absolute.string = pathString; } else { // Resource-, query- or hash-only or empty urlObj.path = objUtils.clone(siteUrlObj.path); } } function copyPort(urlObj, siteUrlObj) { urlObj.port = siteUrlObj.port; urlObj.extra.portIsDefault = siteUrlObj.extra.portIsDefault; } function copyResource(urlObj, siteUrlObj) { urlObj.resource = siteUrlObj.resource; urlObj.extra.resourceIsIndex = siteUrlObj.extra.resourceIsIndex; } module.exports = absolutize; }, { "../util/object": 142, "../util/path": 143, "./findRelation": 139 } ], 139: [ function(require, module, exports) { "use strict"; function findRelation_upToPath(urlObj, siteUrlObj, options) { // Path- or root-relative URL var pathOnly = urlObj.extra.hrefInfo.minimumPathOnly; // Matching scheme, scheme-relative or path-only var minimumScheme = urlObj.scheme === siteUrlObj.scheme || !urlObj.scheme; // Matching auth, ignoring auth or path-only var minimumAuth = minimumScheme && (urlObj.auth === siteUrlObj.auth || options.removeAuth || pathOnly); // Matching host or path-only var www = options.ignore_www ? "stripped" : "full"; var minimumHost = minimumAuth && (urlObj.host[www] === siteUrlObj.host[www] || pathOnly); // Matching port or path-only var minimumPort = minimumHost && (urlObj.port === siteUrlObj.port || pathOnly); urlObj.extra.relation.minimumScheme = minimumScheme; urlObj.extra.relation.minimumAuth = minimumAuth; urlObj.extra.relation.minimumHost = minimumHost; urlObj.extra.relation.minimumPort = minimumPort; urlObj.extra.relation.maximumScheme = !minimumScheme || (minimumScheme && !minimumAuth); urlObj.extra.relation.maximumAuth = !minimumScheme || (minimumScheme && !minimumHost); urlObj.extra.relation.maximumHost = !minimumScheme || (minimumScheme && !minimumPort); } function findRelation_pathOn(urlObj, siteUrlObj, options) { var queryOnly = urlObj.extra.hrefInfo.minimumQueryOnly; var hashOnly = urlObj.extra.hrefInfo.minimumHashOnly; var empty = urlObj.extra.hrefInfo.empty; // not required, but self-documenting // From upToPath() var minimumPort = urlObj.extra.relation.minimumPort; var minimumScheme = urlObj.extra.relation.minimumScheme; // Matching port and path var minimumPath = minimumPort && urlObj.path.absolute.string === siteUrlObj.path.absolute.string; // Matching resource or query/hash-only or empty var matchingResource = urlObj.resource === siteUrlObj.resource || (!urlObj.resource && siteUrlObj.extra.resourceIsIndex) || (options.removeDirectoryIndexes && urlObj.extra.resourceIsIndex && !siteUrlObj.resource); var minimumResource = minimumPath && (matchingResource || queryOnly || hashOnly || empty); // Matching query or hash-only/empty var query = options.removeEmptyQueries ? "stripped" : "full"; var urlQuery = urlObj.query.string[query]; var siteUrlQuery = siteUrlObj.query.string[query]; var minimumQuery = (minimumResource && !!urlQuery && urlQuery === siteUrlQuery) || ((hashOnly || empty) && !urlObj.extra.hrefInfo.separatorOnlyQuery); var minimumHash = minimumQuery && urlObj.hash === siteUrlObj.hash; urlObj.extra.relation.minimumPath = minimumPath; urlObj.extra.relation.minimumResource = minimumResource; urlObj.extra.relation.minimumQuery = minimumQuery; urlObj.extra.relation.minimumHash = minimumHash; urlObj.extra.relation.maximumPort = !minimumScheme || (minimumScheme && !minimumPath); urlObj.extra.relation.maximumPath = !minimumScheme || (minimumScheme && !minimumResource); urlObj.extra.relation.maximumResource = !minimumScheme || (minimumScheme && !minimumQuery); urlObj.extra.relation.maximumQuery = !minimumScheme || (minimumScheme && !minimumHash); urlObj.extra.relation.maximumHash = !minimumScheme || (minimumScheme && !minimumHash); // there's nothing after hash, so it's the same as maximumQuery // Matching path and/or resource with existing but non-matching site query urlObj.extra.relation.overridesQuery = minimumPath && urlObj.extra.relation.maximumResource && !minimumQuery && !!siteUrlQuery; } module.exports = { pathOn: findRelation_pathOn, upToPath: findRelation_upToPath }; }, {} ], 140: [ function(require, module, exports) { "use strict"; var absolutize = require("./absolutize"); var relativize = require("./relativize"); function relateUrl(siteUrlObj, urlObj, options) { absolutize(urlObj, siteUrlObj, options); relativize(urlObj, siteUrlObj, options); return urlObj; } module.exports = relateUrl; }, { "./absolutize": 138, "./relativize": 141 } ], 141: [ function(require, module, exports) { "use strict"; var pathUtils = require("../util/path"); /* Get a path relative to the site path. */ function relatePath(absolutePath, siteAbsolutePath) { var relativePath = []; // At this point, it's related to the host/port var related = true; var parentIndex = -1; // Find parents siteAbsolutePath.forEach(function(siteAbsoluteDir, i) { if (related) { if (absolutePath[i] !== siteAbsoluteDir) { related = false; } else { parentIndex = i; } } if (!related) { // Up one level relativePath.push(".."); } }); // Form path absolutePath.forEach(function(dir, i) { if (i > parentIndex) { relativePath.push(dir); } }); return relativePath; } function relativize(urlObj, siteUrlObj, options) { if (urlObj.extra.relation.minimumScheme) { var pathArray = relatePath( urlObj.path.absolute.array, siteUrlObj.path.absolute.array ); urlObj.path.relative.array = pathArray; urlObj.path.relative.string = pathUtils.join(pathArray); } } module.exports = relativize; }, { "../util/path": 143 } ], 142: [ function(require, module, exports) { "use strict"; /* Deep-clone an object. */ function clone(obj) { if (obj instanceof Object) { var clonedObj = obj instanceof Array ? [] : {}; for (var i in obj) { if (obj.hasOwnProperty(i)) { clonedObj[i] = clone(obj[i]); } } return clonedObj; } return obj; } /* https://github.com/jonschlinkert/is-plain-object */ function isPlainObject(obj) { return !!obj && typeof obj === "object" && obj.constructor === Object; } /* Shallow-merge two objects. */ function shallowMerge(target, source) { if (target instanceof Object && source instanceof Object) { for (var i in source) { if (source.hasOwnProperty(i)) { target[i] = source[i]; } } } return target; } module.exports = { clone: clone, isPlainObject: isPlainObject, shallowMerge: shallowMerge }; }, {} ], 143: [ function(require, module, exports) { "use strict"; function joinPath(pathArray) { if (pathArray.length > 0) { return pathArray.join("/") + "/"; } else { return ""; } } function resolveDotSegments(pathArray) { var pathAbsolute = []; pathArray.forEach(function(dir) { if (dir !== "..") { if (dir !== ".") { pathAbsolute.push(dir); } } else { // Remove parent if (pathAbsolute.length > 0) { pathAbsolute.splice(pathAbsolute.length - 1, 1); } } }); return pathAbsolute; } module.exports = { join: joinPath, resolveDotSegments: resolveDotSegments }; }, {} ], 144: [ function(require, module, exports) { /* 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); } // 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: 4 } ], 145: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var util = require("./util"); var has = Object.prototype.hasOwnProperty; var hasNativeMap = typeof Map !== "undefined"; /** * A data structure which is a combination of an array and a set. Adding a new * member is O(1), testing for membership is O(1), and finding the index of an * element is O(1). Removing elements from the set is not supported. Only * strings are supported for membership. */ function ArraySet() { this._array = []; this._set = hasNativeMap ? new Map() : Object.create(null); } /** * Static method for creating ArraySet instances from an existing array. */ ArraySet.fromArray = function ArraySet_fromArray( aArray, aAllowDuplicates ) { var set = new ArraySet(); for (var i = 0, len = aArray.length; i < len; i++) { set.add(aArray[i], aAllowDuplicates); } return set; }; /** * Return how many unique items are in this ArraySet. If duplicates have been * added, than those do not count towards the size. * * @returns Number */ ArraySet.prototype.size = function ArraySet_size() { return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length; }; /** * Add the given string to this set. * * @param String aStr */ ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) { var sStr = hasNativeMap ? aStr : util.toSetString(aStr); var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr); var idx = this._array.length; if (!isDuplicate || aAllowDuplicates) { this._array.push(aStr); } if (!isDuplicate) { if (hasNativeMap) { this._set.set(aStr, idx); } else { this._set[sStr] = idx; } } }; /** * Is the given string a member of this set? * * @param String aStr */ ArraySet.prototype.has = function ArraySet_has(aStr) { if (hasNativeMap) { return this._set.has(aStr); } else { var sStr = util.toSetString(aStr); return has.call(this._set, sStr); } }; /** * What is the index of the given string in the array? * * @param String aStr */ ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) { if (hasNativeMap) { var idx = this._set.get(aStr); if (idx >= 0) { return idx; } } else { var sStr = util.toSetString(aStr); if (has.call(this._set, sStr)) { return this._set[sStr]; } } throw new Error('"' + aStr + '" is not in the set.'); }; /** * What is the element at the given index? * * @param Number aIdx */ ArraySet.prototype.at = function ArraySet_at(aIdx) { if (aIdx >= 0 && aIdx < this._array.length) { return this._array[aIdx]; } throw new Error("No element indexed by " + aIdx); }; /** * Returns the array representation of this set (which has the proper indices * indicated by indexOf). Note that this is a copy of the internal array used * for storing the members so that no one can mess with internal state. */ ArraySet.prototype.toArray = function ArraySet_toArray() { return this._array.slice(); }; exports.ArraySet = ArraySet; }, { "./util": 154 } ], 146: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause * * Based on the Base 64 VLQ implementation in Closure Compiler: * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java * * Copyright 2011 The Closure Compiler Authors. All rights reserved. * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of Google Inc. nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ var base64 = require("./base64"); // A single base 64 digit can contain 6 bits of data. For the base 64 variable // length quantities we use in the source map spec, the first bit is the sign, // the next four bits are the actual value, and the 6th bit is the // continuation bit. The continuation bit tells us whether there are more // digits in this value following this digit. // // Continuation // | Sign // | | // V V // 101011 var VLQ_BASE_SHIFT = 5; // binary: 100000 var VLQ_BASE = 1 << VLQ_BASE_SHIFT; // binary: 011111 var VLQ_BASE_MASK = VLQ_BASE - 1; // binary: 100000 var VLQ_CONTINUATION_BIT = VLQ_BASE; /** * Converts from a two-complement value to a value where the sign bit is * placed in the least significant bit. For example, as decimals: * 1 becomes 2 (10 binary), -1 becomes 3 (11 binary) * 2 becomes 4 (100 binary), -2 becomes 5 (101 binary) */ function toVLQSigned(aValue) { return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0; } /** * Converts to a two-complement value from a value where the sign bit is * placed in the least significant bit. For example, as decimals: * 2 (10 binary) becomes 1, 3 (11 binary) becomes -1 * 4 (100 binary) becomes 2, 5 (101 binary) becomes -2 */ function fromVLQSigned(aValue) { var isNegative = (aValue & 1) === 1; var shifted = aValue >> 1; return isNegative ? -shifted : shifted; } /** * Returns the base 64 VLQ encoded value. */ exports.encode = function base64VLQ_encode(aValue) { var encoded = ""; var digit; var vlq = toVLQSigned(aValue); do { digit = vlq & VLQ_BASE_MASK; vlq >>>= VLQ_BASE_SHIFT; if (vlq > 0) { // There are still more digits in this value, so we must make sure the // continuation bit is marked. digit |= VLQ_CONTINUATION_BIT; } encoded += base64.encode(digit); } while (vlq > 0); return encoded; }; /** * Decodes the next base 64 VLQ value from the given string and returns the * value and the rest of the string via the out parameter. */ exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) { var strLen = aStr.length; var result = 0; var shift = 0; var continuation, digit; do { if (aIndex >= strLen) { throw new Error("Expected more digits in base 64 VLQ value."); } digit = base64.decode(aStr.charCodeAt(aIndex++)); if (digit === -1) { throw new Error( "Invalid base64 digit: " + aStr.charAt(aIndex - 1) ); } continuation = !!(digit & VLQ_CONTINUATION_BIT); digit &= VLQ_BASE_MASK; result = result + (digit << shift); shift += VLQ_BASE_SHIFT; } while (continuation); aOutParam.value = fromVLQSigned(result); aOutParam.rest = aIndex; }; }, { "./base64": 147 } ], 147: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split( "" ); /** * Encode an integer in the range of 0 to 63 to a single base 64 digit. */ exports.encode = function(number) { if (0 <= number && number < intToCharMap.length) { return intToCharMap[number]; } throw new TypeError("Must be between 0 and 63: " + number); }; /** * Decode a single base 64 character code digit to an integer. Returns -1 on * failure. */ exports.decode = function(charCode) { var bigA = 65; // 'A' var bigZ = 90; // 'Z' var littleA = 97; // 'a' var littleZ = 122; // 'z' var zero = 48; // '0' var nine = 57; // '9' var plus = 43; // '+' var slash = 47; // '/' var littleOffset = 26; var numberOffset = 52; // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ if (bigA <= charCode && charCode <= bigZ) { return charCode - bigA; } // 26 - 51: abcdefghijklmnopqrstuvwxyz if (littleA <= charCode && charCode <= littleZ) { return charCode - littleA + littleOffset; } // 52 - 61: 0123456789 if (zero <= charCode && charCode <= nine) { return charCode - zero + numberOffset; } // 62: + if (charCode == plus) { return 62; } // 63: / if (charCode == slash) { return 63; } // Invalid base64 digit. return -1; }; }, {} ], 148: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ exports.GREATEST_LOWER_BOUND = 1; exports.LEAST_UPPER_BOUND = 2; /** * Recursive implementation of binary search. * * @param aLow Indices here and lower do not contain the needle. * @param aHigh Indices here and higher do not contain the needle. * @param aNeedle The element being searched for. * @param aHaystack The non-empty array being searched. * @param aCompare Function which takes two elements and returns -1, 0, or 1. * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the * closest element that is smaller than or greater than the one we are * searching for, respectively, if the exact element cannot be found. */ function recursiveSearch( aLow, aHigh, aNeedle, aHaystack, aCompare, aBias ) { // This function terminates when one of the following is true: // // 1. We find the exact element we are looking for. // // 2. We did not find the exact element, but we can return the index of // the next-closest element. // // 3. We did not find the exact element, and there is no next-closest // element than the one we are searching for, so we return -1. var mid = Math.floor((aHigh - aLow) / 2) + aLow; var cmp = aCompare(aNeedle, aHaystack[mid], true); if (cmp === 0) { // Found the element we are looking for. return mid; } else if (cmp > 0) { // Our needle is greater than aHaystack[mid]. if (aHigh - mid > 1) { // The element is in the upper half. return recursiveSearch( mid, aHigh, aNeedle, aHaystack, aCompare, aBias ); } // The exact needle element was not found in this haystack. Determine if // we are in termination case (3) or (2) and return the appropriate thing. if (aBias == exports.LEAST_UPPER_BOUND) { return aHigh < aHaystack.length ? aHigh : -1; } else { return mid; } } else { // Our needle is less than aHaystack[mid]. if (mid - aLow > 1) { // The element is in the lower half. return recursiveSearch( aLow, mid, aNeedle, aHaystack, aCompare, aBias ); } // we are in termination case (3) or (2) and return the appropriate thing. if (aBias == exports.LEAST_UPPER_BOUND) { return mid; } else { return aLow < 0 ? -1 : aLow; } } } /** * This is an implementation of binary search which will always try and return * the index of the closest element if there is no exact hit. This is because * mappings between original and generated line/col pairs are single points, * and there is an implicit region between each of them, so a miss just means * that you aren't on the very start of a region. * * @param aNeedle The element you are looking for. * @param aHaystack The array that is being searched. * @param aCompare A function which takes the needle and an element in the * array and returns -1, 0, or 1 depending on whether the needle is less * than, equal to, or greater than the element, respectively. * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or * 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the * closest element that is smaller than or greater than the one we are * searching for, respectively, if the exact element cannot be found. * Defaults to 'binarySearch.GREATEST_LOWER_BOUND'. */ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) { if (aHaystack.length === 0) { return -1; } var index = recursiveSearch( -1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND ); if (index < 0) { return -1; } // We have found either the exact element, or the next-closest element than // the one we are searching for. However, there may be more than one such // element. Make sure we always return the smallest of these. while (index - 1 >= 0) { if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) { break; } --index; } return index; }; }, {} ], 149: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2014 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var util = require("./util"); /** * Determine whether mappingB is after mappingA with respect to generated * position. */ function generatedPositionAfter(mappingA, mappingB) { // Optimized for most common case var lineA = mappingA.generatedLine; var lineB = mappingB.generatedLine; var columnA = mappingA.generatedColumn; var columnB = mappingB.generatedColumn; return ( lineB > lineA || (lineB == lineA && columnB >= columnA) || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0 ); } /** * A data structure to provide a sorted view of accumulated mappings in a * performance conscious manner. It trades a neglibable overhead in general * case for a large speedup in case of mappings being added in order. */ function MappingList() { this._array = []; this._sorted = true; // Serves as infimum this._last = { generatedLine: -1, generatedColumn: 0 }; } /** * Iterate through internal items. This method takes the same arguments that * `Array.prototype.forEach` takes. * * NOTE: The order of the mappings is NOT guaranteed. */ MappingList.prototype.unsortedForEach = function MappingList_forEach( aCallback, aThisArg ) { this._array.forEach(aCallback, aThisArg); }; /** * Add the given source mapping. * * @param Object aMapping */ MappingList.prototype.add = function MappingList_add(aMapping) { if (generatedPositionAfter(this._last, aMapping)) { this._last = aMapping; this._array.push(aMapping); } else { this._sorted = false; this._array.push(aMapping); } }; /** * Returns the flat, sorted array of mappings. The mappings are sorted by * generated position. * * WARNING: This method returns internal data without copying, for * performance. The return value must NOT be mutated, and should be treated as * an immutable borrow. If you want to take ownership, you must make your own * copy. */ MappingList.prototype.toArray = function MappingList_toArray() { if (!this._sorted) { this._array.sort(util.compareByGeneratedPositionsInflated); this._sorted = true; } return this._array; }; exports.MappingList = MappingList; }, { "./util": 154 } ], 150: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ // It turns out that some (most?) JavaScript engines don't self-host // `Array.prototype.sort`. This makes sense because C++ will likely remain // faster than JS when doing raw CPU-intensive sorting. However, when using a // custom comparator function, calling back and forth between the VM's C++ and // JIT'd JS is rather slow *and* loses JIT type information, resulting in // worse generated code for the comparator function than would be optimal. In // fact, when sorting with a comparator, these costs outweigh the benefits of // sorting in C++. By using our own JS-implemented Quick Sort (below), we get // a ~3500ms mean speed-up in `bench/bench.html`. /** * Swap the elements indexed by `x` and `y` in the array `ary`. * * @param {Array} ary * The array. * @param {Number} x * The index of the first item. * @param {Number} y * The index of the second item. */ function swap(ary, x, y) { var temp = ary[x]; ary[x] = ary[y]; ary[y] = temp; } /** * Returns a random integer within the range `low .. high` inclusive. * * @param {Number} low * The lower bound on the range. * @param {Number} high * The upper bound on the range. */ function randomIntInRange(low, high) { return Math.round(low + Math.random() * (high - low)); } /** * The Quick Sort algorithm. * * @param {Array} ary * An array to sort. * @param {function} comparator * Function to use to compare two items. * @param {Number} p * Start index of the array * @param {Number} r * End index of the array */ function doQuickSort(ary, comparator, p, r) { // If our lower bound is less than our upper bound, we (1) partition the // array into two pieces and (2) recurse on each half. If it is not, this is // the empty array and our base case. if (p < r) { // (1) Partitioning. // // The partitioning chooses a pivot between `p` and `r` and moves all // elements that are less than or equal to the pivot to the before it, and // all the elements that are greater than it after it. The effect is that // once partition is done, the pivot is in the exact place it will be when // the array is put in sorted order, and it will not need to be moved // again. This runs in O(n) time. // Always choose a random pivot so that an input array which is reverse // sorted does not cause O(n^2) running time. var pivotIndex = randomIntInRange(p, r); var i = p - 1; swap(ary, pivotIndex, r); var pivot = ary[r]; // Immediately after `j` is incremented in this loop, the following hold // true: // // * Every element in `ary[p .. i]` is less than or equal to the pivot. // // * Every element in `ary[i+1 .. j-1]` is greater than the pivot. for (var j = p; j < r; j++) { if (comparator(ary[j], pivot) <= 0) { i += 1; swap(ary, i, j); } } swap(ary, i + 1, j); var q = i + 1; // (2) Recurse on each half. doQuickSort(ary, comparator, p, q - 1); doQuickSort(ary, comparator, q + 1, r); } } /** * Sort the given array in-place with the given comparator function. * * @param {Array} ary * An array to sort. * @param {function} comparator * Function to use to compare two items. */ exports.quickSort = function(ary, comparator) { doQuickSort(ary, comparator, 0, ary.length - 1); }; }, {} ], 151: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var util = require("./util"); var binarySearch = require("./binary-search"); var ArraySet = require("./array-set").ArraySet; var base64VLQ = require("./base64-vlq"); var quickSort = require("./quick-sort").quickSort; function SourceMapConsumer(aSourceMap, aSourceMapURL) { var sourceMap = aSourceMap; if (typeof aSourceMap === "string") { sourceMap = util.parseSourceMapInput(aSourceMap); } return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL); } SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) { return BasicSourceMapConsumer.fromSourceMap( aSourceMap, aSourceMapURL ); }; /** * The version of the source mapping spec that we are consuming. */ SourceMapConsumer.prototype._version = 3; // `__generatedMappings` and `__originalMappings` are arrays that hold the // parsed mapping coordinates from the source map's "mappings" attribute. They // are lazily instantiated, accessed via the `_generatedMappings` and // `_originalMappings` getters respectively, and we only parse the mappings // and create these arrays once queried for a source location. We jump through // these hoops because there can be many thousands of mappings, and parsing // them is expensive, so we only want to do it if we must. // // Each object in the arrays is of the form: // // { // generatedLine: The line number in the generated code, // generatedColumn: The column number in the generated code, // source: The path to the original source file that generated this // chunk of code, // originalLine: The line number in the original source that // corresponds to this chunk of generated code, // originalColumn: The column number in the original source that // corresponds to this chunk of generated code, // name: The name of the original symbol which generated this chunk of // code. // } // // All properties except for `generatedLine` and `generatedColumn` can be // `null`. // // `_generatedMappings` is ordered by the generated positions. // // `_originalMappings` is ordered by the original positions. SourceMapConsumer.prototype.__generatedMappings = null; Object.defineProperty( SourceMapConsumer.prototype, "_generatedMappings", { configurable: true, enumerable: true, get: function() { if (!this.__generatedMappings) { this._parseMappings(this._mappings, this.sourceRoot); } return this.__generatedMappings; } } ); SourceMapConsumer.prototype.__originalMappings = null; Object.defineProperty( SourceMapConsumer.prototype, "_originalMappings", { configurable: true, enumerable: true, get: function() { if (!this.__originalMappings) { this._parseMappings(this._mappings, this.sourceRoot); } return this.__originalMappings; } } ); SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator( aStr, index ) { var c = aStr.charAt(index); return c === ";" || c === ","; }; /** * Parse the mappings in a string in to a data structure which we can easily * query (the ordered arrays in the `this.__generatedMappings` and * `this.__originalMappings` properties). */ SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings( aStr, aSourceRoot ) { throw new Error("Subclasses must implement _parseMappings"); }; SourceMapConsumer.GENERATED_ORDER = 1; SourceMapConsumer.ORIGINAL_ORDER = 2; SourceMapConsumer.GREATEST_LOWER_BOUND = 1; SourceMapConsumer.LEAST_UPPER_BOUND = 2; /** * Iterate over each mapping between an original source/line/column and a * generated line/column in this source map. * * @param Function aCallback * The function that is called with each mapping. * @param Object aContext * Optional. If specified, this object will be the value of `this` every * time that `aCallback` is called. * @param aOrder * Either `SourceMapConsumer.GENERATED_ORDER` or * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to * iterate over the mappings sorted by the generated file's line/column * order or the original's source/line/column order, respectively. Defaults to * `SourceMapConsumer.GENERATED_ORDER`. */ SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping( aCallback, aContext, aOrder ) { var context = aContext || null; var order = aOrder || SourceMapConsumer.GENERATED_ORDER; var mappings; switch (order) { case SourceMapConsumer.GENERATED_ORDER: mappings = this._generatedMappings; break; case SourceMapConsumer.ORIGINAL_ORDER: mappings = this._originalMappings; break; default: throw new Error("Unknown order of iteration."); } var sourceRoot = this.sourceRoot; mappings .map(function(mapping) { var source = mapping.source === null ? null : this._sources.at(mapping.source); source = util.computeSourceURL( sourceRoot, source, this._sourceMapURL ); return { source: source, generatedLine: mapping.generatedLine, generatedColumn: mapping.generatedColumn, originalLine: mapping.originalLine, originalColumn: mapping.originalColumn, name: mapping.name === null ? null : this._names.at(mapping.name) }; }, this) .forEach(aCallback, context); }; /** * Returns all generated line and column information for the original source, * line, and column provided. If no column is provided, returns all mappings * corresponding to a either the line we are searching for or the next * closest line that has any mappings. Otherwise, returns all mappings * corresponding to the given line and either the column we are searching for * or the next closest column that has any offsets. * * The only argument is an object with the following properties: * * - source: The filename of the original source. * - line: The line number in the original source. The line number is 1-based. * - column: Optional. the column number in the original source. * The column number is 0-based. * * and an array of objects is returned, each with the following properties: * * - line: The line number in the generated source, or null. The * line number is 1-based. * - column: The column number in the generated source, or null. * The column number is 0-based. */ SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor( aArgs ) { var line = util.getArg(aArgs, "line"); // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping // returns the index of the closest mapping less than the needle. By // setting needle.originalColumn to 0, we thus find the last mapping for // the given line, provided such a mapping exists. var needle = { source: util.getArg(aArgs, "source"), originalLine: line, originalColumn: util.getArg(aArgs, "column", 0) }; needle.source = this._findSourceIndex(needle.source); if (needle.source < 0) { return []; } var mappings = []; var index = this._findMapping( needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND ); if (index >= 0) { var mapping = this._originalMappings[index]; if (aArgs.column === undefined) { var originalLine = mapping.originalLine; // Iterate until either we run out of mappings, or we run into // a mapping for a different line than the one we found. Since // mappings are sorted, this is guaranteed to find all mappings for // the line we found. while (mapping && mapping.originalLine === originalLine) { mappings.push({ line: util.getArg(mapping, "generatedLine", null), column: util.getArg(mapping, "generatedColumn", null), lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) }); mapping = this._originalMappings[++index]; } } else { var originalColumn = mapping.originalColumn; // Iterate until either we run out of mappings, or we run into // a mapping for a different line than the one we were searching for. // Since mappings are sorted, this is guaranteed to find all mappings for // the line we are searching for. while ( mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn ) { mappings.push({ line: util.getArg(mapping, "generatedLine", null), column: util.getArg(mapping, "generatedColumn", null), lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) }); mapping = this._originalMappings[++index]; } } } return mappings; }; exports.SourceMapConsumer = SourceMapConsumer; /** * A BasicSourceMapConsumer instance represents a parsed source map which we can * query for information about the original file positions by giving it a file * position in the generated source. * * The first parameter is the raw source map (either as a JSON string, or * already parsed to an object). According to the spec, source maps have the * following attributes: * * - version: Which version of the source map spec this map is following. * - sources: An array of URLs to the original source files. * - names: An array of identifiers which can be referrenced by individual mappings. * - sourceRoot: Optional. The URL root from which all sources are relative. * - sourcesContent: Optional. An array of contents of the original source files. * - mappings: A string of base64 VLQs which contain the actual mappings. * - file: Optional. The generated file this source map is associated with. * * Here is an example source map, taken from the source map spec[0]: * * { * version : 3, * file: "out.js", * sourceRoot : "", * sources: ["foo.js", "bar.js"], * names: ["src", "maps", "are", "fun"], * mappings: "AA,AB;;ABCDE;" * } * * The second parameter, if given, is a string whose value is the URL * at which the source map was found. This URL is used to compute the * sources array. * * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1# */ function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) { var sourceMap = aSourceMap; if (typeof aSourceMap === "string") { sourceMap = util.parseSourceMapInput(aSourceMap); } var version = util.getArg(sourceMap, "version"); var sources = util.getArg(sourceMap, "sources"); // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which // requires the array) to play nice here. var names = util.getArg(sourceMap, "names", []); var sourceRoot = util.getArg(sourceMap, "sourceRoot", null); var sourcesContent = util.getArg(sourceMap, "sourcesContent", null); var mappings = util.getArg(sourceMap, "mappings"); var file = util.getArg(sourceMap, "file", null); // Once again, Sass deviates from the spec and supplies the version as a // string rather than a number, so we use loose equality checking here. if (version != this._version) { throw new Error("Unsupported version: " + version); } if (sourceRoot) { sourceRoot = util.normalize(sourceRoot); } sources = sources .map(String) // Some source maps produce relative source paths like "./foo.js" instead of // "foo.js". Normalize these first so that future comparisons will succeed. // See bugzil.la/1090768. .map(util.normalize) // Always ensure that absolute sources are internally stored relative to // the source root, if the source root is absolute. Not doing this would // be particularly problematic when the source root is a prefix of the // source (valid, but why??). See github issue #199 and bugzil.la/1188982. .map(function(source) { return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source; }); // Pass `true` below to allow duplicate names and sources. While source maps // are intended to be compressed and deduplicated, the TypeScript compiler // sometimes generates source maps with duplicates in them. See Github issue // #72 and bugzil.la/889492. this._names = ArraySet.fromArray(names.map(String), true); this._sources = ArraySet.fromArray(sources, true); this._absoluteSources = this._sources.toArray().map(function(s) { return util.computeSourceURL(sourceRoot, s, aSourceMapURL); }); this.sourceRoot = sourceRoot; this.sourcesContent = sourcesContent; this._mappings = mappings; this._sourceMapURL = aSourceMapURL; this.file = file; } BasicSourceMapConsumer.prototype = Object.create( SourceMapConsumer.prototype ); BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer; /** * Utility function to find the index of a source. Returns -1 if not * found. */ BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) { var relativeSource = aSource; if (this.sourceRoot != null) { relativeSource = util.relative(this.sourceRoot, relativeSource); } if (this._sources.has(relativeSource)) { return this._sources.indexOf(relativeSource); } // Maybe aSource is an absolute URL as returned by |sources|. In // this case we can't simply undo the transform. var i; for (i = 0; i < this._absoluteSources.length; ++i) { if (this._absoluteSources[i] == aSource) { return i; } } return -1; }; /** * Create a BasicSourceMapConsumer from a SourceMapGenerator. * * @param SourceMapGenerator aSourceMap * The source map that will be consumed. * @param String aSourceMapURL * The URL at which the source map can be found (optional) * @returns BasicSourceMapConsumer */ BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap( aSourceMap, aSourceMapURL ) { var smc = Object.create(BasicSourceMapConsumer.prototype); var names = (smc._names = ArraySet.fromArray( aSourceMap._names.toArray(), true )); var sources = (smc._sources = ArraySet.fromArray( aSourceMap._sources.toArray(), true )); smc.sourceRoot = aSourceMap._sourceRoot; smc.sourcesContent = aSourceMap._generateSourcesContent( smc._sources.toArray(), smc.sourceRoot ); smc.file = aSourceMap._file; smc._sourceMapURL = aSourceMapURL; smc._absoluteSources = smc._sources.toArray().map(function(s) { return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL); }); // Because we are modifying the entries (by converting string sources and // names to indices into the sources and names ArraySets), we have to make // a copy of the entry or else bad things happen. Shared mutable state // strikes again! See github issue #191. var generatedMappings = aSourceMap._mappings.toArray().slice(); var destGeneratedMappings = (smc.__generatedMappings = []); var destOriginalMappings = (smc.__originalMappings = []); for (var i = 0, length = generatedMappings.length; i < length; i++) { var srcMapping = generatedMappings[i]; var destMapping = new Mapping(); destMapping.generatedLine = srcMapping.generatedLine; destMapping.generatedColumn = srcMapping.generatedColumn; if (srcMapping.source) { destMapping.source = sources.indexOf(srcMapping.source); destMapping.originalLine = srcMapping.originalLine; destMapping.originalColumn = srcMapping.originalColumn; if (srcMapping.name) { destMapping.name = names.indexOf(srcMapping.name); } destOriginalMappings.push(destMapping); } destGeneratedMappings.push(destMapping); } quickSort(smc.__originalMappings, util.compareByOriginalPositions); return smc; }; /** * The version of the source mapping spec that we are consuming. */ BasicSourceMapConsumer.prototype._version = 3; /** * The list of original sources. */ Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { get: function() { return this._absoluteSources.slice(); } }); /** * Provide the JIT with a nice shape / hidden class. */ function Mapping() { this.generatedLine = 0; this.generatedColumn = 0; this.source = null; this.originalLine = null; this.originalColumn = null; this.name = null; } /** * Parse the mappings in a string in to a data structure which we can easily * query (the ordered arrays in the `this.__generatedMappings` and * `this.__originalMappings` properties). */ BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings( aStr, aSourceRoot ) { var generatedLine = 1; var previousGeneratedColumn = 0; var previousOriginalLine = 0; var previousOriginalColumn = 0; var previousSource = 0; var previousName = 0; var length = aStr.length; var index = 0; var cachedSegments = {}; var temp = {}; var originalMappings = []; var generatedMappings = []; var mapping, str, segment, end, value; while (index < length) { if (aStr.charAt(index) === ";") { generatedLine++; index++; previousGeneratedColumn = 0; } else if (aStr.charAt(index) === ",") { index++; } else { mapping = new Mapping(); mapping.generatedLine = generatedLine; // Because each offset is encoded relative to the previous one, // many segments often have the same encoding. We can exploit this // fact by caching the parsed variable length fields of each segment, // allowing us to avoid a second parse if we encounter the same // segment again. for (end = index; end < length; end++) { if (this._charIsMappingSeparator(aStr, end)) { break; } } str = aStr.slice(index, end); segment = cachedSegments[str]; if (segment) { index += str.length; } else { segment = []; while (index < end) { base64VLQ.decode(aStr, index, temp); value = temp.value; index = temp.rest; segment.push(value); } if (segment.length === 2) { throw new Error("Found a source, but no line and column"); } if (segment.length === 3) { throw new Error("Found a source and line, but no column"); } cachedSegments[str] = segment; } // Generated column. mapping.generatedColumn = previousGeneratedColumn + segment[0]; previousGeneratedColumn = mapping.generatedColumn; if (segment.length > 1) { // Original source. mapping.source = previousSource + segment[1]; previousSource += segment[1]; // Original line. mapping.originalLine = previousOriginalLine + segment[2]; previousOriginalLine = mapping.originalLine; // Lines are stored 0-based mapping.originalLine += 1; // Original column. mapping.originalColumn = previousOriginalColumn + segment[3]; previousOriginalColumn = mapping.originalColumn; if (segment.length > 4) { // Original name. mapping.name = previousName + segment[4]; previousName += segment[4]; } } generatedMappings.push(mapping); if (typeof mapping.originalLine === "number") { originalMappings.push(mapping); } } } quickSort( generatedMappings, util.compareByGeneratedPositionsDeflated ); this.__generatedMappings = generatedMappings; quickSort(originalMappings, util.compareByOriginalPositions); this.__originalMappings = originalMappings; }; /** * Find the mapping that best matches the hypothetical "needle" mapping that * we are searching for in the given "haystack" of mappings. */ BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping( aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias ) { // To return the position we are searching for, we must first find the // mapping for the given position and then return the opposite position it // points to. Because the mappings are sorted, we can use binary search to // find the best mapping. if (aNeedle[aLineName] <= 0) { throw new TypeError( "Line must be greater than or equal to 1, got " + aNeedle[aLineName] ); } if (aNeedle[aColumnName] < 0) { throw new TypeError( "Column must be greater than or equal to 0, got " + aNeedle[aColumnName] ); } return binarySearch.search(aNeedle, aMappings, aComparator, aBias); }; /** * Compute the last column for each generated mapping. The last column is * inclusive. */ BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() { for (var index = 0; index < this._generatedMappings.length; ++index) { var mapping = this._generatedMappings[index]; // Mappings do not contain a field for the last generated columnt. We // can come up with an optimistic estimate, however, by assuming that // mappings are contiguous (i.e. given two consecutive mappings, the // first mapping ends where the second one starts). if (index + 1 < this._generatedMappings.length) { var nextMapping = this._generatedMappings[index + 1]; if (mapping.generatedLine === nextMapping.generatedLine) { mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1; continue; } } // The last mapping for each line spans the entire line. mapping.lastGeneratedColumn = Infinity; } }; /** * Returns the original source, line, and column information for the generated * source's line and column positions provided. The only argument is an object * with the following properties: * * - line: The line number in the generated source. The line number * is 1-based. * - column: The column number in the generated source. The column * number is 0-based. * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the * closest element that is smaller than or greater than the one we are * searching for, respectively, if the exact element cannot be found. * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'. * * and an object is returned with the following properties: * * - source: The original source file, or null. * - line: The line number in the original source, or null. The * line number is 1-based. * - column: The column number in the original source, or null. The * column number is 0-based. * - name: The original identifier, or null. */ BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor( aArgs ) { var needle = { generatedLine: util.getArg(aArgs, "line"), generatedColumn: util.getArg(aArgs, "column") }; var index = this._findMapping( needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND) ); if (index >= 0) { var mapping = this._generatedMappings[index]; if (mapping.generatedLine === needle.generatedLine) { var source = util.getArg(mapping, "source", null); if (source !== null) { source = this._sources.at(source); source = util.computeSourceURL( this.sourceRoot, source, this._sourceMapURL ); } var name = util.getArg(mapping, "name", null); if (name !== null) { name = this._names.at(name); } return { source: source, line: util.getArg(mapping, "originalLine", null), column: util.getArg(mapping, "originalColumn", null), name: name }; } } return { source: null, line: null, column: null, name: null }; }; /** * Return true if we have the source content for every source in the source * map, false otherwise. */ BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() { if (!this.sourcesContent) { return false; } return ( this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) { return sc == null; }) ); }; /** * Returns the original source content. The only argument is the url of the * original source file. Returns null if no original source content is * available. */ BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor( aSource, nullOnMissing ) { if (!this.sourcesContent) { return null; } var index = this._findSourceIndex(aSource); if (index >= 0) { return this.sourcesContent[index]; } var relativeSource = aSource; if (this.sourceRoot != null) { relativeSource = util.relative(this.sourceRoot, relativeSource); } var url; if ( this.sourceRoot != null && (url = util.urlParse(this.sourceRoot)) ) { // XXX: file:// URIs and absolute paths lead to unexpected behavior for // many users. We can help them out when they expect file:// URIs to // behave like it would if they were running a local HTTP server. See // https://bugzilla.mozilla.org/show_bug.cgi?id=885597. var fileUriAbsPath = relativeSource.replace(/^file:\/\//, ""); if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) { return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]; } if ( (!url.path || url.path == "/") && this._sources.has("/" + relativeSource) ) { return this.sourcesContent[ this._sources.indexOf("/" + relativeSource) ]; } } // This function is used recursively from // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we // don't want to throw if we can't find the source - we just want to // return null, so we provide a flag to exit gracefully. if (nullOnMissing) { return null; } else { throw new Error( '"' + relativeSource + '" is not in the SourceMap.' ); } }; /** * Returns the generated line and column information for the original source, * line, and column positions provided. The only argument is an object with * the following properties: * * - source: The filename of the original source. * - line: The line number in the original source. The line number * is 1-based. * - column: The column number in the original source. The column * number is 0-based. * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the * closest element that is smaller than or greater than the one we are * searching for, respectively, if the exact element cannot be found. * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'. * * and an object is returned with the following properties: * * - line: The line number in the generated source, or null. The * line number is 1-based. * - column: The column number in the generated source, or null. * The column number is 0-based. */ BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor( aArgs ) { var source = util.getArg(aArgs, "source"); source = this._findSourceIndex(source); if (source < 0) { return { line: null, column: null, lastColumn: null }; } var needle = { source: source, originalLine: util.getArg(aArgs, "line"), originalColumn: util.getArg(aArgs, "column") }; var index = this._findMapping( needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND) ); if (index >= 0) { var mapping = this._originalMappings[index]; if (mapping.source === needle.source) { return { line: util.getArg(mapping, "generatedLine", null), column: util.getArg(mapping, "generatedColumn", null), lastColumn: util.getArg(mapping, "lastGeneratedColumn", null) }; } } return { line: null, column: null, lastColumn: null }; }; exports.BasicSourceMapConsumer = BasicSourceMapConsumer; /** * An IndexedSourceMapConsumer instance represents a parsed source map which * we can query for information. It differs from BasicSourceMapConsumer in * that it takes "indexed" source maps (i.e. ones with a "sections" field) as * input. * * The first parameter is a raw source map (either as a JSON string, or already * parsed to an object). According to the spec for indexed source maps, they * have the following attributes: * * - version: Which version of the source map spec this map is following. * - file: Optional. The generated file this source map is associated with. * - sections: A list of section definitions. * * Each value under the "sections" field has two fields: * - offset: The offset into the original specified at which this section * begins to apply, defined as an object with a "line" and "column" * field. * - map: A source map definition. This source map could also be indexed, * but doesn't have to be. * * Instead of the "map" field, it's also possible to have a "url" field * specifying a URL to retrieve a source map from, but that's currently * unsupported. * * Here's an example source map, taken from the source map spec[0], but * modified to omit a section which uses the "url" field. * * { * version : 3, * file: "app.js", * sections: [{ * offset: {line:100, column:10}, * map: { * version : 3, * file: "section.js", * sources: ["foo.js", "bar.js"], * names: ["src", "maps", "are", "fun"], * mappings: "AAAA,E;;ABCDE;" * } * }], * } * * The second parameter, if given, is a string whose value is the URL * at which the source map was found. This URL is used to compute the * sources array. * * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt */ function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) { var sourceMap = aSourceMap; if (typeof aSourceMap === "string") { sourceMap = util.parseSourceMapInput(aSourceMap); } var version = util.getArg(sourceMap, "version"); var sections = util.getArg(sourceMap, "sections"); if (version != this._version) { throw new Error("Unsupported version: " + version); } this._sources = new ArraySet(); this._names = new ArraySet(); var lastOffset = { line: -1, column: 0 }; this._sections = sections.map(function(s) { if (s.url) { // The url field will require support for asynchronicity. // See https://github.com/mozilla/source-map/issues/16 throw new Error( "Support for url field in sections not implemented." ); } var offset = util.getArg(s, "offset"); var offsetLine = util.getArg(offset, "line"); var offsetColumn = util.getArg(offset, "column"); if ( offsetLine < lastOffset.line || (offsetLine === lastOffset.line && offsetColumn < lastOffset.column) ) { throw new Error( "Section offsets must be ordered and non-overlapping." ); } lastOffset = offset; return { generatedOffset: { // The offset fields are 0-based, but we use 1-based indices when // encoding/decoding from VLQ. generatedLine: offsetLine + 1, generatedColumn: offsetColumn + 1 }, consumer: new SourceMapConsumer( util.getArg(s, "map"), aSourceMapURL ) }; }); } IndexedSourceMapConsumer.prototype = Object.create( SourceMapConsumer.prototype ); IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer; /** * The version of the source mapping spec that we are consuming. */ IndexedSourceMapConsumer.prototype._version = 3; /** * The list of original sources. */ Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { get: function() { var sources = []; for (var i = 0; i < this._sections.length; i++) { for ( var j = 0; j < this._sections[i].consumer.sources.length; j++ ) { sources.push(this._sections[i].consumer.sources[j]); } } return sources; } }); /** * Returns the original source, line, and column information for the generated * source's line and column positions provided. The only argument is an object * with the following properties: * * - line: The line number in the generated source. The line number * is 1-based. * - column: The column number in the generated source. The column * number is 0-based. * * and an object is returned with the following properties: * * - source: The original source file, or null. * - line: The line number in the original source, or null. The * line number is 1-based. * - column: The column number in the original source, or null. The * column number is 0-based. * - name: The original identifier, or null. */ IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor( aArgs ) { var needle = { generatedLine: util.getArg(aArgs, "line"), generatedColumn: util.getArg(aArgs, "column") }; // Find the section containing the generated position we're trying to map // to an original position. var sectionIndex = binarySearch.search( needle, this._sections, function(needle, section) { var cmp = needle.generatedLine - section.generatedOffset.generatedLine; if (cmp) { return cmp; } return ( needle.generatedColumn - section.generatedOffset.generatedColumn ); } ); var section = this._sections[sectionIndex]; if (!section) { return { source: null, line: null, column: null, name: null }; } return section.consumer.originalPositionFor({ line: needle.generatedLine - (section.generatedOffset.generatedLine - 1), column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), bias: aArgs.bias }); }; /** * Return true if we have the source content for every source in the source * map, false otherwise. */ IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() { return this._sections.every(function(s) { return s.consumer.hasContentsOfAllSources(); }); }; /** * Returns the original source content. The only argument is the url of the * original source file. Returns null if no original source content is * available. */ IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor( aSource, nullOnMissing ) { for (var i = 0; i < this._sections.length; i++) { var section = this._sections[i]; var content = section.consumer.sourceContentFor(aSource, true); if (content) { return content; } } if (nullOnMissing) { return null; } else { throw new Error('"' + aSource + '" is not in the SourceMap.'); } }; /** * Returns the generated line and column information for the original source, * line, and column positions provided. The only argument is an object with * the following properties: * * - source: The filename of the original source. * - line: The line number in the original source. The line number * is 1-based. * - column: The column number in the original source. The column * number is 0-based. * * and an object is returned with the following properties: * * - line: The line number in the generated source, or null. The * line number is 1-based. * - column: The column number in the generated source, or null. * The column number is 0-based. */ IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor( aArgs ) { for (var i = 0; i < this._sections.length; i++) { var section = this._sections[i]; // Only consider this section if the requested source is in the list of // sources of the consumer. if ( section.consumer._findSourceIndex( util.getArg(aArgs, "source") ) === -1 ) { continue; } var generatedPosition = section.consumer.generatedPositionFor( aArgs ); if (generatedPosition) { var ret = { line: generatedPosition.line + (section.generatedOffset.generatedLine - 1), column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0) }; return ret; } } return { line: null, column: null }; }; /** * Parse the mappings in a string in to a data structure which we can easily * query (the ordered arrays in the `this.__generatedMappings` and * `this.__originalMappings` properties). */ IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings( aStr, aSourceRoot ) { this.__generatedMappings = []; this.__originalMappings = []; for (var i = 0; i < this._sections.length; i++) { var section = this._sections[i]; var sectionMappings = section.consumer._generatedMappings; for (var j = 0; j < sectionMappings.length; j++) { var mapping = sectionMappings[j]; var source = section.consumer._sources.at(mapping.source); source = util.computeSourceURL( section.consumer.sourceRoot, source, this._sourceMapURL ); this._sources.add(source); source = this._sources.indexOf(source); var name = null; if (mapping.name) { name = section.consumer._names.at(mapping.name); this._names.add(name); name = this._names.indexOf(name); } // The mappings coming from the consumer for the section have // generated positions relative to the start of the section, so we // need to offset them to be relative to the start of the concatenated // generated file. var adjustedMapping = { source: source, generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1), generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0), originalLine: mapping.originalLine, originalColumn: mapping.originalColumn, name: name }; this.__generatedMappings.push(adjustedMapping); if (typeof adjustedMapping.originalLine === "number") { this.__originalMappings.push(adjustedMapping); } } } quickSort( this.__generatedMappings, util.compareByGeneratedPositionsDeflated ); quickSort(this.__originalMappings, util.compareByOriginalPositions); }; exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer; }, { "./array-set": 145, "./base64-vlq": 146, "./binary-search": 148, "./quick-sort": 150, "./util": 154 } ], 152: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var base64VLQ = require("./base64-vlq"); var util = require("./util"); var ArraySet = require("./array-set").ArraySet; var MappingList = require("./mapping-list").MappingList; /** * An instance of the SourceMapGenerator represents a source map which is * being built incrementally. You may pass an object with the following * properties: * * - file: The filename of the generated source. * - sourceRoot: A root for all relative URLs in this source map. */ function SourceMapGenerator(aArgs) { if (!aArgs) { aArgs = {}; } this._file = util.getArg(aArgs, "file", null); this._sourceRoot = util.getArg(aArgs, "sourceRoot", null); this._skipValidation = util.getArg(aArgs, "skipValidation", false); this._sources = new ArraySet(); this._names = new ArraySet(); this._mappings = new MappingList(); this._sourcesContents = null; } SourceMapGenerator.prototype._version = 3; /** * Creates a new SourceMapGenerator based on a SourceMapConsumer * * @param aSourceMapConsumer The SourceMap. */ SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap( aSourceMapConsumer ) { var sourceRoot = aSourceMapConsumer.sourceRoot; var generator = new SourceMapGenerator({ file: aSourceMapConsumer.file, sourceRoot: sourceRoot }); aSourceMapConsumer.eachMapping(function(mapping) { var newMapping = { generated: { line: mapping.generatedLine, column: mapping.generatedColumn } }; if (mapping.source != null) { newMapping.source = mapping.source; if (sourceRoot != null) { newMapping.source = util.relative( sourceRoot, newMapping.source ); } newMapping.original = { line: mapping.originalLine, column: mapping.originalColumn }; if (mapping.name != null) { newMapping.name = mapping.name; } } generator.addMapping(newMapping); }); aSourceMapConsumer.sources.forEach(function(sourceFile) { var sourceRelative = sourceFile; if (sourceRoot !== null) { sourceRelative = util.relative(sourceRoot, sourceFile); } if (!generator._sources.has(sourceRelative)) { generator._sources.add(sourceRelative); } var content = aSourceMapConsumer.sourceContentFor(sourceFile); if (content != null) { generator.setSourceContent(sourceFile, content); } }); return generator; }; /** * Add a single mapping from original source line and column to the generated * source's line and column for this source map being created. The mapping * object should have the following properties: * * - generated: An object with the generated line and column positions. * - original: An object with the original line and column positions. * - source: The original source file (relative to the sourceRoot). * - name: An optional original token name for this mapping. */ SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping( aArgs ) { var generated = util.getArg(aArgs, "generated"); var original = util.getArg(aArgs, "original", null); var source = util.getArg(aArgs, "source", null); var name = util.getArg(aArgs, "name", null); if (!this._skipValidation) { this._validateMapping(generated, original, source, name); } if (source != null) { source = String(source); if (!this._sources.has(source)) { this._sources.add(source); } } if (name != null) { name = String(name); if (!this._names.has(name)) { this._names.add(name); } } this._mappings.add({ generatedLine: generated.line, generatedColumn: generated.column, originalLine: original != null && original.line, originalColumn: original != null && original.column, source: source, name: name }); }; /** * Set the source content for a source file. */ SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent( aSourceFile, aSourceContent ) { var source = aSourceFile; if (this._sourceRoot != null) { source = util.relative(this._sourceRoot, source); } if (aSourceContent != null) { // Add the source content to the _sourcesContents map. // Create a new _sourcesContents map if the property is null. if (!this._sourcesContents) { this._sourcesContents = Object.create(null); } this._sourcesContents[util.toSetString(source)] = aSourceContent; } else if (this._sourcesContents) { // Remove the source file from the _sourcesContents map. // If the _sourcesContents map is empty, set the property to null. delete this._sourcesContents[util.toSetString(source)]; if (Object.keys(this._sourcesContents).length === 0) { this._sourcesContents = null; } } }; /** * Applies the mappings of a sub-source-map for a specific source file to the * source map being generated. Each mapping to the supplied source file is * rewritten using the supplied source map. Note: The resolution for the * resulting mappings is the minimium of this map and the supplied map. * * @param aSourceMapConsumer The source map to be applied. * @param aSourceFile Optional. The filename of the source file. * If omitted, SourceMapConsumer's file property will be used. * @param aSourceMapPath Optional. The dirname of the path to the source map * to be applied. If relative, it is relative to the SourceMapConsumer. * This parameter is needed when the two source maps aren't in the same * directory, and the source map to be applied contains relative source * paths. If so, those relative source paths need to be rewritten * relative to the SourceMapGenerator. */ SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap( aSourceMapConsumer, aSourceFile, aSourceMapPath ) { var sourceFile = aSourceFile; // If aSourceFile is omitted, we will use the file property of the SourceMap if (aSourceFile == null) { if (aSourceMapConsumer.file == null) { throw new Error( "SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + 'or the source map\'s "file" property. Both were omitted.' ); } sourceFile = aSourceMapConsumer.file; } var sourceRoot = this._sourceRoot; // Make "sourceFile" relative if an absolute Url is passed. if (sourceRoot != null) { sourceFile = util.relative(sourceRoot, sourceFile); } // Applying the SourceMap can add and remove items from the sources and // the names array. var newSources = new ArraySet(); var newNames = new ArraySet(); // Find mappings for the "sourceFile" this._mappings.unsortedForEach(function(mapping) { if (mapping.source === sourceFile && mapping.originalLine != null) { // Check if it can be mapped by the source map, then update the mapping. var original = aSourceMapConsumer.originalPositionFor({ line: mapping.originalLine, column: mapping.originalColumn }); if (original.source != null) { // Copy mapping mapping.source = original.source; if (aSourceMapPath != null) { mapping.source = util.join(aSourceMapPath, mapping.source); } if (sourceRoot != null) { mapping.source = util.relative(sourceRoot, mapping.source); } mapping.originalLine = original.line; mapping.originalColumn = original.column; if (original.name != null) { mapping.name = original.name; } } } var source = mapping.source; if (source != null && !newSources.has(source)) { newSources.add(source); } var name = mapping.name; if (name != null && !newNames.has(name)) { newNames.add(name); } }, this); this._sources = newSources; this._names = newNames; // Copy sourcesContents of applied map. aSourceMapConsumer.sources.forEach(function(sourceFile) { var content = aSourceMapConsumer.sourceContentFor(sourceFile); if (content != null) { if (aSourceMapPath != null) { sourceFile = util.join(aSourceMapPath, sourceFile); } if (sourceRoot != null) { sourceFile = util.relative(sourceRoot, sourceFile); } this.setSourceContent(sourceFile, content); } }, this); }; /** * A mapping can have one of the three levels of data: * * 1. Just the generated position. * 2. The Generated position, original position, and original source. * 3. Generated and original position, original source, as well as a name * token. * * To maintain consistency, we validate that any new mapping being added falls * in to one of these categories. */ SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping( aGenerated, aOriginal, aSource, aName ) { // When aOriginal is truthy but has empty values for .line and .column, // it is most likely a programmer error. In this case we throw a very // specific error message to try to guide them the right way. // For example: https://github.com/Polymer/polymer-bundler/pull/519 if ( aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number" ) { throw new Error( "original.line and original.column are not numbers -- you probably meant to omit " + "the original mapping entirely and only map the generated position. If so, pass " + "null for the original mapping instead of an object with empty or null values." ); } if ( aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName ) { // Case 1. return; } else if ( aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource ) { // Cases 2 and 3. return; } else { throw new Error( "Invalid mapping: " + JSON.stringify({ generated: aGenerated, source: aSource, original: aOriginal, name: aName }) ); } }; /** * Serialize the accumulated mappings in to the stream of base 64 VLQs * specified by the source map format. */ SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() { var previousGeneratedColumn = 0; var previousGeneratedLine = 1; var previousOriginalColumn = 0; var previousOriginalLine = 0; var previousName = 0; var previousSource = 0; var result = ""; var next; var mapping; var nameIdx; var sourceIdx; var mappings = this._mappings.toArray(); for (var i = 0, len = mappings.length; i < len; i++) { mapping = mappings[i]; next = ""; if (mapping.generatedLine !== previousGeneratedLine) { previousGeneratedColumn = 0; while (mapping.generatedLine !== previousGeneratedLine) { next += ";"; previousGeneratedLine++; } } else { if (i > 0) { if ( !util.compareByGeneratedPositionsInflated( mapping, mappings[i - 1] ) ) { continue; } next += ","; } } next += base64VLQ.encode( mapping.generatedColumn - previousGeneratedColumn ); previousGeneratedColumn = mapping.generatedColumn; if (mapping.source != null) { sourceIdx = this._sources.indexOf(mapping.source); next += base64VLQ.encode(sourceIdx - previousSource); previousSource = sourceIdx; // lines are stored 0-based in SourceMap spec version 3 next += base64VLQ.encode( mapping.originalLine - 1 - previousOriginalLine ); previousOriginalLine = mapping.originalLine - 1; next += base64VLQ.encode( mapping.originalColumn - previousOriginalColumn ); previousOriginalColumn = mapping.originalColumn; if (mapping.name != null) { nameIdx = this._names.indexOf(mapping.name); next += base64VLQ.encode(nameIdx - previousName); previousName = nameIdx; } } result += next; } return result; }; SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent( aSources, aSourceRoot ) { return aSources.map(function(source) { if (!this._sourcesContents) { return null; } if (aSourceRoot != null) { source = util.relative(aSourceRoot, source); } var key = util.toSetString(source); return Object.prototype.hasOwnProperty.call( this._sourcesContents, key ) ? this._sourcesContents[key] : null; }, this); }; /** * Externalize the source map. */ SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() { var map = { version: this._version, sources: this._sources.toArray(), names: this._names.toArray(), mappings: this._serializeMappings() }; if (this._file != null) { map.file = this._file; } if (this._sourceRoot != null) { map.sourceRoot = this._sourceRoot; } if (this._sourcesContents) { map.sourcesContent = this._generateSourcesContent( map.sources, map.sourceRoot ); } return map; }; /** * Render the source map being generated to a string. */ SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() { return JSON.stringify(this.toJSON()); }; exports.SourceMapGenerator = SourceMapGenerator; }, { "./array-set": 145, "./base64-vlq": 146, "./mapping-list": 149, "./util": 154 } ], 153: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ var SourceMapGenerator = require("./source-map-generator") .SourceMapGenerator; var util = require("./util"); // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other // operating systems these days (capturing the result). var REGEX_NEWLINE = /(\r?\n)/; // Newline character code for charCodeAt() comparisons var NEWLINE_CODE = 10; // Private symbol for identifying `SourceNode`s when multiple versions of // the source-map library are loaded. This MUST NOT CHANGE across // versions! var isSourceNode = "$$$isSourceNode$$$"; /** * SourceNodes provide a way to abstract over interpolating/concatenating * snippets of generated JavaScript source code while maintaining the line and * column information associated with the original source code. * * @param aLine The original line number. * @param aColumn The original column number. * @param aSource The original source's filename. * @param aChunks Optional. An array of strings which are snippets of * generated JS, or other SourceNodes. * @param aName The original identifier. */ function SourceNode(aLine, aColumn, aSource, aChunks, aName) { this.children = []; this.sourceContents = {}; this.line = aLine == null ? null : aLine; this.column = aColumn == null ? null : aColumn; this.source = aSource == null ? null : aSource; this.name = aName == null ? null : aName; this[isSourceNode] = true; if (aChunks != null) this.add(aChunks); } /** * Creates a SourceNode from generated code and a SourceMapConsumer. * * @param aGeneratedCode The generated code * @param aSourceMapConsumer The SourceMap for the generated code * @param aRelativePath Optional. The path that relative sources in the * SourceMapConsumer should be relative to. */ SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap( aGeneratedCode, aSourceMapConsumer, aRelativePath ) { // The SourceNode we want to fill with the generated code // and the SourceMap var node = new SourceNode(); // All even indices of this array are one line of the generated code, // while all odd indices are the newlines between two adjacent lines // (since `REGEX_NEWLINE` captures its match). // Processed fragments are accessed by calling `shiftNextLine`. var remainingLines = aGeneratedCode.split(REGEX_NEWLINE); var remainingLinesIndex = 0; var shiftNextLine = function() { var lineContents = getNextLine(); // The last line of a file might not have a newline. var newLine = getNextLine() || ""; return lineContents + newLine; function getNextLine() { return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : undefined; } }; // We need to remember the position of "remainingLines" var lastGeneratedLine = 1, lastGeneratedColumn = 0; // The generate SourceNodes we need a code range. // To extract it current and last mapping is used. // Here we store the last mapping. var lastMapping = null; aSourceMapConsumer.eachMapping(function(mapping) { if (lastMapping !== null) { // We add the code from "lastMapping" to "mapping": // First check if there is a new line in between. if (lastGeneratedLine < mapping.generatedLine) { // Associate first line with "lastMapping" addMappingWithCode(lastMapping, shiftNextLine()); lastGeneratedLine++; lastGeneratedColumn = 0; // The remaining code is added without mapping } else { // There is no new line in between. // Associate the code between "lastGeneratedColumn" and // "mapping.generatedColumn" with "lastMapping" var nextLine = remainingLines[remainingLinesIndex] || ""; var code = nextLine.substr( 0, mapping.generatedColumn - lastGeneratedColumn ); remainingLines[remainingLinesIndex] = nextLine.substr( mapping.generatedColumn - lastGeneratedColumn ); lastGeneratedColumn = mapping.generatedColumn; addMappingWithCode(lastMapping, code); // No more remaining code, continue lastMapping = mapping; return; } } // We add the generated code until the first mapping // to the SourceNode without any mapping. // Each line is added as separate string. while (lastGeneratedLine < mapping.generatedLine) { node.add(shiftNextLine()); lastGeneratedLine++; } if (lastGeneratedColumn < mapping.generatedColumn) { var nextLine = remainingLines[remainingLinesIndex] || ""; node.add(nextLine.substr(0, mapping.generatedColumn)); remainingLines[remainingLinesIndex] = nextLine.substr( mapping.generatedColumn ); lastGeneratedColumn = mapping.generatedColumn; } lastMapping = mapping; }, this); // We have processed all mappings. if (remainingLinesIndex < remainingLines.length) { if (lastMapping) { // Associate the remaining code in the current line with "lastMapping" addMappingWithCode(lastMapping, shiftNextLine()); } // and add the remaining lines without any mapping node.add(remainingLines.splice(remainingLinesIndex).join("")); } // Copy sourcesContent into SourceNode aSourceMapConsumer.sources.forEach(function(sourceFile) { var content = aSourceMapConsumer.sourceContentFor(sourceFile); if (content != null) { if (aRelativePath != null) { sourceFile = util.join(aRelativePath, sourceFile); } node.setSourceContent(sourceFile, content); } }); return node; function addMappingWithCode(mapping, code) { if (mapping === null || mapping.source === undefined) { node.add(code); } else { var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source; node.add( new SourceNode( mapping.originalLine, mapping.originalColumn, source, code, mapping.name ) ); } } }; /** * Add a chunk of generated JS to this source node. * * @param aChunk A string snippet of generated JS code, another instance of * SourceNode, or an array where each member is one of those things. */ SourceNode.prototype.add = function SourceNode_add(aChunk) { if (Array.isArray(aChunk)) { aChunk.forEach(function(chunk) { this.add(chunk); }, this); } else if (aChunk[isSourceNode] || typeof aChunk === "string") { if (aChunk) { this.children.push(aChunk); } } else { throw new TypeError( "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk ); } return this; }; /** * Add a chunk of generated JS to the beginning of this source node. * * @param aChunk A string snippet of generated JS code, another instance of * SourceNode, or an array where each member is one of those things. */ SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) { if (Array.isArray(aChunk)) { for (var i = aChunk.length - 1; i >= 0; i--) { this.prepend(aChunk[i]); } } else if (aChunk[isSourceNode] || typeof aChunk === "string") { this.children.unshift(aChunk); } else { throw new TypeError( "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk ); } return this; }; /** * Walk over the tree of JS snippets in this node and its children. The * walking function is called once for each snippet of JS and is passed that * snippet and the its original associated source's line/column location. * * @param aFn The traversal function. */ SourceNode.prototype.walk = function SourceNode_walk(aFn) { var chunk; for (var i = 0, len = this.children.length; i < len; i++) { chunk = this.children[i]; if (chunk[isSourceNode]) { chunk.walk(aFn); } else { if (chunk !== "") { aFn(chunk, { source: this.source, line: this.line, column: this.column, name: this.name }); } } } }; /** * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between * each of `this.children`. * * @param aSep The separator. */ SourceNode.prototype.join = function SourceNode_join(aSep) { var newChildren; var i; var len = this.children.length; if (len > 0) { newChildren = []; for (i = 0; i < len - 1; i++) { newChildren.push(this.children[i]); newChildren.push(aSep); } newChildren.push(this.children[i]); this.children = newChildren; } return this; }; /** * Call String.prototype.replace on the very right-most source snippet. Useful * for trimming whitespace from the end of a source node, etc. * * @param aPattern The pattern to replace. * @param aReplacement The thing to replace the pattern with. */ SourceNode.prototype.replaceRight = function SourceNode_replaceRight( aPattern, aReplacement ) { var lastChild = this.children[this.children.length - 1]; if (lastChild[isSourceNode]) { lastChild.replaceRight(aPattern, aReplacement); } else if (typeof lastChild === "string") { this.children[this.children.length - 1] = lastChild.replace( aPattern, aReplacement ); } else { this.children.push("".replace(aPattern, aReplacement)); } return this; }; /** * Set the source content for a source file. This will be added to the SourceMapGenerator * in the sourcesContent field. * * @param aSourceFile The filename of the source file * @param aSourceContent The content of the source file */ SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent( aSourceFile, aSourceContent ) { this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent; }; /** * Walk over the tree of SourceNodes. The walking function is called for each * source file content and is passed the filename and source content. * * @param aFn The traversal function. */ SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents( aFn ) { for (var i = 0, len = this.children.length; i < len; i++) { if (this.children[i][isSourceNode]) { this.children[i].walkSourceContents(aFn); } } var sources = Object.keys(this.sourceContents); for (var i = 0, len = sources.length; i < len; i++) { aFn( util.fromSetString(sources[i]), this.sourceContents[sources[i]] ); } }; /** * Return the string representation of this source node. Walks over the tree * and concatenates all the various snippets together to one string. */ SourceNode.prototype.toString = function SourceNode_toString() { var str = ""; this.walk(function(chunk) { str += chunk; }); return str; }; /** * Returns the string representation of this source node along with a source * map. */ SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap( aArgs ) { var generated = { code: "", line: 1, column: 0 }; var map = new SourceMapGenerator(aArgs); var sourceMappingActive = false; var lastOriginalSource = null; var lastOriginalLine = null; var lastOriginalColumn = null; var lastOriginalName = null; this.walk(function(chunk, original) { generated.code += chunk; if ( original.source !== null && original.line !== null && original.column !== null ) { if ( lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name ) { map.addMapping({ source: original.source, original: { line: original.line, column: original.column }, generated: { line: generated.line, column: generated.column }, name: original.name }); } lastOriginalSource = original.source; lastOriginalLine = original.line; lastOriginalColumn = original.column; lastOriginalName = original.name; sourceMappingActive = true; } else if (sourceMappingActive) { map.addMapping({ generated: { line: generated.line, column: generated.column } }); lastOriginalSource = null; sourceMappingActive = false; } for (var idx = 0, length = chunk.length; idx < length; idx++) { if (chunk.charCodeAt(idx) === NEWLINE_CODE) { generated.line++; generated.column = 0; // Mappings end at eol if (idx + 1 === length) { lastOriginalSource = null; sourceMappingActive = false; } else if (sourceMappingActive) { map.addMapping({ source: original.source, original: { line: original.line, column: original.column }, generated: { line: generated.line, column: generated.column }, name: original.name }); } } else { generated.column++; } } }); this.walkSourceContents(function(sourceFile, sourceContent) { map.setSourceContent(sourceFile, sourceContent); }); return { code: generated.code, map: map }; }; exports.SourceNode = SourceNode; }, { "./source-map-generator": 152, "./util": 154 } ], 154: [ function(require, module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ /* * Copyright 2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE or: * http://opensource.org/licenses/BSD-3-Clause */ /** * This is a helper function for getting values from parameter/options * objects. * * @param args The object we are extracting values from * @param name The name of the property we are getting. * @param defaultValue An optional value to return if the property is missing * from the object. If this is not specified and the property is missing, an * error will be thrown. */ function getArg(aArgs, aName, aDefaultValue) { if (aName in aArgs) { return aArgs[aName]; } else if (arguments.length === 3) { return aDefaultValue; } else { throw new Error('"' + aName + '" is a required argument.'); } } exports.getArg = getArg; var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/; var dataUrlRegexp = /^data:.+\,.+$/; function urlParse(aUrl) { var match = aUrl.match(urlRegexp); if (!match) { return null; } return { scheme: match[1], auth: match[2], host: match[3], port: match[4], path: match[5] }; } exports.urlParse = urlParse; function urlGenerate(aParsedUrl) { var url = ""; if (aParsedUrl.scheme) { url += aParsedUrl.scheme + ":"; } url += "//"; if (aParsedUrl.auth) { url += aParsedUrl.auth + "@"; } if (aParsedUrl.host) { url += aParsedUrl.host; } if (aParsedUrl.port) { url += ":" + aParsedUrl.port; } if (aParsedUrl.path) { url += aParsedUrl.path; } return url; } exports.urlGenerate = urlGenerate; /** * Normalizes a path, or the path portion of a URL: * * - Replaces consecutive slashes with one slash. * - Removes unnecessary '.' parts. * - Removes unnecessary '/..' parts. * * Based on code in the Node.js 'path' core module. * * @param aPath The path or url to normalize. */ function normalize(aPath) { var path = aPath; var url = urlParse(aPath); if (url) { if (!url.path) { return aPath; } path = url.path; } var isAbsolute = exports.isAbsolute(path); var parts = path.split(/\/+/); for (var part, up = 0, i = parts.length - 1; i >= 0; i--) { part = parts[i]; if (part === ".") { parts.splice(i, 1); } else if (part === "..") { up++; } else if (up > 0) { if (part === "") { // The first part is blank if the path is absolute. Trying to go // above the root is a no-op. Therefore we can remove all '..' parts // directly after the root. parts.splice(i + 1, up); up = 0; } else { parts.splice(i, 2); up--; } } } path = parts.join("/"); if (path === "") { path = isAbsolute ? "/" : "."; } if (url) { url.path = path; return urlGenerate(url); } return path; } exports.normalize = normalize; /** * Joins two paths/URLs. * * @param aRoot The root path or URL. * @param aPath The path or URL to be joined with the root. * * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a * scheme-relative URL: Then the scheme of aRoot, if any, is prepended * first. * - Otherwise aPath is a path. If aRoot is a URL, then its path portion * is updated with the result and aRoot is returned. Otherwise the result * is returned. * - If aPath is absolute, the result is aPath. * - Otherwise the two paths are joined with a slash. * - Joining for example 'http://' and 'www.example.com' is also supported. */ function join(aRoot, aPath) { if (aRoot === "") { aRoot = "."; } if (aPath === "") { aPath = "."; } var aPathUrl = urlParse(aPath); var aRootUrl = urlParse(aRoot); if (aRootUrl) { aRoot = aRootUrl.path || "/"; } // `join(foo, '//www.example.org')` if (aPathUrl && !aPathUrl.scheme) { if (aRootUrl) { aPathUrl.scheme = aRootUrl.scheme; } return urlGenerate(aPathUrl); } if (aPathUrl || aPath.match(dataUrlRegexp)) { return aPath; } // `join('http://', 'www.example.com')` if (aRootUrl && !aRootUrl.host && !aRootUrl.path) { aRootUrl.host = aPath; return urlGenerate(aRootUrl); } var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath); if (aRootUrl) { aRootUrl.path = joined; return urlGenerate(aRootUrl); } return joined; } exports.join = join; exports.isAbsolute = function(aPath) { return aPath.charAt(0) === "/" || urlRegexp.test(aPath); }; /** * Make a path relative to a URL or another path. * * @param aRoot The root path or URL. * @param aPath The path or URL to be made relative to aRoot. */ function relative(aRoot, aPath) { if (aRoot === "") { aRoot = "."; } aRoot = aRoot.replace(/\/$/, ""); // It is possible for the path to be above the root. In this case, simply // checking whether the root is a prefix of the path won't work. Instead, we // need to remove components from the root one by one, until either we find // a prefix that fits, or we run out of components to remove. var level = 0; while (aPath.indexOf(aRoot + "/") !== 0) { var index = aRoot.lastIndexOf("/"); if (index < 0) { return aPath; } // If the only part of the root that is left is the scheme (i.e. http://, // file:///, etc.), one or more slashes (/), or simply nothing at all, we // have exhausted all components, so the path is not relative to the root. aRoot = aRoot.slice(0, index); if (aRoot.match(/^([^\/]+:\/)?\/*$/)) { return aPath; } ++level; } // Make sure we add a "../" for each component we removed from the root. return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1); } exports.relative = relative; var supportsNullProto = (function() { var obj = Object.create(null); return !("__proto__" in obj); })(); function identity(s) { return s; } /** * Because behavior goes wacky when you set `__proto__` on objects, we * have to prefix all the strings in our set with an arbitrary character. * * See https://github.com/mozilla/source-map/pull/31 and * https://github.com/mozilla/source-map/issues/30 * * @param String aStr */ function toSetString(aStr) { if (isProtoString(aStr)) { return "$" + aStr; } return aStr; } exports.toSetString = supportsNullProto ? identity : toSetString; function fromSetString(aStr) { if (isProtoString(aStr)) { return aStr.slice(1); } return aStr; } exports.fromSetString = supportsNullProto ? identity : fromSetString; function isProtoString(s) { if (!s) { return false; } var length = s.length; if (length < 9 /* "__proto__".length */) { return false; } if ( s.charCodeAt(length - 1) !== 95 /* '_' */ || s.charCodeAt(length - 2) !== 95 /* '_' */ || s.charCodeAt(length - 3) !== 111 /* 'o' */ || s.charCodeAt(length - 4) !== 116 /* 't' */ || s.charCodeAt(length - 5) !== 111 /* 'o' */ || s.charCodeAt(length - 6) !== 114 /* 'r' */ || s.charCodeAt(length - 7) !== 112 /* 'p' */ || s.charCodeAt(length - 8) !== 95 /* '_' */ || s.charCodeAt(length - 9) !== 95 /* '_' */ ) { return false; } for (var i = length - 10; i >= 0; i--) { if (s.charCodeAt(i) !== 36 /* '$' */) { return false; } } return true; } /** * Comparator between two mappings where the original positions are compared. * * Optionally pass in `true` as `onlyCompareGenerated` to consider two * mappings with the same original source/line/column, but different generated * line and column the same. Useful when searching for a mapping with a * stubbed out mapping. */ function compareByOriginalPositions( mappingA, mappingB, onlyCompareOriginal ) { var cmp = strcmp(mappingA.source, mappingB.source); if (cmp !== 0) { return cmp; } cmp = mappingA.originalLine - mappingB.originalLine; if (cmp !== 0) { return cmp; } cmp = mappingA.originalColumn - mappingB.originalColumn; if (cmp !== 0 || onlyCompareOriginal) { return cmp; } cmp = mappingA.generatedColumn - mappingB.generatedColumn; if (cmp !== 0) { return cmp; } cmp = mappingA.generatedLine - mappingB.generatedLine; if (cmp !== 0) { return cmp; } return strcmp(mappingA.name, mappingB.name); } exports.compareByOriginalPositions = compareByOriginalPositions; /** * Comparator between two mappings with deflated source and name indices where * the generated positions are compared. * * Optionally pass in `true` as `onlyCompareGenerated` to consider two * mappings with the same generated line and column, but different * source/name/original line and column the same. Useful when searching for a * mapping with a stubbed out mapping. */ function compareByGeneratedPositionsDeflated( mappingA, mappingB, onlyCompareGenerated ) { var cmp = mappingA.generatedLine - mappingB.generatedLine; if (cmp !== 0) { return cmp; } cmp = mappingA.generatedColumn - mappingB.generatedColumn; if (cmp !== 0 || onlyCompareGenerated) { return cmp; } cmp = strcmp(mappingA.source, mappingB.source); if (cmp !== 0) { return cmp; } cmp = mappingA.originalLine - mappingB.originalLine; if (cmp !== 0) { return cmp; } cmp = mappingA.originalColumn - mappingB.originalColumn; if (cmp !== 0) { return cmp; } return strcmp(mappingA.name, mappingB.name); } exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated; function strcmp(aStr1, aStr2) { if (aStr1 === aStr2) { return 0; } if (aStr1 === null) { return 1; // aStr2 !== null } if (aStr2 === null) { return -1; // aStr1 !== null } if (aStr1 > aStr2) { return 1; } return -1; } /** * Comparator between two mappings with inflated source and name strings where * the generated positions are compared. */ function compareByGeneratedPositionsInflated(mappingA, mappingB) { var cmp = mappingA.generatedLine - mappingB.generatedLine; if (cmp !== 0) { return cmp; } cmp = mappingA.generatedColumn - mappingB.generatedColumn; if (cmp !== 0) { return cmp; } cmp = strcmp(mappingA.source, mappingB.source); if (cmp !== 0) { return cmp; } cmp = mappingA.originalLine - mappingB.originalLine; if (cmp !== 0) { return cmp; } cmp = mappingA.originalColumn - mappingB.originalColumn; if (cmp !== 0) { return cmp; } return strcmp(mappingA.name, mappingB.name); } exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated; /** * Strip any JSON XSSI avoidance prefix from the string (as documented * in the source maps specification), and then parse the string as * JSON. */ function parseSourceMapInput(str) { return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, "")); } exports.parseSourceMapInput = parseSourceMapInput; /** * Compute the URL of a source given the the source root, the source's * URL, and the source map's URL. */ function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) { sourceURL = sourceURL || ""; if (sourceRoot) { // This follows what Chrome does. if ( sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/" ) { sourceRoot += "/"; } // The spec says: // Line 4: An optional source root, useful for relocating source // files on a server or removing repeated values in the // “sources” entry. This value is prepended to the individual // entries in the “source” field. sourceURL = sourceRoot + sourceURL; } // Historically, SourceMapConsumer did not take the sourceMapURL as // a parameter. This mode is still somewhat supported, which is why // this code block is conditional. However, it's preferable to pass // the source map URL to SourceMapConsumer, so that this function // can implement the source URL resolution algorithm as outlined in // the spec. This block is basically the equivalent of: // new URL(sourceURL, sourceMapURL).toString() // ... except it avoids using URL, which wasn't available in the // older releases of node still supported by this library. // // The spec says: // If the sources are not absolute URLs after prepending of the // “sourceRoot”, the sources are resolved relative to the // SourceMap (like resolving script src in a html document). if (sourceMapURL) { var parsed = urlParse(sourceMapURL); if (!parsed) { throw new Error("sourceMapURL could not be parsed"); } if (parsed.path) { // Strip the last path component, but keep the "/". var index = parsed.path.lastIndexOf("/"); if (index >= 0) { parsed.path = parsed.path.substring(0, index + 1); } } sourceURL = join(urlGenerate(parsed), sourceURL); } return normalize(sourceURL); } exports.computeSourceURL = computeSourceURL; }, {} ], 155: [ function(require, module, exports) { /* * Copyright 2009-2011 Mozilla Foundation and contributors * Licensed under the New BSD license. See LICENSE.txt or: * http://opensource.org/licenses/BSD-3-Clause */ exports.SourceMapGenerator = require("./lib/source-map-generator").SourceMapGenerator; exports.SourceMapConsumer = require("./lib/source-map-consumer").SourceMapConsumer; exports.SourceNode = require("./lib/source-node").SourceNode; }, { "./lib/source-map-consumer": 151, "./lib/source-map-generator": 152, "./lib/source-node": 153 } ], 156: [ 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": 158, "./lib/response": 159, "builtin-status-codes": 5, url: 162, xtend: 165 } ], 157: [ function(require, module, exports) { (function(global) { exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream); exports.writableStream = isFunction(global.WritableStream); exports.abortController = isFunction(global.AbortController); exports.blobConstructor = false; try { new Blob([new ArrayBuffer(1)]); exports.blobConstructor = true; } catch (e) {} // 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; } // For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'. // Safari 7.1 appears to have fixed this bug. var haveArrayBuffer = typeof global.ArrayBuffer !== "undefined"; var haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice); // If fetch is supported, then arraybuffer will be supported too. Skip calling // checkTypeSupport(), since that calls getXHR(). exports.arraybuffer = exports.fetch || (haveArrayBuffer && 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 && haveSlice && checkTypeSupport("ms-stream"); exports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer && 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); exports.vbArray = isFunction(global.VBArray); 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 : {} )); }, {} ], 158: [ 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 toArrayBuffer = require("to-arraybuffer"); 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 if (capability.vbArray && preferBinary) { return "text:vbarray"; } 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 " + new Buffer(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") { if (capability.arraybuffer) { body = toArrayBuffer(Buffer.concat(self._body)); } else if (capability.blobConstructor) { body = new global.Blob( self._body.map(function(buffer) { return toArrayBuffer(buffer); }), { type: (headersObj["content-type"] || {}).value || "" } ); } else { // get utf8 string body = Buffer.concat(self._body).toString(); } } // 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; var fetchTimer = 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.split(":")[0]; 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": 157, "./response": 159, _process: 112, buffer: 4, inherits: 106, "readable-stream": 126, "to-arraybuffer": 161 } ], 159: [ 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(new Buffer(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(new Buffer(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:vbarray": // For IE9 if (xhr.readyState !== rStates.DONE) break; try { // This fails in IE8 response = new global.VBArray(xhr.responseBody).toArray(); } catch (e) {} if (response !== null) { self.push(new Buffer(response)); break; } // Falls through in IE8 case "text": try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4 response = xhr.responseText; } catch (e) { self._mode = "text:vbarray"; break; } if (response.length > self._pos) { var newData = response.substr(self._pos); if (self._charset === "x-user-defined") { var buffer = new Buffer(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(new Buffer(new Uint8Array(response))); break; case "moz-chunked-arraybuffer": // take whole response = xhr.response; if (xhr.readyState !== rStates.LOADING || !response) break; self.push(new Buffer(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( new Buffer(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": 157, _process: 112, buffer: 4, inherits: 106, "readable-stream": 126 } ], 160: [ function(require, module, exports) { (function(setImmediate, clearImmediate) { var nextTick = require("process/browser.js").nextTick; var apply = Function.prototype.apply; var slice = Array.prototype.slice; var immediateIds = {}; var nextImmediateId = 0; // DOM APIs, for completeness exports.setTimeout = function() { return new Timeout( apply.call(setTimeout, window, arguments), clearTimeout ); }; exports.setInterval = function() { return new Timeout( apply.call(setInterval, window, arguments), clearInterval ); }; exports.clearTimeout = exports.clearInterval = function(timeout) { timeout.close(); }; function Timeout(id, clearFn) { this._id = id; this._clearFn = clearFn; } Timeout.prototype.unref = Timeout.prototype.ref = function() {}; Timeout.prototype.close = function() { this._clearFn.call(window, this._id); }; // Does not start the time, just sets up the members needed. exports.enroll = function(item, msecs) { clearTimeout(item._idleTimeoutId); item._idleTimeout = msecs; }; exports.unenroll = function(item) { clearTimeout(item._idleTimeoutId); item._idleTimeout = -1; }; exports._unrefActive = exports.active = function(item) { clearTimeout(item._idleTimeoutId); var msecs = item._idleTimeout; if (msecs >= 0) { item._idleTimeoutId = setTimeout(function onTimeout() { if (item._onTimeout) item._onTimeout(); }, msecs); } }; // That's not how node.js implements it but the exposed api is the same. exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) { var id = nextImmediateId++; var args = arguments.length < 2 ? false : slice.call(arguments, 1); immediateIds[id] = true; nextTick(function onNextTick() { if (immediateIds[id]) { // fn.call() is faster so we optimize for the common use-case // @see http://jsperf.com/call-apply-segu if (args) { fn.apply(null, args); } else { fn.call(null); } // Prevent ids from leaking exports.clearImmediate(id); } }); return id; }; exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) { delete immediateIds[id]; }; }.call( this, require("timers").setImmediate, require("timers").clearImmediate )); }, { "process/browser.js": 112, timers: 160 } ], 161: [ function(require, module, exports) { var Buffer = require("buffer").Buffer; module.exports = function(buf) { // If the buffer is backed by a Uint8Array, a faster version will work if (buf instanceof Uint8Array) { // If the buffer isn't a subarray, return the underlying ArrayBuffer if ( buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength ) { return buf.buffer; } else if (typeof buf.buffer.slice === "function") { // Otherwise we need to get a proper copy return buf.buffer.slice( buf.byteOffset, buf.byteOffset + buf.byteLength ); } } if (Buffer.isBuffer(buf)) { // This is the slow version that will work with any Buffer // implementation (even in old browsers) var arrayCopy = new Uint8Array(buf.length); var len = buf.length; for (var i = 0; i < len; i++) { arrayCopy[i] = buf[i]; } return arrayCopy.buffer; } else { throw new Error("Argument must be a Buffer"); } }; }, { buffer: 4 } ], 162: [ 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": 163, punycode: 113, querystring: 116 } ], 163: [ 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; } }; }, {} ], 164: [ 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 : {} )); }, {} ], 165: [ 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; } }, {} ], 166: [ function(require, module, exports) { /*! * HTML Parser By John Resig (ejohn.org) * Modified by Juriy "kangax" Zaytsev * Original code by Erik Arvidsson, Mozilla Public License * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js */ /* * // Use like so: * HTMLParser(htmlString, { * start: function(tag, attrs, unary) {}, * end: function(tag) {}, * chars: function(text) {}, * comment: function(text) {} * }); * * // or to get an XML string: * HTMLtoXML(htmlString); * * // or to get an XML DOM Document * HTMLtoDOM(htmlString); * * // or to inject into an existing document/DOM node * HTMLtoDOM(htmlString, document); * HTMLtoDOM(htmlString, document.body); * */ /* global ActiveXObject, DOMDocument */ "use strict"; var createMapFromString = require("./utils").createMapFromString; function makeMap(values) { return createMapFromString(values, true); } // Regular Expressions for parsing tags and attributes var singleAttrIdentifier = /([^\s"'<>/=]+)/, singleAttrAssigns = [/=/], singleAttrValues = [ // attr value double quotes /"([^"]*)"+/.source, // attr value, single quotes /'([^']*)'+/.source, // attr value, no quotes /([^ \t\n\f\r"'`=<>]+)/.source ], // https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName qnameCapture = (function() { // based on https://www.npmjs.com/package/ncname var combiningChar = "\\u0300-\\u0345\\u0360\\u0361\\u0483-\\u0486\\u0591-\\u05A1\\u05A3-\\u05B9\\u05BB-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u064B-\\u0652\\u0670\\u06D6-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0901-\\u0903\\u093C\\u093E-\\u094D\\u0951-\\u0954\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A02\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A70\\u0A71\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B43\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B82\\u0B83\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C01-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C82\\u0C83\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86-\\u0F8B\\u0F90-\\u0F95\\u0F97\\u0F99-\\u0FAD\\u0FB1-\\u0FB7\\u0FB9\\u20D0-\\u20DC\\u20E1\\u302A-\\u302F\\u3099\\u309A"; var digit = "0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE7-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29"; var extender = "\\xB7\\u02D0\\u02D1\\u0387\\u0640\\u0E46\\u0EC6\\u3005\\u3031-\\u3035\\u309D\\u309E\\u30FC-\\u30FE"; var letter = "A-Za-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u0131\\u0134-\\u013E\\u0141-\\u0148\\u014A-\\u017E\\u0180-\\u01C3\\u01CD-\\u01F0\\u01F4\\u01F5\\u01FA-\\u0217\\u0250-\\u02A8\\u02BB-\\u02C1\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03D0-\\u03D6\\u03DA\\u03DC\\u03DE\\u03E0\\u03E2-\\u03F3\\u0401-\\u040C\\u040E-\\u044F\\u0451-\\u045C\\u045E-\\u0481\\u0490-\\u04C4\\u04C7\\u04C8\\u04CB\\u04CC\\u04D0-\\u04EB\\u04EE-\\u04F5\\u04F8\\u04F9\\u0531-\\u0556\\u0559\\u0561-\\u0586\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u063A\\u0641-\\u064A\\u0671-\\u06B7\\u06BA-\\u06BE\\u06C0-\\u06CE\\u06D0-\\u06D3\\u06D5\\u06E5\\u06E6\\u0905-\\u0939\\u093D\\u0958-\\u0961\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8B\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AE0\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B36-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB5\\u0BB7-\\u0BB9\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D60\\u0D61\\u0E01-\\u0E2E\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E45\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD\\u0EAE\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0F40-\\u0F47\\u0F49-\\u0F69\\u10A0-\\u10C5\\u10D0-\\u10F6\\u1100\\u1102\\u1103\\u1105-\\u1107\\u1109\\u110B\\u110C\\u110E-\\u1112\\u113C\\u113E\\u1140\\u114C\\u114E\\u1150\\u1154\\u1155\\u1159\\u115F-\\u1161\\u1163\\u1165\\u1167\\u1169\\u116D\\u116E\\u1172\\u1173\\u1175\\u119E\\u11A8\\u11AB\\u11AE\\u11AF\\u11B7\\u11B8\\u11BA\\u11BC-\\u11C2\\u11EB\\u11F0\\u11F9\\u1E00-\\u1E9B\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2126\\u212A\\u212B\\u212E\\u2180-\\u2182\\u3007\\u3021-\\u3029\\u3041-\\u3094\\u30A1-\\u30FA\\u3105-\\u312C\\u4E00-\\u9FA5\\uAC00-\\uD7A3"; var ncname = "[" + letter + "_][" + letter + digit + "\\.\\-_" + combiningChar + extender + "]*"; return "((?:" + ncname + "\\:)?" + ncname + ")"; })(), startTagOpen = new RegExp("^<" + qnameCapture), startTagClose = /^\s*(\/?)>/, endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>"), doctype = /^]+>/i; var IS_REGEX_CAPTURING_BROKEN = false; "x".replace(/x(.)?/g, function(m, g) { IS_REGEX_CAPTURING_BROKEN = g === ""; }); // Empty Elements var empty = makeMap( "area,base,basefont,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr" ); // Inline Elements var inline = makeMap( "a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,noscript,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,svg,textarea,tt,u,var" ); // Elements that you can, intentionally, leave open // (and which close themselves) var closeSelf = makeMap( "colgroup,dd,dt,li,option,p,td,tfoot,th,thead,tr,source" ); // Attributes that have their values filled in disabled='disabled' var fillAttrs = makeMap( "checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected" ); // Special Elements (can contain anything) var special = makeMap("script,style"); // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content var nonPhrasing = makeMap( "address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,ol,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track,ul" ); var reCache = {}; function attrForHandler(handler) { var pattern = singleAttrIdentifier.source + "(?:\\s*(" + joinSingleAttrAssigns(handler) + ")" + "[ \\t\\n\\f\\r]*(?:" + singleAttrValues.join("|") + "))?"; if (handler.customAttrSurround) { var attrClauses = []; for (var i = handler.customAttrSurround.length - 1; i >= 0; i--) { attrClauses[i] = "(?:" + "(" + handler.customAttrSurround[i][0].source + ")\\s*" + pattern + "\\s*(" + handler.customAttrSurround[i][1].source + ")" + ")"; } attrClauses.push("(?:" + pattern + ")"); pattern = "(?:" + attrClauses.join("|") + ")"; } return new RegExp("^\\s*" + pattern); } function joinSingleAttrAssigns(handler) { return singleAttrAssigns .concat(handler.customAttrAssign || []) .map(function(assign) { return "(?:" + assign.source + ")"; }) .join("|"); } function HTMLParser(html, handler) { var stack = [], lastTag; var attribute = attrForHandler(handler); var last, prevTag, nextTag; while (html) { last = html; // Make sure we're not in a script or style element if (!lastTag || !special(lastTag)) { var textEnd = html.indexOf("<"); if (textEnd === 0) { // Comment: if (/^"); if (commentEnd >= 0) { if (handler.comment) { handler.comment(html.substring(4, commentEnd)); } html = html.substring(commentEnd + 3); prevTag = ""; continue; } } // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment if (/^"); if (conditionalEnd >= 0) { if (handler.comment) { handler.comment( html.substring(2, conditionalEnd + 1), true /* non-standard */ ); } html = html.substring(conditionalEnd + 2); prevTag = ""; continue; } } // Doctype: var doctypeMatch = html.match(doctype); if (doctypeMatch) { if (handler.doctype) { handler.doctype(doctypeMatch[0]); } html = html.substring(doctypeMatch[0].length); prevTag = ""; continue; } // End tag: var endTagMatch = html.match(endTag); if (endTagMatch) { html = html.substring(endTagMatch[0].length); endTagMatch[0].replace(endTag, parseEndTag); prevTag = "/" + endTagMatch[1].toLowerCase(); continue; } // Start tag: var startTagMatch = parseStartTag(html); if (startTagMatch) { html = startTagMatch.rest; handleStartTag(startTagMatch); prevTag = startTagMatch.tagName.toLowerCase(); continue; } // Treat `<` as text if (handler.continueOnParseError) { textEnd = html.indexOf("<", 1); } } var text; if (textEnd >= 0) { text = html.substring(0, textEnd); html = html.substring(textEnd); } else { text = html; html = ""; } // next tag var nextTagMatch = parseStartTag(html); if (nextTagMatch) { nextTag = nextTagMatch.tagName; } else { nextTagMatch = html.match(endTag); if (nextTagMatch) { nextTag = "/" + nextTagMatch[1]; } else { nextTag = ""; } } if (handler.chars) { handler.chars(text, prevTag, nextTag); } prevTag = ""; } else { var stackedTag = lastTag.toLowerCase(); var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp( "([\\s\\S]*?)]*>", "i" )); html = html.replace(reStackedTag, function(all, text) { if ( stackedTag !== "script" && stackedTag !== "style" && stackedTag !== "noscript" ) { text = text .replace(//g, "$1") .replace(//g, "$1"); } if (handler.chars) { handler.chars(text); } return ""; }); parseEndTag("", stackedTag); } if (html === last) { throw new Error("Parse Error: " + html); } } if (!handler.partialMarkup) { // Clean up any remaining tags parseEndTag(); } function parseStartTag(input) { var start = input.match(startTagOpen); if (start) { var match = { tagName: start[1], attrs: [] }; input = input.slice(start[0].length); var end, attr; while ( !(end = input.match(startTagClose)) && (attr = input.match(attribute)) ) { input = input.slice(attr[0].length); match.attrs.push(attr); } if (end) { match.unarySlash = end[1]; match.rest = input.slice(end[0].length); return match; } } } function closeIfFound(tagName) { if (findTag(tagName) >= 0) { parseEndTag("", tagName); return true; } } function handleStartTag(match) { var tagName = match.tagName; var unarySlash = match.unarySlash; if (handler.html5) { if (lastTag === "p" && nonPhrasing(tagName)) { parseEndTag("", lastTag); } else if (tagName === "tbody") { closeIfFound("thead"); } else if (tagName === "tfoot") { if (!closeIfFound("tbody")) { closeIfFound("thead"); } } if (tagName === "col" && findTag("colgroup") < 0) { lastTag = "colgroup"; stack.push({ tag: lastTag, attrs: [] }); if (handler.start) { handler.start(lastTag, [], false, ""); } } } if (!handler.html5 && !inline(tagName)) { while (lastTag && inline(lastTag)) { parseEndTag("", lastTag); } } if (closeSelf(tagName) && lastTag === tagName) { parseEndTag("", tagName); } var unary = empty(tagName) || (tagName === "html" && lastTag === "head") || !!unarySlash; var attrs = match.attrs.map(function(args) { var name, value, customOpen, customClose, customAssign, quote; var ncp = 7; // number of captured parts, scalar // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778 if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) { if (args[3] === "") { delete args[3]; } if (args[4] === "") { delete args[4]; } if (args[5] === "") { delete args[5]; } } function populate(index) { customAssign = args[index]; value = args[index + 1]; if (typeof value !== "undefined") { return '"'; } value = args[index + 2]; if (typeof value !== "undefined") { return "'"; } value = args[index + 3]; if (typeof value === "undefined" && fillAttrs(name)) { value = name; } return ""; } var j = 1; if (handler.customAttrSurround) { for ( var i = 0, l = handler.customAttrSurround.length; i < l; i++, j += ncp ) { name = args[j + 1]; if (name) { quote = populate(j + 2); customOpen = args[j]; customClose = args[j + 6]; break; } } } if (!name && (name = args[j])) { quote = populate(j + 1); } return { name: name, value: value, customAssign: customAssign || "=", customOpen: customOpen || "", customClose: customClose || "", quote: quote || "" }; }); if (!unary) { stack.push({ tag: tagName, attrs: attrs }); lastTag = tagName; unarySlash = ""; } if (handler.start) { handler.start(tagName, attrs, unary, unarySlash); } } function findTag(tagName) { var pos; var needle = tagName.toLowerCase(); for (pos = stack.length - 1; pos >= 0; pos--) { if (stack[pos].tag.toLowerCase() === needle) { break; } } return pos; } function parseEndTag(tag, tagName) { var pos; // Find the closest opened tag of the same type if (tagName) { pos = findTag(tagName); } // If no tag name is provided, clean shop else { pos = 0; } if (pos >= 0) { // Close all the open elements, up the stack for (var i = stack.length - 1; i >= pos; i--) { if (handler.end) { handler.end(stack[i].tag, stack[i].attrs, i > pos || !tag); } } // Remove the open elements from the stack stack.length = pos; lastTag = pos && stack[pos - 1].tag; } else if (tagName.toLowerCase() === "br") { if (handler.start) { handler.start(tagName, [], true, ""); } } else if (tagName.toLowerCase() === "p") { if (handler.start) { handler.start(tagName, [], false, "", true); } if (handler.end) { handler.end(tagName, []); } } } } exports.HTMLParser = HTMLParser; exports.HTMLtoXML = function(html) { var results = ""; new HTMLParser(html, { start: function(tag, attrs, unary) { results += "<" + tag; for (var i = 0, len = attrs.length; i < len; i++) { results += " " + attrs[i].name + '="' + (attrs[i].value || "").replace(/"/g, """) + '"'; } results += (unary ? "/" : "") + ">"; }, end: function(tag) { results += ""; }, chars: function(text) { results += text; }, comment: function(text) { results += ""; }, ignore: function(text) { results += text; } }); return results; }; exports.HTMLtoDOM = function(html, doc) { // There can be only one of these elements var one = { html: true, head: true, body: true, title: true }; // Enforce a structure for the document var structure = { link: "head", base: "head" }; if (doc) { doc = doc.ownerDocument || (doc.getOwnerDocument && doc.getOwnerDocument()) || doc; } else if (typeof DOMDocument !== "undefined") { doc = new DOMDocument(); } else if ( typeof document !== "undefined" && document.implementation && document.implementation.createDocument ) { doc = document.implementation.createDocument("", "", null); } else if (typeof ActiveX !== "undefined") { doc = new ActiveXObject("Msxml.DOMDocument"); } var elems = [], documentElement = doc.documentElement || (doc.getDocumentElement && doc.getDocumentElement()); // If we're dealing with an empty document then we // need to pre-populate it with the HTML document structure if (!documentElement && doc.createElement) { (function() { var html = doc.createElement("html"); var head = doc.createElement("head"); head.appendChild(doc.createElement("title")); html.appendChild(head); html.appendChild(doc.createElement("body")); doc.appendChild(html); })(); } // Find all the unique elements if (doc.getElementsByTagName) { for (var i in one) { one[i] = doc.getElementsByTagName(i)[0]; } } // If we're working with a document, inject contents into // the body element var curParentNode = one.body; new HTMLParser(html, { start: function(tagName, attrs, unary) { // If it's a pre-built element, then we can ignore // its construction if (one[tagName]) { curParentNode = one[tagName]; return; } var elem = doc.createElement(tagName); for (var attr in attrs) { elem.setAttribute(attrs[attr].name, attrs[attr].value); } if ( structure[tagName] && typeof one[structure[tagName]] !== "boolean" ) { one[structure[tagName]].appendChild(elem); } else if (curParentNode && curParentNode.appendChild) { curParentNode.appendChild(elem); } if (!unary) { elems.push(elem); curParentNode = elem; } }, end: function(/* tag */) { elems.length -= 1; // Init the new parentNode curParentNode = elems[elems.length - 1]; }, chars: function(text) { curParentNode.appendChild(doc.createTextNode(text)); }, comment: function(/* text */) { // create comment node }, ignore: function(/* text */) { // What to do here? } }); return doc; }; }, { "./utils": 168 } ], 167: [ function(require, module, exports) { "use strict"; function Sorter() {} Sorter.prototype.sort = function(tokens, fromIndex) { fromIndex = fromIndex || 0; for (var i = 0, len = this.keys.length; i < len; i++) { var key = this.keys[i]; var token = key.slice(1); var index = tokens.indexOf(token, fromIndex); if (index !== -1) { do { if (index !== fromIndex) { tokens.splice(index, 1); tokens.splice(fromIndex, 0, token); } fromIndex++; } while ((index = tokens.indexOf(token, fromIndex)) !== -1); return this[key].sort(tokens, fromIndex); } } return tokens; }; function TokenChain() {} TokenChain.prototype = { add: function(tokens) { var self = this; tokens.forEach(function(token) { var key = "$" + token; if (!self[key]) { self[key] = []; self[key].processed = 0; } self[key].push(tokens); }); }, createSorter: function() { var self = this; var sorter = new Sorter(); sorter.keys = Object.keys(self) .sort(function(j, k) { var m = self[j].length; var n = self[k].length; return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0; }) .filter(function(key) { if (self[key].processed < self[key].length) { var token = key.slice(1); var chain = new TokenChain(); self[key].forEach(function(tokens) { var index; while ((index = tokens.indexOf(token)) !== -1) { tokens.splice(index, 1); } tokens.forEach(function(token) { self["$" + token].processed++; }); chain.add(tokens.slice(0)); }); sorter[key] = chain.createSorter(); return true; } return false; }); return sorter; } }; module.exports = TokenChain; }, {} ], 168: [ function(require, module, exports) { "use strict"; function createMap(values, ignoreCase) { var map = {}; values.forEach(function(value) { map[value] = 1; }); return ignoreCase ? function(value) { return map[value.toLowerCase()] === 1; } : function(value) { return map[value] === 1; }; } exports.createMap = createMap; exports.createMapFromString = function(values, ignoreCase) { return createMap(values.split(/,/), ignoreCase); }; }, {} ], "html-minifier": [ function(require, module, exports) { "use strict"; var CleanCSS = require("clean-css"); var decode = require("he").decode; var HTMLParser = require("./htmlparser").HTMLParser; var RelateUrl = require("relateurl"); var TokenChain = require("./tokenchain"); var UglifyJS = require("uglify-js"); var utils = require("./utils"); function trimWhitespace(str) { return ( str && str.replace(/^[ \n\r\t\f]+/, "").replace(/[ \n\r\t\f]+$/, "") ); } function collapseWhitespaceAll(str) { // Non-breaking space is specifically handled inside the replacer function here: return ( str && str.replace(/[ \n\r\t\f\xA0]+/g, function(spaces) { return spaces === "\t" ? "\t" : spaces.replace(/(^|\xA0+)[^\xA0]+/g, "$1 "); }) ); } function collapseWhitespace( str, options, trimLeft, trimRight, collapseAll ) { var lineBreakBefore = "", lineBreakAfter = ""; if (options.preserveLineBreaks) { str = str .replace(/^[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*/, function() { lineBreakBefore = "\n"; return ""; }) .replace(/[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*$/, function() { lineBreakAfter = "\n"; return ""; }); } if (trimLeft) { // Non-breaking space is specifically handled inside the replacer function here: str = str.replace(/^[ \n\r\t\f\xA0]+/, function(spaces) { var conservative = !lineBreakBefore && options.conservativeCollapse; if (conservative && spaces === "\t") { return "\t"; } return ( spaces .replace(/^[^\xA0]+/, "") .replace(/(\xA0+)[^\xA0]+/g, "$1 ") || (conservative ? " " : "") ); }); } if (trimRight) { // Non-breaking space is specifically handled inside the replacer function here: str = str.replace(/[ \n\r\t\f\xA0]+$/, function(spaces) { var conservative = !lineBreakAfter && options.conservativeCollapse; if (conservative && spaces === "\t") { return "\t"; } return ( spaces .replace(/[^\xA0]+(\xA0+)/g, " $1") .replace(/[^\xA0]+$/, "") || (conservative ? " " : "") ); }); } if (collapseAll) { // strip non space whitespace then compress spaces to one str = collapseWhitespaceAll(str); } return lineBreakBefore + str + lineBreakAfter; } var createMapFromString = utils.createMapFromString; // non-empty tags that will maintain whitespace around them var inlineTags = createMapFromString( "a,abbr,acronym,b,bdi,bdo,big,button,cite,code,del,dfn,em,font,i,ins,kbd,label,mark,math,nobr,object,q,rp,rt,rtc,ruby,s,samp,select,small,span,strike,strong,sub,sup,svg,textarea,time,tt,u,var" ); // non-empty tags that will maintain whitespace within them var inlineTextTags = createMapFromString( "a,abbr,acronym,b,big,del,em,font,i,ins,kbd,mark,nobr,rp,s,samp,small,span,strike,strong,sub,sup,time,tt,u,var" ); // self-closing tags that will maintain whitespace around them var selfClosingInlineTags = createMapFromString( "comment,img,input,wbr" ); function collapseWhitespaceSmart(str, prevTag, nextTag, options) { var trimLeft = prevTag && !selfClosingInlineTags(prevTag); if (trimLeft && !options.collapseInlineTagWhitespace) { trimLeft = prevTag.charAt(0) === "/" ? !inlineTags(prevTag.slice(1)) : !inlineTextTags(prevTag); } var trimRight = nextTag && !selfClosingInlineTags(nextTag); if (trimRight && !options.collapseInlineTagWhitespace) { trimRight = nextTag.charAt(0) === "/" ? !inlineTextTags(nextTag.slice(1)) : !inlineTags(nextTag); } return collapseWhitespace( str, options, trimLeft, trimRight, prevTag && nextTag ); } function isConditionalComment(text) { return /^\[if\s[^\]]+]|\[endif]$/.test(text); } function isIgnoredComment(text, options) { for ( var i = 0, len = options.ignoreCustomComments.length; i < len; i++ ) { if (options.ignoreCustomComments[i].test(text)) { return true; } } return false; } function isEventAttribute(attrName, options) { var patterns = options.customEventAttributes; if (patterns) { for (var i = patterns.length; i--; ) { if (patterns[i].test(attrName)) { return true; } } return false; } return /^on[a-z]{3,}$/.test(attrName); } function canRemoveAttributeQuotes(value) { // https://mathiasbynens.be/notes/unquoted-attribute-values return /^[^ \t\n\f\r"'`=<>]+$/.test(value); } function attributesInclude(attributes, attribute) { for (var i = attributes.length; i--; ) { if (attributes[i].name.toLowerCase() === attribute) { return true; } } return false; } function isAttributeRedundant(tag, attrName, attrValue, attrs) { attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : ""; return ( (tag === "script" && attrName === "language" && attrValue === "javascript") || (tag === "form" && attrName === "method" && attrValue === "get") || (tag === "input" && attrName === "type" && attrValue === "text") || (tag === "script" && attrName === "charset" && !attributesInclude(attrs, "src")) || (tag === "a" && attrName === "name" && attributesInclude(attrs, "id")) || (tag === "area" && attrName === "shape" && attrValue === "rect") ); } // https://mathiasbynens.be/demo/javascript-mime-type // https://developer.mozilla.org/en/docs/Web/HTML/Element/script#attr-type var executableScriptsMimetypes = utils.createMap([ "text/javascript", "text/ecmascript", "text/jscript", "application/javascript", "application/x-javascript", "application/ecmascript" ]); function isScriptTypeAttribute(attrValue) { attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase(); return attrValue === "" || executableScriptsMimetypes(attrValue); } function isExecutableScript(tag, attrs) { if (tag !== "script") { return false; } for (var i = 0, len = attrs.length; i < len; i++) { var attrName = attrs[i].name.toLowerCase(); if (attrName === "type") { return isScriptTypeAttribute(attrs[i].value); } } return true; } function isStyleLinkTypeAttribute(attrValue) { attrValue = trimWhitespace(attrValue).toLowerCase(); return attrValue === "" || attrValue === "text/css"; } function isStyleSheet(tag, attrs) { if (tag !== "style") { return false; } for (var i = 0, len = attrs.length; i < len; i++) { var attrName = attrs[i].name.toLowerCase(); if (attrName === "type") { return isStyleLinkTypeAttribute(attrs[i].value); } } return true; } var isSimpleBoolean = createMapFromString( "allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible" ); var isBooleanValue = createMapFromString("true,false"); function isBooleanAttribute(attrName, attrValue) { return ( isSimpleBoolean(attrName) || (attrName === "draggable" && !isBooleanValue(attrValue)) ); } function isUriTypeAttribute(attrName, tag) { return ( (/^(?:a|area|link|base)$/.test(tag) && attrName === "href") || (tag === "img" && /^(?:src|longdesc|usemap)$/.test(attrName)) || (tag === "object" && /^(?:classid|codebase|data|usemap)$/.test(attrName)) || (tag === "q" && attrName === "cite") || (tag === "blockquote" && attrName === "cite") || ((tag === "ins" || tag === "del") && attrName === "cite") || (tag === "form" && attrName === "action") || (tag === "input" && (attrName === "src" || attrName === "usemap")) || (tag === "head" && attrName === "profile") || (tag === "script" && (attrName === "src" || attrName === "for")) ); } function isNumberTypeAttribute(attrName, tag) { return ( (/^(?:a|area|object|button)$/.test(tag) && attrName === "tabindex") || (tag === "input" && (attrName === "maxlength" || attrName === "tabindex")) || (tag === "select" && (attrName === "size" || attrName === "tabindex")) || (tag === "textarea" && /^(?:rows|cols|tabindex)$/.test(attrName)) || (tag === "colgroup" && attrName === "span") || (tag === "col" && attrName === "span") || ((tag === "th" || tag === "td") && (attrName === "rowspan" || attrName === "colspan")) ); } function isLinkType(tag, attrs, value) { if (tag !== "link") { return false; } for (var i = 0, len = attrs.length; i < len; i++) { if (attrs[i].name === "rel" && attrs[i].value === value) { return true; } } } function isMediaQuery(tag, attrs, attrName) { return ( attrName === "media" && (isLinkType(tag, attrs, "stylesheet") || isStyleSheet(tag, attrs)) ); } var srcsetTags = createMapFromString("img,source"); function isSrcset(attrName, tag) { return attrName === "srcset" && srcsetTags(tag); } function cleanAttributeValue(tag, attrName, attrValue, options, attrs) { if (isEventAttribute(attrName, options)) { attrValue = trimWhitespace(attrValue).replace( /^javascript:\s*/i, "" ); return options.minifyJS(attrValue, true); } else if (attrName === "class") { attrValue = trimWhitespace(attrValue); if (options.sortClassName) { attrValue = options.sortClassName(attrValue); } else { attrValue = collapseWhitespaceAll(attrValue); } return attrValue; } else if (isUriTypeAttribute(attrName, tag)) { attrValue = trimWhitespace(attrValue); return isLinkType(tag, attrs, "canonical") ? attrValue : options.minifyURLs(attrValue); } else if (isNumberTypeAttribute(attrName, tag)) { return trimWhitespace(attrValue); } else if (attrName === "style") { attrValue = trimWhitespace(attrValue); if (attrValue) { if ( /;$/.test(attrValue) && !/&#?[0-9a-zA-Z]+;$/.test(attrValue) ) { attrValue = attrValue.replace(/\s*;$/, ";"); } attrValue = options.minifyCSS(attrValue, "inline"); } return attrValue; } else if (isSrcset(attrName, tag)) { // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset attrValue = trimWhitespace(attrValue) .split(/\s+,\s*|\s*,\s+/) .map(function(candidate) { var url = candidate; var descriptor = ""; var match = candidate.match( /\s+([1-9][0-9]*w|[0-9]+(?:\.[0-9]+)?x)$/ ); if (match) { url = url.slice(0, -match[0].length); var num = +match[1].slice(0, -1); var suffix = match[1].slice(-1); if (num !== 1 || suffix !== "x") { descriptor = " " + num + suffix; } } return options.minifyURLs(url) + descriptor; }) .join(", "); } else if (isMetaViewport(tag, attrs) && attrName === "content") { attrValue = attrValue .replace(/\s+/g, "") .replace(/[0-9]+\.[0-9]+/g, function(numString) { // "0.90000" -> "0.9" // "1.0" -> "1" // "1.0001" -> "1.0001" (unchanged) return (+numString).toString(); }); } else if ( isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === "content" ) { return collapseWhitespaceAll(attrValue); } else if ( options.customAttrCollapse && options.customAttrCollapse.test(attrName) ) { attrValue = attrValue.replace(/\n+|\r+|\s{2,}/g, ""); } else if (tag === "script" && attrName === "type") { attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ";")); } else if (isMediaQuery(tag, attrs, attrName)) { attrValue = trimWhitespace(attrValue); return options.minifyCSS(attrValue, "media"); } return attrValue; } function isMetaViewport(tag, attrs) { if (tag !== "meta") { return false; } for (var i = 0, len = attrs.length; i < len; i++) { if (attrs[i].name === "name" && attrs[i].value === "viewport") { return true; } } } function isContentSecurityPolicy(tag, attrs) { if (tag !== "meta") { return false; } for (var i = 0, len = attrs.length; i < len; i++) { if ( attrs[i].name.toLowerCase() === "http-equiv" && attrs[i].value.toLowerCase() === "content-security-policy" ) { return true; } } } function ignoreCSS(id) { return ( "/* clean-css ignore:start */" + id + "/* clean-css ignore:end */" ); } // Wrap CSS declarations for CleanCSS > 3.x // See https://github.com/jakubpawlowicz/clean-css/issues/418 function wrapCSS(text, type) { switch (type) { case "inline": return "*{" + text + "}"; case "media": return "@media " + text + "{a{top:0}}"; default: return text; } } function unwrapCSS(text, type) { var matches; switch (type) { case "inline": matches = text.match(/^\*\{([\s\S]*)\}$/); break; case "media": matches = text.match(/^@media ([\s\S]*?)\s*{[\s\S]*}$/); break; } return matches ? matches[1] : text; } function cleanConditionalComment(comment, options) { return options.processConditionalComments ? comment.replace( /^(\[if\s[^\]]+]>)([\s\S]*?)( -1 ) { return minify(text, options); } } return text; } // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags // with the following deviations: // - retain if followed by