From 39ba83eefb803f8613857630ef8bc8501b704b71 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Tue, 15 May 2018 23:30:35 +0100 Subject: [PATCH 01/23] Created a Ip for now which contains all the helper functions, they may be moved into their corrosponding files in the future --- src/core/lib/Ip.mjs | 398 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 398 insertions(+) create mode 100644 src/core/lib/Ip.mjs diff --git a/src/core/lib/Ip.mjs b/src/core/lib/Ip.mjs new file mode 100644 index 00000000..66a713c7 --- /dev/null +++ b/src/core/lib/Ip.mjs @@ -0,0 +1,398 @@ +import Utils from "../Utils"; + +/** + * Parses an IPv4 CIDR range (e.g. 192.168.0.0/24) and displays information about it. + * + * @private + * @param {RegExp} cidr + * @param {boolean} includeNetworkInfo + * @param {boolean} enumerateAddresses + * @param {boolean} allowLargeList + * @returns {string} + */ +export function _ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, allowLargeList) { + const network = _strToIpv4(cidr[1]), + cidrRange = parseInt(cidr[2], 10); + let output = ""; + + if (cidrRange < 0 || cidrRange > 31) { + return "IPv4 CIDR must be less than 32"; + } + + const mask = ~(0xFFFFFFFF >>> cidrRange), + ip1 = network & mask, + ip2 = ip1 | ~mask; + + if (includeNetworkInfo) { + output += "Network: " + _ipv4ToStr(network) + "\n"; + output += "CIDR: " + cidrRange + "\n"; + output += "Mask: " + _ipv4ToStr(mask) + "\n"; + output += "Range: " + _ipv4ToStr(ip1) + " - " + _ipv4ToStr(ip2) + "\n"; + output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; + } + + if (enumerateAddresses) { + if (cidrRange >= 16 || allowLargeList) { + output += _generateIpv4Range(ip1, ip2).join("\n"); + } else { + output += _LARGE_RANGE_ERROR; + } + } + return output; +} + + /** + * Parses an IPv6 CIDR range (e.g. ff00::/48) and displays information about it. + * + * @private + * @param {RegExp} cidr + * @param {boolean} includeNetworkInfo + * @returns {string} + */ +export function _ipv6CidrRange(cidr, includeNetworkInfo) { + let output = ""; + const network = _strToIpv6(cidr[1]), + cidrRange = parseInt(cidr[cidr.length-1], 10); + + if (cidrRange < 0 || cidrRange > 127) { + return "IPv6 CIDR must be less than 128"; + } + + const ip1 = new Array(8), + ip2 = new Array(8), + total = new Array(128); + + const mask = _genIpv6Mask(cidrRange); + let totalDiff = ""; + + + for (let i = 0; i < 8; i++) { + ip1[i] = network[i] & mask[i]; + ip2[i] = ip1[i] | (~mask[i] & 0x0000FFFF); + totalDiff = (ip2[i] - ip1[i]).toString(2); + + if (totalDiff !== "0") { + for (let n = 0; n < totalDiff.length; n++) { + total[i*16 + 16-(totalDiff.length-n)] = totalDiff[n]; + } + } + } + + if (includeNetworkInfo) { + output += "Network: " + _ipv6ToStr(network) + "\n"; + output += "Shorthand: " + _ipv6ToStr(network, true) + "\n"; + output += "CIDR: " + cidrRange + "\n"; + output += "Mask: " + _ipv6ToStr(mask) + "\n"; + output += "Range: " + _ipv6ToStr(ip1) + " - " + _ipv6ToStr(ip2) + "\n"; + output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; + } + + return output; +} + + /** + * Parses an IPv4 hyphenated range (e.g. 192.168.0.0 - 192.168.0.255) and displays information + * about it. + * + * @private + * @param {RegExp} range + * @param {boolean} includeNetworkInfo + * @param {boolean} enumerateAddresses + * @param {boolean} allowLargeList + * @returns {string} + */ +export function _ipv4HyphenatedRange(range, includeNetworkInfo, enumerateAddresses, allowLargeList) { + const ip1 = _strToIpv4(range[1]), + ip2 = _strToIpv4(range[2]); + + let output = ""; + // Calculate mask + let diff = ip1 ^ ip2, + cidr = 32, + mask = 0; + + while (diff !== 0) { + diff >>= 1; + cidr--; + mask = (mask << 1) | 1; + } + + mask = ~mask >>> 0; + const network = ip1 & mask, + subIp1 = network & mask, + subIp2 = subIp1 | ~mask; + + if (includeNetworkInfo) { + output += "Minimum subnet required to hold this range:\n"; + output += "\tNetwork: " + _ipv4ToStr(network) + "\n"; + output += "\tCIDR: " + cidr + "\n"; + output += "\tMask: " + _ipv4ToStr(mask) + "\n"; + output += "\tSubnet range: " + _ipv4ToStr(subIp1) + " - " + _ipv4ToStr(subIp2) + "\n"; + output += "\tTotal addresses in subnet: " + (((subIp2 - subIp1) >>> 0) + 1) + "\n\n"; + output += "Range: " + _ipv4ToStr(ip1) + " - " + _ipv4ToStr(ip2) + "\n"; + output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; + } + + if (enumerateAddresses) { + if (((ip2 - ip1) >>> 0) <= 65536 || allowLargeList) { + output += _generateIpv4Range(ip1, ip2).join("\n"); + } else { + output += _LARGE_RANGE_ERROR; + } + } + return output; +} + + + /** + * Parses an IPv6 hyphenated range (e.g. ff00:: - ffff::) and displays information about it. + * + * @private + * @param {RegExp} range + * @param {boolean} includeNetworkInfo + * @returns {string} + */ +export function _ipv6HyphenatedRange(range, includeNetworkInfo) { + const ip1 = _strToIpv6(range[1]), + ip2 = _strToIpv6(range[14]), + total = new Array(128).fill(); + + let output = "", + t = "", + i; + + for (i = 0; i < 8; i++) { + t = (ip2[i] - ip1[i]).toString(2); + if (t !== "0") { + for (let n = 0; n < t.length; n++) { + total[i*16 + 16-(t.length-n)] = t[n]; + } + } + } + + if (includeNetworkInfo) { + output += "Range: " + _ipv6ToStr(ip1) + " - " + _ipv6ToStr(ip2) + "\n"; + output += "Shorthand range: " + _ipv6ToStr(ip1, true) + " - " + _ipv6ToStr(ip2, true) + "\n"; + output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; + } + + return output; +} + + /** + * Converts an IPv4 address from string format to numerical format. + * + * @private + * @param {string} ipStr + * @returns {number} + * + * @example + * // returns 168427520 + * _strToIpv4("10.10.0.0"); + */ +export function _strToIpv4(ipStr) { + const blocks = ipStr.split("."), + numBlocks = parseBlocks(blocks); + let result = 0; + + result += numBlocks[0] << 24; + result += numBlocks[1] << 16; + result += numBlocks[2] << 8; + result += numBlocks[3]; + + return result; + + /** + * Converts a list of 4 numeric strings in the range 0-255 to a list of numbers. + */ + function parseBlocks(blocks) { + if (blocks.length !== 4) + throw "More than 4 blocks."; + + const numBlocks = []; + for (let i = 0; i < 4; i++) { + numBlocks[i] = parseInt(blocks[i], 10); + if (numBlocks[i] < 0 || numBlocks[i] > 255) + throw "Block out of range."; + } + return numBlocks; + } +} + + + /** + * Converts an IPv4 address from numerical format to string format. + * + * @private + * @param {number} ipInt + * @returns {string} + * + * @example + * // returns "10.10.0.0" + * _ipv4ToStr(168427520); + */ +export function _ipv4ToStr(ipInt) { + const blockA = (ipInt >> 24) & 255, + blockB = (ipInt >> 16) & 255, + blockC = (ipInt >> 8) & 255, + blockD = ipInt & 255; + + return blockA + "." + blockB + "." + blockC + "." + blockD; +} + + + /** + * Converts an IPv6 address from string format to numerical array format. + * + * @private + * @param {string} ipStr + * @returns {number[]} + * + * @example + * // returns [65280, 0, 0, 0, 0, 0, 4369, 8738] + * _strToIpv6("ff00::1111:2222"); + */ +export function _strToIpv6(ipStr) { + let j = 0; + const blocks = ipStr.split(":"), + numBlocks = parseBlocks(blocks), + ipv6 = new Array(8); + + for (let i = 0; i < 8; i++) { + if (isNaN(numBlocks[j])) { + ipv6[i] = 0; + if (i === (8-numBlocks.slice(j).length)) j++; + } else { + ipv6[i] = numBlocks[j]; + j++; + } + } + return ipv6; + + /** + * Converts a list of 3-8 numeric hex strings in the range 0-65535 to a list of numbers. + */ + function parseBlocks(blocks) { + if (blocks.length < 3 || blocks.length > 8) + throw "Badly formatted IPv6 address."; + const numBlocks = []; + for (let i = 0; i < blocks.length; i++) { + numBlocks[i] = parseInt(blocks[i], 16); + if (numBlocks[i] < 0 || numBlocks[i] > 65535) + throw "Block out of range."; + } + return numBlocks; + } +} + + + /** + * Converts an IPv6 address from numerical array format to string format. + * + * @private + * @param {number[]} ipv6 + * @param {boolean} compact - Whether or not to return the address in shorthand or not + * @returns {string} + * + * @example + * // returns "ff00::1111:2222" + * _ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], true); + * + * // returns "ff00:0000:0000:0000:0000:0000:1111:2222" + * _ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], false); + */ +export function _ipv6ToStr(ipv6, compact) { + let output = "", + i = 0; + + if (compact) { + let start = -1, + end = -1, + s = 0, + e = -1; + + for (i = 0; i < 8; i++) { + if (ipv6[i] === 0 && e === (i-1)) { + e = i; + } else if (ipv6[i] === 0) { + s = i; e = i; + } + if (e >= 0 && (e-s) > (end - start)) { + start = s; + end = e; + } + } + + for (i = 0; i < 8; i++) { + if (i !== start) { + output += Utils.hex(ipv6[i], 1) + ":"; + } else { + output += ":"; + i = end; + if (end === 7) output += ":"; + } + } + if (output[0] === ":") + output = ":" + output; + } else { + for (i = 0; i < 8; i++) { + output += Utils.hex(ipv6[i], 4) + ":"; + } + } + return output.slice(0, output.length-1); +} + + /** + * Generates a list of IPv4 addresses in string format between two given numerical values. + * + * @private + * @param {number} ip + * @param {number} endIp + * @returns {string[]} + * + * @example + * // returns ["0.0.0.1", "0.0.0.2", "0.0.0.3"] + * IP._generateIpv4Range(1, 3); + */ +export function _generateIpv4Range(ip, endIp) { + const range = []; + if (endIp >= ip) { + for (; ip <= endIp; ip++) { + range.push(_ipv4ToStr(ip)); + } + } else { + range[0] = "Second IP address smaller than first."; + } + return range; +} + + /** + * Generates an IPv6 subnet mask given a CIDR value. + * + * @private + * @param {number} cidr + * @returns {number[]} + */ +export function _genIpv6Mask(cidr) { + const mask = new Array(8); + let shift; + + for (let i = 0; i < 8; i++) { + if (cidr > ((i+1)*16)) { + mask[i] = 0x0000FFFF; + } else { + shift = cidr-(i*16); + if (shift < 0) shift = 0; + mask[i] = ~((0x0000FFFF >>> shift) | 0xFFFF0000); + } + } + + return mask; +} + + /** + * @constant + * @default + * @private + */ +const _LARGE_RANGE_ERROR = "The specified range contains more than 65,536 addresses. Running this query could crash your browser. If you want to run it, select the \"Allow large queries\" option. You are advised to turn off \"Auto Bake\" whilst editing large ranges."; From 5b6d57fd47fd862744ebecc571dc418909a32822 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Tue, 15 May 2018 23:31:03 +0100 Subject: [PATCH 02/23] Ported "Parse IP Range". --- src/core/operations/ParseIPRange.mjs | 78 ++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 src/core/operations/ParseIPRange.mjs diff --git a/src/core/operations/ParseIPRange.mjs b/src/core/operations/ParseIPRange.mjs new file mode 100644 index 00000000..30ebf3d2 --- /dev/null +++ b/src/core/operations/ParseIPRange.mjs @@ -0,0 +1,78 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import {_ipv4CidrRange, _ipv4HyphenatedRange, _ipv6CidrRange, _ipv6HyphenatedRange} from "../lib/Ip"; + +/** + * Parse IP range operation + */ +class ParseIPRange extends Operation { + + /** + * ParseIPRange constructor + */ + constructor() { + super(); + + this.name = "Parse IP range"; + this.module = "JSBN"; + this.description = "Given a CIDR range (e.g. 10.0.0.0/24) or a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0), this operation provides network information and enumerates all IP addresses in the range.

IPv6 is supported but will not be enumerated."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Include network info", + "type": "boolean", + "value": "IP.INCLUDE_NETWORK_INFO" + }, + { + "name": "Enumerate IP addresses", + "type": "boolean", + "value": "IP.ENUMERATE_ADDRESSES" + }, + { + "name": "Allow large queries", + "type": "boolean", + "value": "IP.ALLOW_LARGE_LIST" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const includeNetworkInfo = args[0], + enumerateAddresses = args[1], + allowLargeList = args[2]; + + // Check what type of input we are looking at + const ipv4CidrRegex = /^\s*((?:\d{1,3}\.){3}\d{1,3})\/(\d\d?)\s*$/, + ipv4RangeRegex = /^\s*((?:\d{1,3}\.){3}\d{1,3})\s*-\s*((?:\d{1,3}\.){3}\d{1,3})\s*$/, + ipv6CidrRegex = /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\/(\d\d?\d?)\s*$/i, + ipv6RangeRegex = /^\s*(((?=.*::)(?!.*::[^-]+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*-\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\17)::|:\b|(?![\dA-F])))|(?!\16\17)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*$/i; + let match; + + if ((match = ipv4CidrRegex.exec(input))) { + return _ipv4CidrRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); + } else if ((match = ipv4RangeRegex.exec(input))) { + return _ipv4HyphenatedRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); + } else if ((match = ipv6CidrRegex.exec(input))) { + return _ipv6CidrRange(match, includeNetworkInfo); + } else if ((match = ipv6RangeRegex.exec(input))) { + return _ipv6HyphenatedRange(match, includeNetworkInfo); + } else { + return "Invalid input.\n\nEnter either a CIDR range (e.g. 10.0.0.0/24) or a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0). IPv6 also supported."; + } + } + +} + + +export default ParseIPRange; From 8d2adfaae78b26983551ef0506fa5e04154a6494 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Tue, 15 May 2018 23:48:18 +0100 Subject: [PATCH 03/23] Updated the Ip core file with more required functions/variables --- src/core/lib/Ip.mjs | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/src/core/lib/Ip.mjs b/src/core/lib/Ip.mjs index 66a713c7..e844562e 100644 --- a/src/core/lib/Ip.mjs +++ b/src/core/lib/Ip.mjs @@ -390,9 +390,19 @@ export function _genIpv6Mask(cidr) { return mask; } - /** - * @constant - * @default - * @private - */ +/** +* @constant +* @default +* @private +*/ const _LARGE_RANGE_ERROR = "The specified range contains more than 65,536 addresses. Running this query could crash your browser. If you want to run it, select the \"Allow large queries\" option. You are advised to turn off \"Auto Bake\" whilst editing large ranges."; +/** +* @constant +* @default +*/ +export const IPV4_REGEX = /^\s*((?:\d{1,3}\.){3}\d{1,3})\s*$/; +/** +* @constant +* @default +*/ +export const IPV6_REGEX = /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*$/i; From 654596ea79f22946d6055a853652be504d30def8 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Tue, 15 May 2018 23:48:33 +0100 Subject: [PATCH 04/23] Ported "Parse IPv6 Address" --- src/core/operations/ParseIPv6Address.mjs | 191 +++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 src/core/operations/ParseIPv6Address.mjs diff --git a/src/core/operations/ParseIPv6Address.mjs b/src/core/operations/ParseIPv6Address.mjs new file mode 100644 index 00000000..8eadc13b --- /dev/null +++ b/src/core/operations/ParseIPv6Address.mjs @@ -0,0 +1,191 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import {_strToIpv6, _ipv6ToStr, _ipv4ToStr, IPV6_REGEX} from "../lib/Ip"; +import BigInteger from "jsbn"; + +/** + * Parse IPv6 address operation + */ +class ParseIPv6Address extends Operation { + + /** + * ParseIPv6Address constructor + */ + constructor() { + super(); + + this.name = "Parse IPv6 address"; + this.module = "JSBN"; + this.description = "Displays the longhand and shorthand versions of a valid IPv6 address.

Recognises all reserved ranges and parses encapsulated or tunnelled addresses including Teredo and 6to4."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + let match, + output = ""; + + if ((match = IPV6_REGEX.exec(input))) { + const ipv6 = _strToIpv6(match[1]), + longhand = _ipv6ToStr(ipv6), + shorthand = _ipv6ToStr(ipv6, true); + + output += "Longhand: " + longhand + "\nShorthand: " + shorthand + "\n"; + + // Detect reserved addresses + if (shorthand === "::") { + // Unspecified address + output += "\nUnspecified address corresponding to 0.0.0.0/32 in IPv4."; + output += "\nUnspecified address range: ::/128"; + } else if (shorthand === "::1") { + // Loopback address + output += "\nLoopback address to the local host corresponding to 127.0.0.1/8 in IPv4."; + output += "\nLoopback addresses range: ::1/128"; + } else if (ipv6[0] === 0 && ipv6[1] === 0 && ipv6[2] === 0 && + ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0xffff) { + // IPv4-mapped IPv6 address + output += "\nIPv4-mapped IPv6 address detected. IPv6 clients will be handled natively by default, and IPv4 clients appear as IPv6 clients at their IPv4-mapped IPv6 address."; + output += "\nMapped IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\nIPv4-mapped IPv6 addresses range: ::ffff:0:0/96"; + } else if (ipv6[0] === 0 && ipv6[1] === 0 && ipv6[2] === 0 && + ipv6[3] === 0 && ipv6[4] === 0xffff && ipv6[5] === 0) { + // IPv4-translated address + output += "\nIPv4-translated address detected. Used by Stateless IP/ICMP Translation (SIIT). See RFCs 6145 and 6052 for more details."; + output += "\nTranslated IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\nIPv4-translated addresses range: ::ffff:0:0:0/96"; + } else if (ipv6[0] === 0x100) { + // Discard prefix per RFC 6666 + output += "\nDiscard prefix detected. This is used when forwarding traffic to a sinkhole router to mitigate the effects of a denial-of-service attack. See RFC 6666 for more details."; + output += "\nDiscard range: 100::/64"; + } else if (ipv6[0] === 0x64 && ipv6[1] === 0xff9b && ipv6[2] === 0 && + ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0) { + // IPv4/IPv6 translation per RFC 6052 + output += "\n'Well-Known' prefix for IPv4/IPv6 translation detected. See RFC 6052 for more details."; + output += "\nTranslated IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\n'Well-Known' prefix range: 64:ff9b::/96"; + } else if (ipv6[0] === 0x2001 && ipv6[1] === 0) { + // Teredo tunneling + output += "\nTeredo tunneling IPv6 address detected\n"; + const serverIpv4 = (ipv6[2] << 16) + ipv6[3], + udpPort = (~ipv6[5]) & 0xffff, + clientIpv4 = ~((ipv6[6] << 16) + ipv6[7]), + flagCone = (ipv6[4] >>> 15) & 1, + flagR = (ipv6[4] >>> 14) & 1, + flagRandom1 = (ipv6[4] >>> 10) & 15, + flagUg = (ipv6[4] >>> 8) & 3, + flagRandom2 = ipv6[4] & 255; + + output += "\nServer IPv4 address: " + _ipv4ToStr(serverIpv4) + + "\nClient IPv4 address: " + _ipv4ToStr(clientIpv4) + + "\nClient UDP port: " + udpPort + + "\nFlags:" + + "\n\tCone: " + flagCone; + + if (flagCone) { + output += " (Client is behind a cone NAT)"; + } else { + output += " (Client is not behind a cone NAT)"; + } + + output += "\n\tR: " + flagR; + + if (flagR) { + output += " Error: This flag should be set to 0. See RFC 5991 and RFC 4380."; + } + + output += "\n\tRandom1: " + Utils.bin(flagRandom1, 4) + + "\n\tUG: " + Utils.bin(flagUg, 2); + + if (flagUg) { + output += " Error: This flag should be set to 00. See RFC 4380."; + } + + output += "\n\tRandom2: " + Utils.bin(flagRandom2, 8); + + if (!flagR && !flagUg && flagRandom1 && flagRandom2) { + output += "\n\nThis is a valid Teredo address which complies with RFC 4380 and RFC 5991."; + } else if (!flagR && !flagUg) { + output += "\n\nThis is a valid Teredo address which complies with RFC 4380, however it does not comply with RFC 5991 (Teredo Security Updates) as there are no randomised bits in the flag field."; + } else { + output += "\n\nThis is an invalid Teredo address."; + } + output += "\n\nTeredo prefix range: 2001::/32"; + } else if (ipv6[0] === 0x2001 && ipv6[1] === 0x2 && ipv6[2] === 0) { + // Benchmarking + output += "\nAssigned to the Benchmarking Methodology Working Group (BMWG) for benchmarking IPv6. Corresponds to 198.18.0.0/15 for benchmarking IPv4. See RFC 5180 for more details."; + output += "\nBMWG range: 2001:2::/48"; + } else if (ipv6[0] === 0x2001 && ipv6[1] >= 0x10 && ipv6[1] <= 0x1f) { + // ORCHIDv1 + output += "\nDeprecated, previously ORCHIDv1 (Overlay Routable Cryptographic Hash Identifiers).\nORCHIDv1 range: 2001:10::/28\nORCHIDv2 now uses 2001:20::/28."; + } else if (ipv6[0] === 0x2001 && ipv6[1] >= 0x20 && ipv6[1] <= 0x2f) { + // ORCHIDv2 + output += "\nORCHIDv2 (Overlay Routable Cryptographic Hash Identifiers).\nThese are non-routed IPv6 addresses used for Cryptographic Hash Identifiers."; + output += "\nORCHIDv2 range: 2001:20::/28"; + } else if (ipv6[0] === 0x2001 && ipv6[1] === 0xdb8) { + // Documentation + output += "\nThis is a documentation IPv6 address. This range should be used whenever an example IPv6 address is given or to model networking scenarios. Corresponds to 192.0.2.0/24, 198.51.100.0/24, and 203.0.113.0/24 in IPv4."; + output += "\nDocumentation range: 2001:db8::/32"; + } else if (ipv6[0] === 0x2002) { + // 6to4 + output += "\n6to4 transition IPv6 address detected. See RFC 3056 for more details." + + "\n6to4 prefix range: 2002::/16"; + + const v4Addr = _ipv4ToStr((ipv6[1] << 16) + ipv6[2]), + slaId = ipv6[3], + interfaceIdStr = ipv6[4].toString(16) + ipv6[5].toString(16) + ipv6[6].toString(16) + ipv6[7].toString(16), + interfaceId = new BigInteger(interfaceIdStr, 16); + + output += "\n\nEncapsulated IPv4 address: " + v4Addr + + "\nSLA ID: " + slaId + + "\nInterface ID (base 16): " + interfaceIdStr + + "\nInterface ID (base 10): " + interfaceId.toString(); + } else if (ipv6[0] >= 0xfc00 && ipv6[0] <= 0xfdff) { + // Unique local address + output += "\nThis is a unique local address comparable to the IPv4 private addresses 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16. See RFC 4193 for more details."; + output += "\nUnique local addresses range: fc00::/7"; + } else if (ipv6[0] >= 0xfe80 && ipv6[0] <= 0xfebf) { + // Link-local address + output += "\nThis is a link-local address comparable to the auto-configuration addresses 169.254.0.0/16 in IPv4."; + output += "\nLink-local addresses range: fe80::/10"; + } else if (ipv6[0] >= 0xff00) { + // Multicast + output += "\nThis is a reserved multicast address."; + output += "\nMulticast addresses range: ff00::/8"; + } + + + // Detect possible EUI-64 addresses + if ((ipv6[5] & 0xff === 0xff) && (ipv6[6] >>> 8 === 0xfe)) { + output += "\n\nThis IPv6 address contains a modified EUI-64 address, identified by the presence of FF:FE in the 12th and 13th octets."; + + const intIdent = Utils.hex(ipv6[4] >>> 8) + ":" + Utils.hex(ipv6[4] & 0xff) + ":" + + Utils.hex(ipv6[5] >>> 8) + ":" + Utils.hex(ipv6[5] & 0xff) + ":" + + Utils.hex(ipv6[6] >>> 8) + ":" + Utils.hex(ipv6[6] & 0xff) + ":" + + Utils.hex(ipv6[7] >>> 8) + ":" + Utils.hex(ipv6[7] & 0xff), + mac = Utils.hex((ipv6[4] >>> 8) ^ 2) + ":" + Utils.hex(ipv6[4] & 0xff) + ":" + + Utils.hex(ipv6[5] >>> 8) + ":" + Utils.hex(ipv6[6] & 0xff) + ":" + + Utils.hex(ipv6[7] >>> 8) + ":" + Utils.hex(ipv6[7] & 0xff); + output += "\nInterface identifier: " + intIdent + + "\nMAC address: " + mac; + } + } else { + return "Invalid IPv6 address"; + } + return output; + } + +} + +export default ParseIPv6Address; From 1920e9c7fb2eb79a144488bb684e31cfa6291d77 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 21:37:48 +0100 Subject: [PATCH 05/23] Added more content to the Ip.mjs file, required for other functions. --- src/core/lib/Ip.mjs | 180 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) diff --git a/src/core/lib/Ip.mjs b/src/core/lib/Ip.mjs index e844562e..f63c3f9d 100644 --- a/src/core/lib/Ip.mjs +++ b/src/core/lib/Ip.mjs @@ -406,3 +406,183 @@ export const IPV4_REGEX = /^\s*((?:\d{1,3}\.){3}\d{1,3})\s*$/; * @default */ export const IPV6_REGEX = /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*$/i; + +/** + * Lookup table for Internet Protocols. + * Taken from https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml + * + * @private + * @constant + */ +export const _protocolLookup = { + 0: {keyword: "HOPOPT", protocol: "IPv6 Hop-by-Hop Option"}, + 1: {keyword: "ICMP", protocol: "Internet Control Message"}, + 2: {keyword: "IGMP", protocol: "Internet Group Management"}, + 3: {keyword: "GGP", protocol: "Gateway-to-Gateway"}, + 4: {keyword: "IPv4", protocol: "IPv4 encapsulation"}, + 5: {keyword: "ST", protocol: "Stream"}, + 6: {keyword: "TCP", protocol: "Transmission Control"}, + 7: {keyword: "CBT", protocol: "CBT"}, + 8: {keyword: "EGP", protocol: "Exterior Gateway Protocol"}, + 9: {keyword: "IGP", protocol: "any private interior gateway (used by Cisco for their IGRP)"}, + 10: {keyword: "BBN-RCC-MON", protocol: "BBN RCC Monitoring"}, + 11: {keyword: "NVP-II", protocol: "Network Voice Protocol"}, + 12: {keyword: "PUP", protocol: "PUP"}, + 13: {keyword: "ARGUS (deprecated)", protocol: "ARGUS"}, + 14: {keyword: "EMCON", protocol: "EMCON"}, + 15: {keyword: "XNET", protocol: "Cross Net Debugger"}, + 16: {keyword: "CHAOS", protocol: "Chaos"}, + 17: {keyword: "UDP", protocol: "User Datagram"}, + 18: {keyword: "MUX", protocol: "Multiplexing"}, + 19: {keyword: "DCN-MEAS", protocol: "DCN Measurement Subsystems"}, + 20: {keyword: "HMP", protocol: "Host Monitoring"}, + 21: {keyword: "PRM", protocol: "Packet Radio Measurement"}, + 22: {keyword: "XNS-IDP", protocol: "XEROX NS IDP"}, + 23: {keyword: "TRUNK-1", protocol: "Trunk-1"}, + 24: {keyword: "TRUNK-2", protocol: "Trunk-2"}, + 25: {keyword: "LEAF-1", protocol: "Leaf-1"}, + 26: {keyword: "LEAF-2", protocol: "Leaf-2"}, + 27: {keyword: "RDP", protocol: "Reliable Data Protocol"}, + 28: {keyword: "IRTP", protocol: "Internet Reliable Transaction"}, + 29: {keyword: "ISO-TP4", protocol: "ISO Transport Protocol Class 4"}, + 30: {keyword: "NETBLT", protocol: "Bulk Data Transfer Protocol"}, + 31: {keyword: "MFE-NSP", protocol: "MFE Network Services Protocol"}, + 32: {keyword: "MERIT-INP", protocol: "MERIT Internodal Protocol"}, + 33: {keyword: "DCCP", protocol: "Datagram Congestion Control Protocol"}, + 34: {keyword: "3PC", protocol: "Third Party Connect Protocol"}, + 35: {keyword: "IDPR", protocol: "Inter-Domain Policy Routing Protocol"}, + 36: {keyword: "XTP", protocol: "XTP"}, + 37: {keyword: "DDP", protocol: "Datagram Delivery Protocol"}, + 38: {keyword: "IDPR-CMTP", protocol: "IDPR Control Message Transport Proto"}, + 39: {keyword: "TP++", protocol: "TP++ Transport Protocol"}, + 40: {keyword: "IL", protocol: "IL Transport Protocol"}, + 41: {keyword: "IPv6", protocol: "IPv6 encapsulation"}, + 42: {keyword: "SDRP", protocol: "Source Demand Routing Protocol"}, + 43: {keyword: "IPv6-Route", protocol: "Routing Header for IPv6"}, + 44: {keyword: "IPv6-Frag", protocol: "Fragment Header for IPv6"}, + 45: {keyword: "IDRP", protocol: "Inter-Domain Routing Protocol"}, + 46: {keyword: "RSVP", protocol: "Reservation Protocol"}, + 47: {keyword: "GRE", protocol: "Generic Routing Encapsulation"}, + 48: {keyword: "DSR", protocol: "Dynamic Source Routing Protocol"}, + 49: {keyword: "BNA", protocol: "BNA"}, + 50: {keyword: "ESP", protocol: "Encap Security Payload"}, + 51: {keyword: "AH", protocol: "Authentication Header"}, + 52: {keyword: "I-NLSP", protocol: "Integrated Net Layer Security TUBA"}, + 53: {keyword: "SWIPE (deprecated)", protocol: "IP with Encryption"}, + 54: {keyword: "NARP", protocol: "NBMA Address Resolution Protocol"}, + 55: {keyword: "MOBILE", protocol: "IP Mobility"}, + 56: {keyword: "TLSP", protocol: "Transport Layer Security Protocol using Kryptonet key management"}, + 57: {keyword: "SKIP", protocol: "SKIP"}, + 58: {keyword: "IPv6-ICMP", protocol: "ICMP for IPv6"}, + 59: {keyword: "IPv6-NoNxt", protocol: "No Next Header for IPv6"}, + 60: {keyword: "IPv6-Opts", protocol: "Destination Options for IPv6"}, + 61: {keyword: "", protocol: "any host internal protocol"}, + 62: {keyword: "CFTP", protocol: "CFTP"}, + 63: {keyword: "", protocol: "any local network"}, + 64: {keyword: "SAT-EXPAK", protocol: "SATNET and Backroom EXPAK"}, + 65: {keyword: "KRYPTOLAN", protocol: "Kryptolan"}, + 66: {keyword: "RVD", protocol: "MIT Remote Virtual Disk Protocol"}, + 67: {keyword: "IPPC", protocol: "Internet Pluribus Packet Core"}, + 68: {keyword: "", protocol: "any distributed file system"}, + 69: {keyword: "SAT-MON", protocol: "SATNET Monitoring"}, + 70: {keyword: "VISA", protocol: "VISA Protocol"}, + 71: {keyword: "IPCV", protocol: "Internet Packet Core Utility"}, + 72: {keyword: "CPNX", protocol: "Computer Protocol Network Executive"}, + 73: {keyword: "CPHB", protocol: "Computer Protocol Heart Beat"}, + 74: {keyword: "WSN", protocol: "Wang Span Network"}, + 75: {keyword: "PVP", protocol: "Packet Video Protocol"}, + 76: {keyword: "BR-SAT-MON", protocol: "Backroom SATNET Monitoring"}, + 77: {keyword: "SUN-ND", protocol: "SUN ND PROTOCOL-Temporary"}, + 78: {keyword: "WB-MON", protocol: "WIDEBAND Monitoring"}, + 79: {keyword: "WB-EXPAK", protocol: "WIDEBAND EXPAK"}, + 80: {keyword: "ISO-IP", protocol: "ISO Internet Protocol"}, + 81: {keyword: "VMTP", protocol: "VMTP"}, + 82: {keyword: "SECURE-VMTP", protocol: "SECURE-VMTP"}, + 83: {keyword: "VINES", protocol: "VINES"}, + 84: {keyword: "TTP", protocol: "Transaction Transport Protocol"}, + 85: {keyword: "NSFNET-IGP", protocol: "NSFNET-IGP"}, + 86: {keyword: "DGP", protocol: "Dissimilar Gateway Protocol"}, + 87: {keyword: "TCF", protocol: "TCF"}, + 88: {keyword: "EIGRP", protocol: "EIGRP"}, + 89: {keyword: "OSPFIGP", protocol: "OSPFIGP"}, + 90: {keyword: "Sprite-RPC", protocol: "Sprite RPC Protocol"}, + 91: {keyword: "LARP", protocol: "Locus Address Resolution Protocol"}, + 92: {keyword: "MTP", protocol: "Multicast Transport Protocol"}, + 93: {keyword: "AX.25", protocol: "AX.25 Frames"}, + 94: {keyword: "IPIP", protocol: "IP-within-IP Encapsulation Protocol"}, + 95: {keyword: "MICP (deprecated)", protocol: "Mobile Internetworking Control Pro."}, + 96: {keyword: "SCC-SP", protocol: "Semaphore Communications Sec. Pro."}, + 97: {keyword: "ETHERIP", protocol: "Ethernet-within-IP Encapsulation"}, + 98: {keyword: "ENCAP", protocol: "Encapsulation Header"}, + 99: {keyword: "", protocol: "any private encryption scheme"}, + 100: {keyword: "GMTP", protocol: "GMTP"}, + 101: {keyword: "IFMP", protocol: "Ipsilon Flow Management Protocol"}, + 102: {keyword: "PNNI", protocol: "PNNI over IP"}, + 103: {keyword: "PIM", protocol: "Protocol Independent Multicast"}, + 104: {keyword: "ARIS", protocol: "ARIS"}, + 105: {keyword: "SCPS", protocol: "SCPS"}, + 106: {keyword: "QNX", protocol: "QNX"}, + 107: {keyword: "A/N", protocol: "Active Networks"}, + 108: {keyword: "IPComp", protocol: "IP Payload Compression Protocol"}, + 109: {keyword: "SNP", protocol: "Sitara Networks Protocol"}, + 110: {keyword: "Compaq-Peer", protocol: "Compaq Peer Protocol"}, + 111: {keyword: "IPX-in-IP", protocol: "IPX in IP"}, + 112: {keyword: "VRRP", protocol: "Virtual Router Redundancy Protocol"}, + 113: {keyword: "PGM", protocol: "PGM Reliable Transport Protocol"}, + 114: {keyword: "", protocol: "any 0-hop protocol"}, + 115: {keyword: "L2TP", protocol: "Layer Two Tunneling Protocol"}, + 116: {keyword: "DDX", protocol: "D-II Data Exchange (DDX)"}, + 117: {keyword: "IATP", protocol: "Interactive Agent Transfer Protocol"}, + 118: {keyword: "STP", protocol: "Schedule Transfer Protocol"}, + 119: {keyword: "SRP", protocol: "SpectraLink Radio Protocol"}, + 120: {keyword: "UTI", protocol: "UTI"}, + 121: {keyword: "SMP", protocol: "Simple Message Protocol"}, + 122: {keyword: "SM (deprecated)", protocol: "Simple Multicast Protocol"}, + 123: {keyword: "PTP", protocol: "Performance Transparency Protocol"}, + 124: {keyword: "ISIS over IPv4", protocol: ""}, + 125: {keyword: "FIRE", protocol: ""}, + 126: {keyword: "CRTP", protocol: "Combat Radio Transport Protocol"}, + 127: {keyword: "CRUDP", protocol: "Combat Radio User Datagram"}, + 128: {keyword: "SSCOPMCE", protocol: ""}, + 129: {keyword: "IPLT", protocol: ""}, + 130: {keyword: "SPS", protocol: "Secure Packet Shield"}, + 131: {keyword: "PIPE", protocol: "Private IP Encapsulation within IP"}, + 132: {keyword: "SCTP", protocol: "Stream Control Transmission Protocol"}, + 133: {keyword: "FC", protocol: "Fibre Channel"}, + 134: {keyword: "RSVP-E2E-IGNORE", protocol: ""}, + 135: {keyword: "Mobility Header", protocol: ""}, + 136: {keyword: "UDPLite", protocol: ""}, + 137: {keyword: "MPLS-in-IP", protocol: ""}, + 138: {keyword: "manet", protocol: "MANET Protocols"}, + 139: {keyword: "HIP", protocol: "Host Identity Protocol"}, + 140: {keyword: "Shim6", protocol: "Shim6 Protocol"}, + 141: {keyword: "WESP", protocol: "Wrapped Encapsulating Security Payload"}, + 142: {keyword: "ROHC", protocol: "Robust Header Compression"}, + 253: {keyword: "", protocol: "Use for experimentation and testing"}, + 254: {keyword: "", protocol: "Use for experimentation and testing"}, + 255: {keyword: "Reserved", protocol: ""} +}; + + +/** + * Generates an checksum, based upon provided raw input, for use with TCP/IP. + * + * @private + * @param {byteArray} input + * @returns {string} + */ +export function calculateTCPIPChecksum(input){ + let csum = 0; + + for (let i = 0; i < input.length; i++) { + if (i % 2 === 0) { + csum += (input[i] << 8); + } else { + csum += input[i]; + } + } + + csum = (csum >> 16) + (csum & 0xffff); + + return Utils.hex(0xffff - csum); +} From 161f89c03819860d002a2cb2566f20dba6d7fce8 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 21:50:48 +0100 Subject: [PATCH 06/23] Ported the TCPIPChecksum operation. Main content has been moved to the IP lib file, as it is used in multiple files. Changed the name, due to it originally containing a backslash, which caused issues with the script. --- src/core/operations/TCPIPChecksum.mjs | 40 +++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 src/core/operations/TCPIPChecksum.mjs diff --git a/src/core/operations/TCPIPChecksum.mjs b/src/core/operations/TCPIPChecksum.mjs new file mode 100644 index 00000000..e31cb511 --- /dev/null +++ b/src/core/operations/TCPIPChecksum.mjs @@ -0,0 +1,40 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import {calculateTCPIPChecksum} from "../lib/Ip"; + +/** + * TCP/IP Checksum operation + */ +class TCPIPChecksum extends Operation { + + /** + * TCP/IPChecksum constructor + */ + constructor() { + super(); + + this.name = "TCP/IP Checksum"; + this.module = "Hashing"; + this.description = "Calculates the checksum for a TCP (Transport Control Protocol) or IP (Internet Protocol) header from an input of raw bytes."; + this.inputType = "byteArray"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + return calculateTCPIPChecksum(input); + } + +} + +export default TCPIPChecksum; From 792218df9c5952aa75615f439e7badac82682cec Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 21:51:04 +0100 Subject: [PATCH 07/23] Ported the ChangeIPFormat operation. --- src/core/operations/ChangeIPFormat.mjs | 121 +++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 src/core/operations/ChangeIPFormat.mjs diff --git a/src/core/operations/ChangeIPFormat.mjs b/src/core/operations/ChangeIPFormat.mjs new file mode 100644 index 00000000..af3f8fc7 --- /dev/null +++ b/src/core/operations/ChangeIPFormat.mjs @@ -0,0 +1,121 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import {fromHex} from "../lib/Hex"; + +/** + * Change IP format operation + */ +class ChangeIPFormat extends Operation { + + /** + * ChangeIPFormat constructor + */ + constructor() { + super(); + + this.name = "Change IP format"; + this.module = "JSBN"; + this.description = "Convert an IP address from one format to another, e.g. 172.20.23.54 to ac141736"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Input format", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output format", + "type": "option", + "value": ["Hex", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const inFormat = args[0], + outFormat = args[1], + lines = input.split("\n"); + let output = "", + j = 0; + + + for (let i = 0; i < lines.length; i++) { + if (lines[i] === "") continue; + let baIp = []; + let octets; + let decimal; + + if (inFormat === outFormat) { + output += lines[i] + "\n"; + continue; + } + + // Convert to byte array IP from input format + switch (inFormat) { + case "Dotted Decimal": + octets = lines[i].split("."); + for (j = 0; j < octets.length; j++) { + baIp.push(parseInt(octets[j], 10)); + } + break; + case "Decimal": + decimal = lines[i].toString(); + baIp.push(decimal >> 24 & 255); + baIp.push(decimal >> 16 & 255); + baIp.push(decimal >> 8 & 255); + baIp.push(decimal & 255); + break; + case "Hex": + baIp = fromHex(lines[i]); + break; + default: + throw "Unsupported input IP format"; + } + + let ddIp; + let decIp; + let hexIp; + + // Convert byte array IP to output format + switch (outFormat) { + case "Dotted Decimal": + ddIp = ""; + for (j = 0; j < baIp.length; j++) { + ddIp += baIp[j] + "."; + } + output += ddIp.slice(0, ddIp.length-1) + "\n"; + break; + case "Decimal": + decIp = ((baIp[0] << 24) | (baIp[1] << 16) | (baIp[2] << 8) | baIp[3]) >>> 0; + output += decIp.toString() + "\n"; + break; + case "Hex": + hexIp = ""; + for (j = 0; j < baIp.length; j++) { + hexIp += Utils.hex(baIp[j]); + } + output += hexIp + "\n"; + break; + default: + throw "Unsupported output IP format"; + } + } + + return output.slice(0, output.length-1); + } + +} + +export default ChangeIPFormat; From b7bdd4eed6a3d712b129d798b100ac6d080a166b Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 21:51:24 +0100 Subject: [PATCH 08/23] Ported the GroupIPAddresses operation. --- src/core/operations/GroupIPAddresses.mjs | 134 +++++++++++++++++++++++ 1 file changed, 134 insertions(+) create mode 100644 src/core/operations/GroupIPAddresses.mjs diff --git a/src/core/operations/GroupIPAddresses.mjs b/src/core/operations/GroupIPAddresses.mjs new file mode 100644 index 00000000..6ff5023b --- /dev/null +++ b/src/core/operations/GroupIPAddresses.mjs @@ -0,0 +1,134 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import {_ipv6ToStr, _genIpv6Mask, IPV4_REGEX, _strToIpv6, _ipv4ToStr, IPV6_REGEX, _strToIpv4} from "../lib/Ip"; + +/** + * Group IP addresses operation + */ +class GroupIPAddresses extends Operation { + + /** + * GroupIPAddresses constructor + */ + constructor() { + super(); + + this.name = "Group IP addresses"; + this.module = "JSBN"; + this.description = "Groups a list of IP addresses into subnets. Supports both IPv4 and IPv6 addresses."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Delimiter", + "type": "option", + "value": ["Line feed", "CRLF", "Space", "Comma", "Semi-colon"] + }, + { + "name": "Subnet (CIDR)", + "type": "number", + "value": 24 + }, + { + "name": "Only show the subnets", + "type": "boolean", + "value": false, + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const delim = Utils.charRep(args[0]), + cidr = args[1], + onlySubnets = args[2], + ipv4Mask = cidr < 32 ? ~(0xFFFFFFFF >>> cidr) : 0xFFFFFFFF, + ipv6Mask = _genIpv6Mask(cidr), + ips = input.split(delim), + ipv4Networks = {}, + ipv6Networks = {}; + let match = null, + output = "", + ip = null, + network = null, + networkStr = "", + i; + + if (cidr < 0 || cidr > 127) { + return "CIDR must be less than 32 for IPv4 or 128 for IPv6"; + } + + // Parse all IPs and add to network dictionary + for (i = 0; i < ips.length; i++) { + if ((match = IPV4_REGEX.exec(ips[i]))) { + ip = _strToIpv4(match[1]) >>> 0; + network = ip & ipv4Mask; + + if (ipv4Networks.hasOwnProperty(network)) { + ipv4Networks[network].push(ip); + } else { + ipv4Networks[network] = [ip]; + } + } else if ((match = IPV6_REGEX.exec(ips[i]))) { + ip = _strToIpv6(match[1]); + network = []; + networkStr = ""; + + for (let j = 0; j < 8; j++) { + network.push(ip[j] & ipv6Mask[j]); + } + + networkStr = _ipv6ToStr(network, true); + + if (ipv6Networks.hasOwnProperty(networkStr)) { + ipv6Networks[networkStr].push(ip); + } else { + ipv6Networks[networkStr] = [ip]; + } + } + } + + // Sort IPv4 network dictionaries and print + for (network in ipv4Networks) { + ipv4Networks[network] = ipv4Networks[network].sort(); + + output += _ipv4ToStr(network) + "/" + cidr + "\n"; + + if (!onlySubnets) { + for (i = 0; i < ipv4Networks[network].length; i++) { + output += " " + _ipv4ToStr(ipv4Networks[network][i]) + "\n"; + } + output += "\n"; + } + } + + // Sort IPv6 network dictionaries and print + for (networkStr in ipv6Networks) { + //ipv6Networks[networkStr] = ipv6Networks[networkStr].sort(); TODO + + output += networkStr + "/" + cidr + "\n"; + + if (!onlySubnets) { + for (i = 0; i < ipv6Networks[networkStr].length; i++) { + output += " " + _ipv6ToStr(ipv6Networks[networkStr][i], true) + "\n"; + } + output += "\n"; + } + } + + return output; + } + +} + +export default GroupIPAddresses; From c17e89767415dd72bae3e70ee4f00e29d47dab5e Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 21:51:51 +0100 Subject: [PATCH 09/23] Ported the ParseIPv4Header operation. --- src/core/operations/ParseIPv4Header.mjs | 127 ++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 src/core/operations/ParseIPv4Header.mjs diff --git a/src/core/operations/ParseIPv4Header.mjs b/src/core/operations/ParseIPv4Header.mjs new file mode 100644 index 00000000..d88d6f60 --- /dev/null +++ b/src/core/operations/ParseIPv4Header.mjs @@ -0,0 +1,127 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import {fromHex, toHex} from "../lib/Hex"; +import {_ipv4ToStr, _protocolLookup, calculateTCPIPChecksum} from "../lib/Ip"; + +/** + * Parse IPv4 header operation + */ +class ParseIPv4Header extends Operation { + + /** + * ParseIPv4Header constructor + */ + constructor() { + super(); + + this.name = "Parse IPv4 header"; + this.module = "JSBN"; + this.description = "Given an IPv4 header, this operations parses and displays each field in an easily readable format."; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Input format", + "type": "option", + "value": ["Hex", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const format = args[0]; + let output; + + if (format === "Hex") { + input = fromHex(input); + } else if (format === "Raw") { + input = Utils.strToByteArray(input); + } else { + return "Unrecognised input format."; + } + + let ihl = input[0] & 0x0f; + const dscp = (input[1] >>> 2) & 0x3f, + ecn = input[1] & 0x03, + length = input[2] << 8 | input[3], + identification = input[4] << 8 | input[5], + flags = (input[6] >>> 5) & 0x07, + fragOffset = (input[6] & 0x1f) << 8 | input[7], + ttl = input[8], + protocol = input[9], + checksum = input[10] << 8 | input[11], + srcIP = input[12] << 24 | input[13] << 16 | input[14] << 8 | input[15], + dstIP = input[16] << 24 | input[17] << 16 | input[18] << 8 | input[19], + checksumHeader = input.slice(0, 10).concat([0, 0]).concat(input.slice(12, 20)); + let version = (input[0] >>> 4) & 0x0f, + options = []; + + + // Version + if (version !== 4) { + version = version + " (Error: for IPv4 headers, this should always be set to 4)"; + } + + // IHL + if (ihl < 5) { + ihl = ihl + " (Error: this should always be at least 5)"; + } else if (ihl > 5) { + // sort out options... + const optionsLen = ihl * 4 - 20; + options = input.slice(20, optionsLen + 20); + } + + // Protocol + const protocolInfo = _protocolLookup[protocol] || {keyword: "", protocol: ""}; + + // Checksum + const correctChecksum = calculateTCPIPChecksum(checksumHeader), + givenChecksum = Utils.hex(checksum); + let checksumResult; + if (correctChecksum === givenChecksum) { + checksumResult = givenChecksum + " (correct)"; + } else { + checksumResult = givenChecksum + " (incorrect, should be " + correctChecksum + ")"; + } + + output = "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""; + + if (ihl > 5) { + output += ""; + } + + return output + "
FieldValue
Version" + version + "
Internet Header Length (IHL)" + ihl + " (" + (ihl * 4) + " bytes)
Differentiated Services Code Point (DSCP)" + dscp + "
Explicit Congestion Notification (ECN)" + ecn + "
Total length" + length + " bytes" + + "\n IP header: " + (ihl * 4) + " bytes" + + "\n Data: " + (length - ihl * 4) + " bytes
Identification0x" + Utils.hex(identification) + " (" + identification + ")
Flags0x" + Utils.hex(flags, 2) + + "\n Reserved bit:" + (flags >> 2) + " (must be 0)" + + "\n Don't fragment:" + (flags >> 1 & 1) + + "\n More fragments:" + (flags & 1) + "
Fragment offset" + fragOffset + "
Time-To-Live" + ttl + "
Protocol" + protocol + ", " + protocolInfo.protocol + " (" + protocolInfo.keyword + ")
Header checksum" + checksumResult + "
Source IP address" + _ipv4ToStr(srcIP) + "
Destination IP address" + _ipv4ToStr(dstIP) + "
Options" + toHex(options) + "
"; + } + +} + +export default ParseIPv4Header; From 3ba12ae9ac7fe16cb36c36cee5fb664dfa923512 Mon Sep 17 00:00:00 2001 From: Callum Fraser Date: Wed, 16 May 2018 22:32:46 +0100 Subject: [PATCH 10/23] Made variables non-private, and followed convention for the references to the IP lib. --- src/core/lib/Ip.mjs | 80 ++++++++++++------------ src/core/operations/ChangeIPFormat.mjs | 2 +- src/core/operations/GroupIPAddresses.mjs | 16 ++--- src/core/operations/ParseIPRange.mjs | 10 +-- src/core/operations/ParseIPv4Header.mjs | 10 +-- src/core/operations/ParseIPv6Address.mjs | 20 +++--- src/core/operations/TCPIPChecksum.mjs | 2 +- 7 files changed, 70 insertions(+), 70 deletions(-) diff --git a/src/core/lib/Ip.mjs b/src/core/lib/Ip.mjs index f63c3f9d..67e69c03 100644 --- a/src/core/lib/Ip.mjs +++ b/src/core/lib/Ip.mjs @@ -10,8 +10,8 @@ import Utils from "../Utils"; * @param {boolean} allowLargeList * @returns {string} */ -export function _ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, allowLargeList) { - const network = _strToIpv4(cidr[1]), +export function ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, allowLargeList) { + const network = strToIpv4(cidr[1]), cidrRange = parseInt(cidr[2], 10); let output = ""; @@ -24,16 +24,16 @@ export function _ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, all ip2 = ip1 | ~mask; if (includeNetworkInfo) { - output += "Network: " + _ipv4ToStr(network) + "\n"; + output += "Network: " + ipv4ToStr(network) + "\n"; output += "CIDR: " + cidrRange + "\n"; - output += "Mask: " + _ipv4ToStr(mask) + "\n"; - output += "Range: " + _ipv4ToStr(ip1) + " - " + _ipv4ToStr(ip2) + "\n"; + output += "Mask: " + ipv4ToStr(mask) + "\n"; + output += "Range: " + ipv4ToStr(ip1) + " - " + ipv4ToStr(ip2) + "\n"; output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; } if (enumerateAddresses) { if (cidrRange >= 16 || allowLargeList) { - output += _generateIpv4Range(ip1, ip2).join("\n"); + output += generateIpv4Range(ip1, ip2).join("\n"); } else { output += _LARGE_RANGE_ERROR; } @@ -49,9 +49,9 @@ export function _ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, all * @param {boolean} includeNetworkInfo * @returns {string} */ -export function _ipv6CidrRange(cidr, includeNetworkInfo) { +export function ipv6CidrRange(cidr, includeNetworkInfo) { let output = ""; - const network = _strToIpv6(cidr[1]), + const network = strToIpv6(cidr[1]), cidrRange = parseInt(cidr[cidr.length-1], 10); if (cidrRange < 0 || cidrRange > 127) { @@ -62,7 +62,7 @@ export function _ipv6CidrRange(cidr, includeNetworkInfo) { ip2 = new Array(8), total = new Array(128); - const mask = _genIpv6Mask(cidrRange); + const mask = genIpv6Mask(cidrRange); let totalDiff = ""; @@ -79,11 +79,11 @@ export function _ipv6CidrRange(cidr, includeNetworkInfo) { } if (includeNetworkInfo) { - output += "Network: " + _ipv6ToStr(network) + "\n"; - output += "Shorthand: " + _ipv6ToStr(network, true) + "\n"; + output += "Network: " + ipv6ToStr(network) + "\n"; + output += "Shorthand: " + ipv6ToStr(network, true) + "\n"; output += "CIDR: " + cidrRange + "\n"; - output += "Mask: " + _ipv6ToStr(mask) + "\n"; - output += "Range: " + _ipv6ToStr(ip1) + " - " + _ipv6ToStr(ip2) + "\n"; + output += "Mask: " + ipv6ToStr(mask) + "\n"; + output += "Range: " + ipv6ToStr(ip1) + " - " + ipv6ToStr(ip2) + "\n"; output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; } @@ -101,9 +101,9 @@ export function _ipv6CidrRange(cidr, includeNetworkInfo) { * @param {boolean} allowLargeList * @returns {string} */ -export function _ipv4HyphenatedRange(range, includeNetworkInfo, enumerateAddresses, allowLargeList) { - const ip1 = _strToIpv4(range[1]), - ip2 = _strToIpv4(range[2]); +export function ipv4HyphenatedRange(range, includeNetworkInfo, enumerateAddresses, allowLargeList) { + const ip1 = strToIpv4(range[1]), + ip2 = strToIpv4(range[2]); let output = ""; // Calculate mask @@ -124,18 +124,18 @@ export function _ipv4HyphenatedRange(range, includeNetworkInfo, enumerateAddress if (includeNetworkInfo) { output += "Minimum subnet required to hold this range:\n"; - output += "\tNetwork: " + _ipv4ToStr(network) + "\n"; + output += "\tNetwork: " + ipv4ToStr(network) + "\n"; output += "\tCIDR: " + cidr + "\n"; - output += "\tMask: " + _ipv4ToStr(mask) + "\n"; - output += "\tSubnet range: " + _ipv4ToStr(subIp1) + " - " + _ipv4ToStr(subIp2) + "\n"; + output += "\tMask: " + ipv4ToStr(mask) + "\n"; + output += "\tSubnet range: " + ipv4ToStr(subIp1) + " - " + ipv4ToStr(subIp2) + "\n"; output += "\tTotal addresses in subnet: " + (((subIp2 - subIp1) >>> 0) + 1) + "\n\n"; - output += "Range: " + _ipv4ToStr(ip1) + " - " + _ipv4ToStr(ip2) + "\n"; + output += "Range: " + ipv4ToStr(ip1) + " - " + ipv4ToStr(ip2) + "\n"; output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; } if (enumerateAddresses) { if (((ip2 - ip1) >>> 0) <= 65536 || allowLargeList) { - output += _generateIpv4Range(ip1, ip2).join("\n"); + output += generateIpv4Range(ip1, ip2).join("\n"); } else { output += _LARGE_RANGE_ERROR; } @@ -152,9 +152,9 @@ export function _ipv4HyphenatedRange(range, includeNetworkInfo, enumerateAddress * @param {boolean} includeNetworkInfo * @returns {string} */ -export function _ipv6HyphenatedRange(range, includeNetworkInfo) { - const ip1 = _strToIpv6(range[1]), - ip2 = _strToIpv6(range[14]), +export function ipv6HyphenatedRange(range, includeNetworkInfo) { + const ip1 = strToIpv6(range[1]), + ip2 = strToIpv6(range[14]), total = new Array(128).fill(); let output = "", @@ -171,8 +171,8 @@ export function _ipv6HyphenatedRange(range, includeNetworkInfo) { } if (includeNetworkInfo) { - output += "Range: " + _ipv6ToStr(ip1) + " - " + _ipv6ToStr(ip2) + "\n"; - output += "Shorthand range: " + _ipv6ToStr(ip1, true) + " - " + _ipv6ToStr(ip2, true) + "\n"; + output += "Range: " + ipv6ToStr(ip1) + " - " + ipv6ToStr(ip2) + "\n"; + output += "Shorthand range: " + ipv6ToStr(ip1, true) + " - " + ipv6ToStr(ip2, true) + "\n"; output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; } @@ -188,9 +188,9 @@ export function _ipv6HyphenatedRange(range, includeNetworkInfo) { * * @example * // returns 168427520 - * _strToIpv4("10.10.0.0"); + * strToIpv4("10.10.0.0"); */ -export function _strToIpv4(ipStr) { +export function strToIpv4(ipStr) { const blocks = ipStr.split("."), numBlocks = parseBlocks(blocks); let result = 0; @@ -229,9 +229,9 @@ export function _strToIpv4(ipStr) { * * @example * // returns "10.10.0.0" - * _ipv4ToStr(168427520); + * ipv4ToStr(168427520); */ -export function _ipv4ToStr(ipInt) { +export function ipv4ToStr(ipInt) { const blockA = (ipInt >> 24) & 255, blockB = (ipInt >> 16) & 255, blockC = (ipInt >> 8) & 255, @@ -250,9 +250,9 @@ export function _ipv4ToStr(ipInt) { * * @example * // returns [65280, 0, 0, 0, 0, 0, 4369, 8738] - * _strToIpv6("ff00::1111:2222"); + * strToIpv6("ff00::1111:2222"); */ -export function _strToIpv6(ipStr) { +export function strToIpv6(ipStr) { let j = 0; const blocks = ipStr.split(":"), numBlocks = parseBlocks(blocks), @@ -296,12 +296,12 @@ export function _strToIpv6(ipStr) { * * @example * // returns "ff00::1111:2222" - * _ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], true); + * ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], true); * * // returns "ff00:0000:0000:0000:0000:0000:1111:2222" - * _ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], false); + * ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], false); */ -export function _ipv6ToStr(ipv6, compact) { +export function ipv6ToStr(ipv6, compact) { let output = "", i = 0; @@ -352,13 +352,13 @@ export function _ipv6ToStr(ipv6, compact) { * * @example * // returns ["0.0.0.1", "0.0.0.2", "0.0.0.3"] - * IP._generateIpv4Range(1, 3); + * IP.generateIpv4Range(1, 3); */ -export function _generateIpv4Range(ip, endIp) { +export function generateIpv4Range(ip, endIp) { const range = []; if (endIp >= ip) { for (; ip <= endIp; ip++) { - range.push(_ipv4ToStr(ip)); + range.push(ipv4ToStr(ip)); } } else { range[0] = "Second IP address smaller than first."; @@ -373,7 +373,7 @@ export function _generateIpv4Range(ip, endIp) { * @param {number} cidr * @returns {number[]} */ -export function _genIpv6Mask(cidr) { +export function genIpv6Mask(cidr) { const mask = new Array(8); let shift; @@ -414,7 +414,7 @@ export const IPV6_REGEX = /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|) * @private * @constant */ -export const _protocolLookup = { +export const protocolLookup = { 0: {keyword: "HOPOPT", protocol: "IPv6 Hop-by-Hop Option"}, 1: {keyword: "ICMP", protocol: "Internet Control Message"}, 2: {keyword: "IGMP", protocol: "Internet Group Management"}, diff --git a/src/core/operations/ChangeIPFormat.mjs b/src/core/operations/ChangeIPFormat.mjs index af3f8fc7..fcc43dea 100644 --- a/src/core/operations/ChangeIPFormat.mjs +++ b/src/core/operations/ChangeIPFormat.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import {fromHex} from "../lib/Hex"; +import {fromHex} from "../lib/Hex.mjs"; /** * Change IP format operation diff --git a/src/core/operations/GroupIPAddresses.mjs b/src/core/operations/GroupIPAddresses.mjs index 6ff5023b..423f1b33 100644 --- a/src/core/operations/GroupIPAddresses.mjs +++ b/src/core/operations/GroupIPAddresses.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import {_ipv6ToStr, _genIpv6Mask, IPV4_REGEX, _strToIpv6, _ipv4ToStr, IPV6_REGEX, _strToIpv4} from "../lib/Ip"; +import {ipv6ToStr, genIpv6Mask, IPV4_REGEX, strToIpv6, ipv4ToStr, IPV6_REGEX, strToIpv4} from "../lib/Ip.mjs"; /** * Group IP addresses operation @@ -53,7 +53,7 @@ class GroupIPAddresses extends Operation { cidr = args[1], onlySubnets = args[2], ipv4Mask = cidr < 32 ? ~(0xFFFFFFFF >>> cidr) : 0xFFFFFFFF, - ipv6Mask = _genIpv6Mask(cidr), + ipv6Mask = genIpv6Mask(cidr), ips = input.split(delim), ipv4Networks = {}, ipv6Networks = {}; @@ -71,7 +71,7 @@ class GroupIPAddresses extends Operation { // Parse all IPs and add to network dictionary for (i = 0; i < ips.length; i++) { if ((match = IPV4_REGEX.exec(ips[i]))) { - ip = _strToIpv4(match[1]) >>> 0; + ip = strToIpv4(match[1]) >>> 0; network = ip & ipv4Mask; if (ipv4Networks.hasOwnProperty(network)) { @@ -80,7 +80,7 @@ class GroupIPAddresses extends Operation { ipv4Networks[network] = [ip]; } } else if ((match = IPV6_REGEX.exec(ips[i]))) { - ip = _strToIpv6(match[1]); + ip = strToIpv6(match[1]); network = []; networkStr = ""; @@ -88,7 +88,7 @@ class GroupIPAddresses extends Operation { network.push(ip[j] & ipv6Mask[j]); } - networkStr = _ipv6ToStr(network, true); + networkStr = ipv6ToStr(network, true); if (ipv6Networks.hasOwnProperty(networkStr)) { ipv6Networks[networkStr].push(ip); @@ -102,11 +102,11 @@ class GroupIPAddresses extends Operation { for (network in ipv4Networks) { ipv4Networks[network] = ipv4Networks[network].sort(); - output += _ipv4ToStr(network) + "/" + cidr + "\n"; + output += ipv4ToStr(network) + "/" + cidr + "\n"; if (!onlySubnets) { for (i = 0; i < ipv4Networks[network].length; i++) { - output += " " + _ipv4ToStr(ipv4Networks[network][i]) + "\n"; + output += " " + ipv4ToStr(ipv4Networks[network][i]) + "\n"; } output += "\n"; } @@ -120,7 +120,7 @@ class GroupIPAddresses extends Operation { if (!onlySubnets) { for (i = 0; i < ipv6Networks[networkStr].length; i++) { - output += " " + _ipv6ToStr(ipv6Networks[networkStr][i], true) + "\n"; + output += " " + ipv6ToStr(ipv6Networks[networkStr][i], true) + "\n"; } output += "\n"; } diff --git a/src/core/operations/ParseIPRange.mjs b/src/core/operations/ParseIPRange.mjs index 30ebf3d2..dbc09ef8 100644 --- a/src/core/operations/ParseIPRange.mjs +++ b/src/core/operations/ParseIPRange.mjs @@ -5,7 +5,7 @@ */ import Operation from "../Operation"; -import {_ipv4CidrRange, _ipv4HyphenatedRange, _ipv6CidrRange, _ipv6HyphenatedRange} from "../lib/Ip"; +import {ipv4CidrRange, ipv4HyphenatedRange, ipv6CidrRange, ipv6HyphenatedRange} from "../lib/Ip"; /** * Parse IP range operation @@ -60,13 +60,13 @@ class ParseIPRange extends Operation { let match; if ((match = ipv4CidrRegex.exec(input))) { - return _ipv4CidrRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); + return ipv4CidrRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); } else if ((match = ipv4RangeRegex.exec(input))) { - return _ipv4HyphenatedRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); + return ipv4HyphenatedRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); } else if ((match = ipv6CidrRegex.exec(input))) { - return _ipv6CidrRange(match, includeNetworkInfo); + return ipv6CidrRange(match, includeNetworkInfo); } else if ((match = ipv6RangeRegex.exec(input))) { - return _ipv6HyphenatedRange(match, includeNetworkInfo); + return ipv6HyphenatedRange(match, includeNetworkInfo); } else { return "Invalid input.\n\nEnter either a CIDR range (e.g. 10.0.0.0/24) or a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0). IPv6 also supported."; } diff --git a/src/core/operations/ParseIPv4Header.mjs b/src/core/operations/ParseIPv4Header.mjs index d88d6f60..db1cc926 100644 --- a/src/core/operations/ParseIPv4Header.mjs +++ b/src/core/operations/ParseIPv4Header.mjs @@ -6,8 +6,8 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import {fromHex, toHex} from "../lib/Hex"; -import {_ipv4ToStr, _protocolLookup, calculateTCPIPChecksum} from "../lib/Ip"; +import {fromHex, toHex} from "../lib/Hex.mjs"; +import {ipv4ToStr, protocolLookup, calculateTCPIPChecksum} from "../lib/Ip.mjs"; /** * Parse IPv4 header operation @@ -83,7 +83,7 @@ class ParseIPv4Header extends Operation { } // Protocol - const protocolInfo = _protocolLookup[protocol] || {keyword: "", protocol: ""}; + const protocolInfo = protocolLookup[protocol] || {keyword: "", protocol: ""}; // Checksum const correctChecksum = calculateTCPIPChecksum(checksumHeader), @@ -112,8 +112,8 @@ class ParseIPv4Header extends Operation { "Time-To-Live" + ttl + "" + "Protocol" + protocol + ", " + protocolInfo.protocol + " (" + protocolInfo.keyword + ")" + "Header checksum" + checksumResult + "" + - "Source IP address" + _ipv4ToStr(srcIP) + "" + - "Destination IP address" + _ipv4ToStr(dstIP) + ""; + "Source IP address" + ipv4ToStr(srcIP) + "" + + "Destination IP address" + ipv4ToStr(dstIP) + ""; if (ihl > 5) { output += "Options" + toHex(options) + ""; diff --git a/src/core/operations/ParseIPv6Address.mjs b/src/core/operations/ParseIPv6Address.mjs index 8eadc13b..eca7a46e 100644 --- a/src/core/operations/ParseIPv6Address.mjs +++ b/src/core/operations/ParseIPv6Address.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import {_strToIpv6, _ipv6ToStr, _ipv4ToStr, IPV6_REGEX} from "../lib/Ip"; +import {strToIpv6, ipv6ToStr, ipv4ToStr, IPV6_REGEX} from "../lib/Ip.mjs"; import BigInteger from "jsbn"; /** @@ -38,9 +38,9 @@ class ParseIPv6Address extends Operation { output = ""; if ((match = IPV6_REGEX.exec(input))) { - const ipv6 = _strToIpv6(match[1]), - longhand = _ipv6ToStr(ipv6), - shorthand = _ipv6ToStr(ipv6, true); + const ipv6 = strToIpv6(match[1]), + longhand = ipv6ToStr(ipv6), + shorthand = ipv6ToStr(ipv6, true); output += "Longhand: " + longhand + "\nShorthand: " + shorthand + "\n"; @@ -57,13 +57,13 @@ class ParseIPv6Address extends Operation { ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0xffff) { // IPv4-mapped IPv6 address output += "\nIPv4-mapped IPv6 address detected. IPv6 clients will be handled natively by default, and IPv4 clients appear as IPv6 clients at their IPv4-mapped IPv6 address."; - output += "\nMapped IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\nMapped IPv4 address: " + ipv4ToStr((ipv6[6] << 16) + ipv6[7]); output += "\nIPv4-mapped IPv6 addresses range: ::ffff:0:0/96"; } else if (ipv6[0] === 0 && ipv6[1] === 0 && ipv6[2] === 0 && ipv6[3] === 0 && ipv6[4] === 0xffff && ipv6[5] === 0) { // IPv4-translated address output += "\nIPv4-translated address detected. Used by Stateless IP/ICMP Translation (SIIT). See RFCs 6145 and 6052 for more details."; - output += "\nTranslated IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\nTranslated IPv4 address: " + ipv4ToStr((ipv6[6] << 16) + ipv6[7]); output += "\nIPv4-translated addresses range: ::ffff:0:0:0/96"; } else if (ipv6[0] === 0x100) { // Discard prefix per RFC 6666 @@ -73,7 +73,7 @@ class ParseIPv6Address extends Operation { ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0) { // IPv4/IPv6 translation per RFC 6052 output += "\n'Well-Known' prefix for IPv4/IPv6 translation detected. See RFC 6052 for more details."; - output += "\nTranslated IPv4 address: " + _ipv4ToStr((ipv6[6] << 16) + ipv6[7]); + output += "\nTranslated IPv4 address: " + ipv4ToStr((ipv6[6] << 16) + ipv6[7]); output += "\n'Well-Known' prefix range: 64:ff9b::/96"; } else if (ipv6[0] === 0x2001 && ipv6[1] === 0) { // Teredo tunneling @@ -87,8 +87,8 @@ class ParseIPv6Address extends Operation { flagUg = (ipv6[4] >>> 8) & 3, flagRandom2 = ipv6[4] & 255; - output += "\nServer IPv4 address: " + _ipv4ToStr(serverIpv4) + - "\nClient IPv4 address: " + _ipv4ToStr(clientIpv4) + + output += "\nServer IPv4 address: " + ipv4ToStr(serverIpv4) + + "\nClient IPv4 address: " + ipv4ToStr(clientIpv4) + "\nClient UDP port: " + udpPort + "\nFlags:" + "\n\tCone: " + flagCone; @@ -142,7 +142,7 @@ class ParseIPv6Address extends Operation { output += "\n6to4 transition IPv6 address detected. See RFC 3056 for more details." + "\n6to4 prefix range: 2002::/16"; - const v4Addr = _ipv4ToStr((ipv6[1] << 16) + ipv6[2]), + const v4Addr = ipv4ToStr((ipv6[1] << 16) + ipv6[2]), slaId = ipv6[3], interfaceIdStr = ipv6[4].toString(16) + ipv6[5].toString(16) + ipv6[6].toString(16) + ipv6[7].toString(16), interfaceId = new BigInteger(interfaceIdStr, 16); diff --git a/src/core/operations/TCPIPChecksum.mjs b/src/core/operations/TCPIPChecksum.mjs index e31cb511..cc673777 100644 --- a/src/core/operations/TCPIPChecksum.mjs +++ b/src/core/operations/TCPIPChecksum.mjs @@ -5,7 +5,7 @@ */ import Operation from "../Operation"; -import {calculateTCPIPChecksum} from "../lib/Ip"; +import {calculateTCPIPChecksum} from "../lib/Ip.mjs"; /** * TCP/IP Checksum operation From 189e077247b81e2267c4fa1c65f0c64cb396a825 Mon Sep 17 00:00:00 2001 From: Matt C Date: Wed, 23 May 2018 16:54:12 +0100 Subject: [PATCH 11/23] Ported blowfish operations and library to ESM modules --- package-lock.json | 4067 +++++++++++------------ package.json | 7 +- src/core/operations/BlowfishDecrypt.mjs | 101 + src/core/operations/BlowfishEncrypt.mjs | 98 + src/core/vendor/Blowfish.mjs | 652 ++++ 5 files changed, 2885 insertions(+), 2040 deletions(-) create mode 100644 src/core/operations/BlowfishDecrypt.mjs create mode 100644 src/core/operations/BlowfishEncrypt.mjs create mode 100644 src/core/vendor/Blowfish.mjs diff --git a/package-lock.json b/package-lock.json index 35b473b3..730e6b1f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,7 +12,7 @@ "requires": { "@webassemblyjs/helper-wasm-bytecode": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "debug": "3.1.0", + "debug": "^3.1.0", "webassemblyjs": "1.4.3" }, "dependencies": { @@ -39,7 +39,7 @@ "integrity": "sha512-e8+KZHh+RV8MUvoSRtuT1sFXskFnWG9vbDy47Oa166xX+l0dD5sERJ21g5/tcH8Yo95e9IN3u7Jc3NbhnUcSkw==", "dev": true, "requires": { - "debug": "3.1.0" + "debug": "^3.1.0" }, "dependencies": { "debug": { @@ -84,7 +84,7 @@ "@webassemblyjs/helper-buffer": "1.4.3", "@webassemblyjs/helper-wasm-bytecode": "1.4.3", "@webassemblyjs/wasm-gen": "1.4.3", - "debug": "3.1.0" + "debug": "^3.1.0" }, "dependencies": { "debug": { @@ -104,7 +104,7 @@ "integrity": "sha512-4u0LJLSPzuRDWHwdqsrThYn+WqMFVqbI2ltNrHvZZkzFPO8XOZ0HFQ5eVc4jY/TNHgXcnwrHjONhPGYuuf//KQ==", "dev": true, "requires": { - "leb": "0.3.0" + "leb": "^0.3.0" } }, "@webassemblyjs/validation": { @@ -130,7 +130,7 @@ "@webassemblyjs/wasm-opt": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", "@webassemblyjs/wast-printer": "1.4.3", - "debug": "3.1.0" + "debug": "^3.1.0" }, "dependencies": { "debug": { @@ -165,7 +165,7 @@ "@webassemblyjs/helper-buffer": "1.4.3", "@webassemblyjs/wasm-gen": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", - "debug": "3.1.0" + "debug": "^3.1.0" }, "dependencies": { "debug": { @@ -202,7 +202,7 @@ "@webassemblyjs/floating-point-hex-parser": "1.4.3", "@webassemblyjs/helper-code-frame": "1.4.3", "@webassemblyjs/helper-fsm": "1.4.3", - "long": "3.2.0", + "long": "^3.2.0", "webassemblyjs": "1.4.3" } }, @@ -214,7 +214,7 @@ "requires": { "@webassemblyjs/ast": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "long": "3.2.0" + "long": "^3.2.0" } }, "JSONSelect": { @@ -240,7 +240,7 @@ "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", "dev": true, "requires": { - "mime-types": "2.1.18", + "mime-types": "~2.1.18", "negotiator": "0.6.1" } }, @@ -250,19 +250,19 @@ "integrity": "sha512-HLvH8e5g312urx6ZRo+nxSHjhVHEcuUxbpjFaFQ1LZOtN19L0CSb5ppwxtxy0QZ05zYAcWmXH6lVurdb+mGuUw==", "dev": true, "requires": { - "axios": "0.18.0", - "bluebird": "3.5.1", - "chalk": "2.4.1", - "commander": "2.15.1", - "glob": "7.1.2", - "html_codesniffer": "2.2.0", - "jsdom": "11.10.0", - "mkdirp": "0.5.1", - "phantomjs-prebuilt": "2.1.16", - "rc": "1.2.7", - "underscore": "1.9.0", - "unixify": "1.0.0", - "validator": "9.4.1" + "axios": "^0.18.0", + "bluebird": "^3.5.1", + "chalk": "^2.3.1", + "commander": "^2.14.1", + "glob": "^7.1.2", + "html_codesniffer": "^2.1.1", + "jsdom": "^11.6.2", + "mkdirp": "^0.5.1", + "phantomjs-prebuilt": "^2.1.16", + "rc": "^1.2.5", + "underscore": "^1.8.3", + "unixify": "^1.0.0", + "validator": "^9.4.1" }, "dependencies": { "ansi-styles": { @@ -271,7 +271,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -280,9 +280,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -297,7 +297,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } }, "underscore": { @@ -320,7 +320,7 @@ "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", "dev": true, "requires": { - "acorn": "5.5.3" + "acorn": "^5.0.0" } }, "acorn-globals": { @@ -329,7 +329,7 @@ "integrity": "sha512-KjZwU26uG3u6eZcfGbTULzFcsoz6pegNKtHPksZPOUsiKo5bUmiBPa38FuHZ/Eun+XYh/JCCkS9AS3Lu4McQOQ==", "dev": true, "requires": { - "acorn": "5.5.3" + "acorn": "^5.0.0" } }, "acorn-jsx": { @@ -338,7 +338,7 @@ "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=", "dev": true, "requires": { - "acorn": "3.3.0" + "acorn": "^3.0.4" }, "dependencies": { "acorn": { @@ -355,10 +355,10 @@ "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", "dev": true, "requires": { - "co": "4.6.0", - "fast-deep-equal": "1.1.0", - "fast-json-stable-stringify": "2.0.0", - "json-schema-traverse": "0.3.1" + "co": "^4.6.0", + "fast-deep-equal": "^1.0.0", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0" } }, "ajv-keywords": { @@ -406,8 +406,8 @@ "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", "dev": true, "requires": { - "micromatch": "3.1.10", - "normalize-path": "2.1.1" + "micromatch": "^3.1.4", + "normalize-path": "^2.1.1" } }, "aproba": { @@ -422,7 +422,7 @@ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", "dev": true, "requires": { - "sprintf-js": "1.0.3" + "sprintf-js": "~1.0.2" } }, "arr-diff": { @@ -473,8 +473,8 @@ "integrity": "sha1-GEtI9i2S10UrsxsyMWXH+L0CJm0=", "dev": true, "requires": { - "define-properties": "1.1.2", - "es-abstract": "1.11.0" + "define-properties": "^1.1.2", + "es-abstract": "^1.7.0" } }, "array-union": { @@ -483,7 +483,7 @@ "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", "dev": true, "requires": { - "array-uniq": "1.0.3" + "array-uniq": "^1.0.1" } }, "array-uniq": { @@ -523,9 +523,9 @@ "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", "dev": true, "requires": { - "bn.js": "4.11.8", - "inherits": "2.0.3", - "minimalistic-assert": "1.0.1" + "bn.js": "^4.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" } }, "assert": { @@ -555,7 +555,7 @@ "integrity": "sha512-xAfGg1/NTLBBKlHFmnd7PlmUW9KhVQIUuSrYem9xzFUZy13ScvtyGGejaae9iAVRiRq9+Cx7DPFaAAhCpyxyPw==", "dev": true, "requires": { - "lodash": "4.17.10" + "lodash": "^4.14.0" } }, "async-each": { @@ -588,12 +588,12 @@ "integrity": "sha1-Hb0cg1ZY41zj+ZhAmdsAWFx4IBQ=", "dev": true, "requires": { - "browserslist": "1.7.7", - "caniuse-db": "1.0.30000843", - "normalize-range": "0.1.2", - "num2fraction": "1.2.2", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "browserslist": "^1.7.6", + "caniuse-db": "^1.0.30000634", + "normalize-range": "^0.1.2", + "num2fraction": "^1.2.2", + "postcss": "^5.2.16", + "postcss-value-parser": "^3.2.3" }, "dependencies": { "browserslist": { @@ -602,8 +602,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "1.0.30000843", - "electron-to-chromium": "1.3.47" + "caniuse-db": "^1.0.30000639", + "electron-to-chromium": "^1.2.7" } } } @@ -626,8 +626,8 @@ "integrity": "sha1-MtU+SFHv3AoRmTts0AB4nXDAUQI=", "dev": true, "requires": { - "follow-redirects": "1.4.1", - "is-buffer": "1.1.6" + "follow-redirects": "^1.3.0", + "is-buffer": "^1.1.5" } }, "babel-code-frame": { @@ -635,9 +635,9 @@ "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", "requires": { - "chalk": "1.1.3", - "esutils": "2.0.2", - "js-tokens": "3.0.2" + "chalk": "^1.1.3", + "esutils": "^2.0.2", + "js-tokens": "^3.0.2" } }, "babel-core": { @@ -646,25 +646,25 @@ "integrity": "sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==", "dev": true, "requires": { - "babel-code-frame": "6.26.0", - "babel-generator": "6.26.1", - "babel-helpers": "6.24.1", - "babel-messages": "6.23.0", - "babel-register": "6.26.0", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0", - "babylon": "6.18.0", - "convert-source-map": "1.5.1", - "debug": "2.6.9", - "json5": "0.5.1", - "lodash": "4.17.10", - "minimatch": "3.0.4", - "path-is-absolute": "1.0.1", - "private": "0.1.8", - "slash": "1.0.0", - "source-map": "0.5.7" + "babel-code-frame": "^6.26.0", + "babel-generator": "^6.26.0", + "babel-helpers": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-register": "^6.26.0", + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "convert-source-map": "^1.5.1", + "debug": "^2.6.9", + "json5": "^0.5.1", + "lodash": "^4.17.4", + "minimatch": "^3.0.4", + "path-is-absolute": "^1.0.1", + "private": "^0.1.8", + "slash": "^1.0.0", + "source-map": "^0.5.7" }, "dependencies": { "source-map": { @@ -681,14 +681,14 @@ "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==", "dev": true, "requires": { - "babel-messages": "6.23.0", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0", - "detect-indent": "4.0.0", - "jsesc": "1.3.0", - "lodash": "4.17.10", - "source-map": "0.5.7", - "trim-right": "1.0.1" + "babel-messages": "^6.23.0", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "detect-indent": "^4.0.0", + "jsesc": "^1.3.0", + "lodash": "^4.17.4", + "source-map": "^0.5.7", + "trim-right": "^1.0.1" }, "dependencies": { "jsesc": { @@ -711,9 +711,9 @@ "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=", "dev": true, "requires": { - "babel-helper-explode-assignable-expression": "6.24.1", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-explode-assignable-expression": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-helper-call-delegate": { @@ -722,10 +722,10 @@ "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", "dev": true, "requires": { - "babel-helper-hoist-variables": "6.24.1", - "babel-runtime": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-hoist-variables": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-helper-define-map": { @@ -734,10 +734,10 @@ "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", "dev": true, "requires": { - "babel-helper-function-name": "6.24.1", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0", - "lodash": "4.17.10" + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" } }, "babel-helper-explode-assignable-expression": { @@ -746,9 +746,9 @@ "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-helper-function-name": { @@ -757,11 +757,11 @@ "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", "dev": true, "requires": { - "babel-helper-get-function-arity": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-get-function-arity": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-helper-get-function-arity": { @@ -770,8 +770,8 @@ "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-helper-hoist-variables": { @@ -780,8 +780,8 @@ "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-helper-optimise-call-expression": { @@ -790,8 +790,8 @@ "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-helper-regex": { @@ -800,9 +800,9 @@ "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0", - "lodash": "4.17.10" + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" } }, "babel-helper-remap-async-to-generator": { @@ -811,11 +811,11 @@ "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=", "dev": true, "requires": { - "babel-helper-function-name": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-helper-replace-supers": { @@ -824,12 +824,12 @@ "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", "dev": true, "requires": { - "babel-helper-optimise-call-expression": "6.24.1", - "babel-messages": "6.23.0", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-optimise-call-expression": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-helpers": { @@ -838,8 +838,8 @@ "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" } }, "babel-loader": { @@ -848,9 +848,9 @@ "integrity": "sha512-/hbyEvPzBJuGpk9o80R0ZyTej6heEOr59GoEUtn8qFKbnx4cJm9FWES6J/iv644sYgrtVw9JJQkjaLW/bqb5gw==", "dev": true, "requires": { - "find-cache-dir": "1.0.0", - "loader-utils": "1.1.0", - "mkdirp": "0.5.1" + "find-cache-dir": "^1.0.0", + "loader-utils": "^1.0.2", + "mkdirp": "^0.5.1" } }, "babel-messages": { @@ -858,7 +858,7 @@ "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-check-es2015-constants": { @@ -867,7 +867,7 @@ "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-syntax-async-functions": { @@ -894,9 +894,9 @@ "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=", "dev": true, "requires": { - "babel-helper-remap-async-to-generator": "6.24.1", - "babel-plugin-syntax-async-functions": "6.13.0", - "babel-runtime": "6.26.0" + "babel-helper-remap-async-to-generator": "^6.24.1", + "babel-plugin-syntax-async-functions": "^6.8.0", + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-builtin-extend": { @@ -904,8 +904,8 @@ "resolved": "https://registry.npmjs.org/babel-plugin-transform-builtin-extend/-/babel-plugin-transform-builtin-extend-1.1.2.tgz", "integrity": "sha1-Xpb+z1i4+h7XTvytiEdbKvPJEW4=", "requires": { - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-runtime": "^6.2.0", + "babel-template": "^6.3.0" } }, "babel-plugin-transform-es2015-arrow-functions": { @@ -914,7 +914,7 @@ "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-block-scoped-functions": { @@ -923,7 +923,7 @@ "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-block-scoping": { @@ -932,11 +932,11 @@ "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0", - "lodash": "4.17.10" + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" } }, "babel-plugin-transform-es2015-classes": { @@ -945,15 +945,15 @@ "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", "dev": true, "requires": { - "babel-helper-define-map": "6.26.0", - "babel-helper-function-name": "6.24.1", - "babel-helper-optimise-call-expression": "6.24.1", - "babel-helper-replace-supers": "6.24.1", - "babel-messages": "6.23.0", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-define-map": "^6.24.1", + "babel-helper-function-name": "^6.24.1", + "babel-helper-optimise-call-expression": "^6.24.1", + "babel-helper-replace-supers": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-computed-properties": { @@ -962,8 +962,8 @@ "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" } }, "babel-plugin-transform-es2015-destructuring": { @@ -972,7 +972,7 @@ "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-duplicate-keys": { @@ -981,8 +981,8 @@ "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-for-of": { @@ -991,7 +991,7 @@ "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-function-name": { @@ -1000,9 +1000,9 @@ "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", "dev": true, "requires": { - "babel-helper-function-name": "6.24.1", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-literals": { @@ -1011,7 +1011,7 @@ "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-modules-amd": { @@ -1020,9 +1020,9 @@ "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", "dev": true, "requires": { - "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" } }, "babel-plugin-transform-es2015-modules-commonjs": { @@ -1031,10 +1031,10 @@ "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==", "dev": true, "requires": { - "babel-plugin-transform-strict-mode": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-types": "6.26.0" + "babel-plugin-transform-strict-mode": "^6.24.1", + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-types": "^6.26.0" } }, "babel-plugin-transform-es2015-modules-systemjs": { @@ -1043,9 +1043,9 @@ "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", "dev": true, "requires": { - "babel-helper-hoist-variables": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-helper-hoist-variables": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" } }, "babel-plugin-transform-es2015-modules-umd": { @@ -1054,9 +1054,9 @@ "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", "dev": true, "requires": { - "babel-plugin-transform-es2015-modules-amd": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0" + "babel-plugin-transform-es2015-modules-amd": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" } }, "babel-plugin-transform-es2015-object-super": { @@ -1065,8 +1065,8 @@ "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", "dev": true, "requires": { - "babel-helper-replace-supers": "6.24.1", - "babel-runtime": "6.26.0" + "babel-helper-replace-supers": "^6.24.1", + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-parameters": { @@ -1075,12 +1075,12 @@ "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", "dev": true, "requires": { - "babel-helper-call-delegate": "6.24.1", - "babel-helper-get-function-arity": "6.24.1", - "babel-runtime": "6.26.0", - "babel-template": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-call-delegate": "^6.24.1", + "babel-helper-get-function-arity": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-shorthand-properties": { @@ -1089,8 +1089,8 @@ "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-spread": { @@ -1099,7 +1099,7 @@ "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-sticky-regex": { @@ -1108,9 +1108,9 @@ "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", "dev": true, "requires": { - "babel-helper-regex": "6.26.0", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-helper-regex": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-plugin-transform-es2015-template-literals": { @@ -1119,7 +1119,7 @@ "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-typeof-symbol": { @@ -1128,7 +1128,7 @@ "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", "dev": true, "requires": { - "babel-runtime": "6.26.0" + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-es2015-unicode-regex": { @@ -1137,9 +1137,9 @@ "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", "dev": true, "requires": { - "babel-helper-regex": "6.26.0", - "babel-runtime": "6.26.0", - "regexpu-core": "2.0.0" + "babel-helper-regex": "^6.24.1", + "babel-runtime": "^6.22.0", + "regexpu-core": "^2.0.0" } }, "babel-plugin-transform-exponentiation-operator": { @@ -1148,9 +1148,9 @@ "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=", "dev": true, "requires": { - "babel-helper-builder-binary-assignment-operator-visitor": "6.24.1", - "babel-plugin-syntax-exponentiation-operator": "6.13.0", - "babel-runtime": "6.26.0" + "babel-helper-builder-binary-assignment-operator-visitor": "^6.24.1", + "babel-plugin-syntax-exponentiation-operator": "^6.8.0", + "babel-runtime": "^6.22.0" } }, "babel-plugin-transform-regenerator": { @@ -1159,7 +1159,7 @@ "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", "dev": true, "requires": { - "regenerator-transform": "0.10.1" + "regenerator-transform": "^0.10.0" } }, "babel-plugin-transform-strict-mode": { @@ -1168,8 +1168,8 @@ "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0" + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" } }, "babel-polyfill": { @@ -1177,9 +1177,9 @@ "resolved": "https://registry.npmjs.org/babel-polyfill/-/babel-polyfill-6.26.0.tgz", "integrity": "sha1-N5k3q8Z9eJWXCtxiHyhM2WbPIVM=", "requires": { - "babel-runtime": "6.26.0", - "core-js": "2.5.6", - "regenerator-runtime": "0.10.5" + "babel-runtime": "^6.26.0", + "core-js": "^2.5.0", + "regenerator-runtime": "^0.10.5" }, "dependencies": { "regenerator-runtime": { @@ -1195,36 +1195,36 @@ "integrity": "sha512-9OR2afuKDneX2/q2EurSftUYM0xGu4O2D9adAhVfADDhrYDaxXV0rBbevVYoY9n6nyX1PmQW/0jtpJvUNr9CHg==", "dev": true, "requires": { - "babel-plugin-check-es2015-constants": "6.22.0", - "babel-plugin-syntax-trailing-function-commas": "6.22.0", - "babel-plugin-transform-async-to-generator": "6.24.1", - "babel-plugin-transform-es2015-arrow-functions": "6.22.0", - "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0", - "babel-plugin-transform-es2015-block-scoping": "6.26.0", - "babel-plugin-transform-es2015-classes": "6.24.1", - "babel-plugin-transform-es2015-computed-properties": "6.24.1", - "babel-plugin-transform-es2015-destructuring": "6.23.0", - "babel-plugin-transform-es2015-duplicate-keys": "6.24.1", - "babel-plugin-transform-es2015-for-of": "6.23.0", - "babel-plugin-transform-es2015-function-name": "6.24.1", - "babel-plugin-transform-es2015-literals": "6.22.0", - "babel-plugin-transform-es2015-modules-amd": "6.24.1", - "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", - "babel-plugin-transform-es2015-modules-systemjs": "6.24.1", - "babel-plugin-transform-es2015-modules-umd": "6.24.1", - "babel-plugin-transform-es2015-object-super": "6.24.1", - "babel-plugin-transform-es2015-parameters": "6.24.1", - "babel-plugin-transform-es2015-shorthand-properties": "6.24.1", - "babel-plugin-transform-es2015-spread": "6.22.0", - "babel-plugin-transform-es2015-sticky-regex": "6.24.1", - "babel-plugin-transform-es2015-template-literals": "6.22.0", - "babel-plugin-transform-es2015-typeof-symbol": "6.23.0", - "babel-plugin-transform-es2015-unicode-regex": "6.24.1", - "babel-plugin-transform-exponentiation-operator": "6.24.1", - "babel-plugin-transform-regenerator": "6.26.0", - "browserslist": "3.2.7", - "invariant": "2.2.4", - "semver": "5.5.0" + "babel-plugin-check-es2015-constants": "^6.22.0", + "babel-plugin-syntax-trailing-function-commas": "^6.22.0", + "babel-plugin-transform-async-to-generator": "^6.22.0", + "babel-plugin-transform-es2015-arrow-functions": "^6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0", + "babel-plugin-transform-es2015-block-scoping": "^6.23.0", + "babel-plugin-transform-es2015-classes": "^6.23.0", + "babel-plugin-transform-es2015-computed-properties": "^6.22.0", + "babel-plugin-transform-es2015-destructuring": "^6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "^6.22.0", + "babel-plugin-transform-es2015-for-of": "^6.23.0", + "babel-plugin-transform-es2015-function-name": "^6.22.0", + "babel-plugin-transform-es2015-literals": "^6.22.0", + "babel-plugin-transform-es2015-modules-amd": "^6.22.0", + "babel-plugin-transform-es2015-modules-commonjs": "^6.23.0", + "babel-plugin-transform-es2015-modules-systemjs": "^6.23.0", + "babel-plugin-transform-es2015-modules-umd": "^6.23.0", + "babel-plugin-transform-es2015-object-super": "^6.22.0", + "babel-plugin-transform-es2015-parameters": "^6.23.0", + "babel-plugin-transform-es2015-shorthand-properties": "^6.22.0", + "babel-plugin-transform-es2015-spread": "^6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "^6.22.0", + "babel-plugin-transform-es2015-template-literals": "^6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "^6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "^6.22.0", + "babel-plugin-transform-exponentiation-operator": "^6.22.0", + "babel-plugin-transform-regenerator": "^6.22.0", + "browserslist": "^3.2.6", + "invariant": "^2.2.2", + "semver": "^5.3.0" } }, "babel-register": { @@ -1233,13 +1233,13 @@ "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", "dev": true, "requires": { - "babel-core": "6.26.3", - "babel-runtime": "6.26.0", - "core-js": "2.5.6", - "home-or-tmp": "2.0.0", - "lodash": "4.17.10", - "mkdirp": "0.5.1", - "source-map-support": "0.4.18" + "babel-core": "^6.26.0", + "babel-runtime": "^6.26.0", + "core-js": "^2.5.0", + "home-or-tmp": "^2.0.0", + "lodash": "^4.17.4", + "mkdirp": "^0.5.1", + "source-map-support": "^0.4.15" } }, "babel-runtime": { @@ -1247,8 +1247,8 @@ "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", "requires": { - "core-js": "2.5.6", - "regenerator-runtime": "0.11.1" + "core-js": "^2.4.0", + "regenerator-runtime": "^0.11.0" } }, "babel-template": { @@ -1256,11 +1256,11 @@ "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", "requires": { - "babel-runtime": "6.26.0", - "babel-traverse": "6.26.0", - "babel-types": "6.26.0", - "babylon": "6.18.0", - "lodash": "4.17.10" + "babel-runtime": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "lodash": "^4.17.4" } }, "babel-traverse": { @@ -1268,15 +1268,15 @@ "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", "requires": { - "babel-code-frame": "6.26.0", - "babel-messages": "6.23.0", - "babel-runtime": "6.26.0", - "babel-types": "6.26.0", - "babylon": "6.18.0", - "debug": "2.6.9", - "globals": "9.18.0", - "invariant": "2.2.4", - "lodash": "4.17.10" + "babel-code-frame": "^6.26.0", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "debug": "^2.6.8", + "globals": "^9.18.0", + "invariant": "^2.2.2", + "lodash": "^4.17.4" } }, "babel-types": { @@ -1284,10 +1284,10 @@ "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", "requires": { - "babel-runtime": "6.26.0", - "esutils": "2.0.2", - "lodash": "4.17.10", - "to-fast-properties": "1.0.3" + "babel-runtime": "^6.26.0", + "esutils": "^2.0.2", + "lodash": "^4.17.4", + "to-fast-properties": "^1.0.3" } }, "babylon": { @@ -1307,13 +1307,13 @@ "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", "dev": true, "requires": { - "cache-base": "1.0.1", - "class-utils": "0.3.6", - "component-emitter": "1.2.1", - "define-property": "1.0.0", - "isobject": "3.0.1", - "mixin-deep": "1.3.1", - "pascalcase": "0.1.1" + "cache-base": "^1.0.1", + "class-utils": "^0.3.5", + "component-emitter": "^1.2.1", + "define-property": "^1.0.0", + "isobject": "^3.0.1", + "mixin-deep": "^1.2.0", + "pascalcase": "^0.1.1" }, "dependencies": { "define-property": { @@ -1322,7 +1322,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "1.0.2" + "is-descriptor": "^1.0.0" } }, "is-accessor-descriptor": { @@ -1331,7 +1331,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-data-descriptor": { @@ -1340,7 +1340,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-descriptor": { @@ -1349,9 +1349,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "1.0.0", - "is-data-descriptor": "1.0.0", - "kind-of": "6.0.2" + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" } } } @@ -1375,7 +1375,7 @@ "dev": true, "optional": true, "requires": { - "tweetnacl": "0.14.5" + "tweetnacl": "^0.14.3" }, "dependencies": { "tweetnacl": { @@ -1432,10 +1432,10 @@ "integrity": "sha1-5LoM5BCkaTYyM2dgnstOZVMSUGk=", "dev": true, "requires": { - "continuable-cache": "0.3.1", - "error": "7.0.2", - "raw-body": "1.1.7", - "safe-json-parse": "1.0.1" + "continuable-cache": "^0.3.1", + "error": "^7.0.0", + "raw-body": "~1.1.0", + "safe-json-parse": "~1.0.1" } }, "body-parser": { @@ -1445,15 +1445,15 @@ "dev": true, "requires": { "bytes": "3.0.0", - "content-type": "1.0.4", + "content-type": "~1.0.4", "debug": "2.6.9", - "depd": "1.1.2", - "http-errors": "1.6.3", + "depd": "~1.1.1", + "http-errors": "~1.6.2", "iconv-lite": "0.4.19", - "on-finished": "2.3.0", + "on-finished": "~2.3.0", "qs": "6.5.1", "raw-body": "2.3.2", - "type-is": "1.6.16" + "type-is": "~1.6.15" }, "dependencies": { "bytes": { @@ -1501,7 +1501,7 @@ "depd": "1.1.1", "inherits": "2.0.3", "setprototypeof": "1.0.3", - "statuses": "1.4.0" + "statuses": ">= 1.3.1 < 2" } } } @@ -1520,12 +1520,12 @@ "integrity": "sha1-jokKGD2O6aI5OzhExpGkK897yfU=", "dev": true, "requires": { - "array-flatten": "2.1.1", - "deep-equal": "1.0.1", - "dns-equal": "1.0.0", - "dns-txt": "2.0.2", - "multicast-dns": "6.2.3", - "multicast-dns-service-types": "1.1.0" + "array-flatten": "^2.1.0", + "deep-equal": "^1.0.1", + "dns-equal": "^1.0.0", + "dns-txt": "^2.0.2", + "multicast-dns": "^6.0.1", + "multicast-dns-service-types": "^1.1.0" } }, "boolbase": { @@ -1540,7 +1540,7 @@ "integrity": "sha1-T4owBctKfjiJ90kDD9JbluAdLjE=", "dev": true, "requires": { - "hoek": "4.2.1" + "hoek": "4.x.x" } }, "bootstrap": { @@ -1553,7 +1553,7 @@ "resolved": "https://registry.npmjs.org/bootstrap-colorpicker/-/bootstrap-colorpicker-2.5.2.tgz", "integrity": "sha512-krzBno9AMUwI2+IDwMvjnpqpa2f8womW0CCKmEcxGzVkolCFrt22jjMjzx1NZqB8C1DUdNgZP4LfyCsgpHRiYA==", "requires": { - "jquery": "3.3.1" + "jquery": ">=1.10" } }, "bootstrap-switch": { @@ -1567,7 +1567,7 @@ "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dev": true, "requires": { - "balanced-match": "1.0.0", + "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, @@ -1577,16 +1577,16 @@ "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", "dev": true, "requires": { - "arr-flatten": "1.1.0", - "array-unique": "0.3.2", - "extend-shallow": "2.0.1", - "fill-range": "4.0.0", - "isobject": "3.0.1", - "repeat-element": "1.1.2", - "snapdragon": "0.8.2", - "snapdragon-node": "2.1.1", - "split-string": "3.1.0", - "to-regex": "3.0.2" + "arr-flatten": "^1.1.0", + "array-unique": "^0.3.2", + "extend-shallow": "^2.0.1", + "fill-range": "^4.0.0", + "isobject": "^3.0.1", + "repeat-element": "^1.1.2", + "snapdragon": "^0.8.1", + "snapdragon-node": "^2.0.1", + "split-string": "^3.0.2", + "to-regex": "^3.0.1" }, "dependencies": { "extend-shallow": { @@ -1595,7 +1595,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } } } @@ -1618,12 +1618,12 @@ "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", "dev": true, "requires": { - "buffer-xor": "1.0.3", - "cipher-base": "1.0.4", - "create-hash": "1.2.0", - "evp_bytestokey": "1.0.3", - "inherits": "2.0.3", - "safe-buffer": "5.1.2" + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" } }, "browserify-cipher": { @@ -1632,9 +1632,9 @@ "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", "dev": true, "requires": { - "browserify-aes": "1.2.0", - "browserify-des": "1.0.1", - "evp_bytestokey": "1.0.3" + "browserify-aes": "^1.0.4", + "browserify-des": "^1.0.0", + "evp_bytestokey": "^1.0.0" } }, "browserify-des": { @@ -1643,9 +1643,9 @@ "integrity": "sha512-zy0Cobe3hhgpiOM32Tj7KQ3Vl91m0njwsjzZQK1L+JDf11dzP9qIvjreVinsvXrgfjhStXwUWAEpB9D7Gwmayw==", "dev": true, "requires": { - "cipher-base": "1.0.4", - "des.js": "1.0.0", - "inherits": "2.0.3" + "cipher-base": "^1.0.1", + "des.js": "^1.0.0", + "inherits": "^2.0.1" } }, "browserify-rsa": { @@ -1654,8 +1654,8 @@ "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", "dev": true, "requires": { - "bn.js": "4.11.8", - "randombytes": "2.0.6" + "bn.js": "^4.1.0", + "randombytes": "^2.0.1" } }, "browserify-sign": { @@ -1664,13 +1664,13 @@ "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", "dev": true, "requires": { - "bn.js": "4.11.8", - "browserify-rsa": "4.0.1", - "create-hash": "1.2.0", - "create-hmac": "1.1.7", - "elliptic": "6.4.0", - "inherits": "2.0.3", - "parse-asn1": "5.1.1" + "bn.js": "^4.1.1", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.2", + "elliptic": "^6.0.0", + "inherits": "^2.0.1", + "parse-asn1": "^5.0.0" } }, "browserify-zlib": { @@ -1679,7 +1679,7 @@ "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", "dev": true, "requires": { - "pako": "1.0.6" + "pako": "~1.0.5" } }, "browserslist": { @@ -1688,8 +1688,8 @@ "integrity": "sha512-oYVLxFVqpX9uMhOIQBLtZL+CX4uY8ZpWcjNTaxyWl5rO8yA9SSNikFnAfvk8J3P/7z3BZwNmEqFKaJoYltj3MQ==", "dev": true, "requires": { - "caniuse-lite": "1.0.30000843", - "electron-to-chromium": "1.3.47" + "caniuse-lite": "^1.0.30000835", + "electron-to-chromium": "^1.3.45" } }, "bson": { @@ -1703,9 +1703,9 @@ "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", "dev": true, "requires": { - "base64-js": "1.3.0", - "ieee754": "1.1.11", - "isarray": "1.0.0" + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" } }, "buffer-from": { @@ -1755,19 +1755,19 @@ "integrity": "sha512-Dph0MzuH+rTQzGPNT9fAnrPmMmjKfST6trxJeK7NQuHRaVw24VzPRWTmg9MpcwOVQZO0E1FBICUlFeNaKPIfHA==", "dev": true, "requires": { - "bluebird": "3.5.1", - "chownr": "1.0.1", - "glob": "7.1.2", - "graceful-fs": "4.1.11", - "lru-cache": "4.1.3", - "mississippi": "2.0.0", - "mkdirp": "0.5.1", - "move-concurrently": "1.0.1", - "promise-inflight": "1.0.1", - "rimraf": "2.6.2", - "ssri": "5.3.0", - "unique-filename": "1.1.0", - "y18n": "4.0.0" + "bluebird": "^3.5.1", + "chownr": "^1.0.1", + "glob": "^7.1.2", + "graceful-fs": "^4.1.11", + "lru-cache": "^4.1.1", + "mississippi": "^2.0.0", + "mkdirp": "^0.5.1", + "move-concurrently": "^1.0.1", + "promise-inflight": "^1.0.1", + "rimraf": "^2.6.2", + "ssri": "^5.2.4", + "unique-filename": "^1.1.0", + "y18n": "^4.0.0" } }, "cache-base": { @@ -1776,15 +1776,15 @@ "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", "dev": true, "requires": { - "collection-visit": "1.0.0", - "component-emitter": "1.2.1", - "get-value": "2.0.6", - "has-value": "1.0.0", - "isobject": "3.0.1", - "set-value": "2.0.0", - "to-object-path": "0.3.0", - "union-value": "1.0.0", - "unset-value": "1.0.0" + "collection-visit": "^1.0.0", + "component-emitter": "^1.2.1", + "get-value": "^2.0.6", + "has-value": "^1.0.0", + "isobject": "^3.0.1", + "set-value": "^2.0.0", + "to-object-path": "^0.3.0", + "union-value": "^1.0.0", + "unset-value": "^1.0.0" } }, "caller-path": { @@ -1793,7 +1793,7 @@ "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", "dev": true, "requires": { - "callsites": "0.2.0" + "callsites": "^0.2.0" } }, "callsites": { @@ -1808,8 +1808,8 @@ "integrity": "sha1-yjw2iKTpzzpM2nd9xNy8cTJJz3M=", "dev": true, "requires": { - "no-case": "2.3.2", - "upper-case": "1.1.3" + "no-case": "^2.2.0", + "upper-case": "^1.1.1" } }, "camelcase": { @@ -1824,8 +1824,8 @@ "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", "dev": true, "requires": { - "camelcase": "2.1.1", - "map-obj": "1.0.1" + "camelcase": "^2.0.0", + "map-obj": "^1.0.0" } }, "caniuse-api": { @@ -1834,10 +1834,10 @@ "integrity": "sha1-tTTnxzTE+B7F++isoq0kNUuWLGw=", "dev": true, "requires": { - "browserslist": "1.7.7", - "caniuse-db": "1.0.30000843", - "lodash.memoize": "4.1.2", - "lodash.uniq": "4.5.0" + "browserslist": "^1.3.6", + "caniuse-db": "^1.0.30000529", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" }, "dependencies": { "browserslist": { @@ -1846,8 +1846,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "1.0.30000843", - "electron-to-chromium": "1.3.47" + "caniuse-db": "^1.0.30000639", + "electron-to-chromium": "^1.2.7" } } } @@ -1876,7 +1876,7 @@ "integrity": "sha1-mMyJDKZS3S7w5ws3klMQ/56Q/Is=", "dev": true, "requires": { - "underscore-contrib": "0.3.0" + "underscore-contrib": "~0.3.0" } }, "chalk": { @@ -1884,11 +1884,11 @@ "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", "requires": { - "ansi-styles": "2.2.1", - "escape-string-regexp": "1.0.5", - "has-ansi": "2.0.0", - "strip-ansi": "3.0.1", - "supports-color": "2.0.0" + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" } }, "chardet": { @@ -1902,7 +1902,7 @@ "resolved": "https://registry.npmjs.org/chi-squared/-/chi-squared-1.1.0.tgz", "integrity": "sha1-iShlz/qOCnIPkhv8nGNcGawqNG0=", "requires": { - "gamma": "1.0.0" + "gamma": "^1.0.0" } }, "chokidar": { @@ -1911,18 +1911,18 @@ "integrity": "sha512-zW8iXYZtXMx4kux/nuZVXjkLP+CyIK5Al5FHnj1OgTKGZfp4Oy6/ymtMSKFv3GD8DviEmUPmJg9eFdJ/JzudMg==", "dev": true, "requires": { - "anymatch": "2.0.0", - "async-each": "1.0.1", - "braces": "2.3.2", - "fsevents": "1.2.4", - "glob-parent": "3.1.0", - "inherits": "2.0.3", - "is-binary-path": "1.0.1", - "is-glob": "4.0.0", - "normalize-path": "2.1.1", - "path-is-absolute": "1.0.1", - "readdirp": "2.1.0", - "upath": "1.1.0" + "anymatch": "^2.0.0", + "async-each": "^1.0.0", + "braces": "^2.3.0", + "fsevents": "^1.1.2", + "glob-parent": "^3.1.0", + "inherits": "^2.0.1", + "is-binary-path": "^1.0.0", + "is-glob": "^4.0.0", + "normalize-path": "^2.1.1", + "path-is-absolute": "^1.0.0", + "readdirp": "^2.0.0", + "upath": "^1.0.0" } }, "chownr": { @@ -1943,8 +1943,8 @@ "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", "dev": true, "requires": { - "inherits": "2.0.3", - "safe-buffer": "5.1.2" + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" } }, "circular-json": { @@ -1964,7 +1964,7 @@ "integrity": "sha512-4CoL/A3hf90V3VIEjeuhSvlGFEHKzOz+Wfc2IVZc+FaUgU0ZQafJTP49fvnULipOPcAfqhyI2duwQyns6xqjYA==", "dev": true, "requires": { - "chalk": "1.1.3" + "chalk": "^1.1.3" } }, "class-utils": { @@ -1973,10 +1973,10 @@ "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", "dev": true, "requires": { - "arr-union": "3.1.0", - "define-property": "0.2.5", - "isobject": "3.0.1", - "static-extend": "0.1.2" + "arr-union": "^3.1.0", + "define-property": "^0.2.5", + "isobject": "^3.0.0", + "static-extend": "^0.1.1" }, "dependencies": { "define-property": { @@ -1985,7 +1985,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "0.1.6" + "is-descriptor": "^0.1.0" } } } @@ -1996,7 +1996,7 @@ "integrity": "sha1-Ls3xRaujj1R0DybO/Q/z4D4SXWo=", "dev": true, "requires": { - "source-map": "0.5.7" + "source-map": "0.5.x" }, "dependencies": { "source-map": { @@ -2014,7 +2014,7 @@ "dev": true, "requires": { "exit": "0.1.2", - "glob": "7.1.2" + "glob": "^7.1.1" } }, "cli-cursor": { @@ -2023,7 +2023,7 @@ "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", "dev": true, "requires": { - "restore-cursor": "2.0.0" + "restore-cursor": "^2.0.0" } }, "cli-width": { @@ -2038,9 +2038,9 @@ "integrity": "sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==", "dev": true, "requires": { - "string-width": "2.1.1", - "strip-ansi": "4.0.0", - "wrap-ansi": "2.1.0" + "string-width": "^2.1.1", + "strip-ansi": "^4.0.0", + "wrap-ansi": "^2.0.0" }, "dependencies": { "ansi-regex": { @@ -2055,7 +2055,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "3.0.0" + "ansi-regex": "^3.0.0" } } } @@ -2078,7 +2078,7 @@ "integrity": "sha1-qe8VNmDWqGqL3sAomlxoTSF0Mv0=", "dev": true, "requires": { - "q": "1.5.1" + "q": "^1.1.2" } }, "code-point-at": { @@ -2099,8 +2099,8 @@ "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", "dev": true, "requires": { - "map-visit": "1.0.0", - "object-visit": "1.0.1" + "map-visit": "^1.0.0", + "object-visit": "^1.0.0" } }, "color": { @@ -2109,9 +2109,9 @@ "integrity": "sha1-bXtcdPtl6EHNSHkq0e1eB7kE12Q=", "dev": true, "requires": { - "clone": "1.0.4", - "color-convert": "1.9.1", - "color-string": "0.3.0" + "clone": "^1.0.2", + "color-convert": "^1.3.0", + "color-string": "^0.3.0" } }, "color-convert": { @@ -2120,7 +2120,7 @@ "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==", "dev": true, "requires": { - "color-name": "1.1.3" + "color-name": "^1.1.1" } }, "color-name": { @@ -2135,7 +2135,7 @@ "integrity": "sha1-J9RvtnAlxcL6JZk7+/V55HhBuZE=", "dev": true, "requires": { - "color-name": "1.1.3" + "color-name": "^1.0.0" } }, "colormin": { @@ -2144,9 +2144,9 @@ "integrity": "sha1-6i90IKcrlogaOKrlnsEkpvcpgTM=", "dev": true, "requires": { - "color": "0.11.4", + "color": "^0.11.0", "css-color-names": "0.0.4", - "has": "1.0.1" + "has": "^1.0.1" } }, "colors": { @@ -2160,7 +2160,7 @@ "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", "dev": true, "requires": { - "delayed-stream": "1.0.0" + "delayed-stream": "~1.0.0" } }, "commander": { @@ -2187,22 +2187,22 @@ "integrity": "sha1-DRAgq5JLL9tNYnmHXH1tq6a6p6k=", "dev": true, "requires": { - "mime-db": "1.33.0" + "mime-db": ">= 1.33.0 < 2" } }, "compression": { "version": "1.7.2", - "resolved": "http://registry.npmjs.org/compression/-/compression-1.7.2.tgz", + "resolved": "https://registry.npmjs.org/compression/-/compression-1.7.2.tgz", "integrity": "sha1-qv+81qr4VLROuygDU9WtFlH1mmk=", "dev": true, "requires": { - "accepts": "1.3.5", + "accepts": "~1.3.4", "bytes": "3.0.0", - "compressible": "2.0.13", + "compressible": "~2.0.13", "debug": "2.6.9", - "on-headers": "1.0.1", + "on-headers": "~1.0.1", "safe-buffer": "5.1.1", - "vary": "1.1.2" + "vary": "~1.1.2" }, "dependencies": { "bytes": { @@ -2231,10 +2231,10 @@ "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", "dev": true, "requires": { - "buffer-from": "1.0.0", - "inherits": "2.0.3", - "readable-stream": "2.3.6", - "typedarray": "0.0.6" + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" } }, "connect-history-api-fallback": { @@ -2249,7 +2249,7 @@ "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", "dev": true, "requires": { - "date-now": "0.1.4" + "date-now": "^0.1.4" } }, "constants-browserify": { @@ -2300,12 +2300,12 @@ "integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==", "dev": true, "requires": { - "aproba": "1.2.0", - "fs-write-stream-atomic": "1.0.10", - "iferr": "0.1.5", - "mkdirp": "0.5.1", - "rimraf": "2.6.2", - "run-queue": "1.0.3" + "aproba": "^1.1.1", + "fs-write-stream-atomic": "^1.0.8", + "iferr": "^0.1.5", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.4", + "run-queue": "^1.0.0" } }, "copy-descriptor": { @@ -2331,13 +2331,13 @@ "integrity": "sha512-GiNXLwAFPYHy25XmTPpafYvn3CLAkJ8FLsscq78MQd1Kh0OU6Yzhn4eV2MVF4G9WEQZoWEGltatdR+ntGPMl5A==", "dev": true, "requires": { - "is-directory": "0.3.1", - "js-yaml": "3.7.0", - "minimist": "1.2.0", - "object-assign": "4.1.1", - "os-homedir": "1.0.2", - "parse-json": "2.2.0", - "require-from-string": "1.2.1" + "is-directory": "^0.3.1", + "js-yaml": "^3.4.3", + "minimist": "^1.2.0", + "object-assign": "^4.1.0", + "os-homedir": "^1.0.1", + "parse-json": "^2.2.0", + "require-from-string": "^1.1.0" } }, "create-ecdh": { @@ -2346,8 +2346,8 @@ "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", "dev": true, "requires": { - "bn.js": "4.11.8", - "elliptic": "6.4.0" + "bn.js": "^4.1.0", + "elliptic": "^6.0.0" } }, "create-hash": { @@ -2356,11 +2356,11 @@ "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", "dev": true, "requires": { - "cipher-base": "1.0.4", - "inherits": "2.0.3", - "md5.js": "1.3.4", - "ripemd160": "2.0.2", - "sha.js": "2.4.11" + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" } }, "create-hmac": { @@ -2369,12 +2369,12 @@ "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", "dev": true, "requires": { - "cipher-base": "1.0.4", - "create-hash": "1.2.0", - "inherits": "2.0.3", - "ripemd160": "2.0.2", - "safe-buffer": "5.1.2", - "sha.js": "2.4.11" + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" } }, "cross-spawn": { @@ -2383,9 +2383,9 @@ "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", "dev": true, "requires": { - "lru-cache": "4.1.3", - "shebang-command": "1.2.0", - "which": "1.3.0" + "lru-cache": "^4.0.1", + "shebang-command": "^1.2.0", + "which": "^1.2.9" } }, "cryptiles": { @@ -2394,7 +2394,7 @@ "integrity": "sha1-qJ+7Ig9c4l7FboxKqKT9e1sNKf4=", "dev": true, "requires": { - "boom": "5.2.0" + "boom": "5.x.x" }, "dependencies": { "boom": { @@ -2403,7 +2403,7 @@ "integrity": "sha512-Z5BTk6ZRe4tXXQlkqftmsAUANpXmuwlsF5Oov8ThoMbQRzdGTA1ngYRW160GexgOgjsFOKJz0LYhoNi+2AMBUw==", "dev": true, "requires": { - "hoek": "4.2.1" + "hoek": "4.x.x" } } } @@ -2419,17 +2419,17 @@ "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", "dev": true, "requires": { - "browserify-cipher": "1.0.1", - "browserify-sign": "4.0.4", - "create-ecdh": "4.0.3", - "create-hash": "1.2.0", - "create-hmac": "1.1.7", - "diffie-hellman": "5.0.3", - "inherits": "2.0.3", - "pbkdf2": "3.0.16", - "public-encrypt": "4.0.2", - "randombytes": "2.0.6", - "randomfill": "1.0.4" + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" } }, "crypto-js": { @@ -2449,20 +2449,20 @@ "integrity": "sha512-wovHgjAx8ZIMGSL8pTys7edA1ClmzxHeY6n/d97gg5odgsxEgKjULPR0viqyC+FWMCL9sfqoC/QCUBo62tLvPg==", "dev": true, "requires": { - "babel-code-frame": "6.26.0", - "css-selector-tokenizer": "0.7.0", - "cssnano": "3.10.0", - "icss-utils": "2.1.0", - "loader-utils": "1.1.0", - "lodash.camelcase": "4.3.0", - "object-assign": "4.1.1", - "postcss": "5.2.18", - "postcss-modules-extract-imports": "1.2.0", - "postcss-modules-local-by-default": "1.2.0", - "postcss-modules-scope": "1.1.0", - "postcss-modules-values": "1.3.0", - "postcss-value-parser": "3.3.0", - "source-list-map": "2.0.0" + "babel-code-frame": "^6.26.0", + "css-selector-tokenizer": "^0.7.0", + "cssnano": "^3.10.0", + "icss-utils": "^2.1.0", + "loader-utils": "^1.0.2", + "lodash.camelcase": "^4.3.0", + "object-assign": "^4.1.1", + "postcss": "^5.0.6", + "postcss-modules-extract-imports": "^1.2.0", + "postcss-modules-local-by-default": "^1.2.0", + "postcss-modules-scope": "^1.1.0", + "postcss-modules-values": "^1.3.0", + "postcss-value-parser": "^3.3.0", + "source-list-map": "^2.0.0" } }, "css-select": { @@ -2471,10 +2471,10 @@ "integrity": "sha1-KzoRBTnFNV8c2NMUYj6HCxIeyFg=", "dev": true, "requires": { - "boolbase": "1.0.0", - "css-what": "2.1.0", + "boolbase": "~1.0.0", + "css-what": "2.1", "domutils": "1.5.1", - "nth-check": "1.0.1" + "nth-check": "~1.0.1" } }, "css-selector-tokenizer": { @@ -2483,9 +2483,9 @@ "integrity": "sha1-5piEdK6MlTR3v15+/s/OzNnPTIY=", "dev": true, "requires": { - "cssesc": "0.1.0", - "fastparse": "1.1.1", - "regexpu-core": "1.0.0" + "cssesc": "^0.1.0", + "fastparse": "^1.1.1", + "regexpu-core": "^1.0.0" }, "dependencies": { "regexpu-core": { @@ -2494,9 +2494,9 @@ "integrity": "sha1-hqdj9Y7k18L2sQLkdkBQ3n7ZDGs=", "dev": true, "requires": { - "regenerate": "1.4.0", - "regjsgen": "0.2.0", - "regjsparser": "0.1.5" + "regenerate": "^1.2.1", + "regjsgen": "^0.2.0", + "regjsparser": "^0.1.4" } } } @@ -2519,38 +2519,38 @@ "integrity": "sha1-Tzj2zqK5sX+gFJDyPx3GjqZcHDg=", "dev": true, "requires": { - "autoprefixer": "6.7.7", - "decamelize": "1.2.0", - "defined": "1.0.0", - "has": "1.0.1", - "object-assign": "4.1.1", - "postcss": "5.2.18", - "postcss-calc": "5.3.1", - "postcss-colormin": "2.2.2", - "postcss-convert-values": "2.6.1", - "postcss-discard-comments": "2.0.4", - "postcss-discard-duplicates": "2.1.0", - "postcss-discard-empty": "2.1.0", - "postcss-discard-overridden": "0.1.1", - "postcss-discard-unused": "2.2.3", - "postcss-filter-plugins": "2.0.2", - "postcss-merge-idents": "2.1.7", - "postcss-merge-longhand": "2.0.2", - "postcss-merge-rules": "2.1.2", - "postcss-minify-font-values": "1.0.5", - "postcss-minify-gradients": "1.0.5", - "postcss-minify-params": "1.2.2", - "postcss-minify-selectors": "2.1.1", - "postcss-normalize-charset": "1.1.1", - "postcss-normalize-url": "3.0.8", - "postcss-ordered-values": "2.2.3", - "postcss-reduce-idents": "2.4.0", - "postcss-reduce-initial": "1.0.1", - "postcss-reduce-transforms": "1.0.4", - "postcss-svgo": "2.1.6", - "postcss-unique-selectors": "2.0.2", - "postcss-value-parser": "3.3.0", - "postcss-zindex": "2.2.0" + "autoprefixer": "^6.3.1", + "decamelize": "^1.1.2", + "defined": "^1.0.0", + "has": "^1.0.1", + "object-assign": "^4.0.1", + "postcss": "^5.0.14", + "postcss-calc": "^5.2.0", + "postcss-colormin": "^2.1.8", + "postcss-convert-values": "^2.3.4", + "postcss-discard-comments": "^2.0.4", + "postcss-discard-duplicates": "^2.0.1", + "postcss-discard-empty": "^2.0.1", + "postcss-discard-overridden": "^0.1.1", + "postcss-discard-unused": "^2.2.1", + "postcss-filter-plugins": "^2.0.0", + "postcss-merge-idents": "^2.1.5", + "postcss-merge-longhand": "^2.0.1", + "postcss-merge-rules": "^2.0.3", + "postcss-minify-font-values": "^1.0.2", + "postcss-minify-gradients": "^1.0.1", + "postcss-minify-params": "^1.0.4", + "postcss-minify-selectors": "^2.0.4", + "postcss-normalize-charset": "^1.1.0", + "postcss-normalize-url": "^3.0.7", + "postcss-ordered-values": "^2.1.0", + "postcss-reduce-idents": "^2.2.2", + "postcss-reduce-initial": "^1.0.0", + "postcss-reduce-transforms": "^1.0.3", + "postcss-svgo": "^2.1.1", + "postcss-unique-selectors": "^2.0.2", + "postcss-value-parser": "^3.2.3", + "postcss-zindex": "^2.0.1" } }, "csso": { @@ -2559,8 +2559,8 @@ "integrity": "sha1-3dUsWHAz9J6Utx/FVWnyUuj/X4U=", "dev": true, "requires": { - "clap": "1.2.3", - "source-map": "0.5.7" + "clap": "^1.0.9", + "source-map": "^0.5.3" }, "dependencies": { "source-map": { @@ -2583,7 +2583,7 @@ "integrity": "sha1-VBCXI0yyUTyDzu06zdwn/yeYfVQ=", "dev": true, "requires": { - "cssom": "0.3.2" + "cssom": "0.3.x" } }, "ctph.js": { @@ -2597,7 +2597,7 @@ "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", "dev": true, "requires": { - "array-find-index": "1.0.2" + "array-find-index": "^1.0.1" } }, "cyclist": { @@ -2612,7 +2612,7 @@ "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", "dev": true, "requires": { - "es5-ext": "0.10.42" + "es5-ext": "^0.10.9" } }, "dashdash": { @@ -2621,7 +2621,7 @@ "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", "dev": true, "requires": { - "assert-plus": "1.0.0" + "assert-plus": "^1.0.0" } }, "data-urls": { @@ -2630,9 +2630,9 @@ "integrity": "sha512-ai40PPQR0Fn1lD2PPie79CibnlMN2AYiDhwFX/rZHVsxbs5kNJSjegqXIprhouGXlRdEnfybva7kqRGnB6mypA==", "dev": true, "requires": { - "abab": "1.0.4", - "whatwg-mimetype": "2.1.0", - "whatwg-url": "6.4.1" + "abab": "^1.0.4", + "whatwg-mimetype": "^2.0.0", + "whatwg-url": "^6.4.0" } }, "datauri": { @@ -2641,9 +2641,9 @@ "integrity": "sha512-0q+cTTKx7q8eDteZRIQLTFJuiIsVing17UbWTPssY4JLSMaYsk/VKpNulBDo9NSgQWcvlPrkEHW8kUO67T/7mQ==", "dev": true, "requires": { - "image-size": "0.6.2", - "mimer": "0.3.2", - "semver": "5.5.0" + "image-size": "^0.6.2", + "mimer": "^0.3.2", + "semver": "^5.5.0" }, "dependencies": { "image-size": { @@ -2666,8 +2666,8 @@ "integrity": "sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=", "dev": true, "requires": { - "get-stdin": "4.0.1", - "meow": "3.7.0" + "get-stdin": "^4.0.1", + "meow": "^3.3.0" } }, "debug": { @@ -2707,7 +2707,7 @@ "integrity": "sha512-Y9mu+rplGcNZ7veer+5rqcdI9w3aPb7/WyE/nYnsuPevaE2z5YuC2u7/Gz/hIKsa0zo8sE8gKoBimSNsO/sr+A==", "dev": true, "requires": { - "lodash.isplainobject": "4.0.6" + "lodash.isplainobject": "^4.0.6" } }, "deep-is": { @@ -2721,8 +2721,8 @@ "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", "dev": true, "requires": { - "foreach": "2.0.5", - "object-keys": "1.0.11" + "foreach": "^2.0.5", + "object-keys": "^1.0.8" } }, "define-property": { @@ -2731,8 +2731,8 @@ "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "requires": { - "is-descriptor": "1.0.2", - "isobject": "3.0.1" + "is-descriptor": "^1.0.2", + "isobject": "^3.0.1" }, "dependencies": { "is-accessor-descriptor": { @@ -2741,7 +2741,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-data-descriptor": { @@ -2750,7 +2750,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-descriptor": { @@ -2759,9 +2759,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "1.0.0", - "is-data-descriptor": "1.0.0", - "kind-of": "6.0.2" + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" } } } @@ -2778,13 +2778,13 @@ "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=", "dev": true, "requires": { - "globby": "5.0.0", - "is-path-cwd": "1.0.0", - "is-path-in-cwd": "1.0.1", - "object-assign": "4.1.1", - "pify": "2.3.0", - "pinkie-promise": "2.0.1", - "rimraf": "2.6.2" + "globby": "^5.0.0", + "is-path-cwd": "^1.0.0", + "is-path-in-cwd": "^1.0.0", + "object-assign": "^4.0.1", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0", + "rimraf": "^2.2.8" }, "dependencies": { "pify": { @@ -2813,8 +2813,8 @@ "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", "dev": true, "requires": { - "inherits": "2.0.3", - "minimalistic-assert": "1.0.1" + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" } }, "destroy": { @@ -2829,7 +2829,7 @@ "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", "dev": true, "requires": { - "repeating": "2.0.1" + "repeating": "^2.0.0" } }, "detect-node": { @@ -2849,9 +2849,9 @@ "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", "dev": true, "requires": { - "bn.js": "4.11.8", - "miller-rabin": "4.0.1", - "randombytes": "2.0.6" + "bn.js": "^4.1.0", + "miller-rabin": "^4.0.0", + "randombytes": "^2.0.0" } }, "dns-equal": { @@ -2866,8 +2866,8 @@ "integrity": "sha512-0UxfQkMhYAUaZI+xrNZOz/as5KgDU0M/fQ9b6SpkyLbk3GEswDi6PADJVaYJradtRVsRIlF1zLyOodbcTCDzUg==", "dev": true, "requires": { - "ip": "1.1.5", - "safe-buffer": "5.1.2" + "ip": "^1.1.0", + "safe-buffer": "^5.0.1" } }, "dns-txt": { @@ -2876,7 +2876,7 @@ "integrity": "sha1-uR2Ab10nGI5Ks+fRB9iBocxGQrY=", "dev": true, "requires": { - "buffer-indexof": "1.1.1" + "buffer-indexof": "^1.0.0" } }, "doctrine": { @@ -2885,7 +2885,7 @@ "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", "dev": true, "requires": { - "esutils": "2.0.2" + "esutils": "^2.0.2" } }, "dom-converter": { @@ -2894,7 +2894,7 @@ "integrity": "sha1-pF71cnuJDJv/5tfIduexnLDhfzs=", "dev": true, "requires": { - "utila": "0.3.3" + "utila": "~0.3" }, "dependencies": { "utila": { @@ -2911,8 +2911,8 @@ "integrity": "sha1-BzxpdUbOB4DOI75KKOKT5AvDDII=", "dev": true, "requires": { - "domelementtype": "1.1.3", - "entities": "1.1.1" + "domelementtype": "~1.1.1", + "entities": "~1.1.1" }, "dependencies": { "domelementtype": { @@ -2947,7 +2947,7 @@ "integrity": "sha512-raigMkn7CJNNo6Ihro1fzG7wr3fHuYVytzquZKX5n0yizGsTcYgzdIUwj1X9pK0VvjeihV+XiclP+DjwbsSKug==", "dev": true, "requires": { - "webidl-conversions": "4.0.2" + "webidl-conversions": "^4.0.2" } }, "domhandler": { @@ -2956,7 +2956,7 @@ "integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=", "dev": true, "requires": { - "domelementtype": "1.3.0" + "domelementtype": "1" } }, "domutils": { @@ -2965,8 +2965,8 @@ "integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=", "dev": true, "requires": { - "dom-serializer": "0.1.0", - "domelementtype": "1.3.0" + "dom-serializer": "0", + "domelementtype": "1" } }, "duplexify": { @@ -2975,10 +2975,10 @@ "integrity": "sha512-fO3Di4tBKJpYTFHAxTU00BcfWMY9w24r/x21a6rZRbsD/ToUgGxsMbiGRmB7uVAXeGKXD9MwiLZa5E97EVgIRQ==", "dev": true, "requires": { - "end-of-stream": "1.4.1", - "inherits": "2.0.3", - "readable-stream": "2.3.6", - "stream-shift": "1.0.0" + "end-of-stream": "^1.0.0", + "inherits": "^2.0.1", + "readable-stream": "^2.0.0", + "stream-shift": "^1.0.0" } }, "ebnf-parser": { @@ -2993,7 +2993,7 @@ "dev": true, "optional": true, "requires": { - "jsbn": "0.1.1" + "jsbn": "~0.1.0" }, "dependencies": { "jsbn": { @@ -3023,13 +3023,13 @@ "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", "dev": true, "requires": { - "bn.js": "4.11.8", - "brorand": "1.1.0", - "hash.js": "1.1.3", - "hmac-drbg": "1.0.1", - "inherits": "2.0.3", - "minimalistic-assert": "1.0.1", - "minimalistic-crypto-utils": "1.0.1" + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" } }, "emojis-list": { @@ -3050,7 +3050,7 @@ "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", "dev": true, "requires": { - "once": "1.4.0" + "once": "^1.4.0" } }, "enhanced-resolve": { @@ -3059,9 +3059,9 @@ "integrity": "sha512-jox/62b2GofV1qTUQTMPEJSDIGycS43evqYzD/KVtEb9OCoki9cnacUPxCrZa7JfPzZSYOCZhu9O9luaMxAX8g==", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "memory-fs": "0.4.1", - "tapable": "1.0.0" + "graceful-fs": "^4.1.2", + "memory-fs": "^0.4.0", + "tapable": "^1.0.0" } }, "entities": { @@ -3076,7 +3076,7 @@ "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==", "dev": true, "requires": { - "prr": "1.0.1" + "prr": "~1.0.1" } }, "error": { @@ -3085,8 +3085,8 @@ "integrity": "sha1-pfdf/02ZJhJt2sDqXcOOaJFTywI=", "dev": true, "requires": { - "string-template": "0.2.1", - "xtend": "4.0.1" + "string-template": "~0.2.1", + "xtend": "~4.0.0" } }, "error-ex": { @@ -3095,7 +3095,7 @@ "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", "dev": true, "requires": { - "is-arrayish": "0.2.1" + "is-arrayish": "^0.2.1" } }, "es-abstract": { @@ -3104,11 +3104,11 @@ "integrity": "sha512-ZnQrE/lXTTQ39ulXZ+J1DTFazV9qBy61x2bY071B+qGco8Z8q1QddsLdt/EF8Ai9hcWH72dWS0kFqXLxOxqslA==", "dev": true, "requires": { - "es-to-primitive": "1.1.1", - "function-bind": "1.1.1", - "has": "1.0.1", - "is-callable": "1.1.3", - "is-regex": "1.0.4" + "es-to-primitive": "^1.1.1", + "function-bind": "^1.1.1", + "has": "^1.0.1", + "is-callable": "^1.1.3", + "is-regex": "^1.0.4" } }, "es-to-primitive": { @@ -3117,9 +3117,9 @@ "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", "dev": true, "requires": { - "is-callable": "1.1.3", - "is-date-object": "1.0.1", - "is-symbol": "1.0.1" + "is-callable": "^1.1.1", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.1" } }, "es5-ext": { @@ -3128,9 +3128,9 @@ "integrity": "sha512-AJxO1rmPe1bDEfSR6TJ/FgMFYuTBhR5R57KW58iCkYACMyFbrkqVyzXSurYoScDGvgyMpk7uRF/lPUPPTmsRSA==", "dev": true, "requires": { - "es6-iterator": "2.0.3", - "es6-symbol": "3.1.1", - "next-tick": "1.0.0" + "es6-iterator": "~2.0.3", + "es6-symbol": "~3.1.1", + "next-tick": "1" } }, "es6-iterator": { @@ -3139,9 +3139,9 @@ "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", "dev": true, "requires": { - "d": "1.0.0", - "es5-ext": "0.10.42", - "es6-symbol": "3.1.1" + "d": "1", + "es5-ext": "^0.10.35", + "es6-symbol": "^3.1.1" } }, "es6-object-assign": { @@ -3154,8 +3154,8 @@ "resolved": "https://registry.npmjs.org/es6-polyfills/-/es6-polyfills-2.0.0.tgz", "integrity": "sha1-fzWP04jYyIjQDPyaHuqJ+XFoOTE=", "requires": { - "es6-object-assign": "1.1.0", - "es6-promise-polyfill": "1.2.0" + "es6-object-assign": "^1.0.3", + "es6-promise-polyfill": "^1.2.0" } }, "es6-promise": { @@ -3180,8 +3180,8 @@ "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", "dev": true, "requires": { - "d": "1.0.0", - "es5-ext": "0.10.42" + "d": "1", + "es5-ext": "~0.10.14" } }, "escape-html": { @@ -3200,11 +3200,11 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", "integrity": "sha512-6hTjO1NAWkHnDk3OqQ4YrCuwwmGHL9S3nPlzBOUG/R44rda3wLNrfvQ5fkSGjyhHFKM7ALPKcKGrwvCLe0lC7Q==", "requires": { - "esprima": "3.1.3", - "estraverse": "4.2.0", - "esutils": "2.0.2", - "optionator": "0.8.2", - "source-map": "0.6.1" + "esprima": "^3.1.3", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + "source-map": "~0.6.1" }, "dependencies": { "esprima": { @@ -3219,7 +3219,7 @@ "resolved": "https://registry.npmjs.org/escope/-/escope-1.0.3.tgz", "integrity": "sha1-dZ3OhJbEJI/sLQyq9BCLzz8af10=", "requires": { - "estraverse": "2.0.0" + "estraverse": "^2.0.0" }, "dependencies": { "estraverse": { @@ -3235,44 +3235,44 @@ "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==", "dev": true, "requires": { - "ajv": "5.5.2", - "babel-code-frame": "6.26.0", - "chalk": "2.4.1", - "concat-stream": "1.6.2", - "cross-spawn": "5.1.0", - "debug": "3.1.0", - "doctrine": "2.1.0", - "eslint-scope": "3.7.1", - "eslint-visitor-keys": "1.0.0", - "espree": "3.5.4", - "esquery": "1.0.1", - "esutils": "2.0.2", - "file-entry-cache": "2.0.0", - "functional-red-black-tree": "1.0.1", - "glob": "7.1.2", - "globals": "11.5.0", - "ignore": "3.3.8", - "imurmurhash": "0.1.4", - "inquirer": "3.3.0", - "is-resolvable": "1.1.0", - "js-yaml": "3.11.0", - "json-stable-stringify-without-jsonify": "1.0.1", - "levn": "0.3.0", - "lodash": "4.17.10", - "minimatch": "3.0.4", - "mkdirp": "0.5.1", - "natural-compare": "1.4.0", - "optionator": "0.8.2", - "path-is-inside": "1.0.2", - "pluralize": "7.0.0", - "progress": "2.0.0", - "regexpp": "1.1.0", - "require-uncached": "1.0.3", - "semver": "5.5.0", - "strip-ansi": "4.0.0", - "strip-json-comments": "2.0.1", + "ajv": "^5.3.0", + "babel-code-frame": "^6.22.0", + "chalk": "^2.1.0", + "concat-stream": "^1.6.0", + "cross-spawn": "^5.1.0", + "debug": "^3.1.0", + "doctrine": "^2.1.0", + "eslint-scope": "^3.7.1", + "eslint-visitor-keys": "^1.0.0", + "espree": "^3.5.4", + "esquery": "^1.0.0", + "esutils": "^2.0.2", + "file-entry-cache": "^2.0.0", + "functional-red-black-tree": "^1.0.1", + "glob": "^7.1.2", + "globals": "^11.0.1", + "ignore": "^3.3.3", + "imurmurhash": "^0.1.4", + "inquirer": "^3.0.6", + "is-resolvable": "^1.0.0", + "js-yaml": "^3.9.1", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.3.0", + "lodash": "^4.17.4", + "minimatch": "^3.0.2", + "mkdirp": "^0.5.1", + "natural-compare": "^1.4.0", + "optionator": "^0.8.2", + "path-is-inside": "^1.0.2", + "pluralize": "^7.0.0", + "progress": "^2.0.0", + "regexpp": "^1.0.1", + "require-uncached": "^1.0.3", + "semver": "^5.3.0", + "strip-ansi": "^4.0.0", + "strip-json-comments": "~2.0.1", "table": "4.0.2", - "text-table": "0.2.0" + "text-table": "~0.2.0" }, "dependencies": { "ansi-regex": { @@ -3287,7 +3287,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -3296,9 +3296,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "debug": { @@ -3328,8 +3328,8 @@ "integrity": "sha512-saJstZWv7oNeOyBh3+Dx1qWzhW0+e6/8eDzo7p5rDFqxntSztloLtuKu+Ejhtq82jsilwOIZYsCz+lIjthg1Hw==", "dev": true, "requires": { - "argparse": "1.0.10", - "esprima": "4.0.0" + "argparse": "^1.0.7", + "esprima": "^4.0.0" } }, "progress": { @@ -3344,7 +3344,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "3.0.0" + "ansi-regex": "^3.0.0" } }, "supports-color": { @@ -3353,7 +3353,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -3364,8 +3364,8 @@ "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=", "dev": true, "requires": { - "esrecurse": "4.2.1", - "estraverse": "4.2.0" + "esrecurse": "^4.1.0", + "estraverse": "^4.1.1" } }, "eslint-visitor-keys": { @@ -3379,14 +3379,14 @@ "resolved": "https://registry.npmjs.org/esmangle/-/esmangle-1.0.1.tgz", "integrity": "sha1-2bs3uPjq+/Tm1O1reqKVarvTxMI=", "requires": { - "escodegen": "1.3.3", - "escope": "1.0.3", - "esprima": "1.1.1", - "esshorten": "1.1.1", - "estraverse": "1.5.1", - "esutils": "1.0.0", - "optionator": "0.3.0", - "source-map": "0.1.43" + "escodegen": "~1.3.2", + "escope": "~1.0.1", + "esprima": "~1.1.1", + "esshorten": "~1.1.0", + "estraverse": "~1.5.0", + "esutils": "~ 1.0.0", + "optionator": "~0.3.0", + "source-map": "~0.1.33" }, "dependencies": { "escodegen": { @@ -3394,10 +3394,10 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.3.3.tgz", "integrity": "sha1-8CQBb1qI4Eb9EgBQVek5gC5sXyM=", "requires": { - "esprima": "1.1.1", - "estraverse": "1.5.1", - "esutils": "1.0.0", - "source-map": "0.1.43" + "esprima": "~1.1.1", + "estraverse": "~1.5.0", + "esutils": "~1.0.0", + "source-map": "~0.1.33" } }, "esprima": { @@ -3425,8 +3425,8 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.2.5.tgz", "integrity": "sha1-uo0znQykphDjo/FFucr0iAcVUFQ=", "requires": { - "prelude-ls": "1.1.2", - "type-check": "0.3.2" + "prelude-ls": "~1.1.0", + "type-check": "~0.3.1" } }, "optionator": { @@ -3434,12 +3434,12 @@ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.3.0.tgz", "integrity": "sha1-lxWotfXnWGz/BsgkngOc1zZNP1Q=", "requires": { - "deep-is": "0.1.3", - "fast-levenshtein": "1.0.7", - "levn": "0.2.5", - "prelude-ls": "1.1.2", - "type-check": "0.3.2", - "wordwrap": "0.0.3" + "deep-is": "~0.1.2", + "fast-levenshtein": "~1.0.0", + "levn": "~0.2.4", + "prelude-ls": "~1.1.0", + "type-check": "~0.3.1", + "wordwrap": "~0.0.2" } }, "source-map": { @@ -3447,7 +3447,7 @@ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz", "integrity": "sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=", "requires": { - "amdefine": "1.0.1" + "amdefine": ">=0.0.4" } }, "wordwrap": { @@ -3463,8 +3463,8 @@ "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==", "dev": true, "requires": { - "acorn": "5.5.3", - "acorn-jsx": "3.0.1" + "acorn": "^5.5.0", + "acorn-jsx": "^3.0.0" } }, "esprima": { @@ -3478,7 +3478,7 @@ "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", "dev": true, "requires": { - "estraverse": "4.2.0" + "estraverse": "^4.0.0" } }, "esrecurse": { @@ -3487,7 +3487,7 @@ "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", "dev": true, "requires": { - "estraverse": "4.2.0" + "estraverse": "^4.1.0" } }, "esshorten": { @@ -3495,9 +3495,9 @@ "resolved": "https://registry.npmjs.org/esshorten/-/esshorten-1.1.1.tgz", "integrity": "sha1-F0+Wt8wmfkaHLYFOfbfCkL3/Yak=", "requires": { - "escope": "1.0.3", - "estraverse": "4.1.1", - "esutils": "2.0.2" + "escope": "~1.0.1", + "estraverse": "~4.1.1", + "esutils": "~2.0.2" }, "dependencies": { "estraverse": { @@ -3547,7 +3547,7 @@ "integrity": "sha1-Cs7ehJ7X3RzMMsgRuxG5RNTykjI=", "dev": true, "requires": { - "original": "1.0.1" + "original": ">=0.0.5" } }, "evp_bytestokey": { @@ -3556,8 +3556,8 @@ "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", "dev": true, "requires": { - "md5.js": "1.3.4", - "safe-buffer": "5.1.2" + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" } }, "execa": { @@ -3566,13 +3566,13 @@ "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", "dev": true, "requires": { - "cross-spawn": "5.1.0", - "get-stream": "3.0.0", - "is-stream": "1.1.0", - "npm-run-path": "2.0.2", - "p-finally": "1.0.0", - "signal-exit": "3.0.2", - "strip-eof": "1.0.0" + "cross-spawn": "^5.0.1", + "get-stream": "^3.0.0", + "is-stream": "^1.1.0", + "npm-run-path": "^2.0.0", + "p-finally": "^1.0.0", + "signal-exit": "^3.0.0", + "strip-eof": "^1.0.0" } }, "exif-parser": { @@ -3592,13 +3592,13 @@ "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", "dev": true, "requires": { - "debug": "2.6.9", - "define-property": "0.2.5", - "extend-shallow": "2.0.1", - "posix-character-classes": "0.1.1", - "regex-not": "1.0.2", - "snapdragon": "0.8.2", - "to-regex": "3.0.2" + "debug": "^2.3.3", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "posix-character-classes": "^0.1.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" }, "dependencies": { "define-property": { @@ -3607,7 +3607,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "0.1.6" + "is-descriptor": "^0.1.0" } }, "extend-shallow": { @@ -3616,7 +3616,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } } } @@ -3627,7 +3627,7 @@ "integrity": "sha512-RKwCrO4A6IiKm0pG3c9V46JxIHcDplwwGJn6+JJ1RcVnh/WSGJa0xkmk5cRVtgOPzCAtTMGj2F7nluh9L0vpSA==", "dev": true, "requires": { - "loader-utils": "1.1.0", + "loader-utils": "^1.1.0", "source-map": "0.5.0" }, "dependencies": { @@ -3645,36 +3645,36 @@ "integrity": "sha1-avilAjUNsyRuzEvs9rWjTSL37VM=", "dev": true, "requires": { - "accepts": "1.3.5", + "accepts": "~1.3.5", "array-flatten": "1.1.1", "body-parser": "1.18.2", "content-disposition": "0.5.2", - "content-type": "1.0.4", + "content-type": "~1.0.4", "cookie": "0.3.1", "cookie-signature": "1.0.6", "debug": "2.6.9", - "depd": "1.1.2", - "encodeurl": "1.0.2", - "escape-html": "1.0.3", - "etag": "1.8.1", + "depd": "~1.1.2", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", "finalhandler": "1.1.1", "fresh": "0.5.2", "merge-descriptors": "1.0.1", - "methods": "1.1.2", - "on-finished": "2.3.0", - "parseurl": "1.3.2", + "methods": "~1.1.2", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", "path-to-regexp": "0.1.7", - "proxy-addr": "2.0.3", + "proxy-addr": "~2.0.3", "qs": "6.5.1", - "range-parser": "1.2.0", + "range-parser": "~1.2.0", "safe-buffer": "5.1.1", "send": "0.16.2", "serve-static": "1.13.2", "setprototypeof": "1.1.0", - "statuses": "1.4.0", - "type-is": "1.6.16", + "statuses": "~1.4.0", + "type-is": "~1.6.16", "utils-merge": "1.0.1", - "vary": "1.1.2" + "vary": "~1.1.2" }, "dependencies": { "array-flatten": { @@ -3709,8 +3709,8 @@ "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", "dev": true, "requires": { - "assign-symbols": "1.0.0", - "is-extendable": "1.0.1" + "assign-symbols": "^1.0.0", + "is-extendable": "^1.0.1" }, "dependencies": { "is-extendable": { @@ -3719,7 +3719,7 @@ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "requires": { - "is-plain-object": "2.0.4" + "is-plain-object": "^2.0.4" } } } @@ -3730,9 +3730,9 @@ "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==", "dev": true, "requires": { - "chardet": "0.4.2", - "iconv-lite": "0.4.23", - "tmp": "0.0.33" + "chardet": "^0.4.0", + "iconv-lite": "^0.4.17", + "tmp": "^0.0.33" } }, "extglob": { @@ -3741,14 +3741,14 @@ "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", "dev": true, "requires": { - "array-unique": "0.3.2", - "define-property": "1.0.0", - "expand-brackets": "2.1.4", - "extend-shallow": "2.0.1", - "fragment-cache": "0.2.1", - "regex-not": "1.0.2", - "snapdragon": "0.8.2", - "to-regex": "3.0.2" + "array-unique": "^0.3.2", + "define-property": "^1.0.0", + "expand-brackets": "^2.1.4", + "extend-shallow": "^2.0.1", + "fragment-cache": "^0.2.1", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" }, "dependencies": { "define-property": { @@ -3757,7 +3757,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "1.0.2" + "is-descriptor": "^1.0.0" } }, "extend-shallow": { @@ -3766,7 +3766,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } }, "is-accessor-descriptor": { @@ -3775,7 +3775,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-data-descriptor": { @@ -3784,7 +3784,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-descriptor": { @@ -3793,9 +3793,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "1.0.0", - "is-data-descriptor": "1.0.0", - "kind-of": "6.0.2" + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" } } } @@ -3806,10 +3806,10 @@ "integrity": "sha512-Hypkn9jUTnFr0DpekNam53X47tXn3ucY08BQumv7kdGgeVUBLq3DJHJTi6HNxv4jl9W+Skxjz9+RnK0sJyqqjA==", "dev": true, "requires": { - "async": "2.6.0", - "loader-utils": "1.1.0", - "schema-utils": "0.4.5", - "webpack-sources": "1.1.0" + "async": "^2.4.1", + "loader-utils": "^1.1.0", + "schema-utils": "^0.4.5", + "webpack-sources": "^1.1.0" } }, "extract-zip": { @@ -3830,9 +3830,9 @@ "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", "dev": true, "requires": { - "inherits": "2.0.3", - "readable-stream": "2.3.6", - "typedarray": "0.0.6" + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" } }, "minimist": { @@ -3887,7 +3887,7 @@ "integrity": "sha1-TkkvjQTftviQA1B/btvy1QHnxvQ=", "dev": true, "requires": { - "websocket-driver": "0.7.0" + "websocket-driver": ">=0.5.1" } }, "fd-slicer": { @@ -3896,7 +3896,7 @@ "integrity": "sha1-i1vL2ewyfFBBv5qwI/1nUPEXfmU=", "dev": true, "requires": { - "pend": "1.2.0" + "pend": "~1.2.0" } }, "figures": { @@ -3905,7 +3905,7 @@ "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", "dev": true, "requires": { - "escape-string-regexp": "1.0.5" + "escape-string-regexp": "^1.0.5" } }, "file-entry-cache": { @@ -3914,8 +3914,8 @@ "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", "dev": true, "requires": { - "flat-cache": "1.3.0", - "object-assign": "4.1.1" + "flat-cache": "^1.2.1", + "object-assign": "^4.0.1" } }, "file-loader": { @@ -3924,8 +3924,8 @@ "integrity": "sha512-TGR4HU7HUsGg6GCOPJnFk06RhWgEWFLAGWiT6rcD+GRC2keU3s9RGJ+b3Z6/U73jwwNb2gKLJ7YCrp+jvU4ALg==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "schema-utils": "0.4.5" + "loader-utils": "^1.0.2", + "schema-utils": "^0.4.5" } }, "file-saver": { @@ -3945,10 +3945,10 @@ "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", "dev": true, "requires": { - "extend-shallow": "2.0.1", - "is-number": "3.0.0", - "repeat-string": "1.6.1", - "to-regex-range": "2.1.1" + "extend-shallow": "^2.0.1", + "is-number": "^3.0.0", + "repeat-string": "^1.6.1", + "to-regex-range": "^2.1.0" }, "dependencies": { "extend-shallow": { @@ -3957,7 +3957,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } } } @@ -3969,12 +3969,12 @@ "dev": true, "requires": { "debug": "2.6.9", - "encodeurl": "1.0.2", - "escape-html": "1.0.3", - "on-finished": "2.3.0", - "parseurl": "1.3.2", - "statuses": "1.4.0", - "unpipe": "1.0.0" + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", + "statuses": "~1.4.0", + "unpipe": "~1.0.0" } }, "find-cache-dir": { @@ -3983,9 +3983,9 @@ "integrity": "sha1-kojj6ePMN0hxfTnq3hfPcfww7m8=", "dev": true, "requires": { - "commondir": "1.0.1", - "make-dir": "1.3.0", - "pkg-dir": "2.0.0" + "commondir": "^1.0.1", + "make-dir": "^1.0.0", + "pkg-dir": "^2.0.0" } }, "find-up": { @@ -3994,7 +3994,7 @@ "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", "dev": true, "requires": { - "locate-path": "2.0.0" + "locate-path": "^2.0.0" } }, "findup-sync": { @@ -4003,7 +4003,7 @@ "integrity": "sha1-N5MKpdgWt3fANEXhlmzGeQpMCxY=", "dev": true, "requires": { - "glob": "5.0.15" + "glob": "~5.0.0" }, "dependencies": { "glob": { @@ -4012,11 +4012,11 @@ "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=", "dev": true, "requires": { - "inflight": "1.0.6", - "inherits": "2.0.3", - "minimatch": "3.0.4", - "once": "1.4.0", - "path-is-absolute": "1.0.1" + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" } } } @@ -4027,10 +4027,10 @@ "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=", "dev": true, "requires": { - "circular-json": "0.3.3", - "del": "2.2.2", - "graceful-fs": "4.1.11", - "write": "0.2.1" + "circular-json": "^0.3.1", + "del": "^2.0.2", + "graceful-fs": "^4.1.2", + "write": "^0.2.1" } }, "flatten": { @@ -4045,8 +4045,8 @@ "integrity": "sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==", "dev": true, "requires": { - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "inherits": "^2.0.1", + "readable-stream": "^2.0.4" } }, "follow-redirects": { @@ -4055,7 +4055,7 @@ "integrity": "sha512-uxYePVPogtya1ktGnAAXOacnbIuRMB4dkvqeNz2qTtTQsuzSfbDolV+wMMKxAmCx0bLgAKLbBOkjItMbbkR1vg==", "dev": true, "requires": { - "debug": "3.1.0" + "debug": "^3.1.0" }, "dependencies": { "debug": { @@ -4093,9 +4093,9 @@ "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", "dev": true, "requires": { - "asynckit": "0.4.0", + "asynckit": "^0.4.0", "combined-stream": "1.0.6", - "mime-types": "2.1.18" + "mime-types": "^2.1.12" } }, "forwarded": { @@ -4110,7 +4110,7 @@ "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", "dev": true, "requires": { - "map-cache": "0.2.2" + "map-cache": "^0.2.2" } }, "fresh": { @@ -4125,8 +4125,8 @@ "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=", "dev": true, "requires": { - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "inherits": "^2.0.1", + "readable-stream": "^2.0.0" } }, "fs-extra": { @@ -4135,9 +4135,9 @@ "integrity": "sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "jsonfile": "2.4.0", - "klaw": "1.3.1" + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0", + "klaw": "^1.0.0" } }, "fs-write-stream-atomic": { @@ -4146,10 +4146,10 @@ "integrity": "sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "iferr": "0.1.5", - "imurmurhash": "0.1.4", - "readable-stream": "2.3.6" + "graceful-fs": "^4.1.2", + "iferr": "^0.1.5", + "imurmurhash": "^0.1.4", + "readable-stream": "1 || 2" } }, "fs.realpath": { @@ -4165,8 +4165,8 @@ "dev": true, "optional": true, "requires": { - "nan": "2.10.0", - "node-pre-gyp": "0.10.0" + "nan": "^2.9.2", + "node-pre-gyp": "^0.10.0" }, "dependencies": { "abbrev": { @@ -4192,8 +4192,8 @@ "dev": true, "optional": true, "requires": { - "delegates": "1.0.0", - "readable-stream": "2.3.6" + "delegates": "^1.0.0", + "readable-stream": "^2.0.6" } }, "balanced-match": { @@ -4206,7 +4206,7 @@ "bundled": true, "dev": true, "requires": { - "balanced-match": "1.0.0", + "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, @@ -4270,7 +4270,7 @@ "dev": true, "optional": true, "requires": { - "minipass": "2.2.4" + "minipass": "^2.2.1" } }, "fs.realpath": { @@ -4285,14 +4285,14 @@ "dev": true, "optional": true, "requires": { - "aproba": "1.2.0", - "console-control-strings": "1.1.0", - "has-unicode": "2.0.1", - "object-assign": "4.1.1", - "signal-exit": "3.0.2", - "string-width": "1.0.2", - "strip-ansi": "3.0.1", - "wide-align": "1.1.2" + "aproba": "^1.0.3", + "console-control-strings": "^1.0.0", + "has-unicode": "^2.0.0", + "object-assign": "^4.1.0", + "signal-exit": "^3.0.0", + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1", + "wide-align": "^1.1.0" } }, "glob": { @@ -4301,12 +4301,12 @@ "dev": true, "optional": true, "requires": { - "fs.realpath": "1.0.0", - "inflight": "1.0.6", - "inherits": "2.0.3", - "minimatch": "3.0.4", - "once": "1.4.0", - "path-is-absolute": "1.0.1" + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" } }, "has-unicode": { @@ -4321,7 +4321,7 @@ "dev": true, "optional": true, "requires": { - "safer-buffer": "2.1.2" + "safer-buffer": "^2.1.0" } }, "ignore-walk": { @@ -4330,7 +4330,7 @@ "dev": true, "optional": true, "requires": { - "minimatch": "3.0.4" + "minimatch": "^3.0.4" } }, "inflight": { @@ -4339,8 +4339,8 @@ "dev": true, "optional": true, "requires": { - "once": "1.4.0", - "wrappy": "1.0.2" + "once": "^1.3.0", + "wrappy": "1" } }, "inherits": { @@ -4359,7 +4359,7 @@ "bundled": true, "dev": true, "requires": { - "number-is-nan": "1.0.1" + "number-is-nan": "^1.0.0" } }, "isarray": { @@ -4373,7 +4373,7 @@ "bundled": true, "dev": true, "requires": { - "brace-expansion": "1.1.11" + "brace-expansion": "^1.1.7" } }, "minimist": { @@ -4386,8 +4386,8 @@ "bundled": true, "dev": true, "requires": { - "safe-buffer": "5.1.1", - "yallist": "3.0.2" + "safe-buffer": "^5.1.1", + "yallist": "^3.0.0" } }, "minizlib": { @@ -4396,7 +4396,7 @@ "dev": true, "optional": true, "requires": { - "minipass": "2.2.4" + "minipass": "^2.2.1" } }, "mkdirp": { @@ -4419,9 +4419,9 @@ "dev": true, "optional": true, "requires": { - "debug": "2.6.9", - "iconv-lite": "0.4.21", - "sax": "1.2.4" + "debug": "^2.1.2", + "iconv-lite": "^0.4.4", + "sax": "^1.2.4" } }, "node-pre-gyp": { @@ -4430,16 +4430,16 @@ "dev": true, "optional": true, "requires": { - "detect-libc": "1.0.3", - "mkdirp": "0.5.1", - "needle": "2.2.0", - "nopt": "4.0.1", - "npm-packlist": "1.1.10", - "npmlog": "4.1.2", - "rc": "1.2.7", - "rimraf": "2.6.2", - "semver": "5.5.0", - "tar": "4.4.1" + "detect-libc": "^1.0.2", + "mkdirp": "^0.5.1", + "needle": "^2.2.0", + "nopt": "^4.0.1", + "npm-packlist": "^1.1.6", + "npmlog": "^4.0.2", + "rc": "^1.1.7", + "rimraf": "^2.6.1", + "semver": "^5.3.0", + "tar": "^4" } }, "nopt": { @@ -4448,8 +4448,8 @@ "dev": true, "optional": true, "requires": { - "abbrev": "1.1.1", - "osenv": "0.1.5" + "abbrev": "1", + "osenv": "^0.1.4" } }, "npm-bundled": { @@ -4464,8 +4464,8 @@ "dev": true, "optional": true, "requires": { - "ignore-walk": "3.0.1", - "npm-bundled": "1.0.3" + "ignore-walk": "^3.0.1", + "npm-bundled": "^1.0.1" } }, "npmlog": { @@ -4474,10 +4474,10 @@ "dev": true, "optional": true, "requires": { - "are-we-there-yet": "1.1.4", - "console-control-strings": "1.1.0", - "gauge": "2.7.4", - "set-blocking": "2.0.0" + "are-we-there-yet": "~1.1.2", + "console-control-strings": "~1.1.0", + "gauge": "~2.7.3", + "set-blocking": "~2.0.0" } }, "number-is-nan": { @@ -4496,7 +4496,7 @@ "bundled": true, "dev": true, "requires": { - "wrappy": "1.0.2" + "wrappy": "1" } }, "os-homedir": { @@ -4517,8 +4517,8 @@ "dev": true, "optional": true, "requires": { - "os-homedir": "1.0.2", - "os-tmpdir": "1.0.2" + "os-homedir": "^1.0.0", + "os-tmpdir": "^1.0.0" } }, "path-is-absolute": { @@ -4539,10 +4539,10 @@ "dev": true, "optional": true, "requires": { - "deep-extend": "0.5.1", - "ini": "1.3.5", - "minimist": "1.2.0", - "strip-json-comments": "2.0.1" + "deep-extend": "^0.5.1", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" }, "dependencies": { "minimist": { @@ -4559,13 +4559,13 @@ "dev": true, "optional": true, "requires": { - "core-util-is": "1.0.2", - "inherits": "2.0.3", - "isarray": "1.0.0", - "process-nextick-args": "2.0.0", - "safe-buffer": "5.1.1", - "string_decoder": "1.1.1", - "util-deprecate": "1.0.2" + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" } }, "rimraf": { @@ -4574,7 +4574,7 @@ "dev": true, "optional": true, "requires": { - "glob": "7.1.2" + "glob": "^7.0.5" } }, "safe-buffer": { @@ -4617,9 +4617,9 @@ "bundled": true, "dev": true, "requires": { - "code-point-at": "1.1.0", - "is-fullwidth-code-point": "1.0.0", - "strip-ansi": "3.0.1" + "code-point-at": "^1.0.0", + "is-fullwidth-code-point": "^1.0.0", + "strip-ansi": "^3.0.0" } }, "string_decoder": { @@ -4628,7 +4628,7 @@ "dev": true, "optional": true, "requires": { - "safe-buffer": "5.1.1" + "safe-buffer": "~5.1.0" } }, "strip-ansi": { @@ -4636,7 +4636,7 @@ "bundled": true, "dev": true, "requires": { - "ansi-regex": "2.1.1" + "ansi-regex": "^2.0.0" } }, "strip-json-comments": { @@ -4651,13 +4651,13 @@ "dev": true, "optional": true, "requires": { - "chownr": "1.0.1", - "fs-minipass": "1.2.5", - "minipass": "2.2.4", - "minizlib": "1.1.0", - "mkdirp": "0.5.1", - "safe-buffer": "5.1.1", - "yallist": "3.0.2" + "chownr": "^1.0.1", + "fs-minipass": "^1.2.5", + "minipass": "^2.2.4", + "minizlib": "^1.1.0", + "mkdirp": "^0.5.0", + "safe-buffer": "^5.1.1", + "yallist": "^3.0.2" } }, "util-deprecate": { @@ -4672,7 +4672,7 @@ "dev": true, "optional": true, "requires": { - "string-width": "1.0.2" + "string-width": "^1.0.2" } }, "wrappy": { @@ -4710,7 +4710,7 @@ "integrity": "sha1-hHIkZ3rbiHDWeSV+0ziP22HkAQU=", "dev": true, "requires": { - "globule": "1.2.0" + "globule": "^1.0.0" } }, "get-caller-file": { @@ -4749,7 +4749,7 @@ "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", "dev": true, "requires": { - "assert-plus": "1.0.0" + "assert-plus": "^1.0.0" } }, "glob": { @@ -4758,12 +4758,12 @@ "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", "dev": true, "requires": { - "fs.realpath": "1.0.0", - "inflight": "1.0.6", - "inherits": "2.0.3", - "minimatch": "3.0.4", - "once": "1.4.0", - "path-is-absolute": "1.0.1" + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" } }, "glob-parent": { @@ -4772,8 +4772,8 @@ "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", "dev": true, "requires": { - "is-glob": "3.1.0", - "path-dirname": "1.0.2" + "is-glob": "^3.1.0", + "path-dirname": "^1.0.0" }, "dependencies": { "is-glob": { @@ -4782,7 +4782,7 @@ "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", "dev": true, "requires": { - "is-extglob": "2.1.1" + "is-extglob": "^2.1.0" } } } @@ -4798,12 +4798,12 @@ "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=", "dev": true, "requires": { - "array-union": "1.0.2", - "arrify": "1.0.1", - "glob": "7.1.2", - "object-assign": "4.1.1", - "pify": "2.3.0", - "pinkie-promise": "2.0.1" + "array-union": "^1.0.1", + "arrify": "^1.0.0", + "glob": "^7.0.3", + "object-assign": "^4.0.1", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" }, "dependencies": { "pify": { @@ -4820,9 +4820,9 @@ "integrity": "sha1-HcScaCLdnoovoAuiopUAboZkvQk=", "dev": true, "requires": { - "glob": "7.1.2", - "lodash": "4.17.10", - "minimatch": "3.0.4" + "glob": "~7.1.1", + "lodash": "~4.17.4", + "minimatch": "~3.0.2" } }, "graceful-fs": { @@ -4837,22 +4837,22 @@ "integrity": "sha1-TmpeaVtwRy/VME9fqeNCNoNqc7w=", "dev": true, "requires": { - "coffeescript": "1.10.0", - "dateformat": "1.0.12", - "eventemitter2": "0.4.14", - "exit": "0.1.2", - "findup-sync": "0.3.0", - "glob": "7.0.6", - "grunt-cli": "1.2.0", - "grunt-known-options": "1.1.0", - "grunt-legacy-log": "1.0.2", - "grunt-legacy-util": "1.0.0", - "iconv-lite": "0.4.23", - "js-yaml": "3.5.5", - "minimatch": "3.0.4", - "nopt": "3.0.6", - "path-is-absolute": "1.0.1", - "rimraf": "2.2.8" + "coffeescript": "~1.10.0", + "dateformat": "~1.0.12", + "eventemitter2": "~0.4.13", + "exit": "~0.1.1", + "findup-sync": "~0.3.0", + "glob": "~7.0.0", + "grunt-cli": "~1.2.0", + "grunt-known-options": "~1.1.0", + "grunt-legacy-log": "~1.0.0", + "grunt-legacy-util": "~1.0.0", + "iconv-lite": "~0.4.13", + "js-yaml": "~3.5.2", + "minimatch": "~3.0.2", + "nopt": "~3.0.6", + "path-is-absolute": "~1.0.0", + "rimraf": "~2.2.8" }, "dependencies": { "esprima": { @@ -4867,12 +4867,12 @@ "integrity": "sha1-IRuvr0nlJbjNkyYNFKsTYVKz9Xo=", "dev": true, "requires": { - "fs.realpath": "1.0.0", - "inflight": "1.0.6", - "inherits": "2.0.3", - "minimatch": "3.0.4", - "once": "1.4.0", - "path-is-absolute": "1.0.1" + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.2", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" } }, "grunt-cli": { @@ -4881,10 +4881,10 @@ "integrity": "sha1-VisRnrsGndtGSs4oRVAb6Xs1tqg=", "dev": true, "requires": { - "findup-sync": "0.3.0", - "grunt-known-options": "1.1.0", - "nopt": "3.0.6", - "resolve": "1.1.7" + "findup-sync": "~0.3.0", + "grunt-known-options": "~1.1.0", + "nopt": "~3.0.6", + "resolve": "~1.1.0" } }, "js-yaml": { @@ -4893,8 +4893,8 @@ "integrity": "sha1-A3fDgBfKvHMisNH7zSWkkWQfL74=", "dev": true, "requires": { - "argparse": "1.0.10", - "esprima": "2.7.3" + "argparse": "^1.0.2", + "esprima": "^2.6.0" } }, "rimraf": { @@ -4911,7 +4911,7 @@ "integrity": "sha512-5Y7MMYzpzMICkspvmUOU+YC/VE5eiB5TV8k9u43ZFrzLIoYDulKce8KX0fyi2EXYEDKlUEyaVI/W4rLDqqy3/Q==", "dev": true, "requires": { - "access-sniff": "3.2.0" + "access-sniff": "^3.2.0" } }, "grunt-chmod": { @@ -4920,7 +4920,7 @@ "integrity": "sha1-0YZcWoTn7Zrv5Qn/v1KQ+XoleEA=", "dev": true, "requires": { - "shelljs": "0.5.3" + "shelljs": "^0.5.3" }, "dependencies": { "shelljs": { @@ -4937,10 +4937,10 @@ "integrity": "sha1-Hj2zjM71o9oRleYdYx/n4yE0TSM=", "dev": true, "requires": { - "arrify": "1.0.1", - "async": "1.5.2", - "indent-string": "2.1.0", - "pad-stream": "1.2.0" + "arrify": "^1.0.1", + "async": "^1.2.1", + "indent-string": "^2.0.0", + "pad-stream": "^1.0.0" }, "dependencies": { "async": { @@ -4957,8 +4957,8 @@ "integrity": "sha1-Vkq/LQN4qYOhW54/MO51tzjEBjg=", "dev": true, "requires": { - "async": "1.5.2", - "rimraf": "2.6.2" + "async": "^1.5.2", + "rimraf": "^2.5.1" }, "dependencies": { "async": { @@ -4975,8 +4975,8 @@ "integrity": "sha1-cGDGWB6QS4qw0A8HbgqPbj58NXM=", "dev": true, "requires": { - "chalk": "1.1.3", - "file-sync-cmp": "0.1.1" + "chalk": "^1.1.1", + "file-sync-cmp": "^0.1.0" } }, "grunt-contrib-jshint": { @@ -4985,9 +4985,9 @@ "integrity": "sha1-Np2QmyWTxA6L55lAshNAhQx5Oaw=", "dev": true, "requires": { - "chalk": "1.1.3", - "hooker": "0.2.3", - "jshint": "2.9.5" + "chalk": "^1.1.1", + "hooker": "^0.2.3", + "jshint": "~2.9.4" } }, "grunt-contrib-watch": { @@ -4996,10 +4996,10 @@ "integrity": "sha512-yGweN+0DW5yM+oo58fRu/XIRrPcn3r4tQx+nL7eMRwjpvk+rQY6R8o94BPK0i2UhTg9FN21hS+m8vR8v9vXfeg==", "dev": true, "requires": { - "async": "2.6.0", - "gaze": "1.1.2", - "lodash": "4.17.10", - "tiny-lr": "1.1.1" + "async": "^2.6.0", + "gaze": "^1.1.0", + "lodash": "^4.17.10", + "tiny-lr": "^1.1.1" } }, "grunt-eslint": { @@ -5008,8 +5008,8 @@ "integrity": "sha512-VZlDOLrB2KKefDDcx/wR8rEEz7smDwDKVblmooa+itdt/2jWw3ee2AiZB5Ap4s4AoRY0pbHRjZ3HHwY8uKR9Rw==", "dev": true, "requires": { - "chalk": "2.4.1", - "eslint": "4.19.1" + "chalk": "^2.1.0", + "eslint": "^4.0.0" }, "dependencies": { "ansi-styles": { @@ -5018,7 +5018,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -5027,9 +5027,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -5044,7 +5044,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -5061,9 +5061,9 @@ "integrity": "sha512-33QZYBYjv2Ph3H2ygqXHn/o0ttfptw1f9QciOTgvzhzUeiPrnvzMNUApTPtw22T6zgReE5FZ1RR58U2wnK/l+w==", "dev": true, "requires": { - "cross-spawn": "3.0.1", - "jsdoc": "3.5.5", - "marked": "0.3.19" + "cross-spawn": "^3.0.1", + "jsdoc": "~3.5.5", + "marked": "^0.3.9" }, "dependencies": { "cross-spawn": { @@ -5072,8 +5072,8 @@ "integrity": "sha1-ElYDfsufDF9549bvE14wdwGEuYI=", "dev": true, "requires": { - "lru-cache": "4.1.3", - "which": "1.3.0" + "lru-cache": "^4.0.1", + "which": "^1.2.9" } } } @@ -5090,10 +5090,10 @@ "integrity": "sha512-WdedTJ/6zCXnI/coaouzqvkI19uwqbcPkdsXiDRKJyB5rOUlOxnCnTVbpeUdEckKVir2uHF3rDBYppj2p6N3+g==", "dev": true, "requires": { - "colors": "1.1.2", - "grunt-legacy-log-utils": "1.0.0", - "hooker": "0.2.3", - "lodash": "4.17.10" + "colors": "~1.1.2", + "grunt-legacy-log-utils": "~1.0.0", + "hooker": "~0.2.3", + "lodash": "~4.17.5" }, "dependencies": { "colors": { @@ -5110,8 +5110,8 @@ "integrity": "sha1-p7ji0Ps1taUPSvmG/BEnSevJbz0=", "dev": true, "requires": { - "chalk": "1.1.3", - "lodash": "4.3.0" + "chalk": "~1.1.1", + "lodash": "~4.3.0" }, "dependencies": { "lodash": { @@ -5128,13 +5128,13 @@ "integrity": "sha1-OGqnjcbtUJhsKxiVcmWxtIq7m4Y=", "dev": true, "requires": { - "async": "1.5.2", - "exit": "0.1.2", - "getobject": "0.1.0", - "hooker": "0.2.3", - "lodash": "4.3.0", - "underscore.string": "3.2.3", - "which": "1.2.14" + "async": "~1.5.2", + "exit": "~0.1.1", + "getobject": "~0.1.0", + "hooker": "~0.2.3", + "lodash": "~4.3.0", + "underscore.string": "~3.2.3", + "which": "~1.2.1" }, "dependencies": { "async": { @@ -5155,7 +5155,7 @@ "integrity": "sha1-mofEN48D6CfOyvGs31bHNsAcFOU=", "dev": true, "requires": { - "isexe": "2.0.0" + "isexe": "^2.0.0" } } } @@ -5166,8 +5166,8 @@ "integrity": "sha512-Ngixl4W/mNJYyghyXJ+JzJ7pUaVRcVKgvC+74ePXPglAEodc9jMlBrGszZAzmspCuvo5dkhbBIcuBHn+Wv1pOQ==", "dev": true, "requires": { - "deep-for-each": "2.0.3", - "lodash": "4.17.10" + "deep-for-each": "^2.0.2", + "lodash": "^4.7.0" } }, "handle-thing": { @@ -5188,8 +5188,8 @@ "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", "dev": true, "requires": { - "ajv": "5.5.2", - "har-schema": "2.0.0" + "ajv": "^5.1.0", + "har-schema": "^2.0.0" } }, "has": { @@ -5198,7 +5198,7 @@ "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=", "dev": true, "requires": { - "function-bind": "1.1.1" + "function-bind": "^1.0.2" } }, "has-ansi": { @@ -5206,7 +5206,7 @@ "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", "requires": { - "ansi-regex": "2.1.1" + "ansi-regex": "^2.0.0" } }, "has-flag": { @@ -5227,9 +5227,9 @@ "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", "dev": true, "requires": { - "get-value": "2.0.6", - "has-values": "1.0.0", - "isobject": "3.0.1" + "get-value": "^2.0.6", + "has-values": "^1.0.0", + "isobject": "^3.0.0" } }, "has-values": { @@ -5238,8 +5238,8 @@ "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", "dev": true, "requires": { - "is-number": "3.0.0", - "kind-of": "4.0.0" + "is-number": "^3.0.0", + "kind-of": "^4.0.0" }, "dependencies": { "kind-of": { @@ -5248,7 +5248,7 @@ "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -5259,8 +5259,8 @@ "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", "dev": true, "requires": { - "inherits": "2.0.3", - "safe-buffer": "5.1.2" + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" } }, "hash.js": { @@ -5269,8 +5269,8 @@ "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", "dev": true, "requires": { - "inherits": "2.0.3", - "minimalistic-assert": "1.0.1" + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.0" } }, "hasha": { @@ -5279,8 +5279,8 @@ "integrity": "sha1-eNfL/B5tZjA/55g3NlmEUXsvbuE=", "dev": true, "requires": { - "is-stream": "1.1.0", - "pinkie-promise": "2.0.1" + "is-stream": "^1.0.1", + "pinkie-promise": "^2.0.0" } }, "hawk": { @@ -5289,10 +5289,10 @@ "integrity": "sha512-miowhl2+U7Qle4vdLqDdPt9m09K6yZhkLDTWGoUiUzrQCn+mHHSmfJgAyGaLRZbPmTqfFFjRV1QWCW0VWUJBbQ==", "dev": true, "requires": { - "boom": "4.3.1", - "cryptiles": "3.1.2", - "hoek": "4.2.1", - "sntp": "2.1.0" + "boom": "4.x.x", + "cryptiles": "3.x.x", + "hoek": "4.x.x", + "sntp": "2.x.x" } }, "he": { @@ -5312,9 +5312,9 @@ "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", "dev": true, "requires": { - "hash.js": "1.1.3", - "minimalistic-assert": "1.0.1", - "minimalistic-crypto-utils": "1.0.1" + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" } }, "hoek": { @@ -5329,8 +5329,8 @@ "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", "dev": true, "requires": { - "os-homedir": "1.0.2", - "os-tmpdir": "1.0.2" + "os-homedir": "^1.0.0", + "os-tmpdir": "^1.0.1" } }, "hooker": { @@ -5351,10 +5351,10 @@ "integrity": "sha1-h3dMCUnlE/QuhFdbPEVoH63ioLI=", "dev": true, "requires": { - "inherits": "2.0.3", - "obuf": "1.1.2", - "readable-stream": "2.3.6", - "wbuf": "1.7.3" + "inherits": "^2.0.1", + "obuf": "^1.0.0", + "readable-stream": "^2.0.1", + "wbuf": "^1.1.0" } }, "html-comment-regex": { @@ -5369,7 +5369,7 @@ "integrity": "sha512-71lZziiDnsuabfdYiUeWdCVyKuqwWi23L8YeIgV9jSSZHCtb6wB1BKWooH7L3tn4/FuZJMVWyNaIDr4RGmaSYw==", "dev": true, "requires": { - "whatwg-encoding": "1.0.3" + "whatwg-encoding": "^1.0.1" } }, "html-entities": { @@ -5384,13 +5384,13 @@ "integrity": "sha512-OZa4rfb6tZOZ3Z8Xf0jKxXkiDcFWldQePGYFDcgKqES2sXeWaEv9y6QQvWUtX3ySI3feApQi5uCsHLINQ6NoAw==", "dev": true, "requires": { - "camel-case": "3.0.0", - "clean-css": "4.1.11", - "commander": "2.15.1", - "he": "1.1.1", - "param-case": "2.1.1", - "relateurl": "0.2.7", - "uglify-js": "3.3.25" + "camel-case": "3.0.x", + "clean-css": "4.1.x", + "commander": "2.15.x", + "he": "1.1.x", + "param-case": "2.1.x", + "relateurl": "0.2.x", + "uglify-js": "3.3.x" } }, "html-webpack-plugin": { @@ -5399,12 +5399,12 @@ "integrity": "sha1-sBq71yOsqqeze2r0SS69oD2d03s=", "dev": true, "requires": { - "html-minifier": "3.5.15", - "loader-utils": "0.2.17", - "lodash": "4.17.10", - "pretty-error": "2.1.1", - "tapable": "1.0.0", - "toposort": "1.0.7", + "html-minifier": "^3.2.3", + "loader-utils": "^0.2.16", + "lodash": "^4.17.3", + "pretty-error": "^2.0.2", + "tapable": "^1.0.0", + "toposort": "^1.0.0", "util.promisify": "1.0.0" }, "dependencies": { @@ -5414,10 +5414,10 @@ "integrity": "sha1-+G5jdNQyBabmxg6RlvF8Apm/s0g=", "dev": true, "requires": { - "big.js": "3.2.0", - "emojis-list": "2.1.0", - "json5": "0.5.1", - "object-assign": "4.1.1" + "big.js": "^3.1.3", + "emojis-list": "^2.0.0", + "json5": "^0.5.0", + "object-assign": "^4.0.1" } } } @@ -5428,11 +5428,11 @@ "integrity": "sha512-xG6E3g2V/huu/WwRcrX3AFRmAUFkU7PWlgF/QFLtuRitI+NxvJcYTFthb24rB7/mhKE3khSIxB11A8IQTJ2N9w==", "dev": true, "requires": { - "grunt": "1.0.2", - "grunt-contrib-copy": "1.0.0", - "grunt-contrib-jshint": "1.1.0", - "grunt-contrib-watch": "1.1.0", - "load-grunt-tasks": "3.5.2" + "grunt": "^1.0.0", + "grunt-contrib-copy": "^1.0.0", + "grunt-contrib-jshint": "^1.0.0", + "grunt-contrib-watch": "^1.0.0", + "load-grunt-tasks": "^3.5.2" } }, "htmlparser2": { @@ -5441,11 +5441,11 @@ "integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=", "dev": true, "requires": { - "domelementtype": "1.3.0", - "domhandler": "2.3.0", - "domutils": "1.5.1", - "entities": "1.0.0", - "readable-stream": "1.1.14" + "domelementtype": "1", + "domhandler": "2.3", + "domutils": "1.5", + "entities": "1.0", + "readable-stream": "1.1" }, "dependencies": { "isarray": { @@ -5460,10 +5460,10 @@ "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", "dev": true, "requires": { - "core-util-is": "1.0.2", - "inherits": "2.0.3", + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", "isarray": "0.0.1", - "string_decoder": "0.10.31" + "string_decoder": "~0.10.x" } }, "string_decoder": { @@ -5486,10 +5486,10 @@ "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", "dev": true, "requires": { - "depd": "1.1.2", + "depd": "~1.1.2", "inherits": "2.0.3", "setprototypeof": "1.1.0", - "statuses": "1.4.0" + "statuses": ">= 1.4.0 < 2" } }, "http-parser-js": { @@ -5504,9 +5504,9 @@ "integrity": "sha512-Taqn+3nNvYRfJ3bGvKfBSRwy1v6eePlm3oc/aWVxZp57DQr5Eq3xhKJi7Z4hZpS8PC3H4qI+Yly5EmFacGuA/g==", "dev": true, "requires": { - "eventemitter3": "3.1.0", - "follow-redirects": "1.4.1", - "requires-port": "1.0.0" + "eventemitter3": "^3.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" } }, "http-proxy-middleware": { @@ -5515,10 +5515,10 @@ "integrity": "sha512-Fs25KVMPAIIcgjMZkVHJoKg9VcXcC1C8yb9JUgeDvVXY0S/zgVIhMb+qVswDIgtJe2DfckMSY2d6TuTEutlk6Q==", "dev": true, "requires": { - "http-proxy": "1.17.0", - "is-glob": "4.0.0", - "lodash": "4.17.10", - "micromatch": "3.1.10" + "http-proxy": "^1.16.2", + "is-glob": "^4.0.0", + "lodash": "^4.17.5", + "micromatch": "^3.1.9" } }, "http-signature": { @@ -5527,9 +5527,9 @@ "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", "dev": true, "requires": { - "assert-plus": "1.0.0", - "jsprim": "1.4.1", - "sshpk": "1.14.1" + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" } }, "https-browserify": { @@ -5548,7 +5548,7 @@ "resolved": "https://registry.npmjs.org/iced-lock/-/iced-lock-1.1.0.tgz", "integrity": "sha1-YRbvHKs6zW5rEIk7snumIv0/3nI=", "requires": { - "iced-runtime": "1.0.3" + "iced-runtime": "^1.0.0" } }, "iced-runtime": { @@ -5562,7 +5562,7 @@ "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", "dev": true, "requires": { - "safer-buffer": "2.1.2" + "safer-buffer": ">= 2.1.2 < 3" } }, "icss-replace-symbols": { @@ -5577,7 +5577,7 @@ "integrity": "sha1-g/Cg7DeL8yRheLbCrZE28TWxyWI=", "dev": true, "requires": { - "postcss": "6.0.22" + "postcss": "^6.0.1" }, "dependencies": { "ansi-styles": { @@ -5586,7 +5586,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -5595,9 +5595,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -5612,9 +5612,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -5623,7 +5623,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -5659,8 +5659,8 @@ "integrity": "sha512-vAaZHieK9qjGo58agRBg+bhHX3hoTZU/Oa3GESWLz7t1U62fk63aHuDJJEteXoDeTCcPmUT+z38gkHPZkkmpmQ==", "dev": true, "requires": { - "pkg-dir": "2.0.0", - "resolve-cwd": "2.0.0" + "pkg-dir": "^2.0.0", + "resolve-cwd": "^2.0.0" } }, "imports-loader": { @@ -5669,8 +5669,8 @@ "integrity": "sha512-kXWL7Scp8KQ4552ZcdVTeaQCZSLW+e6nJfp3cwUMB673T7Hr98Xjx5JK+ql7ADlJUvj1JS5O01RLbKoutN5QDQ==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "source-map": "0.6.1" + "loader-utils": "^1.0.2", + "source-map": "^0.6.1" } }, "imurmurhash": { @@ -5685,7 +5685,7 @@ "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=", "dev": true, "requires": { - "repeating": "2.0.1" + "repeating": "^2.0.0" } }, "indexes-of": { @@ -5706,8 +5706,8 @@ "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", "dev": true, "requires": { - "once": "1.4.0", - "wrappy": "1.0.2" + "once": "^1.3.0", + "wrappy": "1" } }, "inherits": { @@ -5728,8 +5728,8 @@ "integrity": "sha512-STx5orGQU1gfrkoI/fMU7lX6CSP7LBGO10gXNgOZhwKhUqbtNjCkYSewJtNnLmWP1tAGN6oyEpG1HFPw5vpa5Q==", "dev": true, "requires": { - "moment": "2.22.1", - "sanitize-html": "1.18.2" + "moment": "^2.14.1", + "sanitize-html": "^1.13.0" } }, "inquirer": { @@ -5738,20 +5738,20 @@ "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", "dev": true, "requires": { - "ansi-escapes": "3.1.0", - "chalk": "2.4.1", - "cli-cursor": "2.1.0", - "cli-width": "2.2.0", - "external-editor": "2.2.0", - "figures": "2.0.0", - "lodash": "4.17.10", + "ansi-escapes": "^3.0.0", + "chalk": "^2.0.0", + "cli-cursor": "^2.1.0", + "cli-width": "^2.0.0", + "external-editor": "^2.0.4", + "figures": "^2.0.0", + "lodash": "^4.3.0", "mute-stream": "0.0.7", - "run-async": "2.3.0", - "rx-lite": "4.0.8", - "rx-lite-aggregates": "4.0.8", - "string-width": "2.1.1", - "strip-ansi": "4.0.0", - "through": "2.3.8" + "run-async": "^2.2.0", + "rx-lite": "^4.0.8", + "rx-lite-aggregates": "^4.0.8", + "string-width": "^2.1.0", + "strip-ansi": "^4.0.0", + "through": "^2.3.6" }, "dependencies": { "ansi-regex": { @@ -5766,7 +5766,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -5775,9 +5775,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -5792,7 +5792,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "3.0.0" + "ansi-regex": "^3.0.0" } }, "supports-color": { @@ -5801,7 +5801,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -5812,7 +5812,7 @@ "integrity": "sha1-rp+/k7mEh4eF1QqN4bNWlWBYz1w=", "dev": true, "requires": { - "meow": "3.7.0" + "meow": "^3.3.0" } }, "invariant": { @@ -5820,7 +5820,7 @@ "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", "requires": { - "loose-envify": "1.3.1" + "loose-envify": "^1.0.0" } }, "invert-kv": { @@ -5853,7 +5853,7 @@ "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", "dev": true, "requires": { - "kind-of": "3.2.2" + "kind-of": "^3.0.2" }, "dependencies": { "kind-of": { @@ -5862,7 +5862,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -5879,7 +5879,7 @@ "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", "dev": true, "requires": { - "binary-extensions": "1.11.0" + "binary-extensions": "^1.0.0" } }, "is-buffer": { @@ -5894,7 +5894,7 @@ "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", "dev": true, "requires": { - "builtin-modules": "1.1.1" + "builtin-modules": "^1.0.0" } }, "is-callable": { @@ -5909,7 +5909,7 @@ "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", "dev": true, "requires": { - "kind-of": "3.2.2" + "kind-of": "^3.0.2" }, "dependencies": { "kind-of": { @@ -5918,7 +5918,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -5935,9 +5935,9 @@ "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", "dev": true, "requires": { - "is-accessor-descriptor": "0.1.6", - "is-data-descriptor": "0.1.4", - "kind-of": "5.1.0" + "is-accessor-descriptor": "^0.1.6", + "is-data-descriptor": "^0.1.4", + "kind-of": "^5.0.0" }, "dependencies": { "kind-of": { @@ -5972,7 +5972,7 @@ "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", "dev": true, "requires": { - "number-is-nan": "1.0.1" + "number-is-nan": "^1.0.0" } }, "is-fullwidth-code-point": { @@ -5987,7 +5987,7 @@ "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=", "dev": true, "requires": { - "is-extglob": "2.1.1" + "is-extglob": "^2.1.1" } }, "is-number": { @@ -5996,7 +5996,7 @@ "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", "dev": true, "requires": { - "kind-of": "3.2.2" + "kind-of": "^3.0.2" }, "dependencies": { "kind-of": { @@ -6005,7 +6005,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -6016,7 +6016,7 @@ "integrity": "sha512-OTiixgpZAT1M4NHgS5IguFp/Vz2VI3U7Goh4/HA1adtwyLtSBrxYlcSYkhpAE07s4fKEcjrFxyvtQBND4vFQyQ==", "dev": true, "requires": { - "is-number": "4.0.0" + "is-number": "^4.0.0" }, "dependencies": { "is-number": { @@ -6039,7 +6039,7 @@ "integrity": "sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==", "dev": true, "requires": { - "is-path-inside": "1.0.1" + "is-path-inside": "^1.0.0" } }, "is-path-inside": { @@ -6048,7 +6048,7 @@ "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=", "dev": true, "requires": { - "path-is-inside": "1.0.2" + "path-is-inside": "^1.0.1" } }, "is-plain-obj": { @@ -6063,7 +6063,7 @@ "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "requires": { - "isobject": "3.0.1" + "isobject": "^3.0.1" } }, "is-promise": { @@ -6078,7 +6078,7 @@ "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", "dev": true, "requires": { - "has": "1.0.1" + "has": "^1.0.1" } }, "is-resolvable": { @@ -6099,7 +6099,7 @@ "integrity": "sha1-z2EJDaDZ77yrhyLeum8DIgjbsOk=", "dev": true, "requires": { - "html-comment-regex": "1.1.1" + "html-comment-regex": "^1.1.0" } }, "is-symbol": { @@ -6162,12 +6162,12 @@ "integrity": "sha1-kEFwfWIkE2f1iDRTK58ZwsNvrHg=", "requires": { "JSONSelect": "0.4.0", - "cjson": "0.2.1", - "ebnf-parser": "0.1.10", + "cjson": "~0.2.1", + "ebnf-parser": "~0.1.9", "escodegen": "0.0.21", - "esprima": "1.0.4", - "jison-lex": "0.2.1", - "lex-parser": "0.1.4", + "esprima": "1.0.x", + "jison-lex": "0.2.x", + "lex-parser": "~0.1.3", "nomnom": "1.5.2" }, "dependencies": { @@ -6176,9 +6176,9 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-0.0.21.tgz", "integrity": "sha1-U9ZSz6EDA4gnlFilJmxf/HCcY8M=", "requires": { - "esprima": "1.0.4", - "estraverse": "0.0.4", - "source-map": "0.6.1" + "esprima": "~1.0.2", + "estraverse": "~0.0.4", + "source-map": ">= 0.1.2" } }, "esprima": { @@ -6198,7 +6198,7 @@ "resolved": "https://registry.npmjs.org/jison-lex/-/jison-lex-0.2.1.tgz", "integrity": "sha1-rEuBXozOUTLrErXfz+jXB7iETf4=", "requires": { - "lex-parser": "0.1.4", + "lex-parser": "0.1.x", "nomnom": "1.5.2" } }, @@ -6229,8 +6229,8 @@ "integrity": "sha512-5OlmInr6FuKAEAqNi0Ag8ErS8LWCp53w/vHSc6Ndm8aTckuOKI/uiil/ltP/xRrl+cSz8Q/oW7q6iglNQHCx+A==", "dev": true, "requires": { - "babylon": "6.18.0", - "chalk": "2.4.1" + "babylon": "^6.18.0", + "chalk": "^2.1.0" }, "dependencies": { "ansi-styles": { @@ -6239,7 +6239,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -6248,9 +6248,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -6265,7 +6265,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -6281,8 +6281,8 @@ "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=", "dev": true, "requires": { - "argparse": "1.0.10", - "esprima": "2.7.3" + "argparse": "^1.0.7", + "esprima": "^2.6.0" }, "dependencies": { "esprima": { @@ -6299,7 +6299,7 @@ "integrity": "sha1-P7YOqgicVED5MZ9RdgzNB+JJlzM=", "dev": true, "requires": { - "xmlcreate": "1.0.2" + "xmlcreate": "^1.0.1" } }, "jsbn": { @@ -6314,17 +6314,17 @@ "dev": true, "requires": { "babylon": "7.0.0-beta.19", - "bluebird": "3.5.1", - "catharsis": "0.8.9", - "escape-string-regexp": "1.0.5", - "js2xmlparser": "3.0.0", - "klaw": "2.0.0", - "marked": "0.3.19", - "mkdirp": "0.5.1", - "requizzle": "0.2.1", - "strip-json-comments": "2.0.1", + "bluebird": "~3.5.0", + "catharsis": "~0.8.9", + "escape-string-regexp": "~1.0.5", + "js2xmlparser": "~3.0.0", + "klaw": "~2.0.0", + "marked": "~0.3.6", + "mkdirp": "~0.5.1", + "requizzle": "~0.2.1", + "strip-json-comments": "~2.0.1", "taffydb": "2.6.2", - "underscore": "1.8.3" + "underscore": "~1.8.3" }, "dependencies": { "babylon": { @@ -6339,7 +6339,7 @@ "integrity": "sha1-WcEo4Nxc5BAgEVEZTuucv4WGUPY=", "dev": true, "requires": { - "graceful-fs": "4.1.11" + "graceful-fs": "^4.1.9" } }, "underscore": { @@ -6356,8 +6356,8 @@ "integrity": "sha512-KF3WTPvoPYc8ZyXzC1m+vvwi+2VCKkqZX/NkqcE1tFephp8RnZAxG52QB/wvz/zoDS6XU28aM8NItMPMad50PA==", "dev": true, "requires": { - "jsdoc-regex": "1.0.1", - "lodash": "4.17.10" + "jsdoc-regex": "^1.0.1", + "lodash": "^4.13.1" } }, "jsdoc-regex": { @@ -6372,32 +6372,32 @@ "integrity": "sha512-x5No5FpJgBg3j5aBwA8ka6eGuS5IxbC8FOkmyccKvObtFT0bDMict/LOxINZsZGZSfGdNomLZ/qRV9Bpq/GIBA==", "dev": true, "requires": { - "abab": "1.0.4", - "acorn": "5.5.3", - "acorn-globals": "4.1.0", - "array-equal": "1.0.0", - "cssom": "0.3.2", - "cssstyle": "0.2.37", - "data-urls": "1.0.0", - "domexception": "1.0.1", - "escodegen": "1.9.1", - "html-encoding-sniffer": "1.0.2", - "left-pad": "1.3.0", - "nwmatcher": "1.4.4", + "abab": "^1.0.4", + "acorn": "^5.3.0", + "acorn-globals": "^4.1.0", + "array-equal": "^1.0.0", + "cssom": ">= 0.3.2 < 0.4.0", + "cssstyle": ">= 0.2.37 < 0.3.0", + "data-urls": "^1.0.0", + "domexception": "^1.0.0", + "escodegen": "^1.9.0", + "html-encoding-sniffer": "^1.0.2", + "left-pad": "^1.2.0", + "nwmatcher": "^1.4.3", "parse5": "4.0.0", - "pn": "1.1.0", - "request": "2.86.0", - "request-promise-native": "1.0.5", - "sax": "1.2.4", - "symbol-tree": "3.2.2", - "tough-cookie": "2.3.4", - "w3c-hr-time": "1.0.1", - "webidl-conversions": "4.0.2", - "whatwg-encoding": "1.0.3", - "whatwg-mimetype": "2.1.0", - "whatwg-url": "6.4.1", - "ws": "4.1.0", - "xml-name-validator": "3.0.0" + "pn": "^1.1.0", + "request": "^2.83.0", + "request-promise-native": "^1.0.5", + "sax": "^1.2.4", + "symbol-tree": "^3.2.2", + "tough-cookie": "^2.3.3", + "w3c-hr-time": "^1.0.1", + "webidl-conversions": "^4.0.2", + "whatwg-encoding": "^1.0.3", + "whatwg-mimetype": "^2.1.0", + "whatwg-url": "^6.4.0", + "ws": "^4.0.0", + "xml-name-validator": "^3.0.0" } }, "jsesc": { @@ -6411,14 +6411,14 @@ "integrity": "sha1-HnJSkVzmgbQIJ+4UJIxG006apiw=", "dev": true, "requires": { - "cli": "1.0.1", - "console-browserify": "1.1.0", - "exit": "0.1.2", - "htmlparser2": "3.8.3", - "lodash": "3.7.0", - "minimatch": "3.0.4", - "shelljs": "0.3.0", - "strip-json-comments": "1.0.4" + "cli": "~1.0.0", + "console-browserify": "1.1.x", + "exit": "0.1.x", + "htmlparser2": "3.8.x", + "lodash": "3.7.x", + "minimatch": "~3.0.2", + "shelljs": "0.3.x", + "strip-json-comments": "1.0.x" }, "dependencies": { "lodash": { @@ -6477,7 +6477,7 @@ "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", "dev": true, "requires": { - "graceful-fs": "4.1.11" + "graceful-fs": "^4.1.6" } }, "jsonpath": { @@ -6520,19 +6520,19 @@ "resolved": "https://registry.npmjs.org/kbpgp/-/kbpgp-2.0.77.tgz", "integrity": "sha1-bp0vV5hb6VlsXqbJ5aODM/MasZk=", "requires": { - "bn": "1.0.1", - "bzip-deflate": "1.0.0", - "deep-equal": "1.0.1", - "iced-error": "0.0.12", - "iced-lock": "1.1.0", - "iced-runtime": "1.0.3", - "keybase-ecurve": "1.0.0", - "keybase-nacl": "1.0.10", - "minimist": "1.2.0", - "pgp-utils": "0.0.34", - "purepack": "1.0.4", - "triplesec": "3.0.26", - "tweetnacl": "0.13.3" + "bn": "^1.0.0", + "bzip-deflate": "^1.0.0", + "deep-equal": ">=0.2.1", + "iced-error": ">=0.0.10", + "iced-lock": "^1.0.2", + "iced-runtime": "^1.0.3", + "keybase-ecurve": "^1.0.0", + "keybase-nacl": "^1.0.0", + "minimist": "^1.2.0", + "pgp-utils": ">=0.0.34", + "purepack": ">=1.0.4", + "triplesec": ">=3.0.19", + "tweetnacl": "^0.13.1" } }, "kew": { @@ -6546,7 +6546,7 @@ "resolved": "https://registry.npmjs.org/keybase-ecurve/-/keybase-ecurve-1.0.0.tgz", "integrity": "sha1-xrxyrdpGA/0xhP7n6ZaU7Y/WmtI=", "requires": { - "bn": "1.0.1" + "bn": "^1.0.0" } }, "keybase-nacl": { @@ -6554,9 +6554,9 @@ "resolved": "https://registry.npmjs.org/keybase-nacl/-/keybase-nacl-1.0.10.tgz", "integrity": "sha1-OGWDHpSBUWSI33y9mJRn6VDYeos=", "requires": { - "iced-runtime": "1.0.3", - "tweetnacl": "0.13.3", - "uint64be": "1.0.1" + "iced-runtime": "^1.0.2", + "tweetnacl": "^0.13.1", + "uint64be": "^1.0.1" } }, "killable": { @@ -6577,7 +6577,7 @@ "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", "dev": true, "requires": { - "graceful-fs": "4.1.11" + "graceful-fs": "^4.1.9" } }, "lcid": { @@ -6586,7 +6586,7 @@ "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", "dev": true, "requires": { - "invert-kv": "1.0.0" + "invert-kv": "^1.0.0" } }, "leb": { @@ -6607,14 +6607,14 @@ "integrity": "sha512-q3SyEnPKbk9zh4l36PGeW2fgynKu+FpbhiUNx/yaiBUQ3V0CbACCgb9FzYWcRgI2DJlP6eI4jc8XPrCTi55YcQ==", "dev": true, "requires": { - "errno": "0.1.7", - "graceful-fs": "4.1.11", - "image-size": "0.5.5", - "mime": "1.6.0", - "mkdirp": "0.5.1", - "promise": "7.3.1", - "request": "2.86.0", - "source-map": "0.6.1" + "errno": "^0.1.1", + "graceful-fs": "^4.1.2", + "image-size": "~0.5.0", + "mime": "^1.4.1", + "mkdirp": "^0.5.0", + "promise": "^7.1.1", + "request": "^2.83.0", + "source-map": "~0.6.0" } }, "less-loader": { @@ -6623,9 +6623,9 @@ "integrity": "sha512-KNTsgCE9tMOM70+ddxp9yyt9iHqgmSs0yTZc5XH5Wo+g80RWRIYNqE58QJKm/yMud5wZEvz50ugRDuzVIkyahg==", "dev": true, "requires": { - "clone": "2.1.1", - "loader-utils": "1.1.0", - "pify": "3.0.0" + "clone": "^2.1.1", + "loader-utils": "^1.1.0", + "pify": "^3.0.0" }, "dependencies": { "clone": { @@ -6641,8 +6641,8 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", "requires": { - "prelude-ls": "1.1.2", - "type-check": "0.3.2" + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" } }, "lex-parser": { @@ -6662,10 +6662,10 @@ "integrity": "sha1-ByhWEYD9IP+KaSdQWFL8WKrqDIg=", "dev": true, "requires": { - "arrify": "1.0.1", - "multimatch": "2.1.0", - "pkg-up": "1.0.0", - "resolve-pkg": "0.1.0" + "arrify": "^1.0.0", + "multimatch": "^2.0.0", + "pkg-up": "^1.0.0", + "resolve-pkg": "^0.1.0" } }, "load-json-file": { @@ -6674,11 +6674,11 @@ "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "parse-json": "2.2.0", - "pify": "2.3.0", - "pinkie-promise": "2.0.1", - "strip-bom": "2.0.0" + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0", + "strip-bom": "^2.0.0" }, "dependencies": { "pify": { @@ -6701,9 +6701,9 @@ "integrity": "sha1-yYrvSIvM7aL/teLeZG1qdUQp9c0=", "dev": true, "requires": { - "big.js": "3.2.0", - "emojis-list": "2.1.0", - "json5": "0.5.1" + "big.js": "^3.1.3", + "emojis-list": "^2.0.0", + "json5": "^0.5.0" } }, "locate-path": { @@ -6712,8 +6712,8 @@ "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", "dev": true, "requires": { - "p-locate": "2.0.0", - "path-exists": "3.0.0" + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" } }, "lodash": { @@ -6787,7 +6787,7 @@ "integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==", "dev": true, "requires": { - "chalk": "2.4.1" + "chalk": "^2.0.1" }, "dependencies": { "ansi-styles": { @@ -6796,7 +6796,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -6805,9 +6805,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -6822,7 +6822,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -6837,8 +6837,8 @@ "resolved": "https://registry.npmjs.org/loglevel-message-prefix/-/loglevel-message-prefix-3.0.0.tgz", "integrity": "sha1-ER/bltlPlh2PyLiqv7ZrBqw+dq0=", "requires": { - "es6-polyfills": "2.0.0", - "loglevel": "1.6.1" + "es6-polyfills": "^2.0.0", + "loglevel": "^1.4.0" } }, "loglevelnext": { @@ -6847,8 +6847,8 @@ "integrity": "sha512-V/73qkPuJmx4BcBF19xPBr+0ZRVBhc4POxvZTZdMeXpJ4NItXSJ/MSwuFT0kQJlCbXvdlZoQQ/418bS1y9Jh6A==", "dev": true, "requires": { - "es6-symbol": "3.1.1", - "object.assign": "4.1.0" + "es6-symbol": "^3.1.1", + "object.assign": "^4.1.0" } }, "long": { @@ -6862,7 +6862,7 @@ "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz", "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=", "requires": { - "js-tokens": "3.0.2" + "js-tokens": "^3.0.0" } }, "loud-rejection": { @@ -6871,8 +6871,8 @@ "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", "dev": true, "requires": { - "currently-unhandled": "0.4.1", - "signal-exit": "3.0.2" + "currently-unhandled": "^0.4.1", + "signal-exit": "^3.0.0" } }, "lower-case": { @@ -6887,8 +6887,8 @@ "integrity": "sha512-fFEhvcgzuIoJVUF8fYr5KR0YqxD238zgObTps31YdADwPPAp82a4M8TrckkWyx7ekNlf9aBcVn81cFwwXngrJA==", "dev": true, "requires": { - "pseudomap": "1.0.2", - "yallist": "2.1.2" + "pseudomap": "^1.0.2", + "yallist": "^2.1.2" } }, "macaddress": { @@ -6903,7 +6903,7 @@ "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==", "dev": true, "requires": { - "pify": "3.0.0" + "pify": "^3.0.0" } }, "map-cache": { @@ -6924,7 +6924,7 @@ "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", "dev": true, "requires": { - "object-visit": "1.0.1" + "object-visit": "^1.0.0" } }, "marked": { @@ -6945,8 +6945,8 @@ "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", "dev": true, "requires": { - "hash-base": "3.0.4", - "inherits": "2.0.3" + "hash-base": "^3.0.0", + "inherits": "^2.0.1" } }, "media-typer": { @@ -6961,7 +6961,7 @@ "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=", "dev": true, "requires": { - "mimic-fn": "1.2.0" + "mimic-fn": "^1.0.0" } }, "memory-fs": { @@ -6970,8 +6970,8 @@ "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=", "dev": true, "requires": { - "errno": "0.1.7", - "readable-stream": "2.3.6" + "errno": "^0.1.3", + "readable-stream": "^2.0.1" } }, "meow": { @@ -6980,16 +6980,16 @@ "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", "dev": true, "requires": { - "camelcase-keys": "2.1.0", - "decamelize": "1.2.0", - "loud-rejection": "1.6.0", - "map-obj": "1.0.1", - "minimist": "1.2.0", - "normalize-package-data": "2.4.0", - "object-assign": "4.1.1", - "read-pkg-up": "1.0.1", - "redent": "1.0.0", - "trim-newlines": "1.0.0" + "camelcase-keys": "^2.0.0", + "decamelize": "^1.1.2", + "loud-rejection": "^1.0.0", + "map-obj": "^1.0.1", + "minimist": "^1.1.3", + "normalize-package-data": "^2.3.4", + "object-assign": "^4.0.1", + "read-pkg-up": "^1.0.1", + "redent": "^1.0.0", + "trim-newlines": "^1.0.0" } }, "merge-descriptors": { @@ -7010,19 +7010,19 @@ "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "requires": { - "arr-diff": "4.0.0", - "array-unique": "0.3.2", - "braces": "2.3.2", - "define-property": "2.0.2", - "extend-shallow": "3.0.2", - "extglob": "2.0.4", - "fragment-cache": "0.2.1", - "kind-of": "6.0.2", - "nanomatch": "1.2.9", - "object.pick": "1.3.0", - "regex-not": "1.0.2", - "snapdragon": "0.8.2", - "to-regex": "3.0.2" + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "braces": "^2.3.1", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "extglob": "^2.0.4", + "fragment-cache": "^0.2.1", + "kind-of": "^6.0.2", + "nanomatch": "^1.2.9", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.2" } }, "miller-rabin": { @@ -7031,8 +7031,8 @@ "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", "dev": true, "requires": { - "bn.js": "4.11.8", - "brorand": "1.1.0" + "bn.js": "^4.0.0", + "brorand": "^1.0.1" } }, "mime": { @@ -7054,7 +7054,7 @@ "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==", "dev": true, "requires": { - "mime-db": "1.33.0" + "mime-db": "~1.33.0" } }, "mimer": { @@ -7087,7 +7087,7 @@ "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", "dev": true, "requires": { - "brace-expansion": "1.1.11" + "brace-expansion": "^1.1.7" } }, "minimist": { @@ -7101,16 +7101,16 @@ "integrity": "sha512-zHo8v+otD1J10j/tC+VNoGK9keCuByhKovAvdn74dmxJl9+mWHnx6EMsDN4lgRoMI/eYo2nchAxniIbUPb5onw==", "dev": true, "requires": { - "concat-stream": "1.6.2", - "duplexify": "3.6.0", - "end-of-stream": "1.4.1", - "flush-write-stream": "1.0.3", - "from2": "2.3.0", - "parallel-transform": "1.1.0", - "pump": "2.0.1", - "pumpify": "1.5.1", - "stream-each": "1.2.2", - "through2": "2.0.3" + "concat-stream": "^1.5.0", + "duplexify": "^3.4.2", + "end-of-stream": "^1.1.0", + "flush-write-stream": "^1.0.0", + "from2": "^2.1.0", + "parallel-transform": "^1.1.0", + "pump": "^2.0.1", + "pumpify": "^1.3.3", + "stream-each": "^1.1.0", + "through2": "^2.0.0" } }, "mixin-deep": { @@ -7119,8 +7119,8 @@ "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==", "dev": true, "requires": { - "for-in": "1.0.2", - "is-extendable": "1.0.1" + "for-in": "^1.0.2", + "is-extendable": "^1.0.1" }, "dependencies": { "is-extendable": { @@ -7129,7 +7129,7 @@ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "requires": { - "is-plain-object": "2.0.4" + "is-plain-object": "^2.0.4" } } } @@ -7161,7 +7161,7 @@ "resolved": "https://registry.npmjs.org/moment-timezone/-/moment-timezone-0.5.17.tgz", "integrity": "sha512-Y/JpVEWIOA9Gho4vO15MTnW1FCmHi3ypprrkUaxsZ1TKg3uqC8q/qMBjTddkHoiwwZN3qvZSr4zJP7x9V3LpXA==", "requires": { - "moment": "2.22.1" + "moment": ">= 2.9.0" } }, "more-entropy": { @@ -7169,7 +7169,7 @@ "resolved": "https://registry.npmjs.org/more-entropy/-/more-entropy-0.0.7.tgz", "integrity": "sha1-Z7/G96hvJvvDeqyD/UbYjGHRCbU=", "requires": { - "iced-runtime": "1.0.3" + "iced-runtime": ">=0.0.1" } }, "move-concurrently": { @@ -7178,12 +7178,12 @@ "integrity": "sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=", "dev": true, "requires": { - "aproba": "1.2.0", - "copy-concurrently": "1.0.5", - "fs-write-stream-atomic": "1.0.10", - "mkdirp": "0.5.1", - "rimraf": "2.6.2", - "run-queue": "1.0.3" + "aproba": "^1.1.1", + "copy-concurrently": "^1.0.0", + "fs-write-stream-atomic": "^1.0.8", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.4", + "run-queue": "^1.0.3" } }, "ms": { @@ -7197,8 +7197,8 @@ "integrity": "sha512-ji6J5enbMyGRHIAkAOu3WdV8nggqviKCEKtXcOqfphZZtQrmHKycfynJ2V7eVPUA4NhJ6V7Wf4TmGbTwKE9B6g==", "dev": true, "requires": { - "dns-packet": "1.3.1", - "thunky": "1.0.2" + "dns-packet": "^1.3.1", + "thunky": "^1.0.2" } }, "multicast-dns-service-types": { @@ -7213,10 +7213,10 @@ "integrity": "sha1-nHkGoi+0wCkZ4vX3UWG0zb1LKis=", "dev": true, "requires": { - "array-differ": "1.0.0", - "array-union": "1.0.2", - "arrify": "1.0.1", - "minimatch": "3.0.4" + "array-differ": "^1.0.0", + "array-union": "^1.0.1", + "arrify": "^1.0.0", + "minimatch": "^3.0.0" } }, "mute-stream": { @@ -7238,18 +7238,18 @@ "integrity": "sha512-n8R9bS8yQ6eSXaV6jHUpKzD8gLsin02w1HSFiegwrs9E098Ylhw5jdyKPaYqvHknHaSCKTPp7C8dGCQ0q9koXA==", "dev": true, "requires": { - "arr-diff": "4.0.0", - "array-unique": "0.3.2", - "define-property": "2.0.2", - "extend-shallow": "3.0.2", - "fragment-cache": "0.2.1", - "is-odd": "2.0.0", - "is-windows": "1.0.2", - "kind-of": "6.0.2", - "object.pick": "1.3.0", - "regex-not": "1.0.2", - "snapdragon": "0.8.2", - "to-regex": "3.0.2" + "arr-diff": "^4.0.0", + "array-unique": "^0.3.2", + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "fragment-cache": "^0.2.1", + "is-odd": "^2.0.0", + "is-windows": "^1.0.2", + "kind-of": "^6.0.2", + "object.pick": "^1.3.0", + "regex-not": "^1.0.0", + "snapdragon": "^0.8.1", + "to-regex": "^3.0.1" } }, "natural-compare": { @@ -7282,7 +7282,7 @@ "integrity": "sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==", "dev": true, "requires": { - "lower-case": "1.1.4" + "lower-case": "^1.1.1" } }, "node-forge": { @@ -7296,28 +7296,28 @@ "integrity": "sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==", "dev": true, "requires": { - "assert": "1.4.1", - "browserify-zlib": "0.2.0", - "buffer": "4.9.1", - "console-browserify": "1.1.0", - "constants-browserify": "1.0.0", - "crypto-browserify": "3.12.0", - "domain-browser": "1.2.0", - "events": "1.1.1", - "https-browserify": "1.0.0", - "os-browserify": "0.3.0", + "assert": "^1.1.1", + "browserify-zlib": "^0.2.0", + "buffer": "^4.3.0", + "console-browserify": "^1.1.0", + "constants-browserify": "^1.0.0", + "crypto-browserify": "^3.11.0", + "domain-browser": "^1.1.1", + "events": "^1.0.0", + "https-browserify": "^1.0.0", + "os-browserify": "^0.3.0", "path-browserify": "0.0.0", - "process": "0.11.10", - "punycode": "1.4.1", - "querystring-es3": "0.2.1", - "readable-stream": "2.3.6", - "stream-browserify": "2.0.1", - "stream-http": "2.8.2", - "string_decoder": "1.1.1", - "timers-browserify": "2.0.10", + "process": "^0.11.10", + "punycode": "^1.2.4", + "querystring-es3": "^0.2.0", + "readable-stream": "^2.3.3", + "stream-browserify": "^2.0.1", + "stream-http": "^2.7.2", + "string_decoder": "^1.0.0", + "timers-browserify": "^2.0.4", "tty-browserify": "0.0.0", - "url": "0.11.0", - "util": "0.10.3", + "url": "^0.11.0", + "util": "^0.10.3", "vm-browserify": "0.0.4" }, "dependencies": { @@ -7339,8 +7339,8 @@ "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.5.2.tgz", "integrity": "sha1-9DRUSKhTz71cDSYyDyR3qwUm/i8=", "requires": { - "colors": "0.5.1", - "underscore": "1.1.7" + "colors": "0.5.x", + "underscore": "1.1.x" }, "dependencies": { "underscore": { @@ -7356,7 +7356,7 @@ "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", "dev": true, "requires": { - "abbrev": "1.1.1" + "abbrev": "1" } }, "normalize-package-data": { @@ -7365,10 +7365,10 @@ "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", "dev": true, "requires": { - "hosted-git-info": "2.6.0", - "is-builtin-module": "1.0.0", - "semver": "5.5.0", - "validate-npm-package-license": "3.0.3" + "hosted-git-info": "^2.1.4", + "is-builtin-module": "^1.0.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" } }, "normalize-path": { @@ -7377,7 +7377,7 @@ "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", "dev": true, "requires": { - "remove-trailing-separator": "1.1.0" + "remove-trailing-separator": "^1.0.1" } }, "normalize-range": { @@ -7392,10 +7392,10 @@ "integrity": "sha1-LMDWazHqIwNkWENuNiDYWVTGbDw=", "dev": true, "requires": { - "object-assign": "4.1.1", - "prepend-http": "1.0.4", - "query-string": "4.3.4", - "sort-keys": "1.1.2" + "object-assign": "^4.0.1", + "prepend-http": "^1.0.0", + "query-string": "^4.1.0", + "sort-keys": "^1.0.0" } }, "npm-run-path": { @@ -7404,7 +7404,7 @@ "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", "dev": true, "requires": { - "path-key": "2.0.1" + "path-key": "^2.0.0" } }, "nth-check": { @@ -7413,7 +7413,7 @@ "integrity": "sha1-mSms32KPwsQQmN6rgqxYDPFJquQ=", "dev": true, "requires": { - "boolbase": "1.0.0" + "boolbase": "~1.0.0" } }, "num2fraction": { @@ -7451,9 +7451,9 @@ "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", "dev": true, "requires": { - "copy-descriptor": "0.1.1", - "define-property": "0.2.5", - "kind-of": "3.2.2" + "copy-descriptor": "^0.1.0", + "define-property": "^0.2.5", + "kind-of": "^3.0.3" }, "dependencies": { "define-property": { @@ -7462,7 +7462,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "0.1.6" + "is-descriptor": "^0.1.0" } }, "kind-of": { @@ -7471,7 +7471,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -7488,7 +7488,7 @@ "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", "dev": true, "requires": { - "isobject": "3.0.1" + "isobject": "^3.0.0" } }, "object.assign": { @@ -7497,10 +7497,10 @@ "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", "dev": true, "requires": { - "define-properties": "1.1.2", - "function-bind": "1.1.1", - "has-symbols": "1.0.0", - "object-keys": "1.0.11" + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" } }, "object.getownpropertydescriptors": { @@ -7509,8 +7509,8 @@ "integrity": "sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=", "dev": true, "requires": { - "define-properties": "1.1.2", - "es-abstract": "1.11.0" + "define-properties": "^1.1.2", + "es-abstract": "^1.5.1" } }, "object.pick": { @@ -7519,7 +7519,7 @@ "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", "dev": true, "requires": { - "isobject": "3.0.1" + "isobject": "^3.0.1" } }, "obuf": { @@ -7549,7 +7549,7 @@ "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", "dev": true, "requires": { - "wrappy": "1.0.2" + "wrappy": "1" } }, "onetime": { @@ -7558,7 +7558,7 @@ "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", "dev": true, "requires": { - "mimic-fn": "1.2.0" + "mimic-fn": "^1.0.0" } }, "opn": { @@ -7567,7 +7567,7 @@ "integrity": "sha512-bYJHo/LOmoTd+pfiYhfZDnf9zekVJrY+cnS2a5F2x+w5ppvTqObojTP7WiFG+kVZs9Inw+qQ/lw7TroWwhdd2g==", "dev": true, "requires": { - "is-wsl": "1.1.0" + "is-wsl": "^1.1.0" } }, "optionator": { @@ -7575,12 +7575,12 @@ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", "requires": { - "deep-is": "0.1.3", - "fast-levenshtein": "2.0.6", - "levn": "0.3.0", - "prelude-ls": "1.1.2", - "type-check": "0.3.2", - "wordwrap": "1.0.0" + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.4", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "wordwrap": "~1.0.0" } }, "original": { @@ -7589,7 +7589,7 @@ "integrity": "sha512-IEvtB5vM5ULvwnqMxWBLxkS13JIEXbakizMSo3yoPNPCIWzg8TG3Usn/UhXoZFM/m+FuEA20KdzPSFq/0rS+UA==", "dev": true, "requires": { - "url-parse": "1.4.0" + "url-parse": "~1.4.0" } }, "os-browserify": { @@ -7610,9 +7610,9 @@ "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==", "dev": true, "requires": { - "execa": "0.7.0", - "lcid": "1.0.0", - "mem": "1.1.0" + "execa": "^0.7.0", + "lcid": "^1.0.0", + "mem": "^1.1.0" } }, "os-tmpdir": { @@ -7626,7 +7626,7 @@ "resolved": "https://registry.npmjs.org/otp/-/otp-0.1.3.tgz", "integrity": "sha1-wle/JdL5Anr3esUiabPBQmjSvWs=", "requires": { - "thirty-two": "0.0.2" + "thirty-two": "^0.0.2" } }, "p-finally": { @@ -7641,7 +7641,7 @@ "integrity": "sha512-Y/OtIaXtUPr4/YpMv1pCL5L5ed0rumAaAeBSj12F+bSlMdys7i8oQF/GUJmfpTS/QoaRrS/k6pma29haJpsMng==", "dev": true, "requires": { - "p-try": "1.0.0" + "p-try": "^1.0.0" } }, "p-locate": { @@ -7650,7 +7650,7 @@ "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", "dev": true, "requires": { - "p-limit": "1.2.0" + "p-limit": "^1.1.0" } }, "p-map": { @@ -7671,11 +7671,11 @@ "integrity": "sha1-Yx3Mn3mBC3BZZeid7eps/w/B38k=", "dev": true, "requires": { - "meow": "3.7.0", - "pumpify": "1.5.1", - "repeating": "2.0.1", - "split2": "1.1.1", - "through2": "2.0.3" + "meow": "^3.0.0", + "pumpify": "^1.3.3", + "repeating": "^2.0.0", + "split2": "^1.0.0", + "through2": "^2.0.0" } }, "pako": { @@ -7690,9 +7690,9 @@ "integrity": "sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=", "dev": true, "requires": { - "cyclist": "0.2.2", - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "cyclist": "~0.2.2", + "inherits": "^2.0.3", + "readable-stream": "^2.1.5" } }, "param-case": { @@ -7701,7 +7701,7 @@ "integrity": "sha1-35T9jPZTHs915r75oIWPvHK+Ikc=", "dev": true, "requires": { - "no-case": "2.3.2" + "no-case": "^2.2.0" } }, "parse-asn1": { @@ -7710,11 +7710,11 @@ "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==", "dev": true, "requires": { - "asn1.js": "4.10.1", - "browserify-aes": "1.2.0", - "create-hash": "1.2.0", - "evp_bytestokey": "1.0.3", - "pbkdf2": "3.0.16" + "asn1.js": "^4.0.0", + "browserify-aes": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.0", + "pbkdf2": "^3.0.3" } }, "parse-json": { @@ -7723,7 +7723,7 @@ "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", "dev": true, "requires": { - "error-ex": "1.3.1" + "error-ex": "^1.2.0" } }, "parse5": { @@ -7792,9 +7792,9 @@ "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "pify": "2.3.0", - "pinkie-promise": "2.0.1" + "graceful-fs": "^4.1.2", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" }, "dependencies": { "pify": { @@ -7811,11 +7811,11 @@ "integrity": "sha512-y4CXP3thSxqf7c0qmOF+9UeOTrifiVTIM+u7NWlq+PRsHbr7r7dpCmvzrZxa96JJUNi0Y5w9VqG5ZNeCVMoDcA==", "dev": true, "requires": { - "create-hash": "1.2.0", - "create-hmac": "1.1.7", - "ripemd160": "2.0.2", - "safe-buffer": "5.1.2", - "sha.js": "2.4.11" + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" } }, "pend": { @@ -7835,8 +7835,8 @@ "resolved": "https://registry.npmjs.org/pgp-utils/-/pgp-utils-0.0.34.tgz", "integrity": "sha1-2E9J98GTteC5QV9cxcKmle15DCM=", "requires": { - "iced-error": "0.0.12", - "iced-runtime": "1.0.3" + "iced-error": ">=0.0.8", + "iced-runtime": ">=0.0.1" } }, "phantomjs-prebuilt": { @@ -7845,15 +7845,15 @@ "integrity": "sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=", "dev": true, "requires": { - "es6-promise": "4.2.4", - "extract-zip": "1.6.6", - "fs-extra": "1.0.0", - "hasha": "2.2.0", - "kew": "0.7.0", - "progress": "1.1.8", - "request": "2.86.0", - "request-progress": "2.0.1", - "which": "1.3.0" + "es6-promise": "^4.0.3", + "extract-zip": "^1.6.5", + "fs-extra": "^1.0.0", + "hasha": "^2.2.0", + "kew": "^0.7.0", + "progress": "^1.1.8", + "request": "^2.81.0", + "request-progress": "^2.0.1", + "which": "^1.2.10" } }, "pify": { @@ -7874,7 +7874,7 @@ "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", "dev": true, "requires": { - "pinkie": "2.0.4" + "pinkie": "^2.0.0" } }, "pkg-dir": { @@ -7883,7 +7883,7 @@ "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", "dev": true, "requires": { - "find-up": "2.1.0" + "find-up": "^2.1.0" } }, "pkg-up": { @@ -7892,7 +7892,7 @@ "integrity": "sha1-Pgj7RhUlxEIWJKM7n35tCvWwWiY=", "dev": true, "requires": { - "find-up": "1.1.2" + "find-up": "^1.0.0" }, "dependencies": { "find-up": { @@ -7901,8 +7901,8 @@ "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", "dev": true, "requires": { - "path-exists": "2.1.0", - "pinkie-promise": "2.0.1" + "path-exists": "^2.0.0", + "pinkie-promise": "^2.0.0" } }, "path-exists": { @@ -7911,7 +7911,7 @@ "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", "dev": true, "requires": { - "pinkie-promise": "2.0.1" + "pinkie-promise": "^2.0.0" } } } @@ -7934,9 +7934,9 @@ "integrity": "sha1-uzLs2HwnEErm7kS1o8y/Drsa7ek=", "dev": true, "requires": { - "async": "1.5.2", - "debug": "2.6.9", - "mkdirp": "0.5.1" + "async": "^1.5.2", + "debug": "^2.2.0", + "mkdirp": "0.5.x" }, "dependencies": { "async": { @@ -7959,10 +7959,10 @@ "integrity": "sha512-zrUjRRe1bpXKsX1qAJNJjqZViErVuyEkMTRrwu4ud4sbTtIBRmtaYDrHmcGgmrbsW3MHfmtIf+vJumgQn+PrXg==", "dev": true, "requires": { - "chalk": "1.1.3", - "js-base64": "2.4.5", - "source-map": "0.5.7", - "supports-color": "3.2.3" + "chalk": "^1.1.3", + "js-base64": "^2.1.9", + "source-map": "^0.5.6", + "supports-color": "^3.2.3" }, "dependencies": { "source-map": { @@ -7977,7 +7977,7 @@ "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=", "dev": true, "requires": { - "has-flag": "1.0.0" + "has-flag": "^1.0.0" } } } @@ -7988,9 +7988,9 @@ "integrity": "sha1-d7rnypKK2FcW4v2kLyYb98HWW14=", "dev": true, "requires": { - "postcss": "5.2.18", - "postcss-message-helpers": "2.0.0", - "reduce-css-calc": "1.3.0" + "postcss": "^5.0.2", + "postcss-message-helpers": "^2.0.0", + "reduce-css-calc": "^1.2.6" } }, "postcss-colormin": { @@ -7999,9 +7999,9 @@ "integrity": "sha1-ZjFBfV8OkJo9fsJrJMio0eT5bks=", "dev": true, "requires": { - "colormin": "1.1.2", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "colormin": "^1.0.5", + "postcss": "^5.0.13", + "postcss-value-parser": "^3.2.3" } }, "postcss-convert-values": { @@ -8010,8 +8010,8 @@ "integrity": "sha1-u9hZPFwf0uPRwyK7kl3K6Nrk1i0=", "dev": true, "requires": { - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "postcss": "^5.0.11", + "postcss-value-parser": "^3.1.2" } }, "postcss-css-variables": { @@ -8020,9 +8020,9 @@ "integrity": "sha1-pS5e8aLrYzqKT1/ENNbYXUD+cxA=", "dev": true, "requires": { - "escape-string-regexp": "1.0.5", - "extend": "3.0.1", - "postcss": "6.0.22" + "escape-string-regexp": "^1.0.3", + "extend": "^3.0.1", + "postcss": "^6.0.8" }, "dependencies": { "ansi-styles": { @@ -8031,7 +8031,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8040,9 +8040,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8057,9 +8057,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8068,7 +8068,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8079,7 +8079,7 @@ "integrity": "sha1-vv6J+v1bPazlzM5Rt2uBUUvgDj0=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.14" } }, "postcss-discard-duplicates": { @@ -8088,7 +8088,7 @@ "integrity": "sha1-uavye4isGIFYpesSq8riAmO5GTI=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.4" } }, "postcss-discard-empty": { @@ -8097,7 +8097,7 @@ "integrity": "sha1-0rS9nVztXr2Nyt52QMfXzX9PkrU=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.14" } }, "postcss-discard-overridden": { @@ -8106,7 +8106,7 @@ "integrity": "sha1-ix6vVU9ob7KIzYdMVWZ7CqNmjVg=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.16" } }, "postcss-discard-unused": { @@ -8115,8 +8115,8 @@ "integrity": "sha1-vOMLLMWR/8Y0Mitfs0ZLbZNPRDM=", "dev": true, "requires": { - "postcss": "5.2.18", - "uniqs": "2.0.0" + "postcss": "^5.0.14", + "uniqs": "^2.0.0" } }, "postcss-filter-plugins": { @@ -8125,8 +8125,8 @@ "integrity": "sha1-bYWGJTTXNaxCDkqFgG4fXUKG2Ew=", "dev": true, "requires": { - "postcss": "5.2.18", - "uniqid": "4.1.1" + "postcss": "^5.0.4", + "uniqid": "^4.0.0" } }, "postcss-import": { @@ -8135,10 +8135,10 @@ "integrity": "sha512-5l327iI75POonjxkXgdRCUS+AlzAdBx4pOvMEhTKTCjb1p8IEeVR9yx3cPbmN7LIWJLbfnIXxAhoB4jpD0c/Cw==", "dev": true, "requires": { - "postcss": "6.0.22", - "postcss-value-parser": "3.3.0", - "read-cache": "1.0.0", - "resolve": "1.1.7" + "postcss": "^6.0.1", + "postcss-value-parser": "^3.2.3", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" }, "dependencies": { "ansi-styles": { @@ -8147,7 +8147,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8156,9 +8156,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8173,9 +8173,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8184,7 +8184,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8195,10 +8195,10 @@ "integrity": "sha1-U56a/J3chiASHr+djDZz4M5Q0oo=", "dev": true, "requires": { - "cosmiconfig": "2.2.2", - "object-assign": "4.1.1", - "postcss-load-options": "1.2.0", - "postcss-load-plugins": "2.3.0" + "cosmiconfig": "^2.1.0", + "object-assign": "^4.1.0", + "postcss-load-options": "^1.2.0", + "postcss-load-plugins": "^2.3.0" } }, "postcss-load-options": { @@ -8207,8 +8207,8 @@ "integrity": "sha1-sJixVZ3awt8EvAuzdfmaXP4rbYw=", "dev": true, "requires": { - "cosmiconfig": "2.2.2", - "object-assign": "4.1.1" + "cosmiconfig": "^2.1.0", + "object-assign": "^4.1.0" } }, "postcss-load-plugins": { @@ -8217,8 +8217,8 @@ "integrity": "sha1-dFdoEWWZrKLwCfrUJrABdQSdjZI=", "dev": true, "requires": { - "cosmiconfig": "2.2.2", - "object-assign": "4.1.1" + "cosmiconfig": "^2.1.1", + "object-assign": "^4.1.0" } }, "postcss-loader": { @@ -8227,10 +8227,10 @@ "integrity": "sha512-pV7kB5neJ0/1tZ8L1uGOBNTVBCSCXQoIsZMsrwvO8V2rKGa2tBl/f80GGVxow2jJnRJ2w1ocx693EKhZAb9Isg==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "postcss": "6.0.22", - "postcss-load-config": "1.2.0", - "schema-utils": "0.4.5" + "loader-utils": "^1.1.0", + "postcss": "^6.0.0", + "postcss-load-config": "^1.2.0", + "schema-utils": "^0.4.0" }, "dependencies": { "ansi-styles": { @@ -8239,7 +8239,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8248,9 +8248,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8265,9 +8265,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8276,7 +8276,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8287,9 +8287,9 @@ "integrity": "sha1-TFUwMTwI4dWzu/PSu8dH4njuonA=", "dev": true, "requires": { - "has": "1.0.1", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "has": "^1.0.1", + "postcss": "^5.0.10", + "postcss-value-parser": "^3.1.1" } }, "postcss-merge-longhand": { @@ -8298,7 +8298,7 @@ "integrity": "sha1-I9kM0Sewp3mUkVMyc5A0oaTz1lg=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.4" } }, "postcss-merge-rules": { @@ -8307,11 +8307,11 @@ "integrity": "sha1-0d9d+qexrMO+VT8OnhDofGG19yE=", "dev": true, "requires": { - "browserslist": "1.7.7", - "caniuse-api": "1.6.1", - "postcss": "5.2.18", - "postcss-selector-parser": "2.2.3", - "vendors": "1.0.2" + "browserslist": "^1.5.2", + "caniuse-api": "^1.5.2", + "postcss": "^5.0.4", + "postcss-selector-parser": "^2.2.2", + "vendors": "^1.0.0" }, "dependencies": { "browserslist": { @@ -8320,8 +8320,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "1.0.30000843", - "electron-to-chromium": "1.3.47" + "caniuse-db": "^1.0.30000639", + "electron-to-chromium": "^1.2.7" } } } @@ -8338,9 +8338,9 @@ "integrity": "sha1-S1jttWZB66fIR0qzUmyv17vey2k=", "dev": true, "requires": { - "object-assign": "4.1.1", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "object-assign": "^4.0.1", + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.2" } }, "postcss-minify-gradients": { @@ -8349,8 +8349,8 @@ "integrity": "sha1-Xb2hE3NwP4PPtKPqOIHY11/15uE=", "dev": true, "requires": { - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "postcss": "^5.0.12", + "postcss-value-parser": "^3.3.0" } }, "postcss-minify-params": { @@ -8359,10 +8359,10 @@ "integrity": "sha1-rSzgcTc7lDs9kwo/pZo1jCjW8fM=", "dev": true, "requires": { - "alphanum-sort": "1.0.2", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0", - "uniqs": "2.0.0" + "alphanum-sort": "^1.0.1", + "postcss": "^5.0.2", + "postcss-value-parser": "^3.0.2", + "uniqs": "^2.0.0" } }, "postcss-minify-selectors": { @@ -8371,10 +8371,10 @@ "integrity": "sha1-ssapjAByz5G5MtGkllCBFDEXNb8=", "dev": true, "requires": { - "alphanum-sort": "1.0.2", - "has": "1.0.1", - "postcss": "5.2.18", - "postcss-selector-parser": "2.2.3" + "alphanum-sort": "^1.0.2", + "has": "^1.0.1", + "postcss": "^5.0.14", + "postcss-selector-parser": "^2.0.0" } }, "postcss-modules-extract-imports": { @@ -8383,7 +8383,7 @@ "integrity": "sha1-ZhQOzs447wa/DT41XWm/WdFB6oU=", "dev": true, "requires": { - "postcss": "6.0.22" + "postcss": "^6.0.1" }, "dependencies": { "ansi-styles": { @@ -8392,7 +8392,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8401,9 +8401,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8418,9 +8418,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8429,7 +8429,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8440,8 +8440,8 @@ "integrity": "sha1-99gMOYxaOT+nlkRmvRlQCn1hwGk=", "dev": true, "requires": { - "css-selector-tokenizer": "0.7.0", - "postcss": "6.0.22" + "css-selector-tokenizer": "^0.7.0", + "postcss": "^6.0.1" }, "dependencies": { "ansi-styles": { @@ -8450,7 +8450,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8459,9 +8459,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8476,9 +8476,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8487,7 +8487,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8498,8 +8498,8 @@ "integrity": "sha1-1upkmUx5+XtipytCb75gVqGUu5A=", "dev": true, "requires": { - "css-selector-tokenizer": "0.7.0", - "postcss": "6.0.22" + "css-selector-tokenizer": "^0.7.0", + "postcss": "^6.0.1" }, "dependencies": { "ansi-styles": { @@ -8508,7 +8508,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8517,9 +8517,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8534,9 +8534,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8545,7 +8545,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8556,8 +8556,8 @@ "integrity": "sha1-7P+p1+GSUYOJ9CrQ6D9yrsRW6iA=", "dev": true, "requires": { - "icss-replace-symbols": "1.1.0", - "postcss": "6.0.22" + "icss-replace-symbols": "^1.1.0", + "postcss": "^6.0.1" }, "dependencies": { "ansi-styles": { @@ -8566,7 +8566,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -8575,9 +8575,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -8592,9 +8592,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -8603,7 +8603,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -8614,7 +8614,7 @@ "integrity": "sha1-757nEhLX/nWceO0WL2HtYrXLk/E=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.5" } }, "postcss-normalize-url": { @@ -8623,10 +8623,10 @@ "integrity": "sha1-EI90s/L82viRov+j6kWSJ5/HgiI=", "dev": true, "requires": { - "is-absolute-url": "2.1.0", - "normalize-url": "1.9.1", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "is-absolute-url": "^2.0.0", + "normalize-url": "^1.4.0", + "postcss": "^5.0.14", + "postcss-value-parser": "^3.2.3" } }, "postcss-ordered-values": { @@ -8635,8 +8635,8 @@ "integrity": "sha1-7sbCpntsQSqNsgQud/6NpD+VwR0=", "dev": true, "requires": { - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.1" } }, "postcss-reduce-idents": { @@ -8645,8 +8645,8 @@ "integrity": "sha1-wsbSDMlYKE9qv75j92Cb9AkFmtM=", "dev": true, "requires": { - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "postcss": "^5.0.4", + "postcss-value-parser": "^3.0.2" } }, "postcss-reduce-initial": { @@ -8655,7 +8655,7 @@ "integrity": "sha1-aPgGlfBF0IJjqHmtJA343WT2ROo=", "dev": true, "requires": { - "postcss": "5.2.18" + "postcss": "^5.0.4" } }, "postcss-reduce-transforms": { @@ -8664,9 +8664,9 @@ "integrity": "sha1-/3b02CEkN7McKYpC0uFEQCV3GuE=", "dev": true, "requires": { - "has": "1.0.1", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0" + "has": "^1.0.1", + "postcss": "^5.0.8", + "postcss-value-parser": "^3.0.1" } }, "postcss-selector-parser": { @@ -8675,9 +8675,9 @@ "integrity": "sha1-+UN3iGBsPJrO4W/+jYsWKX8nu5A=", "dev": true, "requires": { - "flatten": "1.0.2", - "indexes-of": "1.0.1", - "uniq": "1.0.1" + "flatten": "^1.0.2", + "indexes-of": "^1.0.1", + "uniq": "^1.0.1" } }, "postcss-svgo": { @@ -8686,10 +8686,10 @@ "integrity": "sha1-tt8YqmE7Zm4TPwittSGcJoSsEI0=", "dev": true, "requires": { - "is-svg": "2.1.0", - "postcss": "5.2.18", - "postcss-value-parser": "3.3.0", - "svgo": "0.7.2" + "is-svg": "^2.0.0", + "postcss": "^5.0.14", + "postcss-value-parser": "^3.2.3", + "svgo": "^0.7.0" } }, "postcss-unique-selectors": { @@ -8698,9 +8698,9 @@ "integrity": "sha1-mB1X0p3csz57Hf4f1DuGSfkzyh0=", "dev": true, "requires": { - "alphanum-sort": "1.0.2", - "postcss": "5.2.18", - "uniqs": "2.0.0" + "alphanum-sort": "^1.0.1", + "postcss": "^5.0.4", + "uniqs": "^2.0.0" } }, "postcss-value-parser": { @@ -8715,9 +8715,9 @@ "integrity": "sha1-0hCd3AVbka9n/EyzsCWUZjnSryI=", "dev": true, "requires": { - "has": "1.0.1", - "postcss": "5.2.18", - "uniqs": "2.0.0" + "has": "^1.0.1", + "postcss": "^5.0.4", + "uniqs": "^2.0.0" } }, "prelude-ls": { @@ -8737,8 +8737,8 @@ "integrity": "sha1-X0+HyPkeWuPzuoerTPXgOxoX8aM=", "dev": true, "requires": { - "renderkid": "2.0.1", - "utila": "0.4.0" + "renderkid": "^2.0.1", + "utila": "~0.4" } }, "private": { @@ -8771,7 +8771,7 @@ "dev": true, "optional": true, "requires": { - "asap": "2.0.6" + "asap": "~2.0.3" } }, "promise-inflight": { @@ -8786,7 +8786,7 @@ "integrity": "sha512-jQTChiCJteusULxjBp8+jftSQE5Obdl3k4cnmLA6WXtK6XFuWRnvVL7aCiBqaLPM8c4ph0S4tKna8XvmIwEnXQ==", "dev": true, "requires": { - "forwarded": "0.1.2", + "forwarded": "~0.1.2", "ipaddr.js": "1.6.0" } }, @@ -8808,11 +8808,11 @@ "integrity": "sha512-4kJ5Esocg8X3h8YgJsKAuoesBgB7mqH3eowiDzMUPKiRDDE7E/BqqZD1hnTByIaAFiwAw246YEltSq7tdrOH0Q==", "dev": true, "requires": { - "bn.js": "4.11.8", - "browserify-rsa": "4.0.1", - "create-hash": "1.2.0", - "parse-asn1": "5.1.1", - "randombytes": "2.0.6" + "bn.js": "^4.1.0", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "parse-asn1": "^5.0.0", + "randombytes": "^2.0.1" } }, "pump": { @@ -8821,8 +8821,8 @@ "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", "dev": true, "requires": { - "end-of-stream": "1.4.1", - "once": "1.4.0" + "end-of-stream": "^1.1.0", + "once": "^1.3.1" } }, "pumpify": { @@ -8831,9 +8831,9 @@ "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", "dev": true, "requires": { - "duplexify": "3.6.0", - "inherits": "2.0.3", - "pump": "2.0.1" + "duplexify": "^3.6.0", + "inherits": "^2.0.3", + "pump": "^2.0.0" } }, "punycode": { @@ -8865,8 +8865,8 @@ "integrity": "sha1-u7aTucqRXCMlFbIosaArYJBD2+s=", "dev": true, "requires": { - "object-assign": "4.1.1", - "strict-uri-encode": "1.1.0" + "object-assign": "^4.1.0", + "strict-uri-encode": "^1.0.0" } }, "querystring": { @@ -8893,7 +8893,7 @@ "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", "dev": true, "requires": { - "safe-buffer": "5.1.2" + "safe-buffer": "^5.1.0" } }, "randomfill": { @@ -8902,8 +8902,8 @@ "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", "dev": true, "requires": { - "randombytes": "2.0.6", - "safe-buffer": "5.1.2" + "randombytes": "^2.0.5", + "safe-buffer": "^5.1.0" } }, "range-parser": { @@ -8918,8 +8918,8 @@ "integrity": "sha1-HQJ8K/oRasxmI7yo8AAWVyqH1CU=", "dev": true, "requires": { - "bytes": "1.0.0", - "string_decoder": "0.10.31" + "bytes": "1", + "string_decoder": "0.10" }, "dependencies": { "string_decoder": { @@ -8936,10 +8936,10 @@ "integrity": "sha512-LdLD8xD4zzLsAT5xyushXDNscEjB7+2ulnl8+r1pnESlYtlJtVSoCMBGr30eDRJ3+2Gq89jK9P9e4tCEH1+ywA==", "dev": true, "requires": { - "deep-extend": "0.5.1", - "ini": "1.3.5", - "minimist": "1.2.0", - "strip-json-comments": "2.0.1" + "deep-extend": "^0.5.1", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" } }, "read-cache": { @@ -8948,7 +8948,7 @@ "integrity": "sha1-5mTvMRYRZsl1HNvo28+GtftY93Q=", "dev": true, "requires": { - "pify": "2.3.0" + "pify": "^2.3.0" }, "dependencies": { "pify": { @@ -8965,9 +8965,9 @@ "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", "dev": true, "requires": { - "load-json-file": "1.1.0", - "normalize-package-data": "2.4.0", - "path-type": "1.1.0" + "load-json-file": "^1.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^1.0.0" } }, "read-pkg-up": { @@ -8976,8 +8976,8 @@ "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", "dev": true, "requires": { - "find-up": "1.1.2", - "read-pkg": "1.1.0" + "find-up": "^1.0.0", + "read-pkg": "^1.0.0" }, "dependencies": { "find-up": { @@ -8986,8 +8986,8 @@ "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", "dev": true, "requires": { - "path-exists": "2.1.0", - "pinkie-promise": "2.0.1" + "path-exists": "^2.0.0", + "pinkie-promise": "^2.0.0" } }, "path-exists": { @@ -8996,7 +8996,7 @@ "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", "dev": true, "requires": { - "pinkie-promise": "2.0.1" + "pinkie-promise": "^2.0.0" } } } @@ -9007,13 +9007,13 @@ "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", "dev": true, "requires": { - "core-util-is": "1.0.2", - "inherits": "2.0.3", - "isarray": "1.0.0", - "process-nextick-args": "2.0.0", - "safe-buffer": "5.1.2", - "string_decoder": "1.1.1", - "util-deprecate": "1.0.2" + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" } }, "readdirp": { @@ -9022,10 +9022,10 @@ "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", "dev": true, "requires": { - "graceful-fs": "4.1.11", - "minimatch": "3.0.4", - "readable-stream": "2.3.6", - "set-immediate-shim": "1.0.1" + "graceful-fs": "^4.1.2", + "minimatch": "^3.0.2", + "readable-stream": "^2.0.2", + "set-immediate-shim": "^1.0.1" } }, "redent": { @@ -9034,8 +9034,8 @@ "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", "dev": true, "requires": { - "indent-string": "2.1.0", - "strip-indent": "1.0.1" + "indent-string": "^2.1.0", + "strip-indent": "^1.0.1" } }, "reduce-css-calc": { @@ -9044,9 +9044,9 @@ "integrity": "sha1-dHyRTgSWFKTJz7umKYca0dKSdxY=", "dev": true, "requires": { - "balanced-match": "0.4.2", - "math-expression-evaluator": "1.2.17", - "reduce-function-call": "1.0.2" + "balanced-match": "^0.4.2", + "math-expression-evaluator": "^1.2.14", + "reduce-function-call": "^1.0.1" }, "dependencies": { "balanced-match": { @@ -9063,7 +9063,7 @@ "integrity": "sha1-WiAL+S4ON3UXUv5FsKszD9S2vpk=", "dev": true, "requires": { - "balanced-match": "0.4.2" + "balanced-match": "^0.4.2" }, "dependencies": { "balanced-match": { @@ -9091,9 +9091,9 @@ "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", "dev": true, "requires": { - "babel-runtime": "6.26.0", - "babel-types": "6.26.0", - "private": "0.1.8" + "babel-runtime": "^6.18.0", + "babel-types": "^6.19.0", + "private": "^0.1.6" } }, "regex-not": { @@ -9102,8 +9102,8 @@ "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", "dev": true, "requires": { - "extend-shallow": "3.0.2", - "safe-regex": "1.1.0" + "extend-shallow": "^3.0.2", + "safe-regex": "^1.1.0" } }, "regexpp": { @@ -9118,9 +9118,9 @@ "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", "dev": true, "requires": { - "regenerate": "1.4.0", - "regjsgen": "0.2.0", - "regjsparser": "0.1.5" + "regenerate": "^1.2.1", + "regjsgen": "^0.2.0", + "regjsparser": "^0.1.4" } }, "regjsgen": { @@ -9135,7 +9135,7 @@ "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", "dev": true, "requires": { - "jsesc": "0.5.0" + "jsesc": "~0.5.0" }, "dependencies": { "jsesc": { @@ -9164,11 +9164,11 @@ "integrity": "sha1-iYyr/Ivt5Le5ETWj/9Mj5YwNsxk=", "dev": true, "requires": { - "css-select": "1.2.0", - "dom-converter": "0.1.4", - "htmlparser2": "3.3.0", - "strip-ansi": "3.0.1", - "utila": "0.3.3" + "css-select": "^1.1.0", + "dom-converter": "~0.1", + "htmlparser2": "~3.3.0", + "strip-ansi": "^3.0.0", + "utila": "~0.3" }, "dependencies": { "domhandler": { @@ -9177,7 +9177,7 @@ "integrity": "sha1-0mRvXlf2w7qxHPbLBdPArPdBJZQ=", "dev": true, "requires": { - "domelementtype": "1.3.0" + "domelementtype": "1" } }, "domutils": { @@ -9186,7 +9186,7 @@ "integrity": "sha1-vdw94Jm5ou+sxRxiPyj0FuzFdIU=", "dev": true, "requires": { - "domelementtype": "1.3.0" + "domelementtype": "1" } }, "htmlparser2": { @@ -9195,10 +9195,10 @@ "integrity": "sha1-zHDQWln2VC5D8OaFyYLhTJJKnv4=", "dev": true, "requires": { - "domelementtype": "1.3.0", - "domhandler": "2.1.0", - "domutils": "1.1.6", - "readable-stream": "1.0.34" + "domelementtype": "1", + "domhandler": "2.1", + "domutils": "1.1", + "readable-stream": "1.0" } }, "isarray": { @@ -9213,10 +9213,10 @@ "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", "dev": true, "requires": { - "core-util-is": "1.0.2", - "inherits": "2.0.3", + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", "isarray": "0.0.1", - "string_decoder": "0.10.31" + "string_decoder": "~0.10.x" } }, "string_decoder": { @@ -9251,7 +9251,7 @@ "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", "dev": true, "requires": { - "is-finite": "1.0.2" + "is-finite": "^1.0.0" } }, "request": { @@ -9260,27 +9260,27 @@ "integrity": "sha512-BQZih67o9r+Ys94tcIW4S7Uu8pthjrQVxhsZ/weOwHbDfACxvIyvnAbzFQxjy1jMtvFSzv5zf4my6cZsJBbVzw==", "dev": true, "requires": { - "aws-sign2": "0.7.0", - "aws4": "1.7.0", - "caseless": "0.12.0", - "combined-stream": "1.0.6", - "extend": "3.0.1", - "forever-agent": "0.6.1", - "form-data": "2.3.2", - "har-validator": "5.0.3", - "hawk": "6.0.2", - "http-signature": "1.2.0", - "is-typedarray": "1.0.0", - "isstream": "0.1.2", - "json-stringify-safe": "5.0.1", - "mime-types": "2.1.18", - "oauth-sign": "0.8.2", - "performance-now": "2.1.0", - "qs": "6.5.2", - "safe-buffer": "5.1.2", - "tough-cookie": "2.3.4", - "tunnel-agent": "0.6.0", - "uuid": "3.2.1" + "aws-sign2": "~0.7.0", + "aws4": "^1.6.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.5", + "extend": "~3.0.1", + "forever-agent": "~0.6.1", + "form-data": "~2.3.1", + "har-validator": "~5.0.3", + "hawk": "~6.0.2", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.17", + "oauth-sign": "~0.8.2", + "performance-now": "^2.1.0", + "qs": "~6.5.1", + "safe-buffer": "^5.1.1", + "tough-cookie": "~2.3.3", + "tunnel-agent": "^0.6.0", + "uuid": "^3.1.0" } }, "request-progress": { @@ -9289,7 +9289,7 @@ "integrity": "sha1-XTa7V5YcZzqlt4jbyBQf3yO0Tgg=", "dev": true, "requires": { - "throttleit": "1.0.0" + "throttleit": "^1.0.0" } }, "request-promise-core": { @@ -9298,7 +9298,7 @@ "integrity": "sha1-Pu4AssWqgyOc+wTFcA2jb4HNCLY=", "dev": true, "requires": { - "lodash": "4.17.10" + "lodash": "^4.13.1" } }, "request-promise-native": { @@ -9308,8 +9308,8 @@ "dev": true, "requires": { "request-promise-core": "1.1.1", - "stealthy-require": "1.1.1", - "tough-cookie": "2.3.4" + "stealthy-require": "^1.1.0", + "tough-cookie": ">=2.3.3" } }, "require-directory": { @@ -9336,8 +9336,8 @@ "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", "dev": true, "requires": { - "caller-path": "0.1.0", - "resolve-from": "1.0.1" + "caller-path": "^0.1.0", + "resolve-from": "^1.0.0" } }, "requires-port": { @@ -9352,7 +9352,7 @@ "integrity": "sha1-aUPDUwxNmn5G8c3dUcFY/GcM294=", "dev": true, "requires": { - "underscore": "1.6.0" + "underscore": "~1.6.0" }, "dependencies": { "underscore": { @@ -9375,7 +9375,7 @@ "integrity": "sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=", "dev": true, "requires": { - "resolve-from": "3.0.0" + "resolve-from": "^3.0.0" }, "dependencies": { "resolve-from": { @@ -9398,7 +9398,7 @@ "integrity": "sha1-AsyZNBDik2livZcWahsHfalyVTE=", "dev": true, "requires": { - "resolve-from": "2.0.0" + "resolve-from": "^2.0.0" }, "dependencies": { "resolve-from": { @@ -9421,8 +9421,8 @@ "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", "dev": true, "requires": { - "onetime": "2.0.1", - "signal-exit": "3.0.2" + "onetime": "^2.0.0", + "signal-exit": "^3.0.2" } }, "ret": { @@ -9437,7 +9437,7 @@ "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", "dev": true, "requires": { - "glob": "7.1.2" + "glob": "^7.0.5" } }, "ripemd160": { @@ -9446,8 +9446,8 @@ "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", "dev": true, "requires": { - "hash-base": "3.0.4", - "inherits": "2.0.3" + "hash-base": "^3.0.0", + "inherits": "^2.0.1" } }, "run-async": { @@ -9456,7 +9456,7 @@ "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", "dev": true, "requires": { - "is-promise": "2.1.0" + "is-promise": "^2.1.0" } }, "run-queue": { @@ -9465,7 +9465,7 @@ "integrity": "sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=", "dev": true, "requires": { - "aproba": "1.2.0" + "aproba": "^1.1.1" } }, "rx-lite": { @@ -9480,7 +9480,7 @@ "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", "dev": true, "requires": { - "rx-lite": "4.0.8" + "rx-lite": "*" } }, "safe-buffer": { @@ -9501,7 +9501,7 @@ "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", "dev": true, "requires": { - "ret": "0.1.15" + "ret": "~0.1.10" } }, "safer-buffer": { @@ -9516,16 +9516,16 @@ "integrity": "sha512-52ThA+Z7h6BnvpSVbURwChl10XZrps5q7ytjTwWcIe9bmJwnVP6cpEVK2NvDOUhGupoqAvNbUz3cpnJDp4+/pg==", "dev": true, "requires": { - "chalk": "2.4.1", - "htmlparser2": "3.9.2", - "lodash.clonedeep": "4.5.0", - "lodash.escaperegexp": "4.1.2", - "lodash.isplainobject": "4.0.6", - "lodash.isstring": "4.0.1", - "lodash.mergewith": "4.6.1", - "postcss": "6.0.22", - "srcset": "1.0.0", - "xtend": "4.0.1" + "chalk": "^2.3.0", + "htmlparser2": "^3.9.0", + "lodash.clonedeep": "^4.5.0", + "lodash.escaperegexp": "^4.1.2", + "lodash.isplainobject": "^4.0.6", + "lodash.isstring": "^4.0.1", + "lodash.mergewith": "^4.6.0", + "postcss": "^6.0.14", + "srcset": "^1.0.0", + "xtend": "^4.0.0" }, "dependencies": { "ansi-styles": { @@ -9534,7 +9534,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -9543,9 +9543,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "entities": { @@ -9566,12 +9566,12 @@ "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", "dev": true, "requires": { - "domelementtype": "1.3.0", - "domhandler": "2.3.0", - "domutils": "1.5.1", - "entities": "1.1.1", - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "domelementtype": "^1.3.0", + "domhandler": "^2.3.0", + "domutils": "^1.5.1", + "entities": "^1.1.1", + "inherits": "^2.0.1", + "readable-stream": "^2.0.2" } }, "postcss": { @@ -9580,9 +9580,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "source-map": "0.6.1", - "supports-color": "5.4.0" + "chalk": "^2.4.1", + "source-map": "^0.6.1", + "supports-color": "^5.4.0" } }, "supports-color": { @@ -9591,7 +9591,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -9608,8 +9608,8 @@ "integrity": "sha512-yYrjb9TX2k/J1Y5UNy3KYdZq10xhYcF8nMpAW6o3hy6Q8WSIEf9lJHG/ePnOBfziPM3fvQwfOwa13U/Fh8qTfA==", "dev": true, "requires": { - "ajv": "6.5.0", - "ajv-keywords": "3.2.0" + "ajv": "^6.1.0", + "ajv-keywords": "^3.1.0" }, "dependencies": { "ajv": { @@ -9618,10 +9618,10 @@ "integrity": "sha512-VDUX1oSajablmiyFyED9L1DFndg0P9h7p1F+NO8FkIzei6EPrR6Zu1n18rd5P8PqaSRd/FrWv3G1TVBqpM83gA==", "dev": true, "requires": { - "fast-deep-equal": "2.0.1", - "fast-json-stable-stringify": "2.0.0", - "json-schema-traverse": "0.3.1", - "uri-js": "4.2.1" + "fast-deep-equal": "^2.0.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0", + "uri-js": "^4.2.1" } }, "ajv-keywords": { @@ -9671,18 +9671,18 @@ "dev": true, "requires": { "debug": "2.6.9", - "depd": "1.1.2", - "destroy": "1.0.4", - "encodeurl": "1.0.2", - "escape-html": "1.0.3", - "etag": "1.8.1", + "depd": "~1.1.2", + "destroy": "~1.0.4", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", "fresh": "0.5.2", - "http-errors": "1.6.3", + "http-errors": "~1.6.2", "mime": "1.4.1", "ms": "2.0.0", - "on-finished": "2.3.0", - "range-parser": "1.2.0", - "statuses": "1.4.0" + "on-finished": "~2.3.0", + "range-parser": "~1.2.0", + "statuses": "~1.4.0" }, "dependencies": { "mime": { @@ -9705,13 +9705,13 @@ "integrity": "sha1-03aNabHn2C5c4FD/9bRTvqEqkjk=", "dev": true, "requires": { - "accepts": "1.3.5", + "accepts": "~1.3.4", "batch": "0.6.1", "debug": "2.6.9", - "escape-html": "1.0.3", - "http-errors": "1.6.3", - "mime-types": "2.1.18", - "parseurl": "1.3.2" + "escape-html": "~1.0.3", + "http-errors": "~1.6.2", + "mime-types": "~2.1.17", + "parseurl": "~1.3.2" } }, "serve-static": { @@ -9720,9 +9720,9 @@ "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==", "dev": true, "requires": { - "encodeurl": "1.0.2", - "escape-html": "1.0.3", - "parseurl": "1.3.2", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.2", "send": "0.16.2" } }, @@ -9744,10 +9744,10 @@ "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==", "dev": true, "requires": { - "extend-shallow": "2.0.1", - "is-extendable": "0.1.1", - "is-plain-object": "2.0.4", - "split-string": "3.1.0" + "extend-shallow": "^2.0.1", + "is-extendable": "^0.1.1", + "is-plain-object": "^2.0.3", + "split-string": "^3.0.1" }, "dependencies": { "extend-shallow": { @@ -9756,7 +9756,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } } } @@ -9779,8 +9779,8 @@ "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", "dev": true, "requires": { - "inherits": "2.0.3", - "safe-buffer": "5.1.2" + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" } }, "shebang-command": { @@ -9789,7 +9789,7 @@ "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", "dev": true, "requires": { - "shebang-regex": "1.0.0" + "shebang-regex": "^1.0.0" } }, "shebang-regex": { @@ -9816,15 +9816,10 @@ "integrity": "sha1-Vpy+IYAgKSamKiZs094Jyc60P4M=", "dev": true, "requires": { - "underscore": "1.7.0", - "url-join": "1.1.0" + "underscore": "^1.7.0", + "url-join": "^1.1.0" } }, - "sladex-blowfish": { - "version": "0.8.1", - "resolved": "https://registry.npmjs.org/sladex-blowfish/-/sladex-blowfish-0.8.1.tgz", - "integrity": "sha1-y431Dra7sJgchCjGzl6B8H5kZrE=" - }, "slash": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", @@ -9837,7 +9832,7 @@ "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", "dev": true, "requires": { - "is-fullwidth-code-point": "2.0.0" + "is-fullwidth-code-point": "^2.0.0" } }, "snapdragon": { @@ -9846,14 +9841,14 @@ "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", "dev": true, "requires": { - "base": "0.11.2", - "debug": "2.6.9", - "define-property": "0.2.5", - "extend-shallow": "2.0.1", - "map-cache": "0.2.2", - "source-map": "0.5.7", - "source-map-resolve": "0.5.2", - "use": "3.1.0" + "base": "^0.11.1", + "debug": "^2.2.0", + "define-property": "^0.2.5", + "extend-shallow": "^2.0.1", + "map-cache": "^0.2.2", + "source-map": "^0.5.6", + "source-map-resolve": "^0.5.0", + "use": "^3.1.0" }, "dependencies": { "define-property": { @@ -9862,7 +9857,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "0.1.6" + "is-descriptor": "^0.1.0" } }, "extend-shallow": { @@ -9871,7 +9866,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } }, "source-map": { @@ -9888,9 +9883,9 @@ "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", "dev": true, "requires": { - "define-property": "1.0.0", - "isobject": "3.0.1", - "snapdragon-util": "3.0.1" + "define-property": "^1.0.0", + "isobject": "^3.0.0", + "snapdragon-util": "^3.0.1" }, "dependencies": { "define-property": { @@ -9899,7 +9894,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "1.0.2" + "is-descriptor": "^1.0.0" } }, "is-accessor-descriptor": { @@ -9908,7 +9903,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-data-descriptor": { @@ -9917,7 +9912,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.0" } }, "is-descriptor": { @@ -9926,9 +9921,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "1.0.0", - "is-data-descriptor": "1.0.0", - "kind-of": "6.0.2" + "is-accessor-descriptor": "^1.0.0", + "is-data-descriptor": "^1.0.0", + "kind-of": "^6.0.2" } } } @@ -9939,7 +9934,7 @@ "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", "dev": true, "requires": { - "kind-of": "3.2.2" + "kind-of": "^3.2.0" }, "dependencies": { "kind-of": { @@ -9948,7 +9943,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -9959,7 +9954,7 @@ "integrity": "sha512-FL1b58BDrqS3A11lJ0zEdnJ3UOKqVxawAkF3k7F0CVN7VQ34aZrV+G8BZ1WC9ZL7NyrwsW0oviwsWDgRuVYtJg==", "dev": true, "requires": { - "hoek": "4.2.1" + "hoek": "4.x.x" } }, "sockjs": { @@ -9968,8 +9963,8 @@ "integrity": "sha512-V48klKZl8T6MzatbLlzzRNhMepEys9Y4oGFpypBFFn1gLI/QQ9HtLLyWJNbPlwGLelOVOEijUbTTJeLLI59jLw==", "dev": true, "requires": { - "faye-websocket": "0.10.0", - "uuid": "3.2.1" + "faye-websocket": "^0.10.0", + "uuid": "^3.0.1" } }, "sockjs-client": { @@ -9978,12 +9973,12 @@ "integrity": "sha1-W6vjhrd15M8U51IJEUUmVAFsixI=", "dev": true, "requires": { - "debug": "2.6.9", + "debug": "^2.6.6", "eventsource": "0.1.6", - "faye-websocket": "0.11.1", - "inherits": "2.0.3", - "json3": "3.3.2", - "url-parse": "1.4.0" + "faye-websocket": "~0.11.0", + "inherits": "^2.0.1", + "json3": "^3.3.2", + "url-parse": "^1.1.8" }, "dependencies": { "faye-websocket": { @@ -9992,7 +9987,7 @@ "integrity": "sha1-8O/hjE9W5PQK/H4Gxxn9XuYYjzg=", "dev": true, "requires": { - "websocket-driver": "0.7.0" + "websocket-driver": ">=0.5.1" } } } @@ -10003,7 +9998,7 @@ "integrity": "sha1-RBttTTRnmPG05J6JIK37oOVD+a0=", "dev": true, "requires": { - "is-plain-obj": "1.1.0" + "is-plain-obj": "^1.0.0" } }, "sortablejs": { @@ -10028,11 +10023,11 @@ "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==", "dev": true, "requires": { - "atob": "2.1.1", - "decode-uri-component": "0.2.0", - "resolve-url": "0.2.1", - "source-map-url": "0.4.0", - "urix": "0.1.0" + "atob": "^2.1.1", + "decode-uri-component": "^0.2.0", + "resolve-url": "^0.2.1", + "source-map-url": "^0.4.0", + "urix": "^0.1.0" } }, "source-map-support": { @@ -10041,7 +10036,7 @@ "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==", "dev": true, "requires": { - "source-map": "0.5.7" + "source-map": "^0.5.6" }, "dependencies": { "source-map": { @@ -10064,8 +10059,8 @@ "integrity": "sha512-N19o9z5cEyc8yQQPukRCZ9EUmb4HUpnrmaL/fxS2pBo2jbfcFRVuFZ/oFC+vZz0MNNk0h80iMn5/S6qGZOL5+g==", "dev": true, "requires": { - "spdx-expression-parse": "3.0.0", - "spdx-license-ids": "3.0.0" + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" } }, "spdx-exceptions": { @@ -10080,8 +10075,8 @@ "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", "dev": true, "requires": { - "spdx-exceptions": "2.1.0", - "spdx-license-ids": "3.0.0" + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" } }, "spdx-license-ids": { @@ -10096,12 +10091,12 @@ "integrity": "sha1-Qv9B7OXMD5mjpsKKq7c/XDsDrLw=", "dev": true, "requires": { - "debug": "2.6.9", - "handle-thing": "1.2.5", - "http-deceiver": "1.2.7", - "safe-buffer": "5.1.2", - "select-hose": "2.0.0", - "spdy-transport": "2.1.0" + "debug": "^2.6.8", + "handle-thing": "^1.2.5", + "http-deceiver": "^1.2.7", + "safe-buffer": "^5.0.1", + "select-hose": "^2.0.0", + "spdy-transport": "^2.0.18" } }, "spdy-transport": { @@ -10110,13 +10105,13 @@ "integrity": "sha512-bpUeGpZcmZ692rrTiqf9/2EUakI6/kXX1Rpe0ib/DyOzbiexVfXkw6GnvI9hVGvIwVaUhkaBojjCZwLNRGQg1g==", "dev": true, "requires": { - "debug": "2.6.9", - "detect-node": "2.0.3", - "hpack.js": "2.1.6", - "obuf": "1.1.2", - "readable-stream": "2.3.6", - "safe-buffer": "5.1.2", - "wbuf": "1.7.3" + "debug": "^2.6.8", + "detect-node": "^2.0.3", + "hpack.js": "^2.1.6", + "obuf": "^1.1.1", + "readable-stream": "^2.2.9", + "safe-buffer": "^5.0.1", + "wbuf": "^1.7.2" } }, "split-string": { @@ -10125,7 +10120,7 @@ "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", "dev": true, "requires": { - "extend-shallow": "3.0.2" + "extend-shallow": "^3.0.0" } }, "split.js": { @@ -10139,7 +10134,7 @@ "integrity": "sha1-Fi2bGIZfAqsvKtlYVSLbm1TEgfk=", "dev": true, "requires": { - "through2": "2.0.3" + "through2": "~2.0.0" } }, "sprintf-js": { @@ -10154,8 +10149,8 @@ "integrity": "sha1-pWad4StC87HV6D7QPHEEb8SPQe8=", "dev": true, "requires": { - "array-uniq": "1.0.3", - "number-is-nan": "1.0.1" + "array-uniq": "^1.0.2", + "number-is-nan": "^1.0.0" } }, "ssdeep.js": { @@ -10169,14 +10164,14 @@ "integrity": "sha1-Ew9Zde3a2WPx1W+SuaxsUfqfg+s=", "dev": true, "requires": { - "asn1": "0.2.3", - "assert-plus": "1.0.0", - "bcrypt-pbkdf": "1.0.1", - "dashdash": "1.14.1", - "ecc-jsbn": "0.1.1", - "getpass": "0.1.7", - "jsbn": "0.1.1", - "tweetnacl": "0.14.5" + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "tweetnacl": "~0.14.0" }, "dependencies": { "jsbn": { @@ -10201,7 +10196,7 @@ "integrity": "sha512-XRSIPqLij52MtgoQavH/x/dU1qVKtWUAAZeOHsR9c2Ddi4XerFy3mc1alf+dLJKl9EUIm/Ht+EowFkTUOA6GAQ==", "dev": true, "requires": { - "safe-buffer": "5.1.2" + "safe-buffer": "^5.1.1" } }, "static-eval": { @@ -10209,7 +10204,7 @@ "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.0.tgz", "integrity": "sha512-6flshd3F1Gwm+Ksxq463LtFd1liC77N/PX1FVVc3OzL3hAmo2fwHFbuArkcfi7s9rTNsLEhcRmXGFZhlgy40uw==", "requires": { - "escodegen": "1.9.1" + "escodegen": "^1.8.1" } }, "static-extend": { @@ -10218,8 +10213,8 @@ "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", "dev": true, "requires": { - "define-property": "0.2.5", - "object-copy": "0.1.0" + "define-property": "^0.2.5", + "object-copy": "^0.1.0" }, "dependencies": { "define-property": { @@ -10228,7 +10223,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "0.1.6" + "is-descriptor": "^0.1.0" } } } @@ -10251,8 +10246,8 @@ "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", "dev": true, "requires": { - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "inherits": "~2.0.1", + "readable-stream": "^2.0.2" } }, "stream-each": { @@ -10261,8 +10256,8 @@ "integrity": "sha512-mc1dbFhGBxvTM3bIWmAAINbqiuAk9TATcfIQC8P+/+HJefgaiTlMn2dHvkX8qlI12KeYKSQ1Ua9RrIqrn1VPoA==", "dev": true, "requires": { - "end-of-stream": "1.4.1", - "stream-shift": "1.0.0" + "end-of-stream": "^1.1.0", + "stream-shift": "^1.0.0" } }, "stream-http": { @@ -10271,11 +10266,11 @@ "integrity": "sha512-QllfrBhqF1DPcz46WxKTs6Mz1Bpc+8Qm6vbqOpVav5odAXwbyzwnEczoWqtxrsmlO+cJqtPrp/8gWKWjaKLLlA==", "dev": true, "requires": { - "builtin-status-codes": "3.0.0", - "inherits": "2.0.3", - "readable-stream": "2.3.6", - "to-arraybuffer": "1.0.1", - "xtend": "4.0.1" + "builtin-status-codes": "^3.0.0", + "inherits": "^2.0.1", + "readable-stream": "^2.3.6", + "to-arraybuffer": "^1.0.0", + "xtend": "^4.0.0" } }, "stream-shift": { @@ -10302,8 +10297,8 @@ "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", "dev": true, "requires": { - "is-fullwidth-code-point": "2.0.0", - "strip-ansi": "4.0.0" + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" }, "dependencies": { "ansi-regex": { @@ -10318,7 +10313,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "3.0.0" + "ansi-regex": "^3.0.0" } } } @@ -10329,7 +10324,7 @@ "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, "requires": { - "safe-buffer": "5.1.2" + "safe-buffer": "~5.1.0" } }, "strip-ansi": { @@ -10337,7 +10332,7 @@ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", "requires": { - "ansi-regex": "2.1.1" + "ansi-regex": "^2.0.0" } }, "strip-bom": { @@ -10346,7 +10341,7 @@ "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", "dev": true, "requires": { - "is-utf8": "0.2.1" + "is-utf8": "^0.2.0" } }, "strip-eof": { @@ -10361,7 +10356,7 @@ "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", "dev": true, "requires": { - "get-stdin": "4.0.1" + "get-stdin": "^4.0.1" } }, "strip-json-comments": { @@ -10376,8 +10371,8 @@ "integrity": "sha512-T+UNsAcl3Yg+BsPKs1vd22Fr8sVT+CJMtzqc6LEw9bbJZb43lm9GoeIfUcDEefBSWC0BhYbcdupV1GtI4DGzxg==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "schema-utils": "0.4.5" + "loader-utils": "^1.1.0", + "schema-utils": "^0.4.5" } }, "supports-color": { @@ -10391,13 +10386,13 @@ "integrity": "sha1-n1dyQTlSE1xv779Ar+ak+qiLS7U=", "dev": true, "requires": { - "coa": "1.0.4", - "colors": "1.1.2", - "csso": "2.3.2", - "js-yaml": "3.7.0", - "mkdirp": "0.5.1", - "sax": "1.2.4", - "whet.extend": "0.9.9" + "coa": "~1.0.1", + "colors": "~1.1.2", + "csso": "~2.3.1", + "js-yaml": "~3.7.0", + "mkdirp": "~0.5.1", + "sax": "~1.2.1", + "whet.extend": "~0.9.9" }, "dependencies": { "colors": { @@ -10420,12 +10415,12 @@ "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", "dev": true, "requires": { - "ajv": "5.5.2", - "ajv-keywords": "2.1.1", - "chalk": "2.4.1", - "lodash": "4.17.10", + "ajv": "^5.2.3", + "ajv-keywords": "^2.1.0", + "chalk": "^2.1.0", + "lodash": "^4.17.4", "slice-ansi": "1.0.0", - "string-width": "2.1.1" + "string-width": "^2.1.1" }, "dependencies": { "ansi-styles": { @@ -10434,7 +10429,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -10443,9 +10438,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -10460,7 +10455,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -10506,8 +10501,8 @@ "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", "dev": true, "requires": { - "readable-stream": "2.3.6", - "xtend": "4.0.1" + "readable-stream": "^2.1.5", + "xtend": "~4.0.1" } }, "thunky": { @@ -10522,7 +10517,7 @@ "integrity": "sha512-YvC1SV1XdOUaL6gx5CoGroT3Gu49pK9+TZ38ErPldOWW4j49GI1HKs9DV+KGq/w6y+LZ72W1c8cKz2vzY+qpzg==", "dev": true, "requires": { - "setimmediate": "1.0.5" + "setimmediate": "^1.0.4" } }, "tiny-lr": { @@ -10531,12 +10526,12 @@ "integrity": "sha512-44yhA3tsaRoMOjQQ+5v5mVdqef+kH6Qze9jTpqtVufgYjYt08zyZAwNwwVBj3i1rJMnR52IxOW0LK0vBzgAkuA==", "dev": true, "requires": { - "body": "5.1.0", - "debug": "3.1.0", - "faye-websocket": "0.10.0", - "livereload-js": "2.3.0", - "object-assign": "4.1.1", - "qs": "6.5.2" + "body": "^5.1.0", + "debug": "^3.1.0", + "faye-websocket": "~0.10.0", + "livereload-js": "^2.3.0", + "object-assign": "^4.1.0", + "qs": "^6.4.0" }, "dependencies": { "debug": { @@ -10556,7 +10551,7 @@ "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", "dev": true, "requires": { - "os-tmpdir": "1.0.2" + "os-tmpdir": "~1.0.2" } }, "to-arraybuffer": { @@ -10576,7 +10571,7 @@ "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", "dev": true, "requires": { - "kind-of": "3.2.2" + "kind-of": "^3.0.2" }, "dependencies": { "kind-of": { @@ -10585,7 +10580,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "1.1.6" + "is-buffer": "^1.1.5" } } } @@ -10596,10 +10591,10 @@ "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", "dev": true, "requires": { - "define-property": "2.0.2", - "extend-shallow": "3.0.2", - "regex-not": "1.0.2", - "safe-regex": "1.1.0" + "define-property": "^2.0.2", + "extend-shallow": "^3.0.2", + "regex-not": "^1.0.2", + "safe-regex": "^1.1.0" } }, "to-regex-range": { @@ -10608,8 +10603,8 @@ "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", "dev": true, "requires": { - "is-number": "3.0.0", - "repeat-string": "1.6.1" + "is-number": "^3.0.0", + "repeat-string": "^1.6.1" } }, "toposort": { @@ -10624,7 +10619,7 @@ "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", "dev": true, "requires": { - "punycode": "1.4.1" + "punycode": "^1.4.1" }, "dependencies": { "punycode": { @@ -10641,7 +10636,7 @@ "integrity": "sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=", "dev": true, "requires": { - "punycode": "2.1.0" + "punycode": "^2.1.0" } }, "trim-newlines": { @@ -10661,11 +10656,11 @@ "resolved": "https://registry.npmjs.org/triplesec/-/triplesec-3.0.26.tgz", "integrity": "sha1-3/K7R1ikIzcuc5o5fYmR8Fl9CsE=", "requires": { - "iced-error": "0.0.12", - "iced-lock": "1.1.0", - "iced-runtime": "1.0.3", - "more-entropy": "0.0.7", - "progress": "1.1.8" + "iced-error": ">=0.0.9", + "iced-lock": "^1.0.1", + "iced-runtime": "^1.0.2", + "more-entropy": ">=0.0.7", + "progress": "~1.1.2" } }, "tty-browserify": { @@ -10680,7 +10675,7 @@ "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", "dev": true, "requires": { - "safe-buffer": "5.1.2" + "safe-buffer": "^5.0.1" } }, "tweetnacl": { @@ -10693,7 +10688,7 @@ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", "requires": { - "prelude-ls": "1.1.2" + "prelude-ls": "~1.1.2" } }, "type-is": { @@ -10703,7 +10698,7 @@ "dev": true, "requires": { "media-typer": "0.3.0", - "mime-types": "2.1.18" + "mime-types": "~2.1.18" } }, "typedarray": { @@ -10723,8 +10718,8 @@ "integrity": "sha512-hobogryjDV36VrLK3Y69ou4REyrTApzUblVFmdQOYRe8cYaSmFJXMb4dR9McdvYDSbeNdzUgYr2YVukJaErJcA==", "dev": true, "requires": { - "commander": "2.15.1", - "source-map": "0.6.1" + "commander": "~2.15.0", + "source-map": "~0.6.1" } }, "uglifyjs-webpack-plugin": { @@ -10733,14 +10728,14 @@ "integrity": "sha512-hIQJ1yxAPhEA2yW/i7Fr+SXZVMp+VEI3d42RTHBgQd2yhp/1UdBcR3QEWPV5ahBxlqQDMEMTuTEvDHSFINfwSw==", "dev": true, "requires": { - "cacache": "10.0.4", - "find-cache-dir": "1.0.0", - "schema-utils": "0.4.5", - "serialize-javascript": "1.5.0", - "source-map": "0.6.1", - "uglify-es": "3.3.9", - "webpack-sources": "1.1.0", - "worker-farm": "1.6.0" + "cacache": "^10.0.4", + "find-cache-dir": "^1.0.0", + "schema-utils": "^0.4.5", + "serialize-javascript": "^1.4.0", + "source-map": "^0.6.1", + "uglify-es": "^3.3.4", + "webpack-sources": "^1.1.0", + "worker-farm": "^1.5.2" }, "dependencies": { "commander": { @@ -10755,8 +10750,8 @@ "integrity": "sha512-r+MU0rfv4L/0eeW3xZrd16t4NZfK8Ld4SWVglYBb7ez5uXFWHuVRs6xCTrf1yirs9a4j4Y27nn7SRfO6v67XsQ==", "dev": true, "requires": { - "commander": "2.13.0", - "source-map": "0.6.1" + "commander": "~2.13.0", + "source-map": "~0.6.1" } } } @@ -10800,10 +10795,10 @@ "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=", "dev": true, "requires": { - "arr-union": "3.1.0", - "get-value": "2.0.6", - "is-extendable": "0.1.1", - "set-value": "0.4.3" + "arr-union": "^3.1.0", + "get-value": "^2.0.6", + "is-extendable": "^0.1.1", + "set-value": "^0.4.3" }, "dependencies": { "extend-shallow": { @@ -10812,7 +10807,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "0.1.1" + "is-extendable": "^0.1.0" } }, "set-value": { @@ -10821,10 +10816,10 @@ "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=", "dev": true, "requires": { - "extend-shallow": "2.0.1", - "is-extendable": "0.1.1", - "is-plain-object": "2.0.4", - "to-object-path": "0.3.0" + "extend-shallow": "^2.0.1", + "is-extendable": "^0.1.1", + "is-plain-object": "^2.0.1", + "to-object-path": "^0.3.0" } } } @@ -10841,7 +10836,7 @@ "integrity": "sha1-iSIN32t1GuUrX3JISGNShZa7hME=", "dev": true, "requires": { - "macaddress": "0.2.8" + "macaddress": "^0.2.8" } }, "uniqs": { @@ -10856,7 +10851,7 @@ "integrity": "sha1-0F8v5AMlYIcfMOk8vnNe6iAVFPM=", "dev": true, "requires": { - "unique-slug": "2.0.0" + "unique-slug": "^2.0.0" } }, "unique-slug": { @@ -10865,7 +10860,7 @@ "integrity": "sha1-22Z258fMBimHj/GWCXx4hVrp9Ks=", "dev": true, "requires": { - "imurmurhash": "0.1.4" + "imurmurhash": "^0.1.4" } }, "unixify": { @@ -10874,7 +10869,7 @@ "integrity": "sha1-OmQcjC/7zk2mg6XHDwOkYpQMIJA=", "dev": true, "requires": { - "normalize-path": "2.1.1" + "normalize-path": "^2.1.1" } }, "unpipe": { @@ -10889,8 +10884,8 @@ "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", "dev": true, "requires": { - "has-value": "0.3.1", - "isobject": "3.0.1" + "has-value": "^0.3.1", + "isobject": "^3.0.0" }, "dependencies": { "has-value": { @@ -10899,9 +10894,9 @@ "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", "dev": true, "requires": { - "get-value": "2.0.6", - "has-values": "0.1.4", - "isobject": "2.1.0" + "get-value": "^2.0.3", + "has-values": "^0.1.4", + "isobject": "^2.0.0" }, "dependencies": { "isobject": { @@ -10941,7 +10936,7 @@ "integrity": "sha512-jpKCA3HjsBfSDOEgxRDAxQCNyHfCPSbq57PqCkd3gAyBuPb3IWxw54EHncqESznIdqSetHfw3D7ylThu2Kcc9A==", "dev": true, "requires": { - "punycode": "2.1.0" + "punycode": "^2.1.0" } }, "urix": { @@ -10980,9 +10975,9 @@ "integrity": "sha512-rAonpHy7231fmweBKUFe0bYnlGDty77E+fm53NZdij7j/YOpyGzc7ttqG1nAXl3aRs0k41o0PC3TvGXQiw2Zvw==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "mime": "2.3.1", - "schema-utils": "0.4.5" + "loader-utils": "^1.1.0", + "mime": "^2.0.3", + "schema-utils": "^0.4.3" }, "dependencies": { "mime": { @@ -10999,8 +10994,8 @@ "integrity": "sha512-ERuGxDiQ6Xw/agN4tuoCRbmwRuZP0cJ1lJxJubXr5Q/5cDa78+Dc4wfvtxzhzhkm5VvmW6Mf8EVj9SPGN4l8Lg==", "dev": true, "requires": { - "querystringify": "2.0.0", - "requires-port": "1.0.0" + "querystringify": "^2.0.0", + "requires-port": "^1.0.0" } }, "use": { @@ -11009,7 +11004,7 @@ "integrity": "sha512-6UJEQM/L+mzC3ZJNM56Q4DFGLX/evKGRg15UJHGB9X5j5Z3AFbgZvjUh2yq/UJUY4U5dh7Fal++XbNg1uzpRAw==", "dev": true, "requires": { - "kind-of": "6.0.2" + "kind-of": "^6.0.2" } }, "utf8": { @@ -11046,8 +11041,8 @@ "integrity": "sha512-i+6qA2MPhvoKLuxnJNpXAGhg7HphQOSUq2LKMZD0m15EiskXUkMvKdF4Uui0WYeCUGea+o2cw/ZuwehtfsrNkA==", "dev": true, "requires": { - "define-properties": "1.1.2", - "object.getownpropertydescriptors": "2.0.3" + "define-properties": "^1.1.2", + "object.getownpropertydescriptors": "^2.0.3" } }, "utila": { @@ -11080,8 +11075,8 @@ "integrity": "sha512-63ZOUnL4SIXj4L0NixR3L1lcjO38crAbgrTpl28t8jjrfuiOBL5Iygm+60qPs/KsZGzPNg6Smnc/oY16QTjF0g==", "dev": true, "requires": { - "spdx-correct": "3.0.0", - "spdx-expression-parse": "3.0.0" + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" } }, "validator": { @@ -11108,9 +11103,9 @@ "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", "dev": true, "requires": { - "assert-plus": "1.0.0", + "assert-plus": "^1.0.0", "core-util-is": "1.0.2", - "extsprintf": "1.3.0" + "extsprintf": "^1.2.0" } }, "vkbeautify": { @@ -11133,7 +11128,7 @@ "integrity": "sha1-gqwr/2PZUOqeMYmlimViX+3xkEU=", "dev": true, "requires": { - "browser-process-hrtime": "0.1.2" + "browser-process-hrtime": "^0.1.2" } }, "watchpack": { @@ -11142,9 +11137,9 @@ "integrity": "sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==", "dev": true, "requires": { - "chokidar": "2.0.3", - "graceful-fs": "4.1.11", - "neo-async": "2.5.1" + "chokidar": "^2.0.2", + "graceful-fs": "^4.1.2", + "neo-async": "^2.5.0" } }, "wbuf": { @@ -11153,7 +11148,7 @@ "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==", "dev": true, "requires": { - "minimalistic-assert": "1.0.1" + "minimalistic-assert": "^1.0.0" } }, "web-resource-inliner": { @@ -11162,14 +11157,14 @@ "integrity": "sha512-fOWnBQHVX8zHvEbECDTxtYL0FXIIZZ5H3LWoez8mGopYJK7inEru1kVMDzM1lVdeJBNEqUnNP5FBGxvzuMcwwQ==", "dev": true, "requires": { - "async": "2.6.0", - "chalk": "1.1.3", - "datauri": "1.1.0", - "htmlparser2": "3.9.2", - "lodash.unescape": "4.0.1", - "request": "2.86.0", - "valid-data-url": "0.1.6", - "xtend": "4.0.1" + "async": "^2.1.2", + "chalk": "^1.1.3", + "datauri": "^1.0.4", + "htmlparser2": "^3.9.2", + "lodash.unescape": "^4.0.1", + "request": "^2.78.0", + "valid-data-url": "^0.1.4", + "xtend": "^4.0.0" }, "dependencies": { "entities": { @@ -11184,12 +11179,12 @@ "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", "dev": true, "requires": { - "domelementtype": "1.3.0", - "domhandler": "2.3.0", - "domutils": "1.5.1", - "entities": "1.1.1", - "inherits": "2.0.3", - "readable-stream": "2.3.6" + "domelementtype": "^1.3.0", + "domhandler": "^2.3.0", + "domutils": "^1.5.1", + "entities": "^1.1.1", + "inherits": "^2.0.1", + "readable-stream": "^2.0.2" } } } @@ -11204,7 +11199,7 @@ "@webassemblyjs/validation": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "long": "3.2.0" + "long": "^3.2.0" } }, "webidl-conversions": { @@ -11222,25 +11217,25 @@ "@webassemblyjs/ast": "1.4.3", "@webassemblyjs/wasm-edit": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", - "acorn": "5.5.3", - "acorn-dynamic-import": "3.0.0", - "ajv": "6.5.0", - "ajv-keywords": "3.2.0", - "chrome-trace-event": "0.1.3", - "enhanced-resolve": "4.0.0", - "eslint-scope": "3.7.1", - "loader-runner": "2.3.0", - "loader-utils": "1.1.0", - "memory-fs": "0.4.1", - "micromatch": "3.1.10", - "mkdirp": "0.5.1", - "neo-async": "2.5.1", - "node-libs-browser": "2.1.0", - "schema-utils": "0.4.5", - "tapable": "1.0.0", - "uglifyjs-webpack-plugin": "1.2.5", - "watchpack": "1.6.0", - "webpack-sources": "1.1.0" + "acorn": "^5.0.0", + "acorn-dynamic-import": "^3.0.0", + "ajv": "^6.1.0", + "ajv-keywords": "^3.1.0", + "chrome-trace-event": "^0.1.1", + "enhanced-resolve": "^4.0.0", + "eslint-scope": "^3.7.1", + "loader-runner": "^2.3.0", + "loader-utils": "^1.1.0", + "memory-fs": "~0.4.1", + "micromatch": "^3.1.8", + "mkdirp": "~0.5.0", + "neo-async": "^2.5.0", + "node-libs-browser": "^2.0.0", + "schema-utils": "^0.4.4", + "tapable": "^1.0.0", + "uglifyjs-webpack-plugin": "^1.2.4", + "watchpack": "^1.5.0", + "webpack-sources": "^1.0.1" }, "dependencies": { "ajv": { @@ -11249,10 +11244,10 @@ "integrity": "sha512-VDUX1oSajablmiyFyED9L1DFndg0P9h7p1F+NO8FkIzei6EPrR6Zu1n18rd5P8PqaSRd/FrWv3G1TVBqpM83gA==", "dev": true, "requires": { - "fast-deep-equal": "2.0.1", - "fast-json-stable-stringify": "2.0.0", - "json-schema-traverse": "0.3.1", - "uri-js": "4.2.1" + "fast-deep-equal": "^2.0.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0", + "uri-js": "^4.2.1" } }, "ajv-keywords": { @@ -11275,13 +11270,13 @@ "integrity": "sha512-I6Mmy/QjWU/kXwCSFGaiOoL5YEQIVmbb0o45xMoCyQAg/mClqZVTcsX327sPfekDyJWpCxb+04whNyLOIxpJdQ==", "dev": true, "requires": { - "loud-rejection": "1.6.0", - "memory-fs": "0.4.1", - "mime": "2.3.1", - "path-is-absolute": "1.0.1", - "range-parser": "1.2.0", - "url-join": "4.0.0", - "webpack-log": "1.2.0" + "loud-rejection": "^1.6.0", + "memory-fs": "~0.4.1", + "mime": "^2.1.0", + "path-is-absolute": "^1.0.0", + "range-parser": "^1.0.3", + "url-join": "^4.0.0", + "webpack-log": "^1.0.1" }, "dependencies": { "mime": { @@ -11305,32 +11300,32 @@ "dev": true, "requires": { "ansi-html": "0.0.7", - "array-includes": "3.0.3", - "bonjour": "3.5.0", - "chokidar": "2.0.3", - "compression": "1.7.2", - "connect-history-api-fallback": "1.5.0", - "debug": "3.1.0", - "del": "3.0.0", - "express": "4.16.3", - "html-entities": "1.2.1", - "http-proxy-middleware": "0.18.0", - "import-local": "1.0.0", + "array-includes": "^3.0.3", + "bonjour": "^3.5.0", + "chokidar": "^2.0.0", + "compression": "^1.5.2", + "connect-history-api-fallback": "^1.3.0", + "debug": "^3.1.0", + "del": "^3.0.0", + "express": "^4.16.2", + "html-entities": "^1.2.0", + "http-proxy-middleware": "~0.18.0", + "import-local": "^1.0.0", "internal-ip": "1.2.0", - "ip": "1.1.5", - "killable": "1.0.0", - "loglevel": "1.6.1", - "opn": "5.3.0", - "portfinder": "1.0.13", - "selfsigned": "1.10.3", - "serve-index": "1.9.1", + "ip": "^1.1.5", + "killable": "^1.0.0", + "loglevel": "^1.4.1", + "opn": "^5.1.0", + "portfinder": "^1.0.9", + "selfsigned": "^1.9.1", + "serve-index": "^1.7.2", "sockjs": "0.3.19", "sockjs-client": "1.1.4", - "spdy": "3.4.7", - "strip-ansi": "3.0.1", - "supports-color": "5.4.0", + "spdy": "^3.4.1", + "strip-ansi": "^3.0.0", + "supports-color": "^5.1.0", "webpack-dev-middleware": "3.1.3", - "webpack-log": "1.2.0", + "webpack-log": "^1.1.2", "yargs": "11.0.0" }, "dependencies": { @@ -11349,12 +11344,12 @@ "integrity": "sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=", "dev": true, "requires": { - "globby": "6.1.0", - "is-path-cwd": "1.0.0", - "is-path-in-cwd": "1.0.1", - "p-map": "1.2.0", - "pify": "3.0.0", - "rimraf": "2.6.2" + "globby": "^6.1.0", + "is-path-cwd": "^1.0.0", + "is-path-in-cwd": "^1.0.0", + "p-map": "^1.1.1", + "pify": "^3.0.0", + "rimraf": "^2.2.8" } }, "globby": { @@ -11363,11 +11358,11 @@ "integrity": "sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=", "dev": true, "requires": { - "array-union": "1.0.2", - "glob": "7.1.2", - "object-assign": "4.1.1", - "pify": "2.3.0", - "pinkie-promise": "2.0.1" + "array-union": "^1.0.1", + "glob": "^7.0.3", + "object-assign": "^4.0.1", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" }, "dependencies": { "pify": { @@ -11390,7 +11385,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -11401,10 +11396,10 @@ "integrity": "sha512-U9AnICnu50HXtiqiDxuli5gLB5PGBo7VvcHx36jRZHwK4vzOYLbImqT4lwWwoMHdQWwEKw736fCHEekokTEKHA==", "dev": true, "requires": { - "chalk": "2.4.1", - "log-symbols": "2.2.0", - "loglevelnext": "1.0.5", - "uuid": "3.2.1" + "chalk": "^2.1.0", + "log-symbols": "^2.1.0", + "loglevelnext": "^1.0.1", + "uuid": "^3.1.0" }, "dependencies": { "ansi-styles": { @@ -11413,7 +11408,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "1.9.1" + "color-convert": "^1.9.0" } }, "chalk": { @@ -11422,9 +11417,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "3.2.1", - "escape-string-regexp": "1.0.5", - "supports-color": "5.4.0" + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" } }, "has-flag": { @@ -11439,7 +11434,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "3.0.0" + "has-flag": "^3.0.0" } } } @@ -11456,8 +11451,8 @@ "integrity": "sha512-aqYp18kPphgoO5c/+NaUvEeACtZjMESmDChuD3NBciVpah3XpMEU9VAAtIaB1BsfJWWTSdv8Vv1m3T0aRk2dUw==", "dev": true, "requires": { - "source-list-map": "2.0.0", - "source-map": "0.6.1" + "source-list-map": "^2.0.0", + "source-map": "~0.6.1" } }, "websocket-driver": { @@ -11466,8 +11461,8 @@ "integrity": "sha1-DK+dLXVdk67gSdS90NP+LMoqJOs=", "dev": true, "requires": { - "http-parser-js": "0.4.12", - "websocket-extensions": "0.1.3" + "http-parser-js": ">=0.4.0", + "websocket-extensions": ">=0.1.1" } }, "websocket-extensions": { @@ -11505,9 +11500,9 @@ "integrity": "sha512-FwygsxsXx27x6XXuExA/ox3Ktwcbf+OAvrKmLulotDAiO1Q6ixchPFaHYsis2zZBZSJTR0+dR+JVtf7MlbqZjw==", "dev": true, "requires": { - "lodash.sortby": "4.7.0", - "tr46": "1.0.1", - "webidl-conversions": "4.0.2" + "lodash.sortby": "^4.7.0", + "tr46": "^1.0.1", + "webidl-conversions": "^4.0.2" } }, "whet.extend": { @@ -11522,7 +11517,7 @@ "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", "dev": true, "requires": { - "isexe": "2.0.0" + "isexe": "^2.0.0" } }, "which-module": { @@ -11542,7 +11537,7 @@ "integrity": "sha512-6w+3tHbM87WnSWnENBUvA2pxJPLhQUg5LKwUQHq3r+XPhIM+Gh2R5ycbwPCyuGbNg+lPgdcnQUhuC02kJCvffQ==", "dev": true, "requires": { - "errno": "0.1.7" + "errno": "~0.1.7" } }, "worker-loader": { @@ -11551,8 +11546,8 @@ "integrity": "sha512-qJZLVS/jMCBITDzPo/RuweYSIG8VJP5P67mP/71alGyTZRe1LYJFdwLjLalY3T5ifx0bMDRD3OB6P2p1escvlg==", "dev": true, "requires": { - "loader-utils": "1.1.0", - "schema-utils": "0.4.5" + "loader-utils": "^1.0.0", + "schema-utils": "^0.4.0" } }, "wrap-ansi": { @@ -11561,8 +11556,8 @@ "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", "dev": true, "requires": { - "string-width": "1.0.2", - "strip-ansi": "3.0.1" + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1" }, "dependencies": { "is-fullwidth-code-point": { @@ -11571,7 +11566,7 @@ "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", "dev": true, "requires": { - "number-is-nan": "1.0.1" + "number-is-nan": "^1.0.0" } }, "string-width": { @@ -11580,9 +11575,9 @@ "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", "dev": true, "requires": { - "code-point-at": "1.1.0", - "is-fullwidth-code-point": "1.0.0", - "strip-ansi": "3.0.1" + "code-point-at": "^1.0.0", + "is-fullwidth-code-point": "^1.0.0", + "strip-ansi": "^3.0.0" } } } @@ -11599,7 +11594,7 @@ "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", "dev": true, "requires": { - "mkdirp": "0.5.1" + "mkdirp": "^0.5.1" } }, "ws": { @@ -11608,8 +11603,8 @@ "integrity": "sha512-ZGh/8kF9rrRNffkLFV4AzhvooEclrOH0xaugmqGsIfFgOE/pIz4fMc4Ef+5HSQqTEug2S9JZIWDR47duDSLfaA==", "dev": true, "requires": { - "async-limiter": "1.0.0", - "safe-buffer": "5.1.2" + "async-limiter": "~1.0.0", + "safe-buffer": "~5.1.0" } }, "xml-name-validator": { @@ -11663,18 +11658,18 @@ "integrity": "sha512-Rjp+lMYQOWtgqojx1dEWorjCofi1YN7AoFvYV7b1gx/7dAAeuI4kN5SZiEvr0ZmsZTOpDRcCqrpI10L31tFkBw==", "dev": true, "requires": { - "cliui": "4.1.0", - "decamelize": "1.2.0", - "find-up": "2.1.0", - "get-caller-file": "1.0.2", - "os-locale": "2.1.0", - "require-directory": "2.1.1", - "require-main-filename": "1.0.1", - "set-blocking": "2.0.0", - "string-width": "2.1.1", - "which-module": "2.0.0", - "y18n": "3.2.1", - "yargs-parser": "9.0.2" + "cliui": "^4.0.0", + "decamelize": "^1.1.1", + "find-up": "^2.1.0", + "get-caller-file": "^1.0.1", + "os-locale": "^2.0.0", + "require-directory": "^2.1.1", + "require-main-filename": "^1.0.1", + "set-blocking": "^2.0.0", + "string-width": "^2.0.0", + "which-module": "^2.0.0", + "y18n": "^3.2.1", + "yargs-parser": "^9.0.2" }, "dependencies": { "y18n": { @@ -11691,7 +11686,7 @@ "integrity": "sha1-nM9qQ0YP5O1Aqbto9I1DuKaMwHc=", "dev": true, "requires": { - "camelcase": "4.1.0" + "camelcase": "^4.1.0" }, "dependencies": { "camelcase": { @@ -11708,7 +11703,7 @@ "integrity": "sha1-lSj0QtqxsihOWLQ3m7GU4i4MQAU=", "dev": true, "requires": { - "fd-slicer": "1.0.1" + "fd-slicer": "~1.0.1" } }, "zlibjs": { diff --git a/package.json b/package.json index 527beeb9..84b6dd53 100644 --- a/package.json +++ b/package.json @@ -69,8 +69,8 @@ "worker-loader": "^1.1.1" }, "dependencies": { - "babel-polyfill": "^6.26.0", "babel-plugin-transform-builtin-extend": "1.1.2", + "babel-polyfill": "^6.26.0", "bcryptjs": "^2.4.3", "bignumber.js": "^7.0.1", "bootstrap": "^3.3.7", @@ -82,8 +82,8 @@ "crypto-js": "^3.1.9-1", "ctph.js": "0.0.5", "diff": "^3.5.0", - "escodegen": "^1.9.1", "es6-promisify": "^6.0.0", + "escodegen": "^1.9.1", "esmangle": "^1.0.1", "esprima": "^4.0.0", "exif-parser": "^0.1.12", @@ -96,9 +96,9 @@ "jsesc": "^2.5.1", "jsonpath": "^1.0.0", "jsrsasign": "8.0.12", + "kbpgp": "^2.0.77", "lodash": "^4.17.10", "loglevel": "^1.6.1", - "kbpgp": "^2.0.77", "loglevel-message-prefix": "^3.0.0", "moment": "^2.22.1", "moment-timezone": "^0.5.16", @@ -107,7 +107,6 @@ "nwmatcher": "^1.4.4", "otp": "^0.1.3", "scryptsy": "^2.0.0", - "sladex-blowfish": "^0.8.1", "sortablejs": "^1.7.0", "split.js": "^1.3.5", "ssdeep.js": "0.0.2", diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs new file mode 100644 index 00000000..5e155195 --- /dev/null +++ b/src/core/operations/BlowfishDecrypt.mjs @@ -0,0 +1,101 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { Blowfish } from "../vendor/Blowfish"; +import { toBase64 } from "../lib/Base64"; +import { toHexFast } from "../lib/Hex"; + +/** + * Lookup table for Blowfish output types. + */ +const BLOWFISH_OUTPUT_TYPE_LOOKUP = { + Base64: 0, Hex: 1, String: 2, Raw: 3 +}; +/** + * Lookup table for Blowfish modes. + */ +const BLOWFISH_MODE_LOOKUP = { + ECB: 0, CBC: 1, PCBC: 2, CFB: 3, OFB: 4, CTR: 5 +}; + +/** + * Blowfish Decrypt operation + */ +class BlowfishDecrypt extends Operation { + + /** + * BlowfishDecrypt constructor + */ + constructor() { + super(); + + this.name = "Blowfish Decrypt"; + this.module = "Ciphers"; + this.description = "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "PCBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Base64", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length === 0) return "Enter a key"; + + input = inputType === "Raw" ? Utils.strToByteArray(input) : input; + + Blowfish.setIV(toBase64(iv), 0); + + const result = Blowfish.decrypt(input, key, { + outputType: BLOWFISH_OUTPUT_TYPE_LOOKUP[inputType], // This actually means inputType. The library is weird. + cipherMode: BLOWFISH_MODE_LOOKUP[mode] + }); + + return outputType === "Hex" ? toHexFast(Utils.strToByteArray(result)) : result; + } + +} + +export default BlowfishDecrypt; diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs new file mode 100644 index 00000000..aa0b04e6 --- /dev/null +++ b/src/core/operations/BlowfishEncrypt.mjs @@ -0,0 +1,98 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { Blowfish } from "../vendor/Blowfish"; +import { toBase64 } from "../lib/Base64"; + +const BLOWFISH_OUTPUT_TYPE_LOOKUP = { + Base64: 0, Hex: 1, String: 2, Raw: 3 +}; +/** + * Lookup table for Blowfish modes. + */ +const BLOWFISH_MODE_LOOKUP = { + ECB: 0, CBC: 1, PCBC: 2, CFB: 3, OFB: 4, CTR: 5 +}; + + +/** + * Blowfish Encrypt operation + */ +class BlowfishEncrypt extends Operation { + + /** + * BlowfishEncrypt constructor + */ + constructor() { + super(); + + this.name = "Blowfish Encrypt"; + this.module = "Ciphers"; + this.description = "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "PCBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Base64", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length === 0) return "Enter a key"; + + input = Utils.convertToByteString(input, inputType); + + Blowfish.setIV(toBase64(iv), 0); + + const enc = Blowfish.encrypt(input, key, { + outputType: BLOWFISH_OUTPUT_TYPE_LOOKUP[outputType], + cipherMode: BLOWFISH_MODE_LOOKUP[mode] + }); + + return outputType === "Raw" ? Utils.byteArrayToChars(enc) : enc ; + } + +} + +export default BlowfishEncrypt; diff --git a/src/core/vendor/Blowfish.mjs b/src/core/vendor/Blowfish.mjs new file mode 100644 index 00000000..f60fb90f --- /dev/null +++ b/src/core/vendor/Blowfish.mjs @@ -0,0 +1,652 @@ +/** + Blowfish.js from Dojo Toolkit 1.8.1 (https://github.com/dojo/dojox/tree/1.8/encoding) + Extracted by Sladex (xslade@gmail.com) + Shoehorned into working with mjs for CyberChef by Matt C (matt@artemisbot.uk) + + @license BSD + ======================================================================== + The "New" BSD License: + ********************** + + Copyright (c) 2005-2016, The Dojo Foundation + 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 the Dojo Foundation 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. + */ + +let crypto = {}; + + + +/* dojo-release-1.8.1/dojox/encoding/crypto/_base.js.uncompressed.js */ + +crypto.cipherModes = { + // summary: + // Enumeration for various cipher modes. + ECB:0, CBC:1, PCBC:2, CFB:3, OFB:4, CTR:5 +}; +crypto.outputTypes = { + // summary: + // Enumeration for input and output encodings. + Base64:0, Hex:1, String:2, Raw:3 +}; + + + +/* dojo-release-1.8.1/dojox/encoding/base64.js.uncompressed.js */ + +var base64 = {}; +var p="="; +var tab="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +base64.encode=function(/* byte[] */ba){ + // summary: + // Encode an array of bytes as a base64-encoded string + var s=[], l=ba.length; + var rm=l%3; + var x=l-rm; + for (var i=0; i>>18)&0x3f)); + s.push(tab.charAt((t>>>12)&0x3f)); + s.push(tab.charAt((t>>>6)&0x3f)); + s.push(tab.charAt(t&0x3f)); + } + // deal with trailers, based on patch from Peter Wood. + switch(rm){ + case 2:{ + var t=ba[i++]<<16|ba[i++]<<8; + s.push(tab.charAt((t>>>18)&0x3f)); + s.push(tab.charAt((t>>>12)&0x3f)); + s.push(tab.charAt((t>>>6)&0x3f)); + s.push(p); + break; + } + case 1:{ + var t=ba[i++]<<16; + s.push(tab.charAt((t>>>18)&0x3f)); + s.push(tab.charAt((t>>>12)&0x3f)); + s.push(p); + s.push(p); + break; + } + } + return s.join(""); // string +}; + +base64.decode=function(/* string */str){ + // summary: + // Convert a base64-encoded string to an array of bytes + var s=str.split(""), out=[]; + var l=s.length; + while(s[--l]==p){ } // strip off trailing padding + for (var i=0; i>>16)&0xff); + out.push((t>>>8)&0xff); + out.push(t&0xff); + } + // strip off any null bytes + while(out[out.length-1]==0){ out.pop(); } + return out; // byte[] +}; + + + +/* dojo-release-1.8.1/dojo/_base/lang.js.uncompressed.js */ + +var lang = {}; +lang.isString = function(it){ + // summary: + // Return true if it is a String + // it: anything + // Item to test. + return (typeof it == "string" || it instanceof String); // Boolean +}; + + + +/* dojo-release-1.8.1/dojo/_base/array.js.uncompressed.js */ + +var arrayUtil = {}; +arrayUtil.map = function(arr, callback, thisObject, Ctr){ + // summary: + // applies callback to each element of arr and returns + // an Array with the results + // arr: Array|String + // the array to iterate on. If a string, operates on + // individual characters. + // callback: Function|String + // a function is invoked with three arguments, (item, index, + // array), and returns a value + // thisObject: Object? + // may be used to scope the call to callback + // returns: Array + // description: + // This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when + // run over sparse arrays, this implementation passes the "holes" in the sparse array to + // the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array. + // For more details, see: + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map + // example: + // | // returns [2, 3, 4, 5] + // | array.map([1, 2, 3, 4], function(item){ return item+1 }); + + // TODO: why do we have a non-standard signature here? do we need "Ctr"? + var i = 0, l = arr && arr.length || 0, out = new (Ctr || Array)(l); + if(l && typeof arr == "string") arr = arr.split(""); + if(typeof callback == "string") callback = cache[callback] || buildFn(callback); + if(thisObject){ + for(; i < l; ++i){ + out[i] = callback.call(thisObject, arr[i], i, arr); + } + }else{ + for(; i < l; ++i){ + out[i] = callback(arr[i], i, arr); + } + } + return out; // Array +}; + + + +/* dojo-release-1.8.1/dojox/encoding/crypto/Blowfish.js.uncompressed.js */ + +/* Blowfish + * Created based on the C# implementation by Marcus Hahn (http://www.hotpixel.net/) + * Unsigned math based on Paul Johnstone and Peter Wood patches. + * 2005-12-08 + */ +crypto.Blowfish = new function(){ + // summary: + // Object for doing Blowfish encryption/decryption. + var POW2=Math.pow(2,2); + var POW3=Math.pow(2,3); + var POW4=Math.pow(2,4); + var POW8=Math.pow(2,8); + var POW16=Math.pow(2,16); + var POW24=Math.pow(2,24); + var iv=null; // CBC mode initialization vector + var boxes={ + p:[ + 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, + 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, + 0x9216d5d9, 0x8979fb1b + ], + s0:[ + 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, + 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, + 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, + 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, + 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, + 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, + 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, + 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, + 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, + 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, + 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, + 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, + 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, + 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, + 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, + 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, + 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, + 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, + 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, + 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, + 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, + 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, + 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, + 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, + 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, + 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, + 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, + 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, + 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, + 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, + 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, + 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a + ], + s1:[ + 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, + 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, + 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, + 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, + 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, + 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, + 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, + 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, + 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, + 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, + 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, + 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, + 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, + 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, + 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, + 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, + 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, + 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, + 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, + 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, + 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, + 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, + 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, + 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, + 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, + 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, + 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, + 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, + 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, + 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, + 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, + 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7 + ], + s2:[ + 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, + 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, + 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, + 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, + 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, + 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, + 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, + 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, + 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, + 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, + 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, + 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, + 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, + 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, + 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, + 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, + 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, + 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, + 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, + 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, + 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, + 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, + 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, + 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, + 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, + 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, + 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, + 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, + 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, + 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, + 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, + 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0 + ], + s3:[ + 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, + 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, + 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, + 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, + 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, + 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, + 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, + 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, + 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, + 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, + 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, + 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, + 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, + 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, + 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, + 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, + 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, + 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, + 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, + 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, + 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, + 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, + 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, + 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, + 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, + 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, + 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, + 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, + 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, + 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, + 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, + 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6 + ] + } +//////////////////////////////////////////////////////////////////////////// +// fixes based on patch submitted by Peter Wood (#5791) + function add(x,y){ + return (((x>>0x10)+(y>>0x10)+(((x&0xffff)+(y&0xffff))>>0x10))<<0x10)|(((x&0xffff)+(y&0xffff))&0xffff); + } + function xor(x,y){ + return (((x>>0x10)^(y>>0x10))<<0x10)|(((x&0xffff)^(y&0xffff))&0xffff); + } + + function $(v, box){ + var d=box.s3[v&0xff]; v>>=8; + var c=box.s2[v&0xff]; v>>=8; + var b=box.s1[v&0xff]; v>>=8; + var a=box.s0[v&0xff]; + + var r = (((a>>0x10)+(b>>0x10)+(((a&0xffff)+(b&0xffff))>>0x10))<<0x10)|(((a&0xffff)+(b&0xffff))&0xffff); + r = (((r>>0x10)^(c>>0x10))<<0x10)|(((r&0xffff)^(c&0xffff))&0xffff); + return (((r>>0x10)+(d>>0x10)+(((r&0xffff)+(d&0xffff))>>0x10))<<0x10)|(((r&0xffff)+(d&0xffff))&0xffff); + } +//////////////////////////////////////////////////////////////////////////// + function eb(o, box){ + // TODO: see if this can't be made more efficient + var l=o.left; + var r=o.right; + l=xor(l,box.p[0]); + r=xor(r,xor($(l,box),box.p[1])); + l=xor(l,xor($(r,box),box.p[2])); + r=xor(r,xor($(l,box),box.p[3])); + l=xor(l,xor($(r,box),box.p[4])); + r=xor(r,xor($(l,box),box.p[5])); + l=xor(l,xor($(r,box),box.p[6])); + r=xor(r,xor($(l,box),box.p[7])); + l=xor(l,xor($(r,box),box.p[8])); + r=xor(r,xor($(l,box),box.p[9])); + l=xor(l,xor($(r,box),box.p[10])); + r=xor(r,xor($(l,box),box.p[11])); + l=xor(l,xor($(r,box),box.p[12])); + r=xor(r,xor($(l,box),box.p[13])); + l=xor(l,xor($(r,box),box.p[14])); + r=xor(r,xor($(l,box),box.p[15])); + l=xor(l,xor($(r,box),box.p[16])); + o.right=l; + o.left=xor(r,box.p[17]); + } + + function db(o, box){ + var l=o.left; + var r=o.right; + l=xor(l,box.p[17]); + r=xor(r,xor($(l,box),box.p[16])); + l=xor(l,xor($(r,box),box.p[15])); + r=xor(r,xor($(l,box),box.p[14])); + l=xor(l,xor($(r,box),box.p[13])); + r=xor(r,xor($(l,box),box.p[12])); + l=xor(l,xor($(r,box),box.p[11])); + r=xor(r,xor($(l,box),box.p[10])); + l=xor(l,xor($(r,box),box.p[9])); + r=xor(r,xor($(l,box),box.p[8])); + l=xor(l,xor($(r,box),box.p[7])); + r=xor(r,xor($(l,box),box.p[6])); + l=xor(l,xor($(r,box),box.p[5])); + r=xor(r,xor($(l,box),box.p[4])); + l=xor(l,xor($(r,box),box.p[3])); + r=xor(r,xor($(l,box),box.p[2])); + l=xor(l,xor($(r,box),box.p[1])); + o.right=l; + o.left=xor(r,box.p[0]); + } + + // Note that we aren't caching contexts here; it might take a little longer + // but we should be more secure this way. + function init(key){ + var k=key; + if(lang.isString(k)){ + k = arrayUtil.map(k.split(""), function(item){ + return item.charCodeAt(0) & 0xff; + }); + } + + // init the boxes + var pos=0, data=0, res={ left:0, right:0 }, i, j, l; + var box = { + p: arrayUtil.map(boxes.p.slice(0), function(item){ + var l=k.length, j; + for(j=0; j<4; j++){ data=(data*POW8)|k[pos++ % l]; } + return (((item>>0x10)^(data>>0x10))<<0x10)|(((item&0xffff)^(data&0xffff))&0xffff); + }), + s0:boxes.s0.slice(0), + s1:boxes.s1.slice(0), + s2:boxes.s2.slice(0), + s3:boxes.s3.slice(0) + }; + + // encrypt p and the s boxes + for(i=0, l=box.p.length; i> 3, pos=0, o={}, isCBC=(mode==crypto.cipherModes.CBC); + var vector={left:iv.left||null, right:iv.right||null}; + for(var i=0; i>0x10)^(vector.left>>0x10))<<0x10)|(((o.left&0xffff)^(vector.left&0xffff))&0xffff); + o.right=(((o.right>>0x10)^(vector.right>>0x10))<<0x10)|(((o.right&0xffff)^(vector.right&0xffff))&0xffff); + } + + eb(o, bx); // encrypt the block + + if(isCBC){ + vector.left=o.left; + vector.right=o.right; + } + + cipher.push((o.left>>24)&0xff); + cipher.push((o.left>>16)&0xff); + cipher.push((o.left>>8)&0xff); + cipher.push(o.left&0xff); + cipher.push((o.right>>24)&0xff); + cipher.push((o.right>>16)&0xff); + cipher.push((o.right>>8)&0xff); + cipher.push(o.right&0xff); + pos+=8; + } + + switch(out){ + case crypto.outputTypes.Hex:{ + return arrayUtil.map(cipher, function(item){ + return (item<=0xf?'0':'')+item.toString(16); + }).join(""); // string + } + case crypto.outputTypes.String:{ + return cipher.join(""); // string + } + case crypto.outputTypes.Raw:{ + return cipher; // array + } + default:{ + return base64.encode(cipher); // string + } + } + }; + + this.decrypt = function(/* string */ciphertext, /* string */key, /* object? */ao){ + // summary: + // decrypts ciphertext using key; allows specification of how ciphertext is encoded via ao. + var ip=crypto.outputTypes.Base64; + var mode=crypto.cipherModes.ECB; + if (ao){ + if (ao.outputType) ip=ao.outputType; + if (ao.cipherMode) mode=ao.cipherMode; + } + var bx = init(key); + var pt=[]; + + var c=null; + switch(ip){ + case crypto.outputTypes.Hex:{ + c = []; + for(var i=0, l=ciphertext.length-1; i> 3, pos=0, o={}, isCBC=(mode==crypto.cipherModes.CBC); + var vector={left:iv.left||null, right:iv.right||null}; + for(var i=0; i>0x10)^(vector.left>>0x10))<<0x10)|(((o.left&0xffff)^(vector.left&0xffff))&0xffff); + o.right=(((o.right>>0x10)^(vector.right>>0x10))<<0x10)|(((o.right&0xffff)^(vector.right&0xffff))&0xffff); + vector.left=left; + vector.right=right; + } + + pt.push((o.left>>24)&0xff); + pt.push((o.left>>16)&0xff); + pt.push((o.left>>8)&0xff); + pt.push(o.left&0xff); + pt.push((o.right>>24)&0xff); + pt.push((o.right>>16)&0xff); + pt.push((o.right>>8)&0xff); + pt.push(o.right&0xff); + pos+=8; + } + + // check for padding, and remove. + if(pt[pt.length-1]==pt[pt.length-2]||pt[pt.length-1]==0x01){ + var n=pt[pt.length-1]; + pt.splice(pt.length-n, n); + } + + // convert to string + return arrayUtil.map(pt, function(item){ + return String.fromCharCode(item); + }).join(""); // string + }; + + this.setIV("0000000000000000", crypto.outputTypes.Hex); +}(); + +export const Blowfish = crypto.Blowfish; From 46b8b2fa7e9e881af3237542b5e3b2fc197196a9 Mon Sep 17 00:00:00 2001 From: Matt C Date: Wed, 23 May 2018 18:23:03 +0100 Subject: [PATCH 12/23] Converted DES and TripleDES ops --- src/core/operations/DESDecrypt.mjs | 92 +++++++ src/core/operations/DESEncrypt.mjs | 89 +++++++ src/core/operations/TripleDESDecrypt.mjs | 93 +++++++ src/core/operations/TripleDESEncrypt.mjs | 89 +++++++ src/core/operations/legacy/Cipher.js | 324 ----------------------- 5 files changed, 363 insertions(+), 324 deletions(-) create mode 100644 src/core/operations/DESDecrypt.mjs create mode 100644 src/core/operations/DESEncrypt.mjs create mode 100644 src/core/operations/TripleDESDecrypt.mjs create mode 100644 src/core/operations/TripleDESEncrypt.mjs diff --git a/src/core/operations/DESDecrypt.mjs b/src/core/operations/DESDecrypt.mjs new file mode 100644 index 00000000..4c8a37ce --- /dev/null +++ b/src/core/operations/DESDecrypt.mjs @@ -0,0 +1,92 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * DES Decrypt operation + */ +class DESDecrypt extends Operation { + + /** + * DESDecrypt constructor + */ + constructor() { + super(); + + this.name = "DES Decrypt"; + this.module = "Ciphers"; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.

Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length !== 8) { + return `Invalid key length: ${key.length} bytes +DES uses a key length of 8 bytes (64 bits). +Triple DES uses a key length of 24 bytes (192 bits).`; + } + + input = Utils.convertToByteString(input, inputType); + + const decipher = forge.cipher.createDecipher("DES-" + mode, key); + decipher.start({iv: iv}); + decipher.update(forge.util.createBuffer(input)); + const result = decipher.finish(); + + if (result) { + return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); + } else { + return "Unable to decrypt input with these parameters."; + } + } + +} + +export default DESDecrypt; diff --git a/src/core/operations/DESEncrypt.mjs b/src/core/operations/DESEncrypt.mjs new file mode 100644 index 00000000..07a7d722 --- /dev/null +++ b/src/core/operations/DESEncrypt.mjs @@ -0,0 +1,89 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * DES Encrypt operation + */ +class DESEncrypt extends Operation { + + /** + * DESEncrypt constructor + */ + constructor() { + super(); + + this.name = "DES Encrypt"; + this.module = "Ciphers"; + this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.

Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).

You can generate a password-based key using one of the KDF operations.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length !== 8) { + return `Invalid key length: ${key.length} bytes + +DES uses a key length of 8 bytes (64 bits). +Triple DES uses a key length of 24 bytes (192 bits).`; + } + + input = Utils.convertToByteString(input, inputType); + + const cipher = forge.cipher.createCipher("DES-" + mode, key); + cipher.start({iv: iv}); + cipher.update(forge.util.createBuffer(input)); + cipher.finish(); + + return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); + } + +} + +export default DESEncrypt; diff --git a/src/core/operations/TripleDESDecrypt.mjs b/src/core/operations/TripleDESDecrypt.mjs new file mode 100644 index 00000000..db9e6cd2 --- /dev/null +++ b/src/core/operations/TripleDESDecrypt.mjs @@ -0,0 +1,93 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * Triple DES Decrypt operation + */ +class TripleDESDecrypt extends Operation { + + /** + * TripleDESDecrypt constructor + */ + constructor() { + super(); + + this.name = "Triple DES Decrypt"; + this.module = "Ciphers"; + this.description = "Triple DES applies DES three times to each block to increase key size.

Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length !== 24) { + return `Invalid key length: ${key.length} bytes + +Triple DES uses a key length of 24 bytes (192 bits). +DES uses a key length of 8 bytes (64 bits).`; + } + + input = Utils.convertToByteString(input, inputType); + + const decipher = forge.cipher.createDecipher("3DES-" + mode, key); + decipher.start({iv: iv}); + decipher.update(forge.util.createBuffer(input)); + const result = decipher.finish(); + + if (result) { + return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); + } else { + return "Unable to decrypt input with these parameters."; + } + } + +} + +export default TripleDESDecrypt; diff --git a/src/core/operations/TripleDESEncrypt.mjs b/src/core/operations/TripleDESEncrypt.mjs new file mode 100644 index 00000000..c1618ca5 --- /dev/null +++ b/src/core/operations/TripleDESEncrypt.mjs @@ -0,0 +1,89 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * Triple DES Encrypt operation + */ +class TripleDESEncrypt extends Operation { + + /** + * TripleDESEncrypt constructor + */ + constructor() { + super(); + + this.name = "Triple DES Encrypt"; + this.module = "Ciphers"; + this.description = "Triple DES applies DES three times to each block to increase key size.

Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).

You can generate a password-based key using one of the KDF operations.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Mode", + "type": "option", + "value": ["CBC", "CFB", "OFB", "CTR", "ECB"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteArray(args[1].string, args[1].option), + mode = args[2], + inputType = args[3], + outputType = args[4]; + + if (key.length !== 24) { + return `Invalid key length: ${key.length} bytes + +Triple DES uses a key length of 24 bytes (192 bits). +DES uses a key length of 8 bytes (64 bits).`; + } + + input = Utils.convertToByteString(input, inputType); + + const cipher = forge.cipher.createCipher("3DES-" + mode, key); + cipher.start({iv: iv}); + cipher.update(forge.util.createBuffer(input)); + cipher.finish(); + + return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); + } + +} + +export default TripleDESEncrypt; diff --git a/src/core/operations/legacy/Cipher.js b/src/core/operations/legacy/Cipher.js index 197560c1..3a81281d 100755 --- a/src/core/operations/legacy/Cipher.js +++ b/src/core/operations/legacy/Cipher.js @@ -1,9 +1,5 @@ import Utils from "../Utils.js"; -import {toBase64} from "../lib/Base64"; -import {toHexFast} from "../lib/Hex"; -import CryptoJS from "crypto-js"; import forge from "imports-loader?jQuery=>null!node-forge/dist/forge.min.js"; -import {blowfish as Blowfish} from "sladex-blowfish"; import BigNumber from "bignumber.js"; @@ -38,240 +34,6 @@ const Cipher = { * @default */ IO_FORMAT4: ["Hex", "Raw"], - /** - * @constant - * @default - */ - AES_MODES: ["CBC", "CFB", "OFB", "CTR", "GCM", "ECB"], - - /** - * AES Encrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runAesEnc: function (input, args) { - const key = Utils.convertToByteArray(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if ([16, 24, 32].indexOf(key.length) < 0) { - return `Invalid key length: ${key.length} bytes - -The following algorithms will be used based on the size of the key: - 16 bytes = AES-128 - 24 bytes = AES-192 - 32 bytes = AES-256`; - } - - input = Utils.convertToByteString(input, inputType); - - const cipher = forge.cipher.createCipher("AES-" + mode, key); - cipher.start({iv: iv}); - cipher.update(forge.util.createBuffer(input)); - cipher.finish(); - - if (outputType === "Hex") { - if (mode === "GCM") { - return cipher.output.toHex() + "\n\n" + - "Tag: " + cipher.mode.tag.toHex(); - } - return cipher.output.toHex(); - } else { - if (mode === "GCM") { - return cipher.output.getBytes() + "\n\n" + - "Tag: " + cipher.mode.tag.getBytes(); - } - return cipher.output.getBytes(); - } - }, - - - /** - * AES Decrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runAesDec: function (input, args) { - const key = Utils.convertToByteArray(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4], - gcmTag = Utils.convertToByteString(args[5].string, args[5].option); - - if ([16, 24, 32].indexOf(key.length) < 0) { - return `Invalid key length: ${key.length} bytes - -The following algorithms will be used based on the size of the key: - 16 bytes = AES-128 - 24 bytes = AES-192 - 32 bytes = AES-256`; - } - - input = Utils.convertToByteString(input, inputType); - - const decipher = forge.cipher.createDecipher("AES-" + mode, key); - decipher.start({ - iv: iv, - tag: gcmTag - }); - decipher.update(forge.util.createBuffer(input)); - const result = decipher.finish(); - - if (result) { - return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); - } else { - return "Unable to decrypt input with these parameters."; - } - }, - - - /** - * @constant - * @default - */ - DES_MODES: ["CBC", "CFB", "OFB", "CTR", "ECB"], - - /** - * DES Encrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runDesEnc: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length !== 8) { - return `Invalid key length: ${key.length} bytes - -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`; - } - - input = Utils.convertToByteString(input, inputType); - - const cipher = forge.cipher.createCipher("DES-" + mode, key); - cipher.start({iv: iv}); - cipher.update(forge.util.createBuffer(input)); - cipher.finish(); - - return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); - }, - - - /** - * DES Decrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runDesDec: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length !== 8) { - return `Invalid key length: ${key.length} bytes - -DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`; - } - - input = Utils.convertToByteString(input, inputType); - - const decipher = forge.cipher.createDecipher("DES-" + mode, key); - decipher.start({iv: iv}); - decipher.update(forge.util.createBuffer(input)); - const result = decipher.finish(); - - if (result) { - return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); - } else { - return "Unable to decrypt input with these parameters."; - } - }, - - - /** - * Triple DES Encrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runTripleDesEnc: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length !== 24) { - return `Invalid key length: ${key.length} bytes - -Triple DES uses a key length of 24 bytes (192 bits). -DES uses a key length of 8 bytes (64 bits).`; - } - - input = Utils.convertToByteString(input, inputType); - - const cipher = forge.cipher.createCipher("3DES-" + mode, key); - cipher.start({iv: iv}); - cipher.update(forge.util.createBuffer(input)); - cipher.finish(); - - return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); - }, - - - /** - * Triple DES Decrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runTripleDesDec: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length !== 24) { - return `Invalid key length: ${key.length} bytes - -Triple DES uses a key length of 24 bytes (192 bits). -DES uses a key length of 8 bytes (64 bits).`; - } - - input = Utils.convertToByteString(input, inputType); - - const decipher = forge.cipher.createDecipher("3DES-" + mode, key); - decipher.start({iv: iv}); - decipher.update(forge.util.createBuffer(input)); - const result = decipher.finish(); - - if (result) { - return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); - } else { - return "Unable to decrypt input with these parameters."; - } - }, /** @@ -322,92 +84,6 @@ DES uses a key length of 8 bytes (64 bits).`; }, - /** - * @constant - * @default - */ - BLOWFISH_MODES: ["CBC", "PCBC", "CFB", "OFB", "CTR", "ECB"], - /** - * @constant - * @default - */ - BLOWFISH_OUTPUT_TYPES: ["Hex", "Base64", "Raw"], - - /** - * Lookup table for Blowfish output types. - * - * @private - */ - _BLOWFISH_OUTPUT_TYPE_LOOKUP: { - Base64: 0, Hex: 1, String: 2, Raw: 3 - }, - /** - * Lookup table for Blowfish modes. - * - * @private - */ - _BLOWFISH_MODE_LOOKUP: { - ECB: 0, CBC: 1, PCBC: 2, CFB: 3, OFB: 4, CTR: 5 - }, - - /** - * Blowfish Encrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBlowfishEnc: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length === 0) return "Enter a key"; - - input = Utils.convertToByteString(input, inputType); - - Blowfish.setIV(toBase64(iv), 0); - - const enc = Blowfish.encrypt(input, key, { - outputType: Cipher._BLOWFISH_OUTPUT_TYPE_LOOKUP[outputType], - cipherMode: Cipher._BLOWFISH_MODE_LOOKUP[mode] - }); - - return outputType === "Raw" ? Utils.byteArrayToChars(enc) : enc ; - }, - - - /** - * Blowfish Decrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBlowfishDec: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; - - if (key.length === 0) return "Enter a key"; - - input = inputType === "Raw" ? Utils.strToByteArray(input) : input; - - Blowfish.setIV(toBase64(iv), 0); - - const result = Blowfish.decrypt(input, key, { - outputType: Cipher._BLOWFISH_OUTPUT_TYPE_LOOKUP[inputType], // This actually means inputType. The library is weird. - cipherMode: Cipher._BLOWFISH_MODE_LOOKUP[mode] - }); - - return outputType === "Hex" ? toHexFast(Utils.strToByteArray(result)) : result; - }, - - /** * @constant * @default From 9ffab374dbf8cc580aa8e8e644e0fc14a033d127 Mon Sep 17 00:00:00 2001 From: Matt C Date: Wed, 23 May 2018 18:31:26 +0100 Subject: [PATCH 13/23] Converted PBKDF2 and RC2, enabled tests, deleted legacy Cipher file Also made DESDecrypt test pass --- src/core/operations/DESDecrypt.mjs | 1 + src/core/operations/DerivePBKDF2Key.mjs | 77 +++++++++++ src/core/operations/RC2Decrypt.mjs | 76 ++++++++++ src/core/operations/RC2Encrypt.mjs | 77 +++++++++++ src/core/operations/legacy/Cipher.js | 175 ------------------------ test/index.mjs | 2 +- 6 files changed, 232 insertions(+), 176 deletions(-) create mode 100644 src/core/operations/DerivePBKDF2Key.mjs create mode 100644 src/core/operations/RC2Decrypt.mjs create mode 100644 src/core/operations/RC2Encrypt.mjs delete mode 100755 src/core/operations/legacy/Cipher.js diff --git a/src/core/operations/DESDecrypt.mjs b/src/core/operations/DESDecrypt.mjs index 4c8a37ce..9cdcf5fd 100644 --- a/src/core/operations/DESDecrypt.mjs +++ b/src/core/operations/DESDecrypt.mjs @@ -69,6 +69,7 @@ class DESDecrypt extends Operation { if (key.length !== 8) { return `Invalid key length: ${key.length} bytes + DES uses a key length of 8 bytes (64 bits). Triple DES uses a key length of 24 bytes (192 bits).`; } diff --git a/src/core/operations/DerivePBKDF2Key.mjs b/src/core/operations/DerivePBKDF2Key.mjs new file mode 100644 index 00000000..d3f7fe9a --- /dev/null +++ b/src/core/operations/DerivePBKDF2Key.mjs @@ -0,0 +1,77 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * Derive PBKDF2 key operation + */ +class DerivePBKDF2Key extends Operation { + + /** + * DerivePBKDF2Key constructor + */ + constructor() { + super(); + + this.name = "Derive PBKDF2 key"; + this.module = "Ciphers"; + this.description = "PBKDF2 is a password-based key derivation function. It is part of RSA Laboratories' Public-Key Cryptography Standards (PKCS) series, specifically PKCS #5 v2.0, also published as Internet Engineering Task Force's RFC 2898.

In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.

A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.

If you leave the salt argument empty, a random salt will be generated."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Passphrase", + "type": "toggleString", + "value": "", + "toggleValues": ["UTF8", "Latin1", "Hex", "Base64"] + }, + { + "name": "Key size", + "type": "number", + "value": 128 + }, + { + "name": "Iterations", + "type": "number", + "value": 1 + }, + { + "name": "Hashing function", + "type": "option", + "value": ["SHA1", "SHA256", "SHA384", "SHA512", "MD5"] + }, + { + "name": "Salt", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const passphrase = Utils.convertToByteString(args[0].string, args[0].option), + keySize = args[1], + iterations = args[2], + hasher = args[3], + salt = Utils.convertToByteString(args[4].string, args[4].option) || + forge.random.getBytesSync(keySize), + derivedKey = forge.pkcs5.pbkdf2(passphrase, salt, iterations, keySize / 8, hasher.toLowerCase()); + + return forge.util.bytesToHex(derivedKey); + } + +} + +export default DerivePBKDF2Key; diff --git a/src/core/operations/RC2Decrypt.mjs b/src/core/operations/RC2Decrypt.mjs new file mode 100644 index 00000000..77dc5da5 --- /dev/null +++ b/src/core/operations/RC2Decrypt.mjs @@ -0,0 +1,76 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + +/** + * RC2 Decrypt operation + */ +class RC2Decrypt extends Operation { + + /** + * RC2Decrypt constructor + */ + constructor() { + super(); + + this.name = "RC2 Decrypt"; + this.module = "Ciphers"; + this.description = "RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. 'RC' stands for 'Rivest Cipher'.

Key: RC2 uses a variable size key.

IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.

Padding: In both CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Hex", "Raw"] + }, + { + "name": "Output", + "type": "option", + "value": ["Raw", "Hex"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3], + decipher = forge.rc2.createDecryptionCipher(key); + + input = Utils.convertToByteString(input, inputType); + + decipher.start(iv || null); + decipher.update(forge.util.createBuffer(input)); + decipher.finish(); + + return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); + } + +} + +export default RC2Decrypt; diff --git a/src/core/operations/RC2Encrypt.mjs b/src/core/operations/RC2Encrypt.mjs new file mode 100644 index 00000000..0c2fcd61 --- /dev/null +++ b/src/core/operations/RC2Encrypt.mjs @@ -0,0 +1,77 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import forge from "node-forge/dist/forge.min.js"; + + +/** + * RC2 Encrypt operation + */ +class RC2Encrypt extends Operation { + + /** + * RC2Encrypt constructor + */ + constructor() { + super(); + + this.name = "RC2 Encrypt"; + this.module = "Ciphers"; + this.description = "RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. 'RC' stands for 'Rivest Cipher'.

Key: RC2 uses a variable size key.

You can generate a password-based key using one of the KDF operations.

IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.

Padding: In both CBC and ECB mode, PKCS#7 padding will be used."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "IV", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"] + }, + { + "name": "Input", + "type": "option", + "value": ["Raw", "Hex"] + }, + { + "name": "Output", + "type": "option", + "value": ["Hex", "Raw"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const key = Utils.convertToByteString(args[0].string, args[0].option), + iv = Utils.convertToByteString(args[1].string, args[1].option), + inputType = args[2], + outputType = args[3], + cipher = forge.rc2.createEncryptionCipher(key); + + input = Utils.convertToByteString(input, inputType); + + cipher.start(iv || null); + cipher.update(forge.util.createBuffer(input)); + cipher.finish(); + + return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); + } + +} + +export default RC2Encrypt; diff --git a/src/core/operations/legacy/Cipher.js b/src/core/operations/legacy/Cipher.js deleted file mode 100755 index 3a81281d..00000000 --- a/src/core/operations/legacy/Cipher.js +++ /dev/null @@ -1,175 +0,0 @@ -import Utils from "../Utils.js"; -import forge from "imports-loader?jQuery=>null!node-forge/dist/forge.min.js"; -import BigNumber from "bignumber.js"; - - -/** - * Cipher operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Cipher = { - - /** - * @constant - * @default - */ - IO_FORMAT1: ["Hex", "UTF8", "Latin1", "Base64"], - /** - * @constant - * @default - */ - IO_FORMAT2: ["UTF8", "Latin1", "Hex", "Base64"], - /** - * @constant - * @default - */ - IO_FORMAT3: ["Raw", "Hex"], - /** - * @constant - * @default - */ - IO_FORMAT4: ["Hex", "Raw"], - - - /** - * RC2 Encrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runRc2Enc: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteString(args[1].string, args[1].option), - inputType = args[2], - outputType = args[3], - cipher = forge.rc2.createEncryptionCipher(key); - - input = Utils.convertToByteString(input, inputType); - - cipher.start(iv || null); - cipher.update(forge.util.createBuffer(input)); - cipher.finish(); - - return outputType === "Hex" ? cipher.output.toHex() : cipher.output.getBytes(); - }, - - - /** - * RC2 Decrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runRc2Dec: function (input, args) { - const key = Utils.convertToByteString(args[0].string, args[0].option), - iv = Utils.convertToByteString(args[1].string, args[1].option), - inputType = args[2], - outputType = args[3], - decipher = forge.rc2.createDecryptionCipher(key); - - input = Utils.convertToByteString(input, inputType); - - decipher.start(iv || null); - decipher.update(forge.util.createBuffer(input)); - decipher.finish(); - - return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); - }, - - - /** - * @constant - * @default - */ - KDF_KEY_SIZE: 128, - /** - * @constant - * @default - */ - KDF_ITERATIONS: 1, - /** - * @constant - * @default - */ - HASHERS: ["SHA1", "SHA256", "SHA384", "SHA512", "MD5"], - - /** - * Derive PBKDF2 key operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runPbkdf2: function (input, args) { - const passphrase = Utils.convertToByteString(args[0].string, args[0].option), - keySize = args[1], - iterations = args[2], - hasher = args[3], - salt = Utils.convertToByteString(args[4].string, args[4].option) || - forge.random.getBytesSync(keySize), - derivedKey = forge.pkcs5.pbkdf2(passphrase, salt, iterations, keySize / 8, hasher.toLowerCase()); - - return forge.util.bytesToHex(derivedKey); - }, - - - /** - * @constant - * @default - */ - PRNG_BYTES: 32, - /** - * @constant - * @default - */ - PRNG_OUTPUT: ["Hex", "Integer", "Byte array", "Raw"], - - /** - * Pseudo-Random Number Generator operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runPRNG: function(input, args) { - const numBytes = args[0], - outputAs = args[1]; - - let bytes; - - if (ENVIRONMENT_IS_WORKER() && self.crypto) { - bytes = self.crypto.getRandomValues(new Uint8Array(numBytes)); - bytes = Utils.arrayBufferToStr(bytes.buffer); - } else { - bytes = forge.random.getBytesSync(numBytes); - } - - let value = new BigNumber(0), - i; - - switch (outputAs) { - case "Hex": - return forge.util.bytesToHex(bytes); - case "Integer": - for (i = bytes.length - 1; i >= 0; i--) { - value = value.times(256).plus(bytes.charCodeAt(i)); - } - return value.toFixed(); - case "Byte array": - return JSON.stringify(Utils.strToCharcode(bytes)); - case "Raw": - default: - return bytes; - } - }, - -}; - -export default Cipher; diff --git a/test/index.mjs b/test/index.mjs index a20d5fa6..07312fa4 100644 --- a/test/index.mjs +++ b/test/index.mjs @@ -36,7 +36,7 @@ import "./tests/operations/Ciphers"; import "./tests/operations/Checksum"; // import "./tests/operations/Code"; import "./tests/operations/Compress"; -// import "./tests/operations/Crypt"; +import "./tests/operations/Crypt"; import "./tests/operations/DateTime"; import "./tests/operations/Fork"; import "./tests/operations/Jump"; From 95f81ad74018ec312ac78955b467b814ac153af7 Mon Sep 17 00:00:00 2001 From: Matt C Date: Wed, 23 May 2018 18:59:57 +0100 Subject: [PATCH 14/23] Ported Bitwise operations also enabled bitshift tests --- src/core/lib/BitwiseOp.mjs | 117 +++++++++++++++++++++++ src/core/operations/ADD.mjs | 76 +++++++++++++++ src/core/operations/AND.mjs | 76 +++++++++++++++ src/core/operations/NOT.mjs | 66 +++++++++++++ src/core/operations/OR.mjs | 76 +++++++++++++++ src/core/operations/SUB.mjs | 76 +++++++++++++++ src/core/operations/XOR.mjs | 87 +++++++++++++++++ src/core/operations/XORBruteForce.mjs | 132 ++++++++++++++++++++++++++ test/index.mjs | 2 +- 9 files changed, 707 insertions(+), 1 deletion(-) create mode 100644 src/core/lib/BitwiseOp.mjs create mode 100644 src/core/operations/ADD.mjs create mode 100644 src/core/operations/AND.mjs create mode 100644 src/core/operations/NOT.mjs create mode 100644 src/core/operations/OR.mjs create mode 100644 src/core/operations/SUB.mjs create mode 100644 src/core/operations/XOR.mjs create mode 100644 src/core/operations/XORBruteForce.mjs diff --git a/src/core/lib/BitwiseOp.mjs b/src/core/lib/BitwiseOp.mjs new file mode 100644 index 00000000..b7cf7c97 --- /dev/null +++ b/src/core/lib/BitwiseOp.mjs @@ -0,0 +1,117 @@ +/** + * Bitwise operation resources. + * + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2018 + * @license Apache-2.0 + */ + +/** + * Runs bitwise operations across the input data. + * + * @param {byteArray} input + * @param {byteArray} key + * @param {function} func - The bitwise calculation to carry out + * @param {boolean} nullPreserving + * @param {string} scheme + * @returns {byteArray} + */ +export function bitOp (input, key, func, nullPreserving, scheme) { + if (!key || !key.length) key = [0]; + const result = []; + let x = null, + k = null, + o = null; + + for (let i = 0; i < input.length; i++) { + k = key[i % key.length]; + o = input[i]; + x = nullPreserving && (o === 0 || o === k) ? o : func(o, k); + result.push(x); + if (scheme && + scheme !== "Standard" && + !(nullPreserving && (o === 0 || o === k))) { + switch (scheme) { + case "Input differential": + key[i % key.length] = x; + break; + case "Output differential": + key[i % key.length] = o; + break; + } + } + } + + return result; +} + +/** + * XOR bitwise calculation. + * + * @param {number} operand + * @param {number} key + * @returns {number} + */ +export function xor(operand, key) { + return operand ^ key; +} + + +/** + * NOT bitwise calculation. + * + * @param {number} operand + * @returns {number} + */ +export function not(operand, _) { + return ~operand & 0xff; +} + + +/** + * AND bitwise calculation. + * + * @param {number} operand + * @param {number} key + * @returns {number} + */ +export function and(operand, key) { + return operand & key; +} + + +/** + * OR bitwise calculation. + * + * @param {number} operand + * @param {number} key + * @returns {number} + */ +export function or(operand, key) { + return operand | key; +} + + +/** + * ADD bitwise calculation. + * + * @param {number} operand + * @param {number} key + * @returns {number} + */ +export function add(operand, key) { + return (operand + key) % 256; +} + + +/** + * SUB bitwise calculation. + * + * @param {number} operand + * @param {number} key + * @returns {number} + */ +export function sub(operand, key) { + const result = operand - key; + return (result < 0) ? 256 + result : result; +} diff --git a/src/core/operations/ADD.mjs b/src/core/operations/ADD.mjs new file mode 100644 index 00000000..7e6ad9d5 --- /dev/null +++ b/src/core/operations/ADD.mjs @@ -0,0 +1,76 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, add } from "../lib/BitwiseOp"; + +/** + * ADD operation + */ +class ADD extends Operation { + + /** + * ADD constructor + */ + constructor() { + super(); + + this.name = "ADD"; + this.module = "Default"; + this.description = "ADD the input with the given key (e.g. fe023da5), MOD 255"; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "Base64", "UTF8", "Latin1"] + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string || "", args[0].option); + + return bitOp(input, key, add); + } + + /** + * Highlight ADD + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight ADD in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default ADD; diff --git a/src/core/operations/AND.mjs b/src/core/operations/AND.mjs new file mode 100644 index 00000000..4a062725 --- /dev/null +++ b/src/core/operations/AND.mjs @@ -0,0 +1,76 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, and } from "../lib/BitwiseOp"; + +/** + * AND operation + */ +class AND extends Operation { + + /** + * AND constructor + */ + constructor() { + super(); + + this.name = "AND"; + this.module = "Default"; + this.description = "AND the input with the given key.
e.g. fe023da5"; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "Base64", "UTF8", "Latin1"] + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string || "", args[0].option); + + return bitOp(input, key, and); + } + + /** + * Highlight AND + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight AND in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default AND; diff --git a/src/core/operations/NOT.mjs b/src/core/operations/NOT.mjs new file mode 100644 index 00000000..e0352dd0 --- /dev/null +++ b/src/core/operations/NOT.mjs @@ -0,0 +1,66 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import { bitOp, not } from "../lib/BitwiseOp"; + +/** + * NOT operation + */ +class NOT extends Operation { + + /** + * NOT constructor + */ + constructor() { + super(); + + this.name = "NOT"; + this.module = "Default"; + this.description = "Returns the inverse of each byte."; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = []; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + return bitOp(input, null, not); + } + + /** + * Highlight NOT + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight NOT in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default NOT; diff --git a/src/core/operations/OR.mjs b/src/core/operations/OR.mjs new file mode 100644 index 00000000..33bb2f63 --- /dev/null +++ b/src/core/operations/OR.mjs @@ -0,0 +1,76 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, or } from "../lib/BitwiseOp"; + +/** + * OR operation + */ +class OR extends Operation { + + /** + * OR constructor + */ + constructor() { + super(); + + this.name = "OR"; + this.module = "Default"; + this.description = "OR the input with the given key.
e.g. fe023da5"; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "Base64", "UTF8", "Latin1"] + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string || "", args[0].option); + + return bitOp(input, key, or); + } + + /** + * Highlight OR + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight OR in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default OR; diff --git a/src/core/operations/SUB.mjs b/src/core/operations/SUB.mjs new file mode 100644 index 00000000..79ce95d0 --- /dev/null +++ b/src/core/operations/SUB.mjs @@ -0,0 +1,76 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, sub } from "../lib/BitwiseOp"; + +/** + * SUB operation + */ +class SUB extends Operation { + + /** + * SUB constructor + */ + constructor() { + super(); + + this.name = "SUB"; + this.module = "Default"; + this.description = "SUB the input with the given key (e.g. fe023da5), MOD 255"; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "Base64", "UTF8", "Latin1"] + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string || "", args[0].option); + + return bitOp(input, key, sub); + } + + /** + * Highlight SUB + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight SUB in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default SUB; diff --git a/src/core/operations/XOR.mjs b/src/core/operations/XOR.mjs new file mode 100644 index 00000000..ae35eab7 --- /dev/null +++ b/src/core/operations/XOR.mjs @@ -0,0 +1,87 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, xor } from "../lib/BitwiseOp"; + +/** + * XOR operation + */ +class XOR extends Operation { + + /** + * XOR constructor + */ + constructor() { + super(); + + this.name = "XOR"; + this.module = "Default"; + this.description = "XOR the input with the given key.
e.g. fe023da5

Options
Null preserving: If the current byte is 0x00 or the same as the key, skip it.

Scheme:
  • Standard - key is unchanged after each round
  • Input differential - key is set to the value of the previous unprocessed byte
  • Output differential - key is set to the value of the previous processed byte
"; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = [ + { + "name": "Key", + "type": "toggleString", + "value": "", + "toggleValues": ["Hex", "Base64", "UTF8", "Latin1"] + }, + { + "name": "Scheme", + "type": "option", + "value": ["Standard", "Input differential", "Output differential"] + }, + { + "name": "Null preserving", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + const key = Utils.convertToByteArray(args[0].string || "", args[0].option), + [, scheme, nullPreserving] = args; + + return bitOp(input, key, xor, nullPreserving, scheme); + } + + /** + * Highlight XOR + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight XOR in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default XOR; diff --git a/src/core/operations/XORBruteForce.mjs b/src/core/operations/XORBruteForce.mjs new file mode 100644 index 00000000..4ceeb44a --- /dev/null +++ b/src/core/operations/XORBruteForce.mjs @@ -0,0 +1,132 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; +import { bitOp, xor } from "../lib/BitwiseOp"; +import { toHex } from "../lib/Hex"; + +/** + * XOR Brute Force operation + */ +class XORBruteForce extends Operation { + + /** + * XORBruteForce constructor + */ + constructor() { + super(); + + this.name = "XOR Brute Force"; + this.module = "Default"; + this.description = "Enumerate all possible XOR solutions. Current maximum key length is 2 due to browser performance.

Optionally enter a string that you expect to find in the plaintext to filter results (crib)."; + this.inputType = "byteArray"; + this.outputType = "string"; + this.args = [ + { + "name": "Key length", + "type": "number", + "value": 1 + }, + { + "name": "Sample length", + "type": "number", + "value": 100 + }, + { + "name": "Sample offset", + "type": "number", + "value": 0 + }, + { + "name": "Scheme", + "type": "option", + "value": ["Standard", "Input differential", "Output differential"] + }, + { + "name": "Null preserving", + "type": "boolean", + "value": false + }, + { + "name": "Print key", + "type": "boolean", + "value": true + }, + { + "name": "Output as hex", + "type": "boolean", + "value": false + }, + { + "name": "Crib (known plaintext string)", + "type": "binaryString", + "value": "" + } + ]; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [keyLength, sampleLength, sampleOffset, scheme, nullPreserving, printKey, outputHex, /* ignore element */] = args, //eslint-disable-line array-bracket-spacing + crib = args[7].toLowerCase(); + + const output = []; + let result, + resultUtf8, + record = ""; + + input = input.slice(sampleOffset, sampleOffset + sampleLength); + + if (ENVIRONMENT_IS_WORKER()) + self.sendStatusMessage("Calculating " + Math.pow(256, keyLength) + " values..."); + + /** + * Converts an integer to an array of bytes expressing that number. + * + * @param {number} int + * @param {number} len - Length of the resulting array + * @returns {array} + */ + const intToByteArray = (int, len) => { + const res = Array(len).fill(0); + for (let i = len - 1; i >= 0; i--) { + res[i] = int & 0xff; + int = int >>> 8; + } + return res; + }; + + for (let key = 1, l = Math.pow(256, keyLength); key < l; key++) { + if (key % 10000 === 0 && ENVIRONMENT_IS_WORKER()) { + self.sendStatusMessage("Calculating " + l + " values... " + Math.floor(key / l * 100) + "%"); + } + + result = bitOp(input, intToByteArray(key, keyLength), xor, nullPreserving, scheme); + resultUtf8 = Utils.byteArrayToUtf8(result); + record = ""; + + if (crib && resultUtf8.toLowerCase().indexOf(crib) < 0) continue; + if (printKey) record += "Key = " + Utils.hex(key, (2*keyLength)) + ": "; + if (outputHex) { + record += toHex(result); + } else { + record += Utils.printable(resultUtf8, false); + } + + output.push(record); + } + + return output.join("\n"); + } + +} + +export default XORBruteForce; diff --git a/test/index.mjs b/test/index.mjs index 07312fa4..c03cf046 100644 --- a/test/index.mjs +++ b/test/index.mjs @@ -27,7 +27,7 @@ import TestRegister from "./TestRegister"; import "./tests/operations/Base58"; import "./tests/operations/Base64"; import "./tests/operations/BCD"; -// import "./tests/operations/BitwiseOp"; +import "./tests/operations/BitwiseOp"; import "./tests/operations/BSON"; import "./tests/operations/ByteRepr"; import "./tests/operations/CartesianProduct"; From 176e83a79f7f1c26e9c53e322692e84db918acc5 Mon Sep 17 00:00:00 2001 From: Matt C Date: Wed, 23 May 2018 20:36:29 +0100 Subject: [PATCH 15/23] Converted JS operations Deleted legacy files, neatened args in other ported ops --- src/core/operations/BlowfishDecrypt.mjs | 4 +- src/core/operations/BlowfishEncrypt.mjs | 4 +- src/core/operations/DESDecrypt.mjs | 4 +- src/core/operations/DESEncrypt.mjs | 4 +- src/core/operations/DeriveEVPKey.mjs | 3 +- src/core/operations/DerivePBKDF2Key.mjs | 4 +- src/core/operations/JavaScriptBeautify.mjs | 94 ++++++ src/core/operations/JavaScriptMinify.mjs | 57 ++++ src/core/operations/JavaScriptParser.mjs | 77 +++++ src/core/operations/RC2Decrypt.mjs | 3 +- src/core/operations/RC2Encrypt.mjs | 3 +- src/core/operations/legacy/BitwiseOp.js | 369 --------------------- src/core/operations/legacy/JS.js | 164 --------- 13 files changed, 236 insertions(+), 554 deletions(-) create mode 100644 src/core/operations/JavaScriptBeautify.mjs create mode 100644 src/core/operations/JavaScriptMinify.mjs create mode 100644 src/core/operations/JavaScriptParser.mjs delete mode 100755 src/core/operations/legacy/BitwiseOp.js delete mode 100755 src/core/operations/legacy/JS.js diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs index 5e155195..95ba415d 100644 --- a/src/core/operations/BlowfishDecrypt.mjs +++ b/src/core/operations/BlowfishDecrypt.mjs @@ -78,9 +78,7 @@ class BlowfishDecrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; + [,, mode, inputType, outputType] = args; if (key.length === 0) return "Enter a key"; diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs index aa0b04e6..7af32bc8 100644 --- a/src/core/operations/BlowfishEncrypt.mjs +++ b/src/core/operations/BlowfishEncrypt.mjs @@ -75,9 +75,7 @@ class BlowfishEncrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; + [,, mode, inputType, outputType] = args; if (key.length === 0) return "Enter a key"; diff --git a/src/core/operations/DESDecrypt.mjs b/src/core/operations/DESDecrypt.mjs index 9cdcf5fd..0894dfb8 100644 --- a/src/core/operations/DESDecrypt.mjs +++ b/src/core/operations/DESDecrypt.mjs @@ -63,9 +63,7 @@ class DESDecrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; + [,, mode, inputType, outputType] = args; if (key.length !== 8) { return `Invalid key length: ${key.length} bytes diff --git a/src/core/operations/DESEncrypt.mjs b/src/core/operations/DESEncrypt.mjs index 07a7d722..ca3f52e5 100644 --- a/src/core/operations/DESEncrypt.mjs +++ b/src/core/operations/DESEncrypt.mjs @@ -63,9 +63,7 @@ class DESEncrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteArray(args[1].string, args[1].option), - mode = args[2], - inputType = args[3], - outputType = args[4]; + [,, mode, inputType, outputType] = args; if (key.length !== 8) { return `Invalid key length: ${key.length} bytes diff --git a/src/core/operations/DeriveEVPKey.mjs b/src/core/operations/DeriveEVPKey.mjs index ad17f0b1..ebab6961 100644 --- a/src/core/operations/DeriveEVPKey.mjs +++ b/src/core/operations/DeriveEVPKey.mjs @@ -63,8 +63,7 @@ class DeriveEVPKey extends Operation { run(input, args) { const passphrase = Utils.convertToByteString(args[0].string, args[0].option), keySize = args[1] / 32, - iterations = args[2], - hasher = args[3], + [,, iterations, hasher, ] = args, //eslint-disable-line array-bracket-spacing salt = Utils.convertToByteString(args[4].string, args[4].option), key = CryptoJS.EvpKDF(passphrase, salt, { keySize: keySize, diff --git a/src/core/operations/DerivePBKDF2Key.mjs b/src/core/operations/DerivePBKDF2Key.mjs index d3f7fe9a..f9c7cf75 100644 --- a/src/core/operations/DerivePBKDF2Key.mjs +++ b/src/core/operations/DerivePBKDF2Key.mjs @@ -62,9 +62,7 @@ class DerivePBKDF2Key extends Operation { */ run(input, args) { const passphrase = Utils.convertToByteString(args[0].string, args[0].option), - keySize = args[1], - iterations = args[2], - hasher = args[3], + [, keySize, iterations, hasher, ] = args, //eslint-disable-line array-bracket-spacing salt = Utils.convertToByteString(args[4].string, args[4].option) || forge.random.getBytesSync(keySize), derivedKey = forge.pkcs5.pbkdf2(passphrase, salt, iterations, keySize / 8, hasher.toLowerCase()); diff --git a/src/core/operations/JavaScriptBeautify.mjs b/src/core/operations/JavaScriptBeautify.mjs new file mode 100644 index 00000000..4c0607d2 --- /dev/null +++ b/src/core/operations/JavaScriptBeautify.mjs @@ -0,0 +1,94 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import escodegen from "escodegen"; +import * as esprima from "esprima"; + +/** + * JavaScript Beautify operation + */ +class JavaScriptBeautify extends Operation { + + /** + * JavaScriptBeautify constructor + */ + constructor() { + super(); + + this.name = "JavaScript Beautify"; + this.module = "Code"; + this.description = "Parses and pretty prints valid JavaScript code. Also works with JavaScript Object Notation (JSON)."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Indent string", + "type": "binaryShortString", + "value": "\\t" + }, + { + "name": "Quotes", + "type": "option", + "value": ["Auto", "Single", "Double"] + }, + { + "name": "Semicolons before closing braces", + "type": "boolean", + "value": true + }, + { + "name": "Include comments", + "type": "boolean", + "value": true + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const beautifyIndent = args[0] || "\\t", + quotes = args[1].toLowerCase(), + [,, beautifySemicolons, beautifyComment] = args; + let result = "", + AST; + + try { + AST = esprima.parseScript(input, { + range: true, + tokens: true, + comment: true + }); + + const options = { + format: { + indent: { + style: beautifyIndent + }, + quotes: quotes, + semicolons: beautifySemicolons, + }, + comment: beautifyComment + }; + + if (options.comment) + AST = escodegen.attachComments(AST, AST.comments, AST.tokens); + + result = escodegen.generate(AST, options); + } catch (e) { + // Leave original error so the user can see the detail + throw "Unable to parse JavaScript.
" + e.message; + } + return result; + } + +} + +export default JavaScriptBeautify; diff --git a/src/core/operations/JavaScriptMinify.mjs b/src/core/operations/JavaScriptMinify.mjs new file mode 100644 index 00000000..9841d5bb --- /dev/null +++ b/src/core/operations/JavaScriptMinify.mjs @@ -0,0 +1,57 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import * as esprima from "esprima"; +import escodegen from "escodegen"; +import esmangle from "esmangle"; + +/** + * JavaScript Minify operation + */ +class JavaScriptMinify extends Operation { + + /** + * JavaScriptMinify constructor + */ + constructor() { + super(); + + this.name = "JavaScript Minify"; + this.module = "Code"; + this.description = "Compresses JavaScript code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + let result = ""; + const AST = esprima.parseScript(input), + optimisedAST = esmangle.optimize(AST, null), + mangledAST = esmangle.mangle(optimisedAST); + + result = escodegen.generate(mangledAST, { + format: { + renumber: true, + hexadecimal: true, + escapeless: true, + compact: true, + semicolons: false, + parentheses: false + } + }); + return result; + } + +} + +export default JavaScriptMinify; diff --git a/src/core/operations/JavaScriptParser.mjs b/src/core/operations/JavaScriptParser.mjs new file mode 100644 index 00000000..047bc730 --- /dev/null +++ b/src/core/operations/JavaScriptParser.mjs @@ -0,0 +1,77 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import * as esprima from "esprima"; + +/** + * JavaScript Parser operation + */ +class JavaScriptParser extends Operation { + + /** + * JavaScriptParser constructor + */ + constructor() { + super(); + + this.name = "JavaScript Parser"; + this.module = "Code"; + this.description = "Returns an Abstract Syntax Tree for valid JavaScript code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Location info", + "type": "boolean", + "value": false + }, + { + "name": "Range info", + "type": "boolean", + "value": false + }, + { + "name": "Include tokens array", + "type": "boolean", + "value": false + }, + { + "name": "Include comments array", + "type": "boolean", + "value": false + }, + { + "name": "Report errors and try to continue", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [parseLoc, parseRange, parseTokens, parseComment, parseTolerant] = args, + options = { + loc: parseLoc, + range: parseRange, + tokens: parseTokens, + comment: parseComment, + tolerant: parseTolerant + }; + let result = {}; + + result = esprima.parseScript(input, options); + return JSON.stringify(result, null, 2); + } + +} + +export default JavaScriptParser; diff --git a/src/core/operations/RC2Decrypt.mjs b/src/core/operations/RC2Decrypt.mjs index 77dc5da5..a8a8a75f 100644 --- a/src/core/operations/RC2Decrypt.mjs +++ b/src/core/operations/RC2Decrypt.mjs @@ -58,8 +58,7 @@ class RC2Decrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteString(args[1].string, args[1].option), - inputType = args[2], - outputType = args[3], + [,, inputType, outputType] = args, decipher = forge.rc2.createDecryptionCipher(key); input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/RC2Encrypt.mjs b/src/core/operations/RC2Encrypt.mjs index 0c2fcd61..bf6642e6 100644 --- a/src/core/operations/RC2Encrypt.mjs +++ b/src/core/operations/RC2Encrypt.mjs @@ -59,8 +59,7 @@ class RC2Encrypt extends Operation { run(input, args) { const key = Utils.convertToByteString(args[0].string, args[0].option), iv = Utils.convertToByteString(args[1].string, args[1].option), - inputType = args[2], - outputType = args[3], + [,, inputType, outputType] = args, cipher = forge.rc2.createEncryptionCipher(key); input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/legacy/BitwiseOp.js b/src/core/operations/legacy/BitwiseOp.js deleted file mode 100755 index 26408096..00000000 --- a/src/core/operations/legacy/BitwiseOp.js +++ /dev/null @@ -1,369 +0,0 @@ -import Utils from "../Utils.js"; -import {toHex} from "../lib/Hex"; - - -/** - * Bitwise operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const BitwiseOp = { - - /** - * Runs bitwise operations across the input data. - * - * @private - * @param {byteArray} input - * @param {byteArray} key - * @param {function} func - The bitwise calculation to carry out - * @param {boolean} nullPreserving - * @param {string} scheme - * @returns {byteArray} - */ - _bitOp: function (input, key, func, nullPreserving, scheme) { - if (!key || !key.length) key = [0]; - let result = [], - x = null, - k = null, - o = null; - - for (let i = 0; i < input.length; i++) { - k = key[i % key.length]; - o = input[i]; - x = nullPreserving && (o === 0 || o === k) ? o : func(o, k); - result.push(x); - if (scheme && - scheme !== "Standard" && - !(nullPreserving && (o === 0 || o === k))) { - switch (scheme) { - case "Input differential": - key[i % key.length] = x; - break; - case "Output differential": - key[i % key.length] = o; - break; - } - } - } - - return result; - }, - - - /** - * @constant - * @default - */ - XOR_PRESERVE_NULLS: false, - /** - * @constant - * @default - */ - XOR_SCHEME: ["Standard", "Input differential", "Output differential"], - /** - * @constant - * @default - */ - KEY_FORMAT: ["Hex", "Base64", "UTF8", "Latin1"], - - /** - * XOR operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runXor: function (input, args) { - const key = Utils.convertToByteArray(args[0].string || "", args[0].option), - scheme = args[1], - nullPreserving = args[2]; - - return BitwiseOp._bitOp(input, key, BitwiseOp._xor, nullPreserving, scheme); - }, - - - /** - * @constant - * @default - */ - XOR_BRUTE_KEY_LENGTH: 1, - /** - * @constant - * @default - */ - XOR_BRUTE_SAMPLE_LENGTH: 100, - /** - * @constant - * @default - */ - XOR_BRUTE_SAMPLE_OFFSET: 0, - /** - * @constant - * @default - */ - XOR_BRUTE_PRINT_KEY: true, - /** - * @constant - * @default - */ - XOR_BRUTE_OUTPUT_HEX: false, - - /** - * XOR Brute Force operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runXorBrute: function (input, args) { - const keyLength = args[0], - sampleLength = args[1], - sampleOffset = args[2], - scheme = args[3], - nullPreserving = args[4], - printKey = args[5], - outputHex = args[6], - crib = args[7].toLowerCase(); - - let output = [], - result, - resultUtf8, - record = ""; - - input = input.slice(sampleOffset, sampleOffset + sampleLength); - - if (ENVIRONMENT_IS_WORKER()) - self.sendStatusMessage("Calculating " + Math.pow(256, keyLength) + " values..."); - - /** - * Converts an integer to an array of bytes expressing that number. - * - * @param {number} int - * @param {number} len - Length of the resulting array - * @returns {array} - */ - const intToByteArray = (int, len) => { - let res = Array(len).fill(0); - for (let i = len - 1; i >= 0; i--) { - res[i] = int & 0xff; - int = int >>> 8; - } - return res; - }; - - for (let key = 1, l = Math.pow(256, keyLength); key < l; key++) { - if (key % 10000 === 0 && ENVIRONMENT_IS_WORKER()) { - self.sendStatusMessage("Calculating " + l + " values... " + Math.floor(key / l * 100) + "%"); - } - - result = BitwiseOp._bitOp(input, intToByteArray(key, keyLength), BitwiseOp._xor, nullPreserving, scheme); - resultUtf8 = Utils.byteArrayToUtf8(result); - record = ""; - - if (crib && resultUtf8.toLowerCase().indexOf(crib) < 0) continue; - if (printKey) record += "Key = " + Utils.hex(key, (2*keyLength)) + ": "; - if (outputHex) { - record += toHex(result); - } else { - record += Utils.printable(resultUtf8, false); - } - - output.push(record); - } - - return output.join("\n"); - }, - - - /** - * NOT operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runNot: function (input, args) { - return BitwiseOp._bitOp(input, null, BitwiseOp._not); - }, - - - /** - * AND operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runAnd: function (input, args) { - const key = Utils.convertToByteArray(args[0].string || "", args[0].option); - - return BitwiseOp._bitOp(input, key, BitwiseOp._and); - }, - - - /** - * OR operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runOr: function (input, args) { - const key = Utils.convertToByteArray(args[0].string || "", args[0].option); - - return BitwiseOp._bitOp(input, key, BitwiseOp._or); - }, - - - /** - * ADD operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runAdd: function (input, args) { - const key = Utils.convertToByteArray(args[0].string || "", args[0].option); - - return BitwiseOp._bitOp(input, key, BitwiseOp._add); - }, - - - /** - * SUB operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runSub: function (input, args) { - const key = Utils.convertToByteArray(args[0].string || "", args[0].option); - - return BitwiseOp._bitOp(input, key, BitwiseOp._sub); - }, - - - /** - * Bit shift left operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runBitShiftLeft: function(input, args) { - const amount = args[0]; - - return input.map(b => { - return (b << amount) & 0xff; - }); - }, - - - /** - * @constant - * @default - */ - BIT_SHIFT_TYPE: ["Logical shift", "Arithmetic shift"], - - /** - * Bit shift right operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runBitShiftRight: function(input, args) { - const amount = args[0], - type = args[1], - mask = type === "Logical shift" ? 0 : 0x80; - - return input.map(b => { - return (b >>> amount) ^ (b & mask); - }); - }, - - - /** - * XOR bitwise calculation. - * - * @private - * @param {number} operand - * @param {number} key - * @returns {number} - */ - _xor: function (operand, key) { - return operand ^ key; - }, - - - /** - * NOT bitwise calculation. - * - * @private - * @param {number} operand - * @returns {number} - */ - _not: function (operand, _) { - return ~operand & 0xff; - }, - - - /** - * AND bitwise calculation. - * - * @private - * @param {number} operand - * @param {number} key - * @returns {number} - */ - _and: function (operand, key) { - return operand & key; - }, - - - /** - * OR bitwise calculation. - * - * @private - * @param {number} operand - * @param {number} key - * @returns {number} - */ - _or: function (operand, key) { - return operand | key; - }, - - - /** - * ADD bitwise calculation. - * - * @private - * @param {number} operand - * @param {number} key - * @returns {number} - */ - _add: function (operand, key) { - return (operand + key) % 256; - }, - - - /** - * SUB bitwise calculation. - * - * @private - * @param {number} operand - * @param {number} key - * @returns {number} - */ - _sub: function (operand, key) { - const result = operand - key; - return (result < 0) ? 256 + result : result; - }, - -}; - -export default BitwiseOp; diff --git a/src/core/operations/legacy/JS.js b/src/core/operations/legacy/JS.js deleted file mode 100755 index 58290aaa..00000000 --- a/src/core/operations/legacy/JS.js +++ /dev/null @@ -1,164 +0,0 @@ -import * as esprima from "esprima"; -import escodegen from "escodegen"; -import esmangle from "esmangle"; - - -/** - * JavaScript operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const JS = { - - /** - * @constant - * @default - */ - PARSE_LOC: false, - /** - * @constant - * @default - */ - PARSE_RANGE: false, - /** - * @constant - * @default - */ - PARSE_TOKENS: false, - /** - * @constant - * @default - */ - PARSE_COMMENT: false, - /** - * @constant - * @default - */ - PARSE_TOLERANT: false, - - /** - * JavaScript Parser operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParse: function (input, args) { - let parseLoc = args[0], - parseRange = args[1], - parseTokens = args[2], - parseComment = args[3], - parseTolerant = args[4], - result = {}, - options = { - loc: parseLoc, - range: parseRange, - tokens: parseTokens, - comment: parseComment, - tolerant: parseTolerant - }; - - result = esprima.parseScript(input, options); - return JSON.stringify(result, null, 2); - }, - - - /** - * @constant - * @default - */ - BEAUTIFY_INDENT: "\\t", - /** - * @constant - * @default - */ - BEAUTIFY_QUOTES: ["Auto", "Single", "Double"], - /** - * @constant - * @default - */ - BEAUTIFY_SEMICOLONS: true, - /** - * @constant - * @default - */ - BEAUTIFY_COMMENT: true, - - /** - * JavaScript Beautify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBeautify: function(input, args) { - let beautifyIndent = args[0] || JS.BEAUTIFY_INDENT, - quotes = args[1].toLowerCase(), - beautifySemicolons = args[2], - beautifyComment = args[3], - result = "", - AST; - - try { - AST = esprima.parseScript(input, { - range: true, - tokens: true, - comment: true - }); - - const options = { - format: { - indent: { - style: beautifyIndent - }, - quotes: quotes, - semicolons: beautifySemicolons, - }, - comment: beautifyComment - }; - - if (options.comment) - AST = escodegen.attachComments(AST, AST.comments, AST.tokens); - - result = escodegen.generate(AST, options); - } catch (e) { - // Leave original error so the user can see the detail - throw "Unable to parse JavaScript.
" + e.message; - } - return result; - }, - - - /** - * JavaScript Minify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runMinify: function(input, args) { - let result = "", - AST = esprima.parseScript(input), - optimisedAST = esmangle.optimize(AST, null), - mangledAST = esmangle.mangle(optimisedAST); - - result = escodegen.generate(mangledAST, { - format: { - renumber: true, - hexadecimal: true, - escapeless: true, - compact: true, - semicolons: false, - parentheses: false - } - }); - return result; - }, - -}; - -export default JS; From 905bc6699e9e38c846c9e21df6834e26e1abce63 Mon Sep 17 00:00:00 2001 From: Matt C Date: Sat, 26 May 2018 18:04:53 +0100 Subject: [PATCH 16/23] ESM: Ported case converters, generic beautifier and syntax highlighting --- src/core/lib/Code.mjs | 31 ++++ src/core/operations/GenericCodeBeautify.mjs | 161 ++++++++++++++++++++ src/core/operations/SyntaxHighlighter.mjs | 78 ++++++++++ src/core/operations/ToCamelCase.mjs | 53 +++++++ src/core/operations/ToKebabCase.mjs | 53 +++++++ src/core/operations/ToSnakeCase.mjs | 52 +++++++ 6 files changed, 428 insertions(+) create mode 100644 src/core/lib/Code.mjs create mode 100644 src/core/operations/GenericCodeBeautify.mjs create mode 100644 src/core/operations/SyntaxHighlighter.mjs create mode 100644 src/core/operations/ToCamelCase.mjs create mode 100644 src/core/operations/ToKebabCase.mjs create mode 100644 src/core/operations/ToSnakeCase.mjs diff --git a/src/core/lib/Code.mjs b/src/core/lib/Code.mjs new file mode 100644 index 00000000..ee55dfaf --- /dev/null +++ b/src/core/lib/Code.mjs @@ -0,0 +1,31 @@ +/** + * Code functions. + * + * @author n1474335 [n1474335@gmail.com] + * + * @copyright Crown Copyright 2018 + * @license Apache-2.0 + * + */ + +/** + * This tries to rename variable names in a code snippet according to a function. + * + * @param {string} input + * @param {function} replacer - this function will be fed the token which should be renamed. + * @returns {string} + */ +export function replaceVariableNames(input, replacer) { + const tokenRegex = /\\"|"(?:\\"|[^"])*"|(\b[a-z0-9\-_]+\b)/ig; + + return input.replace(tokenRegex, (...args) => { + const match = args[0], + quotes = args[1]; + + if (!quotes) { + return match; + } else { + return replacer(match); + } + }); +} diff --git a/src/core/operations/GenericCodeBeautify.mjs b/src/core/operations/GenericCodeBeautify.mjs new file mode 100644 index 00000000..5078bebc --- /dev/null +++ b/src/core/operations/GenericCodeBeautify.mjs @@ -0,0 +1,161 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; + +/** + * Generic Code Beautify operation + */ +class GenericCodeBeautify extends Operation { + + /** + * GenericCodeBeautify constructor + */ + constructor() { + super(); + + this.name = "Generic Code Beautify"; + this.module = "Code"; + this.description = "Attempts to pretty print C-style languages such as C, C++, C#, Java, PHP, JavaScript etc.

This will not do a perfect job, and the resulting code may not work any more. This operation is designed purely to make obfuscated or minified code more easy to read and understand.

Things which will not work properly:
  • For loop formatting
  • Do-While loop formatting
  • Switch/Case indentation
  • Certain bit shift operators
"; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const preservedTokens = []; + let code = input, + t = 0, + m; + + // Remove strings + const sstrings = /'([^'\\]|\\.)*'/g; + while ((m = sstrings.exec(code))) { + code = preserveToken(code, m, t++); + sstrings.lastIndex = m.index; + } + + const dstrings = /"([^"\\]|\\.)*"/g; + while ((m = dstrings.exec(code))) { + code = preserveToken(code, m, t++); + dstrings.lastIndex = m.index; + } + + // Remove comments + const scomments = /\/\/[^\n\r]*/g; + while ((m = scomments.exec(code))) { + code = preserveToken(code, m, t++); + scomments.lastIndex = m.index; + } + + const mcomments = /\/\*[\s\S]*?\*\//gm; + while ((m = mcomments.exec(code))) { + code = preserveToken(code, m, t++); + mcomments.lastIndex = m.index; + } + + const hcomments = /(^|\n)#[^\n\r#]+/g; + while ((m = hcomments.exec(code))) { + code = preserveToken(code, m, t++); + hcomments.lastIndex = m.index; + } + + // Remove regexes + const regexes = /\/.*?[^\\]\/[gim]{0,3}/gi; + while ((m = regexes.exec(code))) { + code = preserveToken(code, m, t++); + regexes.lastIndex = m.index; + } + + code = code + // Create newlines after ; + .replace(/;/g, ";\n") + // Create newlines after { and around } + .replace(/{/g, "{\n") + .replace(/}/g, "\n}\n") + // Remove carriage returns + .replace(/\r/g, "") + // Remove all indentation + .replace(/^\s+/g, "") + .replace(/\n\s+/g, "\n") + // Remove trailing spaces + .replace(/\s*$/g, "") + .replace(/\n{/g, "{"); + + // Indent + let i = 0, + level = 0, + indent; + while (i < code.length) { + switch (code[i]) { + case "{": + level++; + break; + case "\n": + if (i+1 >= code.length) break; + + if (code[i+1] === "}") level--; + indent = (level >= 0) ? Array(level*4+1).join(" ") : ""; + + code = code.substring(0, i+1) + indent + code.substring(i+1); + if (level > 0) i += level*4; + break; + } + i++; + } + + code = code + // Add strategic spaces + .replace(/\s*([!<>=+-/*]?)=\s*/g, " $1= ") + .replace(/\s*<([=]?)\s*/g, " <$1 ") + .replace(/\s*>([=]?)\s*/g, " >$1 ") + .replace(/([^+])\+([^+=])/g, "$1 + $2") + .replace(/([^-])-([^-=])/g, "$1 - $2") + .replace(/([^*])\*([^*=])/g, "$1 * $2") + .replace(/([^/])\/([^/=])/g, "$1 / $2") + .replace(/\s*,\s*/g, ", ") + .replace(/\s*{/g, " {") + .replace(/}\n/g, "}\n\n") + // Hacky horribleness + .replace(/(if|for|while|with|elif|elseif)\s*\(([^\n]*)\)\s*\n([^{])/gim, "$1 ($2)\n $3") + .replace(/(if|for|while|with|elif|elseif)\s*\(([^\n]*)\)([^{])/gim, "$1 ($2) $3") + .replace(/else\s*\n([^{])/gim, "else\n $1") + .replace(/else\s+([^{])/gim, "else $1") + // Remove strategic spaces + .replace(/\s+;/g, ";") + .replace(/\{\s+\}/g, "{}") + .replace(/\[\s+\]/g, "[]") + .replace(/}\s*(else|catch|except|finally|elif|elseif|else if)/gi, "} $1"); + + // Replace preserved tokens + const ptokens = /###preservedToken(\d+)###/g; + while ((m = ptokens.exec(code))) { + const ti = parseInt(m[1], 10); + code = code.substring(0, m.index) + preservedTokens[ti] + code.substring(m.index + m[0].length); + ptokens.lastIndex = m.index; + } + + return code; + + /** + * Replaces a matched token with a placeholder value. + */ + function preserveToken(str, match, t) { + preservedTokens[t] = match[0]; + return str.substring(0, match.index) + + "###preservedToken" + t + "###" + + str.substring(match.index + match[0].length); + } + } + +} + +export default GenericCodeBeautify; diff --git a/src/core/operations/SyntaxHighlighter.mjs b/src/core/operations/SyntaxHighlighter.mjs new file mode 100644 index 00000000..bde6fbde --- /dev/null +++ b/src/core/operations/SyntaxHighlighter.mjs @@ -0,0 +1,78 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import hljs from "highlight.js"; + +/** + * Syntax highlighter operation + */ +class SyntaxHighlighter extends Operation { + + /** + * SyntaxHighlighter constructor + */ + constructor() { + super(); + + this.name = "Syntax highlighter"; + this.module = "Code"; + this.description = "Adds syntax highlighting to a range of source code languages. Note that this will not indent the code. Use one of the 'Beautify' operations for that."; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Language", + "type": "option", + "value": ["auto detect"].concat(hljs.listLanguages()) + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const language = args[0]; + + if (language === "auto detect") { + return hljs.highlightAuto(input).value; + } + + return hljs.highlight(language, input, true).value; + } + + /** + * Highlight Syntax highlighter + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlight(pos, args) { + return pos; + } + + /** + * Highlight Syntax highlighter in reverse + * + * @param {Object[]} pos + * @param {number} pos[].start + * @param {number} pos[].end + * @param {Object[]} args + * @returns {Object[]} pos + */ + highlightReverse(pos, args) { + return pos; + } + +} + +export default SyntaxHighlighter; diff --git a/src/core/operations/ToCamelCase.mjs b/src/core/operations/ToCamelCase.mjs new file mode 100644 index 00000000..5c9fa939 --- /dev/null +++ b/src/core/operations/ToCamelCase.mjs @@ -0,0 +1,53 @@ +/** + * @author tlwr [toby@toby.codes] + * @copyright Crown Copyright 2017 + * @license Apache-2.0 + */ + +import { camelCase } from "lodash"; +import Operation from "../Operation"; +import { replaceVariableNames } from "../lib/Code"; + +/** + * To Camel case operation + */ +class ToCamelCase extends Operation { + + /** + * ToCamelCase constructor + */ + constructor() { + super(); + + this.name = "To Camel case"; + this.module = "Code"; + this.description = "Converts the input string to camel case.\n

\nCamel case is all lower case except letters after word boundaries which are uppercase.\n

\ne.g. thisIsCamelCase\n

\n'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Attempt to be context aware", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const smart = args[0]; + + if (smart) { + return replaceVariableNames(input, camelCase); + } else { + return camelCase(input); + } + } + +} + +export default ToCamelCase; diff --git a/src/core/operations/ToKebabCase.mjs b/src/core/operations/ToKebabCase.mjs new file mode 100644 index 00000000..5e62460e --- /dev/null +++ b/src/core/operations/ToKebabCase.mjs @@ -0,0 +1,53 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import { kebabCase } from "lodash"; +import Operation from "../Operation"; +import { replaceVariableNames } from "../lib/Code"; + +/** + * To Kebab case operation + */ +class ToKebabCase extends Operation { + + /** + * ToKebabCase constructor + */ + constructor() { + super(); + + this.name = "To Kebab case"; + this.module = "Code"; + this.description = "Converts the input string to kebab case.\n

\nKebab case is all lower case with dashes as word boundaries.\n

\ne.g. this-is-kebab-case\n

\n'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Attempt to be context aware", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const smart = args[0]; + + if (smart) { + return replaceVariableNames(input, kebabCase); + } else { + return kebabCase(input); + } + } + +} + +export default ToKebabCase; diff --git a/src/core/operations/ToSnakeCase.mjs b/src/core/operations/ToSnakeCase.mjs new file mode 100644 index 00000000..0c138272 --- /dev/null +++ b/src/core/operations/ToSnakeCase.mjs @@ -0,0 +1,52 @@ +/** + * @author tlwr [toby@toby.codes] + * @copyright Crown Copyright 2017 + * @license Apache-2.0 + */ + +import { snakeCase } from "lodash"; +import Operation from "../Operation"; +import { replaceVariableNames } from "../lib/Code"; + +/** + * To Snake case operation + */ +class ToSnakeCase extends Operation { + + /** + * ToSnakeCase constructor + */ + constructor() { + super(); + + this.name = "To Snake case"; + this.module = "Code"; + this.description = "Converts the input string to snake case.\n

\nSnake case is all lower case with underscores as word boundaries.\n

\ne.g. this_is_snake_case\n

\n'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Attempt to be context aware", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const smart = args[0]; + + if (smart) { + return replaceVariableNames(input, snakeCase); + } else { + return snakeCase(input); + } + } +} + +export default ToSnakeCase; From 6768038a2f0dc8d1be46d34078ea3966fbf7ffb2 Mon Sep 17 00:00:00 2001 From: n1474335 Date: Sun, 27 May 2018 16:13:18 +0100 Subject: [PATCH 17/23] ESM: Tidied up recently ported ops --- src/core/lib/Code.mjs | 6 ++---- src/core/operations/BlowfishDecrypt.mjs | 3 ++- src/core/operations/BlowfishEncrypt.mjs | 9 +++++++-- src/core/operations/DESDecrypt.mjs | 7 ++++--- src/core/operations/DESEncrypt.mjs | 5 +++-- src/core/operations/DeriveEVPKey.mjs | 3 ++- src/core/operations/DerivePBKDF2Key.mjs | 4 +++- src/core/operations/JavaScriptBeautify.mjs | 3 ++- src/core/operations/ToCamelCase.mjs | 2 +- src/core/operations/ToKebabCase.mjs | 2 +- src/core/operations/ToSnakeCase.mjs | 2 +- src/core/operations/TripleDESDecrypt.mjs | 7 ++++--- src/core/operations/TripleDESEncrypt.mjs | 5 +++-- src/core/operations/XORBruteForce.mjs | 16 ++++++++++++---- 14 files changed, 47 insertions(+), 27 deletions(-) diff --git a/src/core/lib/Code.mjs b/src/core/lib/Code.mjs index ee55dfaf..2d749d79 100644 --- a/src/core/lib/Code.mjs +++ b/src/core/lib/Code.mjs @@ -1,18 +1,16 @@ /** - * Code functions. + * Code resources. * * @author n1474335 [n1474335@gmail.com] - * * @copyright Crown Copyright 2018 * @license Apache-2.0 - * */ /** * This tries to rename variable names in a code snippet according to a function. * * @param {string} input - * @param {function} replacer - this function will be fed the token which should be renamed. + * @param {function} replacer - This function will be fed the token which should be renamed. * @returns {string} */ export function replaceVariableNames(input, replacer) { diff --git a/src/core/operations/BlowfishDecrypt.mjs b/src/core/operations/BlowfishDecrypt.mjs index 95ba415d..d349d3c4 100644 --- a/src/core/operations/BlowfishDecrypt.mjs +++ b/src/core/operations/BlowfishDecrypt.mjs @@ -6,6 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import { Blowfish } from "../vendor/Blowfish"; import { toBase64 } from "../lib/Base64"; import { toHexFast } from "../lib/Hex"; @@ -80,7 +81,7 @@ class BlowfishDecrypt extends Operation { iv = Utils.convertToByteArray(args[1].string, args[1].option), [,, mode, inputType, outputType] = args; - if (key.length === 0) return "Enter a key"; + if (key.length === 0) throw new OperationError("Enter a key"); input = inputType === "Raw" ? Utils.strToByteArray(input) : input; diff --git a/src/core/operations/BlowfishEncrypt.mjs b/src/core/operations/BlowfishEncrypt.mjs index 7af32bc8..60c45560 100644 --- a/src/core/operations/BlowfishEncrypt.mjs +++ b/src/core/operations/BlowfishEncrypt.mjs @@ -6,12 +6,17 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import { Blowfish } from "../vendor/Blowfish"; import { toBase64 } from "../lib/Base64"; +/** + * Lookup table for Blowfish output types. + */ const BLOWFISH_OUTPUT_TYPE_LOOKUP = { Base64: 0, Hex: 1, String: 2, Raw: 3 }; + /** * Lookup table for Blowfish modes. */ @@ -77,7 +82,7 @@ class BlowfishEncrypt extends Operation { iv = Utils.convertToByteArray(args[1].string, args[1].option), [,, mode, inputType, outputType] = args; - if (key.length === 0) return "Enter a key"; + if (key.length === 0) throw new OperationError("Enter a key"); input = Utils.convertToByteString(input, inputType); @@ -88,7 +93,7 @@ class BlowfishEncrypt extends Operation { cipherMode: BLOWFISH_MODE_LOOKUP[mode] }); - return outputType === "Raw" ? Utils.byteArrayToChars(enc) : enc ; + return outputType === "Raw" ? Utils.byteArrayToChars(enc) : enc; } } diff --git a/src/core/operations/DESDecrypt.mjs b/src/core/operations/DESDecrypt.mjs index 0894dfb8..b1d0d8c7 100644 --- a/src/core/operations/DESDecrypt.mjs +++ b/src/core/operations/DESDecrypt.mjs @@ -6,6 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import forge from "node-forge/dist/forge.min.js"; /** @@ -66,10 +67,10 @@ class DESDecrypt extends Operation { [,, mode, inputType, outputType] = args; if (key.length !== 8) { - return `Invalid key length: ${key.length} bytes + throw new OperationError(`Invalid key length: ${key.length} bytes DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`; +Triple DES uses a key length of 24 bytes (192 bits).`); } input = Utils.convertToByteString(input, inputType); @@ -82,7 +83,7 @@ Triple DES uses a key length of 24 bytes (192 bits).`; if (result) { return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); } else { - return "Unable to decrypt input with these parameters."; + throw new OperationError("Unable to decrypt input with these parameters."); } } diff --git a/src/core/operations/DESEncrypt.mjs b/src/core/operations/DESEncrypt.mjs index ca3f52e5..17a2abcf 100644 --- a/src/core/operations/DESEncrypt.mjs +++ b/src/core/operations/DESEncrypt.mjs @@ -6,6 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import forge from "node-forge/dist/forge.min.js"; /** @@ -66,10 +67,10 @@ class DESEncrypt extends Operation { [,, mode, inputType, outputType] = args; if (key.length !== 8) { - return `Invalid key length: ${key.length} bytes + throw new OperationError(`Invalid key length: ${key.length} bytes DES uses a key length of 8 bytes (64 bits). -Triple DES uses a key length of 24 bytes (192 bits).`; +Triple DES uses a key length of 24 bytes (192 bits).`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/DeriveEVPKey.mjs b/src/core/operations/DeriveEVPKey.mjs index ebab6961..ad17f0b1 100644 --- a/src/core/operations/DeriveEVPKey.mjs +++ b/src/core/operations/DeriveEVPKey.mjs @@ -63,7 +63,8 @@ class DeriveEVPKey extends Operation { run(input, args) { const passphrase = Utils.convertToByteString(args[0].string, args[0].option), keySize = args[1] / 32, - [,, iterations, hasher, ] = args, //eslint-disable-line array-bracket-spacing + iterations = args[2], + hasher = args[3], salt = Utils.convertToByteString(args[4].string, args[4].option), key = CryptoJS.EvpKDF(passphrase, salt, { keySize: keySize, diff --git a/src/core/operations/DerivePBKDF2Key.mjs b/src/core/operations/DerivePBKDF2Key.mjs index f9c7cf75..d3f7fe9a 100644 --- a/src/core/operations/DerivePBKDF2Key.mjs +++ b/src/core/operations/DerivePBKDF2Key.mjs @@ -62,7 +62,9 @@ class DerivePBKDF2Key extends Operation { */ run(input, args) { const passphrase = Utils.convertToByteString(args[0].string, args[0].option), - [, keySize, iterations, hasher, ] = args, //eslint-disable-line array-bracket-spacing + keySize = args[1], + iterations = args[2], + hasher = args[3], salt = Utils.convertToByteString(args[4].string, args[4].option) || forge.random.getBytesSync(keySize), derivedKey = forge.pkcs5.pbkdf2(passphrase, salt, iterations, keySize / 8, hasher.toLowerCase()); diff --git a/src/core/operations/JavaScriptBeautify.mjs b/src/core/operations/JavaScriptBeautify.mjs index 4c0607d2..a4bf326b 100644 --- a/src/core/operations/JavaScriptBeautify.mjs +++ b/src/core/operations/JavaScriptBeautify.mjs @@ -5,6 +5,7 @@ */ import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; import escodegen from "escodegen"; import * as esprima from "esprima"; @@ -84,7 +85,7 @@ class JavaScriptBeautify extends Operation { result = escodegen.generate(AST, options); } catch (e) { // Leave original error so the user can see the detail - throw "Unable to parse JavaScript.
" + e.message; + throw new OperationError("Unable to parse JavaScript.
" + e.message); } return result; } diff --git a/src/core/operations/ToCamelCase.mjs b/src/core/operations/ToCamelCase.mjs index 5c9fa939..cc42949c 100644 --- a/src/core/operations/ToCamelCase.mjs +++ b/src/core/operations/ToCamelCase.mjs @@ -4,7 +4,7 @@ * @license Apache-2.0 */ -import { camelCase } from "lodash"; +import camelCase from "lodash/camelCase"; import Operation from "../Operation"; import { replaceVariableNames } from "../lib/Code"; diff --git a/src/core/operations/ToKebabCase.mjs b/src/core/operations/ToKebabCase.mjs index 5e62460e..c293ede8 100644 --- a/src/core/operations/ToKebabCase.mjs +++ b/src/core/operations/ToKebabCase.mjs @@ -4,7 +4,7 @@ * @license Apache-2.0 */ -import { kebabCase } from "lodash"; +import kebabCase from "lodash/kebabCase"; import Operation from "../Operation"; import { replaceVariableNames } from "../lib/Code"; diff --git a/src/core/operations/ToSnakeCase.mjs b/src/core/operations/ToSnakeCase.mjs index 0c138272..10af102b 100644 --- a/src/core/operations/ToSnakeCase.mjs +++ b/src/core/operations/ToSnakeCase.mjs @@ -4,7 +4,7 @@ * @license Apache-2.0 */ -import { snakeCase } from "lodash"; +import snakeCase from "lodash/snakeCase"; import Operation from "../Operation"; import { replaceVariableNames } from "../lib/Code"; diff --git a/src/core/operations/TripleDESDecrypt.mjs b/src/core/operations/TripleDESDecrypt.mjs index db9e6cd2..8f5a295d 100644 --- a/src/core/operations/TripleDESDecrypt.mjs +++ b/src/core/operations/TripleDESDecrypt.mjs @@ -6,6 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import forge from "node-forge/dist/forge.min.js"; /** @@ -68,10 +69,10 @@ class TripleDESDecrypt extends Operation { outputType = args[4]; if (key.length !== 24) { - return `Invalid key length: ${key.length} bytes + throw new OperationError(`Invalid key length: ${key.length} bytes Triple DES uses a key length of 24 bytes (192 bits). -DES uses a key length of 8 bytes (64 bits).`; +DES uses a key length of 8 bytes (64 bits).`); } input = Utils.convertToByteString(input, inputType); @@ -84,7 +85,7 @@ DES uses a key length of 8 bytes (64 bits).`; if (result) { return outputType === "Hex" ? decipher.output.toHex() : decipher.output.getBytes(); } else { - return "Unable to decrypt input with these parameters."; + throw new OperationError("Unable to decrypt input with these parameters."); } } diff --git a/src/core/operations/TripleDESEncrypt.mjs b/src/core/operations/TripleDESEncrypt.mjs index c1618ca5..2384ea3c 100644 --- a/src/core/operations/TripleDESEncrypt.mjs +++ b/src/core/operations/TripleDESEncrypt.mjs @@ -6,6 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; import forge from "node-forge/dist/forge.min.js"; /** @@ -68,10 +69,10 @@ class TripleDESEncrypt extends Operation { outputType = args[4]; if (key.length !== 24) { - return `Invalid key length: ${key.length} bytes + throw new OperationError(`Invalid key length: ${key.length} bytes Triple DES uses a key length of 24 bytes (192 bits). -DES uses a key length of 8 bytes (64 bits).`; +DES uses a key length of 8 bytes (64 bits).`); } input = Utils.convertToByteString(input, inputType); diff --git a/src/core/operations/XORBruteForce.mjs b/src/core/operations/XORBruteForce.mjs index 4ceeb44a..131d5a63 100644 --- a/src/core/operations/XORBruteForce.mjs +++ b/src/core/operations/XORBruteForce.mjs @@ -75,10 +75,18 @@ class XORBruteForce extends Operation { * @returns {string} */ run(input, args) { - const [keyLength, sampleLength, sampleOffset, scheme, nullPreserving, printKey, outputHex, /* ignore element */] = args, //eslint-disable-line array-bracket-spacing - crib = args[7].toLowerCase(); - - const output = []; + const [ + keyLength, + sampleLength, + sampleOffset, + scheme, + nullPreserving, + printKey, + outputHex, + rawCrib + ] = args, + crib = rawCrib.toLowerCase(), + output = []; let result, resultUtf8, record = ""; From eb3a2502f5df10d7846623d92be27fb02ac3bf63 Mon Sep 17 00:00:00 2001 From: Matt C Date: Sun, 27 May 2018 22:07:09 +0100 Subject: [PATCH 18/23] Ported rest of Code ops & enabled/fixed some tests --- src/core/operations/CSSBeautify.mjs | 47 +++++++++++++ src/core/operations/CSSMinify.mjs | 47 +++++++++++++ src/core/operations/CSSSelector.mjs | 88 +++++++++++++++++++++++++ src/core/operations/Diff.mjs | 2 +- src/core/operations/JPathExpression.mjs | 68 +++++++++++++++++++ src/core/operations/JSONBeautify.mjs | 48 ++++++++++++++ src/core/operations/JSONMinify.mjs | 41 ++++++++++++ src/core/operations/SQLBeautify.mjs | 47 +++++++++++++ src/core/operations/SQLMinify.mjs | 40 +++++++++++ src/core/operations/XMLBeautify.mjs | 47 +++++++++++++ src/core/operations/XMLMinify.mjs | 47 +++++++++++++ src/core/operations/XPathExpression.mjs | 72 ++++++++++++++++++++ test/index.mjs | 4 +- test/tests/operations/Code.mjs | 3 +- 14 files changed, 597 insertions(+), 4 deletions(-) create mode 100644 src/core/operations/CSSBeautify.mjs create mode 100644 src/core/operations/CSSMinify.mjs create mode 100644 src/core/operations/CSSSelector.mjs create mode 100644 src/core/operations/JPathExpression.mjs create mode 100644 src/core/operations/JSONBeautify.mjs create mode 100644 src/core/operations/JSONMinify.mjs create mode 100644 src/core/operations/SQLBeautify.mjs create mode 100644 src/core/operations/SQLMinify.mjs create mode 100644 src/core/operations/XMLBeautify.mjs create mode 100644 src/core/operations/XMLMinify.mjs create mode 100644 src/core/operations/XPathExpression.mjs diff --git a/src/core/operations/CSSBeautify.mjs b/src/core/operations/CSSBeautify.mjs new file mode 100644 index 00000000..d9835550 --- /dev/null +++ b/src/core/operations/CSSBeautify.mjs @@ -0,0 +1,47 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * CSS Beautify operation + */ +class CSSBeautify extends Operation { + + /** + * CSSBeautify constructor + */ + constructor() { + super(); + + this.name = "CSS Beautify"; + this.module = "Code"; + this.description = "Indents and prettifies Cascading Style Sheets (CSS) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Indent string", + "type": "binaryShortString", + "value": "\\t" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const indentStr = args[0]; + return vkbeautify.css(input, indentStr); + } + +} + +export default CSSBeautify; diff --git a/src/core/operations/CSSMinify.mjs b/src/core/operations/CSSMinify.mjs new file mode 100644 index 00000000..2d489edc --- /dev/null +++ b/src/core/operations/CSSMinify.mjs @@ -0,0 +1,47 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * CSS Minify operation + */ +class CSSMinify extends Operation { + + /** + * CSSMinify constructor + */ + constructor() { + super(); + + this.name = "CSS Minify"; + this.module = "Code"; + this.description = "Compresses Cascading Style Sheets (CSS) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Preserve comments", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const preserveComments = args[0]; + return vkbeautify.cssmin(input, preserveComments); + } + +} + +export default CSSMinify; diff --git a/src/core/operations/CSSSelector.mjs b/src/core/operations/CSSSelector.mjs new file mode 100644 index 00000000..5894066e --- /dev/null +++ b/src/core/operations/CSSSelector.mjs @@ -0,0 +1,88 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import nwmatcher from "nwmatcher"; +import Operation from "../Operation"; + +/** + * CSS selector operation + */ +class CSSSelector extends Operation { + + /** + * CSSSelector constructor + */ + constructor() { + super(); + + this.name = "CSS selector"; + this.module = "Code"; + this.description = "Extract information from an HTML document with a CSS selector"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "CSS selector", + "type": "string", + "value": "" + }, + { + "name": "Delimiter", + "type": "binaryShortString", + "value": "\\n" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [query, delimiter] = args, + parser = new DOMParser(); + let dom, + result; + + if (!query.length || !input.length) { + return ""; + } + + try { + dom = parser.parseFromString(input); + } catch (err) { + return "Invalid input HTML."; + } + + try { + const matcher = nwmatcher({document: dom}); + result = matcher.select(query, dom); + } catch (err) { + return "Invalid CSS Selector. Details:\n" + err.message; + } + + const nodeToString = function(node) { + return node.toString(); + /* xmldom does not return the outerHTML value. + switch (node.nodeType) { + case node.ELEMENT_NODE: return node.outerHTML; + case node.ATTRIBUTE_NODE: return node.value; + case node.TEXT_NODE: return node.wholeText; + case node.COMMENT_NODE: return node.data; + case node.DOCUMENT_NODE: return node.outerHTML; + default: throw new Error("Unknown Node Type: " + node.nodeType); + }*/ + }; + + return result + .map(nodeToString) + .join(delimiter); + } + +} + +export default CSSSelector; diff --git a/src/core/operations/Diff.mjs b/src/core/operations/Diff.mjs index 6627cf6e..90697140 100644 --- a/src/core/operations/Diff.mjs +++ b/src/core/operations/Diff.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import * as JsDiff from "diff"; +import JsDiff from "diff"; import OperationError from "../errors/OperationError"; /** diff --git a/src/core/operations/JPathExpression.mjs b/src/core/operations/JPathExpression.mjs new file mode 100644 index 00000000..21b4284f --- /dev/null +++ b/src/core/operations/JPathExpression.mjs @@ -0,0 +1,68 @@ +/** + * @author Matt C (matt@artemisbot.uk) + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import jpath from "jsonpath"; +import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; + +/** + * JPath expression operation + */ +class JPathExpression extends Operation { + + /** + * JPathExpression constructor + */ + constructor() { + super(); + + this.name = "JPath expression"; + this.module = "Code"; + this.description = "Extract information from a JSON object with a JPath query."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Query", + "type": "string", + "value": "" + }, + { + "name": "Result delimiter", + "type": "binaryShortString", + "value": "\\n" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [query, delimiter] = args; + let results, + obj; + + try { + obj = JSON.parse(input); + } catch (err) { + throw new OperationError(`Invalid input JSON: ${err.message}`); + } + + try { + results = jpath.query(obj, query); + } catch (err) { + throw new OperationError(`Invalid JPath expression: ${err.message}`); + } + + return results.map(result => JSON.stringify(result)).join(delimiter); + } + +} + +export default JPathExpression; diff --git a/src/core/operations/JSONBeautify.mjs b/src/core/operations/JSONBeautify.mjs new file mode 100644 index 00000000..15fb7f58 --- /dev/null +++ b/src/core/operations/JSONBeautify.mjs @@ -0,0 +1,48 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * JSON Beautify operation + */ +class JSONBeautify extends Operation { + + /** + * JSONBeautify constructor + */ + constructor() { + super(); + + this.name = "JSON Beautify"; + this.module = "Code"; + this.description = "Indents and prettifies JavaScript Object Notation (JSON) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Indent string", + "type": "binaryShortString", + "value": "\\t" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const indentStr = args[0]; + if (!input) return ""; + return vkbeautify.json(input, indentStr); + } + +} + +export default JSONBeautify; diff --git a/src/core/operations/JSONMinify.mjs b/src/core/operations/JSONMinify.mjs new file mode 100644 index 00000000..ca594397 --- /dev/null +++ b/src/core/operations/JSONMinify.mjs @@ -0,0 +1,41 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * JSON Minify operation + */ +class JSONMinify extends Operation { + + /** + * JSONMinify constructor + */ + constructor() { + super(); + + this.name = "JSON Minify"; + this.module = "Code"; + this.description = "Compresses JavaScript Object Notation (JSON) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + if (!input) return ""; + return vkbeautify.jsonmin(input); + } + +} + +export default JSONMinify; diff --git a/src/core/operations/SQLBeautify.mjs b/src/core/operations/SQLBeautify.mjs new file mode 100644 index 00000000..1862972a --- /dev/null +++ b/src/core/operations/SQLBeautify.mjs @@ -0,0 +1,47 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * SQL Beautify operation + */ +class SQLBeautify extends Operation { + + /** + * SQLBeautify constructor + */ + constructor() { + super(); + + this.name = "SQL Beautify"; + this.module = "Code"; + this.description = "Indents and prettifies Structured Query Language (SQL) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Indent string", + "type": "binaryShortString", + "value": "\\t" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const indentStr = args[0]; + return vkbeautify.sql(input, indentStr); + } + +} + +export default SQLBeautify; diff --git a/src/core/operations/SQLMinify.mjs b/src/core/operations/SQLMinify.mjs new file mode 100644 index 00000000..d81e29ad --- /dev/null +++ b/src/core/operations/SQLMinify.mjs @@ -0,0 +1,40 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * SQL Minify operation + */ +class SQLMinify extends Operation { + + /** + * SQLMinify constructor + */ + constructor() { + super(); + + this.name = "SQL Minify"; + this.module = "Code"; + this.description = "Compresses Structured Query Language (SQL) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + return vkbeautify.sqlmin(input); + } + +} + +export default SQLMinify; diff --git a/src/core/operations/XMLBeautify.mjs b/src/core/operations/XMLBeautify.mjs new file mode 100644 index 00000000..4c059411 --- /dev/null +++ b/src/core/operations/XMLBeautify.mjs @@ -0,0 +1,47 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * XML Beautify operation + */ +class XMLBeautify extends Operation { + + /** + * XMLBeautify constructor + */ + constructor() { + super(); + + this.name = "XML Beautify"; + this.module = "Code"; + this.description = "Indents and prettifies eXtensible Markup Language (XML) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Indent string", + "type": "binaryShortString", + "value": "\\t" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const indentStr = args[0]; + return vkbeautify.xml(input, indentStr); + } + +} + +export default XMLBeautify; diff --git a/src/core/operations/XMLMinify.mjs b/src/core/operations/XMLMinify.mjs new file mode 100644 index 00000000..9c4fb2f6 --- /dev/null +++ b/src/core/operations/XMLMinify.mjs @@ -0,0 +1,47 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import vkbeautify from "vkbeautify"; +import Operation from "../Operation"; + +/** + * XML Minify operation + */ +class XMLMinify extends Operation { + + /** + * XMLMinify constructor + */ + constructor() { + super(); + + this.name = "XML Minify"; + this.module = "Code"; + this.description = "Compresses eXtensible Markup Language (XML) code."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Preserve comments", + "type": "boolean", + "value": false + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const preserveComments = args[0]; + return vkbeautify.xmlmin(input, preserveComments); + } + +} + +export default XMLMinify; diff --git a/src/core/operations/XPathExpression.mjs b/src/core/operations/XPathExpression.mjs new file mode 100644 index 00000000..4e83aff1 --- /dev/null +++ b/src/core/operations/XPathExpression.mjs @@ -0,0 +1,72 @@ +/** + * @author Mikescher (https://github.com/Mikescher | https://mikescher.com) + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import xpath from "xpath"; +import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; + +/** + * XPath expression operation + */ +class XPathExpression extends Operation { + + /** + * XPathExpression constructor + */ + constructor() { + super(); + + this.name = "XPath expression"; + this.module = "Code"; + this.description = "Extract information from an XML document with an XPath query"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "XPath", + "type": "string", + "value": "" + }, + { + "name": "Result delimiter", + "type": "binaryShortString", + "value": "\\n" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [query, delimiter] = args; + + let doc; + try { + doc = new DOMParser().parseFromString(input, "application/xml"); + } catch (err) { + throw new OperationError("Invalid input XML."); + } + + let nodes; + try { + nodes = xpath.select(query, doc); + } catch (err) { + throw new OperationError(`Invalid XPath. Details:\n${err.message}.`); + } + + const nodeToString = function(node) { + return node.toString(); + }; + + return nodes.map(nodeToString).join(delimiter); + } + +} + +export default XPathExpression; diff --git a/test/index.mjs b/test/index.mjs index c03cf046..cd7a2278 100644 --- a/test/index.mjs +++ b/test/index.mjs @@ -34,7 +34,7 @@ import "./tests/operations/CartesianProduct"; import "./tests/operations/CharEnc"; import "./tests/operations/Ciphers"; import "./tests/operations/Checksum"; -// import "./tests/operations/Code"; +import "./tests/operations/Code"; import "./tests/operations/Compress"; import "./tests/operations/Crypt"; import "./tests/operations/DateTime"; @@ -54,7 +54,7 @@ import "./tests/operations/OTP"; import "./tests/operations/PowerSet"; // import "./tests/operations/Regex"; import "./tests/operations/Rotate"; -// import "./tests/operations/StrUtils"; +import "./tests/operations/StrUtils"; import "./tests/operations/SeqUtils"; import "./tests/operations/SetDifference"; import "./tests/operations/SetIntersection"; diff --git a/test/tests/operations/Code.mjs b/test/tests/operations/Code.mjs index 3b282b67..00643ed1 100644 --- a/test/tests/operations/Code.mjs +++ b/test/tests/operations/Code.mjs @@ -310,6 +310,7 @@ TestRegister.addTests([ } ], }, + /* Since we don't pack ops before running tests, there's no polyfill for DomParser() { name: "CSS selector", input: '
\n

hello

\n

world

\n

again

\n
', @@ -331,5 +332,5 @@ TestRegister.addTests([ "args": ["/div/p[@class=\"a\"]", "\\n"] } ] - } + }*/ ]); From 709630f39b656ba558f700009e6619ef93d5bccf Mon Sep 17 00:00:00 2001 From: Matt C Date: Sun, 27 May 2018 23:27:11 +0100 Subject: [PATCH 19/23] Ported Image operations + some cleanup --- src/core/operations/ExtractEXIF.mjs | 56 ++ src/core/operations/RemoveEXIF.mjs | 50 ++ src/core/operations/RenderImage.mjs | 91 +++ src/core/operations/legacy/Code.js | 540 ------------------ src/core/operations/legacy/Image.js | 125 ---- .../{remove-exif.js => remove-exif.mjs} | 6 +- test/index.mjs | 2 +- test/tests/operations/Image.mjs | 4 +- 8 files changed, 202 insertions(+), 672 deletions(-) create mode 100644 src/core/operations/ExtractEXIF.mjs create mode 100644 src/core/operations/RemoveEXIF.mjs create mode 100644 src/core/operations/RenderImage.mjs delete mode 100755 src/core/operations/legacy/Code.js delete mode 100644 src/core/operations/legacy/Image.js rename src/core/vendor/{remove-exif.js => remove-exif.mjs} (98%) diff --git a/src/core/operations/ExtractEXIF.mjs b/src/core/operations/ExtractEXIF.mjs new file mode 100644 index 00000000..ae293763 --- /dev/null +++ b/src/core/operations/ExtractEXIF.mjs @@ -0,0 +1,56 @@ +/** + * @author tlwr [toby@toby.codes] + * @copyright Crown Copyright 2017 + * @license Apache-2.0 + */ + +import ExifParser from "exif-parser"; +import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; + +/** + * Extract EXIF operation + */ +class ExtractEXIF extends Operation { + + /** + * ExtractEXIF constructor + */ + constructor() { + super(); + + this.name = "Extract EXIF"; + this.module = "Image"; + this.description = "Extracts EXIF data from an image.\n

\nEXIF data is metadata embedded in images (JPEG, JPG, TIFF) and audio files.\n

\nEXIF data from photos usually contains information about the image file itself as well as the device used to create it."; + this.inputType = "ArrayBuffer"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {ArrayBuffer} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + try { + const parser = ExifParser.create(input); + const result = parser.parse(); + + const lines = []; + for (const tagName in result.tags) { + const value = result.tags[tagName]; + lines.push(`${tagName}: ${value}`); + } + + const numTags = lines.length; + lines.unshift(`Found ${numTags} tags.\n`); + return lines.join("\n"); + } catch (err) { + throw new OperationError(`Could not extract EXIF data from image: ${err}`); + } + } + +} + +export default ExtractEXIF; diff --git a/src/core/operations/RemoveEXIF.mjs b/src/core/operations/RemoveEXIF.mjs new file mode 100644 index 00000000..0d5c9d49 --- /dev/null +++ b/src/core/operations/RemoveEXIF.mjs @@ -0,0 +1,50 @@ +/** + * @author tlwr [toby@toby.codes] + * @copyright Crown Copyright 2017 + * @license Apache-2.0 + */ + +import { removeEXIF } from "../vendor/remove-exif"; +import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; + +/** + * Remove EXIF operation + */ +class RemoveEXIF extends Operation { + + /** + * RemoveEXIF constructor + */ + constructor() { + super(); + + this.name = "Remove EXIF"; + this.module = "Image"; + this.description = "Removes EXIF data from a JPEG image.\n

\nEXIF data embedded in photos usually contains information about the image file itself as well as the device used to create it."; + this.inputType = "byteArray"; + this.outputType = "byteArray"; + this.args = []; + } + + /** + * @param {byteArray} input + * @param {Object[]} args + * @returns {byteArray} + */ + run(input, args) { + // Do nothing if input is empty + if (input.length === 0) return input; + + try { + return removeEXIF(input); + } catch (err) { + // Simply return input if no EXIF data is found + if (err === "Exif not found.") return input; + throw new OperationError(`Could not remove EXIF data from image: ${err}`); + } + } + +} + +export default RemoveEXIF; diff --git a/src/core/operations/RenderImage.mjs b/src/core/operations/RenderImage.mjs new file mode 100644 index 00000000..b99fbe9b --- /dev/null +++ b/src/core/operations/RenderImage.mjs @@ -0,0 +1,91 @@ +/** + * @author tlwr [toby@toby.codes] + * @copyright Crown Copyright 2017 + * @license Apache-2.0 + */ + +import { fromBase64, toBase64 } from "../lib/Base64"; +import { fromHex } from "../lib/Hex"; +import Operation from "../Operation"; +import Utils from "../Utils"; +import Magic from "../lib/Magic"; + +/** + * Render Image operation + */ +class RenderImage extends Operation { + + /** + * RenderImage constructor + */ + constructor() { + super(); + + this.name = "Render Image"; + this.module = "Image"; + this.description = "Displays the input as an image. Supports the following formats:

  • jpg/jpeg
  • png
  • gif
  • webp
  • bmp
  • ico
"; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Input format", + "type": "option", + "value": ["Raw", "Base64", "Hex"] + } + ]; + this.patterns = [ + { + "match": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", + "flags": "", + "args": [ + "Raw" + ], + "useful": true + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const inputFormat = args[0]; + let dataURI = "data:"; + + if (!input.length) return ""; + + // Convert input to raw bytes + switch (inputFormat) { + case "Hex": + input = fromHex(input); + break; + case "Base64": + // Don't trust the Base64 entered by the user. + // Unwrap it first, then re-encode later. + input = fromBase64(input, undefined, "byteArray"); + break; + case "Raw": + default: + input = Utils.strToByteArray(input); + break; + } + + // Determine file type + const type = Magic.magicFileType(input); + if (type && type.mime.indexOf("image") === 0) { + dataURI += type.mime + ";"; + } else { + throw "Invalid file type"; + } + + // Add image data to URI + dataURI += "base64," + toBase64(input); + + return ""; + } + +} + +export default RenderImage; diff --git a/src/core/operations/legacy/Code.js b/src/core/operations/legacy/Code.js deleted file mode 100755 index ad777d01..00000000 --- a/src/core/operations/legacy/Code.js +++ /dev/null @@ -1,540 +0,0 @@ -import {camelCase, kebabCase, snakeCase} from "lodash"; -import vkbeautify from "vkbeautify"; -import {DOMParser} from "xmldom"; -import xpath from "xpath"; -import jpath from "jsonpath"; -import nwmatcher from "nwmatcher"; -import hljs from "highlight.js"; - - -/** - * Code operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Code = { - - /** - * @constant - * @default - */ - LANGUAGES: ["auto detect"].concat(hljs.listLanguages()), - - /** - * Syntax highlighter operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runSyntaxHighlight: function(input, args) { - const language = args[0]; - - if (language === "auto detect") { - return hljs.highlightAuto(input).value; - } - - return hljs.highlight(language, input, true).value; - }, - - - /** - * @constant - * @default - */ - BEAUTIFY_INDENT: "\\t", - - /** - * XML Beautify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runXmlBeautify: function(input, args) { - const indentStr = args[0]; - return vkbeautify.xml(input, indentStr); - }, - - - /** - * JSON Beautify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runJsonBeautify: function(input, args) { - const indentStr = args[0]; - if (!input) return ""; - return vkbeautify.json(input, indentStr); - }, - - - /** - * CSS Beautify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runCssBeautify: function(input, args) { - const indentStr = args[0]; - return vkbeautify.css(input, indentStr); - }, - - - /** - * SQL Beautify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSqlBeautify: function(input, args) { - const indentStr = args[0]; - return vkbeautify.sql(input, indentStr); - }, - - - /** - * @constant - * @default - */ - PRESERVE_COMMENTS: false, - - /** - * XML Minify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runXmlMinify: function(input, args) { - const preserveComments = args[0]; - return vkbeautify.xmlmin(input, preserveComments); - }, - - - /** - * JSON Minify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runJsonMinify: function(input, args) { - if (!input) return ""; - return vkbeautify.jsonmin(input); - }, - - - /** - * CSS Minify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runCssMinify: function(input, args) { - const preserveComments = args[0]; - return vkbeautify.cssmin(input, preserveComments); - }, - - - /** - * SQL Minify operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSqlMinify: function(input, args) { - return vkbeautify.sqlmin(input); - }, - - - /** - * Generic Code Beautify operation. - * - * Yeeeaaah... - * - * I'm not proud of this code, but seriously, try writing a generic lexer and parser that - * correctly generates an AST for multiple different languages. I have tried, and I can tell - * you it's pretty much impossible. - * - * This basically works. That'll have to be good enough. It's not meant to produce working code, - * just slightly more readable code. - * - * Things that don't work: - * - For loop formatting - * - Do-While loop formatting - * - Switch/Case indentation - * - Bit shift operators - * - * @author n1474335 [n1474335@gmail.com] - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runGenericBeautify: function(input, args) { - let code = input, - t = 0, - preservedTokens = [], - m; - - // Remove strings - const sstrings = /'([^'\\]|\\.)*'/g; - while ((m = sstrings.exec(code))) { - code = preserveToken(code, m, t++); - sstrings.lastIndex = m.index; - } - - const dstrings = /"([^"\\]|\\.)*"/g; - while ((m = dstrings.exec(code))) { - code = preserveToken(code, m, t++); - dstrings.lastIndex = m.index; - } - - // Remove comments - const scomments = /\/\/[^\n\r]*/g; - while ((m = scomments.exec(code))) { - code = preserveToken(code, m, t++); - scomments.lastIndex = m.index; - } - - const mcomments = /\/\*[\s\S]*?\*\//gm; - while ((m = mcomments.exec(code))) { - code = preserveToken(code, m, t++); - mcomments.lastIndex = m.index; - } - - const hcomments = /(^|\n)#[^\n\r#]+/g; - while ((m = hcomments.exec(code))) { - code = preserveToken(code, m, t++); - hcomments.lastIndex = m.index; - } - - // Remove regexes - const regexes = /\/.*?[^\\]\/[gim]{0,3}/gi; - while ((m = regexes.exec(code))) { - code = preserveToken(code, m, t++); - regexes.lastIndex = m.index; - } - - code = code - // Create newlines after ; - .replace(/;/g, ";\n") - // Create newlines after { and around } - .replace(/{/g, "{\n") - .replace(/}/g, "\n}\n") - // Remove carriage returns - .replace(/\r/g, "") - // Remove all indentation - .replace(/^\s+/g, "") - .replace(/\n\s+/g, "\n") - // Remove trailing spaces - .replace(/\s*$/g, "") - .replace(/\n{/g, "{"); - - // Indent - let i = 0, - level = 0, - indent; - while (i < code.length) { - switch (code[i]) { - case "{": - level++; - break; - case "\n": - if (i+1 >= code.length) break; - - if (code[i+1] === "}") level--; - indent = (level >= 0) ? Array(level*4+1).join(" ") : ""; - - code = code.substring(0, i+1) + indent + code.substring(i+1); - if (level > 0) i += level*4; - break; - } - i++; - } - - code = code - // Add strategic spaces - .replace(/\s*([!<>=+-/*]?)=\s*/g, " $1= ") - .replace(/\s*<([=]?)\s*/g, " <$1 ") - .replace(/\s*>([=]?)\s*/g, " >$1 ") - .replace(/([^+])\+([^+=])/g, "$1 + $2") - .replace(/([^-])-([^-=])/g, "$1 - $2") - .replace(/([^*])\*([^*=])/g, "$1 * $2") - .replace(/([^/])\/([^/=])/g, "$1 / $2") - .replace(/\s*,\s*/g, ", ") - .replace(/\s*{/g, " {") - .replace(/}\n/g, "}\n\n") - // Hacky horribleness - .replace(/(if|for|while|with|elif|elseif)\s*\(([^\n]*)\)\s*\n([^{])/gim, "$1 ($2)\n $3") - .replace(/(if|for|while|with|elif|elseif)\s*\(([^\n]*)\)([^{])/gim, "$1 ($2) $3") - .replace(/else\s*\n([^{])/gim, "else\n $1") - .replace(/else\s+([^{])/gim, "else $1") - // Remove strategic spaces - .replace(/\s+;/g, ";") - .replace(/\{\s+\}/g, "{}") - .replace(/\[\s+\]/g, "[]") - .replace(/}\s*(else|catch|except|finally|elif|elseif|else if)/gi, "} $1"); - - // Replace preserved tokens - const ptokens = /###preservedToken(\d+)###/g; - while ((m = ptokens.exec(code))) { - const ti = parseInt(m[1], 10); - code = code.substring(0, m.index) + preservedTokens[ti] + code.substring(m.index + m[0].length); - ptokens.lastIndex = m.index; - } - - return code; - - /** - * Replaces a matched token with a placeholder value. - */ - function preserveToken(str, match, t) { - preservedTokens[t] = match[0]; - return str.substring(0, match.index) + - "###preservedToken" + t + "###" + - str.substring(match.index + match[0].length); - } - }, - - - /** - * @constant - * @default - */ - XPATH_INITIAL: "", - - /** - * @constant - * @default - */ - XPATH_DELIMITER: "\\n", - - /** - * XPath expression operation. - * - * @author Mikescher (https://github.com/Mikescher | https://mikescher.com) - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runXpath: function(input, args) { - let query = args[0], - delimiter = args[1]; - - let doc; - try { - doc = new DOMParser().parseFromString(input, "application/xml"); - } catch (err) { - return "Invalid input XML."; - } - - let nodes; - try { - nodes = xpath.select(query, doc); - } catch (err) { - return "Invalid XPath. Details:\n" + err.message; - } - - const nodeToString = function(node) { - return node.toString(); - }; - - return nodes.map(nodeToString).join(delimiter); - }, - - - /** - * @constant - * @default - */ - JPATH_INITIAL: "", - - /** - * @constant - * @default - */ - JPATH_DELIMITER: "\\n", - - /** - * JPath expression operation. - * - * @author Matt C (matt@artemisbot.uk) - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runJpath: function(input, args) { - let query = args[0], - delimiter = args[1], - results, - obj; - - try { - obj = JSON.parse(input); - } catch (err) { - return "Invalid input JSON: " + err.message; - } - - try { - results = jpath.query(obj, query); - } catch (err) { - return "Invalid JPath expression: " + err.message; - } - - return results.map(result => JSON.stringify(result)).join(delimiter); - }, - - - /** - * @constant - * @default - */ - CSS_SELECTOR_INITIAL: "", - - /** - * @constant - * @default - */ - CSS_QUERY_DELIMITER: "\\n", - - /** - * CSS selector operation. - * - * @author Mikescher (https://github.com/Mikescher | https://mikescher.com) - * @author n1474335 [n1474335@gmail.com] - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runCSSQuery: function(input, args) { - let query = args[0], - delimiter = args[1], - parser = new DOMParser(), - dom, - result; - - if (!query.length || !input.length) { - return ""; - } - - try { - dom = parser.parseFromString(input); - } catch (err) { - return "Invalid input HTML."; - } - - try { - const matcher = nwmatcher({document: dom}); - result = matcher.select(query, dom); - } catch (err) { - return "Invalid CSS Selector. Details:\n" + err.message; - } - - const nodeToString = function(node) { - return node.toString(); - /* xmldom does not return the outerHTML value. - switch (node.nodeType) { - case node.ELEMENT_NODE: return node.outerHTML; - case node.ATTRIBUTE_NODE: return node.value; - case node.TEXT_NODE: return node.wholeText; - case node.COMMENT_NODE: return node.data; - case node.DOCUMENT_NODE: return node.outerHTML; - default: throw new Error("Unknown Node Type: " + node.nodeType); - }*/ - }; - - return result - .map(nodeToString) - .join(delimiter); - }, - - /** - * This tries to rename variable names in a code snippet according to a function. - * - * @param {string} input - * @param {function} replacer - this function will be fed the token which should be renamed. - * @returns {string} - */ - _replaceVariableNames(input, replacer) { - const tokenRegex = /\\"|"(?:\\"|[^"])*"|(\b[a-z0-9\-_]+\b)/ig; - - return input.replace(tokenRegex, (...args) => { - let match = args[0], - quotes = args[1]; - - if (!quotes) { - return match; - } else { - return replacer(match); - } - }); - }, - - - /** - * To Snake Case operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToSnakeCase(input, args) { - const smart = args[0]; - - if (smart) { - return Code._replaceVariableNames(input, snakeCase); - } else { - return snakeCase(input); - } - }, - - - /** - * To Camel Case operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToCamelCase(input, args) { - const smart = args[0]; - - if (smart) { - return Code._replaceVariableNames(input, camelCase); - } else { - return camelCase(input); - } - }, - - - /** - * To Kebab Case operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToKebabCase(input, args) { - const smart = args[0]; - - if (smart) { - return Code._replaceVariableNames(input, kebabCase); - } else { - return kebabCase(input); - } - }, - -}; - -export default Code; diff --git a/src/core/operations/legacy/Image.js b/src/core/operations/legacy/Image.js deleted file mode 100644 index 23581382..00000000 --- a/src/core/operations/legacy/Image.js +++ /dev/null @@ -1,125 +0,0 @@ -import * as ExifParser from "exif-parser"; -import removeEXIF from "../vendor/remove-exif.js"; -import Utils from "../Utils.js"; -import FileType from "./FileType.js"; -import {fromBase64, toBase64} from "../lib/Base64"; -import {fromHex} from "../lib/Hex"; - - -/** - * Image operations. - * - * @author tlwr [toby@toby.codes] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const Image = { - - /** - * Extract EXIF operation. - * - * Extracts EXIF data from a byteArray, representing a JPG or a TIFF image. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runExtractEXIF(input, args) { - try { - const parser = ExifParser.create(input); - const result = parser.parse(); - - let lines = []; - for (let tagName in result.tags) { - let value = result.tags[tagName]; - lines.push(`${tagName}: ${value}`); - } - - const numTags = lines.length; - lines.unshift(`Found ${numTags} tags.\n`); - return lines.join("\n"); - } catch (err) { - throw "Could not extract EXIF data from image: " + err; - } - }, - - - /** - * Remove EXIF operation. - * - * Removes EXIF data from a byteArray, representing a JPG. - * - * @author David Moodie [davidmoodie12@gmail.com] - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runRemoveEXIF(input, args) { - // Do nothing if input is empty - if (input.length === 0) return input; - - try { - return removeEXIF(input); - } catch (err) { - // Simply return input if no EXIF data is found - if (err === "Exif not found.") return input; - throw "Could not remove EXIF data from image: " + err; - } - }, - - - /** - * @constant - * @default - */ - INPUT_FORMAT: ["Raw", "Base64", "Hex"], - - /** - * Render Image operation. - * - * @author n1474335 [n1474335@gmail.com] - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runRenderImage(input, args) { - const inputFormat = args[0]; - let dataURI = "data:"; - - if (!input.length) return ""; - - // Convert input to raw bytes - switch (inputFormat) { - case "Hex": - input = fromHex(input); - break; - case "Base64": - // Don't trust the Base64 entered by the user. - // Unwrap it first, then re-encode later. - input = fromBase64(input, null, "byteArray"); - break; - case "Raw": - default: - input = Utils.strToByteArray(input); - break; - } - - // Determine file type - const type = FileType.magicType(input); - if (type && type.mime.indexOf("image") === 0) { - dataURI += type.mime + ";"; - } else { - throw "Invalid file type"; - } - - // Add image data to URI - dataURI += "base64," + toBase64(input); - - return ""; - }, - -}; - -export default Image; diff --git a/src/core/vendor/remove-exif.js b/src/core/vendor/remove-exif.mjs similarity index 98% rename from src/core/vendor/remove-exif.js rename to src/core/vendor/remove-exif.mjs index 5dbb5bb0..6c5c9e53 100644 --- a/src/core/vendor/remove-exif.js +++ b/src/core/vendor/remove-exif.mjs @@ -18,10 +18,10 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -import Utils from "../Utils.js"; +import Utils from "../Utils.mjs"; // Param jpeg should be a binaryArray -function removeEXIF(jpeg) { +export function removeEXIF(jpeg) { // Convert binaryArray to char string jpeg = Utils.byteArrayToChars(jpeg); if (jpeg.slice(0, 2) != "\xff\xd8") { @@ -149,5 +149,3 @@ function unpack(mark, str) { return unpacked; } - -export default removeEXIF; diff --git a/test/index.mjs b/test/index.mjs index cd7a2278..11811e7e 100644 --- a/test/index.mjs +++ b/test/index.mjs @@ -45,7 +45,7 @@ import "./tests/operations/Register"; import "./tests/operations/Comment"; import "./tests/operations/Hash"; import "./tests/operations/Hexdump"; -// import "./tests/operations/Image"; +import "./tests/operations/Image"; import "./tests/operations/MorseCode"; import "./tests/operations/MS"; import "./tests/operations/PHP"; diff --git a/test/tests/operations/Image.mjs b/test/tests/operations/Image.mjs index 4cb405e3..a24cfa20 100644 --- a/test/tests/operations/Image.mjs +++ b/test/tests/operations/Image.mjs @@ -57,7 +57,7 @@ TestRegister.addTests([ { name: "Extract EXIF: hello world text (error)", input: "hello world", - expectedError: true, + expectedOutput: "Could not extract EXIF data from image: Error: Invalid JPEG section offset", recipeConfig: [ { op: "Extract EXIF", @@ -129,7 +129,7 @@ TestRegister.addTests([ { name: "Remove EXIF: hello world text (error)", input: "hello world", - expectedError: true, + expectedOutput: "Could not remove EXIF data from image: Given data is not jpeg.", recipeConfig: [ { op: "Remove EXIF", From 049656ec6bc6796285a9c23a03da351d7558e896 Mon Sep 17 00:00:00 2001 From: Matt C Date: Sun, 27 May 2018 23:53:43 +0100 Subject: [PATCH 20/23] ESM: Ported PublicKey operations --- src/core/lib/PublicKey.mjs | 72 ++++++ src/core/operations/HexToObjectIdentifier.mjs | 40 ++++ src/core/operations/HexToPEM.mjs | 46 ++++ src/core/operations/ObjectIdentifierToHex.mjs | 40 ++++ src/core/operations/PEMToHex.mjs | 50 ++++ src/core/operations/ParseASN1HexString.mjs | 54 +++++ src/core/operations/ParseX509Certificate.mjs | 216 ++++++++++++++++++ 7 files changed, 518 insertions(+) create mode 100644 src/core/lib/PublicKey.mjs create mode 100644 src/core/operations/HexToObjectIdentifier.mjs create mode 100644 src/core/operations/HexToPEM.mjs create mode 100644 src/core/operations/ObjectIdentifierToHex.mjs create mode 100644 src/core/operations/PEMToHex.mjs create mode 100644 src/core/operations/ParseASN1HexString.mjs create mode 100644 src/core/operations/ParseX509Certificate.mjs diff --git a/src/core/lib/PublicKey.mjs b/src/core/lib/PublicKey.mjs new file mode 100644 index 00000000..2fabc89d --- /dev/null +++ b/src/core/lib/PublicKey.mjs @@ -0,0 +1,72 @@ +/** + * Public key functions. + * + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import { toHex, fromHex } from "./Hex"; + +/** + * Formats Distinguished Name (DN) strings. + * + * @param {string} dnStr + * @param {number} indent + * @returns {string} + */ +export function formatDnStr (dnStr, indent) { + const fields = dnStr.substr(1).replace(/([^\\])\//g, "$1$1/").split(/[^\\]\//); + let output = "", + maxKeyLen = 0, + key, + value, + i, + str; + + for (i = 0; i < fields.length; i++) { + if (!fields[i].length) continue; + + key = fields[i].split("=")[0]; + + maxKeyLen = key.length > maxKeyLen ? key.length : maxKeyLen; + } + + for (i = 0; i < fields.length; i++) { + if (!fields[i].length) continue; + + key = fields[i].split("=")[0]; + value = fields[i].split("=")[1]; + str = key.padEnd(maxKeyLen, " ") + " = " + value + "\n"; + + output += str.padStart(indent + str.length, " "); + } + + return output.slice(0, -1); +} + + +/** + * Formats byte strings by adding line breaks and delimiters. + * + * @param {string} byteStr + * @param {number} length - Line width + * @param {number} indent + * @returns {string} + */ +export function formatByteStr (byteStr, length, indent) { + byteStr = toHex(fromHex(byteStr), ":"); + length = length * 3; + let output = ""; + + for (let i = 0; i < byteStr.length; i += length) { + const str = byteStr.slice(i, i + length) + "\n"; + if (i === 0) { + output += str; + } else { + output += str.padStart(indent + str.length, " "); + } + } + + return output.slice(0, output.length-1); +} diff --git a/src/core/operations/HexToObjectIdentifier.mjs b/src/core/operations/HexToObjectIdentifier.mjs new file mode 100644 index 00000000..00512e1a --- /dev/null +++ b/src/core/operations/HexToObjectIdentifier.mjs @@ -0,0 +1,40 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import Operation from "../Operation"; + +/** + * Hex to Object Identifier operation + */ +class HexToObjectIdentifier extends Operation { + + /** + * HexToObjectIdentifier constructor + */ + constructor() { + super(); + + this.name = "Hex to Object Identifier"; + this.module = "PublicKey"; + this.description = "Converts a hexadecimal string into an object identifier (OID)."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + return r.KJUR.asn1.ASN1Util.oidHexToInt(input.replace(/\s/g, "")); + } + +} + +export default HexToObjectIdentifier; diff --git a/src/core/operations/HexToPEM.mjs b/src/core/operations/HexToPEM.mjs new file mode 100644 index 00000000..c08888d4 --- /dev/null +++ b/src/core/operations/HexToPEM.mjs @@ -0,0 +1,46 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import Operation from "../Operation"; + +/** + * Hex to PEM operation + */ +class HexToPEM extends Operation { + + /** + * HexToPEM constructor + */ + constructor() { + super(); + + this.name = "Hex to PEM"; + this.module = "PublicKey"; + this.description = "Converts a hexadecimal DER (Distinguished Encoding Rules) string into PEM (Privacy Enhanced Mail) format."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Header string", + "type": "string", + "value": "CERTIFICATE" + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + return r.KJUR.asn1.ASN1Util.getPEMStringFromHex(input.replace(/\s/g, ""), args[0]); + } + +} + +export default HexToPEM; diff --git a/src/core/operations/ObjectIdentifierToHex.mjs b/src/core/operations/ObjectIdentifierToHex.mjs new file mode 100644 index 00000000..9be7108c --- /dev/null +++ b/src/core/operations/ObjectIdentifierToHex.mjs @@ -0,0 +1,40 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import Operation from "../Operation"; + +/** + * Object Identifier to Hex operation + */ +class ObjectIdentifierToHex extends Operation { + + /** + * ObjectIdentifierToHex constructor + */ + constructor() { + super(); + + this.name = "Object Identifier to Hex"; + this.module = "PublicKey"; + this.description = "Converts an object identifier (OID) into a hexadecimal string."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + return r.KJUR.asn1.ASN1Util.oidIntToHex(input); + } + +} + +export default ObjectIdentifierToHex; diff --git a/src/core/operations/PEMToHex.mjs b/src/core/operations/PEMToHex.mjs new file mode 100644 index 00000000..36ac4d71 --- /dev/null +++ b/src/core/operations/PEMToHex.mjs @@ -0,0 +1,50 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import Operation from "../Operation"; + +/** + * PEM to Hex operation + */ +class PEMToHex extends Operation { + + /** + * PEMToHex constructor + */ + constructor() { + super(); + + this.name = "PEM to Hex"; + this.module = "PublicKey"; + this.description = "Converts PEM (Privacy Enhanced Mail) format to a hexadecimal DER (Distinguished Encoding Rules) string."; + this.inputType = "string"; + this.outputType = "string"; + this.args = []; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + if (input.indexOf("-----BEGIN") < 0) { + // Add header so that the KEYUTIL function works + input = "-----BEGIN CERTIFICATE-----" + input; + } + if (input.indexOf("-----END") < 0) { + // Add footer so that the KEYUTIL function works + input = input + "-----END CERTIFICATE-----"; + } + const cert = new r.X509(); + cert.readCertPEM(input); + return cert.hex; + } + +} + +export default PEMToHex; diff --git a/src/core/operations/ParseASN1HexString.mjs b/src/core/operations/ParseASN1HexString.mjs new file mode 100644 index 00000000..9f192156 --- /dev/null +++ b/src/core/operations/ParseASN1HexString.mjs @@ -0,0 +1,54 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import Operation from "../Operation"; + +/** + * Parse ASN.1 hex string operation + */ +class ParseASN1HexString extends Operation { + + /** + * ParseASN1HexString constructor + */ + constructor() { + super(); + + this.name = "Parse ASN.1 hex string"; + this.module = "PublicKey"; + this.description = "Abstract Syntax Notation One (ASN.1) is a standard and notation that describes rules and structures for representing, encoding, transmitting, and decoding data in telecommunications and computer networking.

This operation parses arbitrary ASN.1 data and presents the resulting tree."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Starting index", + "type": "number", + "value": 0 + }, + { + "name": "Truncate octet strings longer than", + "type": "number", + "value": 32 + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [index, truncateLen] = args; + return r.ASN1HEX.dump(input.replace(/\s/g, ""), { + "ommitLongOctet": truncateLen + }, index); + } + +} + +export default ParseASN1HexString; diff --git a/src/core/operations/ParseX509Certificate.mjs b/src/core/operations/ParseX509Certificate.mjs new file mode 100644 index 00000000..99040cdf --- /dev/null +++ b/src/core/operations/ParseX509Certificate.mjs @@ -0,0 +1,216 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2016 + * @license Apache-2.0 + */ + +import r from "jsrsasign"; +import { fromBase64 } from "../lib/Base64"; +import { toHex } from "../lib/Hex"; +import { formatByteStr, formatDnStr } from "../lib/PublicKey"; +import Operation from "../Operation"; +import Utils from "../Utils"; + +/** + * Parse X.509 certificate operation + */ +class ParseX509Certificate extends Operation { + + /** + * ParseX509Certificate constructor + */ + constructor() { + super(); + + this.name = "Parse X.509 certificate"; + this.module = "PublicKey"; + this.description = "X.509 is an ITU-T standard for a public key infrastructure (PKI) and Privilege Management Infrastructure (PMI). It is commonly involved with SSL/TLS security.

This operation displays the contents of a certificate in a human readable format, similar to the openssl command line tool.

Tags: X509, server hello, handshake"; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Input format", + "type": "option", + "value": ["PEM", "DER Hex", "Base64", "Raw"] + } + ]; + this.patterns = [ + { + "match": "^-+BEGIN CERTIFICATE-+\\r?\\n[\\da-z+/\\n\\r]+-+END CERTIFICATE-+\\r?\\n?$", + "flags": "i", + "args": [ + "PEM" + ] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + if (!input.length) { + return "No input"; + } + + const cert = new r.X509(), + inputFormat = args[0]; + + switch (inputFormat) { + case "DER Hex": + input = input.replace(/\s/g, ""); + cert.readCertHex(input); + break; + case "PEM": + cert.readCertPEM(input); + break; + case "Base64": + cert.readCertHex(toHex(fromBase64(input, null, "byteArray"), "")); + break; + case "Raw": + cert.readCertHex(toHex(Utils.strToByteArray(input), "")); + break; + default: + throw "Undefined input format"; + } + + const sn = cert.getSerialNumberHex(), + issuer = cert.getIssuerString(), + subject = cert.getSubjectString(), + pk = cert.getPublicKey(), + pkFields = [], + sig = cert.getSignatureValueHex(); + + let pkStr = "", + sigStr = "", + extensions = ""; + + // Public Key fields + pkFields.push({ + key: "Algorithm", + value: pk.type + }); + + if (pk.type === "EC") { // ECDSA + pkFields.push({ + key: "Curve Name", + value: pk.curveName + }); + pkFields.push({ + key: "Length", + value: (((new r.BigInteger(pk.pubKeyHex, 16)).bitLength()-3) /2) + " bits" + }); + pkFields.push({ + key: "pub", + value: formatByteStr(pk.pubKeyHex, 16, 18) + }); + } else if (pk.type === "DSA") { // DSA + pkFields.push({ + key: "pub", + value: formatByteStr(pk.y.toString(16), 16, 18) + }); + pkFields.push({ + key: "P", + value: formatByteStr(pk.p.toString(16), 16, 18) + }); + pkFields.push({ + key: "Q", + value: formatByteStr(pk.q.toString(16), 16, 18) + }); + pkFields.push({ + key: "G", + value: formatByteStr(pk.g.toString(16), 16, 18) + }); + } else if (pk.e) { // RSA + pkFields.push({ + key: "Length", + value: pk.n.bitLength() + " bits" + }); + pkFields.push({ + key: "Modulus", + value: formatByteStr(pk.n.toString(16), 16, 18) + }); + pkFields.push({ + key: "Exponent", + value: pk.e + " (0x" + pk.e.toString(16) + ")" + }); + } else { + pkFields.push({ + key: "Error", + value: "Unknown Public Key type" + }); + } + + // Format Public Key fields + for (let i = 0; i < pkFields.length; i++) { + pkStr += ` ${pkFields[i].key}:${(pkFields[i].value + "\n").padStart( + 18 - (pkFields[i].key.length + 3) + pkFields[i].value.length + 1, + " " + )}`; + } + + // Signature fields + let breakoutSig = false; + try { + breakoutSig = r.ASN1HEX.dump(sig).indexOf("SEQUENCE") === 0; + } catch (err) { + // Error processing signature, output without further breakout + } + + if (breakoutSig) { // DSA or ECDSA + sigStr = ` r: ${formatByteStr(r.ASN1HEX.getV(sig, 4), 16, 18)} + s: ${formatByteStr(r.ASN1HEX.getV(sig, 48), 16, 18)}`; + } else { // RSA or unknown + sigStr = ` Signature: ${formatByteStr(sig, 16, 18)}`; + } + + // Extensions + try { + extensions = cert.getInfo().split("X509v3 Extensions:\n")[1].split("signature")[0]; + } catch (err) {} + + const issuerStr = formatDnStr(issuer, 2), + nbDate = formatDate(cert.getNotBefore()), + naDate = formatDate(cert.getNotAfter()), + subjectStr = formatDnStr(subject, 2); + + return `Version: ${cert.version} (0x${Utils.hex(cert.version - 1)}) +Serial number: ${new r.BigInteger(sn, 16).toString()} (0x${sn}) +Algorithm ID: ${cert.getSignatureAlgorithmField()} +Validity + Not Before: ${nbDate} (dd-mm-yy hh:mm:ss) (${cert.getNotBefore()}) + Not After: ${naDate} (dd-mm-yy hh:mm:ss) (${cert.getNotAfter()}) +Issuer +${issuerStr} +Subject +${subjectStr} +Public Key +${pkStr.slice(0, -1)} +Certificate Signature + Algorithm: ${cert.getSignatureAlgorithmName()} +${sigStr} + +Extensions +${extensions}`; + } + +} + +export default ParseX509Certificate; + +/** + * Formats dates. + * + * @param {string} dateStr + * @returns {string} + */ +function formatDate (dateStr) { + return dateStr[4] + dateStr[5] + "/" + + dateStr[2] + dateStr[3] + "/" + + dateStr[0] + dateStr[1] + " " + + dateStr[6] + dateStr[7] + ":" + + dateStr[8] + dateStr[9] + ":" + + dateStr[10] + dateStr[11]; +} From 6a561185df58c0e008aa5f8e671d87d15d455e3b Mon Sep 17 00:00:00 2001 From: Matt C Date: Mon, 28 May 2018 00:39:03 +0100 Subject: [PATCH 21/23] ESM: Ported RegEx operations --- src/core/operations/FindReplace.mjs | 86 +++++++ src/core/operations/RegularExpression.mjs | 263 ++++++++++++++++++++++ test/index.mjs | 2 +- 3 files changed, 350 insertions(+), 1 deletion(-) create mode 100644 src/core/operations/FindReplace.mjs create mode 100644 src/core/operations/RegularExpression.mjs diff --git a/src/core/operations/FindReplace.mjs b/src/core/operations/FindReplace.mjs new file mode 100644 index 00000000..b983e69a --- /dev/null +++ b/src/core/operations/FindReplace.mjs @@ -0,0 +1,86 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2018 + * @license Apache-2.0 + */ + +import Operation from "../Operation"; +import Utils from "../Utils"; + +/** + * Find / Replace operation + */ +class FindReplace extends Operation { + + /** + * FindReplace constructor + */ + constructor() { + super(); + + this.name = "Find / Replace"; + this.module = "Regex"; + this.description = "Replaces all occurrences of the first string with the second.

Includes support for regular expressions (regex), simple strings and extended strings (which support \\n, \\r, \\t, \\b, \\f and escaped hex bytes using \\x notation, e.g. \\x00 for a null byte)."; + this.inputType = "string"; + this.outputType = "string"; + this.args = [ + { + "name": "Find", + "type": "toggleString", + "value": "", + "toggleValues": ["Regex", "Extended (\\n, \\t, \\x...)", "Simple string"] + }, + { + "name": "Replace", + "type": "binaryString", + "value": "" + }, + { + "name": "Global match", + "type": "boolean", + "value": true + }, + { + "name": "Case insensitive", + "type": "boolean", + "value": false + }, + { + "name": "Multiline matching", + "type": "boolean", + "value": true + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {string} + */ + run(input, args) { + const [{option: type}, replace, g, i, m] = args; + let find = args[0].string, + modifiers = ""; + + if (g) modifiers += "g"; + if (i) modifiers += "i"; + if (m) modifiers += "m"; + + if (type === "Regex") { + find = new RegExp(find, modifiers); + return input.replace(find, replace); + } + + if (type.indexOf("Extended") === 0) { + find = Utils.parseEscapedChars(find); + } + + find = new RegExp(Utils.escapeRegex(find), modifiers); + + return input.replace(find, replace); + } + +} + +export default FindReplace; diff --git a/src/core/operations/RegularExpression.mjs b/src/core/operations/RegularExpression.mjs new file mode 100644 index 00000000..05f6fefb --- /dev/null +++ b/src/core/operations/RegularExpression.mjs @@ -0,0 +1,263 @@ +/** + * @author n1474335 [n1474335@gmail.com] + * @copyright Crown Copyright 2018 + * @license Apache-2.0 + */ + +import XRegExp from "xregexp"; +import Operation from "../Operation"; +import Utils from "../Utils"; + +/** + * Regular expression operation + */ +class RegularExpression extends Operation { + + /** + * RegularExpression constructor + */ + constructor() { + super(); + + this.name = "Regular expression"; + this.module = "Regex"; + this.description = "Define your own regular expression (regex) to search the input data with, optionally choosing from a list of pre-defined patterns.

Supports extended regex syntax including the 'dot matches all' flag, named capture groups, full unicode coverage (including \\p{} categories and scripts as well as astral codes) and recursive matching."; + this.inputType = "string"; + this.outputType = "html"; + this.args = [ + { + "name": "Built in regexes", + "type": "populateOption", + "value": [ + { + name: "User defined", + value: "" + }, + { + name: "IPv4 address", + value: "(?:(?:\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d|\\d)(?:\\/\\d{1,2})?" + }, + { + name: "IPv6 address", + value: "((?=.*::)(?!.*::.+::)(::)?([\\dA-Fa-f]{1,4}:(:|\\b)|){5}|([\\dA-Fa-f]{1,4}:){6})((([\\dA-Fa-f]{1,4}((?!\\3)::|:\\b|(?![\\dA-Fa-f])))|(?!\\2\\3)){2}|(((2[0-4]|1\\d|[1-9])?\\d|25[0-5])\\.?\\b){4})" + }, + { + name: "Email address", + value: "\\b(\\w[-.\\w]*)@([-\\w]+(?:\\.[-\\w]+)*)\\.([A-Za-z]{2,4})\\b" + }, + { + name: "URL", + value: "([A-Za-z]+://)([-\\w]+(?:\\.\\w[-\\w]*)+)(:\\d+)?(/[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]*(?:[.!,?]+[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]+)*)?" + }, + { + name: "Domain", + value: "\\b((?=[a-z0-9-]{1,63}\\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,63}\\b" + }, + { + name: "Windows file path", + value: "([A-Za-z]):\\\\((?:[A-Za-z\\d][A-Za-z\\d\\- \\x27_\\(\\)~]{0,61}\\\\?)*[A-Za-z\\d][A-Za-z\\d\\- \\x27_\\(\\)]{0,61})(\\.[A-Za-z\\d]{1,6})?" + }, + { + name: "UNIX file path", + value: "(?:/[A-Za-z\\d.][A-Za-z\\d\\-.]{0,61})+" + }, + { + name: "MAC address", + value: "[A-Fa-f\\d]{2}(?:[:-][A-Fa-f\\d]{2}){5}" + }, + { + name: "Date (yyyy-mm-dd)", + value: "((?:19|20)\\d\\d)[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])" + }, + { + name: "Date (dd/mm/yyyy)", + value: "(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.]((?:19|20)\\d\\d)" + }, + { + name: "Date (mm/dd/yyyy)", + value: "(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.]((?:19|20)\\d\\d)" + }, + { + name: "Strings", + value: "[A-Za-z\\d/\\-:.,_$%\\x27\"()<>= !\\[\\]{}@]{4,}" + }, + ], + "target": 1 + }, + { + "name": "Regex", + "type": "text", + "value": "" + }, + { + "name": "Case insensitive", + "type": "boolean", + "value": true + }, + { + "name": "^ and $ match at newlines", + "type": "boolean", + "value": true + }, + { + "name": "Dot matches all", + "type": "boolean", + "value": false + }, + { + "name": "Unicode support", + "type": "boolean", + "value": false + }, + { + "name": "Astral support", + "type": "boolean", + "value": false + }, + { + "name": "Display total", + "type": "boolean", + "value": false + }, + { + "name": "Output format", + "type": "option", + "value": ["Highlight matches", "List matches", "List capture groups", "List matches with capture groups"] + } + ]; + } + + /** + * @param {string} input + * @param {Object[]} args + * @returns {html} + */ + run(input, args) { + const userRegex = args[1], + i = args[2], + m = args[3], + s = args[4], + u = args[5], + a = args[6], + displayTotal = args[7], + outputFormat = args[8]; + let modifiers = "g"; + + if (i) modifiers += "i"; + if (m) modifiers += "m"; + if (s) modifiers += "s"; + if (u) modifiers += "u"; + if (a) modifiers += "A"; + + if (userRegex && userRegex !== "^" && userRegex !== "$") { + try { + const regex = new XRegExp(userRegex, modifiers); + + switch (outputFormat) { + case "Highlight matches": + return regexHighlight(input, regex, displayTotal); + case "List matches": + return Utils.escapeHtml(regexList(input, regex, displayTotal, true, false)); + case "List capture groups": + return Utils.escapeHtml(regexList(input, regex, displayTotal, false, true)); + case "List matches with capture groups": + return Utils.escapeHtml(regexList(input, regex, displayTotal, true, true)); + default: + return "Error: Invalid output format"; + } + } catch (err) { + return "Invalid regex. Details: " + err.message; + } + } else { + return Utils.escapeHtml(input); + } + } + +} + +export default RegularExpression; + +/** + * Creates a string listing the matches within a string. + * + * @param {string} input + * @param {RegExp} regex + * @param {boolean} displayTotal + * @param {boolean} matches - Display full match + * @param {boolean} captureGroups - Display each of the capture groups separately + * @returns {string} + */ +function regexList (input, regex, displayTotal, matches, captureGroups) { + let output = "", + total = 0, + match; + + while ((match = regex.exec(input))) { + // Moves pointer when an empty string is matched (prevents infinite loop) + if (match.index === regex.lastIndex) { + regex.lastIndex++; + } + + total++; + if (matches) { + output += match[0] + "\n"; + } + if (captureGroups) { + for (let i = 1; i < match.length; i++) { + if (matches) { + output += " Group " + i + ": "; + } + output += match[i] + "\n"; + } + } + } + + if (displayTotal) + output = "Total found: " + total + "\n\n" + output; + + return output.slice(0, -1); +} + +/** + * Adds HTML highlights to matches within a string. + * + * @private + * @param {string} input + * @param {RegExp} regex + * @param {boolean} displayTotal + * @returns {string} + */ +function regexHighlight (input, regex, displayTotal) { + let output = "", + m, + hl = 1, + i = 0, + total = 0; + + while ((m = regex.exec(input))) { + // Moves pointer when an empty string is matched (prevents infinite loop) + if (m.index === regex.lastIndex) { + regex.lastIndex++; + } + + // Add up to match + output += Utils.escapeHtml(input.slice(i, m.index)); + + // Add match with highlighting + output += "" + Utils.escapeHtml(m[0]) + ""; + + // Switch highlight + hl = hl === 1 ? 2 : 1; + + i = regex.lastIndex; + total++; + } + + // Add all after final match + output += Utils.escapeHtml(input.slice(i, input.length)); + + if (displayTotal) + output = "Total found: " + total + "\n\n" + output; + + return output; +} diff --git a/test/index.mjs b/test/index.mjs index 11811e7e..7b235211 100644 --- a/test/index.mjs +++ b/test/index.mjs @@ -52,7 +52,7 @@ import "./tests/operations/PHP"; import "./tests/operations/NetBIOS"; import "./tests/operations/OTP"; import "./tests/operations/PowerSet"; -// import "./tests/operations/Regex"; +import "./tests/operations/Regex"; import "./tests/operations/Rotate"; import "./tests/operations/StrUtils"; import "./tests/operations/SeqUtils"; From 3f3a3e00166c4521fe2301dd4230f68ccd6ce735 Mon Sep 17 00:00:00 2001 From: n1474335 Date: Mon, 28 May 2018 15:42:43 -0700 Subject: [PATCH 22/23] ESM: Tidied up recently added operations --- package-lock.json | 4062 +++++++++--------- src/core/lib/PublicKey.mjs | 2 +- src/core/operations/CSSSelector.mjs | 10 +- src/core/operations/Diff.mjs | 21 +- src/core/operations/ExtractEXIF.mjs | 8 +- src/core/operations/FindReplace.mjs | 2 +- src/core/operations/ParseX509Certificate.mjs | 4 +- src/core/operations/RegularExpression.mjs | 21 +- src/core/operations/RemoveEXIF.mjs | 6 +- src/core/operations/RenderImage.mjs | 7 +- src/core/operations/XPathExpression.mjs | 5 +- test/tests/operations/Code.mjs | 3 +- 12 files changed, 2082 insertions(+), 2069 deletions(-) diff --git a/package-lock.json b/package-lock.json index 730e6b1f..e333a92f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,7 +12,7 @@ "requires": { "@webassemblyjs/helper-wasm-bytecode": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "debug": "^3.1.0", + "debug": "3.1.0", "webassemblyjs": "1.4.3" }, "dependencies": { @@ -39,7 +39,7 @@ "integrity": "sha512-e8+KZHh+RV8MUvoSRtuT1sFXskFnWG9vbDy47Oa166xX+l0dD5sERJ21g5/tcH8Yo95e9IN3u7Jc3NbhnUcSkw==", "dev": true, "requires": { - "debug": "^3.1.0" + "debug": "3.1.0" }, "dependencies": { "debug": { @@ -84,7 +84,7 @@ "@webassemblyjs/helper-buffer": "1.4.3", "@webassemblyjs/helper-wasm-bytecode": "1.4.3", "@webassemblyjs/wasm-gen": "1.4.3", - "debug": "^3.1.0" + "debug": "3.1.0" }, "dependencies": { "debug": { @@ -104,7 +104,7 @@ "integrity": "sha512-4u0LJLSPzuRDWHwdqsrThYn+WqMFVqbI2ltNrHvZZkzFPO8XOZ0HFQ5eVc4jY/TNHgXcnwrHjONhPGYuuf//KQ==", "dev": true, "requires": { - "leb": "^0.3.0" + "leb": "0.3.0" } }, "@webassemblyjs/validation": { @@ -130,7 +130,7 @@ "@webassemblyjs/wasm-opt": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", "@webassemblyjs/wast-printer": "1.4.3", - "debug": "^3.1.0" + "debug": "3.1.0" }, "dependencies": { "debug": { @@ -165,7 +165,7 @@ "@webassemblyjs/helper-buffer": "1.4.3", "@webassemblyjs/wasm-gen": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", - "debug": "^3.1.0" + "debug": "3.1.0" }, "dependencies": { "debug": { @@ -202,7 +202,7 @@ "@webassemblyjs/floating-point-hex-parser": "1.4.3", "@webassemblyjs/helper-code-frame": "1.4.3", "@webassemblyjs/helper-fsm": "1.4.3", - "long": "^3.2.0", + "long": "3.2.0", "webassemblyjs": "1.4.3" } }, @@ -214,7 +214,7 @@ "requires": { "@webassemblyjs/ast": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "long": "^3.2.0" + "long": "3.2.0" } }, "JSONSelect": { @@ -240,7 +240,7 @@ "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", "dev": true, "requires": { - "mime-types": "~2.1.18", + "mime-types": "2.1.18", "negotiator": "0.6.1" } }, @@ -250,19 +250,19 @@ "integrity": "sha512-HLvH8e5g312urx6ZRo+nxSHjhVHEcuUxbpjFaFQ1LZOtN19L0CSb5ppwxtxy0QZ05zYAcWmXH6lVurdb+mGuUw==", "dev": true, "requires": { - "axios": "^0.18.0", - "bluebird": "^3.5.1", - "chalk": "^2.3.1", - "commander": "^2.14.1", - "glob": "^7.1.2", - "html_codesniffer": "^2.1.1", - "jsdom": "^11.6.2", - "mkdirp": "^0.5.1", - "phantomjs-prebuilt": "^2.1.16", - "rc": "^1.2.5", - "underscore": "^1.8.3", - "unixify": "^1.0.0", - "validator": "^9.4.1" + "axios": "0.18.0", + "bluebird": "3.5.1", + "chalk": "2.4.1", + "commander": "2.15.1", + "glob": "7.1.2", + "html_codesniffer": "2.2.0", + "jsdom": "11.10.0", + "mkdirp": "0.5.1", + "phantomjs-prebuilt": "2.1.16", + "rc": "1.2.7", + "underscore": "1.9.0", + "unixify": "1.0.0", + "validator": "9.4.1" }, "dependencies": { "ansi-styles": { @@ -271,7 +271,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -280,9 +280,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -297,7 +297,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } }, "underscore": { @@ -320,7 +320,7 @@ "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", "dev": true, "requires": { - "acorn": "^5.0.0" + "acorn": "5.5.3" } }, "acorn-globals": { @@ -329,7 +329,7 @@ "integrity": "sha512-KjZwU26uG3u6eZcfGbTULzFcsoz6pegNKtHPksZPOUsiKo5bUmiBPa38FuHZ/Eun+XYh/JCCkS9AS3Lu4McQOQ==", "dev": true, "requires": { - "acorn": "^5.0.0" + "acorn": "5.5.3" } }, "acorn-jsx": { @@ -338,7 +338,7 @@ "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=", "dev": true, "requires": { - "acorn": "^3.0.4" + "acorn": "3.3.0" }, "dependencies": { "acorn": { @@ -355,10 +355,10 @@ "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", "dev": true, "requires": { - "co": "^4.6.0", - "fast-deep-equal": "^1.0.0", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.3.0" + "co": "4.6.0", + "fast-deep-equal": "1.1.0", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1" } }, "ajv-keywords": { @@ -406,8 +406,8 @@ "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", "dev": true, "requires": { - "micromatch": "^3.1.4", - "normalize-path": "^2.1.1" + "micromatch": "3.1.10", + "normalize-path": "2.1.1" } }, "aproba": { @@ -422,7 +422,7 @@ "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", "dev": true, "requires": { - "sprintf-js": "~1.0.2" + "sprintf-js": "1.0.3" } }, "arr-diff": { @@ -473,8 +473,8 @@ "integrity": "sha1-GEtI9i2S10UrsxsyMWXH+L0CJm0=", "dev": true, "requires": { - "define-properties": "^1.1.2", - "es-abstract": "^1.7.0" + "define-properties": "1.1.2", + "es-abstract": "1.11.0" } }, "array-union": { @@ -483,7 +483,7 @@ "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", "dev": true, "requires": { - "array-uniq": "^1.0.1" + "array-uniq": "1.0.3" } }, "array-uniq": { @@ -523,9 +523,9 @@ "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", "dev": true, "requires": { - "bn.js": "^4.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0" + "bn.js": "4.11.8", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.1" } }, "assert": { @@ -555,7 +555,7 @@ "integrity": "sha512-xAfGg1/NTLBBKlHFmnd7PlmUW9KhVQIUuSrYem9xzFUZy13ScvtyGGejaae9iAVRiRq9+Cx7DPFaAAhCpyxyPw==", "dev": true, "requires": { - "lodash": "^4.14.0" + "lodash": "4.17.10" } }, "async-each": { @@ -588,12 +588,12 @@ "integrity": "sha1-Hb0cg1ZY41zj+ZhAmdsAWFx4IBQ=", "dev": true, "requires": { - "browserslist": "^1.7.6", - "caniuse-db": "^1.0.30000634", - "normalize-range": "^0.1.2", - "num2fraction": "^1.2.2", - "postcss": "^5.2.16", - "postcss-value-parser": "^3.2.3" + "browserslist": "1.7.7", + "caniuse-db": "1.0.30000843", + "normalize-range": "0.1.2", + "num2fraction": "1.2.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" }, "dependencies": { "browserslist": { @@ -602,8 +602,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "^1.0.30000639", - "electron-to-chromium": "^1.2.7" + "caniuse-db": "1.0.30000843", + "electron-to-chromium": "1.3.47" } } } @@ -626,8 +626,8 @@ "integrity": "sha1-MtU+SFHv3AoRmTts0AB4nXDAUQI=", "dev": true, "requires": { - "follow-redirects": "^1.3.0", - "is-buffer": "^1.1.5" + "follow-redirects": "1.4.1", + "is-buffer": "1.1.6" } }, "babel-code-frame": { @@ -635,9 +635,9 @@ "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", "requires": { - "chalk": "^1.1.3", - "esutils": "^2.0.2", - "js-tokens": "^3.0.2" + "chalk": "1.1.3", + "esutils": "2.0.2", + "js-tokens": "3.0.2" } }, "babel-core": { @@ -646,25 +646,25 @@ "integrity": "sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==", "dev": true, "requires": { - "babel-code-frame": "^6.26.0", - "babel-generator": "^6.26.0", - "babel-helpers": "^6.24.1", - "babel-messages": "^6.23.0", - "babel-register": "^6.26.0", - "babel-runtime": "^6.26.0", - "babel-template": "^6.26.0", - "babel-traverse": "^6.26.0", - "babel-types": "^6.26.0", - "babylon": "^6.18.0", - "convert-source-map": "^1.5.1", - "debug": "^2.6.9", - "json5": "^0.5.1", - "lodash": "^4.17.4", - "minimatch": "^3.0.4", - "path-is-absolute": "^1.0.1", - "private": "^0.1.8", - "slash": "^1.0.0", - "source-map": "^0.5.7" + "babel-code-frame": "6.26.0", + "babel-generator": "6.26.1", + "babel-helpers": "6.24.1", + "babel-messages": "6.23.0", + "babel-register": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "convert-source-map": "1.5.1", + "debug": "2.6.9", + "json5": "0.5.1", + "lodash": "4.17.10", + "minimatch": "3.0.4", + "path-is-absolute": "1.0.1", + "private": "0.1.8", + "slash": "1.0.0", + "source-map": "0.5.7" }, "dependencies": { "source-map": { @@ -681,14 +681,14 @@ "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==", "dev": true, "requires": { - "babel-messages": "^6.23.0", - "babel-runtime": "^6.26.0", - "babel-types": "^6.26.0", - "detect-indent": "^4.0.0", - "jsesc": "^1.3.0", - "lodash": "^4.17.4", - "source-map": "^0.5.7", - "trim-right": "^1.0.1" + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "detect-indent": "4.0.0", + "jsesc": "1.3.0", + "lodash": "4.17.10", + "source-map": "0.5.7", + "trim-right": "1.0.1" }, "dependencies": { "jsesc": { @@ -711,9 +711,9 @@ "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=", "dev": true, "requires": { - "babel-helper-explode-assignable-expression": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-helper-explode-assignable-expression": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-call-delegate": { @@ -722,10 +722,10 @@ "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", "dev": true, "requires": { - "babel-helper-hoist-variables": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-define-map": { @@ -734,10 +734,10 @@ "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", "dev": true, "requires": { - "babel-helper-function-name": "^6.24.1", - "babel-runtime": "^6.26.0", - "babel-types": "^6.26.0", - "lodash": "^4.17.4" + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.10" } }, "babel-helper-explode-assignable-expression": { @@ -746,9 +746,9 @@ "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-function-name": { @@ -757,11 +757,11 @@ "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", "dev": true, "requires": { - "babel-helper-get-function-arity": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-get-function-arity": { @@ -770,8 +770,8 @@ "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-hoist-variables": { @@ -780,8 +780,8 @@ "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-optimise-call-expression": { @@ -790,8 +790,8 @@ "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-regex": { @@ -800,9 +800,9 @@ "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", "dev": true, "requires": { - "babel-runtime": "^6.26.0", - "babel-types": "^6.26.0", - "lodash": "^4.17.4" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.10" } }, "babel-helper-remap-async-to-generator": { @@ -811,11 +811,11 @@ "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=", "dev": true, "requires": { - "babel-helper-function-name": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helper-replace-supers": { @@ -824,12 +824,12 @@ "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", "dev": true, "requires": { - "babel-helper-optimise-call-expression": "^6.24.1", - "babel-messages": "^6.23.0", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-optimise-call-expression": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-helpers": { @@ -838,8 +838,8 @@ "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-loader": { @@ -848,9 +848,9 @@ "integrity": "sha512-/hbyEvPzBJuGpk9o80R0ZyTej6heEOr59GoEUtn8qFKbnx4cJm9FWES6J/iv644sYgrtVw9JJQkjaLW/bqb5gw==", "dev": true, "requires": { - "find-cache-dir": "^1.0.0", - "loader-utils": "^1.0.2", - "mkdirp": "^0.5.1" + "find-cache-dir": "1.0.0", + "loader-utils": "1.1.0", + "mkdirp": "0.5.1" } }, "babel-messages": { @@ -858,7 +858,7 @@ "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-check-es2015-constants": { @@ -867,7 +867,7 @@ "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-syntax-async-functions": { @@ -894,9 +894,9 @@ "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=", "dev": true, "requires": { - "babel-helper-remap-async-to-generator": "^6.24.1", - "babel-plugin-syntax-async-functions": "^6.8.0", - "babel-runtime": "^6.22.0" + "babel-helper-remap-async-to-generator": "6.24.1", + "babel-plugin-syntax-async-functions": "6.13.0", + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-builtin-extend": { @@ -904,8 +904,8 @@ "resolved": "https://registry.npmjs.org/babel-plugin-transform-builtin-extend/-/babel-plugin-transform-builtin-extend-1.1.2.tgz", "integrity": "sha1-Xpb+z1i4+h7XTvytiEdbKvPJEW4=", "requires": { - "babel-runtime": "^6.2.0", - "babel-template": "^6.3.0" + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-plugin-transform-es2015-arrow-functions": { @@ -914,7 +914,7 @@ "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-block-scoped-functions": { @@ -923,7 +923,7 @@ "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-block-scoping": { @@ -932,11 +932,11 @@ "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", "dev": true, "requires": { - "babel-runtime": "^6.26.0", - "babel-template": "^6.26.0", - "babel-traverse": "^6.26.0", - "babel-types": "^6.26.0", - "lodash": "^4.17.4" + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.10" } }, "babel-plugin-transform-es2015-classes": { @@ -945,15 +945,15 @@ "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", "dev": true, "requires": { - "babel-helper-define-map": "^6.24.1", - "babel-helper-function-name": "^6.24.1", - "babel-helper-optimise-call-expression": "^6.24.1", - "babel-helper-replace-supers": "^6.24.1", - "babel-messages": "^6.23.0", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-define-map": "6.26.0", + "babel-helper-function-name": "6.24.1", + "babel-helper-optimise-call-expression": "6.24.1", + "babel-helper-replace-supers": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-computed-properties": { @@ -962,8 +962,8 @@ "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-plugin-transform-es2015-destructuring": { @@ -972,7 +972,7 @@ "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-duplicate-keys": { @@ -981,8 +981,8 @@ "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-for-of": { @@ -991,7 +991,7 @@ "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-function-name": { @@ -1000,9 +1000,9 @@ "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", "dev": true, "requires": { - "babel-helper-function-name": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-literals": { @@ -1011,7 +1011,7 @@ "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-modules-amd": { @@ -1020,9 +1020,9 @@ "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", "dev": true, "requires": { - "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1" + "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-plugin-transform-es2015-modules-commonjs": { @@ -1031,10 +1031,10 @@ "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==", "dev": true, "requires": { - "babel-plugin-transform-strict-mode": "^6.24.1", - "babel-runtime": "^6.26.0", - "babel-template": "^6.26.0", - "babel-types": "^6.26.0" + "babel-plugin-transform-strict-mode": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-modules-systemjs": { @@ -1043,9 +1043,9 @@ "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", "dev": true, "requires": { - "babel-helper-hoist-variables": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1" + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-plugin-transform-es2015-modules-umd": { @@ -1054,9 +1054,9 @@ "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", "dev": true, "requires": { - "babel-plugin-transform-es2015-modules-amd": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1" + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" } }, "babel-plugin-transform-es2015-object-super": { @@ -1065,8 +1065,8 @@ "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", "dev": true, "requires": { - "babel-helper-replace-supers": "^6.24.1", - "babel-runtime": "^6.22.0" + "babel-helper-replace-supers": "6.24.1", + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-parameters": { @@ -1075,12 +1075,12 @@ "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", "dev": true, "requires": { - "babel-helper-call-delegate": "^6.24.1", - "babel-helper-get-function-arity": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-template": "^6.24.1", - "babel-traverse": "^6.24.1", - "babel-types": "^6.24.1" + "babel-helper-call-delegate": "6.24.1", + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-shorthand-properties": { @@ -1089,8 +1089,8 @@ "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-spread": { @@ -1099,7 +1099,7 @@ "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-sticky-regex": { @@ -1108,9 +1108,9 @@ "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", "dev": true, "requires": { - "babel-helper-regex": "^6.24.1", - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-plugin-transform-es2015-template-literals": { @@ -1119,7 +1119,7 @@ "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-typeof-symbol": { @@ -1128,7 +1128,7 @@ "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", "dev": true, "requires": { - "babel-runtime": "^6.22.0" + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-es2015-unicode-regex": { @@ -1137,9 +1137,9 @@ "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", "dev": true, "requires": { - "babel-helper-regex": "^6.24.1", - "babel-runtime": "^6.22.0", - "regexpu-core": "^2.0.0" + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "regexpu-core": "2.0.0" } }, "babel-plugin-transform-exponentiation-operator": { @@ -1148,9 +1148,9 @@ "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=", "dev": true, "requires": { - "babel-helper-builder-binary-assignment-operator-visitor": "^6.24.1", - "babel-plugin-syntax-exponentiation-operator": "^6.8.0", - "babel-runtime": "^6.22.0" + "babel-helper-builder-binary-assignment-operator-visitor": "6.24.1", + "babel-plugin-syntax-exponentiation-operator": "6.13.0", + "babel-runtime": "6.26.0" } }, "babel-plugin-transform-regenerator": { @@ -1159,7 +1159,7 @@ "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", "dev": true, "requires": { - "regenerator-transform": "^0.10.0" + "regenerator-transform": "0.10.1" } }, "babel-plugin-transform-strict-mode": { @@ -1168,8 +1168,8 @@ "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", "dev": true, "requires": { - "babel-runtime": "^6.22.0", - "babel-types": "^6.24.1" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" } }, "babel-polyfill": { @@ -1177,9 +1177,9 @@ "resolved": "https://registry.npmjs.org/babel-polyfill/-/babel-polyfill-6.26.0.tgz", "integrity": "sha1-N5k3q8Z9eJWXCtxiHyhM2WbPIVM=", "requires": { - "babel-runtime": "^6.26.0", - "core-js": "^2.5.0", - "regenerator-runtime": "^0.10.5" + "babel-runtime": "6.26.0", + "core-js": "2.5.6", + "regenerator-runtime": "0.10.5" }, "dependencies": { "regenerator-runtime": { @@ -1195,36 +1195,36 @@ "integrity": "sha512-9OR2afuKDneX2/q2EurSftUYM0xGu4O2D9adAhVfADDhrYDaxXV0rBbevVYoY9n6nyX1PmQW/0jtpJvUNr9CHg==", "dev": true, "requires": { - "babel-plugin-check-es2015-constants": "^6.22.0", - "babel-plugin-syntax-trailing-function-commas": "^6.22.0", - "babel-plugin-transform-async-to-generator": "^6.22.0", - "babel-plugin-transform-es2015-arrow-functions": "^6.22.0", - "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0", - "babel-plugin-transform-es2015-block-scoping": "^6.23.0", - "babel-plugin-transform-es2015-classes": "^6.23.0", - "babel-plugin-transform-es2015-computed-properties": "^6.22.0", - "babel-plugin-transform-es2015-destructuring": "^6.23.0", - "babel-plugin-transform-es2015-duplicate-keys": "^6.22.0", - "babel-plugin-transform-es2015-for-of": "^6.23.0", - "babel-plugin-transform-es2015-function-name": "^6.22.0", - "babel-plugin-transform-es2015-literals": "^6.22.0", - "babel-plugin-transform-es2015-modules-amd": "^6.22.0", - "babel-plugin-transform-es2015-modules-commonjs": "^6.23.0", - "babel-plugin-transform-es2015-modules-systemjs": "^6.23.0", - "babel-plugin-transform-es2015-modules-umd": "^6.23.0", - "babel-plugin-transform-es2015-object-super": "^6.22.0", - "babel-plugin-transform-es2015-parameters": "^6.23.0", - "babel-plugin-transform-es2015-shorthand-properties": "^6.22.0", - "babel-plugin-transform-es2015-spread": "^6.22.0", - "babel-plugin-transform-es2015-sticky-regex": "^6.22.0", - "babel-plugin-transform-es2015-template-literals": "^6.22.0", - "babel-plugin-transform-es2015-typeof-symbol": "^6.23.0", - "babel-plugin-transform-es2015-unicode-regex": "^6.22.0", - "babel-plugin-transform-exponentiation-operator": "^6.22.0", - "babel-plugin-transform-regenerator": "^6.22.0", - "browserslist": "^3.2.6", - "invariant": "^2.2.2", - "semver": "^5.3.0" + "babel-plugin-check-es2015-constants": "6.22.0", + "babel-plugin-syntax-trailing-function-commas": "6.22.0", + "babel-plugin-transform-async-to-generator": "6.24.1", + "babel-plugin-transform-es2015-arrow-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoping": "6.26.0", + "babel-plugin-transform-es2015-classes": "6.24.1", + "babel-plugin-transform-es2015-computed-properties": "6.24.1", + "babel-plugin-transform-es2015-destructuring": "6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "6.24.1", + "babel-plugin-transform-es2015-for-of": "6.23.0", + "babel-plugin-transform-es2015-function-name": "6.24.1", + "babel-plugin-transform-es2015-literals": "6.22.0", + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-plugin-transform-es2015-modules-commonjs": "6.26.2", + "babel-plugin-transform-es2015-modules-systemjs": "6.24.1", + "babel-plugin-transform-es2015-modules-umd": "6.24.1", + "babel-plugin-transform-es2015-object-super": "6.24.1", + "babel-plugin-transform-es2015-parameters": "6.24.1", + "babel-plugin-transform-es2015-shorthand-properties": "6.24.1", + "babel-plugin-transform-es2015-spread": "6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "6.24.1", + "babel-plugin-transform-es2015-template-literals": "6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "6.24.1", + "babel-plugin-transform-exponentiation-operator": "6.24.1", + "babel-plugin-transform-regenerator": "6.26.0", + "browserslist": "3.2.7", + "invariant": "2.2.4", + "semver": "5.5.0" } }, "babel-register": { @@ -1233,13 +1233,13 @@ "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", "dev": true, "requires": { - "babel-core": "^6.26.0", - "babel-runtime": "^6.26.0", - "core-js": "^2.5.0", - "home-or-tmp": "^2.0.0", - "lodash": "^4.17.4", - "mkdirp": "^0.5.1", - "source-map-support": "^0.4.15" + "babel-core": "6.26.3", + "babel-runtime": "6.26.0", + "core-js": "2.5.6", + "home-or-tmp": "2.0.0", + "lodash": "4.17.10", + "mkdirp": "0.5.1", + "source-map-support": "0.4.18" } }, "babel-runtime": { @@ -1247,8 +1247,8 @@ "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", "requires": { - "core-js": "^2.4.0", - "regenerator-runtime": "^0.11.0" + "core-js": "2.5.6", + "regenerator-runtime": "0.11.1" } }, "babel-template": { @@ -1256,11 +1256,11 @@ "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", "requires": { - "babel-runtime": "^6.26.0", - "babel-traverse": "^6.26.0", - "babel-types": "^6.26.0", - "babylon": "^6.18.0", - "lodash": "^4.17.4" + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "lodash": "4.17.10" } }, "babel-traverse": { @@ -1268,15 +1268,15 @@ "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", "requires": { - "babel-code-frame": "^6.26.0", - "babel-messages": "^6.23.0", - "babel-runtime": "^6.26.0", - "babel-types": "^6.26.0", - "babylon": "^6.18.0", - "debug": "^2.6.8", - "globals": "^9.18.0", - "invariant": "^2.2.2", - "lodash": "^4.17.4" + "babel-code-frame": "6.26.0", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "debug": "2.6.9", + "globals": "9.18.0", + "invariant": "2.2.4", + "lodash": "4.17.10" } }, "babel-types": { @@ -1284,10 +1284,10 @@ "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", "requires": { - "babel-runtime": "^6.26.0", - "esutils": "^2.0.2", - "lodash": "^4.17.4", - "to-fast-properties": "^1.0.3" + "babel-runtime": "6.26.0", + "esutils": "2.0.2", + "lodash": "4.17.10", + "to-fast-properties": "1.0.3" } }, "babylon": { @@ -1307,13 +1307,13 @@ "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", "dev": true, "requires": { - "cache-base": "^1.0.1", - "class-utils": "^0.3.5", - "component-emitter": "^1.2.1", - "define-property": "^1.0.0", - "isobject": "^3.0.1", - "mixin-deep": "^1.2.0", - "pascalcase": "^0.1.1" + "cache-base": "1.0.1", + "class-utils": "0.3.6", + "component-emitter": "1.2.1", + "define-property": "1.0.0", + "isobject": "3.0.1", + "mixin-deep": "1.3.1", + "pascalcase": "0.1.1" }, "dependencies": { "define-property": { @@ -1322,7 +1322,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "^1.0.0" + "is-descriptor": "1.0.2" } }, "is-accessor-descriptor": { @@ -1331,7 +1331,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-data-descriptor": { @@ -1340,7 +1340,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-descriptor": { @@ -1349,9 +1349,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" } } } @@ -1375,7 +1375,7 @@ "dev": true, "optional": true, "requires": { - "tweetnacl": "^0.14.3" + "tweetnacl": "0.14.5" }, "dependencies": { "tweetnacl": { @@ -1432,10 +1432,10 @@ "integrity": "sha1-5LoM5BCkaTYyM2dgnstOZVMSUGk=", "dev": true, "requires": { - "continuable-cache": "^0.3.1", - "error": "^7.0.0", - "raw-body": "~1.1.0", - "safe-json-parse": "~1.0.1" + "continuable-cache": "0.3.1", + "error": "7.0.2", + "raw-body": "1.1.7", + "safe-json-parse": "1.0.1" } }, "body-parser": { @@ -1445,15 +1445,15 @@ "dev": true, "requires": { "bytes": "3.0.0", - "content-type": "~1.0.4", + "content-type": "1.0.4", "debug": "2.6.9", - "depd": "~1.1.1", - "http-errors": "~1.6.2", + "depd": "1.1.2", + "http-errors": "1.6.3", "iconv-lite": "0.4.19", - "on-finished": "~2.3.0", + "on-finished": "2.3.0", "qs": "6.5.1", "raw-body": "2.3.2", - "type-is": "~1.6.15" + "type-is": "1.6.16" }, "dependencies": { "bytes": { @@ -1501,7 +1501,7 @@ "depd": "1.1.1", "inherits": "2.0.3", "setprototypeof": "1.0.3", - "statuses": ">= 1.3.1 < 2" + "statuses": "1.4.0" } } } @@ -1520,12 +1520,12 @@ "integrity": "sha1-jokKGD2O6aI5OzhExpGkK897yfU=", "dev": true, "requires": { - "array-flatten": "^2.1.0", - "deep-equal": "^1.0.1", - "dns-equal": "^1.0.0", - "dns-txt": "^2.0.2", - "multicast-dns": "^6.0.1", - "multicast-dns-service-types": "^1.1.0" + "array-flatten": "2.1.1", + "deep-equal": "1.0.1", + "dns-equal": "1.0.0", + "dns-txt": "2.0.2", + "multicast-dns": "6.2.3", + "multicast-dns-service-types": "1.1.0" } }, "boolbase": { @@ -1540,7 +1540,7 @@ "integrity": "sha1-T4owBctKfjiJ90kDD9JbluAdLjE=", "dev": true, "requires": { - "hoek": "4.x.x" + "hoek": "4.2.1" } }, "bootstrap": { @@ -1553,7 +1553,7 @@ "resolved": "https://registry.npmjs.org/bootstrap-colorpicker/-/bootstrap-colorpicker-2.5.2.tgz", "integrity": "sha512-krzBno9AMUwI2+IDwMvjnpqpa2f8womW0CCKmEcxGzVkolCFrt22jjMjzx1NZqB8C1DUdNgZP4LfyCsgpHRiYA==", "requires": { - "jquery": ">=1.10" + "jquery": "3.3.1" } }, "bootstrap-switch": { @@ -1567,7 +1567,7 @@ "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dev": true, "requires": { - "balanced-match": "^1.0.0", + "balanced-match": "1.0.0", "concat-map": "0.0.1" } }, @@ -1577,16 +1577,16 @@ "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", "dev": true, "requires": { - "arr-flatten": "^1.1.0", - "array-unique": "^0.3.2", - "extend-shallow": "^2.0.1", - "fill-range": "^4.0.0", - "isobject": "^3.0.1", - "repeat-element": "^1.1.2", - "snapdragon": "^0.8.1", - "snapdragon-node": "^2.0.1", - "split-string": "^3.0.2", - "to-regex": "^3.0.1" + "arr-flatten": "1.1.0", + "array-unique": "0.3.2", + "extend-shallow": "2.0.1", + "fill-range": "4.0.0", + "isobject": "3.0.1", + "repeat-element": "1.1.2", + "snapdragon": "0.8.2", + "snapdragon-node": "2.1.1", + "split-string": "3.1.0", + "to-regex": "3.0.2" }, "dependencies": { "extend-shallow": { @@ -1595,7 +1595,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } } } @@ -1618,12 +1618,12 @@ "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", "dev": true, "requires": { - "buffer-xor": "^1.0.3", - "cipher-base": "^1.0.0", - "create-hash": "^1.1.0", - "evp_bytestokey": "^1.0.3", - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.2.0", + "evp_bytestokey": "1.0.3", + "inherits": "2.0.3", + "safe-buffer": "5.1.2" } }, "browserify-cipher": { @@ -1632,9 +1632,9 @@ "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", "dev": true, "requires": { - "browserify-aes": "^1.0.4", - "browserify-des": "^1.0.0", - "evp_bytestokey": "^1.0.0" + "browserify-aes": "1.2.0", + "browserify-des": "1.0.1", + "evp_bytestokey": "1.0.3" } }, "browserify-des": { @@ -1643,9 +1643,9 @@ "integrity": "sha512-zy0Cobe3hhgpiOM32Tj7KQ3Vl91m0njwsjzZQK1L+JDf11dzP9qIvjreVinsvXrgfjhStXwUWAEpB9D7Gwmayw==", "dev": true, "requires": { - "cipher-base": "^1.0.1", - "des.js": "^1.0.0", - "inherits": "^2.0.1" + "cipher-base": "1.0.4", + "des.js": "1.0.0", + "inherits": "2.0.3" } }, "browserify-rsa": { @@ -1654,8 +1654,8 @@ "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", "dev": true, "requires": { - "bn.js": "^4.1.0", - "randombytes": "^2.0.1" + "bn.js": "4.11.8", + "randombytes": "2.0.6" } }, "browserify-sign": { @@ -1664,13 +1664,13 @@ "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", "dev": true, "requires": { - "bn.js": "^4.1.1", - "browserify-rsa": "^4.0.0", - "create-hash": "^1.1.0", - "create-hmac": "^1.1.2", - "elliptic": "^6.0.0", - "inherits": "^2.0.1", - "parse-asn1": "^5.0.0" + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.2.0", + "create-hmac": "1.1.7", + "elliptic": "6.4.0", + "inherits": "2.0.3", + "parse-asn1": "5.1.1" } }, "browserify-zlib": { @@ -1679,7 +1679,7 @@ "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", "dev": true, "requires": { - "pako": "~1.0.5" + "pako": "1.0.6" } }, "browserslist": { @@ -1688,8 +1688,8 @@ "integrity": "sha512-oYVLxFVqpX9uMhOIQBLtZL+CX4uY8ZpWcjNTaxyWl5rO8yA9SSNikFnAfvk8J3P/7z3BZwNmEqFKaJoYltj3MQ==", "dev": true, "requires": { - "caniuse-lite": "^1.0.30000835", - "electron-to-chromium": "^1.3.45" + "caniuse-lite": "1.0.30000843", + "electron-to-chromium": "1.3.47" } }, "bson": { @@ -1703,9 +1703,9 @@ "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", "dev": true, "requires": { - "base64-js": "^1.0.2", - "ieee754": "^1.1.4", - "isarray": "^1.0.0" + "base64-js": "1.3.0", + "ieee754": "1.1.11", + "isarray": "1.0.0" } }, "buffer-from": { @@ -1755,19 +1755,19 @@ "integrity": "sha512-Dph0MzuH+rTQzGPNT9fAnrPmMmjKfST6trxJeK7NQuHRaVw24VzPRWTmg9MpcwOVQZO0E1FBICUlFeNaKPIfHA==", "dev": true, "requires": { - "bluebird": "^3.5.1", - "chownr": "^1.0.1", - "glob": "^7.1.2", - "graceful-fs": "^4.1.11", - "lru-cache": "^4.1.1", - "mississippi": "^2.0.0", - "mkdirp": "^0.5.1", - "move-concurrently": "^1.0.1", - "promise-inflight": "^1.0.1", - "rimraf": "^2.6.2", - "ssri": "^5.2.4", - "unique-filename": "^1.1.0", - "y18n": "^4.0.0" + "bluebird": "3.5.1", + "chownr": "1.0.1", + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "lru-cache": "4.1.3", + "mississippi": "2.0.0", + "mkdirp": "0.5.1", + "move-concurrently": "1.0.1", + "promise-inflight": "1.0.1", + "rimraf": "2.6.2", + "ssri": "5.3.0", + "unique-filename": "1.1.0", + "y18n": "4.0.0" } }, "cache-base": { @@ -1776,15 +1776,15 @@ "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", "dev": true, "requires": { - "collection-visit": "^1.0.0", - "component-emitter": "^1.2.1", - "get-value": "^2.0.6", - "has-value": "^1.0.0", - "isobject": "^3.0.1", - "set-value": "^2.0.0", - "to-object-path": "^0.3.0", - "union-value": "^1.0.0", - "unset-value": "^1.0.0" + "collection-visit": "1.0.0", + "component-emitter": "1.2.1", + "get-value": "2.0.6", + "has-value": "1.0.0", + "isobject": "3.0.1", + "set-value": "2.0.0", + "to-object-path": "0.3.0", + "union-value": "1.0.0", + "unset-value": "1.0.0" } }, "caller-path": { @@ -1793,7 +1793,7 @@ "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", "dev": true, "requires": { - "callsites": "^0.2.0" + "callsites": "0.2.0" } }, "callsites": { @@ -1808,8 +1808,8 @@ "integrity": "sha1-yjw2iKTpzzpM2nd9xNy8cTJJz3M=", "dev": true, "requires": { - "no-case": "^2.2.0", - "upper-case": "^1.1.1" + "no-case": "2.3.2", + "upper-case": "1.1.3" } }, "camelcase": { @@ -1824,8 +1824,8 @@ "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", "dev": true, "requires": { - "camelcase": "^2.0.0", - "map-obj": "^1.0.0" + "camelcase": "2.1.1", + "map-obj": "1.0.1" } }, "caniuse-api": { @@ -1834,10 +1834,10 @@ "integrity": "sha1-tTTnxzTE+B7F++isoq0kNUuWLGw=", "dev": true, "requires": { - "browserslist": "^1.3.6", - "caniuse-db": "^1.0.30000529", - "lodash.memoize": "^4.1.2", - "lodash.uniq": "^4.5.0" + "browserslist": "1.7.7", + "caniuse-db": "1.0.30000843", + "lodash.memoize": "4.1.2", + "lodash.uniq": "4.5.0" }, "dependencies": { "browserslist": { @@ -1846,8 +1846,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "^1.0.30000639", - "electron-to-chromium": "^1.2.7" + "caniuse-db": "1.0.30000843", + "electron-to-chromium": "1.3.47" } } } @@ -1876,7 +1876,7 @@ "integrity": "sha1-mMyJDKZS3S7w5ws3klMQ/56Q/Is=", "dev": true, "requires": { - "underscore-contrib": "~0.3.0" + "underscore-contrib": "0.3.0" } }, "chalk": { @@ -1884,11 +1884,11 @@ "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", "requires": { - "ansi-styles": "^2.2.1", - "escape-string-regexp": "^1.0.2", - "has-ansi": "^2.0.0", - "strip-ansi": "^3.0.0", - "supports-color": "^2.0.0" + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" } }, "chardet": { @@ -1902,7 +1902,7 @@ "resolved": "https://registry.npmjs.org/chi-squared/-/chi-squared-1.1.0.tgz", "integrity": "sha1-iShlz/qOCnIPkhv8nGNcGawqNG0=", "requires": { - "gamma": "^1.0.0" + "gamma": "1.0.0" } }, "chokidar": { @@ -1911,18 +1911,18 @@ "integrity": "sha512-zW8iXYZtXMx4kux/nuZVXjkLP+CyIK5Al5FHnj1OgTKGZfp4Oy6/ymtMSKFv3GD8DviEmUPmJg9eFdJ/JzudMg==", "dev": true, "requires": { - "anymatch": "^2.0.0", - "async-each": "^1.0.0", - "braces": "^2.3.0", - "fsevents": "^1.1.2", - "glob-parent": "^3.1.0", - "inherits": "^2.0.1", - "is-binary-path": "^1.0.0", - "is-glob": "^4.0.0", - "normalize-path": "^2.1.1", - "path-is-absolute": "^1.0.0", - "readdirp": "^2.0.0", - "upath": "^1.0.0" + "anymatch": "2.0.0", + "async-each": "1.0.1", + "braces": "2.3.2", + "fsevents": "1.2.4", + "glob-parent": "3.1.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "4.0.0", + "normalize-path": "2.1.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0", + "upath": "1.1.0" } }, "chownr": { @@ -1943,8 +1943,8 @@ "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", "dev": true, "requires": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" + "inherits": "2.0.3", + "safe-buffer": "5.1.2" } }, "circular-json": { @@ -1964,7 +1964,7 @@ "integrity": "sha512-4CoL/A3hf90V3VIEjeuhSvlGFEHKzOz+Wfc2IVZc+FaUgU0ZQafJTP49fvnULipOPcAfqhyI2duwQyns6xqjYA==", "dev": true, "requires": { - "chalk": "^1.1.3" + "chalk": "1.1.3" } }, "class-utils": { @@ -1973,10 +1973,10 @@ "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", "dev": true, "requires": { - "arr-union": "^3.1.0", - "define-property": "^0.2.5", - "isobject": "^3.0.0", - "static-extend": "^0.1.1" + "arr-union": "3.1.0", + "define-property": "0.2.5", + "isobject": "3.0.1", + "static-extend": "0.1.2" }, "dependencies": { "define-property": { @@ -1985,7 +1985,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "^0.1.0" + "is-descriptor": "0.1.6" } } } @@ -1996,7 +1996,7 @@ "integrity": "sha1-Ls3xRaujj1R0DybO/Q/z4D4SXWo=", "dev": true, "requires": { - "source-map": "0.5.x" + "source-map": "0.5.7" }, "dependencies": { "source-map": { @@ -2014,7 +2014,7 @@ "dev": true, "requires": { "exit": "0.1.2", - "glob": "^7.1.1" + "glob": "7.1.2" } }, "cli-cursor": { @@ -2023,7 +2023,7 @@ "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", "dev": true, "requires": { - "restore-cursor": "^2.0.0" + "restore-cursor": "2.0.0" } }, "cli-width": { @@ -2038,9 +2038,9 @@ "integrity": "sha512-4FG+RSG9DL7uEwRUZXZn3SS34DiDPfzP0VOiEwtUWlE+AR2EIg+hSyvrIgUUfhdgR/UkAeW2QHgeP+hWrXs7jQ==", "dev": true, "requires": { - "string-width": "^2.1.1", - "strip-ansi": "^4.0.0", - "wrap-ansi": "^2.0.0" + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "wrap-ansi": "2.1.0" }, "dependencies": { "ansi-regex": { @@ -2055,7 +2055,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "^3.0.0" + "ansi-regex": "3.0.0" } } } @@ -2078,7 +2078,7 @@ "integrity": "sha1-qe8VNmDWqGqL3sAomlxoTSF0Mv0=", "dev": true, "requires": { - "q": "^1.1.2" + "q": "1.5.1" } }, "code-point-at": { @@ -2099,8 +2099,8 @@ "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", "dev": true, "requires": { - "map-visit": "^1.0.0", - "object-visit": "^1.0.0" + "map-visit": "1.0.0", + "object-visit": "1.0.1" } }, "color": { @@ -2109,9 +2109,9 @@ "integrity": "sha1-bXtcdPtl6EHNSHkq0e1eB7kE12Q=", "dev": true, "requires": { - "clone": "^1.0.2", - "color-convert": "^1.3.0", - "color-string": "^0.3.0" + "clone": "1.0.4", + "color-convert": "1.9.1", + "color-string": "0.3.0" } }, "color-convert": { @@ -2120,7 +2120,7 @@ "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==", "dev": true, "requires": { - "color-name": "^1.1.1" + "color-name": "1.1.3" } }, "color-name": { @@ -2135,7 +2135,7 @@ "integrity": "sha1-J9RvtnAlxcL6JZk7+/V55HhBuZE=", "dev": true, "requires": { - "color-name": "^1.0.0" + "color-name": "1.1.3" } }, "colormin": { @@ -2144,9 +2144,9 @@ "integrity": "sha1-6i90IKcrlogaOKrlnsEkpvcpgTM=", "dev": true, "requires": { - "color": "^0.11.0", + "color": "0.11.4", "css-color-names": "0.0.4", - "has": "^1.0.1" + "has": "1.0.1" } }, "colors": { @@ -2160,7 +2160,7 @@ "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", "dev": true, "requires": { - "delayed-stream": "~1.0.0" + "delayed-stream": "1.0.0" } }, "commander": { @@ -2187,22 +2187,22 @@ "integrity": "sha1-DRAgq5JLL9tNYnmHXH1tq6a6p6k=", "dev": true, "requires": { - "mime-db": ">= 1.33.0 < 2" + "mime-db": "1.33.0" } }, "compression": { "version": "1.7.2", - "resolved": "https://registry.npmjs.org/compression/-/compression-1.7.2.tgz", + "resolved": "http://registry.npmjs.org/compression/-/compression-1.7.2.tgz", "integrity": "sha1-qv+81qr4VLROuygDU9WtFlH1mmk=", "dev": true, "requires": { - "accepts": "~1.3.4", + "accepts": "1.3.5", "bytes": "3.0.0", - "compressible": "~2.0.13", + "compressible": "2.0.13", "debug": "2.6.9", - "on-headers": "~1.0.1", + "on-headers": "1.0.1", "safe-buffer": "5.1.1", - "vary": "~1.1.2" + "vary": "1.1.2" }, "dependencies": { "bytes": { @@ -2231,10 +2231,10 @@ "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", "dev": true, "requires": { - "buffer-from": "^1.0.0", - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" + "buffer-from": "1.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "typedarray": "0.0.6" } }, "connect-history-api-fallback": { @@ -2249,7 +2249,7 @@ "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", "dev": true, "requires": { - "date-now": "^0.1.4" + "date-now": "0.1.4" } }, "constants-browserify": { @@ -2300,12 +2300,12 @@ "integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==", "dev": true, "requires": { - "aproba": "^1.1.1", - "fs-write-stream-atomic": "^1.0.8", - "iferr": "^0.1.5", - "mkdirp": "^0.5.1", - "rimraf": "^2.5.4", - "run-queue": "^1.0.0" + "aproba": "1.2.0", + "fs-write-stream-atomic": "1.0.10", + "iferr": "0.1.5", + "mkdirp": "0.5.1", + "rimraf": "2.6.2", + "run-queue": "1.0.3" } }, "copy-descriptor": { @@ -2331,13 +2331,13 @@ "integrity": "sha512-GiNXLwAFPYHy25XmTPpafYvn3CLAkJ8FLsscq78MQd1Kh0OU6Yzhn4eV2MVF4G9WEQZoWEGltatdR+ntGPMl5A==", "dev": true, "requires": { - "is-directory": "^0.3.1", - "js-yaml": "^3.4.3", - "minimist": "^1.2.0", - "object-assign": "^4.1.0", - "os-homedir": "^1.0.1", - "parse-json": "^2.2.0", - "require-from-string": "^1.1.0" + "is-directory": "0.3.1", + "js-yaml": "3.7.0", + "minimist": "1.2.0", + "object-assign": "4.1.1", + "os-homedir": "1.0.2", + "parse-json": "2.2.0", + "require-from-string": "1.2.1" } }, "create-ecdh": { @@ -2346,8 +2346,8 @@ "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", "dev": true, "requires": { - "bn.js": "^4.1.0", - "elliptic": "^6.0.0" + "bn.js": "4.11.8", + "elliptic": "6.4.0" } }, "create-hash": { @@ -2356,11 +2356,11 @@ "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", "dev": true, "requires": { - "cipher-base": "^1.0.1", - "inherits": "^2.0.1", - "md5.js": "^1.3.4", - "ripemd160": "^2.0.1", - "sha.js": "^2.4.0" + "cipher-base": "1.0.4", + "inherits": "2.0.3", + "md5.js": "1.3.4", + "ripemd160": "2.0.2", + "sha.js": "2.4.11" } }, "create-hmac": { @@ -2369,12 +2369,12 @@ "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", "dev": true, "requires": { - "cipher-base": "^1.0.3", - "create-hash": "^1.1.0", - "inherits": "^2.0.1", - "ripemd160": "^2.0.0", - "safe-buffer": "^5.0.1", - "sha.js": "^2.4.8" + "cipher-base": "1.0.4", + "create-hash": "1.2.0", + "inherits": "2.0.3", + "ripemd160": "2.0.2", + "safe-buffer": "5.1.2", + "sha.js": "2.4.11" } }, "cross-spawn": { @@ -2383,9 +2383,9 @@ "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", "dev": true, "requires": { - "lru-cache": "^4.0.1", - "shebang-command": "^1.2.0", - "which": "^1.2.9" + "lru-cache": "4.1.3", + "shebang-command": "1.2.0", + "which": "1.3.0" } }, "cryptiles": { @@ -2394,7 +2394,7 @@ "integrity": "sha1-qJ+7Ig9c4l7FboxKqKT9e1sNKf4=", "dev": true, "requires": { - "boom": "5.x.x" + "boom": "5.2.0" }, "dependencies": { "boom": { @@ -2403,7 +2403,7 @@ "integrity": "sha512-Z5BTk6ZRe4tXXQlkqftmsAUANpXmuwlsF5Oov8ThoMbQRzdGTA1ngYRW160GexgOgjsFOKJz0LYhoNi+2AMBUw==", "dev": true, "requires": { - "hoek": "4.x.x" + "hoek": "4.2.1" } } } @@ -2419,17 +2419,17 @@ "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", "dev": true, "requires": { - "browserify-cipher": "^1.0.0", - "browserify-sign": "^4.0.0", - "create-ecdh": "^4.0.0", - "create-hash": "^1.1.0", - "create-hmac": "^1.1.0", - "diffie-hellman": "^5.0.0", - "inherits": "^2.0.1", - "pbkdf2": "^3.0.3", - "public-encrypt": "^4.0.0", - "randombytes": "^2.0.0", - "randomfill": "^1.0.3" + "browserify-cipher": "1.0.1", + "browserify-sign": "4.0.4", + "create-ecdh": "4.0.3", + "create-hash": "1.2.0", + "create-hmac": "1.1.7", + "diffie-hellman": "5.0.3", + "inherits": "2.0.3", + "pbkdf2": "3.0.16", + "public-encrypt": "4.0.2", + "randombytes": "2.0.6", + "randomfill": "1.0.4" } }, "crypto-js": { @@ -2449,20 +2449,20 @@ "integrity": "sha512-wovHgjAx8ZIMGSL8pTys7edA1ClmzxHeY6n/d97gg5odgsxEgKjULPR0viqyC+FWMCL9sfqoC/QCUBo62tLvPg==", "dev": true, "requires": { - "babel-code-frame": "^6.26.0", - "css-selector-tokenizer": "^0.7.0", - "cssnano": "^3.10.0", - "icss-utils": "^2.1.0", - "loader-utils": "^1.0.2", - "lodash.camelcase": "^4.3.0", - "object-assign": "^4.1.1", - "postcss": "^5.0.6", - "postcss-modules-extract-imports": "^1.2.0", - "postcss-modules-local-by-default": "^1.2.0", - "postcss-modules-scope": "^1.1.0", - "postcss-modules-values": "^1.3.0", - "postcss-value-parser": "^3.3.0", - "source-list-map": "^2.0.0" + "babel-code-frame": "6.26.0", + "css-selector-tokenizer": "0.7.0", + "cssnano": "3.10.0", + "icss-utils": "2.1.0", + "loader-utils": "1.1.0", + "lodash.camelcase": "4.3.0", + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-modules-extract-imports": "1.2.0", + "postcss-modules-local-by-default": "1.2.0", + "postcss-modules-scope": "1.1.0", + "postcss-modules-values": "1.3.0", + "postcss-value-parser": "3.3.0", + "source-list-map": "2.0.0" } }, "css-select": { @@ -2471,10 +2471,10 @@ "integrity": "sha1-KzoRBTnFNV8c2NMUYj6HCxIeyFg=", "dev": true, "requires": { - "boolbase": "~1.0.0", - "css-what": "2.1", + "boolbase": "1.0.0", + "css-what": "2.1.0", "domutils": "1.5.1", - "nth-check": "~1.0.1" + "nth-check": "1.0.1" } }, "css-selector-tokenizer": { @@ -2483,9 +2483,9 @@ "integrity": "sha1-5piEdK6MlTR3v15+/s/OzNnPTIY=", "dev": true, "requires": { - "cssesc": "^0.1.0", - "fastparse": "^1.1.1", - "regexpu-core": "^1.0.0" + "cssesc": "0.1.0", + "fastparse": "1.1.1", + "regexpu-core": "1.0.0" }, "dependencies": { "regexpu-core": { @@ -2494,9 +2494,9 @@ "integrity": "sha1-hqdj9Y7k18L2sQLkdkBQ3n7ZDGs=", "dev": true, "requires": { - "regenerate": "^1.2.1", - "regjsgen": "^0.2.0", - "regjsparser": "^0.1.4" + "regenerate": "1.4.0", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" } } } @@ -2519,38 +2519,38 @@ "integrity": "sha1-Tzj2zqK5sX+gFJDyPx3GjqZcHDg=", "dev": true, "requires": { - "autoprefixer": "^6.3.1", - "decamelize": "^1.1.2", - "defined": "^1.0.0", - "has": "^1.0.1", - "object-assign": "^4.0.1", - "postcss": "^5.0.14", - "postcss-calc": "^5.2.0", - "postcss-colormin": "^2.1.8", - "postcss-convert-values": "^2.3.4", - "postcss-discard-comments": "^2.0.4", - "postcss-discard-duplicates": "^2.0.1", - "postcss-discard-empty": "^2.0.1", - "postcss-discard-overridden": "^0.1.1", - "postcss-discard-unused": "^2.2.1", - "postcss-filter-plugins": "^2.0.0", - "postcss-merge-idents": "^2.1.5", - "postcss-merge-longhand": "^2.0.1", - "postcss-merge-rules": "^2.0.3", - "postcss-minify-font-values": "^1.0.2", - "postcss-minify-gradients": "^1.0.1", - "postcss-minify-params": "^1.0.4", - "postcss-minify-selectors": "^2.0.4", - "postcss-normalize-charset": "^1.1.0", - "postcss-normalize-url": "^3.0.7", - "postcss-ordered-values": "^2.1.0", - "postcss-reduce-idents": "^2.2.2", - "postcss-reduce-initial": "^1.0.0", - "postcss-reduce-transforms": "^1.0.3", - "postcss-svgo": "^2.1.1", - "postcss-unique-selectors": "^2.0.2", - "postcss-value-parser": "^3.2.3", - "postcss-zindex": "^2.0.1" + "autoprefixer": "6.7.7", + "decamelize": "1.2.0", + "defined": "1.0.0", + "has": "1.0.1", + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-calc": "5.3.1", + "postcss-colormin": "2.2.2", + "postcss-convert-values": "2.6.1", + "postcss-discard-comments": "2.0.4", + "postcss-discard-duplicates": "2.1.0", + "postcss-discard-empty": "2.1.0", + "postcss-discard-overridden": "0.1.1", + "postcss-discard-unused": "2.2.3", + "postcss-filter-plugins": "2.0.2", + "postcss-merge-idents": "2.1.7", + "postcss-merge-longhand": "2.0.2", + "postcss-merge-rules": "2.1.2", + "postcss-minify-font-values": "1.0.5", + "postcss-minify-gradients": "1.0.5", + "postcss-minify-params": "1.2.2", + "postcss-minify-selectors": "2.1.1", + "postcss-normalize-charset": "1.1.1", + "postcss-normalize-url": "3.0.8", + "postcss-ordered-values": "2.2.3", + "postcss-reduce-idents": "2.4.0", + "postcss-reduce-initial": "1.0.1", + "postcss-reduce-transforms": "1.0.4", + "postcss-svgo": "2.1.6", + "postcss-unique-selectors": "2.0.2", + "postcss-value-parser": "3.3.0", + "postcss-zindex": "2.2.0" } }, "csso": { @@ -2559,8 +2559,8 @@ "integrity": "sha1-3dUsWHAz9J6Utx/FVWnyUuj/X4U=", "dev": true, "requires": { - "clap": "^1.0.9", - "source-map": "^0.5.3" + "clap": "1.2.3", + "source-map": "0.5.7" }, "dependencies": { "source-map": { @@ -2583,7 +2583,7 @@ "integrity": "sha1-VBCXI0yyUTyDzu06zdwn/yeYfVQ=", "dev": true, "requires": { - "cssom": "0.3.x" + "cssom": "0.3.2" } }, "ctph.js": { @@ -2597,7 +2597,7 @@ "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", "dev": true, "requires": { - "array-find-index": "^1.0.1" + "array-find-index": "1.0.2" } }, "cyclist": { @@ -2612,7 +2612,7 @@ "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", "dev": true, "requires": { - "es5-ext": "^0.10.9" + "es5-ext": "0.10.42" } }, "dashdash": { @@ -2621,7 +2621,7 @@ "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", "dev": true, "requires": { - "assert-plus": "^1.0.0" + "assert-plus": "1.0.0" } }, "data-urls": { @@ -2630,9 +2630,9 @@ "integrity": "sha512-ai40PPQR0Fn1lD2PPie79CibnlMN2AYiDhwFX/rZHVsxbs5kNJSjegqXIprhouGXlRdEnfybva7kqRGnB6mypA==", "dev": true, "requires": { - "abab": "^1.0.4", - "whatwg-mimetype": "^2.0.0", - "whatwg-url": "^6.4.0" + "abab": "1.0.4", + "whatwg-mimetype": "2.1.0", + "whatwg-url": "6.4.1" } }, "datauri": { @@ -2641,9 +2641,9 @@ "integrity": "sha512-0q+cTTKx7q8eDteZRIQLTFJuiIsVing17UbWTPssY4JLSMaYsk/VKpNulBDo9NSgQWcvlPrkEHW8kUO67T/7mQ==", "dev": true, "requires": { - "image-size": "^0.6.2", - "mimer": "^0.3.2", - "semver": "^5.5.0" + "image-size": "0.6.2", + "mimer": "0.3.2", + "semver": "5.5.0" }, "dependencies": { "image-size": { @@ -2666,8 +2666,8 @@ "integrity": "sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=", "dev": true, "requires": { - "get-stdin": "^4.0.1", - "meow": "^3.3.0" + "get-stdin": "4.0.1", + "meow": "3.7.0" } }, "debug": { @@ -2707,7 +2707,7 @@ "integrity": "sha512-Y9mu+rplGcNZ7veer+5rqcdI9w3aPb7/WyE/nYnsuPevaE2z5YuC2u7/Gz/hIKsa0zo8sE8gKoBimSNsO/sr+A==", "dev": true, "requires": { - "lodash.isplainobject": "^4.0.6" + "lodash.isplainobject": "4.0.6" } }, "deep-is": { @@ -2721,8 +2721,8 @@ "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", "dev": true, "requires": { - "foreach": "^2.0.5", - "object-keys": "^1.0.8" + "foreach": "2.0.5", + "object-keys": "1.0.11" } }, "define-property": { @@ -2731,8 +2731,8 @@ "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, "requires": { - "is-descriptor": "^1.0.2", - "isobject": "^3.0.1" + "is-descriptor": "1.0.2", + "isobject": "3.0.1" }, "dependencies": { "is-accessor-descriptor": { @@ -2741,7 +2741,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-data-descriptor": { @@ -2750,7 +2750,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-descriptor": { @@ -2759,9 +2759,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" } } } @@ -2778,13 +2778,13 @@ "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=", "dev": true, "requires": { - "globby": "^5.0.0", - "is-path-cwd": "^1.0.0", - "is-path-in-cwd": "^1.0.0", - "object-assign": "^4.0.1", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "rimraf": "^2.2.8" + "globby": "5.0.0", + "is-path-cwd": "1.0.0", + "is-path-in-cwd": "1.0.1", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "rimraf": "2.6.2" }, "dependencies": { "pify": { @@ -2813,8 +2813,8 @@ "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", "dev": true, "requires": { - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0" + "inherits": "2.0.3", + "minimalistic-assert": "1.0.1" } }, "destroy": { @@ -2829,7 +2829,7 @@ "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", "dev": true, "requires": { - "repeating": "^2.0.0" + "repeating": "2.0.1" } }, "detect-node": { @@ -2849,9 +2849,9 @@ "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", "dev": true, "requires": { - "bn.js": "^4.1.0", - "miller-rabin": "^4.0.0", - "randombytes": "^2.0.0" + "bn.js": "4.11.8", + "miller-rabin": "4.0.1", + "randombytes": "2.0.6" } }, "dns-equal": { @@ -2866,8 +2866,8 @@ "integrity": "sha512-0UxfQkMhYAUaZI+xrNZOz/as5KgDU0M/fQ9b6SpkyLbk3GEswDi6PADJVaYJradtRVsRIlF1zLyOodbcTCDzUg==", "dev": true, "requires": { - "ip": "^1.1.0", - "safe-buffer": "^5.0.1" + "ip": "1.1.5", + "safe-buffer": "5.1.2" } }, "dns-txt": { @@ -2876,7 +2876,7 @@ "integrity": "sha1-uR2Ab10nGI5Ks+fRB9iBocxGQrY=", "dev": true, "requires": { - "buffer-indexof": "^1.0.0" + "buffer-indexof": "1.1.1" } }, "doctrine": { @@ -2885,7 +2885,7 @@ "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", "dev": true, "requires": { - "esutils": "^2.0.2" + "esutils": "2.0.2" } }, "dom-converter": { @@ -2894,7 +2894,7 @@ "integrity": "sha1-pF71cnuJDJv/5tfIduexnLDhfzs=", "dev": true, "requires": { - "utila": "~0.3" + "utila": "0.3.3" }, "dependencies": { "utila": { @@ -2911,8 +2911,8 @@ "integrity": "sha1-BzxpdUbOB4DOI75KKOKT5AvDDII=", "dev": true, "requires": { - "domelementtype": "~1.1.1", - "entities": "~1.1.1" + "domelementtype": "1.1.3", + "entities": "1.1.1" }, "dependencies": { "domelementtype": { @@ -2947,7 +2947,7 @@ "integrity": "sha512-raigMkn7CJNNo6Ihro1fzG7wr3fHuYVytzquZKX5n0yizGsTcYgzdIUwj1X9pK0VvjeihV+XiclP+DjwbsSKug==", "dev": true, "requires": { - "webidl-conversions": "^4.0.2" + "webidl-conversions": "4.0.2" } }, "domhandler": { @@ -2956,7 +2956,7 @@ "integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=", "dev": true, "requires": { - "domelementtype": "1" + "domelementtype": "1.3.0" } }, "domutils": { @@ -2965,8 +2965,8 @@ "integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=", "dev": true, "requires": { - "dom-serializer": "0", - "domelementtype": "1" + "dom-serializer": "0.1.0", + "domelementtype": "1.3.0" } }, "duplexify": { @@ -2975,10 +2975,10 @@ "integrity": "sha512-fO3Di4tBKJpYTFHAxTU00BcfWMY9w24r/x21a6rZRbsD/ToUgGxsMbiGRmB7uVAXeGKXD9MwiLZa5E97EVgIRQ==", "dev": true, "requires": { - "end-of-stream": "^1.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.0.0", - "stream-shift": "^1.0.0" + "end-of-stream": "1.4.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "stream-shift": "1.0.0" } }, "ebnf-parser": { @@ -2993,7 +2993,7 @@ "dev": true, "optional": true, "requires": { - "jsbn": "~0.1.0" + "jsbn": "0.1.1" }, "dependencies": { "jsbn": { @@ -3023,13 +3023,13 @@ "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", "dev": true, "requires": { - "bn.js": "^4.4.0", - "brorand": "^1.0.1", - "hash.js": "^1.0.0", - "hmac-drbg": "^1.0.0", - "inherits": "^2.0.1", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.0" + "bn.js": "4.11.8", + "brorand": "1.1.0", + "hash.js": "1.1.3", + "hmac-drbg": "1.0.1", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.1", + "minimalistic-crypto-utils": "1.0.1" } }, "emojis-list": { @@ -3050,7 +3050,7 @@ "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", "dev": true, "requires": { - "once": "^1.4.0" + "once": "1.4.0" } }, "enhanced-resolve": { @@ -3059,9 +3059,9 @@ "integrity": "sha512-jox/62b2GofV1qTUQTMPEJSDIGycS43evqYzD/KVtEb9OCoki9cnacUPxCrZa7JfPzZSYOCZhu9O9luaMxAX8g==", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "memory-fs": "^0.4.0", - "tapable": "^1.0.0" + "graceful-fs": "4.1.11", + "memory-fs": "0.4.1", + "tapable": "1.0.0" } }, "entities": { @@ -3076,7 +3076,7 @@ "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==", "dev": true, "requires": { - "prr": "~1.0.1" + "prr": "1.0.1" } }, "error": { @@ -3085,8 +3085,8 @@ "integrity": "sha1-pfdf/02ZJhJt2sDqXcOOaJFTywI=", "dev": true, "requires": { - "string-template": "~0.2.1", - "xtend": "~4.0.0" + "string-template": "0.2.1", + "xtend": "4.0.1" } }, "error-ex": { @@ -3095,7 +3095,7 @@ "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", "dev": true, "requires": { - "is-arrayish": "^0.2.1" + "is-arrayish": "0.2.1" } }, "es-abstract": { @@ -3104,11 +3104,11 @@ "integrity": "sha512-ZnQrE/lXTTQ39ulXZ+J1DTFazV9qBy61x2bY071B+qGco8Z8q1QddsLdt/EF8Ai9hcWH72dWS0kFqXLxOxqslA==", "dev": true, "requires": { - "es-to-primitive": "^1.1.1", - "function-bind": "^1.1.1", - "has": "^1.0.1", - "is-callable": "^1.1.3", - "is-regex": "^1.0.4" + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.1", + "is-callable": "1.1.3", + "is-regex": "1.0.4" } }, "es-to-primitive": { @@ -3117,9 +3117,9 @@ "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", "dev": true, "requires": { - "is-callable": "^1.1.1", - "is-date-object": "^1.0.1", - "is-symbol": "^1.0.1" + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" } }, "es5-ext": { @@ -3128,9 +3128,9 @@ "integrity": "sha512-AJxO1rmPe1bDEfSR6TJ/FgMFYuTBhR5R57KW58iCkYACMyFbrkqVyzXSurYoScDGvgyMpk7uRF/lPUPPTmsRSA==", "dev": true, "requires": { - "es6-iterator": "~2.0.3", - "es6-symbol": "~3.1.1", - "next-tick": "1" + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1", + "next-tick": "1.0.0" } }, "es6-iterator": { @@ -3139,9 +3139,9 @@ "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", "dev": true, "requires": { - "d": "1", - "es5-ext": "^0.10.35", - "es6-symbol": "^3.1.1" + "d": "1.0.0", + "es5-ext": "0.10.42", + "es6-symbol": "3.1.1" } }, "es6-object-assign": { @@ -3154,8 +3154,8 @@ "resolved": "https://registry.npmjs.org/es6-polyfills/-/es6-polyfills-2.0.0.tgz", "integrity": "sha1-fzWP04jYyIjQDPyaHuqJ+XFoOTE=", "requires": { - "es6-object-assign": "^1.0.3", - "es6-promise-polyfill": "^1.2.0" + "es6-object-assign": "1.1.0", + "es6-promise-polyfill": "1.2.0" } }, "es6-promise": { @@ -3180,8 +3180,8 @@ "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", "dev": true, "requires": { - "d": "1", - "es5-ext": "~0.10.14" + "d": "1.0.0", + "es5-ext": "0.10.42" } }, "escape-html": { @@ -3200,11 +3200,11 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", "integrity": "sha512-6hTjO1NAWkHnDk3OqQ4YrCuwwmGHL9S3nPlzBOUG/R44rda3wLNrfvQ5fkSGjyhHFKM7ALPKcKGrwvCLe0lC7Q==", "requires": { - "esprima": "^3.1.3", - "estraverse": "^4.2.0", - "esutils": "^2.0.2", - "optionator": "^0.8.1", - "source-map": "~0.6.1" + "esprima": "3.1.3", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "optionator": "0.8.2", + "source-map": "0.6.1" }, "dependencies": { "esprima": { @@ -3219,7 +3219,7 @@ "resolved": "https://registry.npmjs.org/escope/-/escope-1.0.3.tgz", "integrity": "sha1-dZ3OhJbEJI/sLQyq9BCLzz8af10=", "requires": { - "estraverse": "^2.0.0" + "estraverse": "2.0.0" }, "dependencies": { "estraverse": { @@ -3235,44 +3235,44 @@ "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==", "dev": true, "requires": { - "ajv": "^5.3.0", - "babel-code-frame": "^6.22.0", - "chalk": "^2.1.0", - "concat-stream": "^1.6.0", - "cross-spawn": "^5.1.0", - "debug": "^3.1.0", - "doctrine": "^2.1.0", - "eslint-scope": "^3.7.1", - "eslint-visitor-keys": "^1.0.0", - "espree": "^3.5.4", - "esquery": "^1.0.0", - "esutils": "^2.0.2", - "file-entry-cache": "^2.0.0", - "functional-red-black-tree": "^1.0.1", - "glob": "^7.1.2", - "globals": "^11.0.1", - "ignore": "^3.3.3", - "imurmurhash": "^0.1.4", - "inquirer": "^3.0.6", - "is-resolvable": "^1.0.0", - "js-yaml": "^3.9.1", - "json-stable-stringify-without-jsonify": "^1.0.1", - "levn": "^0.3.0", - "lodash": "^4.17.4", - "minimatch": "^3.0.2", - "mkdirp": "^0.5.1", - "natural-compare": "^1.4.0", - "optionator": "^0.8.2", - "path-is-inside": "^1.0.2", - "pluralize": "^7.0.0", - "progress": "^2.0.0", - "regexpp": "^1.0.1", - "require-uncached": "^1.0.3", - "semver": "^5.3.0", - "strip-ansi": "^4.0.0", - "strip-json-comments": "~2.0.1", + "ajv": "5.5.2", + "babel-code-frame": "6.26.0", + "chalk": "2.4.1", + "concat-stream": "1.6.2", + "cross-spawn": "5.1.0", + "debug": "3.1.0", + "doctrine": "2.1.0", + "eslint-scope": "3.7.1", + "eslint-visitor-keys": "1.0.0", + "espree": "3.5.4", + "esquery": "1.0.1", + "esutils": "2.0.2", + "file-entry-cache": "2.0.0", + "functional-red-black-tree": "1.0.1", + "glob": "7.1.2", + "globals": "11.5.0", + "ignore": "3.3.8", + "imurmurhash": "0.1.4", + "inquirer": "3.3.0", + "is-resolvable": "1.1.0", + "js-yaml": "3.11.0", + "json-stable-stringify-without-jsonify": "1.0.1", + "levn": "0.3.0", + "lodash": "4.17.10", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "natural-compare": "1.4.0", + "optionator": "0.8.2", + "path-is-inside": "1.0.2", + "pluralize": "7.0.0", + "progress": "2.0.0", + "regexpp": "1.1.0", + "require-uncached": "1.0.3", + "semver": "5.5.0", + "strip-ansi": "4.0.0", + "strip-json-comments": "2.0.1", "table": "4.0.2", - "text-table": "~0.2.0" + "text-table": "0.2.0" }, "dependencies": { "ansi-regex": { @@ -3287,7 +3287,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -3296,9 +3296,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "debug": { @@ -3328,8 +3328,8 @@ "integrity": "sha512-saJstZWv7oNeOyBh3+Dx1qWzhW0+e6/8eDzo7p5rDFqxntSztloLtuKu+Ejhtq82jsilwOIZYsCz+lIjthg1Hw==", "dev": true, "requires": { - "argparse": "^1.0.7", - "esprima": "^4.0.0" + "argparse": "1.0.10", + "esprima": "4.0.0" } }, "progress": { @@ -3344,7 +3344,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "^3.0.0" + "ansi-regex": "3.0.0" } }, "supports-color": { @@ -3353,7 +3353,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -3364,8 +3364,8 @@ "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=", "dev": true, "requires": { - "esrecurse": "^4.1.0", - "estraverse": "^4.1.1" + "esrecurse": "4.2.1", + "estraverse": "4.2.0" } }, "eslint-visitor-keys": { @@ -3379,14 +3379,14 @@ "resolved": "https://registry.npmjs.org/esmangle/-/esmangle-1.0.1.tgz", "integrity": "sha1-2bs3uPjq+/Tm1O1reqKVarvTxMI=", "requires": { - "escodegen": "~1.3.2", - "escope": "~1.0.1", - "esprima": "~1.1.1", - "esshorten": "~1.1.0", - "estraverse": "~1.5.0", - "esutils": "~ 1.0.0", - "optionator": "~0.3.0", - "source-map": "~0.1.33" + "escodegen": "1.3.3", + "escope": "1.0.3", + "esprima": "1.1.1", + "esshorten": "1.1.1", + "estraverse": "1.5.1", + "esutils": "1.0.0", + "optionator": "0.3.0", + "source-map": "0.1.43" }, "dependencies": { "escodegen": { @@ -3394,10 +3394,10 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.3.3.tgz", "integrity": "sha1-8CQBb1qI4Eb9EgBQVek5gC5sXyM=", "requires": { - "esprima": "~1.1.1", - "estraverse": "~1.5.0", - "esutils": "~1.0.0", - "source-map": "~0.1.33" + "esprima": "1.1.1", + "estraverse": "1.5.1", + "esutils": "1.0.0", + "source-map": "0.1.43" } }, "esprima": { @@ -3425,8 +3425,8 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.2.5.tgz", "integrity": "sha1-uo0znQykphDjo/FFucr0iAcVUFQ=", "requires": { - "prelude-ls": "~1.1.0", - "type-check": "~0.3.1" + "prelude-ls": "1.1.2", + "type-check": "0.3.2" } }, "optionator": { @@ -3434,12 +3434,12 @@ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.3.0.tgz", "integrity": "sha1-lxWotfXnWGz/BsgkngOc1zZNP1Q=", "requires": { - "deep-is": "~0.1.2", - "fast-levenshtein": "~1.0.0", - "levn": "~0.2.4", - "prelude-ls": "~1.1.0", - "type-check": "~0.3.1", - "wordwrap": "~0.0.2" + "deep-is": "0.1.3", + "fast-levenshtein": "1.0.7", + "levn": "0.2.5", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "0.0.3" } }, "source-map": { @@ -3447,7 +3447,7 @@ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz", "integrity": "sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=", "requires": { - "amdefine": ">=0.0.4" + "amdefine": "1.0.1" } }, "wordwrap": { @@ -3463,8 +3463,8 @@ "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==", "dev": true, "requires": { - "acorn": "^5.5.0", - "acorn-jsx": "^3.0.0" + "acorn": "5.5.3", + "acorn-jsx": "3.0.1" } }, "esprima": { @@ -3478,7 +3478,7 @@ "integrity": "sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==", "dev": true, "requires": { - "estraverse": "^4.0.0" + "estraverse": "4.2.0" } }, "esrecurse": { @@ -3487,7 +3487,7 @@ "integrity": "sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==", "dev": true, "requires": { - "estraverse": "^4.1.0" + "estraverse": "4.2.0" } }, "esshorten": { @@ -3495,9 +3495,9 @@ "resolved": "https://registry.npmjs.org/esshorten/-/esshorten-1.1.1.tgz", "integrity": "sha1-F0+Wt8wmfkaHLYFOfbfCkL3/Yak=", "requires": { - "escope": "~1.0.1", - "estraverse": "~4.1.1", - "esutils": "~2.0.2" + "escope": "1.0.3", + "estraverse": "4.1.1", + "esutils": "2.0.2" }, "dependencies": { "estraverse": { @@ -3547,7 +3547,7 @@ "integrity": "sha1-Cs7ehJ7X3RzMMsgRuxG5RNTykjI=", "dev": true, "requires": { - "original": ">=0.0.5" + "original": "1.0.1" } }, "evp_bytestokey": { @@ -3556,8 +3556,8 @@ "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", "dev": true, "requires": { - "md5.js": "^1.3.4", - "safe-buffer": "^5.1.1" + "md5.js": "1.3.4", + "safe-buffer": "5.1.2" } }, "execa": { @@ -3566,13 +3566,13 @@ "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", "dev": true, "requires": { - "cross-spawn": "^5.0.1", - "get-stream": "^3.0.0", - "is-stream": "^1.1.0", - "npm-run-path": "^2.0.0", - "p-finally": "^1.0.0", - "signal-exit": "^3.0.0", - "strip-eof": "^1.0.0" + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" } }, "exif-parser": { @@ -3592,13 +3592,13 @@ "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", "dev": true, "requires": { - "debug": "^2.3.3", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "posix-character-classes": "^0.1.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "posix-character-classes": "0.1.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" }, "dependencies": { "define-property": { @@ -3607,7 +3607,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "^0.1.0" + "is-descriptor": "0.1.6" } }, "extend-shallow": { @@ -3616,7 +3616,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } } } @@ -3627,7 +3627,7 @@ "integrity": "sha512-RKwCrO4A6IiKm0pG3c9V46JxIHcDplwwGJn6+JJ1RcVnh/WSGJa0xkmk5cRVtgOPzCAtTMGj2F7nluh9L0vpSA==", "dev": true, "requires": { - "loader-utils": "^1.1.0", + "loader-utils": "1.1.0", "source-map": "0.5.0" }, "dependencies": { @@ -3645,36 +3645,36 @@ "integrity": "sha1-avilAjUNsyRuzEvs9rWjTSL37VM=", "dev": true, "requires": { - "accepts": "~1.3.5", + "accepts": "1.3.5", "array-flatten": "1.1.1", "body-parser": "1.18.2", "content-disposition": "0.5.2", - "content-type": "~1.0.4", + "content-type": "1.0.4", "cookie": "0.3.1", "cookie-signature": "1.0.6", "debug": "2.6.9", - "depd": "~1.1.2", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", + "depd": "1.1.2", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "etag": "1.8.1", "finalhandler": "1.1.1", "fresh": "0.5.2", "merge-descriptors": "1.0.1", - "methods": "~1.1.2", - "on-finished": "~2.3.0", - "parseurl": "~1.3.2", + "methods": "1.1.2", + "on-finished": "2.3.0", + "parseurl": "1.3.2", "path-to-regexp": "0.1.7", - "proxy-addr": "~2.0.3", + "proxy-addr": "2.0.3", "qs": "6.5.1", - "range-parser": "~1.2.0", + "range-parser": "1.2.0", "safe-buffer": "5.1.1", "send": "0.16.2", "serve-static": "1.13.2", "setprototypeof": "1.1.0", - "statuses": "~1.4.0", - "type-is": "~1.6.16", + "statuses": "1.4.0", + "type-is": "1.6.16", "utils-merge": "1.0.1", - "vary": "~1.1.2" + "vary": "1.1.2" }, "dependencies": { "array-flatten": { @@ -3709,8 +3709,8 @@ "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", "dev": true, "requires": { - "assign-symbols": "^1.0.0", - "is-extendable": "^1.0.1" + "assign-symbols": "1.0.0", + "is-extendable": "1.0.1" }, "dependencies": { "is-extendable": { @@ -3719,7 +3719,7 @@ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "requires": { - "is-plain-object": "^2.0.4" + "is-plain-object": "2.0.4" } } } @@ -3730,9 +3730,9 @@ "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==", "dev": true, "requires": { - "chardet": "^0.4.0", - "iconv-lite": "^0.4.17", - "tmp": "^0.0.33" + "chardet": "0.4.2", + "iconv-lite": "0.4.23", + "tmp": "0.0.33" } }, "extglob": { @@ -3741,14 +3741,14 @@ "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", "dev": true, "requires": { - "array-unique": "^0.3.2", - "define-property": "^1.0.0", - "expand-brackets": "^2.1.4", - "extend-shallow": "^2.0.1", - "fragment-cache": "^0.2.1", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" + "array-unique": "0.3.2", + "define-property": "1.0.0", + "expand-brackets": "2.1.4", + "extend-shallow": "2.0.1", + "fragment-cache": "0.2.1", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" }, "dependencies": { "define-property": { @@ -3757,7 +3757,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "^1.0.0" + "is-descriptor": "1.0.2" } }, "extend-shallow": { @@ -3766,7 +3766,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } }, "is-accessor-descriptor": { @@ -3775,7 +3775,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-data-descriptor": { @@ -3784,7 +3784,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-descriptor": { @@ -3793,9 +3793,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" } } } @@ -3806,10 +3806,10 @@ "integrity": "sha512-Hypkn9jUTnFr0DpekNam53X47tXn3ucY08BQumv7kdGgeVUBLq3DJHJTi6HNxv4jl9W+Skxjz9+RnK0sJyqqjA==", "dev": true, "requires": { - "async": "^2.4.1", - "loader-utils": "^1.1.0", - "schema-utils": "^0.4.5", - "webpack-sources": "^1.1.0" + "async": "2.6.0", + "loader-utils": "1.1.0", + "schema-utils": "0.4.5", + "webpack-sources": "1.1.0" } }, "extract-zip": { @@ -3830,9 +3830,9 @@ "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", "dev": true, "requires": { - "inherits": "^2.0.3", - "readable-stream": "^2.2.2", - "typedarray": "^0.0.6" + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "typedarray": "0.0.6" } }, "minimist": { @@ -3887,7 +3887,7 @@ "integrity": "sha1-TkkvjQTftviQA1B/btvy1QHnxvQ=", "dev": true, "requires": { - "websocket-driver": ">=0.5.1" + "websocket-driver": "0.7.0" } }, "fd-slicer": { @@ -3896,7 +3896,7 @@ "integrity": "sha1-i1vL2ewyfFBBv5qwI/1nUPEXfmU=", "dev": true, "requires": { - "pend": "~1.2.0" + "pend": "1.2.0" } }, "figures": { @@ -3905,7 +3905,7 @@ "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", "dev": true, "requires": { - "escape-string-regexp": "^1.0.5" + "escape-string-regexp": "1.0.5" } }, "file-entry-cache": { @@ -3914,8 +3914,8 @@ "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", "dev": true, "requires": { - "flat-cache": "^1.2.1", - "object-assign": "^4.0.1" + "flat-cache": "1.3.0", + "object-assign": "4.1.1" } }, "file-loader": { @@ -3924,8 +3924,8 @@ "integrity": "sha512-TGR4HU7HUsGg6GCOPJnFk06RhWgEWFLAGWiT6rcD+GRC2keU3s9RGJ+b3Z6/U73jwwNb2gKLJ7YCrp+jvU4ALg==", "dev": true, "requires": { - "loader-utils": "^1.0.2", - "schema-utils": "^0.4.5" + "loader-utils": "1.1.0", + "schema-utils": "0.4.5" } }, "file-saver": { @@ -3945,10 +3945,10 @@ "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", "dev": true, "requires": { - "extend-shallow": "^2.0.1", - "is-number": "^3.0.0", - "repeat-string": "^1.6.1", - "to-regex-range": "^2.1.0" + "extend-shallow": "2.0.1", + "is-number": "3.0.0", + "repeat-string": "1.6.1", + "to-regex-range": "2.1.1" }, "dependencies": { "extend-shallow": { @@ -3957,7 +3957,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } } } @@ -3969,12 +3969,12 @@ "dev": true, "requires": { "debug": "2.6.9", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "on-finished": "~2.3.0", - "parseurl": "~1.3.2", - "statuses": "~1.4.0", - "unpipe": "~1.0.0" + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "on-finished": "2.3.0", + "parseurl": "1.3.2", + "statuses": "1.4.0", + "unpipe": "1.0.0" } }, "find-cache-dir": { @@ -3983,9 +3983,9 @@ "integrity": "sha1-kojj6ePMN0hxfTnq3hfPcfww7m8=", "dev": true, "requires": { - "commondir": "^1.0.1", - "make-dir": "^1.0.0", - "pkg-dir": "^2.0.0" + "commondir": "1.0.1", + "make-dir": "1.3.0", + "pkg-dir": "2.0.0" } }, "find-up": { @@ -3994,7 +3994,7 @@ "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", "dev": true, "requires": { - "locate-path": "^2.0.0" + "locate-path": "2.0.0" } }, "findup-sync": { @@ -4003,7 +4003,7 @@ "integrity": "sha1-N5MKpdgWt3fANEXhlmzGeQpMCxY=", "dev": true, "requires": { - "glob": "~5.0.0" + "glob": "5.0.15" }, "dependencies": { "glob": { @@ -4012,11 +4012,11 @@ "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=", "dev": true, "requires": { - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "2 || 3", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" } } } @@ -4027,10 +4027,10 @@ "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=", "dev": true, "requires": { - "circular-json": "^0.3.1", - "del": "^2.0.2", - "graceful-fs": "^4.1.2", - "write": "^0.2.1" + "circular-json": "0.3.3", + "del": "2.2.2", + "graceful-fs": "4.1.11", + "write": "0.2.1" } }, "flatten": { @@ -4045,8 +4045,8 @@ "integrity": "sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==", "dev": true, "requires": { - "inherits": "^2.0.1", - "readable-stream": "^2.0.4" + "inherits": "2.0.3", + "readable-stream": "2.3.6" } }, "follow-redirects": { @@ -4055,7 +4055,7 @@ "integrity": "sha512-uxYePVPogtya1ktGnAAXOacnbIuRMB4dkvqeNz2qTtTQsuzSfbDolV+wMMKxAmCx0bLgAKLbBOkjItMbbkR1vg==", "dev": true, "requires": { - "debug": "^3.1.0" + "debug": "3.1.0" }, "dependencies": { "debug": { @@ -4093,9 +4093,9 @@ "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", "dev": true, "requires": { - "asynckit": "^0.4.0", + "asynckit": "0.4.0", "combined-stream": "1.0.6", - "mime-types": "^2.1.12" + "mime-types": "2.1.18" } }, "forwarded": { @@ -4110,7 +4110,7 @@ "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", "dev": true, "requires": { - "map-cache": "^0.2.2" + "map-cache": "0.2.2" } }, "fresh": { @@ -4125,8 +4125,8 @@ "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=", "dev": true, "requires": { - "inherits": "^2.0.1", - "readable-stream": "^2.0.0" + "inherits": "2.0.3", + "readable-stream": "2.3.6" } }, "fs-extra": { @@ -4135,9 +4135,9 @@ "integrity": "sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "jsonfile": "^2.1.0", - "klaw": "^1.0.0" + "graceful-fs": "4.1.11", + "jsonfile": "2.4.0", + "klaw": "1.3.1" } }, "fs-write-stream-atomic": { @@ -4146,10 +4146,10 @@ "integrity": "sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "iferr": "^0.1.5", - "imurmurhash": "^0.1.4", - "readable-stream": "1 || 2" + "graceful-fs": "4.1.11", + "iferr": "0.1.5", + "imurmurhash": "0.1.4", + "readable-stream": "2.3.6" } }, "fs.realpath": { @@ -4165,8 +4165,8 @@ "dev": true, "optional": true, "requires": { - "nan": "^2.9.2", - "node-pre-gyp": "^0.10.0" + "nan": "2.10.0", + "node-pre-gyp": "0.10.0" }, "dependencies": { "abbrev": { @@ -4192,8 +4192,8 @@ "dev": true, "optional": true, "requires": { - "delegates": "^1.0.0", - "readable-stream": "^2.0.6" + "delegates": "1.0.0", + "readable-stream": "2.3.6" } }, "balanced-match": { @@ -4206,7 +4206,7 @@ "bundled": true, "dev": true, "requires": { - "balanced-match": "^1.0.0", + "balanced-match": "1.0.0", "concat-map": "0.0.1" } }, @@ -4270,7 +4270,7 @@ "dev": true, "optional": true, "requires": { - "minipass": "^2.2.1" + "minipass": "2.2.4" } }, "fs.realpath": { @@ -4285,14 +4285,14 @@ "dev": true, "optional": true, "requires": { - "aproba": "^1.0.3", - "console-control-strings": "^1.0.0", - "has-unicode": "^2.0.0", - "object-assign": "^4.1.0", - "signal-exit": "^3.0.0", - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1", - "wide-align": "^1.1.0" + "aproba": "1.2.0", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" } }, "glob": { @@ -4301,12 +4301,12 @@ "dev": true, "optional": true, "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" } }, "has-unicode": { @@ -4321,7 +4321,7 @@ "dev": true, "optional": true, "requires": { - "safer-buffer": "^2.1.0" + "safer-buffer": "2.1.2" } }, "ignore-walk": { @@ -4330,7 +4330,7 @@ "dev": true, "optional": true, "requires": { - "minimatch": "^3.0.4" + "minimatch": "3.0.4" } }, "inflight": { @@ -4339,8 +4339,8 @@ "dev": true, "optional": true, "requires": { - "once": "^1.3.0", - "wrappy": "1" + "once": "1.4.0", + "wrappy": "1.0.2" } }, "inherits": { @@ -4359,7 +4359,7 @@ "bundled": true, "dev": true, "requires": { - "number-is-nan": "^1.0.0" + "number-is-nan": "1.0.1" } }, "isarray": { @@ -4373,7 +4373,7 @@ "bundled": true, "dev": true, "requires": { - "brace-expansion": "^1.1.7" + "brace-expansion": "1.1.11" } }, "minimist": { @@ -4386,8 +4386,8 @@ "bundled": true, "dev": true, "requires": { - "safe-buffer": "^5.1.1", - "yallist": "^3.0.0" + "safe-buffer": "5.1.1", + "yallist": "3.0.2" } }, "minizlib": { @@ -4396,7 +4396,7 @@ "dev": true, "optional": true, "requires": { - "minipass": "^2.2.1" + "minipass": "2.2.4" } }, "mkdirp": { @@ -4419,9 +4419,9 @@ "dev": true, "optional": true, "requires": { - "debug": "^2.1.2", - "iconv-lite": "^0.4.4", - "sax": "^1.2.4" + "debug": "2.6.9", + "iconv-lite": "0.4.21", + "sax": "1.2.4" } }, "node-pre-gyp": { @@ -4430,16 +4430,16 @@ "dev": true, "optional": true, "requires": { - "detect-libc": "^1.0.2", - "mkdirp": "^0.5.1", - "needle": "^2.2.0", - "nopt": "^4.0.1", - "npm-packlist": "^1.1.6", - "npmlog": "^4.0.2", - "rc": "^1.1.7", - "rimraf": "^2.6.1", - "semver": "^5.3.0", - "tar": "^4" + "detect-libc": "1.0.3", + "mkdirp": "0.5.1", + "needle": "2.2.0", + "nopt": "4.0.1", + "npm-packlist": "1.1.10", + "npmlog": "4.1.2", + "rc": "1.2.7", + "rimraf": "2.6.2", + "semver": "5.5.0", + "tar": "4.4.1" } }, "nopt": { @@ -4448,8 +4448,8 @@ "dev": true, "optional": true, "requires": { - "abbrev": "1", - "osenv": "^0.1.4" + "abbrev": "1.1.1", + "osenv": "0.1.5" } }, "npm-bundled": { @@ -4464,8 +4464,8 @@ "dev": true, "optional": true, "requires": { - "ignore-walk": "^3.0.1", - "npm-bundled": "^1.0.1" + "ignore-walk": "3.0.1", + "npm-bundled": "1.0.3" } }, "npmlog": { @@ -4474,10 +4474,10 @@ "dev": true, "optional": true, "requires": { - "are-we-there-yet": "~1.1.2", - "console-control-strings": "~1.1.0", - "gauge": "~2.7.3", - "set-blocking": "~2.0.0" + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" } }, "number-is-nan": { @@ -4496,7 +4496,7 @@ "bundled": true, "dev": true, "requires": { - "wrappy": "1" + "wrappy": "1.0.2" } }, "os-homedir": { @@ -4517,8 +4517,8 @@ "dev": true, "optional": true, "requires": { - "os-homedir": "^1.0.0", - "os-tmpdir": "^1.0.0" + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" } }, "path-is-absolute": { @@ -4539,10 +4539,10 @@ "dev": true, "optional": true, "requires": { - "deep-extend": "^0.5.1", - "ini": "~1.3.0", - "minimist": "^1.2.0", - "strip-json-comments": "~2.0.1" + "deep-extend": "0.5.1", + "ini": "1.3.5", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" }, "dependencies": { "minimist": { @@ -4559,13 +4559,13 @@ "dev": true, "optional": true, "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" } }, "rimraf": { @@ -4574,7 +4574,7 @@ "dev": true, "optional": true, "requires": { - "glob": "^7.0.5" + "glob": "7.1.2" } }, "safe-buffer": { @@ -4617,9 +4617,9 @@ "bundled": true, "dev": true, "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" } }, "string_decoder": { @@ -4628,7 +4628,7 @@ "dev": true, "optional": true, "requires": { - "safe-buffer": "~5.1.0" + "safe-buffer": "5.1.1" } }, "strip-ansi": { @@ -4636,7 +4636,7 @@ "bundled": true, "dev": true, "requires": { - "ansi-regex": "^2.0.0" + "ansi-regex": "2.1.1" } }, "strip-json-comments": { @@ -4651,13 +4651,13 @@ "dev": true, "optional": true, "requires": { - "chownr": "^1.0.1", - "fs-minipass": "^1.2.5", - "minipass": "^2.2.4", - "minizlib": "^1.1.0", - "mkdirp": "^0.5.0", - "safe-buffer": "^5.1.1", - "yallist": "^3.0.2" + "chownr": "1.0.1", + "fs-minipass": "1.2.5", + "minipass": "2.2.4", + "minizlib": "1.1.0", + "mkdirp": "0.5.1", + "safe-buffer": "5.1.1", + "yallist": "3.0.2" } }, "util-deprecate": { @@ -4672,7 +4672,7 @@ "dev": true, "optional": true, "requires": { - "string-width": "^1.0.2" + "string-width": "1.0.2" } }, "wrappy": { @@ -4710,7 +4710,7 @@ "integrity": "sha1-hHIkZ3rbiHDWeSV+0ziP22HkAQU=", "dev": true, "requires": { - "globule": "^1.0.0" + "globule": "1.2.0" } }, "get-caller-file": { @@ -4749,7 +4749,7 @@ "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", "dev": true, "requires": { - "assert-plus": "^1.0.0" + "assert-plus": "1.0.0" } }, "glob": { @@ -4758,12 +4758,12 @@ "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", "dev": true, "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" } }, "glob-parent": { @@ -4772,8 +4772,8 @@ "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", "dev": true, "requires": { - "is-glob": "^3.1.0", - "path-dirname": "^1.0.0" + "is-glob": "3.1.0", + "path-dirname": "1.0.2" }, "dependencies": { "is-glob": { @@ -4782,7 +4782,7 @@ "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", "dev": true, "requires": { - "is-extglob": "^2.1.0" + "is-extglob": "2.1.1" } } } @@ -4798,12 +4798,12 @@ "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=", "dev": true, "requires": { - "array-union": "^1.0.1", - "arrify": "^1.0.0", - "glob": "^7.0.3", - "object-assign": "^4.0.1", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" + "array-union": "1.0.2", + "arrify": "1.0.1", + "glob": "7.1.2", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" }, "dependencies": { "pify": { @@ -4820,9 +4820,9 @@ "integrity": "sha1-HcScaCLdnoovoAuiopUAboZkvQk=", "dev": true, "requires": { - "glob": "~7.1.1", - "lodash": "~4.17.4", - "minimatch": "~3.0.2" + "glob": "7.1.2", + "lodash": "4.17.10", + "minimatch": "3.0.4" } }, "graceful-fs": { @@ -4837,22 +4837,22 @@ "integrity": "sha1-TmpeaVtwRy/VME9fqeNCNoNqc7w=", "dev": true, "requires": { - "coffeescript": "~1.10.0", - "dateformat": "~1.0.12", - "eventemitter2": "~0.4.13", - "exit": "~0.1.1", - "findup-sync": "~0.3.0", - "glob": "~7.0.0", - "grunt-cli": "~1.2.0", - "grunt-known-options": "~1.1.0", - "grunt-legacy-log": "~1.0.0", - "grunt-legacy-util": "~1.0.0", - "iconv-lite": "~0.4.13", - "js-yaml": "~3.5.2", - "minimatch": "~3.0.2", - "nopt": "~3.0.6", - "path-is-absolute": "~1.0.0", - "rimraf": "~2.2.8" + "coffeescript": "1.10.0", + "dateformat": "1.0.12", + "eventemitter2": "0.4.14", + "exit": "0.1.2", + "findup-sync": "0.3.0", + "glob": "7.0.6", + "grunt-cli": "1.2.0", + "grunt-known-options": "1.1.0", + "grunt-legacy-log": "1.0.2", + "grunt-legacy-util": "1.0.0", + "iconv-lite": "0.4.23", + "js-yaml": "3.5.5", + "minimatch": "3.0.4", + "nopt": "3.0.6", + "path-is-absolute": "1.0.1", + "rimraf": "2.2.8" }, "dependencies": { "esprima": { @@ -4867,12 +4867,12 @@ "integrity": "sha1-IRuvr0nlJbjNkyYNFKsTYVKz9Xo=", "dev": true, "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.2", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" } }, "grunt-cli": { @@ -4881,10 +4881,10 @@ "integrity": "sha1-VisRnrsGndtGSs4oRVAb6Xs1tqg=", "dev": true, "requires": { - "findup-sync": "~0.3.0", - "grunt-known-options": "~1.1.0", - "nopt": "~3.0.6", - "resolve": "~1.1.0" + "findup-sync": "0.3.0", + "grunt-known-options": "1.1.0", + "nopt": "3.0.6", + "resolve": "1.1.7" } }, "js-yaml": { @@ -4893,8 +4893,8 @@ "integrity": "sha1-A3fDgBfKvHMisNH7zSWkkWQfL74=", "dev": true, "requires": { - "argparse": "^1.0.2", - "esprima": "^2.6.0" + "argparse": "1.0.10", + "esprima": "2.7.3" } }, "rimraf": { @@ -4911,7 +4911,7 @@ "integrity": "sha512-5Y7MMYzpzMICkspvmUOU+YC/VE5eiB5TV8k9u43ZFrzLIoYDulKce8KX0fyi2EXYEDKlUEyaVI/W4rLDqqy3/Q==", "dev": true, "requires": { - "access-sniff": "^3.2.0" + "access-sniff": "3.2.0" } }, "grunt-chmod": { @@ -4920,7 +4920,7 @@ "integrity": "sha1-0YZcWoTn7Zrv5Qn/v1KQ+XoleEA=", "dev": true, "requires": { - "shelljs": "^0.5.3" + "shelljs": "0.5.3" }, "dependencies": { "shelljs": { @@ -4937,10 +4937,10 @@ "integrity": "sha1-Hj2zjM71o9oRleYdYx/n4yE0TSM=", "dev": true, "requires": { - "arrify": "^1.0.1", - "async": "^1.2.1", - "indent-string": "^2.0.0", - "pad-stream": "^1.0.0" + "arrify": "1.0.1", + "async": "1.5.2", + "indent-string": "2.1.0", + "pad-stream": "1.2.0" }, "dependencies": { "async": { @@ -4957,8 +4957,8 @@ "integrity": "sha1-Vkq/LQN4qYOhW54/MO51tzjEBjg=", "dev": true, "requires": { - "async": "^1.5.2", - "rimraf": "^2.5.1" + "async": "1.5.2", + "rimraf": "2.6.2" }, "dependencies": { "async": { @@ -4975,8 +4975,8 @@ "integrity": "sha1-cGDGWB6QS4qw0A8HbgqPbj58NXM=", "dev": true, "requires": { - "chalk": "^1.1.1", - "file-sync-cmp": "^0.1.0" + "chalk": "1.1.3", + "file-sync-cmp": "0.1.1" } }, "grunt-contrib-jshint": { @@ -4985,9 +4985,9 @@ "integrity": "sha1-Np2QmyWTxA6L55lAshNAhQx5Oaw=", "dev": true, "requires": { - "chalk": "^1.1.1", - "hooker": "^0.2.3", - "jshint": "~2.9.4" + "chalk": "1.1.3", + "hooker": "0.2.3", + "jshint": "2.9.5" } }, "grunt-contrib-watch": { @@ -4996,10 +4996,10 @@ "integrity": "sha512-yGweN+0DW5yM+oo58fRu/XIRrPcn3r4tQx+nL7eMRwjpvk+rQY6R8o94BPK0i2UhTg9FN21hS+m8vR8v9vXfeg==", "dev": true, "requires": { - "async": "^2.6.0", - "gaze": "^1.1.0", - "lodash": "^4.17.10", - "tiny-lr": "^1.1.1" + "async": "2.6.0", + "gaze": "1.1.2", + "lodash": "4.17.10", + "tiny-lr": "1.1.1" } }, "grunt-eslint": { @@ -5008,8 +5008,8 @@ "integrity": "sha512-VZlDOLrB2KKefDDcx/wR8rEEz7smDwDKVblmooa+itdt/2jWw3ee2AiZB5Ap4s4AoRY0pbHRjZ3HHwY8uKR9Rw==", "dev": true, "requires": { - "chalk": "^2.1.0", - "eslint": "^4.0.0" + "chalk": "2.4.1", + "eslint": "4.19.1" }, "dependencies": { "ansi-styles": { @@ -5018,7 +5018,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -5027,9 +5027,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -5044,7 +5044,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -5061,9 +5061,9 @@ "integrity": "sha512-33QZYBYjv2Ph3H2ygqXHn/o0ttfptw1f9QciOTgvzhzUeiPrnvzMNUApTPtw22T6zgReE5FZ1RR58U2wnK/l+w==", "dev": true, "requires": { - "cross-spawn": "^3.0.1", - "jsdoc": "~3.5.5", - "marked": "^0.3.9" + "cross-spawn": "3.0.1", + "jsdoc": "3.5.5", + "marked": "0.3.19" }, "dependencies": { "cross-spawn": { @@ -5072,8 +5072,8 @@ "integrity": "sha1-ElYDfsufDF9549bvE14wdwGEuYI=", "dev": true, "requires": { - "lru-cache": "^4.0.1", - "which": "^1.2.9" + "lru-cache": "4.1.3", + "which": "1.3.0" } } } @@ -5090,10 +5090,10 @@ "integrity": "sha512-WdedTJ/6zCXnI/coaouzqvkI19uwqbcPkdsXiDRKJyB5rOUlOxnCnTVbpeUdEckKVir2uHF3rDBYppj2p6N3+g==", "dev": true, "requires": { - "colors": "~1.1.2", - "grunt-legacy-log-utils": "~1.0.0", - "hooker": "~0.2.3", - "lodash": "~4.17.5" + "colors": "1.1.2", + "grunt-legacy-log-utils": "1.0.0", + "hooker": "0.2.3", + "lodash": "4.17.10" }, "dependencies": { "colors": { @@ -5110,8 +5110,8 @@ "integrity": "sha1-p7ji0Ps1taUPSvmG/BEnSevJbz0=", "dev": true, "requires": { - "chalk": "~1.1.1", - "lodash": "~4.3.0" + "chalk": "1.1.3", + "lodash": "4.3.0" }, "dependencies": { "lodash": { @@ -5128,13 +5128,13 @@ "integrity": "sha1-OGqnjcbtUJhsKxiVcmWxtIq7m4Y=", "dev": true, "requires": { - "async": "~1.5.2", - "exit": "~0.1.1", - "getobject": "~0.1.0", - "hooker": "~0.2.3", - "lodash": "~4.3.0", - "underscore.string": "~3.2.3", - "which": "~1.2.1" + "async": "1.5.2", + "exit": "0.1.2", + "getobject": "0.1.0", + "hooker": "0.2.3", + "lodash": "4.3.0", + "underscore.string": "3.2.3", + "which": "1.2.14" }, "dependencies": { "async": { @@ -5155,7 +5155,7 @@ "integrity": "sha1-mofEN48D6CfOyvGs31bHNsAcFOU=", "dev": true, "requires": { - "isexe": "^2.0.0" + "isexe": "2.0.0" } } } @@ -5166,8 +5166,8 @@ "integrity": "sha512-Ngixl4W/mNJYyghyXJ+JzJ7pUaVRcVKgvC+74ePXPglAEodc9jMlBrGszZAzmspCuvo5dkhbBIcuBHn+Wv1pOQ==", "dev": true, "requires": { - "deep-for-each": "^2.0.2", - "lodash": "^4.7.0" + "deep-for-each": "2.0.3", + "lodash": "4.17.10" } }, "handle-thing": { @@ -5188,8 +5188,8 @@ "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", "dev": true, "requires": { - "ajv": "^5.1.0", - "har-schema": "^2.0.0" + "ajv": "5.5.2", + "har-schema": "2.0.0" } }, "has": { @@ -5198,7 +5198,7 @@ "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=", "dev": true, "requires": { - "function-bind": "^1.0.2" + "function-bind": "1.1.1" } }, "has-ansi": { @@ -5206,7 +5206,7 @@ "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", "requires": { - "ansi-regex": "^2.0.0" + "ansi-regex": "2.1.1" } }, "has-flag": { @@ -5227,9 +5227,9 @@ "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", "dev": true, "requires": { - "get-value": "^2.0.6", - "has-values": "^1.0.0", - "isobject": "^3.0.0" + "get-value": "2.0.6", + "has-values": "1.0.0", + "isobject": "3.0.1" } }, "has-values": { @@ -5238,8 +5238,8 @@ "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", "dev": true, "requires": { - "is-number": "^3.0.0", - "kind-of": "^4.0.0" + "is-number": "3.0.0", + "kind-of": "4.0.0" }, "dependencies": { "kind-of": { @@ -5248,7 +5248,7 @@ "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -5259,8 +5259,8 @@ "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", "dev": true, "requires": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" + "inherits": "2.0.3", + "safe-buffer": "5.1.2" } }, "hash.js": { @@ -5269,8 +5269,8 @@ "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", "dev": true, "requires": { - "inherits": "^2.0.3", - "minimalistic-assert": "^1.0.0" + "inherits": "2.0.3", + "minimalistic-assert": "1.0.1" } }, "hasha": { @@ -5279,8 +5279,8 @@ "integrity": "sha1-eNfL/B5tZjA/55g3NlmEUXsvbuE=", "dev": true, "requires": { - "is-stream": "^1.0.1", - "pinkie-promise": "^2.0.0" + "is-stream": "1.1.0", + "pinkie-promise": "2.0.1" } }, "hawk": { @@ -5289,10 +5289,10 @@ "integrity": "sha512-miowhl2+U7Qle4vdLqDdPt9m09K6yZhkLDTWGoUiUzrQCn+mHHSmfJgAyGaLRZbPmTqfFFjRV1QWCW0VWUJBbQ==", "dev": true, "requires": { - "boom": "4.x.x", - "cryptiles": "3.x.x", - "hoek": "4.x.x", - "sntp": "2.x.x" + "boom": "4.3.1", + "cryptiles": "3.1.2", + "hoek": "4.2.1", + "sntp": "2.1.0" } }, "he": { @@ -5312,9 +5312,9 @@ "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", "dev": true, "requires": { - "hash.js": "^1.0.3", - "minimalistic-assert": "^1.0.0", - "minimalistic-crypto-utils": "^1.0.1" + "hash.js": "1.1.3", + "minimalistic-assert": "1.0.1", + "minimalistic-crypto-utils": "1.0.1" } }, "hoek": { @@ -5329,8 +5329,8 @@ "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", "dev": true, "requires": { - "os-homedir": "^1.0.0", - "os-tmpdir": "^1.0.1" + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" } }, "hooker": { @@ -5351,10 +5351,10 @@ "integrity": "sha1-h3dMCUnlE/QuhFdbPEVoH63ioLI=", "dev": true, "requires": { - "inherits": "^2.0.1", - "obuf": "^1.0.0", - "readable-stream": "^2.0.1", - "wbuf": "^1.1.0" + "inherits": "2.0.3", + "obuf": "1.1.2", + "readable-stream": "2.3.6", + "wbuf": "1.7.3" } }, "html-comment-regex": { @@ -5369,7 +5369,7 @@ "integrity": "sha512-71lZziiDnsuabfdYiUeWdCVyKuqwWi23L8YeIgV9jSSZHCtb6wB1BKWooH7L3tn4/FuZJMVWyNaIDr4RGmaSYw==", "dev": true, "requires": { - "whatwg-encoding": "^1.0.1" + "whatwg-encoding": "1.0.3" } }, "html-entities": { @@ -5384,13 +5384,13 @@ "integrity": "sha512-OZa4rfb6tZOZ3Z8Xf0jKxXkiDcFWldQePGYFDcgKqES2sXeWaEv9y6QQvWUtX3ySI3feApQi5uCsHLINQ6NoAw==", "dev": true, "requires": { - "camel-case": "3.0.x", - "clean-css": "4.1.x", - "commander": "2.15.x", - "he": "1.1.x", - "param-case": "2.1.x", - "relateurl": "0.2.x", - "uglify-js": "3.3.x" + "camel-case": "3.0.0", + "clean-css": "4.1.11", + "commander": "2.15.1", + "he": "1.1.1", + "param-case": "2.1.1", + "relateurl": "0.2.7", + "uglify-js": "3.3.25" } }, "html-webpack-plugin": { @@ -5399,12 +5399,12 @@ "integrity": "sha1-sBq71yOsqqeze2r0SS69oD2d03s=", "dev": true, "requires": { - "html-minifier": "^3.2.3", - "loader-utils": "^0.2.16", - "lodash": "^4.17.3", - "pretty-error": "^2.0.2", - "tapable": "^1.0.0", - "toposort": "^1.0.0", + "html-minifier": "3.5.15", + "loader-utils": "0.2.17", + "lodash": "4.17.10", + "pretty-error": "2.1.1", + "tapable": "1.0.0", + "toposort": "1.0.7", "util.promisify": "1.0.0" }, "dependencies": { @@ -5414,10 +5414,10 @@ "integrity": "sha1-+G5jdNQyBabmxg6RlvF8Apm/s0g=", "dev": true, "requires": { - "big.js": "^3.1.3", - "emojis-list": "^2.0.0", - "json5": "^0.5.0", - "object-assign": "^4.0.1" + "big.js": "3.2.0", + "emojis-list": "2.1.0", + "json5": "0.5.1", + "object-assign": "4.1.1" } } } @@ -5428,11 +5428,11 @@ "integrity": "sha512-xG6E3g2V/huu/WwRcrX3AFRmAUFkU7PWlgF/QFLtuRitI+NxvJcYTFthb24rB7/mhKE3khSIxB11A8IQTJ2N9w==", "dev": true, "requires": { - "grunt": "^1.0.0", - "grunt-contrib-copy": "^1.0.0", - "grunt-contrib-jshint": "^1.0.0", - "grunt-contrib-watch": "^1.0.0", - "load-grunt-tasks": "^3.5.2" + "grunt": "1.0.2", + "grunt-contrib-copy": "1.0.0", + "grunt-contrib-jshint": "1.1.0", + "grunt-contrib-watch": "1.1.0", + "load-grunt-tasks": "3.5.2" } }, "htmlparser2": { @@ -5441,11 +5441,11 @@ "integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=", "dev": true, "requires": { - "domelementtype": "1", - "domhandler": "2.3", - "domutils": "1.5", - "entities": "1.0", - "readable-stream": "1.1" + "domelementtype": "1.3.0", + "domhandler": "2.3.0", + "domutils": "1.5.1", + "entities": "1.0.0", + "readable-stream": "1.1.14" }, "dependencies": { "isarray": { @@ -5460,10 +5460,10 @@ "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", "dev": true, "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.1", + "core-util-is": "1.0.2", + "inherits": "2.0.3", "isarray": "0.0.1", - "string_decoder": "~0.10.x" + "string_decoder": "0.10.31" } }, "string_decoder": { @@ -5486,10 +5486,10 @@ "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", "dev": true, "requires": { - "depd": "~1.1.2", + "depd": "1.1.2", "inherits": "2.0.3", "setprototypeof": "1.1.0", - "statuses": ">= 1.4.0 < 2" + "statuses": "1.4.0" } }, "http-parser-js": { @@ -5504,9 +5504,9 @@ "integrity": "sha512-Taqn+3nNvYRfJ3bGvKfBSRwy1v6eePlm3oc/aWVxZp57DQr5Eq3xhKJi7Z4hZpS8PC3H4qI+Yly5EmFacGuA/g==", "dev": true, "requires": { - "eventemitter3": "^3.0.0", - "follow-redirects": "^1.0.0", - "requires-port": "^1.0.0" + "eventemitter3": "3.1.0", + "follow-redirects": "1.4.1", + "requires-port": "1.0.0" } }, "http-proxy-middleware": { @@ -5515,10 +5515,10 @@ "integrity": "sha512-Fs25KVMPAIIcgjMZkVHJoKg9VcXcC1C8yb9JUgeDvVXY0S/zgVIhMb+qVswDIgtJe2DfckMSY2d6TuTEutlk6Q==", "dev": true, "requires": { - "http-proxy": "^1.16.2", - "is-glob": "^4.0.0", - "lodash": "^4.17.5", - "micromatch": "^3.1.9" + "http-proxy": "1.17.0", + "is-glob": "4.0.0", + "lodash": "4.17.10", + "micromatch": "3.1.10" } }, "http-signature": { @@ -5527,9 +5527,9 @@ "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", "dev": true, "requires": { - "assert-plus": "^1.0.0", - "jsprim": "^1.2.2", - "sshpk": "^1.7.0" + "assert-plus": "1.0.0", + "jsprim": "1.4.1", + "sshpk": "1.14.1" } }, "https-browserify": { @@ -5548,7 +5548,7 @@ "resolved": "https://registry.npmjs.org/iced-lock/-/iced-lock-1.1.0.tgz", "integrity": "sha1-YRbvHKs6zW5rEIk7snumIv0/3nI=", "requires": { - "iced-runtime": "^1.0.0" + "iced-runtime": "1.0.3" } }, "iced-runtime": { @@ -5562,7 +5562,7 @@ "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", "dev": true, "requires": { - "safer-buffer": ">= 2.1.2 < 3" + "safer-buffer": "2.1.2" } }, "icss-replace-symbols": { @@ -5577,7 +5577,7 @@ "integrity": "sha1-g/Cg7DeL8yRheLbCrZE28TWxyWI=", "dev": true, "requires": { - "postcss": "^6.0.1" + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -5586,7 +5586,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -5595,9 +5595,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -5612,9 +5612,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -5623,7 +5623,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -5659,8 +5659,8 @@ "integrity": "sha512-vAaZHieK9qjGo58agRBg+bhHX3hoTZU/Oa3GESWLz7t1U62fk63aHuDJJEteXoDeTCcPmUT+z38gkHPZkkmpmQ==", "dev": true, "requires": { - "pkg-dir": "^2.0.0", - "resolve-cwd": "^2.0.0" + "pkg-dir": "2.0.0", + "resolve-cwd": "2.0.0" } }, "imports-loader": { @@ -5669,8 +5669,8 @@ "integrity": "sha512-kXWL7Scp8KQ4552ZcdVTeaQCZSLW+e6nJfp3cwUMB673T7Hr98Xjx5JK+ql7ADlJUvj1JS5O01RLbKoutN5QDQ==", "dev": true, "requires": { - "loader-utils": "^1.0.2", - "source-map": "^0.6.1" + "loader-utils": "1.1.0", + "source-map": "0.6.1" } }, "imurmurhash": { @@ -5685,7 +5685,7 @@ "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=", "dev": true, "requires": { - "repeating": "^2.0.0" + "repeating": "2.0.1" } }, "indexes-of": { @@ -5706,8 +5706,8 @@ "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", "dev": true, "requires": { - "once": "^1.3.0", - "wrappy": "1" + "once": "1.4.0", + "wrappy": "1.0.2" } }, "inherits": { @@ -5728,8 +5728,8 @@ "integrity": "sha512-STx5orGQU1gfrkoI/fMU7lX6CSP7LBGO10gXNgOZhwKhUqbtNjCkYSewJtNnLmWP1tAGN6oyEpG1HFPw5vpa5Q==", "dev": true, "requires": { - "moment": "^2.14.1", - "sanitize-html": "^1.13.0" + "moment": "2.22.1", + "sanitize-html": "1.18.2" } }, "inquirer": { @@ -5738,20 +5738,20 @@ "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", "dev": true, "requires": { - "ansi-escapes": "^3.0.0", - "chalk": "^2.0.0", - "cli-cursor": "^2.1.0", - "cli-width": "^2.0.0", - "external-editor": "^2.0.4", - "figures": "^2.0.0", - "lodash": "^4.3.0", + "ansi-escapes": "3.1.0", + "chalk": "2.4.1", + "cli-cursor": "2.1.0", + "cli-width": "2.2.0", + "external-editor": "2.2.0", + "figures": "2.0.0", + "lodash": "4.17.10", "mute-stream": "0.0.7", - "run-async": "^2.2.0", - "rx-lite": "^4.0.8", - "rx-lite-aggregates": "^4.0.8", - "string-width": "^2.1.0", - "strip-ansi": "^4.0.0", - "through": "^2.3.6" + "run-async": "2.3.0", + "rx-lite": "4.0.8", + "rx-lite-aggregates": "4.0.8", + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "through": "2.3.8" }, "dependencies": { "ansi-regex": { @@ -5766,7 +5766,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -5775,9 +5775,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -5792,7 +5792,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "^3.0.0" + "ansi-regex": "3.0.0" } }, "supports-color": { @@ -5801,7 +5801,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -5812,7 +5812,7 @@ "integrity": "sha1-rp+/k7mEh4eF1QqN4bNWlWBYz1w=", "dev": true, "requires": { - "meow": "^3.3.0" + "meow": "3.7.0" } }, "invariant": { @@ -5820,7 +5820,7 @@ "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", "requires": { - "loose-envify": "^1.0.0" + "loose-envify": "1.3.1" } }, "invert-kv": { @@ -5853,7 +5853,7 @@ "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", "dev": true, "requires": { - "kind-of": "^3.0.2" + "kind-of": "3.2.2" }, "dependencies": { "kind-of": { @@ -5862,7 +5862,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -5879,7 +5879,7 @@ "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", "dev": true, "requires": { - "binary-extensions": "^1.0.0" + "binary-extensions": "1.11.0" } }, "is-buffer": { @@ -5894,7 +5894,7 @@ "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", "dev": true, "requires": { - "builtin-modules": "^1.0.0" + "builtin-modules": "1.1.1" } }, "is-callable": { @@ -5909,7 +5909,7 @@ "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", "dev": true, "requires": { - "kind-of": "^3.0.2" + "kind-of": "3.2.2" }, "dependencies": { "kind-of": { @@ -5918,7 +5918,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -5935,9 +5935,9 @@ "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", "dev": true, "requires": { - "is-accessor-descriptor": "^0.1.6", - "is-data-descriptor": "^0.1.4", - "kind-of": "^5.0.0" + "is-accessor-descriptor": "0.1.6", + "is-data-descriptor": "0.1.4", + "kind-of": "5.1.0" }, "dependencies": { "kind-of": { @@ -5972,7 +5972,7 @@ "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", "dev": true, "requires": { - "number-is-nan": "^1.0.0" + "number-is-nan": "1.0.1" } }, "is-fullwidth-code-point": { @@ -5987,7 +5987,7 @@ "integrity": "sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=", "dev": true, "requires": { - "is-extglob": "^2.1.1" + "is-extglob": "2.1.1" } }, "is-number": { @@ -5996,7 +5996,7 @@ "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", "dev": true, "requires": { - "kind-of": "^3.0.2" + "kind-of": "3.2.2" }, "dependencies": { "kind-of": { @@ -6005,7 +6005,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -6016,7 +6016,7 @@ "integrity": "sha512-OTiixgpZAT1M4NHgS5IguFp/Vz2VI3U7Goh4/HA1adtwyLtSBrxYlcSYkhpAE07s4fKEcjrFxyvtQBND4vFQyQ==", "dev": true, "requires": { - "is-number": "^4.0.0" + "is-number": "4.0.0" }, "dependencies": { "is-number": { @@ -6039,7 +6039,7 @@ "integrity": "sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==", "dev": true, "requires": { - "is-path-inside": "^1.0.0" + "is-path-inside": "1.0.1" } }, "is-path-inside": { @@ -6048,7 +6048,7 @@ "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=", "dev": true, "requires": { - "path-is-inside": "^1.0.1" + "path-is-inside": "1.0.2" } }, "is-plain-obj": { @@ -6063,7 +6063,7 @@ "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, "requires": { - "isobject": "^3.0.1" + "isobject": "3.0.1" } }, "is-promise": { @@ -6078,7 +6078,7 @@ "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", "dev": true, "requires": { - "has": "^1.0.1" + "has": "1.0.1" } }, "is-resolvable": { @@ -6099,7 +6099,7 @@ "integrity": "sha1-z2EJDaDZ77yrhyLeum8DIgjbsOk=", "dev": true, "requires": { - "html-comment-regex": "^1.1.0" + "html-comment-regex": "1.1.1" } }, "is-symbol": { @@ -6162,12 +6162,12 @@ "integrity": "sha1-kEFwfWIkE2f1iDRTK58ZwsNvrHg=", "requires": { "JSONSelect": "0.4.0", - "cjson": "~0.2.1", - "ebnf-parser": "~0.1.9", + "cjson": "0.2.1", + "ebnf-parser": "0.1.10", "escodegen": "0.0.21", - "esprima": "1.0.x", - "jison-lex": "0.2.x", - "lex-parser": "~0.1.3", + "esprima": "1.0.4", + "jison-lex": "0.2.1", + "lex-parser": "0.1.4", "nomnom": "1.5.2" }, "dependencies": { @@ -6176,9 +6176,9 @@ "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-0.0.21.tgz", "integrity": "sha1-U9ZSz6EDA4gnlFilJmxf/HCcY8M=", "requires": { - "esprima": "~1.0.2", - "estraverse": "~0.0.4", - "source-map": ">= 0.1.2" + "esprima": "1.0.4", + "estraverse": "0.0.4", + "source-map": "0.6.1" } }, "esprima": { @@ -6198,7 +6198,7 @@ "resolved": "https://registry.npmjs.org/jison-lex/-/jison-lex-0.2.1.tgz", "integrity": "sha1-rEuBXozOUTLrErXfz+jXB7iETf4=", "requires": { - "lex-parser": "0.1.x", + "lex-parser": "0.1.4", "nomnom": "1.5.2" } }, @@ -6229,8 +6229,8 @@ "integrity": "sha512-5OlmInr6FuKAEAqNi0Ag8ErS8LWCp53w/vHSc6Ndm8aTckuOKI/uiil/ltP/xRrl+cSz8Q/oW7q6iglNQHCx+A==", "dev": true, "requires": { - "babylon": "^6.18.0", - "chalk": "^2.1.0" + "babylon": "6.18.0", + "chalk": "2.4.1" }, "dependencies": { "ansi-styles": { @@ -6239,7 +6239,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -6248,9 +6248,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -6265,7 +6265,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -6281,8 +6281,8 @@ "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=", "dev": true, "requires": { - "argparse": "^1.0.7", - "esprima": "^2.6.0" + "argparse": "1.0.10", + "esprima": "2.7.3" }, "dependencies": { "esprima": { @@ -6299,7 +6299,7 @@ "integrity": "sha1-P7YOqgicVED5MZ9RdgzNB+JJlzM=", "dev": true, "requires": { - "xmlcreate": "^1.0.1" + "xmlcreate": "1.0.2" } }, "jsbn": { @@ -6314,17 +6314,17 @@ "dev": true, "requires": { "babylon": "7.0.0-beta.19", - "bluebird": "~3.5.0", - "catharsis": "~0.8.9", - "escape-string-regexp": "~1.0.5", - "js2xmlparser": "~3.0.0", - "klaw": "~2.0.0", - "marked": "~0.3.6", - "mkdirp": "~0.5.1", - "requizzle": "~0.2.1", - "strip-json-comments": "~2.0.1", + "bluebird": "3.5.1", + "catharsis": "0.8.9", + "escape-string-regexp": "1.0.5", + "js2xmlparser": "3.0.0", + "klaw": "2.0.0", + "marked": "0.3.19", + "mkdirp": "0.5.1", + "requizzle": "0.2.1", + "strip-json-comments": "2.0.1", "taffydb": "2.6.2", - "underscore": "~1.8.3" + "underscore": "1.8.3" }, "dependencies": { "babylon": { @@ -6339,7 +6339,7 @@ "integrity": "sha1-WcEo4Nxc5BAgEVEZTuucv4WGUPY=", "dev": true, "requires": { - "graceful-fs": "^4.1.9" + "graceful-fs": "4.1.11" } }, "underscore": { @@ -6356,8 +6356,8 @@ "integrity": "sha512-KF3WTPvoPYc8ZyXzC1m+vvwi+2VCKkqZX/NkqcE1tFephp8RnZAxG52QB/wvz/zoDS6XU28aM8NItMPMad50PA==", "dev": true, "requires": { - "jsdoc-regex": "^1.0.1", - "lodash": "^4.13.1" + "jsdoc-regex": "1.0.1", + "lodash": "4.17.10" } }, "jsdoc-regex": { @@ -6372,32 +6372,32 @@ "integrity": "sha512-x5No5FpJgBg3j5aBwA8ka6eGuS5IxbC8FOkmyccKvObtFT0bDMict/LOxINZsZGZSfGdNomLZ/qRV9Bpq/GIBA==", "dev": true, "requires": { - "abab": "^1.0.4", - "acorn": "^5.3.0", - "acorn-globals": "^4.1.0", - "array-equal": "^1.0.0", - "cssom": ">= 0.3.2 < 0.4.0", - "cssstyle": ">= 0.2.37 < 0.3.0", - "data-urls": "^1.0.0", - "domexception": "^1.0.0", - "escodegen": "^1.9.0", - "html-encoding-sniffer": "^1.0.2", - "left-pad": "^1.2.0", - "nwmatcher": "^1.4.3", + "abab": "1.0.4", + "acorn": "5.5.3", + "acorn-globals": "4.1.0", + "array-equal": "1.0.0", + "cssom": "0.3.2", + "cssstyle": "0.2.37", + "data-urls": "1.0.0", + "domexception": "1.0.1", + "escodegen": "1.9.1", + "html-encoding-sniffer": "1.0.2", + "left-pad": "1.3.0", + "nwmatcher": "1.4.4", "parse5": "4.0.0", - "pn": "^1.1.0", - "request": "^2.83.0", - "request-promise-native": "^1.0.5", - "sax": "^1.2.4", - "symbol-tree": "^3.2.2", - "tough-cookie": "^2.3.3", - "w3c-hr-time": "^1.0.1", - "webidl-conversions": "^4.0.2", - "whatwg-encoding": "^1.0.3", - "whatwg-mimetype": "^2.1.0", - "whatwg-url": "^6.4.0", - "ws": "^4.0.0", - "xml-name-validator": "^3.0.0" + "pn": "1.1.0", + "request": "2.86.0", + "request-promise-native": "1.0.5", + "sax": "1.2.4", + "symbol-tree": "3.2.2", + "tough-cookie": "2.3.4", + "w3c-hr-time": "1.0.1", + "webidl-conversions": "4.0.2", + "whatwg-encoding": "1.0.3", + "whatwg-mimetype": "2.1.0", + "whatwg-url": "6.4.1", + "ws": "4.1.0", + "xml-name-validator": "3.0.0" } }, "jsesc": { @@ -6411,14 +6411,14 @@ "integrity": "sha1-HnJSkVzmgbQIJ+4UJIxG006apiw=", "dev": true, "requires": { - "cli": "~1.0.0", - "console-browserify": "1.1.x", - "exit": "0.1.x", - "htmlparser2": "3.8.x", - "lodash": "3.7.x", - "minimatch": "~3.0.2", - "shelljs": "0.3.x", - "strip-json-comments": "1.0.x" + "cli": "1.0.1", + "console-browserify": "1.1.0", + "exit": "0.1.2", + "htmlparser2": "3.8.3", + "lodash": "3.7.0", + "minimatch": "3.0.4", + "shelljs": "0.3.0", + "strip-json-comments": "1.0.4" }, "dependencies": { "lodash": { @@ -6477,7 +6477,7 @@ "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", "dev": true, "requires": { - "graceful-fs": "^4.1.6" + "graceful-fs": "4.1.11" } }, "jsonpath": { @@ -6520,19 +6520,19 @@ "resolved": "https://registry.npmjs.org/kbpgp/-/kbpgp-2.0.77.tgz", "integrity": "sha1-bp0vV5hb6VlsXqbJ5aODM/MasZk=", "requires": { - "bn": "^1.0.0", - "bzip-deflate": "^1.0.0", - "deep-equal": ">=0.2.1", - "iced-error": ">=0.0.10", - "iced-lock": "^1.0.2", - "iced-runtime": "^1.0.3", - "keybase-ecurve": "^1.0.0", - "keybase-nacl": "^1.0.0", - "minimist": "^1.2.0", - "pgp-utils": ">=0.0.34", - "purepack": ">=1.0.4", - "triplesec": ">=3.0.19", - "tweetnacl": "^0.13.1" + "bn": "1.0.1", + "bzip-deflate": "1.0.0", + "deep-equal": "1.0.1", + "iced-error": "0.0.12", + "iced-lock": "1.1.0", + "iced-runtime": "1.0.3", + "keybase-ecurve": "1.0.0", + "keybase-nacl": "1.0.10", + "minimist": "1.2.0", + "pgp-utils": "0.0.34", + "purepack": "1.0.4", + "triplesec": "3.0.26", + "tweetnacl": "0.13.3" } }, "kew": { @@ -6546,7 +6546,7 @@ "resolved": "https://registry.npmjs.org/keybase-ecurve/-/keybase-ecurve-1.0.0.tgz", "integrity": "sha1-xrxyrdpGA/0xhP7n6ZaU7Y/WmtI=", "requires": { - "bn": "^1.0.0" + "bn": "1.0.1" } }, "keybase-nacl": { @@ -6554,9 +6554,9 @@ "resolved": "https://registry.npmjs.org/keybase-nacl/-/keybase-nacl-1.0.10.tgz", "integrity": "sha1-OGWDHpSBUWSI33y9mJRn6VDYeos=", "requires": { - "iced-runtime": "^1.0.2", - "tweetnacl": "^0.13.1", - "uint64be": "^1.0.1" + "iced-runtime": "1.0.3", + "tweetnacl": "0.13.3", + "uint64be": "1.0.1" } }, "killable": { @@ -6577,7 +6577,7 @@ "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", "dev": true, "requires": { - "graceful-fs": "^4.1.9" + "graceful-fs": "4.1.11" } }, "lcid": { @@ -6586,7 +6586,7 @@ "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", "dev": true, "requires": { - "invert-kv": "^1.0.0" + "invert-kv": "1.0.0" } }, "leb": { @@ -6607,14 +6607,14 @@ "integrity": "sha512-q3SyEnPKbk9zh4l36PGeW2fgynKu+FpbhiUNx/yaiBUQ3V0CbACCgb9FzYWcRgI2DJlP6eI4jc8XPrCTi55YcQ==", "dev": true, "requires": { - "errno": "^0.1.1", - "graceful-fs": "^4.1.2", - "image-size": "~0.5.0", - "mime": "^1.4.1", - "mkdirp": "^0.5.0", - "promise": "^7.1.1", - "request": "^2.83.0", - "source-map": "~0.6.0" + "errno": "0.1.7", + "graceful-fs": "4.1.11", + "image-size": "0.5.5", + "mime": "1.6.0", + "mkdirp": "0.5.1", + "promise": "7.3.1", + "request": "2.86.0", + "source-map": "0.6.1" } }, "less-loader": { @@ -6623,9 +6623,9 @@ "integrity": "sha512-KNTsgCE9tMOM70+ddxp9yyt9iHqgmSs0yTZc5XH5Wo+g80RWRIYNqE58QJKm/yMud5wZEvz50ugRDuzVIkyahg==", "dev": true, "requires": { - "clone": "^2.1.1", - "loader-utils": "^1.1.0", - "pify": "^3.0.0" + "clone": "2.1.1", + "loader-utils": "1.1.0", + "pify": "3.0.0" }, "dependencies": { "clone": { @@ -6641,8 +6641,8 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", "requires": { - "prelude-ls": "~1.1.2", - "type-check": "~0.3.2" + "prelude-ls": "1.1.2", + "type-check": "0.3.2" } }, "lex-parser": { @@ -6662,10 +6662,10 @@ "integrity": "sha1-ByhWEYD9IP+KaSdQWFL8WKrqDIg=", "dev": true, "requires": { - "arrify": "^1.0.0", - "multimatch": "^2.0.0", - "pkg-up": "^1.0.0", - "resolve-pkg": "^0.1.0" + "arrify": "1.0.1", + "multimatch": "2.1.0", + "pkg-up": "1.0.0", + "resolve-pkg": "0.1.0" } }, "load-json-file": { @@ -6674,11 +6674,11 @@ "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "parse-json": "^2.2.0", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0", - "strip-bom": "^2.0.0" + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "strip-bom": "2.0.0" }, "dependencies": { "pify": { @@ -6701,9 +6701,9 @@ "integrity": "sha1-yYrvSIvM7aL/teLeZG1qdUQp9c0=", "dev": true, "requires": { - "big.js": "^3.1.3", - "emojis-list": "^2.0.0", - "json5": "^0.5.0" + "big.js": "3.2.0", + "emojis-list": "2.1.0", + "json5": "0.5.1" } }, "locate-path": { @@ -6712,8 +6712,8 @@ "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", "dev": true, "requires": { - "p-locate": "^2.0.0", - "path-exists": "^3.0.0" + "p-locate": "2.0.0", + "path-exists": "3.0.0" } }, "lodash": { @@ -6787,7 +6787,7 @@ "integrity": "sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==", "dev": true, "requires": { - "chalk": "^2.0.1" + "chalk": "2.4.1" }, "dependencies": { "ansi-styles": { @@ -6796,7 +6796,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -6805,9 +6805,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -6822,7 +6822,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -6837,8 +6837,8 @@ "resolved": "https://registry.npmjs.org/loglevel-message-prefix/-/loglevel-message-prefix-3.0.0.tgz", "integrity": "sha1-ER/bltlPlh2PyLiqv7ZrBqw+dq0=", "requires": { - "es6-polyfills": "^2.0.0", - "loglevel": "^1.4.0" + "es6-polyfills": "2.0.0", + "loglevel": "1.6.1" } }, "loglevelnext": { @@ -6847,8 +6847,8 @@ "integrity": "sha512-V/73qkPuJmx4BcBF19xPBr+0ZRVBhc4POxvZTZdMeXpJ4NItXSJ/MSwuFT0kQJlCbXvdlZoQQ/418bS1y9Jh6A==", "dev": true, "requires": { - "es6-symbol": "^3.1.1", - "object.assign": "^4.1.0" + "es6-symbol": "3.1.1", + "object.assign": "4.1.0" } }, "long": { @@ -6862,7 +6862,7 @@ "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz", "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=", "requires": { - "js-tokens": "^3.0.0" + "js-tokens": "3.0.2" } }, "loud-rejection": { @@ -6871,8 +6871,8 @@ "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", "dev": true, "requires": { - "currently-unhandled": "^0.4.1", - "signal-exit": "^3.0.0" + "currently-unhandled": "0.4.1", + "signal-exit": "3.0.2" } }, "lower-case": { @@ -6887,8 +6887,8 @@ "integrity": "sha512-fFEhvcgzuIoJVUF8fYr5KR0YqxD238zgObTps31YdADwPPAp82a4M8TrckkWyx7ekNlf9aBcVn81cFwwXngrJA==", "dev": true, "requires": { - "pseudomap": "^1.0.2", - "yallist": "^2.1.2" + "pseudomap": "1.0.2", + "yallist": "2.1.2" } }, "macaddress": { @@ -6903,7 +6903,7 @@ "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==", "dev": true, "requires": { - "pify": "^3.0.0" + "pify": "3.0.0" } }, "map-cache": { @@ -6924,7 +6924,7 @@ "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", "dev": true, "requires": { - "object-visit": "^1.0.0" + "object-visit": "1.0.1" } }, "marked": { @@ -6945,8 +6945,8 @@ "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", "dev": true, "requires": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1" + "hash-base": "3.0.4", + "inherits": "2.0.3" } }, "media-typer": { @@ -6961,7 +6961,7 @@ "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=", "dev": true, "requires": { - "mimic-fn": "^1.0.0" + "mimic-fn": "1.2.0" } }, "memory-fs": { @@ -6970,8 +6970,8 @@ "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=", "dev": true, "requires": { - "errno": "^0.1.3", - "readable-stream": "^2.0.1" + "errno": "0.1.7", + "readable-stream": "2.3.6" } }, "meow": { @@ -6980,16 +6980,16 @@ "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", "dev": true, "requires": { - "camelcase-keys": "^2.0.0", - "decamelize": "^1.1.2", - "loud-rejection": "^1.0.0", - "map-obj": "^1.0.1", - "minimist": "^1.1.3", - "normalize-package-data": "^2.3.4", - "object-assign": "^4.0.1", - "read-pkg-up": "^1.0.1", - "redent": "^1.0.0", - "trim-newlines": "^1.0.0" + "camelcase-keys": "2.1.0", + "decamelize": "1.2.0", + "loud-rejection": "1.6.0", + "map-obj": "1.0.1", + "minimist": "1.2.0", + "normalize-package-data": "2.4.0", + "object-assign": "4.1.1", + "read-pkg-up": "1.0.1", + "redent": "1.0.0", + "trim-newlines": "1.0.0" } }, "merge-descriptors": { @@ -7010,19 +7010,19 @@ "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "braces": "^2.3.1", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "extglob": "^2.0.4", - "fragment-cache": "^0.2.1", - "kind-of": "^6.0.2", - "nanomatch": "^1.2.9", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.2" + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "braces": "2.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "extglob": "2.0.4", + "fragment-cache": "0.2.1", + "kind-of": "6.0.2", + "nanomatch": "1.2.9", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" } }, "miller-rabin": { @@ -7031,8 +7031,8 @@ "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", "dev": true, "requires": { - "bn.js": "^4.0.0", - "brorand": "^1.0.1" + "bn.js": "4.11.8", + "brorand": "1.1.0" } }, "mime": { @@ -7054,7 +7054,7 @@ "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==", "dev": true, "requires": { - "mime-db": "~1.33.0" + "mime-db": "1.33.0" } }, "mimer": { @@ -7087,7 +7087,7 @@ "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", "dev": true, "requires": { - "brace-expansion": "^1.1.7" + "brace-expansion": "1.1.11" } }, "minimist": { @@ -7101,16 +7101,16 @@ "integrity": "sha512-zHo8v+otD1J10j/tC+VNoGK9keCuByhKovAvdn74dmxJl9+mWHnx6EMsDN4lgRoMI/eYo2nchAxniIbUPb5onw==", "dev": true, "requires": { - "concat-stream": "^1.5.0", - "duplexify": "^3.4.2", - "end-of-stream": "^1.1.0", - "flush-write-stream": "^1.0.0", - "from2": "^2.1.0", - "parallel-transform": "^1.1.0", - "pump": "^2.0.1", - "pumpify": "^1.3.3", - "stream-each": "^1.1.0", - "through2": "^2.0.0" + "concat-stream": "1.6.2", + "duplexify": "3.6.0", + "end-of-stream": "1.4.1", + "flush-write-stream": "1.0.3", + "from2": "2.3.0", + "parallel-transform": "1.1.0", + "pump": "2.0.1", + "pumpify": "1.5.1", + "stream-each": "1.2.2", + "through2": "2.0.3" } }, "mixin-deep": { @@ -7119,8 +7119,8 @@ "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==", "dev": true, "requires": { - "for-in": "^1.0.2", - "is-extendable": "^1.0.1" + "for-in": "1.0.2", + "is-extendable": "1.0.1" }, "dependencies": { "is-extendable": { @@ -7129,7 +7129,7 @@ "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, "requires": { - "is-plain-object": "^2.0.4" + "is-plain-object": "2.0.4" } } } @@ -7161,7 +7161,7 @@ "resolved": "https://registry.npmjs.org/moment-timezone/-/moment-timezone-0.5.17.tgz", "integrity": "sha512-Y/JpVEWIOA9Gho4vO15MTnW1FCmHi3ypprrkUaxsZ1TKg3uqC8q/qMBjTddkHoiwwZN3qvZSr4zJP7x9V3LpXA==", "requires": { - "moment": ">= 2.9.0" + "moment": "2.22.1" } }, "more-entropy": { @@ -7169,7 +7169,7 @@ "resolved": "https://registry.npmjs.org/more-entropy/-/more-entropy-0.0.7.tgz", "integrity": "sha1-Z7/G96hvJvvDeqyD/UbYjGHRCbU=", "requires": { - "iced-runtime": ">=0.0.1" + "iced-runtime": "1.0.3" } }, "move-concurrently": { @@ -7178,12 +7178,12 @@ "integrity": "sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=", "dev": true, "requires": { - "aproba": "^1.1.1", - "copy-concurrently": "^1.0.0", - "fs-write-stream-atomic": "^1.0.8", - "mkdirp": "^0.5.1", - "rimraf": "^2.5.4", - "run-queue": "^1.0.3" + "aproba": "1.2.0", + "copy-concurrently": "1.0.5", + "fs-write-stream-atomic": "1.0.10", + "mkdirp": "0.5.1", + "rimraf": "2.6.2", + "run-queue": "1.0.3" } }, "ms": { @@ -7197,8 +7197,8 @@ "integrity": "sha512-ji6J5enbMyGRHIAkAOu3WdV8nggqviKCEKtXcOqfphZZtQrmHKycfynJ2V7eVPUA4NhJ6V7Wf4TmGbTwKE9B6g==", "dev": true, "requires": { - "dns-packet": "^1.3.1", - "thunky": "^1.0.2" + "dns-packet": "1.3.1", + "thunky": "1.0.2" } }, "multicast-dns-service-types": { @@ -7213,10 +7213,10 @@ "integrity": "sha1-nHkGoi+0wCkZ4vX3UWG0zb1LKis=", "dev": true, "requires": { - "array-differ": "^1.0.0", - "array-union": "^1.0.1", - "arrify": "^1.0.0", - "minimatch": "^3.0.0" + "array-differ": "1.0.0", + "array-union": "1.0.2", + "arrify": "1.0.1", + "minimatch": "3.0.4" } }, "mute-stream": { @@ -7238,18 +7238,18 @@ "integrity": "sha512-n8R9bS8yQ6eSXaV6jHUpKzD8gLsin02w1HSFiegwrs9E098Ylhw5jdyKPaYqvHknHaSCKTPp7C8dGCQ0q9koXA==", "dev": true, "requires": { - "arr-diff": "^4.0.0", - "array-unique": "^0.3.2", - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "fragment-cache": "^0.2.1", - "is-odd": "^2.0.0", - "is-windows": "^1.0.2", - "kind-of": "^6.0.2", - "object.pick": "^1.3.0", - "regex-not": "^1.0.0", - "snapdragon": "^0.8.1", - "to-regex": "^3.0.1" + "arr-diff": "4.0.0", + "array-unique": "0.3.2", + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "fragment-cache": "0.2.1", + "is-odd": "2.0.0", + "is-windows": "1.0.2", + "kind-of": "6.0.2", + "object.pick": "1.3.0", + "regex-not": "1.0.2", + "snapdragon": "0.8.2", + "to-regex": "3.0.2" } }, "natural-compare": { @@ -7282,7 +7282,7 @@ "integrity": "sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==", "dev": true, "requires": { - "lower-case": "^1.1.1" + "lower-case": "1.1.4" } }, "node-forge": { @@ -7296,28 +7296,28 @@ "integrity": "sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==", "dev": true, "requires": { - "assert": "^1.1.1", - "browserify-zlib": "^0.2.0", - "buffer": "^4.3.0", - "console-browserify": "^1.1.0", - "constants-browserify": "^1.0.0", - "crypto-browserify": "^3.11.0", - "domain-browser": "^1.1.1", - "events": "^1.0.0", - "https-browserify": "^1.0.0", - "os-browserify": "^0.3.0", + "assert": "1.4.1", + "browserify-zlib": "0.2.0", + "buffer": "4.9.1", + "console-browserify": "1.1.0", + "constants-browserify": "1.0.0", + "crypto-browserify": "3.12.0", + "domain-browser": "1.2.0", + "events": "1.1.1", + "https-browserify": "1.0.0", + "os-browserify": "0.3.0", "path-browserify": "0.0.0", - "process": "^0.11.10", - "punycode": "^1.2.4", - "querystring-es3": "^0.2.0", - "readable-stream": "^2.3.3", - "stream-browserify": "^2.0.1", - "stream-http": "^2.7.2", - "string_decoder": "^1.0.0", - "timers-browserify": "^2.0.4", + "process": "0.11.10", + "punycode": "1.4.1", + "querystring-es3": "0.2.1", + "readable-stream": "2.3.6", + "stream-browserify": "2.0.1", + "stream-http": "2.8.2", + "string_decoder": "1.1.1", + "timers-browserify": "2.0.10", "tty-browserify": "0.0.0", - "url": "^0.11.0", - "util": "^0.10.3", + "url": "0.11.0", + "util": "0.10.3", "vm-browserify": "0.0.4" }, "dependencies": { @@ -7339,8 +7339,8 @@ "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.5.2.tgz", "integrity": "sha1-9DRUSKhTz71cDSYyDyR3qwUm/i8=", "requires": { - "colors": "0.5.x", - "underscore": "1.1.x" + "colors": "0.5.1", + "underscore": "1.1.7" }, "dependencies": { "underscore": { @@ -7356,7 +7356,7 @@ "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", "dev": true, "requires": { - "abbrev": "1" + "abbrev": "1.1.1" } }, "normalize-package-data": { @@ -7365,10 +7365,10 @@ "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", "dev": true, "requires": { - "hosted-git-info": "^2.1.4", - "is-builtin-module": "^1.0.0", - "semver": "2 || 3 || 4 || 5", - "validate-npm-package-license": "^3.0.1" + "hosted-git-info": "2.6.0", + "is-builtin-module": "1.0.0", + "semver": "5.5.0", + "validate-npm-package-license": "3.0.3" } }, "normalize-path": { @@ -7377,7 +7377,7 @@ "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", "dev": true, "requires": { - "remove-trailing-separator": "^1.0.1" + "remove-trailing-separator": "1.1.0" } }, "normalize-range": { @@ -7392,10 +7392,10 @@ "integrity": "sha1-LMDWazHqIwNkWENuNiDYWVTGbDw=", "dev": true, "requires": { - "object-assign": "^4.0.1", - "prepend-http": "^1.0.0", - "query-string": "^4.1.0", - "sort-keys": "^1.0.0" + "object-assign": "4.1.1", + "prepend-http": "1.0.4", + "query-string": "4.3.4", + "sort-keys": "1.1.2" } }, "npm-run-path": { @@ -7404,7 +7404,7 @@ "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", "dev": true, "requires": { - "path-key": "^2.0.0" + "path-key": "2.0.1" } }, "nth-check": { @@ -7413,7 +7413,7 @@ "integrity": "sha1-mSms32KPwsQQmN6rgqxYDPFJquQ=", "dev": true, "requires": { - "boolbase": "~1.0.0" + "boolbase": "1.0.0" } }, "num2fraction": { @@ -7451,9 +7451,9 @@ "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", "dev": true, "requires": { - "copy-descriptor": "^0.1.0", - "define-property": "^0.2.5", - "kind-of": "^3.0.3" + "copy-descriptor": "0.1.1", + "define-property": "0.2.5", + "kind-of": "3.2.2" }, "dependencies": { "define-property": { @@ -7462,7 +7462,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "^0.1.0" + "is-descriptor": "0.1.6" } }, "kind-of": { @@ -7471,7 +7471,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -7488,7 +7488,7 @@ "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", "dev": true, "requires": { - "isobject": "^3.0.0" + "isobject": "3.0.1" } }, "object.assign": { @@ -7497,10 +7497,10 @@ "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", "dev": true, "requires": { - "define-properties": "^1.1.2", - "function-bind": "^1.1.1", - "has-symbols": "^1.0.0", - "object-keys": "^1.0.11" + "define-properties": "1.1.2", + "function-bind": "1.1.1", + "has-symbols": "1.0.0", + "object-keys": "1.0.11" } }, "object.getownpropertydescriptors": { @@ -7509,8 +7509,8 @@ "integrity": "sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=", "dev": true, "requires": { - "define-properties": "^1.1.2", - "es-abstract": "^1.5.1" + "define-properties": "1.1.2", + "es-abstract": "1.11.0" } }, "object.pick": { @@ -7519,7 +7519,7 @@ "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", "dev": true, "requires": { - "isobject": "^3.0.1" + "isobject": "3.0.1" } }, "obuf": { @@ -7549,7 +7549,7 @@ "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", "dev": true, "requires": { - "wrappy": "1" + "wrappy": "1.0.2" } }, "onetime": { @@ -7558,7 +7558,7 @@ "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", "dev": true, "requires": { - "mimic-fn": "^1.0.0" + "mimic-fn": "1.2.0" } }, "opn": { @@ -7567,7 +7567,7 @@ "integrity": "sha512-bYJHo/LOmoTd+pfiYhfZDnf9zekVJrY+cnS2a5F2x+w5ppvTqObojTP7WiFG+kVZs9Inw+qQ/lw7TroWwhdd2g==", "dev": true, "requires": { - "is-wsl": "^1.1.0" + "is-wsl": "1.1.0" } }, "optionator": { @@ -7575,12 +7575,12 @@ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", "requires": { - "deep-is": "~0.1.3", - "fast-levenshtein": "~2.0.4", - "levn": "~0.3.0", - "prelude-ls": "~1.1.2", - "type-check": "~0.3.2", - "wordwrap": "~1.0.0" + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" } }, "original": { @@ -7589,7 +7589,7 @@ "integrity": "sha512-IEvtB5vM5ULvwnqMxWBLxkS13JIEXbakizMSo3yoPNPCIWzg8TG3Usn/UhXoZFM/m+FuEA20KdzPSFq/0rS+UA==", "dev": true, "requires": { - "url-parse": "~1.4.0" + "url-parse": "1.4.0" } }, "os-browserify": { @@ -7610,9 +7610,9 @@ "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==", "dev": true, "requires": { - "execa": "^0.7.0", - "lcid": "^1.0.0", - "mem": "^1.1.0" + "execa": "0.7.0", + "lcid": "1.0.0", + "mem": "1.1.0" } }, "os-tmpdir": { @@ -7626,7 +7626,7 @@ "resolved": "https://registry.npmjs.org/otp/-/otp-0.1.3.tgz", "integrity": "sha1-wle/JdL5Anr3esUiabPBQmjSvWs=", "requires": { - "thirty-two": "^0.0.2" + "thirty-two": "0.0.2" } }, "p-finally": { @@ -7641,7 +7641,7 @@ "integrity": "sha512-Y/OtIaXtUPr4/YpMv1pCL5L5ed0rumAaAeBSj12F+bSlMdys7i8oQF/GUJmfpTS/QoaRrS/k6pma29haJpsMng==", "dev": true, "requires": { - "p-try": "^1.0.0" + "p-try": "1.0.0" } }, "p-locate": { @@ -7650,7 +7650,7 @@ "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", "dev": true, "requires": { - "p-limit": "^1.1.0" + "p-limit": "1.2.0" } }, "p-map": { @@ -7671,11 +7671,11 @@ "integrity": "sha1-Yx3Mn3mBC3BZZeid7eps/w/B38k=", "dev": true, "requires": { - "meow": "^3.0.0", - "pumpify": "^1.3.3", - "repeating": "^2.0.0", - "split2": "^1.0.0", - "through2": "^2.0.0" + "meow": "3.7.0", + "pumpify": "1.5.1", + "repeating": "2.0.1", + "split2": "1.1.1", + "through2": "2.0.3" } }, "pako": { @@ -7690,9 +7690,9 @@ "integrity": "sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=", "dev": true, "requires": { - "cyclist": "~0.2.2", - "inherits": "^2.0.3", - "readable-stream": "^2.1.5" + "cyclist": "0.2.2", + "inherits": "2.0.3", + "readable-stream": "2.3.6" } }, "param-case": { @@ -7701,7 +7701,7 @@ "integrity": "sha1-35T9jPZTHs915r75oIWPvHK+Ikc=", "dev": true, "requires": { - "no-case": "^2.2.0" + "no-case": "2.3.2" } }, "parse-asn1": { @@ -7710,11 +7710,11 @@ "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==", "dev": true, "requires": { - "asn1.js": "^4.0.0", - "browserify-aes": "^1.0.0", - "create-hash": "^1.1.0", - "evp_bytestokey": "^1.0.0", - "pbkdf2": "^3.0.3" + "asn1.js": "4.10.1", + "browserify-aes": "1.2.0", + "create-hash": "1.2.0", + "evp_bytestokey": "1.0.3", + "pbkdf2": "3.0.16" } }, "parse-json": { @@ -7723,7 +7723,7 @@ "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", "dev": true, "requires": { - "error-ex": "^1.2.0" + "error-ex": "1.3.1" } }, "parse5": { @@ -7792,9 +7792,9 @@ "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" + "graceful-fs": "4.1.11", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" }, "dependencies": { "pify": { @@ -7811,11 +7811,11 @@ "integrity": "sha512-y4CXP3thSxqf7c0qmOF+9UeOTrifiVTIM+u7NWlq+PRsHbr7r7dpCmvzrZxa96JJUNi0Y5w9VqG5ZNeCVMoDcA==", "dev": true, "requires": { - "create-hash": "^1.1.2", - "create-hmac": "^1.1.4", - "ripemd160": "^2.0.1", - "safe-buffer": "^5.0.1", - "sha.js": "^2.4.8" + "create-hash": "1.2.0", + "create-hmac": "1.1.7", + "ripemd160": "2.0.2", + "safe-buffer": "5.1.2", + "sha.js": "2.4.11" } }, "pend": { @@ -7835,8 +7835,8 @@ "resolved": "https://registry.npmjs.org/pgp-utils/-/pgp-utils-0.0.34.tgz", "integrity": "sha1-2E9J98GTteC5QV9cxcKmle15DCM=", "requires": { - "iced-error": ">=0.0.8", - "iced-runtime": ">=0.0.1" + "iced-error": "0.0.12", + "iced-runtime": "1.0.3" } }, "phantomjs-prebuilt": { @@ -7845,15 +7845,15 @@ "integrity": "sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=", "dev": true, "requires": { - "es6-promise": "^4.0.3", - "extract-zip": "^1.6.5", - "fs-extra": "^1.0.0", - "hasha": "^2.2.0", - "kew": "^0.7.0", - "progress": "^1.1.8", - "request": "^2.81.0", - "request-progress": "^2.0.1", - "which": "^1.2.10" + "es6-promise": "4.2.4", + "extract-zip": "1.6.6", + "fs-extra": "1.0.0", + "hasha": "2.2.0", + "kew": "0.7.0", + "progress": "1.1.8", + "request": "2.86.0", + "request-progress": "2.0.1", + "which": "1.3.0" } }, "pify": { @@ -7874,7 +7874,7 @@ "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", "dev": true, "requires": { - "pinkie": "^2.0.0" + "pinkie": "2.0.4" } }, "pkg-dir": { @@ -7883,7 +7883,7 @@ "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", "dev": true, "requires": { - "find-up": "^2.1.0" + "find-up": "2.1.0" } }, "pkg-up": { @@ -7892,7 +7892,7 @@ "integrity": "sha1-Pgj7RhUlxEIWJKM7n35tCvWwWiY=", "dev": true, "requires": { - "find-up": "^1.0.0" + "find-up": "1.1.2" }, "dependencies": { "find-up": { @@ -7901,8 +7901,8 @@ "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", "dev": true, "requires": { - "path-exists": "^2.0.0", - "pinkie-promise": "^2.0.0" + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" } }, "path-exists": { @@ -7911,7 +7911,7 @@ "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", "dev": true, "requires": { - "pinkie-promise": "^2.0.0" + "pinkie-promise": "2.0.1" } } } @@ -7934,9 +7934,9 @@ "integrity": "sha1-uzLs2HwnEErm7kS1o8y/Drsa7ek=", "dev": true, "requires": { - "async": "^1.5.2", - "debug": "^2.2.0", - "mkdirp": "0.5.x" + "async": "1.5.2", + "debug": "2.6.9", + "mkdirp": "0.5.1" }, "dependencies": { "async": { @@ -7959,10 +7959,10 @@ "integrity": "sha512-zrUjRRe1bpXKsX1qAJNJjqZViErVuyEkMTRrwu4ud4sbTtIBRmtaYDrHmcGgmrbsW3MHfmtIf+vJumgQn+PrXg==", "dev": true, "requires": { - "chalk": "^1.1.3", - "js-base64": "^2.1.9", - "source-map": "^0.5.6", - "supports-color": "^3.2.3" + "chalk": "1.1.3", + "js-base64": "2.4.5", + "source-map": "0.5.7", + "supports-color": "3.2.3" }, "dependencies": { "source-map": { @@ -7977,7 +7977,7 @@ "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=", "dev": true, "requires": { - "has-flag": "^1.0.0" + "has-flag": "1.0.0" } } } @@ -7988,9 +7988,9 @@ "integrity": "sha1-d7rnypKK2FcW4v2kLyYb98HWW14=", "dev": true, "requires": { - "postcss": "^5.0.2", - "postcss-message-helpers": "^2.0.0", - "reduce-css-calc": "^1.2.6" + "postcss": "5.2.18", + "postcss-message-helpers": "2.0.0", + "reduce-css-calc": "1.3.0" } }, "postcss-colormin": { @@ -7999,9 +7999,9 @@ "integrity": "sha1-ZjFBfV8OkJo9fsJrJMio0eT5bks=", "dev": true, "requires": { - "colormin": "^1.0.5", - "postcss": "^5.0.13", - "postcss-value-parser": "^3.2.3" + "colormin": "1.1.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-convert-values": { @@ -8010,8 +8010,8 @@ "integrity": "sha1-u9hZPFwf0uPRwyK7kl3K6Nrk1i0=", "dev": true, "requires": { - "postcss": "^5.0.11", - "postcss-value-parser": "^3.1.2" + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-css-variables": { @@ -8020,9 +8020,9 @@ "integrity": "sha1-pS5e8aLrYzqKT1/ENNbYXUD+cxA=", "dev": true, "requires": { - "escape-string-regexp": "^1.0.3", - "extend": "^3.0.1", - "postcss": "^6.0.8" + "escape-string-regexp": "1.0.5", + "extend": "3.0.1", + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -8031,7 +8031,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8040,9 +8040,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8057,9 +8057,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8068,7 +8068,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8079,7 +8079,7 @@ "integrity": "sha1-vv6J+v1bPazlzM5Rt2uBUUvgDj0=", "dev": true, "requires": { - "postcss": "^5.0.14" + "postcss": "5.2.18" } }, "postcss-discard-duplicates": { @@ -8088,7 +8088,7 @@ "integrity": "sha1-uavye4isGIFYpesSq8riAmO5GTI=", "dev": true, "requires": { - "postcss": "^5.0.4" + "postcss": "5.2.18" } }, "postcss-discard-empty": { @@ -8097,7 +8097,7 @@ "integrity": "sha1-0rS9nVztXr2Nyt52QMfXzX9PkrU=", "dev": true, "requires": { - "postcss": "^5.0.14" + "postcss": "5.2.18" } }, "postcss-discard-overridden": { @@ -8106,7 +8106,7 @@ "integrity": "sha1-ix6vVU9ob7KIzYdMVWZ7CqNmjVg=", "dev": true, "requires": { - "postcss": "^5.0.16" + "postcss": "5.2.18" } }, "postcss-discard-unused": { @@ -8115,8 +8115,8 @@ "integrity": "sha1-vOMLLMWR/8Y0Mitfs0ZLbZNPRDM=", "dev": true, "requires": { - "postcss": "^5.0.14", - "uniqs": "^2.0.0" + "postcss": "5.2.18", + "uniqs": "2.0.0" } }, "postcss-filter-plugins": { @@ -8125,8 +8125,8 @@ "integrity": "sha1-bYWGJTTXNaxCDkqFgG4fXUKG2Ew=", "dev": true, "requires": { - "postcss": "^5.0.4", - "uniqid": "^4.0.0" + "postcss": "5.2.18", + "uniqid": "4.1.1" } }, "postcss-import": { @@ -8135,10 +8135,10 @@ "integrity": "sha512-5l327iI75POonjxkXgdRCUS+AlzAdBx4pOvMEhTKTCjb1p8IEeVR9yx3cPbmN7LIWJLbfnIXxAhoB4jpD0c/Cw==", "dev": true, "requires": { - "postcss": "^6.0.1", - "postcss-value-parser": "^3.2.3", - "read-cache": "^1.0.0", - "resolve": "^1.1.7" + "postcss": "6.0.22", + "postcss-value-parser": "3.3.0", + "read-cache": "1.0.0", + "resolve": "1.1.7" }, "dependencies": { "ansi-styles": { @@ -8147,7 +8147,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8156,9 +8156,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8173,9 +8173,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8184,7 +8184,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8195,10 +8195,10 @@ "integrity": "sha1-U56a/J3chiASHr+djDZz4M5Q0oo=", "dev": true, "requires": { - "cosmiconfig": "^2.1.0", - "object-assign": "^4.1.0", - "postcss-load-options": "^1.2.0", - "postcss-load-plugins": "^2.3.0" + "cosmiconfig": "2.2.2", + "object-assign": "4.1.1", + "postcss-load-options": "1.2.0", + "postcss-load-plugins": "2.3.0" } }, "postcss-load-options": { @@ -8207,8 +8207,8 @@ "integrity": "sha1-sJixVZ3awt8EvAuzdfmaXP4rbYw=", "dev": true, "requires": { - "cosmiconfig": "^2.1.0", - "object-assign": "^4.1.0" + "cosmiconfig": "2.2.2", + "object-assign": "4.1.1" } }, "postcss-load-plugins": { @@ -8217,8 +8217,8 @@ "integrity": "sha1-dFdoEWWZrKLwCfrUJrABdQSdjZI=", "dev": true, "requires": { - "cosmiconfig": "^2.1.1", - "object-assign": "^4.1.0" + "cosmiconfig": "2.2.2", + "object-assign": "4.1.1" } }, "postcss-loader": { @@ -8227,10 +8227,10 @@ "integrity": "sha512-pV7kB5neJ0/1tZ8L1uGOBNTVBCSCXQoIsZMsrwvO8V2rKGa2tBl/f80GGVxow2jJnRJ2w1ocx693EKhZAb9Isg==", "dev": true, "requires": { - "loader-utils": "^1.1.0", - "postcss": "^6.0.0", - "postcss-load-config": "^1.2.0", - "schema-utils": "^0.4.0" + "loader-utils": "1.1.0", + "postcss": "6.0.22", + "postcss-load-config": "1.2.0", + "schema-utils": "0.4.5" }, "dependencies": { "ansi-styles": { @@ -8239,7 +8239,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8248,9 +8248,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8265,9 +8265,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8276,7 +8276,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8287,9 +8287,9 @@ "integrity": "sha1-TFUwMTwI4dWzu/PSu8dH4njuonA=", "dev": true, "requires": { - "has": "^1.0.1", - "postcss": "^5.0.10", - "postcss-value-parser": "^3.1.1" + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-merge-longhand": { @@ -8298,7 +8298,7 @@ "integrity": "sha1-I9kM0Sewp3mUkVMyc5A0oaTz1lg=", "dev": true, "requires": { - "postcss": "^5.0.4" + "postcss": "5.2.18" } }, "postcss-merge-rules": { @@ -8307,11 +8307,11 @@ "integrity": "sha1-0d9d+qexrMO+VT8OnhDofGG19yE=", "dev": true, "requires": { - "browserslist": "^1.5.2", - "caniuse-api": "^1.5.2", - "postcss": "^5.0.4", - "postcss-selector-parser": "^2.2.2", - "vendors": "^1.0.0" + "browserslist": "1.7.7", + "caniuse-api": "1.6.1", + "postcss": "5.2.18", + "postcss-selector-parser": "2.2.3", + "vendors": "1.0.2" }, "dependencies": { "browserslist": { @@ -8320,8 +8320,8 @@ "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", "dev": true, "requires": { - "caniuse-db": "^1.0.30000639", - "electron-to-chromium": "^1.2.7" + "caniuse-db": "1.0.30000843", + "electron-to-chromium": "1.3.47" } } } @@ -8338,9 +8338,9 @@ "integrity": "sha1-S1jttWZB66fIR0qzUmyv17vey2k=", "dev": true, "requires": { - "object-assign": "^4.0.1", - "postcss": "^5.0.4", - "postcss-value-parser": "^3.0.2" + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-minify-gradients": { @@ -8349,8 +8349,8 @@ "integrity": "sha1-Xb2hE3NwP4PPtKPqOIHY11/15uE=", "dev": true, "requires": { - "postcss": "^5.0.12", - "postcss-value-parser": "^3.3.0" + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-minify-params": { @@ -8359,10 +8359,10 @@ "integrity": "sha1-rSzgcTc7lDs9kwo/pZo1jCjW8fM=", "dev": true, "requires": { - "alphanum-sort": "^1.0.1", - "postcss": "^5.0.2", - "postcss-value-parser": "^3.0.2", - "uniqs": "^2.0.0" + "alphanum-sort": "1.0.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0", + "uniqs": "2.0.0" } }, "postcss-minify-selectors": { @@ -8371,10 +8371,10 @@ "integrity": "sha1-ssapjAByz5G5MtGkllCBFDEXNb8=", "dev": true, "requires": { - "alphanum-sort": "^1.0.2", - "has": "^1.0.1", - "postcss": "^5.0.14", - "postcss-selector-parser": "^2.0.0" + "alphanum-sort": "1.0.2", + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-selector-parser": "2.2.3" } }, "postcss-modules-extract-imports": { @@ -8383,7 +8383,7 @@ "integrity": "sha1-ZhQOzs447wa/DT41XWm/WdFB6oU=", "dev": true, "requires": { - "postcss": "^6.0.1" + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -8392,7 +8392,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8401,9 +8401,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8418,9 +8418,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8429,7 +8429,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8440,8 +8440,8 @@ "integrity": "sha1-99gMOYxaOT+nlkRmvRlQCn1hwGk=", "dev": true, "requires": { - "css-selector-tokenizer": "^0.7.0", - "postcss": "^6.0.1" + "css-selector-tokenizer": "0.7.0", + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -8450,7 +8450,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8459,9 +8459,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8476,9 +8476,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8487,7 +8487,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8498,8 +8498,8 @@ "integrity": "sha1-1upkmUx5+XtipytCb75gVqGUu5A=", "dev": true, "requires": { - "css-selector-tokenizer": "^0.7.0", - "postcss": "^6.0.1" + "css-selector-tokenizer": "0.7.0", + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -8508,7 +8508,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8517,9 +8517,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8534,9 +8534,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8545,7 +8545,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8556,8 +8556,8 @@ "integrity": "sha1-7P+p1+GSUYOJ9CrQ6D9yrsRW6iA=", "dev": true, "requires": { - "icss-replace-symbols": "^1.1.0", - "postcss": "^6.0.1" + "icss-replace-symbols": "1.1.0", + "postcss": "6.0.22" }, "dependencies": { "ansi-styles": { @@ -8566,7 +8566,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -8575,9 +8575,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -8592,9 +8592,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -8603,7 +8603,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -8614,7 +8614,7 @@ "integrity": "sha1-757nEhLX/nWceO0WL2HtYrXLk/E=", "dev": true, "requires": { - "postcss": "^5.0.5" + "postcss": "5.2.18" } }, "postcss-normalize-url": { @@ -8623,10 +8623,10 @@ "integrity": "sha1-EI90s/L82viRov+j6kWSJ5/HgiI=", "dev": true, "requires": { - "is-absolute-url": "^2.0.0", - "normalize-url": "^1.4.0", - "postcss": "^5.0.14", - "postcss-value-parser": "^3.2.3" + "is-absolute-url": "2.1.0", + "normalize-url": "1.9.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-ordered-values": { @@ -8635,8 +8635,8 @@ "integrity": "sha1-7sbCpntsQSqNsgQud/6NpD+VwR0=", "dev": true, "requires": { - "postcss": "^5.0.4", - "postcss-value-parser": "^3.0.1" + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-reduce-idents": { @@ -8645,8 +8645,8 @@ "integrity": "sha1-wsbSDMlYKE9qv75j92Cb9AkFmtM=", "dev": true, "requires": { - "postcss": "^5.0.4", - "postcss-value-parser": "^3.0.2" + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-reduce-initial": { @@ -8655,7 +8655,7 @@ "integrity": "sha1-aPgGlfBF0IJjqHmtJA343WT2ROo=", "dev": true, "requires": { - "postcss": "^5.0.4" + "postcss": "5.2.18" } }, "postcss-reduce-transforms": { @@ -8664,9 +8664,9 @@ "integrity": "sha1-/3b02CEkN7McKYpC0uFEQCV3GuE=", "dev": true, "requires": { - "has": "^1.0.1", - "postcss": "^5.0.8", - "postcss-value-parser": "^3.0.1" + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" } }, "postcss-selector-parser": { @@ -8675,9 +8675,9 @@ "integrity": "sha1-+UN3iGBsPJrO4W/+jYsWKX8nu5A=", "dev": true, "requires": { - "flatten": "^1.0.2", - "indexes-of": "^1.0.1", - "uniq": "^1.0.1" + "flatten": "1.0.2", + "indexes-of": "1.0.1", + "uniq": "1.0.1" } }, "postcss-svgo": { @@ -8686,10 +8686,10 @@ "integrity": "sha1-tt8YqmE7Zm4TPwittSGcJoSsEI0=", "dev": true, "requires": { - "is-svg": "^2.0.0", - "postcss": "^5.0.14", - "postcss-value-parser": "^3.2.3", - "svgo": "^0.7.0" + "is-svg": "2.1.0", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0", + "svgo": "0.7.2" } }, "postcss-unique-selectors": { @@ -8698,9 +8698,9 @@ "integrity": "sha1-mB1X0p3csz57Hf4f1DuGSfkzyh0=", "dev": true, "requires": { - "alphanum-sort": "^1.0.1", - "postcss": "^5.0.4", - "uniqs": "^2.0.0" + "alphanum-sort": "1.0.2", + "postcss": "5.2.18", + "uniqs": "2.0.0" } }, "postcss-value-parser": { @@ -8715,9 +8715,9 @@ "integrity": "sha1-0hCd3AVbka9n/EyzsCWUZjnSryI=", "dev": true, "requires": { - "has": "^1.0.1", - "postcss": "^5.0.4", - "uniqs": "^2.0.0" + "has": "1.0.1", + "postcss": "5.2.18", + "uniqs": "2.0.0" } }, "prelude-ls": { @@ -8737,8 +8737,8 @@ "integrity": "sha1-X0+HyPkeWuPzuoerTPXgOxoX8aM=", "dev": true, "requires": { - "renderkid": "^2.0.1", - "utila": "~0.4" + "renderkid": "2.0.1", + "utila": "0.4.0" } }, "private": { @@ -8771,7 +8771,7 @@ "dev": true, "optional": true, "requires": { - "asap": "~2.0.3" + "asap": "2.0.6" } }, "promise-inflight": { @@ -8786,7 +8786,7 @@ "integrity": "sha512-jQTChiCJteusULxjBp8+jftSQE5Obdl3k4cnmLA6WXtK6XFuWRnvVL7aCiBqaLPM8c4ph0S4tKna8XvmIwEnXQ==", "dev": true, "requires": { - "forwarded": "~0.1.2", + "forwarded": "0.1.2", "ipaddr.js": "1.6.0" } }, @@ -8808,11 +8808,11 @@ "integrity": "sha512-4kJ5Esocg8X3h8YgJsKAuoesBgB7mqH3eowiDzMUPKiRDDE7E/BqqZD1hnTByIaAFiwAw246YEltSq7tdrOH0Q==", "dev": true, "requires": { - "bn.js": "^4.1.0", - "browserify-rsa": "^4.0.0", - "create-hash": "^1.1.0", - "parse-asn1": "^5.0.0", - "randombytes": "^2.0.1" + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.2.0", + "parse-asn1": "5.1.1", + "randombytes": "2.0.6" } }, "pump": { @@ -8821,8 +8821,8 @@ "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", "dev": true, "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" + "end-of-stream": "1.4.1", + "once": "1.4.0" } }, "pumpify": { @@ -8831,9 +8831,9 @@ "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", "dev": true, "requires": { - "duplexify": "^3.6.0", - "inherits": "^2.0.3", - "pump": "^2.0.0" + "duplexify": "3.6.0", + "inherits": "2.0.3", + "pump": "2.0.1" } }, "punycode": { @@ -8865,8 +8865,8 @@ "integrity": "sha1-u7aTucqRXCMlFbIosaArYJBD2+s=", "dev": true, "requires": { - "object-assign": "^4.1.0", - "strict-uri-encode": "^1.0.0" + "object-assign": "4.1.1", + "strict-uri-encode": "1.1.0" } }, "querystring": { @@ -8893,7 +8893,7 @@ "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", "dev": true, "requires": { - "safe-buffer": "^5.1.0" + "safe-buffer": "5.1.2" } }, "randomfill": { @@ -8902,8 +8902,8 @@ "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", "dev": true, "requires": { - "randombytes": "^2.0.5", - "safe-buffer": "^5.1.0" + "randombytes": "2.0.6", + "safe-buffer": "5.1.2" } }, "range-parser": { @@ -8918,8 +8918,8 @@ "integrity": "sha1-HQJ8K/oRasxmI7yo8AAWVyqH1CU=", "dev": true, "requires": { - "bytes": "1", - "string_decoder": "0.10" + "bytes": "1.0.0", + "string_decoder": "0.10.31" }, "dependencies": { "string_decoder": { @@ -8936,10 +8936,10 @@ "integrity": "sha512-LdLD8xD4zzLsAT5xyushXDNscEjB7+2ulnl8+r1pnESlYtlJtVSoCMBGr30eDRJ3+2Gq89jK9P9e4tCEH1+ywA==", "dev": true, "requires": { - "deep-extend": "^0.5.1", - "ini": "~1.3.0", - "minimist": "^1.2.0", - "strip-json-comments": "~2.0.1" + "deep-extend": "0.5.1", + "ini": "1.3.5", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" } }, "read-cache": { @@ -8948,7 +8948,7 @@ "integrity": "sha1-5mTvMRYRZsl1HNvo28+GtftY93Q=", "dev": true, "requires": { - "pify": "^2.3.0" + "pify": "2.3.0" }, "dependencies": { "pify": { @@ -8965,9 +8965,9 @@ "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", "dev": true, "requires": { - "load-json-file": "^1.0.0", - "normalize-package-data": "^2.3.2", - "path-type": "^1.0.0" + "load-json-file": "1.1.0", + "normalize-package-data": "2.4.0", + "path-type": "1.1.0" } }, "read-pkg-up": { @@ -8976,8 +8976,8 @@ "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", "dev": true, "requires": { - "find-up": "^1.0.0", - "read-pkg": "^1.0.0" + "find-up": "1.1.2", + "read-pkg": "1.1.0" }, "dependencies": { "find-up": { @@ -8986,8 +8986,8 @@ "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", "dev": true, "requires": { - "path-exists": "^2.0.0", - "pinkie-promise": "^2.0.0" + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" } }, "path-exists": { @@ -8996,7 +8996,7 @@ "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", "dev": true, "requires": { - "pinkie-promise": "^2.0.0" + "pinkie-promise": "2.0.1" } } } @@ -9007,13 +9007,13 @@ "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", "dev": true, "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.2", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" } }, "readdirp": { @@ -9022,10 +9022,10 @@ "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", "dev": true, "requires": { - "graceful-fs": "^4.1.2", - "minimatch": "^3.0.2", - "readable-stream": "^2.0.2", - "set-immediate-shim": "^1.0.1" + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "readable-stream": "2.3.6", + "set-immediate-shim": "1.0.1" } }, "redent": { @@ -9034,8 +9034,8 @@ "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", "dev": true, "requires": { - "indent-string": "^2.1.0", - "strip-indent": "^1.0.1" + "indent-string": "2.1.0", + "strip-indent": "1.0.1" } }, "reduce-css-calc": { @@ -9044,9 +9044,9 @@ "integrity": "sha1-dHyRTgSWFKTJz7umKYca0dKSdxY=", "dev": true, "requires": { - "balanced-match": "^0.4.2", - "math-expression-evaluator": "^1.2.14", - "reduce-function-call": "^1.0.1" + "balanced-match": "0.4.2", + "math-expression-evaluator": "1.2.17", + "reduce-function-call": "1.0.2" }, "dependencies": { "balanced-match": { @@ -9063,7 +9063,7 @@ "integrity": "sha1-WiAL+S4ON3UXUv5FsKszD9S2vpk=", "dev": true, "requires": { - "balanced-match": "^0.4.2" + "balanced-match": "0.4.2" }, "dependencies": { "balanced-match": { @@ -9091,9 +9091,9 @@ "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", "dev": true, "requires": { - "babel-runtime": "^6.18.0", - "babel-types": "^6.19.0", - "private": "^0.1.6" + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "private": "0.1.8" } }, "regex-not": { @@ -9102,8 +9102,8 @@ "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", "dev": true, "requires": { - "extend-shallow": "^3.0.2", - "safe-regex": "^1.1.0" + "extend-shallow": "3.0.2", + "safe-regex": "1.1.0" } }, "regexpp": { @@ -9118,9 +9118,9 @@ "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", "dev": true, "requires": { - "regenerate": "^1.2.1", - "regjsgen": "^0.2.0", - "regjsparser": "^0.1.4" + "regenerate": "1.4.0", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" } }, "regjsgen": { @@ -9135,7 +9135,7 @@ "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", "dev": true, "requires": { - "jsesc": "~0.5.0" + "jsesc": "0.5.0" }, "dependencies": { "jsesc": { @@ -9164,11 +9164,11 @@ "integrity": "sha1-iYyr/Ivt5Le5ETWj/9Mj5YwNsxk=", "dev": true, "requires": { - "css-select": "^1.1.0", - "dom-converter": "~0.1", - "htmlparser2": "~3.3.0", - "strip-ansi": "^3.0.0", - "utila": "~0.3" + "css-select": "1.2.0", + "dom-converter": "0.1.4", + "htmlparser2": "3.3.0", + "strip-ansi": "3.0.1", + "utila": "0.3.3" }, "dependencies": { "domhandler": { @@ -9177,7 +9177,7 @@ "integrity": "sha1-0mRvXlf2w7qxHPbLBdPArPdBJZQ=", "dev": true, "requires": { - "domelementtype": "1" + "domelementtype": "1.3.0" } }, "domutils": { @@ -9186,7 +9186,7 @@ "integrity": "sha1-vdw94Jm5ou+sxRxiPyj0FuzFdIU=", "dev": true, "requires": { - "domelementtype": "1" + "domelementtype": "1.3.0" } }, "htmlparser2": { @@ -9195,10 +9195,10 @@ "integrity": "sha1-zHDQWln2VC5D8OaFyYLhTJJKnv4=", "dev": true, "requires": { - "domelementtype": "1", - "domhandler": "2.1", - "domutils": "1.1", - "readable-stream": "1.0" + "domelementtype": "1.3.0", + "domhandler": "2.1.0", + "domutils": "1.1.6", + "readable-stream": "1.0.34" } }, "isarray": { @@ -9213,10 +9213,10 @@ "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", "dev": true, "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.1", + "core-util-is": "1.0.2", + "inherits": "2.0.3", "isarray": "0.0.1", - "string_decoder": "~0.10.x" + "string_decoder": "0.10.31" } }, "string_decoder": { @@ -9251,7 +9251,7 @@ "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", "dev": true, "requires": { - "is-finite": "^1.0.0" + "is-finite": "1.0.2" } }, "request": { @@ -9260,27 +9260,27 @@ "integrity": "sha512-BQZih67o9r+Ys94tcIW4S7Uu8pthjrQVxhsZ/weOwHbDfACxvIyvnAbzFQxjy1jMtvFSzv5zf4my6cZsJBbVzw==", "dev": true, "requires": { - "aws-sign2": "~0.7.0", - "aws4": "^1.6.0", - "caseless": "~0.12.0", - "combined-stream": "~1.0.5", - "extend": "~3.0.1", - "forever-agent": "~0.6.1", - "form-data": "~2.3.1", - "har-validator": "~5.0.3", - "hawk": "~6.0.2", - "http-signature": "~1.2.0", - "is-typedarray": "~1.0.0", - "isstream": "~0.1.2", - "json-stringify-safe": "~5.0.1", - "mime-types": "~2.1.17", - "oauth-sign": "~0.8.2", - "performance-now": "^2.1.0", - "qs": "~6.5.1", - "safe-buffer": "^5.1.1", - "tough-cookie": "~2.3.3", - "tunnel-agent": "^0.6.0", - "uuid": "^3.1.0" + "aws-sign2": "0.7.0", + "aws4": "1.7.0", + "caseless": "0.12.0", + "combined-stream": "1.0.6", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.3.2", + "har-validator": "5.0.3", + "hawk": "6.0.2", + "http-signature": "1.2.0", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.18", + "oauth-sign": "0.8.2", + "performance-now": "2.1.0", + "qs": "6.5.2", + "safe-buffer": "5.1.2", + "tough-cookie": "2.3.4", + "tunnel-agent": "0.6.0", + "uuid": "3.2.1" } }, "request-progress": { @@ -9289,7 +9289,7 @@ "integrity": "sha1-XTa7V5YcZzqlt4jbyBQf3yO0Tgg=", "dev": true, "requires": { - "throttleit": "^1.0.0" + "throttleit": "1.0.0" } }, "request-promise-core": { @@ -9298,7 +9298,7 @@ "integrity": "sha1-Pu4AssWqgyOc+wTFcA2jb4HNCLY=", "dev": true, "requires": { - "lodash": "^4.13.1" + "lodash": "4.17.10" } }, "request-promise-native": { @@ -9308,8 +9308,8 @@ "dev": true, "requires": { "request-promise-core": "1.1.1", - "stealthy-require": "^1.1.0", - "tough-cookie": ">=2.3.3" + "stealthy-require": "1.1.1", + "tough-cookie": "2.3.4" } }, "require-directory": { @@ -9336,8 +9336,8 @@ "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", "dev": true, "requires": { - "caller-path": "^0.1.0", - "resolve-from": "^1.0.0" + "caller-path": "0.1.0", + "resolve-from": "1.0.1" } }, "requires-port": { @@ -9352,7 +9352,7 @@ "integrity": "sha1-aUPDUwxNmn5G8c3dUcFY/GcM294=", "dev": true, "requires": { - "underscore": "~1.6.0" + "underscore": "1.6.0" }, "dependencies": { "underscore": { @@ -9375,7 +9375,7 @@ "integrity": "sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=", "dev": true, "requires": { - "resolve-from": "^3.0.0" + "resolve-from": "3.0.0" }, "dependencies": { "resolve-from": { @@ -9398,7 +9398,7 @@ "integrity": "sha1-AsyZNBDik2livZcWahsHfalyVTE=", "dev": true, "requires": { - "resolve-from": "^2.0.0" + "resolve-from": "2.0.0" }, "dependencies": { "resolve-from": { @@ -9421,8 +9421,8 @@ "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", "dev": true, "requires": { - "onetime": "^2.0.0", - "signal-exit": "^3.0.2" + "onetime": "2.0.1", + "signal-exit": "3.0.2" } }, "ret": { @@ -9437,7 +9437,7 @@ "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", "dev": true, "requires": { - "glob": "^7.0.5" + "glob": "7.1.2" } }, "ripemd160": { @@ -9446,8 +9446,8 @@ "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", "dev": true, "requires": { - "hash-base": "^3.0.0", - "inherits": "^2.0.1" + "hash-base": "3.0.4", + "inherits": "2.0.3" } }, "run-async": { @@ -9456,7 +9456,7 @@ "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", "dev": true, "requires": { - "is-promise": "^2.1.0" + "is-promise": "2.1.0" } }, "run-queue": { @@ -9465,7 +9465,7 @@ "integrity": "sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=", "dev": true, "requires": { - "aproba": "^1.1.1" + "aproba": "1.2.0" } }, "rx-lite": { @@ -9480,7 +9480,7 @@ "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", "dev": true, "requires": { - "rx-lite": "*" + "rx-lite": "4.0.8" } }, "safe-buffer": { @@ -9501,7 +9501,7 @@ "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", "dev": true, "requires": { - "ret": "~0.1.10" + "ret": "0.1.15" } }, "safer-buffer": { @@ -9516,16 +9516,16 @@ "integrity": "sha512-52ThA+Z7h6BnvpSVbURwChl10XZrps5q7ytjTwWcIe9bmJwnVP6cpEVK2NvDOUhGupoqAvNbUz3cpnJDp4+/pg==", "dev": true, "requires": { - "chalk": "^2.3.0", - "htmlparser2": "^3.9.0", - "lodash.clonedeep": "^4.5.0", - "lodash.escaperegexp": "^4.1.2", - "lodash.isplainobject": "^4.0.6", - "lodash.isstring": "^4.0.1", - "lodash.mergewith": "^4.6.0", - "postcss": "^6.0.14", - "srcset": "^1.0.0", - "xtend": "^4.0.0" + "chalk": "2.4.1", + "htmlparser2": "3.9.2", + "lodash.clonedeep": "4.5.0", + "lodash.escaperegexp": "4.1.2", + "lodash.isplainobject": "4.0.6", + "lodash.isstring": "4.0.1", + "lodash.mergewith": "4.6.1", + "postcss": "6.0.22", + "srcset": "1.0.0", + "xtend": "4.0.1" }, "dependencies": { "ansi-styles": { @@ -9534,7 +9534,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -9543,9 +9543,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "entities": { @@ -9566,12 +9566,12 @@ "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", "dev": true, "requires": { - "domelementtype": "^1.3.0", - "domhandler": "^2.3.0", - "domutils": "^1.5.1", - "entities": "^1.1.1", - "inherits": "^2.0.1", - "readable-stream": "^2.0.2" + "domelementtype": "1.3.0", + "domhandler": "2.3.0", + "domutils": "1.5.1", + "entities": "1.1.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6" } }, "postcss": { @@ -9580,9 +9580,9 @@ "integrity": "sha512-Toc9lLoUASwGqxBSJGTVcOQiDqjK+Z2XlWBg+IgYwQMY9vA2f7iMpXVc1GpPcfTSyM5lkxNo0oDwDRO+wm7XHA==", "dev": true, "requires": { - "chalk": "^2.4.1", - "source-map": "^0.6.1", - "supports-color": "^5.4.0" + "chalk": "2.4.1", + "source-map": "0.6.1", + "supports-color": "5.4.0" } }, "supports-color": { @@ -9591,7 +9591,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -9608,8 +9608,8 @@ "integrity": "sha512-yYrjb9TX2k/J1Y5UNy3KYdZq10xhYcF8nMpAW6o3hy6Q8WSIEf9lJHG/ePnOBfziPM3fvQwfOwa13U/Fh8qTfA==", "dev": true, "requires": { - "ajv": "^6.1.0", - "ajv-keywords": "^3.1.0" + "ajv": "6.5.0", + "ajv-keywords": "3.2.0" }, "dependencies": { "ajv": { @@ -9618,10 +9618,10 @@ "integrity": "sha512-VDUX1oSajablmiyFyED9L1DFndg0P9h7p1F+NO8FkIzei6EPrR6Zu1n18rd5P8PqaSRd/FrWv3G1TVBqpM83gA==", "dev": true, "requires": { - "fast-deep-equal": "^2.0.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.3.0", - "uri-js": "^4.2.1" + "fast-deep-equal": "2.0.1", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1", + "uri-js": "4.2.1" } }, "ajv-keywords": { @@ -9671,18 +9671,18 @@ "dev": true, "requires": { "debug": "2.6.9", - "depd": "~1.1.2", - "destroy": "~1.0.4", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "etag": "~1.8.1", + "depd": "1.1.2", + "destroy": "1.0.4", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "etag": "1.8.1", "fresh": "0.5.2", - "http-errors": "~1.6.2", + "http-errors": "1.6.3", "mime": "1.4.1", "ms": "2.0.0", - "on-finished": "~2.3.0", - "range-parser": "~1.2.0", - "statuses": "~1.4.0" + "on-finished": "2.3.0", + "range-parser": "1.2.0", + "statuses": "1.4.0" }, "dependencies": { "mime": { @@ -9705,13 +9705,13 @@ "integrity": "sha1-03aNabHn2C5c4FD/9bRTvqEqkjk=", "dev": true, "requires": { - "accepts": "~1.3.4", + "accepts": "1.3.5", "batch": "0.6.1", "debug": "2.6.9", - "escape-html": "~1.0.3", - "http-errors": "~1.6.2", - "mime-types": "~2.1.17", - "parseurl": "~1.3.2" + "escape-html": "1.0.3", + "http-errors": "1.6.3", + "mime-types": "2.1.18", + "parseurl": "1.3.2" } }, "serve-static": { @@ -9720,9 +9720,9 @@ "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==", "dev": true, "requires": { - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "parseurl": "~1.3.2", + "encodeurl": "1.0.2", + "escape-html": "1.0.3", + "parseurl": "1.3.2", "send": "0.16.2" } }, @@ -9744,10 +9744,10 @@ "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==", "dev": true, "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.3", - "split-string": "^3.0.1" + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "split-string": "3.1.0" }, "dependencies": { "extend-shallow": { @@ -9756,7 +9756,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } } } @@ -9779,8 +9779,8 @@ "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", "dev": true, "requires": { - "inherits": "^2.0.1", - "safe-buffer": "^5.0.1" + "inherits": "2.0.3", + "safe-buffer": "5.1.2" } }, "shebang-command": { @@ -9789,7 +9789,7 @@ "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", "dev": true, "requires": { - "shebang-regex": "^1.0.0" + "shebang-regex": "1.0.0" } }, "shebang-regex": { @@ -9816,8 +9816,8 @@ "integrity": "sha1-Vpy+IYAgKSamKiZs094Jyc60P4M=", "dev": true, "requires": { - "underscore": "^1.7.0", - "url-join": "^1.1.0" + "underscore": "1.7.0", + "url-join": "1.1.0" } }, "slash": { @@ -9832,7 +9832,7 @@ "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", "dev": true, "requires": { - "is-fullwidth-code-point": "^2.0.0" + "is-fullwidth-code-point": "2.0.0" } }, "snapdragon": { @@ -9841,14 +9841,14 @@ "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", "dev": true, "requires": { - "base": "^0.11.1", - "debug": "^2.2.0", - "define-property": "^0.2.5", - "extend-shallow": "^2.0.1", - "map-cache": "^0.2.2", - "source-map": "^0.5.6", - "source-map-resolve": "^0.5.0", - "use": "^3.1.0" + "base": "0.11.2", + "debug": "2.6.9", + "define-property": "0.2.5", + "extend-shallow": "2.0.1", + "map-cache": "0.2.2", + "source-map": "0.5.7", + "source-map-resolve": "0.5.2", + "use": "3.1.0" }, "dependencies": { "define-property": { @@ -9857,7 +9857,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "^0.1.0" + "is-descriptor": "0.1.6" } }, "extend-shallow": { @@ -9866,7 +9866,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } }, "source-map": { @@ -9883,9 +9883,9 @@ "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", "dev": true, "requires": { - "define-property": "^1.0.0", - "isobject": "^3.0.0", - "snapdragon-util": "^3.0.1" + "define-property": "1.0.0", + "isobject": "3.0.1", + "snapdragon-util": "3.0.1" }, "dependencies": { "define-property": { @@ -9894,7 +9894,7 @@ "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, "requires": { - "is-descriptor": "^1.0.0" + "is-descriptor": "1.0.2" } }, "is-accessor-descriptor": { @@ -9903,7 +9903,7 @@ "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-data-descriptor": { @@ -9912,7 +9912,7 @@ "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, "requires": { - "kind-of": "^6.0.0" + "kind-of": "6.0.2" } }, "is-descriptor": { @@ -9921,9 +9921,9 @@ "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, "requires": { - "is-accessor-descriptor": "^1.0.0", - "is-data-descriptor": "^1.0.0", - "kind-of": "^6.0.2" + "is-accessor-descriptor": "1.0.0", + "is-data-descriptor": "1.0.0", + "kind-of": "6.0.2" } } } @@ -9934,7 +9934,7 @@ "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", "dev": true, "requires": { - "kind-of": "^3.2.0" + "kind-of": "3.2.2" }, "dependencies": { "kind-of": { @@ -9943,7 +9943,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -9954,7 +9954,7 @@ "integrity": "sha512-FL1b58BDrqS3A11lJ0zEdnJ3UOKqVxawAkF3k7F0CVN7VQ34aZrV+G8BZ1WC9ZL7NyrwsW0oviwsWDgRuVYtJg==", "dev": true, "requires": { - "hoek": "4.x.x" + "hoek": "4.2.1" } }, "sockjs": { @@ -9963,8 +9963,8 @@ "integrity": "sha512-V48klKZl8T6MzatbLlzzRNhMepEys9Y4oGFpypBFFn1gLI/QQ9HtLLyWJNbPlwGLelOVOEijUbTTJeLLI59jLw==", "dev": true, "requires": { - "faye-websocket": "^0.10.0", - "uuid": "^3.0.1" + "faye-websocket": "0.10.0", + "uuid": "3.2.1" } }, "sockjs-client": { @@ -9973,12 +9973,12 @@ "integrity": "sha1-W6vjhrd15M8U51IJEUUmVAFsixI=", "dev": true, "requires": { - "debug": "^2.6.6", + "debug": "2.6.9", "eventsource": "0.1.6", - "faye-websocket": "~0.11.0", - "inherits": "^2.0.1", - "json3": "^3.3.2", - "url-parse": "^1.1.8" + "faye-websocket": "0.11.1", + "inherits": "2.0.3", + "json3": "3.3.2", + "url-parse": "1.4.0" }, "dependencies": { "faye-websocket": { @@ -9987,7 +9987,7 @@ "integrity": "sha1-8O/hjE9W5PQK/H4Gxxn9XuYYjzg=", "dev": true, "requires": { - "websocket-driver": ">=0.5.1" + "websocket-driver": "0.7.0" } } } @@ -9998,7 +9998,7 @@ "integrity": "sha1-RBttTTRnmPG05J6JIK37oOVD+a0=", "dev": true, "requires": { - "is-plain-obj": "^1.0.0" + "is-plain-obj": "1.1.0" } }, "sortablejs": { @@ -10023,11 +10023,11 @@ "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==", "dev": true, "requires": { - "atob": "^2.1.1", - "decode-uri-component": "^0.2.0", - "resolve-url": "^0.2.1", - "source-map-url": "^0.4.0", - "urix": "^0.1.0" + "atob": "2.1.1", + "decode-uri-component": "0.2.0", + "resolve-url": "0.2.1", + "source-map-url": "0.4.0", + "urix": "0.1.0" } }, "source-map-support": { @@ -10036,7 +10036,7 @@ "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==", "dev": true, "requires": { - "source-map": "^0.5.6" + "source-map": "0.5.7" }, "dependencies": { "source-map": { @@ -10059,8 +10059,8 @@ "integrity": "sha512-N19o9z5cEyc8yQQPukRCZ9EUmb4HUpnrmaL/fxS2pBo2jbfcFRVuFZ/oFC+vZz0MNNk0h80iMn5/S6qGZOL5+g==", "dev": true, "requires": { - "spdx-expression-parse": "^3.0.0", - "spdx-license-ids": "^3.0.0" + "spdx-expression-parse": "3.0.0", + "spdx-license-ids": "3.0.0" } }, "spdx-exceptions": { @@ -10075,8 +10075,8 @@ "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", "dev": true, "requires": { - "spdx-exceptions": "^2.1.0", - "spdx-license-ids": "^3.0.0" + "spdx-exceptions": "2.1.0", + "spdx-license-ids": "3.0.0" } }, "spdx-license-ids": { @@ -10091,12 +10091,12 @@ "integrity": "sha1-Qv9B7OXMD5mjpsKKq7c/XDsDrLw=", "dev": true, "requires": { - "debug": "^2.6.8", - "handle-thing": "^1.2.5", - "http-deceiver": "^1.2.7", - "safe-buffer": "^5.0.1", - "select-hose": "^2.0.0", - "spdy-transport": "^2.0.18" + "debug": "2.6.9", + "handle-thing": "1.2.5", + "http-deceiver": "1.2.7", + "safe-buffer": "5.1.2", + "select-hose": "2.0.0", + "spdy-transport": "2.1.0" } }, "spdy-transport": { @@ -10105,13 +10105,13 @@ "integrity": "sha512-bpUeGpZcmZ692rrTiqf9/2EUakI6/kXX1Rpe0ib/DyOzbiexVfXkw6GnvI9hVGvIwVaUhkaBojjCZwLNRGQg1g==", "dev": true, "requires": { - "debug": "^2.6.8", - "detect-node": "^2.0.3", - "hpack.js": "^2.1.6", - "obuf": "^1.1.1", - "readable-stream": "^2.2.9", - "safe-buffer": "^5.0.1", - "wbuf": "^1.7.2" + "debug": "2.6.9", + "detect-node": "2.0.3", + "hpack.js": "2.1.6", + "obuf": "1.1.2", + "readable-stream": "2.3.6", + "safe-buffer": "5.1.2", + "wbuf": "1.7.3" } }, "split-string": { @@ -10120,7 +10120,7 @@ "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", "dev": true, "requires": { - "extend-shallow": "^3.0.0" + "extend-shallow": "3.0.2" } }, "split.js": { @@ -10134,7 +10134,7 @@ "integrity": "sha1-Fi2bGIZfAqsvKtlYVSLbm1TEgfk=", "dev": true, "requires": { - "through2": "~2.0.0" + "through2": "2.0.3" } }, "sprintf-js": { @@ -10149,8 +10149,8 @@ "integrity": "sha1-pWad4StC87HV6D7QPHEEb8SPQe8=", "dev": true, "requires": { - "array-uniq": "^1.0.2", - "number-is-nan": "^1.0.0" + "array-uniq": "1.0.3", + "number-is-nan": "1.0.1" } }, "ssdeep.js": { @@ -10164,14 +10164,14 @@ "integrity": "sha1-Ew9Zde3a2WPx1W+SuaxsUfqfg+s=", "dev": true, "requires": { - "asn1": "~0.2.3", - "assert-plus": "^1.0.0", - "bcrypt-pbkdf": "^1.0.0", - "dashdash": "^1.12.0", - "ecc-jsbn": "~0.1.1", - "getpass": "^0.1.1", - "jsbn": "~0.1.0", - "tweetnacl": "~0.14.0" + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" }, "dependencies": { "jsbn": { @@ -10196,7 +10196,7 @@ "integrity": "sha512-XRSIPqLij52MtgoQavH/x/dU1qVKtWUAAZeOHsR9c2Ddi4XerFy3mc1alf+dLJKl9EUIm/Ht+EowFkTUOA6GAQ==", "dev": true, "requires": { - "safe-buffer": "^5.1.1" + "safe-buffer": "5.1.2" } }, "static-eval": { @@ -10204,7 +10204,7 @@ "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.0.tgz", "integrity": "sha512-6flshd3F1Gwm+Ksxq463LtFd1liC77N/PX1FVVc3OzL3hAmo2fwHFbuArkcfi7s9rTNsLEhcRmXGFZhlgy40uw==", "requires": { - "escodegen": "^1.8.1" + "escodegen": "1.9.1" } }, "static-extend": { @@ -10213,8 +10213,8 @@ "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", "dev": true, "requires": { - "define-property": "^0.2.5", - "object-copy": "^0.1.0" + "define-property": "0.2.5", + "object-copy": "0.1.0" }, "dependencies": { "define-property": { @@ -10223,7 +10223,7 @@ "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, "requires": { - "is-descriptor": "^0.1.0" + "is-descriptor": "0.1.6" } } } @@ -10246,8 +10246,8 @@ "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", "dev": true, "requires": { - "inherits": "~2.0.1", - "readable-stream": "^2.0.2" + "inherits": "2.0.3", + "readable-stream": "2.3.6" } }, "stream-each": { @@ -10256,8 +10256,8 @@ "integrity": "sha512-mc1dbFhGBxvTM3bIWmAAINbqiuAk9TATcfIQC8P+/+HJefgaiTlMn2dHvkX8qlI12KeYKSQ1Ua9RrIqrn1VPoA==", "dev": true, "requires": { - "end-of-stream": "^1.1.0", - "stream-shift": "^1.0.0" + "end-of-stream": "1.4.1", + "stream-shift": "1.0.0" } }, "stream-http": { @@ -10266,11 +10266,11 @@ "integrity": "sha512-QllfrBhqF1DPcz46WxKTs6Mz1Bpc+8Qm6vbqOpVav5odAXwbyzwnEczoWqtxrsmlO+cJqtPrp/8gWKWjaKLLlA==", "dev": true, "requires": { - "builtin-status-codes": "^3.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.3.6", - "to-arraybuffer": "^1.0.0", - "xtend": "^4.0.0" + "builtin-status-codes": "3.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "to-arraybuffer": "1.0.1", + "xtend": "4.0.1" } }, "stream-shift": { @@ -10297,8 +10297,8 @@ "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", "dev": true, "requires": { - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^4.0.0" + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" }, "dependencies": { "ansi-regex": { @@ -10313,7 +10313,7 @@ "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", "dev": true, "requires": { - "ansi-regex": "^3.0.0" + "ansi-regex": "3.0.0" } } } @@ -10324,7 +10324,7 @@ "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, "requires": { - "safe-buffer": "~5.1.0" + "safe-buffer": "5.1.2" } }, "strip-ansi": { @@ -10332,7 +10332,7 @@ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", "requires": { - "ansi-regex": "^2.0.0" + "ansi-regex": "2.1.1" } }, "strip-bom": { @@ -10341,7 +10341,7 @@ "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", "dev": true, "requires": { - "is-utf8": "^0.2.0" + "is-utf8": "0.2.1" } }, "strip-eof": { @@ -10356,7 +10356,7 @@ "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", "dev": true, "requires": { - "get-stdin": "^4.0.1" + "get-stdin": "4.0.1" } }, "strip-json-comments": { @@ -10371,8 +10371,8 @@ "integrity": "sha512-T+UNsAcl3Yg+BsPKs1vd22Fr8sVT+CJMtzqc6LEw9bbJZb43lm9GoeIfUcDEefBSWC0BhYbcdupV1GtI4DGzxg==", "dev": true, "requires": { - "loader-utils": "^1.1.0", - "schema-utils": "^0.4.5" + "loader-utils": "1.1.0", + "schema-utils": "0.4.5" } }, "supports-color": { @@ -10386,13 +10386,13 @@ "integrity": "sha1-n1dyQTlSE1xv779Ar+ak+qiLS7U=", "dev": true, "requires": { - "coa": "~1.0.1", - "colors": "~1.1.2", - "csso": "~2.3.1", - "js-yaml": "~3.7.0", - "mkdirp": "~0.5.1", - "sax": "~1.2.1", - "whet.extend": "~0.9.9" + "coa": "1.0.4", + "colors": "1.1.2", + "csso": "2.3.2", + "js-yaml": "3.7.0", + "mkdirp": "0.5.1", + "sax": "1.2.4", + "whet.extend": "0.9.9" }, "dependencies": { "colors": { @@ -10415,12 +10415,12 @@ "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", "dev": true, "requires": { - "ajv": "^5.2.3", - "ajv-keywords": "^2.1.0", - "chalk": "^2.1.0", - "lodash": "^4.17.4", + "ajv": "5.5.2", + "ajv-keywords": "2.1.1", + "chalk": "2.4.1", + "lodash": "4.17.10", "slice-ansi": "1.0.0", - "string-width": "^2.1.1" + "string-width": "2.1.1" }, "dependencies": { "ansi-styles": { @@ -10429,7 +10429,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -10438,9 +10438,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -10455,7 +10455,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -10501,8 +10501,8 @@ "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", "dev": true, "requires": { - "readable-stream": "^2.1.5", - "xtend": "~4.0.1" + "readable-stream": "2.3.6", + "xtend": "4.0.1" } }, "thunky": { @@ -10517,7 +10517,7 @@ "integrity": "sha512-YvC1SV1XdOUaL6gx5CoGroT3Gu49pK9+TZ38ErPldOWW4j49GI1HKs9DV+KGq/w6y+LZ72W1c8cKz2vzY+qpzg==", "dev": true, "requires": { - "setimmediate": "^1.0.4" + "setimmediate": "1.0.5" } }, "tiny-lr": { @@ -10526,12 +10526,12 @@ "integrity": "sha512-44yhA3tsaRoMOjQQ+5v5mVdqef+kH6Qze9jTpqtVufgYjYt08zyZAwNwwVBj3i1rJMnR52IxOW0LK0vBzgAkuA==", "dev": true, "requires": { - "body": "^5.1.0", - "debug": "^3.1.0", - "faye-websocket": "~0.10.0", - "livereload-js": "^2.3.0", - "object-assign": "^4.1.0", - "qs": "^6.4.0" + "body": "5.1.0", + "debug": "3.1.0", + "faye-websocket": "0.10.0", + "livereload-js": "2.3.0", + "object-assign": "4.1.1", + "qs": "6.5.2" }, "dependencies": { "debug": { @@ -10551,7 +10551,7 @@ "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", "dev": true, "requires": { - "os-tmpdir": "~1.0.2" + "os-tmpdir": "1.0.2" } }, "to-arraybuffer": { @@ -10571,7 +10571,7 @@ "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", "dev": true, "requires": { - "kind-of": "^3.0.2" + "kind-of": "3.2.2" }, "dependencies": { "kind-of": { @@ -10580,7 +10580,7 @@ "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, "requires": { - "is-buffer": "^1.1.5" + "is-buffer": "1.1.6" } } } @@ -10591,10 +10591,10 @@ "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", "dev": true, "requires": { - "define-property": "^2.0.2", - "extend-shallow": "^3.0.2", - "regex-not": "^1.0.2", - "safe-regex": "^1.1.0" + "define-property": "2.0.2", + "extend-shallow": "3.0.2", + "regex-not": "1.0.2", + "safe-regex": "1.1.0" } }, "to-regex-range": { @@ -10603,8 +10603,8 @@ "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", "dev": true, "requires": { - "is-number": "^3.0.0", - "repeat-string": "^1.6.1" + "is-number": "3.0.0", + "repeat-string": "1.6.1" } }, "toposort": { @@ -10619,7 +10619,7 @@ "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", "dev": true, "requires": { - "punycode": "^1.4.1" + "punycode": "1.4.1" }, "dependencies": { "punycode": { @@ -10636,7 +10636,7 @@ "integrity": "sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=", "dev": true, "requires": { - "punycode": "^2.1.0" + "punycode": "2.1.0" } }, "trim-newlines": { @@ -10656,11 +10656,11 @@ "resolved": "https://registry.npmjs.org/triplesec/-/triplesec-3.0.26.tgz", "integrity": "sha1-3/K7R1ikIzcuc5o5fYmR8Fl9CsE=", "requires": { - "iced-error": ">=0.0.9", - "iced-lock": "^1.0.1", - "iced-runtime": "^1.0.2", - "more-entropy": ">=0.0.7", - "progress": "~1.1.2" + "iced-error": "0.0.12", + "iced-lock": "1.1.0", + "iced-runtime": "1.0.3", + "more-entropy": "0.0.7", + "progress": "1.1.8" } }, "tty-browserify": { @@ -10675,7 +10675,7 @@ "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", "dev": true, "requires": { - "safe-buffer": "^5.0.1" + "safe-buffer": "5.1.2" } }, "tweetnacl": { @@ -10688,7 +10688,7 @@ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", "requires": { - "prelude-ls": "~1.1.2" + "prelude-ls": "1.1.2" } }, "type-is": { @@ -10698,7 +10698,7 @@ "dev": true, "requires": { "media-typer": "0.3.0", - "mime-types": "~2.1.18" + "mime-types": "2.1.18" } }, "typedarray": { @@ -10718,8 +10718,8 @@ "integrity": "sha512-hobogryjDV36VrLK3Y69ou4REyrTApzUblVFmdQOYRe8cYaSmFJXMb4dR9McdvYDSbeNdzUgYr2YVukJaErJcA==", "dev": true, "requires": { - "commander": "~2.15.0", - "source-map": "~0.6.1" + "commander": "2.15.1", + "source-map": "0.6.1" } }, "uglifyjs-webpack-plugin": { @@ -10728,14 +10728,14 @@ "integrity": "sha512-hIQJ1yxAPhEA2yW/i7Fr+SXZVMp+VEI3d42RTHBgQd2yhp/1UdBcR3QEWPV5ahBxlqQDMEMTuTEvDHSFINfwSw==", "dev": true, "requires": { - "cacache": "^10.0.4", - "find-cache-dir": "^1.0.0", - "schema-utils": "^0.4.5", - "serialize-javascript": "^1.4.0", - "source-map": "^0.6.1", - "uglify-es": "^3.3.4", - "webpack-sources": "^1.1.0", - "worker-farm": "^1.5.2" + "cacache": "10.0.4", + "find-cache-dir": "1.0.0", + "schema-utils": "0.4.5", + "serialize-javascript": "1.5.0", + "source-map": "0.6.1", + "uglify-es": "3.3.9", + "webpack-sources": "1.1.0", + "worker-farm": "1.6.0" }, "dependencies": { "commander": { @@ -10750,8 +10750,8 @@ "integrity": "sha512-r+MU0rfv4L/0eeW3xZrd16t4NZfK8Ld4SWVglYBb7ez5uXFWHuVRs6xCTrf1yirs9a4j4Y27nn7SRfO6v67XsQ==", "dev": true, "requires": { - "commander": "~2.13.0", - "source-map": "~0.6.1" + "commander": "2.13.0", + "source-map": "0.6.1" } } } @@ -10795,10 +10795,10 @@ "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=", "dev": true, "requires": { - "arr-union": "^3.1.0", - "get-value": "^2.0.6", - "is-extendable": "^0.1.1", - "set-value": "^0.4.3" + "arr-union": "3.1.0", + "get-value": "2.0.6", + "is-extendable": "0.1.1", + "set-value": "0.4.3" }, "dependencies": { "extend-shallow": { @@ -10807,7 +10807,7 @@ "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, "requires": { - "is-extendable": "^0.1.0" + "is-extendable": "0.1.1" } }, "set-value": { @@ -10816,10 +10816,10 @@ "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=", "dev": true, "requires": { - "extend-shallow": "^2.0.1", - "is-extendable": "^0.1.1", - "is-plain-object": "^2.0.1", - "to-object-path": "^0.3.0" + "extend-shallow": "2.0.1", + "is-extendable": "0.1.1", + "is-plain-object": "2.0.4", + "to-object-path": "0.3.0" } } } @@ -10836,7 +10836,7 @@ "integrity": "sha1-iSIN32t1GuUrX3JISGNShZa7hME=", "dev": true, "requires": { - "macaddress": "^0.2.8" + "macaddress": "0.2.8" } }, "uniqs": { @@ -10851,7 +10851,7 @@ "integrity": "sha1-0F8v5AMlYIcfMOk8vnNe6iAVFPM=", "dev": true, "requires": { - "unique-slug": "^2.0.0" + "unique-slug": "2.0.0" } }, "unique-slug": { @@ -10860,7 +10860,7 @@ "integrity": "sha1-22Z258fMBimHj/GWCXx4hVrp9Ks=", "dev": true, "requires": { - "imurmurhash": "^0.1.4" + "imurmurhash": "0.1.4" } }, "unixify": { @@ -10869,7 +10869,7 @@ "integrity": "sha1-OmQcjC/7zk2mg6XHDwOkYpQMIJA=", "dev": true, "requires": { - "normalize-path": "^2.1.1" + "normalize-path": "2.1.1" } }, "unpipe": { @@ -10884,8 +10884,8 @@ "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", "dev": true, "requires": { - "has-value": "^0.3.1", - "isobject": "^3.0.0" + "has-value": "0.3.1", + "isobject": "3.0.1" }, "dependencies": { "has-value": { @@ -10894,9 +10894,9 @@ "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", "dev": true, "requires": { - "get-value": "^2.0.3", - "has-values": "^0.1.4", - "isobject": "^2.0.0" + "get-value": "2.0.6", + "has-values": "0.1.4", + "isobject": "2.1.0" }, "dependencies": { "isobject": { @@ -10936,7 +10936,7 @@ "integrity": "sha512-jpKCA3HjsBfSDOEgxRDAxQCNyHfCPSbq57PqCkd3gAyBuPb3IWxw54EHncqESznIdqSetHfw3D7ylThu2Kcc9A==", "dev": true, "requires": { - "punycode": "^2.1.0" + "punycode": "2.1.0" } }, "urix": { @@ -10975,9 +10975,9 @@ "integrity": "sha512-rAonpHy7231fmweBKUFe0bYnlGDty77E+fm53NZdij7j/YOpyGzc7ttqG1nAXl3aRs0k41o0PC3TvGXQiw2Zvw==", "dev": true, "requires": { - "loader-utils": "^1.1.0", - "mime": "^2.0.3", - "schema-utils": "^0.4.3" + "loader-utils": "1.1.0", + "mime": "2.3.1", + "schema-utils": "0.4.5" }, "dependencies": { "mime": { @@ -10994,8 +10994,8 @@ "integrity": "sha512-ERuGxDiQ6Xw/agN4tuoCRbmwRuZP0cJ1lJxJubXr5Q/5cDa78+Dc4wfvtxzhzhkm5VvmW6Mf8EVj9SPGN4l8Lg==", "dev": true, "requires": { - "querystringify": "^2.0.0", - "requires-port": "^1.0.0" + "querystringify": "2.0.0", + "requires-port": "1.0.0" } }, "use": { @@ -11004,7 +11004,7 @@ "integrity": "sha512-6UJEQM/L+mzC3ZJNM56Q4DFGLX/evKGRg15UJHGB9X5j5Z3AFbgZvjUh2yq/UJUY4U5dh7Fal++XbNg1uzpRAw==", "dev": true, "requires": { - "kind-of": "^6.0.2" + "kind-of": "6.0.2" } }, "utf8": { @@ -11041,8 +11041,8 @@ "integrity": "sha512-i+6qA2MPhvoKLuxnJNpXAGhg7HphQOSUq2LKMZD0m15EiskXUkMvKdF4Uui0WYeCUGea+o2cw/ZuwehtfsrNkA==", "dev": true, "requires": { - "define-properties": "^1.1.2", - "object.getownpropertydescriptors": "^2.0.3" + "define-properties": "1.1.2", + "object.getownpropertydescriptors": "2.0.3" } }, "utila": { @@ -11075,8 +11075,8 @@ "integrity": "sha512-63ZOUnL4SIXj4L0NixR3L1lcjO38crAbgrTpl28t8jjrfuiOBL5Iygm+60qPs/KsZGzPNg6Smnc/oY16QTjF0g==", "dev": true, "requires": { - "spdx-correct": "^3.0.0", - "spdx-expression-parse": "^3.0.0" + "spdx-correct": "3.0.0", + "spdx-expression-parse": "3.0.0" } }, "validator": { @@ -11103,9 +11103,9 @@ "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", "dev": true, "requires": { - "assert-plus": "^1.0.0", + "assert-plus": "1.0.0", "core-util-is": "1.0.2", - "extsprintf": "^1.2.0" + "extsprintf": "1.3.0" } }, "vkbeautify": { @@ -11128,7 +11128,7 @@ "integrity": "sha1-gqwr/2PZUOqeMYmlimViX+3xkEU=", "dev": true, "requires": { - "browser-process-hrtime": "^0.1.2" + "browser-process-hrtime": "0.1.2" } }, "watchpack": { @@ -11137,9 +11137,9 @@ "integrity": "sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==", "dev": true, "requires": { - "chokidar": "^2.0.2", - "graceful-fs": "^4.1.2", - "neo-async": "^2.5.0" + "chokidar": "2.0.3", + "graceful-fs": "4.1.11", + "neo-async": "2.5.1" } }, "wbuf": { @@ -11148,7 +11148,7 @@ "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==", "dev": true, "requires": { - "minimalistic-assert": "^1.0.0" + "minimalistic-assert": "1.0.1" } }, "web-resource-inliner": { @@ -11157,14 +11157,14 @@ "integrity": "sha512-fOWnBQHVX8zHvEbECDTxtYL0FXIIZZ5H3LWoez8mGopYJK7inEru1kVMDzM1lVdeJBNEqUnNP5FBGxvzuMcwwQ==", "dev": true, "requires": { - "async": "^2.1.2", - "chalk": "^1.1.3", - "datauri": "^1.0.4", - "htmlparser2": "^3.9.2", - "lodash.unescape": "^4.0.1", - "request": "^2.78.0", - "valid-data-url": "^0.1.4", - "xtend": "^4.0.0" + "async": "2.6.0", + "chalk": "1.1.3", + "datauri": "1.1.0", + "htmlparser2": "3.9.2", + "lodash.unescape": "4.0.1", + "request": "2.86.0", + "valid-data-url": "0.1.6", + "xtend": "4.0.1" }, "dependencies": { "entities": { @@ -11179,12 +11179,12 @@ "integrity": "sha1-G9+HrMoPP55T+k/M6w9LTLsAszg=", "dev": true, "requires": { - "domelementtype": "^1.3.0", - "domhandler": "^2.3.0", - "domutils": "^1.5.1", - "entities": "^1.1.1", - "inherits": "^2.0.1", - "readable-stream": "^2.0.2" + "domelementtype": "1.3.0", + "domhandler": "2.3.0", + "domutils": "1.5.1", + "entities": "1.1.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6" } } } @@ -11199,7 +11199,7 @@ "@webassemblyjs/validation": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", "@webassemblyjs/wast-parser": "1.4.3", - "long": "^3.2.0" + "long": "3.2.0" } }, "webidl-conversions": { @@ -11217,25 +11217,25 @@ "@webassemblyjs/ast": "1.4.3", "@webassemblyjs/wasm-edit": "1.4.3", "@webassemblyjs/wasm-parser": "1.4.3", - "acorn": "^5.0.0", - "acorn-dynamic-import": "^3.0.0", - "ajv": "^6.1.0", - "ajv-keywords": "^3.1.0", - "chrome-trace-event": "^0.1.1", - "enhanced-resolve": "^4.0.0", - "eslint-scope": "^3.7.1", - "loader-runner": "^2.3.0", - "loader-utils": "^1.1.0", - "memory-fs": "~0.4.1", - "micromatch": "^3.1.8", - "mkdirp": "~0.5.0", - "neo-async": "^2.5.0", - "node-libs-browser": "^2.0.0", - "schema-utils": "^0.4.4", - "tapable": "^1.0.0", - "uglifyjs-webpack-plugin": "^1.2.4", - "watchpack": "^1.5.0", - "webpack-sources": "^1.0.1" + "acorn": "5.5.3", + "acorn-dynamic-import": "3.0.0", + "ajv": "6.5.0", + "ajv-keywords": "3.2.0", + "chrome-trace-event": "0.1.3", + "enhanced-resolve": "4.0.0", + "eslint-scope": "3.7.1", + "loader-runner": "2.3.0", + "loader-utils": "1.1.0", + "memory-fs": "0.4.1", + "micromatch": "3.1.10", + "mkdirp": "0.5.1", + "neo-async": "2.5.1", + "node-libs-browser": "2.1.0", + "schema-utils": "0.4.5", + "tapable": "1.0.0", + "uglifyjs-webpack-plugin": "1.2.5", + "watchpack": "1.6.0", + "webpack-sources": "1.1.0" }, "dependencies": { "ajv": { @@ -11244,10 +11244,10 @@ "integrity": "sha512-VDUX1oSajablmiyFyED9L1DFndg0P9h7p1F+NO8FkIzei6EPrR6Zu1n18rd5P8PqaSRd/FrWv3G1TVBqpM83gA==", "dev": true, "requires": { - "fast-deep-equal": "^2.0.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.3.0", - "uri-js": "^4.2.1" + "fast-deep-equal": "2.0.1", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1", + "uri-js": "4.2.1" } }, "ajv-keywords": { @@ -11270,13 +11270,13 @@ "integrity": "sha512-I6Mmy/QjWU/kXwCSFGaiOoL5YEQIVmbb0o45xMoCyQAg/mClqZVTcsX327sPfekDyJWpCxb+04whNyLOIxpJdQ==", "dev": true, "requires": { - "loud-rejection": "^1.6.0", - "memory-fs": "~0.4.1", - "mime": "^2.1.0", - "path-is-absolute": "^1.0.0", - "range-parser": "^1.0.3", - "url-join": "^4.0.0", - "webpack-log": "^1.0.1" + "loud-rejection": "1.6.0", + "memory-fs": "0.4.1", + "mime": "2.3.1", + "path-is-absolute": "1.0.1", + "range-parser": "1.2.0", + "url-join": "4.0.0", + "webpack-log": "1.2.0" }, "dependencies": { "mime": { @@ -11300,32 +11300,32 @@ "dev": true, "requires": { "ansi-html": "0.0.7", - "array-includes": "^3.0.3", - "bonjour": "^3.5.0", - "chokidar": "^2.0.0", - "compression": "^1.5.2", - "connect-history-api-fallback": "^1.3.0", - "debug": "^3.1.0", - "del": "^3.0.0", - "express": "^4.16.2", - "html-entities": "^1.2.0", - "http-proxy-middleware": "~0.18.0", - "import-local": "^1.0.0", + "array-includes": "3.0.3", + "bonjour": "3.5.0", + "chokidar": "2.0.3", + "compression": "1.7.2", + "connect-history-api-fallback": "1.5.0", + "debug": "3.1.0", + "del": "3.0.0", + "express": "4.16.3", + "html-entities": "1.2.1", + "http-proxy-middleware": "0.18.0", + "import-local": "1.0.0", "internal-ip": "1.2.0", - "ip": "^1.1.5", - "killable": "^1.0.0", - "loglevel": "^1.4.1", - "opn": "^5.1.0", - "portfinder": "^1.0.9", - "selfsigned": "^1.9.1", - "serve-index": "^1.7.2", + "ip": "1.1.5", + "killable": "1.0.0", + "loglevel": "1.6.1", + "opn": "5.3.0", + "portfinder": "1.0.13", + "selfsigned": "1.10.3", + "serve-index": "1.9.1", "sockjs": "0.3.19", "sockjs-client": "1.1.4", - "spdy": "^3.4.1", - "strip-ansi": "^3.0.0", - "supports-color": "^5.1.0", + "spdy": "3.4.7", + "strip-ansi": "3.0.1", + "supports-color": "5.4.0", "webpack-dev-middleware": "3.1.3", - "webpack-log": "^1.1.2", + "webpack-log": "1.2.0", "yargs": "11.0.0" }, "dependencies": { @@ -11344,12 +11344,12 @@ "integrity": "sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=", "dev": true, "requires": { - "globby": "^6.1.0", - "is-path-cwd": "^1.0.0", - "is-path-in-cwd": "^1.0.0", - "p-map": "^1.1.1", - "pify": "^3.0.0", - "rimraf": "^2.2.8" + "globby": "6.1.0", + "is-path-cwd": "1.0.0", + "is-path-in-cwd": "1.0.1", + "p-map": "1.2.0", + "pify": "3.0.0", + "rimraf": "2.6.2" } }, "globby": { @@ -11358,11 +11358,11 @@ "integrity": "sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=", "dev": true, "requires": { - "array-union": "^1.0.1", - "glob": "^7.0.3", - "object-assign": "^4.0.1", - "pify": "^2.0.0", - "pinkie-promise": "^2.0.0" + "array-union": "1.0.2", + "glob": "7.1.2", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" }, "dependencies": { "pify": { @@ -11385,7 +11385,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -11396,10 +11396,10 @@ "integrity": "sha512-U9AnICnu50HXtiqiDxuli5gLB5PGBo7VvcHx36jRZHwK4vzOYLbImqT4lwWwoMHdQWwEKw736fCHEekokTEKHA==", "dev": true, "requires": { - "chalk": "^2.1.0", - "log-symbols": "^2.1.0", - "loglevelnext": "^1.0.1", - "uuid": "^3.1.0" + "chalk": "2.4.1", + "log-symbols": "2.2.0", + "loglevelnext": "1.0.5", + "uuid": "3.2.1" }, "dependencies": { "ansi-styles": { @@ -11408,7 +11408,7 @@ "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "color-convert": "1.9.1" } }, "chalk": { @@ -11417,9 +11417,9 @@ "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" } }, "has-flag": { @@ -11434,7 +11434,7 @@ "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "3.0.0" } } } @@ -11451,8 +11451,8 @@ "integrity": "sha512-aqYp18kPphgoO5c/+NaUvEeACtZjMESmDChuD3NBciVpah3XpMEU9VAAtIaB1BsfJWWTSdv8Vv1m3T0aRk2dUw==", "dev": true, "requires": { - "source-list-map": "^2.0.0", - "source-map": "~0.6.1" + "source-list-map": "2.0.0", + "source-map": "0.6.1" } }, "websocket-driver": { @@ -11461,8 +11461,8 @@ "integrity": "sha1-DK+dLXVdk67gSdS90NP+LMoqJOs=", "dev": true, "requires": { - "http-parser-js": ">=0.4.0", - "websocket-extensions": ">=0.1.1" + "http-parser-js": "0.4.12", + "websocket-extensions": "0.1.3" } }, "websocket-extensions": { @@ -11500,9 +11500,9 @@ "integrity": "sha512-FwygsxsXx27x6XXuExA/ox3Ktwcbf+OAvrKmLulotDAiO1Q6ixchPFaHYsis2zZBZSJTR0+dR+JVtf7MlbqZjw==", "dev": true, "requires": { - "lodash.sortby": "^4.7.0", - "tr46": "^1.0.1", - "webidl-conversions": "^4.0.2" + "lodash.sortby": "4.7.0", + "tr46": "1.0.1", + "webidl-conversions": "4.0.2" } }, "whet.extend": { @@ -11517,7 +11517,7 @@ "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", "dev": true, "requires": { - "isexe": "^2.0.0" + "isexe": "2.0.0" } }, "which-module": { @@ -11537,7 +11537,7 @@ "integrity": "sha512-6w+3tHbM87WnSWnENBUvA2pxJPLhQUg5LKwUQHq3r+XPhIM+Gh2R5ycbwPCyuGbNg+lPgdcnQUhuC02kJCvffQ==", "dev": true, "requires": { - "errno": "~0.1.7" + "errno": "0.1.7" } }, "worker-loader": { @@ -11546,8 +11546,8 @@ "integrity": "sha512-qJZLVS/jMCBITDzPo/RuweYSIG8VJP5P67mP/71alGyTZRe1LYJFdwLjLalY3T5ifx0bMDRD3OB6P2p1escvlg==", "dev": true, "requires": { - "loader-utils": "^1.0.0", - "schema-utils": "^0.4.0" + "loader-utils": "1.1.0", + "schema-utils": "0.4.5" } }, "wrap-ansi": { @@ -11556,8 +11556,8 @@ "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", "dev": true, "requires": { - "string-width": "^1.0.1", - "strip-ansi": "^3.0.1" + "string-width": "1.0.2", + "strip-ansi": "3.0.1" }, "dependencies": { "is-fullwidth-code-point": { @@ -11566,7 +11566,7 @@ "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", "dev": true, "requires": { - "number-is-nan": "^1.0.0" + "number-is-nan": "1.0.1" } }, "string-width": { @@ -11575,9 +11575,9 @@ "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", "dev": true, "requires": { - "code-point-at": "^1.0.0", - "is-fullwidth-code-point": "^1.0.0", - "strip-ansi": "^3.0.0" + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" } } } @@ -11594,7 +11594,7 @@ "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", "dev": true, "requires": { - "mkdirp": "^0.5.1" + "mkdirp": "0.5.1" } }, "ws": { @@ -11603,8 +11603,8 @@ "integrity": "sha512-ZGh/8kF9rrRNffkLFV4AzhvooEclrOH0xaugmqGsIfFgOE/pIz4fMc4Ef+5HSQqTEug2S9JZIWDR47duDSLfaA==", "dev": true, "requires": { - "async-limiter": "~1.0.0", - "safe-buffer": "~5.1.0" + "async-limiter": "1.0.0", + "safe-buffer": "5.1.2" } }, "xml-name-validator": { @@ -11658,18 +11658,18 @@ "integrity": "sha512-Rjp+lMYQOWtgqojx1dEWorjCofi1YN7AoFvYV7b1gx/7dAAeuI4kN5SZiEvr0ZmsZTOpDRcCqrpI10L31tFkBw==", "dev": true, "requires": { - "cliui": "^4.0.0", - "decamelize": "^1.1.1", - "find-up": "^2.1.0", - "get-caller-file": "^1.0.1", - "os-locale": "^2.0.0", - "require-directory": "^2.1.1", - "require-main-filename": "^1.0.1", - "set-blocking": "^2.0.0", - "string-width": "^2.0.0", - "which-module": "^2.0.0", - "y18n": "^3.2.1", - "yargs-parser": "^9.0.2" + "cliui": "4.1.0", + "decamelize": "1.2.0", + "find-up": "2.1.0", + "get-caller-file": "1.0.2", + "os-locale": "2.1.0", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "2.1.1", + "which-module": "2.0.0", + "y18n": "3.2.1", + "yargs-parser": "9.0.2" }, "dependencies": { "y18n": { @@ -11686,7 +11686,7 @@ "integrity": "sha1-nM9qQ0YP5O1Aqbto9I1DuKaMwHc=", "dev": true, "requires": { - "camelcase": "^4.1.0" + "camelcase": "4.1.0" }, "dependencies": { "camelcase": { @@ -11703,7 +11703,7 @@ "integrity": "sha1-lSj0QtqxsihOWLQ3m7GU4i4MQAU=", "dev": true, "requires": { - "fd-slicer": "~1.0.1" + "fd-slicer": "1.0.1" } }, "zlibjs": { diff --git a/src/core/lib/PublicKey.mjs b/src/core/lib/PublicKey.mjs index 2fabc89d..ece567a0 100644 --- a/src/core/lib/PublicKey.mjs +++ b/src/core/lib/PublicKey.mjs @@ -1,5 +1,5 @@ /** - * Public key functions. + * Public key resources. * * @author n1474335 [n1474335@gmail.com] * @copyright Crown Copyright 2016 diff --git a/src/core/operations/CSSSelector.mjs b/src/core/operations/CSSSelector.mjs index 5894066e..b91178cb 100644 --- a/src/core/operations/CSSSelector.mjs +++ b/src/core/operations/CSSSelector.mjs @@ -4,8 +4,10 @@ * @license Apache-2.0 */ -import nwmatcher from "nwmatcher"; import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; +import xmldom from "xmldom"; +import nwmatcher from "nwmatcher"; /** * CSS selector operation @@ -44,7 +46,7 @@ class CSSSelector extends Operation { */ run(input, args) { const [query, delimiter] = args, - parser = new DOMParser(); + parser = new xmldom.DOMParser(); let dom, result; @@ -55,14 +57,14 @@ class CSSSelector extends Operation { try { dom = parser.parseFromString(input); } catch (err) { - return "Invalid input HTML."; + throw new OperationError("Invalid input HTML."); } try { const matcher = nwmatcher({document: dom}); result = matcher.select(query, dom); } catch (err) { - return "Invalid CSS Selector. Details:\n" + err.message; + throw new OperationError("Invalid CSS Selector. Details:\n" + err.message); } const nodeToString = function(node) { diff --git a/src/core/operations/Diff.mjs b/src/core/operations/Diff.mjs index 90697140..8c72245c 100644 --- a/src/core/operations/Diff.mjs +++ b/src/core/operations/Diff.mjs @@ -6,7 +6,7 @@ import Operation from "../Operation"; import Utils from "../Utils"; -import JsDiff from "diff"; +import * as JsDiff from "diff"; import OperationError from "../errors/OperationError"; /** @@ -71,36 +71,39 @@ class Diff extends Operation { let output = "", diff; + // Node and Webpack load modules slightly differently + const jsdiff = JsDiff.default ? JsDiff.default : JsDiff; + if (!samples || samples.length !== 2) { throw new OperationError("Incorrect number of samples, perhaps you need to modify the sample delimiter or add more samples?"); } switch (diffBy) { case "Character": - diff = JsDiff.diffChars(samples[0], samples[1]); + diff = jsdiff.diffChars(samples[0], samples[1]); break; case "Word": if (ignoreWhitespace) { - diff = JsDiff.diffWords(samples[0], samples[1]); + diff = jsdiff.diffWords(samples[0], samples[1]); } else { - diff = JsDiff.diffWordsWithSpace(samples[0], samples[1]); + diff = jsdiff.diffWordsWithSpace(samples[0], samples[1]); } break; case "Line": if (ignoreWhitespace) { - diff = JsDiff.diffTrimmedLines(samples[0], samples[1]); + diff = jsdiff.diffTrimmedLines(samples[0], samples[1]); } else { - diff = JsDiff.diffLines(samples[0], samples[1]); + diff = jsdiff.diffLines(samples[0], samples[1]); } break; case "Sentence": - diff = JsDiff.diffSentences(samples[0], samples[1]); + diff = jsdiff.diffSentences(samples[0], samples[1]); break; case "CSS": - diff = JsDiff.diffCss(samples[0], samples[1]); + diff = jsdiff.diffCss(samples[0], samples[1]); break; case "JSON": - diff = JsDiff.diffJson(samples[0], samples[1]); + diff = jsdiff.diffJson(samples[0], samples[1]); break; default: throw new OperationError("Invalid 'Diff by' option."); diff --git a/src/core/operations/ExtractEXIF.mjs b/src/core/operations/ExtractEXIF.mjs index ae293763..533fdd63 100644 --- a/src/core/operations/ExtractEXIF.mjs +++ b/src/core/operations/ExtractEXIF.mjs @@ -21,7 +21,13 @@ class ExtractEXIF extends Operation { this.name = "Extract EXIF"; this.module = "Image"; - this.description = "Extracts EXIF data from an image.\n

\nEXIF data is metadata embedded in images (JPEG, JPG, TIFF) and audio files.\n

\nEXIF data from photos usually contains information about the image file itself as well as the device used to create it."; + this.description = [ + "Extracts EXIF data from an image.", + "

", + "EXIF data is metadata embedded in images (JPEG, JPG, TIFF) and audio files.", + "

", + "EXIF data from photos usually contains information about the image file itself as well as the device used to create it.", + ].join("\n"); this.inputType = "ArrayBuffer"; this.outputType = "string"; this.args = []; diff --git a/src/core/operations/FindReplace.mjs b/src/core/operations/FindReplace.mjs index b983e69a..5a971704 100644 --- a/src/core/operations/FindReplace.mjs +++ b/src/core/operations/FindReplace.mjs @@ -20,7 +20,7 @@ class FindReplace extends Operation { this.name = "Find / Replace"; this.module = "Regex"; - this.description = "Replaces all occurrences of the first string with the second.

Includes support for regular expressions (regex), simple strings and extended strings (which support \\n, \\r, \\t, \\b, \\f and escaped hex bytes using \\x notation, e.g. \\x00 for a null byte)."; + this.description = "Replaces all occurrences of the first string with the second.

Includes support for regular expressions (regex), simple strings and extended strings (which support \\n, \\r, \\t, \\b, \\f and escaped hex bytes using \\x notation, e.g. \\x00 for a null byte)."; this.inputType = "string"; this.outputType = "string"; this.args = [ diff --git a/src/core/operations/ParseX509Certificate.mjs b/src/core/operations/ParseX509Certificate.mjs index 99040cdf..831738f3 100644 --- a/src/core/operations/ParseX509Certificate.mjs +++ b/src/core/operations/ParseX509Certificate.mjs @@ -198,8 +198,6 @@ ${extensions}`; } -export default ParseX509Certificate; - /** * Formats dates. * @@ -214,3 +212,5 @@ function formatDate (dateStr) { dateStr[8] + dateStr[9] + ":" + dateStr[10] + dateStr[11]; } + +export default ParseX509Certificate; diff --git a/src/core/operations/RegularExpression.mjs b/src/core/operations/RegularExpression.mjs index 05f6fefb..4f8b9813 100644 --- a/src/core/operations/RegularExpression.mjs +++ b/src/core/operations/RegularExpression.mjs @@ -7,6 +7,7 @@ import XRegExp from "xregexp"; import Operation from "../Operation"; import Utils from "../Utils"; +import OperationError from "../errors/OperationError"; /** * Regular expression operation @@ -133,14 +134,12 @@ class RegularExpression extends Operation { * @returns {html} */ run(input, args) { - const userRegex = args[1], - i = args[2], - m = args[3], - s = args[4], - u = args[5], - a = args[6], - displayTotal = args[7], - outputFormat = args[8]; + const [, + userRegex, + i, m, s, u, a, + displayTotal, + outputFormat + ] = args; let modifiers = "g"; if (i) modifiers += "i"; @@ -166,7 +165,7 @@ class RegularExpression extends Operation { return "Error: Invalid output format"; } } catch (err) { - return "Invalid regex. Details: " + err.message; + throw new OperationError("Invalid regex. Details: " + err.message); } } else { return Utils.escapeHtml(input); @@ -175,8 +174,6 @@ class RegularExpression extends Operation { } -export default RegularExpression; - /** * Creates a string listing the matches within a string. * @@ -261,3 +258,5 @@ function regexHighlight (input, regex, displayTotal) { return output; } + +export default RegularExpression; diff --git a/src/core/operations/RemoveEXIF.mjs b/src/core/operations/RemoveEXIF.mjs index 0d5c9d49..f2c479b3 100644 --- a/src/core/operations/RemoveEXIF.mjs +++ b/src/core/operations/RemoveEXIF.mjs @@ -21,7 +21,11 @@ class RemoveEXIF extends Operation { this.name = "Remove EXIF"; this.module = "Image"; - this.description = "Removes EXIF data from a JPEG image.\n

\nEXIF data embedded in photos usually contains information about the image file itself as well as the device used to create it."; + this.description = [ + "Removes EXIF data from a JPEG image.", + "

", + "EXIF data embedded in photos usually contains information about the image file itself as well as the device used to create it.", + ].join("\n"); this.inputType = "byteArray"; this.outputType = "byteArray"; this.args = []; diff --git a/src/core/operations/RenderImage.mjs b/src/core/operations/RenderImage.mjs index b99fbe9b..8a8fb4a9 100644 --- a/src/core/operations/RenderImage.mjs +++ b/src/core/operations/RenderImage.mjs @@ -7,6 +7,7 @@ import { fromBase64, toBase64 } from "../lib/Base64"; import { fromHex } from "../lib/Hex"; import Operation from "../Operation"; +import OperationError from "../errors/OperationError"; import Utils from "../Utils"; import Magic from "../lib/Magic"; @@ -37,9 +38,7 @@ class RenderImage extends Operation { { "match": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", "flags": "", - "args": [ - "Raw" - ], + "args": ["Raw"], "useful": true } ]; @@ -77,7 +76,7 @@ class RenderImage extends Operation { if (type && type.mime.indexOf("image") === 0) { dataURI += type.mime + ";"; } else { - throw "Invalid file type"; + throw new OperationError("Invalid file type"); } // Add image data to URI diff --git a/src/core/operations/XPathExpression.mjs b/src/core/operations/XPathExpression.mjs index 4e83aff1..7b342004 100644 --- a/src/core/operations/XPathExpression.mjs +++ b/src/core/operations/XPathExpression.mjs @@ -4,9 +4,10 @@ * @license Apache-2.0 */ -import xpath from "xpath"; import Operation from "../Operation"; import OperationError from "../errors/OperationError"; +import xmldom from "xmldom"; +import xpath from "xpath"; /** * XPath expression operation @@ -48,7 +49,7 @@ class XPathExpression extends Operation { let doc; try { - doc = new DOMParser().parseFromString(input, "application/xml"); + doc = new xmldom.DOMParser().parseFromString(input, "application/xml"); } catch (err) { throw new OperationError("Invalid input XML."); } diff --git a/test/tests/operations/Code.mjs b/test/tests/operations/Code.mjs index 00643ed1..3b282b67 100644 --- a/test/tests/operations/Code.mjs +++ b/test/tests/operations/Code.mjs @@ -310,7 +310,6 @@ TestRegister.addTests([ } ], }, - /* Since we don't pack ops before running tests, there's no polyfill for DomParser() { name: "CSS selector", input: '
\n

hello

\n

world

\n

again

\n
', @@ -332,5 +331,5 @@ TestRegister.addTests([ "args": ["/div/p[@class=\"a\"]", "\\n"] } ] - }*/ + } ]); From 60340fc8ae0aafb31e28ee8586b23e35510cabbf Mon Sep 17 00:00:00 2001 From: n1474335 Date: Tue, 29 May 2018 01:20:44 +0100 Subject: [PATCH 23/23] ESM: Removed legacy files --- .eslintignore | 1 - src/core/config/scripts/portOperation.mjs | 4815 ----------------- src/core/operations/legacy/Arithmetic.js | 259 - src/core/operations/legacy/BCD.js | 215 - src/core/operations/legacy/BSON.js | 59 - src/core/operations/legacy/Base.js | 68 - src/core/operations/legacy/Base58.js | 137 - src/core/operations/legacy/ByteRepr.js | 355 -- src/core/operations/legacy/CharEnc.js | 97 - src/core/operations/legacy/Checksum.js | 179 - src/core/operations/legacy/Compress.js | 243 - src/core/operations/legacy/Convert.js | 413 -- src/core/operations/legacy/DateTime.js | 484 -- src/core/operations/legacy/Diff.js | 94 - src/core/operations/legacy/Endian.js | 100 - src/core/operations/legacy/Entropy.js | 195 - src/core/operations/legacy/FileType.js | 542 -- src/core/operations/legacy/Filetime.js | 103 - src/core/operations/legacy/HTML.js | 857 --- src/core/operations/legacy/HTTP.js | 158 - src/core/operations/legacy/Hash.js | 785 --- src/core/operations/legacy/Hexdump.js | 203 - src/core/operations/legacy/IP.js | 1086 ---- src/core/operations/legacy/MAC.js | 105 - src/core/operations/legacy/MS.js | 213 - src/core/operations/legacy/MorseCode.js | 190 - src/core/operations/legacy/NetBIOS.js | 70 - src/core/operations/legacy/Numberwang.js | 85 - src/core/operations/legacy/OS.js | 311 -- src/core/operations/legacy/OTP.js | 56 - src/core/operations/legacy/PHP.js | 160 - src/core/operations/legacy/PublicKey.js | 348 -- src/core/operations/legacy/Punycode.js | 58 - src/core/operations/legacy/QuotedPrintable.js | 272 - src/core/operations/legacy/Regex.js | 278 - src/core/operations/legacy/SeqUtils.js | 257 - src/core/operations/legacy/Shellcode.js | 96 - src/core/operations/legacy/StrUtils.js | 413 -- src/core/operations/legacy/Tidy.js | 250 - src/core/operations/legacy/ToTable.js | 164 - src/core/operations/legacy/UUID.js | 36 - src/core/operations/legacy/Unicode.js | 101 - src/core/operations/legacy/XKCD.js | 26 - src/web/App.js | 753 --- webpack.config.js | 4 +- 45 files changed, 2 insertions(+), 15692 deletions(-) delete mode 100644 src/core/config/scripts/portOperation.mjs delete mode 100644 src/core/operations/legacy/Arithmetic.js delete mode 100755 src/core/operations/legacy/BCD.js delete mode 100644 src/core/operations/legacy/BSON.js delete mode 100755 src/core/operations/legacy/Base.js delete mode 100755 src/core/operations/legacy/Base58.js delete mode 100755 src/core/operations/legacy/ByteRepr.js delete mode 100755 src/core/operations/legacy/CharEnc.js delete mode 100755 src/core/operations/legacy/Checksum.js delete mode 100755 src/core/operations/legacy/Compress.js delete mode 100755 src/core/operations/legacy/Convert.js delete mode 100755 src/core/operations/legacy/DateTime.js delete mode 100644 src/core/operations/legacy/Diff.js delete mode 100755 src/core/operations/legacy/Endian.js delete mode 100755 src/core/operations/legacy/Entropy.js delete mode 100755 src/core/operations/legacy/FileType.js delete mode 100644 src/core/operations/legacy/Filetime.js delete mode 100755 src/core/operations/legacy/HTML.js delete mode 100755 src/core/operations/legacy/HTTP.js delete mode 100755 src/core/operations/legacy/Hash.js delete mode 100755 src/core/operations/legacy/Hexdump.js delete mode 100755 src/core/operations/legacy/IP.js delete mode 100755 src/core/operations/legacy/MAC.js delete mode 100644 src/core/operations/legacy/MS.js delete mode 100644 src/core/operations/legacy/MorseCode.js delete mode 100644 src/core/operations/legacy/NetBIOS.js delete mode 100755 src/core/operations/legacy/Numberwang.js delete mode 100755 src/core/operations/legacy/OS.js delete mode 100755 src/core/operations/legacy/OTP.js delete mode 100644 src/core/operations/legacy/PHP.js delete mode 100755 src/core/operations/legacy/PublicKey.js delete mode 100755 src/core/operations/legacy/Punycode.js delete mode 100755 src/core/operations/legacy/QuotedPrintable.js delete mode 100644 src/core/operations/legacy/Regex.js delete mode 100755 src/core/operations/legacy/SeqUtils.js delete mode 100644 src/core/operations/legacy/Shellcode.js delete mode 100755 src/core/operations/legacy/StrUtils.js delete mode 100755 src/core/operations/legacy/Tidy.js delete mode 100644 src/core/operations/legacy/ToTable.js delete mode 100755 src/core/operations/legacy/UUID.js delete mode 100755 src/core/operations/legacy/Unicode.js delete mode 100755 src/core/operations/legacy/XKCD.js delete mode 100644 src/web/App.js diff --git a/.eslintignore b/.eslintignore index f7c44ebd..529676da 100644 --- a/.eslintignore +++ b/.eslintignore @@ -1,2 +1 @@ src/core/vendor/** -src/core/operations/legacy/** diff --git a/src/core/config/scripts/portOperation.mjs b/src/core/config/scripts/portOperation.mjs deleted file mode 100644 index cac7b1eb..00000000 --- a/src/core/config/scripts/portOperation.mjs +++ /dev/null @@ -1,4815 +0,0 @@ -/** - * Given an existing operation name, this script generates a skeleton for that op - * in the new ESM format. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - */ - -/*eslint no-console: ["off"] */ - -import process from "process"; -import fs from "fs"; -import path from "path"; -import EscapeString from "../../operations/EscapeString"; - -if (process.argv.length < 4) { - console.log("Pass an operation name and legacy filename as arguments."); - console.log("Example> node --experimental-modules src/core/config/scripts/portOperation.mjs 'XOR' 'BitwiseOp'"); - process.exit(0); -} - -const dir = path.join(process.cwd() + "/src/core/config/"); -if (!fs.existsSync(dir)) { - console.log("\nCWD: " + process.cwd()); - console.log("Error: portOperation.mjs should be run from the project root"); - console.log("Example> node --experimental-modules src/core/config/scripts/portOperation.mjs"); - process.exit(1); -} - -/** - * Main function - */ -function main() { - const opName = process.argv[2]; - const legacyFilename = path.join(dir, `../operations/legacy/${process.argv[3]}.js`); - - if (!OP_CONFIG.hasOwnProperty(opName)) { - console.log(`${opName} cannot be found.`); - process.exit(0); - } - - const op = OP_CONFIG[opName]; - const moduleName = opName.replace(/\w\S*/g, txt => { - return txt.charAt(0).toUpperCase() + txt.substr(1); - }).replace(/[\s-/]/g, ""); - let legacyFile = ""; - - - // Read legacy file - try { - legacyFile = fs.readFileSync(legacyFilename, {encoding: "utf8"}); - } catch (err) { - console.log("Unable to read legacy file."); - console.log("Example> node --experimental-modules src/core/config/scripts/portOperation.mjs 'XOR' 'BitwiseOp'"); - process.exit(0); - } - - const author = legacyFile.match(/@author [^\n]+/)[0]; - const copyright = legacyFile.match(/@copyright [^\n]+/)[0]; - const utilsUsed = /Utils/.test(legacyFile); - const esc = new EscapeString(); - const desc = esc.run(op.description, ["Special chars", "Double"]); - const patterns = op.hasOwnProperty("patterns") ? ` - this.patterns = ${JSON.stringify(op.patterns, null, 4).split("\n").join("\n ")};` : ""; - - // Attempt to find the operation run function based on the JSDoc comment - const regex = `\\* ${opName} operation[^:]+:(?: function ?\\(input, args\\))? ?{([\\s\\S]+?)\n }`; - let runFunc = "\n"; - try { - runFunc = legacyFile.match(new RegExp(regex, "im"))[1]; - } catch (err) {} - - - // List all constants in legacyFile - const constants = []; - try { - const constantsRegex = /\* @constant[^/]+\/\s+([^\n]+)/gim; - let m; - - while ((m = constantsRegex.exec(legacyFile)) !== null) { - constants.push(m[1]); - } - } catch (err) {} - - const template = `/** - * ${author} - * ${copyright} - * @license Apache-2.0 - */ - -import Operation from "../Operation"; -${utilsUsed ? 'import Utils from "../Utils";\n' : ""} -/** - * ${opName} operation - */ -class ${moduleName} extends Operation { - - /** - * ${moduleName} constructor - */ - constructor() { - super(); - - this.name = "${opName}";${op.flowControl ? "\n this.flowControl = true;" : ""} - this.module = "${op.module}"; - this.description = "${desc}"; - this.inputType = "${op.inputType}"; - this.outputType = "${op.outputType}";${op.manualBake ? "\n this.manualBake = true;" : ""} - this.args = ${JSON.stringify(op.args, null, 4).split("\n").join("\n ")};${patterns} - } - - /** - * @param {${op.inputType}} input - * @param {Object[]} args - * @returns {${op.outputType}} - */ - run(input, args) {${runFunc} - } -${op.highlight ? ` - /** - * Highlight ${opName} - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlight(pos, args) { - return pos; - } -` : ""}${op.highlightReverse ? ` - /** - * Highlight ${opName} in reverse - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlightReverse(pos, args) { - return pos; - } -` : ""} -} - -export default ${moduleName}; -`; - - console.log("\nLegacy operation config\n-----------------------\n"); - console.log(JSON.stringify(op, null, 4)); - console.log("\n-----------------------\n"); - console.log("\nPotentially related constants\n-----------------------\n"); - console.log(constants.join("\n")); - console.log("\n-----------------------\n"); - - const filename = path.join(dir, `../operations/${moduleName}.mjs`); - if (fs.existsSync(filename)) { - console.log(`\x1b[31m\u274c ${filename} already exists. It has NOT been overwritten.\x1b[0m`); - process.exit(0); - } - fs.writeFileSync(filename, template); - - console.log("\x1b[32m\u2714\x1b[0m Operation written to \x1b[32m" + filename + "\x1b[0m"); - if (runFunc === "\n") { - console.log("\x1b[31m\u274c The run function could not be located automatically.\x1b[0m You will have to copy it accross manually."); - } else { - console.log("\x1b[32m\u2714\x1b[0m The run function was copied across. Double check that it was copied correctly. It may rely on other functions which have not been copied."); - } - console.log(`\nOpen \x1b[32m${legacyFilename}\x1b[0m and copy any relevant code over. Make sure you check imports, args and highlights. Code required by multiple operations should be stored in /src/core/lib/.\n\nDont't forget to run \x1b[36mgrunt lint\x1b[0m!`); -} - - -const OP_CONFIG = { - "Magic": { - module: "Default", - description: "The Magic operation attempts to detect various properties of the input data and suggests which operations could help to make more sense of it.

Options
Depth: If an operation appears to match the data, it will be run and the result will be analysed further. This argument controls the maximum number of levels of recursion.

Intensive mode: When this is turned on, various operations like XOR, bit rotates, and character encodings are brute-forced to attempt to detect valid data underneath. To improve performance, only the first 100 bytes of the data is brute-forced.

Extensive language support: At each stage, the relative byte frequencies of the data will be compared to average frequencies for a number of languages. The default set consists of ~40 of the most commonly used languages on the Internet. The extensive list consists of 284 languages and can result in many languages matching the data if their byte frequencies are similar.", - inputType: "ArrayBuffer", - outputType: "html", - flowControl: true, - args: [ - { - name: "Depth", - type: "number", - value: 3 - }, - { - name: "Intensive mode", - type: "boolean", - value: false - }, - { - name: "Extensive language support", - type: "boolean", - value: false - } - ] - }, - "Fork": { - module: "Default", - description: "Split the input data up based on the specified delimiter and run all subsequent operations on each branch separately.

For example, to decode multiple Base64 strings, enter them all on separate lines then add the 'Fork' and 'From Base64' operations to the recipe. Each string will be decoded separately.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "Split delimiter", - type: "binaryShortString", - value: "\\n" - }, - { - name: "Merge delimiter", - type: "binaryShortString", - value: "\\n" - }, - { - name: "Ignore errors", - type: "boolean", - value: false - } - ] - }, - "Merge": { - module: "Default", - description: "Consolidate all branches back into a single trunk. The opposite of Fork.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [] - }, - "Register": { - module: "Default", - description: "Extract data from the input and store it in registers which can then be passed into subsequent operations as arguments. Regular expression capture groups are used to select the data to extract.

To use registers in arguments, refer to them using the notation $Rn where n is the register number, starting at 0.

For example:
Input: Test
Extractor: (.*)
Argument: $R0 becomes Test

Registers can be escaped in arguments using a backslash. e.g. \\$R0 would become $R0 rather than Test.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "Extractor", - type: "binaryString", - value: "([\\s\\S]*)" - }, - { - name: "Case insensitive", - type: "boolean", - value: true - }, - { - name: "Multiline matching", - type: "boolean", - value: false - }, - ] - }, - "Jump": { - module: "Default", - description: "Jump forwards or backwards to the specified Label", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "Label name", - type: "string", - value: "" - }, - { - name: "Maximum jumps (if jumping backwards)", - type: "number", - value: 10 - } - ] - }, - "Conditional Jump": { - module: "Default", - description: "Conditionally jump forwards or backwards to the specified Label based on whether the data matches the specified regular expression.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "Match (regex)", - type: "string", - value: "" - }, - { - name: "Invert match", - type: "boolean", - value: false - }, - { - name: "Label name", - type: "shortString", - value: "" - }, - { - name: "Maximum jumps (if jumping backwards)", - type: "number", - value: 10 - } - ] - }, - "Label": { - module: "Default", - description: "Provides a location for conditional and fixed jumps to redirect execution to.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "Name", - type: "shortString", - value: "" - } - ] - }, - "Return": { - module: "Default", - description: "End execution of operations at this point in the recipe.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [] - }, - "Comment": { - module: "Default", - description: "Provides a place to write comments within the flow of the recipe. This operation has no computational effect.", - inputType: "string", - outputType: "string", - flowControl: true, - args: [ - { - name: "", - type: "text", - value: "" - } - ] - }, - "From Base64": { - module: "Default", - description: "Base64 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

This operation decodes data from an ASCII Base64 string back into its raw format.

e.g. aGVsbG8= becomes hello", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Alphabet", - type: "editableOption", - value: "Base64.ALPHABET_OPTIONS" - }, - { - name: "Remove non-alphabet chars", - type: "boolean", - value: "Base64.REMOVE_NON_ALPH_CHARS" - } - ], - patterns: [ - { - match: "^(?:[A-Z\\d+/]{4})+(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$", - flags: "i", - args: ["A-Za-z0-9+/=", false] - }, - { - match: "^[A-Z\\d\\-_]{20,}$", - flags: "i", - args: ["A-Za-z0-9-_", false] - }, - { - match: "^(?:[A-Z\\d+\\-]{4}){5,}(?:[A-Z\\d+\\-]{2}==|[A-Z\\d+\\-]{3}=)?$", - flags: "i", - args: ["A-Za-z0-9+\\-=", false] - }, - { - match: "^(?:[A-Z\\d./]{4}){5,}(?:[A-Z\\d./]{2}==|[A-Z\\d./]{3}=)?$", - flags: "i", - args: ["./0-9A-Za-z=", false] - }, - { - match: "^[A-Z\\d_.]{20,}$", - flags: "i", - args: ["A-Za-z0-9_.", false] - }, - { - match: "^(?:[A-Z\\d._]{4}){5,}(?:[A-Z\\d._]{2}--|[A-Z\\d._]{3}-)?$", - flags: "i", - args: ["A-Za-z0-9._-", false] - }, - { - match: "^(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$", - flags: "i", - args: ["0-9a-zA-Z+/=", false] - }, - { - match: "^(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?$", - flags: "i", - args: ["0-9A-Za-z+/=", false] - }, - { - match: "^[ !\"#$%&'()*+,\\-./\\d:;<=>?@A-Z[\\\\\\]^_]{20,}$", - flags: "", - args: [" -_", false] - }, - { - match: "^[A-Z\\d+\\-]{20,}$", - flags: "i", - args: ["+\\-0-9A-Za-z", false] - }, - { - match: "^[!\"#$%&'()*+,\\-0-689@A-NP-VX-Z[`a-fh-mp-r]{20,}$", - flags: "", - args: ["!-,-0-689@A-NP-VX-Z[`a-fh-mp-r", false] - }, - { - match: "^(?:[N-ZA-M\\d+/]{4}){5,}(?:[N-ZA-M\\d+/]{2}==|[N-ZA-M\\d+/]{3}=)?$", - flags: "i", - args: ["N-ZA-Mn-za-m0-9+/=", false] - }, - { - match: "^[A-Z\\d./]{20,}$", - flags: "i", - args: ["./0-9A-Za-z", false] - }, - ] - }, - "To Base64": { - module: "Default", - description: "Base64 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

This operation encodes data in an ASCII Base64 string.

e.g. hello becomes aGVsbG8=", - highlight: "func", - highlightReverse: "func", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Alphabet", - type: "editableOption", - value: "Base64.ALPHABET_OPTIONS" - }, - ] - }, - "From Base58": { - module: "Default", - description: "Base58 (similar to Base64) is a notation for encoding arbitrary byte data. It differs from Base64 by removing easily misread characters (i.e. l, I, 0 and O) to improve human readability.

This operation decodes data from an ASCII string (with an alphabet of your choosing, presets included) back into its raw form.

e.g. StV1DL6CwTryKyV becomes hello world

Base58 is commonly used in cryptocurrencies (Bitcoin, Ripple, etc).", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Alphabet", - type: "editableOption", - value: "Base58.ALPHABET_OPTIONS" - }, - { - name: "Remove non-alphabet chars", - type: "boolean", - value: "Base58.REMOVE_NON_ALPH_CHARS" - } - ], - patterns: [ - { - match: "^[1-9A-HJ-NP-Za-km-z]{20,}$", - flags: "", - args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", false] - }, - { - match: "^[1-9A-HJ-NP-Za-km-z]{20,}$", - flags: "", - args: ["rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz", false] - }, - ] - }, - "To Base58": { - module: "Default", - description: "Base58 (similar to Base64) is a notation for encoding arbitrary byte data. It differs from Base64 by removing easily misread characters (i.e. l, I, 0 and O) to improve human readability.

This operation encodes data in an ASCII string (with an alphabet of your choosing, presets included).

e.g. hello world becomes StV1DL6CwTryKyV

Base58 is commonly used in cryptocurrencies (Bitcoin, Ripple, etc).", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Alphabet", - type: "editableOption", - value: "Base58.ALPHABET_OPTIONS" - }, - ] - }, - "From Base32": { - module: "Default", - description: "Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. It uses a smaller set of characters than Base64, usually the uppercase alphabet and the numbers 2 to 7.", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Alphabet", - type: "binaryString", - value: "Base64.BASE32_ALPHABET" - }, - { - name: "Remove non-alphabet chars", - type: "boolean", - value: "Base64.REMOVE_NON_ALPH_CHARS" - } - ], - patterns: [ - { - match: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$", - flags: "", - args: ["A-Z2-7=", false] - }, - ] - }, - "To Base32": { - module: "Default", - description: "Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. It uses a smaller set of characters than Base64, usually the uppercase alphabet and the numbers 2 to 7.", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Alphabet", - type: "binaryString", - value: "Base64.BASE32_ALPHABET" - } - ] - }, - "Show Base64 offsets": { - module: "Default", - description: "When a string is within a block of data and the whole block is Base64'd, the string itself could be represented in Base64 in three distinct ways depending on its offset within the block.

This operation shows all possible offsets for a given string so that each possible encoding can be considered.", - inputType: "byteArray", - outputType: "html", - args: [ - { - name: "Alphabet", - type: "binaryString", - value: "Base64.ALPHABET" - }, - { - name: "Show variable chars and padding", - type: "boolean", - value: "Base64.OFFSETS_SHOW_VARIABLE" - } - ] - }, - "Disassemble x86": { - module: "Shellcode", - description: "Disassembly is the process of translating machine language into assembly language.

This operation supports 64-bit, 32-bit and 16-bit code written for Intel or AMD x86 processors. It is particularly useful for reverse engineering shellcode.

Input should be in hexadecimal.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Bit mode", - type: "option", - value: "Shellcode.MODE" - }, - { - name: "Compatibility", - type: "option", - value: "Shellcode.COMPATIBILITY" - }, - { - name: "Code Segment (CS)", - type: "number", - value: 16 - }, - { - name: "Offset (IP)", - type: "number", - value: 0 - }, - { - name: "Show instruction hex", - type: "boolean", - value: true - }, - { - name: "Show instruction position", - type: "boolean", - value: true - } - ] - }, - "XOR": { - module: "Default", - description: "XOR the input with the given key.
e.g. fe023da5

Options
Null preserving: If the current byte is 0x00 or the same as the key, skip it.

Scheme:
  • Standard - key is unchanged after each round
  • Input differential - key is set to the value of the previous unprocessed byte
  • Output differential - key is set to the value of the previous processed byte
", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "BitwiseOp.KEY_FORMAT" - }, - { - name: "Scheme", - type: "option", - value: "BitwiseOp.XOR_SCHEME" - }, - { - name: "Null preserving", - type: "boolean", - value: "BitwiseOp.XOR_PRESERVE_NULLS" - } - ] - }, - "XOR Brute Force": { - module: "Default", - description: "Enumerate all possible XOR solutions. Current maximum key length is 2 due to browser performance.

Optionally enter a string that you expect to find in the plaintext to filter results (crib).", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Key length", - type: "number", - value: "BitwiseOp.XOR_BRUTE_KEY_LENGTH" - }, - { - name: "Sample length", - type: "number", - value: "BitwiseOp.XOR_BRUTE_SAMPLE_LENGTH" - }, - { - name: "Sample offset", - type: "number", - value: "BitwiseOp.XOR_BRUTE_SAMPLE_OFFSET" - }, - { - name: "Scheme", - type: "option", - value: "BitwiseOp.XOR_SCHEME" - }, - { - name: "Null preserving", - type: "boolean", - value: "BitwiseOp.XOR_PRESERVE_NULLS" - }, - { - name: "Print key", - type: "boolean", - value: "BitwiseOp.XOR_BRUTE_PRINT_KEY" - }, - { - name: "Output as hex", - type: "boolean", - value: "BitwiseOp.XOR_BRUTE_OUTPUT_HEX" - }, - { - name: "Crib (known plaintext string)", - type: "binaryString", - value: "" - } - ] - }, - "NOT": { - module: "Default", - description: "Returns the inverse of each byte.", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [] - }, - "AND": { - module: "Default", - description: "AND the input with the given key.
e.g. fe023da5", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "BitwiseOp.KEY_FORMAT" - } - ] - }, - "OR": { - module: "Default", - description: "OR the input with the given key.
e.g. fe023da5", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "BitwiseOp.KEY_FORMAT" - } - ] - }, - "ADD": { - module: "Default", - description: "ADD the input with the given key (e.g. fe023da5), MOD 255", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "BitwiseOp.KEY_FORMAT" - } - ] - }, - "SUB": { - module: "Default", - description: "SUB the input with the given key (e.g. fe023da5), MOD 255", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "BitwiseOp.KEY_FORMAT" - } - ] - }, - "Sum": { - module: "Default", - description: "Adds together a list of numbers. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 becomes 18.5", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Subtract": { - module: "Default", - description: "Subtracts a list of numbers. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 becomes 1.5", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Multiply": { - module: "Default", - description: "Multiplies a list of numbers. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 becomes 40", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Divide": { - module: "Default", - description: "Divides a list of numbers. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 becomes 2.5", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Mean": { - module: "Default", - description: "Computes the mean (average) of a number list. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 .5 becomes 4.75", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Median": { - module: "Default", - description: "Computes the median of a number list. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 1 .5 becomes 4.5", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "Standard Deviation": { - module: "Default", - description: "Computes the standard deviation of a number list. If an item in the string is not a number it is excluded from the list.

e.g. 0x0a 8 .5 becomes 4.089281382128433", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Delimiter", - type: "option", - value: "Arithmetic.DELIM_OPTIONS" - } - ] - }, - "To Table": { - module: "Default", - description: "Data can be split on different characters and rendered as an HTML or ASCII table with an optional header row.

Supports the CSV (Comma Separated Values) file format by default. Change the cell delimiter argument to \\t to support TSV (Tab Separated Values) or | for PSV (Pipe Separated Values).

You can enter as many delimiters as you like. Each character will be treat as a separate possible delimiter.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Cell delimiters", - type: "binaryShortString", - value: "," - }, - { - name: "Row delimiters", - type: "binaryShortString", - value: "\\n\\r" - }, - { - name: "Make first row header", - type: "boolean", - value: false - }, - { - name: "Format", - type: "option", - value: "ToTable.FORMATS" - } - ] - }, - "From Hex": { - module: "Default", - description: "Converts a hexadecimal byte string back into its raw value.

e.g. ce 93 ce b5 ce b9 ce ac 20 cf 83 ce bf cf 85 0a becomes the UTF-8 encoded string Γειά σου", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.HEX_DELIM_OPTIONS" - } - ], - patterns: [ - { - match: "^(?:[\\dA-F]{2})+$", - flags: "i", - args: ["None"] - }, - { - match: "^[\\dA-F]{2}(?: [\\dA-F]{2})*$", - flags: "i", - args: ["Space"] - }, - { - match: "^[\\dA-F]{2}(?:,[\\dA-F]{2})*$", - flags: "i", - args: ["Comma"] - }, - { - match: "^[\\dA-F]{2}(?:;[\\dA-F]{2})*$", - flags: "i", - args: ["Semi-colon"] - }, - { - match: "^[\\dA-F]{2}(?::[\\dA-F]{2})*$", - flags: "i", - args: ["Colon"] - }, - { - match: "^[\\dA-F]{2}(?:\\n[\\dA-F]{2})*$", - flags: "i", - args: ["Line feed"] - }, - { - match: "^[\\dA-F]{2}(?:\\r\\n[\\dA-F]{2})*$", - flags: "i", - args: ["CRLF"] - }, - { - match: "^[\\dA-F]{2}(?:0x[\\dA-F]{2})*$", - flags: "i", - args: ["0x"] - }, - { - match: "^[\\dA-F]{2}(?:\\\\x[\\dA-F]{2})*$", - flags: "i", - args: ["\\x"] - } - ] - }, - "To Hex": { - module: "Default", - description: "Converts the input string to hexadecimal bytes separated by the specified delimiter.

e.g. The UTF-8 encoded string Γειά σου becomes ce 93 ce b5 ce b9 ce ac 20 cf 83 ce bf cf 85 0a", - highlight: "func", - highlightReverse: "func", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.HEX_DELIM_OPTIONS" - } - ] - }, - "From Octal": { - module: "Default", - description: "Converts an octal byte string back into its raw value.

e.g. 316 223 316 265 316 271 316 254 40 317 203 316 277 317 205 becomes the UTF-8 encoded string Γειά σου", - highlight: false, - highlightReverse: false, - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - } - ], - patterns: [ - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?: (?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["Space"] - }, - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:,(?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["Comma"] - }, - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:;(?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["Semi-colon"] - }, - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?::(?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["Colon"] - }, - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["Line feed"] - }, - { - match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\r\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$", - flags: "", - args: ["CRLF"] - }, - ] - }, - "To Octal": { - module: "Default", - description: "Converts the input string to octal bytes separated by the specified delimiter.

e.g. The UTF-8 encoded string Γειά σου becomes 316 223 316 265 316 271 316 254 40 317 203 316 277 317 205", - highlight: false, - highlightReverse: false, - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - } - ] - }, - "From Charcode": { - module: "Default", - description: "Converts unicode character codes back into text.

e.g. 0393 03b5 03b9 03ac 20 03c3 03bf 03c5 becomes Γειά σου", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - }, - { - name: "Base", - type: "number", - value: "ByteRepr.CHARCODE_BASE" - } - ] - }, - "To Charcode": { - module: "Default", - description: "Converts text to its unicode character code equivalent.

e.g. Γειά σου becomes 0393 03b5 03b9 03ac 20 03c3 03bf 03c5", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - }, - { - name: "Base", - type: "number", - value: "ByteRepr.CHARCODE_BASE" - } - ] - }, - "From Binary": { - module: "Default", - description: "Converts a binary string back into its raw form.

e.g. 01001000 01101001 becomes Hi", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.BIN_DELIM_OPTIONS" - } - ], - patterns: [ - { - match: "^(?:[01]{8})+$", - flags: "", - args: ["None"] - }, - { - match: "^(?:[01]{8})(?: [01]{8})*$", - flags: "", - args: ["Space"] - }, - { - match: "^(?:[01]{8})(?:,[01]{8})*$", - flags: "", - args: ["Comma"] - }, - { - match: "^(?:[01]{8})(?:;[01]{8})*$", - flags: "", - args: ["Semi-colon"] - }, - { - match: "^(?:[01]{8})(?::[01]{8})*$", - flags: "", - args: ["Colon"] - }, - { - match: "^(?:[01]{8})(?:\\n[01]{8})*$", - flags: "", - args: ["Line feed"] - }, - { - match: "^(?:[01]{8})(?:\\r\\n[01]{8})*$", - flags: "", - args: ["CRLF"] - }, - ] - }, - "To Binary": { - module: "Default", - description: "Displays the input data as a binary string.

e.g. Hi becomes 01001000 01101001", - highlight: "func", - highlightReverse: "func", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.BIN_DELIM_OPTIONS" - } - ] - }, - "From Decimal": { - module: "Default", - description: "Converts the data from an ordinal integer array back into its raw form.

e.g. 72 101 108 108 111 becomes Hello", - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - } - ], - patterns: [ - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?: (?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["Space"] - }, - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:,(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["Comma"] - }, - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:;(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["Semi-colon"] - }, - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?::(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["Colon"] - }, - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["Line feed"] - }, - { - match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\r\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$", - flags: "", - args: ["CRLF"] - }, - ] - }, - "To Decimal": { - module: "Default", - description: "Converts the input data to an ordinal integer array.

e.g. Hello becomes 72 101 108 108 111", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "ByteRepr.DELIM_OPTIONS" - } - ] - }, - "From Hexdump": { - module: "Default", - description: "Attempts to convert a hexdump back into raw data. This operation supports many different hexdump variations, but probably not all. Make sure you verify that the data it gives you is correct before continuing analysis.", - highlight: "func", - highlightReverse: "func", - inputType: "string", - outputType: "byteArray", - args: [], - patterns: [ - { - match: "^(?:(?:[\\dA-F]{4,16}:?)?\\s*((?:[\\dA-F]{2}\\s){1,8}(?:\\s|[\\dA-F]{2}-)(?:[\\dA-F]{2}\\s){1,8}|(?:[\\dA-F]{2}\\s|[\\dA-F]{4}\\s)+)[^\\n]*\\n?)+$", - flags: "i", - args: [] - }, - ] - }, - "To Hexdump": { - module: "Default", - description: "Creates a hexdump of the input data, displaying both the hexadecimal values of each byte and an ASCII representation alongside.", - highlight: "func", - highlightReverse: "func", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Width", - type: "number", - value: "Hexdump.WIDTH" - }, - { - name: "Upper case hex", - type: "boolean", - value: "Hexdump.UPPER_CASE" - }, - { - name: "Include final length", - type: "boolean", - value: "Hexdump.INCLUDE_FINAL_LENGTH" - } - ] - }, - "From Base": { - module: "Default", - description: "Converts a number to decimal from a given numerical base.", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Radix", - type: "number", - value: "Base.DEFAULT_RADIX" - } - ] - }, - "To Base": { - module: "Default", - description: "Converts a decimal number to a given numerical base.", - inputType: "BigNumber", - outputType: "string", - args: [ - { - name: "Radix", - type: "number", - value: "Base.DEFAULT_RADIX" - } - ] - }, - "From HTML Entity": { - module: "Default", - description: "Converts HTML entities back to characters

e.g. &amp; becomes &", // tags required to stop the browser just printing & - inputType: "string", - outputType: "string", - args: [], - patterns: [ - { - match: "&(?:#\\d{2,3}|#x[\\da-f]{2}|[a-z]{2,6});", - flags: "i", - args: [] - }, - ] - }, - "To HTML Entity": { - module: "Default", - description: "Converts characters to HTML entities

e.g. & becomes &amp;", // tags required to stop the browser just printing & - inputType: "string", - outputType: "string", - args: [ - { - name: "Convert all characters", - type: "boolean", - value: "HTML.CONVERT_ALL" - }, - { - name: "Convert to", - type: "option", - value: "HTML.CONVERT_OPTIONS" - } - ] - }, - "Strip HTML tags": { - module: "Default", - description: "Removes all HTML tags from the input.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Remove indentation", - type: "boolean", - value: "HTML.REMOVE_INDENTATION" - }, - { - name: "Remove excess line breaks", - type: "boolean", - value: "HTML.REMOVE_LINE_BREAKS" - } - ] - }, - "URL Decode": { - module: "URL", - description: "Converts URI/URL percent-encoded characters back to their raw values.

e.g. %3d becomes =", - inputType: "string", - outputType: "string", - args: [], - patterns: [ - { - match: ".*(?:%[\\da-f]{2}.*){4}", - flags: "i", - args: [] - }, - ] - }, - "URL Encode": { - module: "URL", - description: "Encodes problematic characters into percent-encoding, a format supported by URIs/URLs.

e.g. = becomes %3d", - inputType: "string", - outputType: "string", - args: [ - { - name: "Encode all special chars", - type: "boolean", - value: "URL_.ENCODE_ALL" - } - ] - }, - "Parse URI": { - module: "URL", - description: "Pretty prints complicated Uniform Resource Identifier (URI) strings for ease of reading. Particularly useful for Uniform Resource Locators (URLs) with a lot of arguments.", - inputType: "string", - outputType: "string", - args: [] - }, - "Unescape Unicode Characters": { - module: "Default", - description: "Converts unicode-escaped character notation back into raw characters.

Supports the prefixes:
  • \\u
  • %u
  • U+
e.g. \\u03c3\\u03bf\\u03c5 becomes σου", - inputType: "string", - outputType: "string", - args: [ - { - name: "Prefix", - type: "option", - value: "Unicode.PREFIXES" - } - ] - }, - "Escape Unicode Characters": { - module: "Default", - description: "Converts characters to their unicode-escaped notations.

Supports the prefixes:
  • \\u
  • %u
  • U+
e.g. σου becomes \\u03C3\\u03BF\\u03C5", - inputType: "string", - outputType: "string", - args: [ - { - name: "Prefix", - type: "option", - value: "Unicode.PREFIXES" - }, - { - name: "Encode all chars", - type: "boolean", - value: false - }, - { - name: "Padding", - type: "number", - value: 4 - }, - { - name: "Uppercase hex", - type: "boolean", - value: true - } - ], - patterns: [ - { - match: "\\\\u(?:[\\da-f]{4,6})", - flags: "i", - args: ["\\u"] - }, - { - match: "%u(?:[\\da-f]{4,6})", - flags: "i", - args: ["%u"] - }, - { - match: "U\\+(?:[\\da-f]{4,6})", - flags: "i", - args: ["U+"] - }, - ] - }, - "From Quoted Printable": { - module: "Default", - description: "Converts QP-encoded text back to standard text.", - inputType: "string", - outputType: "byteArray", - args: [], - patterns: [ - { - match: "^[\\x21-\\x3d\\x3f-\\x7e \\t]*(?:=[\\da-f]{2}|=\\r?\\n)(?:[\\x21-\\x3d\\x3f-\\x7e \\t]|=[\\da-f]{2}|=\\r?\\n)*$", - flags: "i", - args: [] - }, - ] - }, - "To Quoted Printable": { - module: "Default", - description: "Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in e-mail.

QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "From Punycode": { - module: "Encodings", - description: "Punycode is a way to represent Unicode with the limited character subset of ASCII supported by the Domain Name System.

e.g. mnchen-3ya decodes to münchen", - inputType: "string", - outputType: "string", - args: [ - { - name: "Internationalised domain name", - type: "boolean", - value: "Punycode.IDN" - } - ] - }, - "To Punycode": { - module: "Encodings", - description: "Punycode is a way to represent Unicode with the limited character subset of ASCII supported by the Domain Name System.

e.g. münchen encodes to mnchen-3ya", - inputType: "string", - outputType: "string", - args: [ - { - name: "Internationalised domain name", - type: "boolean", - value: "Punycode.IDN" - } - ] - }, - "From Hex Content": { - module: "Default", - description: "Translates hexadecimal bytes in text back to raw bytes.

e.g. foo|3d|bar becomes foo=bar.", - inputType: "string", - outputType: "byteArray", - args: [] - }, - "To Hex Content": { - module: "Default", - description: "Converts special characters in a string to hexadecimal.

e.g. foo=bar becomes foo|3d|bar.", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Convert", - type: "option", - value: "ByteRepr.HEX_CONTENT_CONVERT_WHICH" - }, - { - name: "Print spaces between bytes", - type: "boolean", - value: "ByteRepr.HEX_CONTENT_SPACES_BETWEEN_BYTES" - }, - ] - }, - "Change IP format": { - module: "JSBN", - description: "Convert an IP address from one format to another, e.g. 172.20.23.54 to ac141736", - inputType: "string", - outputType: "string", - args: [ - { - name: "Input format", - type: "option", - value: "IP.IP_FORMAT_LIST" - }, - { - name: "Output format", - type: "option", - value: "IP.IP_FORMAT_LIST" - } - ] - }, - "Parse IP range": { - module: "JSBN", - description: "Given a CIDR range (e.g. 10.0.0.0/24) or a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0), this operation provides network information and enumerates all IP addresses in the range.

IPv6 is supported but will not be enumerated.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Include network info", - type: "boolean", - value: "IP.INCLUDE_NETWORK_INFO" - }, - { - name: "Enumerate IP addresses", - type: "boolean", - value: "IP.ENUMERATE_ADDRESSES" - }, - { - name: "Allow large queries", - type: "boolean", - value: "IP.ALLOW_LARGE_LIST" - } - ] - }, - "Group IP addresses": { - module: "JSBN", - description: "Groups a list of IP addresses into subnets. Supports both IPv4 and IPv6 addresses.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "IP.DELIM_OPTIONS" - }, - { - name: "Subnet (CIDR)", - type: "number", - value: "IP.GROUP_CIDR" - }, - { - name: "Only show the subnets", - type: "boolean", - value: "IP.GROUP_ONLY_SUBNET" - } - ] - }, - "Parse IPv6 address": { - module: "JSBN", - description: "Displays the longhand and shorthand versions of a valid IPv6 address.

Recognises all reserved ranges and parses encapsulated or tunnelled addresses including Teredo and 6to4.", - inputType: "string", - outputType: "string", - args: [] - }, - "Parse IPv4 header": { - module: "JSBN", - description: "Given an IPv4 header, this operations parses and displays each field in an easily readable format.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Input format", - type: "option", - value: "IP.IP_HEADER_FORMAT" - } - ] - }, - "Encode text": { - module: "CharEnc", - description: [ - "Encodes text into the chosen character encoding.", - "

", - "Supported charsets are:", - "
    ", - 'TODO -----------------------Object.keys(CharEnc.IO_FORMAT).map(e => `
  • ${e}
    • `).join("\n")', - "
", - ].join("\n"), - inputType: "string", - outputType: "byteArray", - args: [ - { - name: "Encoding", - type: "option", - value: "Object.keys(CharEnc.IO_FORMAT)," - }, - ], - }, - "Decode text": { - module: "CharEnc", - description: [ - "Decodes text from the chosen character encoding.", - "

", - "Supported charsets are:", - "
    ", - 'TODO -----------------------Object.keys(CharEnc.IO_FORMAT).map(e => `
  • ${e}
    • `).join("\n")', - "
", - ].join("\n"), - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Encoding", - type: "option", - value: "Object.keys(CharEnc.IO_FORMAT)," - }, - ] - }, - "AES Decrypt": { - module: "Ciphers", - description: "Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.

Key: The following algorithms will be used based on the size of the key:
  • 16 bytes = AES-128
  • 24 bytes = AES-192
  • 32 bytes = AES-256


IV: The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.

GCM Tag: This field is ignored unless 'GCM' mode is used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.AES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "GCM Tag", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - ] - }, - "AES Encrypt": { - module: "Ciphers", - description: "Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.

Key: The following algorithms will be used based on the size of the key:
  • 16 bytes = AES-128
  • 24 bytes = AES-192
  • 32 bytes = AES-256
You can generate a password-based key using one of the KDF operations.

IV: The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.AES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - ] - }, - "DES Decrypt": { - module: "Ciphers", - description: "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.

Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.DES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - ] - }, - "DES Encrypt": { - module: "Ciphers", - description: "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.

Key: DES uses a key length of 8 bytes (64 bits).
Triple DES uses a key length of 24 bytes (192 bits).

You can generate a password-based key using one of the KDF operations.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.DES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - ] - }, - "Triple DES Decrypt": { - module: "Ciphers", - description: "Triple DES applies DES three times to each block to increase key size.

Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.DES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - ] - }, - "Triple DES Encrypt": { - module: "Ciphers", - description: "Triple DES applies DES three times to each block to increase key size.

Key: Triple DES uses a key length of 24 bytes (192 bits).
DES uses a key length of 8 bytes (64 bits).

You can generate a password-based key using one of the KDF operations.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.

Padding: In CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.DES_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - ] - }, - "Blowfish Decrypt": { - module: "Ciphers", - description: "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.BLOWFISH_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.BLOWFISH_OUTPUT_TYPES" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - ] - }, - "Blowfish Encrypt": { - module: "Ciphers", - description: "Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.

IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Mode", - type: "option", - value: "Cipher.BLOWFISH_MODES" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "Output", - type: "option", - value: "Cipher.BLOWFISH_OUTPUT_TYPES" - }, - ] - }, - "RC4": { - module: "Ciphers", - description: "RC4 (also known as ARC4) is a widely-used stream cipher designed by Ron Rivest. It is used in popular protocols such as SSL and WEP. Although remarkable for its simplicity and speed, the algorithm's history doesn't inspire confidence in its security.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Passphrase", - type: "toggleString", - value: "", - toggleValues: "Cipher.RC4_KEY_FORMAT" - }, - { - name: "Input format", - type: "option", - value: "Cipher.CJS_IO_FORMAT" - }, - { - name: "Output format", - type: "option", - value: "Cipher.CJS_IO_FORMAT" - }, - ] - }, - "RC4 Drop": { - module: "Ciphers", - description: "It was discovered that the first few bytes of the RC4 keystream are strongly non-random and leak information about the key. We can defend against this attack by discarding the initial portion of the keystream. This modified algorithm is traditionally called RC4-drop.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Passphrase", - type: "toggleString", - value: "", - toggleValues: "Cipher.RC4_KEY_FORMAT" - }, - { - name: "Input format", - type: "option", - value: "Cipher.CJS_IO_FORMAT" - }, - { - name: "Output format", - type: "option", - value: "Cipher.CJS_IO_FORMAT" - }, - { - name: "Number of bytes to drop", - type: "number", - value: "Cipher.RC4DROP_BYTES" - }, - ] - }, - "RC2 Decrypt": { - module: "Ciphers", - description: "RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. 'RC' stands for 'Rivest Cipher'.

Key: RC2 uses a variable size key.

IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.

Padding: In both CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - ] - }, - "RC2 Encrypt": { - module: "Ciphers", - description: "RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. 'RC' stands for 'Rivest Cipher'.

Key: RC2 uses a variable size key.

You can generate a password-based key using one of the KDF operations.

IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.

Padding: In both CBC and ECB mode, PKCS#7 padding will be used.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "IV", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - { - name: "Input", - type: "option", - value: "Cipher.IO_FORMAT3" - }, - { - name: "Output", - type: "option", - value: "Cipher.IO_FORMAT4" - }, - ] - }, - "Pseudo-Random Number Generator": { - module: "Ciphers", - description: "A cryptographically-secure pseudo-random number generator (PRNG).

This operation uses the browser's built-in crypto.getRandomValues() method if available. If this cannot be found, it falls back to a Fortuna-based PRNG algorithm.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Number of bytes", - type: "number", - value: "Cipher.PRNG_BYTES" - }, - { - name: "Output as", - type: "option", - value: "Cipher.PRNG_OUTPUT" - } - ] - }, - "Derive PBKDF2 key": { - module: "Ciphers", - description: "PBKDF2 is a password-based key derivation function. It is part of RSA Laboratories' Public-Key Cryptography Standards (PKCS) series, specifically PKCS #5 v2.0, also published as Internet Engineering Task Force's RFC 2898.

In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.

A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.

If you leave the salt argument empty, a random salt will be generated.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Passphrase", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT2" - }, - { - name: "Key size", - type: "number", - value: "Cipher.KDF_KEY_SIZE" - }, - { - name: "Iterations", - type: "number", - value: "Cipher.KDF_ITERATIONS" - }, - { - name: "Hashing function", - type: "option", - value: "Cipher.HASHERS" - }, - { - name: "Salt", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - ] - }, - "Derive EVP key": { - module: "Ciphers", - description: "EVP is a password-based key derivation function (PBKDF) used extensively in OpenSSL. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can't be used directly as a cryptographic key, some processing is required.

A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.

If you leave the salt argument empty, a random salt will be generated.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Passphrase", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT2" - }, - { - name: "Key size", - type: "number", - value: "Cipher.KDF_KEY_SIZE" - }, - { - name: "Iterations", - type: "number", - value: "Cipher.KDF_ITERATIONS" - }, - { - name: "Hashing function", - type: "option", - value: "Cipher.HASHERS" - }, - { - name: "Salt", - type: "toggleString", - value: "", - toggleValues: "Cipher.IO_FORMAT1" - }, - ] - }, - "Vigenère Encode": { - module: "Ciphers", - description: "The Vigenere cipher is a method of encrypting alphabetic text by using a series of different Caesar ciphers based on the letters of a keyword. It is a simple form of polyalphabetic substitution.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "string", - value: "" - } - ] - }, - "Vigenère Decode": { - module: "Ciphers", - description: "The Vigenere cipher is a method of encrypting alphabetic text by using a series of different Caesar ciphers based on the letters of a keyword. It is a simple form of polyalphabetic substitution.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Key", - type: "string", - value: "" - } - ] - }, - "Bifid Cipher Encode": { - module: "Ciphers", - description: "The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Keyword", - type: "string", - value: "" - } - ] - }, - "Bifid Cipher Decode": { - module: "Ciphers", - description: "The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Keyword", - type: "string", - value: "" - } - ] - }, - "Affine Cipher Encode": { - module: "Ciphers", - description: "The Affine cipher is a type of monoalphabetic substitution cipher, wherein each letter in an alphabet is mapped to its numeric equivalent, encrypted using simple mathematical function, (ax + b) % 26, and converted back to a letter.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "a", - type: "number", - value: "Cipher.AFFINE_A" - }, - { - name: "b", - type: "number", - value: "Cipher.AFFINE_B" - } - ] - }, - "Affine Cipher Decode": { - module: "Ciphers", - description: "The Affine cipher is a type of monoalphabetic substitution cipher. To decrypt, each letter in an alphabet is mapped to its numeric equivalent, decrypted by a mathematical function, and converted back to a letter.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "a", - type: "number", - value: "Cipher.AFFINE_A" - }, - { - name: "b", - type: "number", - value: "Cipher.AFFINE_B" - } - ] - }, - "Atbash Cipher": { - module: "Ciphers", - description: "Atbash is a mono-alphabetic substitution cipher originally used to encode the Hebrew alphabet. It has been modified here for use with the Latin alphabet.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [] - }, - "Rotate right": { - module: "Default", - description: "Rotates each byte to the right by the number of bits specified, optionally carrying the excess bits over to the next byte. Currently only supports 8-bit values.", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Amount", - type: "number", - value: "Rotate.ROTATE_AMOUNT" - }, - { - name: "Carry through", - type: "boolean", - value: "Rotate.ROTATE_CARRY" - } - ] - }, - "Rotate left": { - module: "Default", - description: "Rotates each byte to the left by the number of bits specified, optionally carrying the excess bits over to the next byte. Currently only supports 8-bit values.", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Amount", - type: "number", - value: "Rotate.ROTATE_AMOUNT" - }, - { - name: "Carry through", - type: "boolean", - value: "Rotate.ROTATE_CARRY" - } - ] - }, - "ROT13": { - module: "Default", - description: "A simple caesar substitution cipher which rotates alphabet characters by the specified amount (default 13).", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Rotate lower case chars", - type: "boolean", - value: "Rotate.ROT13_LOWERCASE" - }, - { - name: "Rotate upper case chars", - type: "boolean", - value: "Rotate.ROT13_UPPERCASE" - }, - { - name: "Amount", - type: "number", - value: "Rotate.ROT13_AMOUNT" - }, - ] - }, - "ROT47": { - module: "Default", - description: "A slightly more complex variation of a caesar cipher, which includes ASCII characters from 33 '!' to 126 '~'. Default rotation: 47.", - highlight: true, - highlightReverse: true, - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Amount", - type: "number", - value: "Rotate.ROT47_AMOUNT" - }, - ] - }, - "Strip HTTP headers": { - module: "HTTP", - description: "Removes HTTP headers from a request or response by looking for the first instance of a double newline.", - inputType: "string", - outputType: "string", - args: [] - }, - "Parse User Agent": { - module: "HTTP", - description: "Attempts to identify and categorise information contained in a user-agent string.", - inputType: "string", - outputType: "string", - args: [] - }, - "Format MAC addresses": { - module: "Default", - description: "Displays given MAC addresses in multiple different formats.

Expects addresses in a list separated by newlines, spaces or commas.

WARNING: There are no validity checks.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Output case", - type: "option", - value: "MAC.OUTPUT_CASE" - }, - { - name: "No delimiter", - type: "boolean", - value: "MAC.NO_DELIM" - }, - { - name: "Dash delimiter", - type: "boolean", - value: "MAC.DASH_DELIM" - }, - { - name: "Colon delimiter", - type: "boolean", - value: "MAC.COLON_DELIM" - }, - { - name: "Cisco style", - type: "boolean", - value: "MAC.CISCO_STYLE" - }, - { - name: "IPv6 interface ID", - type: "boolean", - value: "MAC.IPV6_INTERFACE_ID" - } - ] - }, - "Encode NetBIOS Name": { - module: "Default", - description: "NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.

There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.

This operation carries out the first level of encoding. See RFC 1001 for full details.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Offset", - type: "number", - value: "NetBIOS.OFFSET" - } - ] - }, - "Decode NetBIOS Name": { - module: "Default", - description: "NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.

There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.

This operation decodes the first level of encoding. See RFC 1001 for full details.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Offset", - type: "number", - value: "NetBIOS.OFFSET" - } - ] - }, - "Offset checker": { - module: "Default", - description: "Compares multiple inputs (separated by the specified delimiter) and highlights matching characters which appear at the same position in all samples.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Sample delimiter", - type: "binaryString", - value: "StrUtils.OFF_CHK_SAMPLE_DELIMITER" - } - ] - }, - "Remove whitespace": { - module: "Default", - description: "Optionally removes all spaces, carriage returns, line feeds, tabs and form feeds from the input data.

This operation also supports the removal of full stops which are sometimes used to represent non-printable bytes in ASCII output.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Spaces", - type: "boolean", - value: "Tidy.REMOVE_SPACES" - }, - { - name: "Carriage returns (\\r)", - type: "boolean", - value: "Tidy.REMOVE_CARIAGE_RETURNS" - }, - { - name: "Line feeds (\\n)", - type: "boolean", - value: "Tidy.REMOVE_LINE_FEEDS" - }, - { - name: "Tabs", - type: "boolean", - value: "Tidy.REMOVE_TABS" - }, - { - name: "Form feeds (\\f)", - type: "boolean", - value: "Tidy.REMOVE_FORM_FEEDS" - }, - { - name: "Full stops", - type: "boolean", - value: "Tidy.REMOVE_FULL_STOPS" - } - ] - }, - "Remove null bytes": { - module: "Default", - description: "Removes all null bytes (0x00) from the input.", - inputType: "byteArray", - outputType: "byteArray", - args: [] - }, - "Drop bytes": { - module: "Default", - description: "Cuts a slice of the specified number of bytes out of the data.", - inputType: "ArrayBuffer", - outputType: "ArrayBuffer", - args: [ - { - name: "Start", - type: "number", - value: "Tidy.DROP_START" - }, - { - name: "Length", - type: "number", - value: "Tidy.DROP_LENGTH" - }, - { - name: "Apply to each line", - type: "boolean", - value: "Tidy.APPLY_TO_EACH_LINE" - } - ] - }, - "Take bytes": { - module: "Default", - description: "Takes a slice of the specified number of bytes from the data.", - inputType: "ArrayBuffer", - outputType: "ArrayBuffer", - args: [ - { - name: "Start", - type: "number", - value: "Tidy.TAKE_START" - }, - { - name: "Length", - type: "number", - value: "Tidy.TAKE_LENGTH" - }, - { - name: "Apply to each line", - type: "boolean", - value: "Tidy.APPLY_TO_EACH_LINE" - } - ] - }, - "Pad lines": { - module: "Default", - description: "Add the specified number of the specified character to the beginning or end of each line", - inputType: "string", - outputType: "string", - args: [ - { - name: "Position", - type: "option", - value: "Tidy.PAD_POSITION" - }, - { - name: "Length", - type: "number", - value: "Tidy.PAD_LENGTH" - }, - { - name: "Character", - type: "binaryShortString", - value: "Tidy.PAD_CHAR" - } - ] - }, - "Reverse": { - module: "Default", - description: "Reverses the input string.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "By", - type: "option", - value: "SeqUtils.REVERSE_BY" - } - ] - }, - "Sort": { - module: "Default", - description: "Alphabetically sorts strings separated by the specified delimiter.

The IP address option supports IPv4 only.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "SeqUtils.DELIMITER_OPTIONS" - }, - { - name: "Reverse", - type: "boolean", - value: "SeqUtils.SORT_REVERSE" - }, - { - name: "Order", - type: "option", - value: "SeqUtils.SORT_ORDER" - } - ] - }, - "Unique": { - module: "Default", - description: "Removes duplicate strings from the input.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "SeqUtils.DELIMITER_OPTIONS" - } - ] - }, - "Count occurrences": { - module: "Default", - description: "Counts the number of times the provided string occurs in the input.", - inputType: "string", - outputType: "number", - args: [ - { - name: "Search string", - type: "toggleString", - value: "", - toggleValues: "SeqUtils.SEARCH_TYPE" - } - ] - }, - "Add line numbers": { - module: "Default", - description: "Adds line numbers to the output.", - inputType: "string", - outputType: "string", - args: [] - }, - "Remove line numbers": { - module: "Default", - description: "Removes line numbers from the output if they can be trivially detected.", - inputType: "string", - outputType: "string", - args: [] - }, - "Find / Replace": { - module: "Regex", - description: "Replaces all occurrences of the first string with the second.

Includes support for regular expressions (regex), simple strings and extended strings (which support \\n, \\r, \\t, \\b, \\f and escaped hex bytes using \\x notation, e.g. \\x00 for a null byte).", - inputType: "string", - outputType: "string", - args: [ - { - name: "Find", - type: "toggleString", - value: "", - toggleValues: "Regex.SEARCH_TYPE" - }, - { - name: "Replace", - type: "binaryString", - value: "" - }, - { - name: "Global match", - type: "boolean", - value: "Regex.FIND_REPLACE_GLOBAL," - }, - { - name: "Case insensitive", - type: "boolean", - value: "Regex.FIND_REPLACE_CASE," - }, - { - name: "Multiline matching", - type: "boolean", - value: "Regex.FIND_REPLACE_MULTILINE," - }, - - ] - }, - "To Upper case": { - module: "Default", - description: "Converts the input string to upper case, optionally limiting scope to only the first character in each word, sentence or paragraph.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Scope", - type: "option", - value: "StrUtils.CASE_SCOPE" - } - ] - }, - "To Lower case": { - module: "Default", - description: "Converts every character in the input to lower case.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [] - }, - "Split": { - module: "Default", - description: "Splits a string into sections around a given delimiter.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Split delimiter", - type: "editableOption", - value: "StrUtils.SPLIT_DELIM_OPTIONS" - }, - { - name: "Join delimiter", - type: "editableOption", - value: "StrUtils.JOIN_DELIM_OPTIONS" - } - ] - }, - "Filter": { - module: "Default", - description: "Splits up the input using the specified delimiter and then filters each branch based on a regular expression.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "StrUtils.DELIMITER_OPTIONS" - }, - { - name: "Regex", - type: "string", - value: "" - }, - { - name: "Invert condition", - type: "boolean", - value: false - }, - ] - }, - "Strings": { - module: "Regex", - description: "Extracts all strings from the input.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Encoding", - type: "option", - value: "Extract.ENCODING_LIST" - }, - { - name: "Minimum length", - type: "number", - value: "Extract.MIN_STRING_LEN" - }, - { - name: "Match", - type: "option", - value: "Extract.STRING_MATCH_TYPE" - }, - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract IP addresses": { - module: "Regex", - description: "Extracts all IPv4 and IPv6 addresses.

Warning: Given a string 710.65.0.456, this will match 10.65.0.45 so always check the original input!", - inputType: "string", - outputType: "string", - args: [ - { - name: "IPv4", - type: "boolean", - value: "Extract.INCLUDE_IPV4" - }, - { - name: "IPv6", - type: "boolean", - value: "Extract.INCLUDE_IPV6" - }, - { - name: "Remove local IPv4 addresses", - type: "boolean", - value: "Extract.REMOVE_LOCAL" - }, - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract email addresses": { - module: "Regex", - description: "Extracts all email addresses from the input.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract MAC addresses": { - module: "Regex", - description: "Extracts all Media Access Control (MAC) addresses from the input.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract URLs": { - module: "Regex", - description: "Extracts Uniform Resource Locators (URLs) from the input. The protocol (http, ftp etc.) is required otherwise there will be far too many false positives.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract domains": { - module: "Regex", - description: "Extracts domain names.
Note that this will not include paths. Use Extract URLs to find entire URLs.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract file paths": { - module: "Regex", - description: "Extracts anything that looks like a Windows or UNIX file path.

Note that if UNIX is selected, there will likely be a lot of false positives.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Windows", - type: "boolean", - value: "Extract.INCLUDE_WIN_PATH" - }, - { - name: "UNIX", - type: "boolean", - value: "Extract.INCLUDE_UNIX_PATH" - }, - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Extract dates": { - module: "Regex", - description: "Extracts dates in the following formats
  • yyyy-mm-dd
  • dd/mm/yyyy
  • mm/dd/yyyy
Dividers can be any of /, -, . or space", - inputType: "string", - outputType: "string", - args: [ - { - name: "Display total", - type: "boolean", - value: "Extract.DISPLAY_TOTAL" - } - ] - }, - "Regular expression": { - module: "Regex", - description: "Define your own regular expression (regex) to search the input data with, optionally choosing from a list of pre-defined patterns.

Supports extended regex syntax including the 'dot matches all' flag, named capture groups, full unicode coverage (including \\p{} categories and scripts as well as astral codes) and recursive matching.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Built in regexes", - type: "populateOption", - value: "Regex.REGEX_PRE_POPULATE", - target: 1, - }, - { - name: "Regex", - type: "text", - value: "" - }, - { - name: "Case insensitive", - type: "boolean", - value: true - }, - { - name: "^ and $ match at newlines", - type: "boolean", - value: true - }, - { - name: "Dot matches all", - type: "boolean", - value: false - }, - { - name: "Unicode support", - type: "boolean", - value: false - }, - { - name: "Astral support", - type: "boolean", - value: false - }, - { - name: "Display total", - type: "boolean", - value: "Regex.DISPLAY_TOTAL" - }, - { - name: "Output format", - type: "option", - value: "Regex.OUTPUT_FORMAT" - }, - ] - }, - "XPath expression": { - module: "Code", - description: "Extract information from an XML document with an XPath query", - inputType: "string", - outputType: "string", - args: [ - { - name: "XPath", - type: "string", - value: "Code.XPATH_INITIAL" - }, - { - name: "Result delimiter", - type: "binaryShortString", - value: "Code.XPATH_DELIMITER" - } - ] - }, - "JPath expression": { - module: "Code", - description: "Extract information from a JSON object with a JPath query.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Query", - type: "string", - value: "Code.JPATH_INITIAL" - }, - { - name: "Result delimiter", - type: "binaryShortString", - value: "Code.JPATH_DELIMITER" - } - ] - }, - "CSS selector": { - module: "Code", - description: "Extract information from an HTML document with a CSS selector", - inputType: "string", - outputType: "string", - args: [ - { - name: "CSS selector", - type: "string", - value: "Code.CSS_SELECTOR_INITIAL" - }, - { - name: "Delimiter", - type: "binaryShortString", - value: "Code.CSS_QUERY_DELIMITER" - }, - ] - }, - "From UNIX Timestamp": { - module: "Default", - description: "Converts a UNIX timestamp to a datetime string.

e.g. 978346800 becomes Mon 1 January 2001 11:00:00 UTC

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).", - inputType: "number", - outputType: "string", - args: [ - { - name: "Units", - type: "option", - value: "DateTime.UNITS" - } - ], - patterns: [ - { - match: "^1?\\d{9}$", - flags: "", - args: ["Seconds (s)"] - }, - { - match: "^1?\\d{12}$", - flags: "", - args: ["Milliseconds (ms)"] - }, - { - match: "^1?\\d{15}$", - flags: "", - args: ["Microseconds (μs)"] - }, - { - match: "^1?\\d{18}$", - flags: "", - args: ["Nanoseconds (ns)"] - }, - ] - }, - "To UNIX Timestamp": { - module: "Default", - description: "Parses a datetime string in UTC and returns the corresponding UNIX timestamp.

e.g. Mon 1 January 2001 11:00:00 becomes 978346800

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).", - inputType: "string", - outputType: "string", - args: [ - { - name: "Units", - type: "option", - value: "DateTime.UNITS" - }, - { - name: "Treat as UTC", - type: "boolean", - value: "DateTime.TREAT_AS_UTC" - }, - { - name: "Show parsed datetime", - type: "boolean", - value: true - } - ] - }, - "Sleep": { - module: "Default", - description: "Sleep causes the recipe to wait for a specified number of milliseconds before continuing execution.", - inputType: "ArrayBuffer", - outputType: "ArrayBuffer", - args: [ - { - name: "Time (ms)", - type: "number", - value: 1000 - } - ] - }, - "Windows Filetime to UNIX Timestamp": { - module: "Default", - description: "Converts a Windows Filetime value to a UNIX timestamp.

A Windows Filetime is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 UTC.

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).

This operation also supports UNIX timestamps in milliseconds, microseconds and nanoseconds.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Output units", - type: "option", - value: "Filetime.UNITS" - }, - { - name: "Input format", - type: "option", - value: "Filetime.FILETIME_FORMATS" - } - ] - }, - "UNIX Timestamp to Windows Filetime": { - module: "Default", - description: "Converts a UNIX timestamp to a Windows Filetime value.

A Windows Filetime is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 UTC.

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).

This operation also supports UNIX timestamps in milliseconds, microseconds and nanoseconds.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Input units", - type: "option", - value: "Filetime.UNITS" - }, - { - name: "Output format", - type: "option", - value: "Filetime.FILETIME_FORMATS" - } - ] - }, - "Translate DateTime Format": { - module: "Default", - description: "Parses a datetime string in one format and re-writes it in another.

Run with no input to see the relevant format string examples.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Built in formats", - type: "populateOption", - value: "DateTime.DATETIME_FORMATS", - target: 1 - }, - { - name: "Input format string", - type: "binaryString", - value: "DateTime.INPUT_FORMAT_STRING" - }, - { - name: "Input timezone", - type: "option", - value: "DateTime.TIMEZONES" - }, - { - name: "Output format string", - type: "binaryString", - value: "DateTime.OUTPUT_FORMAT_STRING" - }, - { - name: "Output timezone", - type: "option", - value: "DateTime.TIMEZONES" - } - ] - }, - "Parse DateTime": { - module: "Default", - description: "Parses a DateTime string in your specified format and displays it in whichever timezone you choose with the following information:
  • Date
  • Time
  • Period (AM/PM)
  • Timezone
  • UTC offset
  • Daylight Saving Time
  • Leap year
  • Days in this month
  • Day of year
  • Week number
  • Quarter
Run with no input to see format string examples if required.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Built in formats", - type: "populateOption", - value: "DateTime.DATETIME_FORMATS", - target: 1 - }, - { - name: "Input format string", - type: "binaryString", - value: "DateTime.INPUT_FORMAT_STRING" - }, - { - name: "Input timezone", - type: "option", - value: "DateTime.TIMEZONES" - }, - ] - }, - "Convert distance": { - module: "Default", - description: "Converts a unit of distance to another format.", - inputType: "BigNumber", - outputType: "BigNumber", - args: [ - { - name: "Input units", - type: "option", - value: "Convert.DISTANCE_UNITS" - }, - { - name: "Output units", - type: "option", - value: "Convert.DISTANCE_UNITS" - } - ] - }, - "Convert area": { - module: "Default", - description: "Converts a unit of area to another format.", - inputType: "BigNumber", - outputType: "BigNumber", - args: [ - { - name: "Input units", - type: "option", - value: "Convert.AREA_UNITS" - }, - { - name: "Output units", - type: "option", - value: "Convert.AREA_UNITS" - } - ] - }, - "Convert mass": { - module: "Default", - description: "Converts a unit of mass to another format.", - inputType: "BigNumber", - outputType: "BigNumber", - args: [ - { - name: "Input units", - type: "option", - value: "Convert.MASS_UNITS" - }, - { - name: "Output units", - type: "option", - value: "Convert.MASS_UNITS" - } - ] - }, - "Convert speed": { - module: "Default", - description: "Converts a unit of speed to another format.", - inputType: "BigNumber", - outputType: "BigNumber", - args: [ - { - name: "Input units", - type: "option", - value: "Convert.SPEED_UNITS" - }, - { - name: "Output units", - type: "option", - value: "Convert.SPEED_UNITS" - } - ] - }, - "Convert data units": { - module: "Default", - description: "Converts a unit of data to another format.", - inputType: "BigNumber", - outputType: "BigNumber", - args: [ - { - name: "Input units", - type: "option", - value: "Convert.DATA_UNITS" - }, - { - name: "Output units", - type: "option", - value: "Convert.DATA_UNITS" - } - ] - }, - "Raw Deflate": { - module: "Compression", - description: "Compresses data using the deflate algorithm with no headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Compression type", - type: "option", - value: "Compress.COMPRESSION_TYPE" - } - ] - }, - "Raw Inflate": { - module: "Compression", - description: "Decompresses data which has been compressed using the deflate algorithm with no headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Start index", - type: "number", - value: "Compress.INFLATE_INDEX" - }, - { - name: "Initial output buffer size", - type: "number", - value: "Compress.INFLATE_BUFFER_SIZE" - }, - { - name: "Buffer expansion type", - type: "option", - value: "Compress.INFLATE_BUFFER_TYPE" - }, - { - name: "Resize buffer after decompression", - type: "boolean", - value: "Compress.INFLATE_RESIZE" - }, - { - name: "Verify result", - type: "boolean", - value: "Compress.INFLATE_VERIFY" - } - ] - }, - "Zlib Deflate": { - module: "Compression", - description: "Compresses data using the deflate algorithm adding zlib headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Compression type", - type: "option", - value: "Compress.COMPRESSION_TYPE" - } - ] - }, - "Zlib Inflate": { - module: "Compression", - description: "Decompresses data which has been compressed using the deflate algorithm with zlib headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Start index", - type: "number", - value: "Compress.INFLATE_INDEX" - }, - { - name: "Initial output buffer size", - type: "number", - value: "Compress.INFLATE_BUFFER_SIZE" - }, - { - name: "Buffer expansion type", - type: "option", - value: "Compress.INFLATE_BUFFER_TYPE" - }, - { - name: "Resize buffer after decompression", - type: "boolean", - value: "Compress.INFLATE_RESIZE" - }, - { - name: "Verify result", - type: "boolean", - value: "Compress.INFLATE_VERIFY" - } - ], - patterns: [ - { - match: "^\\x78(\\x01|\\x9c|\\xda|\\x5e)", - flags: "", - args: [0, 0, "Adaptive", false, false] - }, - ] - }, - "Gzip": { - module: "Compression", - description: "Compresses data using the deflate algorithm with gzip headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Compression type", - type: "option", - value: "Compress.COMPRESSION_TYPE" - }, - { - name: "Filename (optional)", - type: "string", - value: "" - }, - { - name: "Comment (optional)", - type: "string", - value: "" - }, - { - name: "Include file checksum", - type: "boolean", - value: "Compress.GZIP_CHECKSUM" - } - ] - }, - "Gunzip": { - module: "Compression", - description: "Decompresses data which has been compressed using the deflate algorithm with gzip headers.", - inputType: "byteArray", - outputType: "byteArray", - args: [], - patterns: [ - { - match: "^\\x1f\\x8b\\x08", - flags: "", - args: [] - }, - ] - }, - "Zip": { - module: "Compression", - description: "Compresses data using the PKZIP algorithm with the given filename.

No support for multiple files at this time.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Filename", - type: "string", - value: "Compress.PKZIP_FILENAME" - }, - { - name: "Comment", - type: "string", - value: "" - }, - { - name: "Password", - type: "binaryString", - value: "" - }, - { - name: "Compression method", - type: "option", - value: "Compress.COMPRESSION_METHOD" - }, - { - name: "Operating system", - type: "option", - value: "Compress.OS" - }, - { - name: "Compression type", - type: "option", - value: "Compress.COMPRESSION_TYPE" - } - ] - }, - "Unzip": { - module: "Compression", - description: "Decompresses data using the PKZIP algorithm and displays it per file, with support for passwords.", - inputType: "byteArray", - outputType: "html", - args: [ - { - name: "Password", - type: "binaryString", - value: "" - }, - { - name: "Verify result", - type: "boolean", - value: "Compress.PKUNZIP_VERIFY" - } - ], - patterns: [ - { - match: "^\\x50\\x4b(?:\\x03|\\x05|\\x07)(?:\\x04|\\x06|\\x08)", - flags: "", - args: ["", false] - }, - ] - }, - "Bzip2 Decompress": { - module: "Compression", - description: "Decompresses data using the Bzip2 algorithm.", - inputType: "byteArray", - outputType: "string", - args: [], - patterns: [ - { - match: "^\\x42\\x5a\\x68", - flags: "", - args: [] - }, - ] - }, - "Generic Code Beautify": { - module: "Code", - description: "Attempts to pretty print C-style languages such as C, C++, C#, Java, PHP, JavaScript etc.

This will not do a perfect job, and the resulting code may not work any more. This operation is designed purely to make obfuscated or minified code more easy to read and understand.

Things which will not work properly:
  • For loop formatting
  • Do-While loop formatting
  • Switch/Case indentation
  • Certain bit shift operators
", - inputType: "string", - outputType: "string", - args: [] - }, - "JavaScript Parser": { - module: "Code", - description: "Returns an Abstract Syntax Tree for valid JavaScript code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Location info", - type: "boolean", - value: "JS.PARSE_LOC" - }, - { - name: "Range info", - type: "boolean", - value: "JS.PARSE_RANGE" - }, - { - name: "Include tokens array", - type: "boolean", - value: "JS.PARSE_TOKENS" - }, - { - name: "Include comments array", - type: "boolean", - value: "JS.PARSE_COMMENT" - }, - { - name: "Report errors and try to continue", - type: "boolean", - value: "JS.PARSE_TOLERANT" - }, - ] - }, - "JavaScript Beautify": { - module: "Code", - description: "Parses and pretty prints valid JavaScript code. Also works with JavaScript Object Notation (JSON).", - inputType: "string", - outputType: "string", - args: [ - { - name: "Indent string", - type: "binaryShortString", - value: "JS.BEAUTIFY_INDENT" - }, - { - name: "Quotes", - type: "option", - value: "JS.BEAUTIFY_QUOTES" - }, - { - name: "Semicolons before closing braces", - type: "boolean", - value: "JS.BEAUTIFY_SEMICOLONS" - }, - { - name: "Include comments", - type: "boolean", - value: "JS.BEAUTIFY_COMMENT" - }, - ] - }, - "JavaScript Minify": { - module: "Code", - description: "Compresses JavaScript code.", - inputType: "string", - outputType: "string", - args: [] - }, - "XML Beautify": { - module: "Code", - description: "Indents and prettifies eXtensible Markup Language (XML) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Indent string", - type: "binaryShortString", - value: "Code.BEAUTIFY_INDENT" - } - ] - }, - "JSON Beautify": { - module: "Code", - description: "Indents and prettifies JavaScript Object Notation (JSON) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Indent string", - type: "binaryShortString", - value: "Code.BEAUTIFY_INDENT" - } - ] - }, - "CSS Beautify": { - module: "Code", - description: "Indents and prettifies Cascading Style Sheets (CSS) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Indent string", - type: "binaryShortString", - value: "Code.BEAUTIFY_INDENT" - } - ] - }, - "SQL Beautify": { - module: "Code", - description: "Indents and prettifies Structured Query Language (SQL) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Indent string", - type: "binaryShortString", - value: "Code.BEAUTIFY_INDENT" - } - ] - }, - "XML Minify": { - module: "Code", - description: "Compresses eXtensible Markup Language (XML) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Preserve comments", - type: "boolean", - value: "Code.PRESERVE_COMMENTS" - } - ] - }, - "JSON Minify": { - module: "Code", - description: "Compresses JavaScript Object Notation (JSON) code.", - inputType: "string", - outputType: "string", - args: [] - }, - "CSS Minify": { - module: "Code", - description: "Compresses Cascading Style Sheets (CSS) code.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Preserve comments", - type: "boolean", - value: "Code.PRESERVE_COMMENTS" - } - ] - }, - "SQL Minify": { - module: "Code", - description: "Compresses Structured Query Language (SQL) code.", - inputType: "string", - outputType: "string", - args: [] - }, - "Analyse hash": { - module: "Hashing", - description: "Tries to determine information about a given hash and suggests which algorithm may have been used to generate it based on its length.", - inputType: "string", - outputType: "string", - args: [] - }, - "MD2": { - module: "Hashing", - description: "The MD2 (Message-Digest 2) algorithm is a cryptographic hash function developed by Ronald Rivest in 1989. The algorithm is optimized for 8-bit computers.

Although MD2 is no longer considered secure, even as of 2014, it remains in use in public key infrastructures as part of certificates generated with MD2 and RSA.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "MD4": { - module: "Hashing", - description: "The MD4 (Message-Digest 4) algorithm is a cryptographic hash function developed by Ronald Rivest in 1990. The digest length is 128 bits. The algorithm has influenced later designs, such as the MD5, SHA-1 and RIPEMD algorithms.

The security of MD4 has been severely compromised.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "MD5": { - module: "Hashing", - description: "MD5 (Message-Digest 5) is a widely used hash function. It has been used in a variety of security applications and is also commonly used to check the integrity of files.

However, MD5 is not collision resistant and it isn't suitable for applications like SSL/TLS certificates or digital signatures that rely on this property.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "MD6": { - module: "Hashing", - description: "The MD6 (Message-Digest 6) algorithm is a cryptographic hash function. It uses a Merkle tree-like structure to allow for immense parallel computation of hashes for very long inputs.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Size", - type: "number", - value: "Hash.MD6_SIZE" - }, - { - name: "Levels", - type: "number", - value: "Hash.MD6_LEVELS" - }, - { - name: "Key", - type: "string", - value: "" - } - ] - }, - "SHA0": { - module: "Hashing", - description: "SHA-0 is a retronym applied to the original version of the 160-bit hash function published in 1993 under the name 'SHA'. It was withdrawn shortly after publication due to an undisclosed 'significant flaw' and replaced by the slightly revised version SHA-1.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "SHA1": { - module: "Hashing", - description: "The SHA (Secure Hash Algorithm) hash functions were designed by the NSA. SHA-1 is the most established of the existing SHA hash functions and it is used in a variety of security applications and protocols.

However, SHA-1's collision resistance has been weakening as new attacks are discovered or improved.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "SHA2": { - module: "Hashing", - description: "The SHA-2 (Secure Hash Algorithm 2) hash functions were designed by the NSA. SHA-2 includes significant changes from its predecessor, SHA-1. The SHA-2 family consists of hash functions with digests (hash values) that are 224, 256, 384 or 512 bits: SHA224, SHA256, SHA384, SHA512.

  • SHA-512 operates on 64-bit words.
  • SHA-256 operates on 32-bit words.
  • SHA-384 is largely identical to SHA-512 but is truncated to 384 bytes.
  • SHA-224 is largely identical to SHA-256 but is truncated to 224 bytes.
  • SHA-512/224 and SHA-512/256 are truncated versions of SHA-512, but the initial values are generated using the method described in Federal Information Processing Standards (FIPS) PUB 180-4.
", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Size", - type: "option", - value: "Hash.SHA2_SIZE" - } - ] - }, - "SHA3": { - module: "Hashing", - description: "The SHA-3 (Secure Hash Algorithm 3) hash functions were released by NIST on August 5, 2015. Although part of the same series of standards, SHA-3 is internally quite different from the MD5-like structure of SHA-1 and SHA-2.

SHA-3 is a subset of the broader cryptographic primitive family Keccak designed by Guido Bertoni, Joan Daemen, Michaël Peeters, and Gilles Van Assche, building upon RadioGatún.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Size", - type: "option", - value: "Hash.SHA3_SIZE" - } - ] - }, - "Keccak": { - module: "Hashing", - description: "The Keccak hash algorithm was designed by Guido Bertoni, Joan Daemen, Michaël Peeters, and Gilles Van Assche, building upon RadioGatún. It was selected as the winner of the SHA-3 design competition.

This version of the algorithm is Keccak[c=2d] and differs from the SHA-3 specification.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Size", - type: "option", - value: "Hash.KECCAK_SIZE" - } - ] - }, - "Shake": { - module: "Hashing", - description: "Shake is an Extendable Output Function (XOF) of the SHA-3 hash algorithm, part of the Keccak family, allowing for variable output length/size.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Capacity", - type: "option", - value: "Hash.SHAKE_CAPACITY" - }, - { - name: "Size", - type: "number", - value: "Hash.SHAKE_SIZE" - } - ] - - }, - "RIPEMD": { - module: "Hashing", - description: "RIPEMD (RACE Integrity Primitives Evaluation Message Digest) is a family of cryptographic hash functions developed in Leuven, Belgium, by Hans Dobbertin, Antoon Bosselaers and Bart Preneel at the COSIC research group at the Katholieke Universiteit Leuven, and first published in 1996.

RIPEMD was based upon the design principles used in MD4, and is similar in performance to the more popular SHA-1.

", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Size", - type: "option", - value: "Hash.RIPEMD_SIZE" - } - ] - }, - "HAS-160": { - module: "Hashing", - description: "HAS-160 is a cryptographic hash function designed for use with the Korean KCDSA digital signature algorithm. It is derived from SHA-1, with assorted changes intended to increase its security. It produces a 160-bit output.

HAS-160 is used in the same way as SHA-1. First it divides input in blocks of 512 bits each and pads the final block. A digest function updates the intermediate hash value by processing the input blocks in turn.

The message digest algorithm consists of 80 rounds.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "Whirlpool": { - module: "Hashing", - description: "Whirlpool is a cryptographic hash function designed by Vincent Rijmen (co-creator of AES) and Paulo S. L. M. Barreto, who first described it in 2000.

Several variants exist:
  • Whirlpool-0 is the original version released in 2000.
  • Whirlpool-T is the first revision, released in 2001, improving the generation of the s-box.
  • Wirlpool is the latest revision, released in 2003, fixing a flaw in the difusion matrix.
", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Variant", - type: "option", - value: "Hash.WHIRLPOOL_VARIANT" - } - ] - }, - "Snefru": { - module: "Hashing", - description: "Snefru is a cryptographic hash function invented by Ralph Merkle in 1990 while working at Xerox PARC. The function supports 128-bit and 256-bit output. It was named after the Egyptian Pharaoh Sneferu, continuing the tradition of the Khufu and Khafre block ciphers.

The original design of Snefru was shown to be insecure by Eli Biham and Adi Shamir who were able to use differential cryptanalysis to find hash collisions. The design was then modified by increasing the number of iterations of the main pass of the algorithm from two to eight.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Rounds", - type: "option", - value: "Hash.SNEFRU_ROUNDS" - }, - { - name: "Size", - type: "option", - value: "Hash.SNEFRU_SIZE" - } - ] - }, - "SSDEEP": { - module: "Hashing", - description: "SSDEEP is a program for computing context triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.

SSDEEP hashes are now widely used for simple identification purposes (e.g. the 'Basic Properties' section in VirusTotal). Although 'better' fuzzy hashes are available, SSDEEP is still one of the primary choices because of its speed and being a de facto standard.

This operation is fundamentally the same as the CTPH operation, however their outputs differ in format.", - inputType: "string", - outputType: "string", - args: [] - }, - "CTPH": { - module: "Hashing", - description: "Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.

CTPH was originally based on the work of Dr. Andrew Tridgell and a spam email detector called SpamSum. This method was adapted by Jesse Kornblum and published at the DFRWS conference in 2006 in a paper 'Identifying Almost Identical Files Using Context Triggered Piecewise Hashing'.", - inputType: "string", - outputType: "string", - args: [] - }, - "Compare SSDEEP hashes": { - module: "Hashing", - description: "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100.", - inputType: "string", - outputType: "Number", - args: [ - { - name: "Delimiter", - type: "option", - value: "Hash.DELIM_OPTIONS" - } - ] - }, - "Compare CTPH hashes": { - module: "Hashing", - description: "Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100.", - inputType: "string", - outputType: "Number", - args: [ - { - name: "Delimiter", - type: "option", - value: "Hash.DELIM_OPTIONS" - } - ] - }, - "HMAC": { - module: "Hashing", - description: "Keyed-Hash Message Authentication Codes (HMAC) are a mechanism for message authentication using cryptographic hash functions.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Key", - type: "binaryString", - value: "" - }, - { - name: "Hashing function", - type: "option", - value: "Hash.HMAC_FUNCTIONS" - }, - ] - }, - "Fletcher-8 Checksum": { - module: "Hashing", - description: "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "Fletcher-16 Checksum": { - module: "Hashing", - description: "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "Fletcher-32 Checksum": { - module: "Hashing", - description: "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "Fletcher-64 Checksum": { - module: "Hashing", - description: "The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "Adler-32 Checksum": { - module: "Hashing", - description: "Adler-32 is a checksum algorithm which was invented by Mark Adler in 1995, and is a modification of the Fletcher checksum. Compared to a cyclic redundancy check of the same length, it trades reliability for speed (preferring the latter).

Adler-32 is more reliable than Fletcher-16, and slightly less reliable than Fletcher-32.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "CRC-32 Checksum": { - module: "Hashing", - description: "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The CRC was invented by W. Wesley Peterson in 1961; the 32-bit CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "CRC-16 Checksum": { - module: "Hashing", - description: "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.

The CRC was invented by W. Wesley Peterson in 1961.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "Generate all hashes": { - module: "Hashing", - description: "Generates all available hashes and checksums for the input.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "Entropy": { - module: "Default", - description: "Calculates the Shannon entropy of the input data which gives an idea of its randomness. 8 is the maximum.", - inputType: "byteArray", - outputType: "html", - args: [ - { - name: "Chunk size", - type: "number", - value: "Entropy.CHUNK_SIZE" - } - ] - }, - "Frequency distribution": { - module: "Default", - description: "Displays the distribution of bytes in the data as a graph.", - inputType: "ArrayBuffer", - outputType: "html", - args: [ - { - name: "Show 0%'s", - type: "boolean", - value: "Entropy.FREQ_ZEROS" - } - ] - }, - "Chi Square": { - module: "Default", - description: "Calculates the Chi-Squared distribution of values.", - inputType: "ArrayBuffer", - outputType: "number", - args: [] - }, - "Numberwang": { - module: "Default", - description: "Based on the popular gameshow by Mitchell and Webb.", - inputType: "string", - outputType: "string", - args: [] - }, - "Parse X.509 certificate": { - module: "PublicKey", - description: "X.509 is an ITU-T standard for a public key infrastructure (PKI) and Privilege Management Infrastructure (PMI). It is commonly involved with SSL/TLS security.

This operation displays the contents of a certificate in a human readable format, similar to the openssl command line tool.

Tags: X509, server hello, handshake", - inputType: "string", - outputType: "string", - args: [ - { - name: "Input format", - type: "option", - value: "PublicKey.X509_INPUT_FORMAT" - } - ], - patterns: [ - { - match: "^-+BEGIN CERTIFICATE-+\\r?\\n[\\da-z+/\\n\\r]+-+END CERTIFICATE-+\\r?\\n?$", - flags: "i", - args: ["PEM"] - }, - ] - }, - "PEM to Hex": { - module: "PublicKey", - description: "Converts PEM (Privacy Enhanced Mail) format to a hexadecimal DER (Distinguished Encoding Rules) string.", - inputType: "string", - outputType: "string", - args: [] - }, - "Hex to PEM": { - module: "PublicKey", - description: "Converts a hexadecimal DER (Distinguished Encoding Rules) string into PEM (Privacy Enhanced Mail) format.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Header string", - type: "string", - value: "PublicKey.PEM_HEADER_STRING" - } - ] - }, - "Hex to Object Identifier": { - module: "PublicKey", - description: "Converts a hexadecimal string into an object identifier (OID).", - inputType: "string", - outputType: "string", - args: [] - }, - "Object Identifier to Hex": { - module: "PublicKey", - description: "Converts an object identifier (OID) into a hexadecimal string.", - inputType: "string", - outputType: "string", - args: [] - }, - "Parse ASN.1 hex string": { - module: "PublicKey", - description: "Abstract Syntax Notation One (ASN.1) is a standard and notation that describes rules and structures for representing, encoding, transmitting, and decoding data in telecommunications and computer networking.

This operation parses arbitrary ASN.1 data and presents the resulting tree.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Starting index", - type: "number", - value: 0 - }, - { - name: "Truncate octet strings longer than", - type: "number", - value: "PublicKey.ASN1_TRUNCATE_LENGTH" - } - ] - }, - "Detect File Type": { - module: "Default", - description: "Attempts to guess the MIME (Multipurpose Internet Mail Extensions) type of the data based on 'magic bytes'.

Currently supports the following file types: 7z, amr, avi, bmp, bz2, class, cr2, crx, dex, dmg, doc, elf, eot, epub, exe, flac, flv, gif, gz, ico, iso, jpg, jxr, m4a, m4v, mid, mkv, mov, mp3, mp4, mpg, ogg, otf, pdf, png, ppt, ps, psd, rar, rtf, sqlite, swf, tar, tar.z, tif, ttf, utf8, vmdk, wav, webm, webp, wmv, woff, woff2, xls, xz, zip.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "Scan for Embedded Files": { - module: "Default", - description: "Scans the data for potential embedded files by looking for magic bytes at all offsets. This operation is prone to false positives.

WARNING: Files over about 100KB in size will take a VERY long time to process.", - inputType: "ArrayBuffer", - outputType: "string", - args: [ - { - name: "Ignore common byte sequences", - type: "boolean", - value: "FileType.IGNORE_COMMON_BYTE_SEQUENCES" - } - ] - }, - "Expand alphabet range": { - module: "Default", - description: "Expand an alphabet range string into a list of the characters in that range.

e.g. a-z becomes abcdefghijklmnopqrstuvwxyz.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "binaryString", - value: "" - } - ] - }, - "Diff": { - module: "Diff", - description: "Compares two inputs (separated by the specified delimiter) and highlights the differences between them.", - inputType: "string", - outputType: "html", - args: [ - { - name: "Sample delimiter", - type: "binaryString", - value: "Diff.DIFF_SAMPLE_DELIMITER" - }, - { - name: "Diff by", - type: "option", - value: "Diff.DIFF_BY" - }, - { - name: "Show added", - type: "boolean", - value: true - }, - { - name: "Show removed", - type: "boolean", - value: true - }, - { - name: "Ignore whitespace (relevant for word and line)", - type: "boolean", - value: false - } - ] - }, - "Parse UNIX file permissions": { - module: "Default", - description: "Given a UNIX/Linux file permission string in octal or textual format, this operation explains which permissions are granted to which user groups.

Input should be in either octal (e.g. 755) or textual (e.g. drwxr-xr-x) format.", - inputType: "string", - outputType: "string", - args: [] - }, - "Swap endianness": { - module: "Default", - description: "Switches the data from big-endian to little-endian or vice-versa. Data can be read in as hexadecimal or raw bytes. It will be returned in the same format as it is entered.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "string", - args: [ - { - name: "Data format", - type: "option", - value: "Endian.DATA_FORMAT" - }, - { - name: "Word length (bytes)", - type: "number", - value: "Endian.WORD_LENGTH" - }, - { - name: "Pad incomplete words", - type: "boolean", - value: "Endian.PAD_INCOMPLETE_WORDS" - } - ] - }, - "Microsoft Script Decoder": { - module: "Default", - description: "Decodes Microsoft Encoded Script files that have been encoded with Microsoft's custom encoding. These are often VBS (Visual Basic Script) files that are encoded and renamed with a '.vbe' extention or JS (JScript) files renamed with a '.jse' extention.

Sample

Encoded:
#@~^RQAAAA==-mD~sX|:/TP{~J:+dYbxL~@!F@*@!+@*@!&@*eEI@#@&@#@&.jm.raY 214Wv:zms/obI0xEAAA==^#~@

Decoded:
var my_msg = "Testing <1><2><3>!";\n\nVScript.Echo(my_msg);", - inputType: "string", - outputType: "string", - args: [] - }, - "Syntax highlighter": { - module: "Code", - description: "Adds syntax highlighting to a range of source code languages. Note that this will not indent the code. Use one of the 'Beautify' operations for that.", - highlight: true, - highlightReverse: true, - inputType: "string", - outputType: "html", - args: [ - { - name: "Language", - type: "option", - value: "Code.LANGUAGES" - }, - ] - }, - "TCP/IP Checksum": { - module: "Hashing", - description: "Calculates the checksum for a TCP (Transport Control Protocol) or IP (Internet Protocol) header from an input of raw bytes.", - inputType: "byteArray", - outputType: "string", - args: [] - }, - "Parse colour code": { - module: "Default", - description: "Converts a colour code in a standard format to other standard formats and displays the colour itself.

Example inputs
  • #d9edf7
  • rgba(217,237,247,1)
  • hsla(200,65%,91%,1)
  • cmyk(0.12, 0.04, 0.00, 0.03)
", - inputType: "string", - outputType: "html", - args: [] - }, - "Generate UUID": { - module: "Default", - description: "Generates an RFC 4122 version 4 compliant Universally Unique Identifier (UUID), also known as a Globally Unique Identifier (GUID).

A version 4 UUID relies on random numbers, in this case generated using window.crypto if available and falling back to Math.random if not.", - inputType: "string", - outputType: "string", - args: [] - }, - "Substitute": { - module: "Ciphers", - description: "A substitution cipher allowing you to specify bytes to replace with other byte values. This can be used to create Caesar ciphers but is more powerful as any byte value can be substituted, not just letters, and the substitution values need not be in order.

Enter the bytes you want to replace in the Plaintext field and the bytes to replace them with in the Ciphertext field.

Non-printable bytes can be specified using string escape notation. For example, a line feed character can be written as either \\n or \\x0a.

Byte ranges can be specified using a hyphen. For example, the sequence 0123456789 can be written as 0-9.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Plaintext", - type: "binaryString", - value: "Cipher.SUBS_PLAINTEXT" - }, - { - name: "Ciphertext", - type: "binaryString", - value: "Cipher.SUBS_CIPHERTEXT" - } - ] - }, - "Escape string": { - module: "Default", - description: "Escapes special characters in a string so that they do not cause conflicts. For example, Don't stop me now becomes Don\\'t stop me now.

Supports the following escape sequences:
  • \\n (Line feed/newline)
  • \\r (Carriage return)
  • \\t (Horizontal tab)
  • \\b (Backspace)
  • \\f (Form feed)
  • \\xnn (Hex, where n is 0-f)
  • \\\\ (Backslash)
  • \\' (Single quote)
  • \\" (Double quote)
  • \\unnnn (Unicode character)
  • \\u{nnnnnn} (Unicode code point)
", - inputType: "string", - outputType: "string", - args: [ - { - name: "Escape level", - type: "option", - value: "StrUtils.ESCAPE_LEVEL" - }, - { - name: "Escape quote", - type: "option", - value: "StrUtils.QUOTE_TYPES" - }, - { - name: "JSON compatible", - type: "boolean", - value: false - }, - { - name: "ES6 compatible", - type: "boolean", - value: true - }, - { - name: "Uppercase hex", - type: "boolean", - value: false - } - ] - }, - "Unescape string": { - module: "Default", - description: "Unescapes characters in a string that have been escaped. For example, Don\\'t stop me now becomes Don't stop me now.

Supports the following escape sequences:
  • \\n (Line feed/newline)
  • \\r (Carriage return)
  • \\t (Horizontal tab)
  • \\b (Backspace)
  • \\f (Form feed)
  • \\xnn (Hex, where n is 0-f)
  • \\\\ (Backslash)
  • \\' (Single quote)
  • \\" (Double quote)
  • \\unnnn (Unicode character)
  • \\u{nnnnnn} (Unicode code point)
", - inputType: "string", - outputType: "string", - args: [] - }, - "To Morse Code": { - module: "Default", - description: "Translates alphanumeric characters into International Morse Code.

Ignores non-Morse characters.

e.g. SOS becomes ... --- ...", - inputType: "string", - outputType: "string", - args: [ - { - name: "Format options", - type: "option", - value: "MorseCode.FORMAT_OPTIONS" - }, - { - name: "Letter delimiter", - type: "option", - value: "MorseCode.LETTER_DELIM_OPTIONS" - }, - { - name: "Word delimiter", - type: "option", - value: "MorseCode.WORD_DELIM_OPTIONS" - } - ] - }, - "From Morse Code": { - module: "Default", - description: "Translates Morse Code into (upper case) alphanumeric characters.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Letter delimiter", - type: "option", - value: "MorseCode.LETTER_DELIM_OPTIONS" - }, - { - name: "Word delimiter", - type: "option", - value: "MorseCode.WORD_DELIM_OPTIONS" - } - ], - patterns: [ - { - match: "(?:^[-. \\n]{5,}$|^[_. \\n]{5,}$|^(?:dash|dot| |\\n){5,}$)", - flags: "i", - args: ["Space", "Line feed"] - }, - ] - }, - "Tar": { - module: "Compression", - description: "Packs the input into a tarball.

No support for multiple files at this time.", - inputType: "byteArray", - outputType: "byteArray", - args: [ - { - name: "Filename", - type: "string", - value: "Compress.TAR_FILENAME" - } - ] - }, - "Untar": { - module: "Compression", - description: "Unpacks a tarball and displays it per file.", - inputType: "byteArray", - outputType: "html", - args: [], - patterns: [ - { - match: "^.{257}\\x75\\x73\\x74\\x61\\x72", - flags: "", - args: [] - }, - ] - }, - "Head": { - module: "Default", - description: [ - "Like the UNIX head utility.", - "
", - "Gets the first n lines.", - "
", - "You can select all but the last n lines by entering a negative value for n.", - "
", - "The delimiter can be changed so that instead of lines, fields (i.e. commas) are selected instead.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "StrUtils.DELIMITER_OPTIONS" - }, - { - name: "Number", - type: "number", - value: 10, - }, - ] - }, - "Tail": { - module: "Default", - description: [ - "Like the UNIX tail utility.", - "
", - "Gets the last n lines.", - "
", - "Optionally you can select all lines after line n by entering a negative value for n.", - "
", - "The delimiter can be changed so that instead of lines, fields (i.e. commas) are selected instead.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "option", - value: "StrUtils.DELIMITER_OPTIONS" - }, - { - name: "Number", - type: "number", - value: 10, - }, - ] - }, - "To Snake case": { - module: "Code", - description: [ - "Converts the input string to snake case.", - "

", - "Snake case is all lower case with underscores as word boundaries.", - "

", - "e.g. this_is_snake_case", - "

", - "'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Attempt to be context aware", - type: "boolean", - value: false, - }, - ] - }, - "To Camel case": { - module: "Code", - description: [ - "Converts the input string to camel case.", - "

", - "Camel case is all lower case except letters after word boundaries which are uppercase.", - "

", - "e.g. thisIsCamelCase", - "

", - "'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Attempt to be context aware", - type: "boolean", - value: false, - }, - ] - }, - "To Kebab case": { - module: "Code", - description: [ - "Converts the input string to kebab case.", - "

", - "Kebab case is all lower case with dashes as word boundaries.", - "

", - "e.g. this-is-kebab-case", - "

", - "'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Attempt to be context aware", - type: "boolean", - value: false, - }, - ] - }, - "Extract EXIF": { - module: "Image", - description: [ - "Extracts EXIF data from an image.", - "

", - "EXIF data is metadata embedded in images (JPEG, JPG, TIFF) and audio files.", - "

", - "EXIF data from photos usually contains information about the image file itself as well as the device used to create it.", - ].join("\n"), - inputType: "ArrayBuffer", - outputType: "string", - args: [], - }, - "Render Image": { - module: "Image", - description: "Displays the input as an image. Supports the following formats:

  • jpg/jpeg
  • png
  • gif
  • webp
  • bmp
  • ico
", - inputType: "string", - outputType: "html", - args: [ - { - name: "Input format", - type: "option", - value: "Image.INPUT_FORMAT" - } - ], - patterns: [ - { - match: "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", - flags: "", - args: ["Raw"], - useful: true - }, - ] - }, - "Remove EXIF": { - module: "Image", - description: [ - "Removes EXIF data from a JPEG image.", - "

", - "EXIF data embedded in photos usually contains information about the image file itself as well as the device used to create it.", - ].join("\n"), - inputType: "byteArray", - outputType: "byteArray", - args: [] - }, - "HTTP request": { - module: "HTTP", - description: [ - "Makes an HTTP request and returns the response.", - "

", - "This operation supports different HTTP verbs like GET, POST, PUT, etc.", - "

", - "You can add headers line by line in the format Key: Value", - "

", - "The status code of the response, along with a limited selection of exposed headers, can be viewed by checking the 'Show response metadata' option. Only a limited set of response headers are exposed by the browser for security reasons.", - ].join("\n"), - inputType: "string", - outputType: "string", - manualBake: true, - args: [ - { - name: "Method", - type: "option", - value: "HTTP.METHODS," - }, - { - name: "URL", - type: "string", - value: "", - }, - { - name: "Headers", - type: "text", - value: "", - }, - { - name: "Mode", - type: "option", - value: "HTTP.MODE," - }, - { - name: "Show response metadata", - type: "boolean", - value: false, - } - ] - }, - "From BCD": { - module: "Default", - description: "Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight. Special bit patterns are sometimes used for a sign.", - inputType: "string", - outputType: "BigNumber", - args: [ - { - name: "Scheme", - type: "option", - value: "BCD.ENCODING_SCHEME" - }, - { - name: "Packed", - type: "boolean", - value: true - }, - { - name: "Signed", - type: "boolean", - value: false - }, - { - name: "Input format", - type: "option", - value: "BCD.FORMAT" - } - ], - patterns: [ - { - match: "^(?:\\d{4} ){3,}\\d{4}$", - flags: "", - args: ["8 4 2 1", true, false, "Nibbles"] - }, - ] - }, - "To BCD": { - module: "Default", - description: "Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight. Special bit patterns are sometimes used for a sign", - inputType: "BigNumber", - outputType: "string", - args: [ - { - name: "Scheme", - type: "option", - value: "BCD.ENCODING_SCHEME" - }, - { - name: "Packed", - type: "boolean", - value: true - }, - { - name: "Signed", - type: "boolean", - value: false - }, - { - name: "Output format", - type: "option", - value: "BCD.FORMAT" - } - ] - - }, - "Bit shift left": { - module: "Default", - description: "Shifts the bits in each byte towards the left by the specified amount.", - inputType: "byteArray", - outputType: "byteArray", - highlight: true, - highlightReverse: true, - args: [ - { - name: "Amount", - type: "number", - value: 1 - }, - ] - }, - "Bit shift right": { - module: "Default", - description: "Shifts the bits in each byte towards the right by the specified amount.

Logical shifts replace the leftmost bits with zeros.
Arithmetic shifts preserve the most significant bit (MSB) of the original byte keeping the sign the same (positive or negative).", - inputType: "byteArray", - outputType: "byteArray", - highlight: true, - highlightReverse: true, - args: [ - { - name: "Amount", - type: "number", - value: 1 - }, - { - name: "Type", - type: "option", - value: "BitwiseOp.BIT_SHIFT_TYPE" - } - ] - }, - "Generate TOTP": { - module: "Default", - description: "The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.

Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Name", - type: "string", - value: "" - }, - { - name: "Key size", - type: "number", - value: 32 - }, - { - name: "Code length", - type: "number", - value: 6 - }, - { - name: "Epoch offset (T0)", - type: "number", - value: 0 - }, - { - name: "Interval (T1)", - type: "number", - value: 30 - } - ] - }, - "Generate HOTP": { - module: "Default", - description: "The HMAC-based One-Time Password algorithm (HOTP) is an algorithm that computes a one-time password from a shared secret key and an incrementing counter. It has been adopted as Internet Engineering Task Force standard RFC 4226, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems.

Enter the secret as the input or leave it blank for a random secret to be generated.", - inputType: "byteArray", - outputType: "string", - args: [ - { - name: "Name", - type: "string", - value: "" - }, - { - name: "Key size", - type: "number", - value: 32 - }, - { - name: "Code length", - type: "number", - value: 6 - }, - { - name: "Counter", - type: "number", - value: 0 - } - ] - }, - "PHP Deserialize": { - module: "Default", - description: "Deserializes PHP serialized data, outputting keyed arrays as JSON.

This function does not support object tags.

Example:
a:2:{s:1:"a";i:10;i:0;a:1:{s:2:"ab";b:1;}}
becomes
{"a": 10,0: {"ab": true}}

Output valid JSON: JSON doesn't support integers as keys, whereas PHP serialization does. Enabling this will cast these integers to strings. This will also escape backslashes.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Output valid JSON", - type: "boolean", - value: "PHP.OUTPUT_VALID_JSON" - } - ] - }, - "Hamming Distance": { - module: "Default", - description: "In information theory, the Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different. In other words, it measures the minimum number of substitutions required to change one string into the other, or the minimum number of errors that could have transformed one string into the other. In a more general context, the Hamming distance is one of several string metrics for measuring the edit distance between two sequences.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Delimiter", - type: "binaryShortString", - value: "StrUtils.HAMMING_DELIM" - }, - { - name: "Unit", - type: "option", - value: "StrUtils.HAMMING_UNIT" - }, - { - name: "Input type", - type: "option", - value: "StrUtils.HAMMING_INPUT_TYPE" - } - ] - }, - "XKCD Random Number": { - module: "Default", - description: "RFC 1149.5 specifies 4 as the standard IEEE-vetted random number.

XKCD #221", - inputType: "string", - outputType: "number", - args: [] - }, - "Bcrypt": { - module: "Hashing", - description: "bcrypt is a password hashing function designed by Niels Provos and David Mazières, based on the Blowfish cipher, and presented at USENIX in 1999. Besides incorporating a salt to protect against rainbow table attacks, bcrypt is an adaptive function: over time, the iteration count (rounds) can be increased to make it slower, so it remains resistant to brute-force search attacks even with increasing computation power.

Enter the password in the input to generate its hash.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Rounds", - type: "number", - value: "Hash.BCRYPT_ROUNDS" - } - ] - }, - "Bcrypt compare": { - module: "Hashing", - description: "Tests whether the input matches the given bcrypt hash. To test multiple possible passwords, use the 'Fork' operation.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Hash", - type: "string", - value: "" - } - ] - }, - "Bcrypt parse": { - module: "Hashing", - description: "Parses a bcrypt hash to determine the number of rounds used, the salt, and the password hash.", - inputType: "string", - outputType: "string", - args: [] - }, - "Scrypt": { - module: "Hashing", - description: "scrypt is a password-based key derivation function (PBKDF) created by Colin Percival. The algorithm was specifically designed to make it costly to perform large-scale custom hardware attacks by requiring large amounts of memory. In 2016, the scrypt algorithm was published by IETF as RFC 7914.

Enter the password in the input to generate its hash.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Salt", - type: "toggleString", - value: "", - toggleValues: "Hash.KEY_FORMAT" - }, - { - name: "Iterations (N)", - type: "number", - value: "Hash.SCRYPT_ITERATIONS" - }, - { - name: "Memory factor (r)", - type: "number", - value: "Hash.SCRYPT_MEM_FACTOR" - }, - { - name: "Parallelization factor (p)", - type: "number", - value: "Hash.SCRYPT_PARALLEL_FACTOR" - }, - { - name: "Key length", - type: "number", - value: "Hash.SCRYPT_KEY_LENGTH" - }, - ] - }, - "BSON serialise": { - module: "BSON", - description: "BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'.

Input data should be valid JSON.", - inputType: "string", - outputType: "ArrayBuffer", - args: [] - }, - "BSON deserialise": { - module: "BSON", - description: "BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'.

Input data should be in a raw bytes format.", - inputType: "ArrayBuffer", - outputType: "string", - args: [] - }, - "Generate PGP Key Pair": { - module: "PGP", - description: "Generates a new public/private PGP key pair. Supports RSA and Eliptic Curve (EC) keys.", - inputType: "string", - outputType: "string", - args: [ - { - name: "Key type", - type: "option", - value: "PGP.KEY_TYPES" - }, - { - name: "Password (optional)", - type: "string", - value: "" - }, - { - name: "Name (optional)", - type: "string", - value: "" - }, - { - name: "Email (optional)", - type: "string", - value: "" - }, - ] - }, - "PGP Encrypt": { - module: "PGP", - description: [ - "Input: the message you want to encrypt.", - "

", - "Arguments: the ASCII-armoured PGP public key of the recipient.", - "

", - "Pretty Good Privacy is an encryption standard (OpenPGP) used for encrypting, decrypting, and signing messages.", - "

", - "This function uses the Keybase implementation of PGP.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Public key of recipient", - type: "text", - value: "" - }, - ] - }, - "PGP Decrypt": { - module: "PGP", - description: [ - "Input: the ASCII-armoured PGP message you want to decrypt.", - "

", - "Arguments: the ASCII-armoured PGP private key of the recipient, ", - "(and the private key password if necessary).", - "

", - "Pretty Good Privacy is an encryption standard (OpenPGP) used for encrypting, decrypting, and signing messages.", - "

", - "This function uses the Keybase implementation of PGP.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Private key of recipient", - type: "text", - value: "" - }, - { - name: "Private key passphrase", - type: "string", - value: "" - }, - ] - }, - "PGP Encrypt and Sign": { - module: "PGP", - description: [ - "Input: the cleartext you want to sign.", - "

", - "Arguments: the ASCII-armoured private key of the signer (plus the private key password if necessary)", - "and the ASCII-armoured PGP public key of the recipient.", - "

", - "This operation uses PGP to produce an encrypted digital signature.", - "

", - "Pretty Good Privacy is an encryption standard (OpenPGP) used for encrypting, decrypting, and signing messages.", - "

", - "This function uses the Keybase implementation of PGP.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Private key of signer", - type: "text", - value: "" - }, - { - name: "Private key passphrase", - type: "string", - value: "" - }, - { - name: "Public key of recipient", - type: "text", - value: "" - }, - ] - }, - "PGP Decrypt and Verify": { - module: "PGP", - description: [ - "Input: the ASCII-armoured encrypted PGP message you want to verify.", - "

", - "Arguments: the ASCII-armoured PGP public key of the signer, ", - "the ASCII-armoured private key of the recipient (and the private key password if necessary).", - "

", - "This operation uses PGP to decrypt and verify an encrypted digital signature.", - "

", - "Pretty Good Privacy is an encryption standard (OpenPGP) used for encrypting, decrypting, and signing messages.", - "

", - "This function uses the Keybase implementation of PGP.", - ].join("\n"), - inputType: "string", - outputType: "string", - args: [ - { - name: "Public key of signer", - type: "text", - value: "", - }, - { - name: "Private key of recipient", - type: "text", - value: "", - }, - { - name: "Private key password", - type: "string", - value: "", - }, - ] - }, -}; - -main(); diff --git a/src/core/operations/legacy/Arithmetic.js b/src/core/operations/legacy/Arithmetic.js deleted file mode 100644 index e1e44981..00000000 --- a/src/core/operations/legacy/Arithmetic.js +++ /dev/null @@ -1,259 +0,0 @@ -/** - * @author d98762625 [d98762625@gmail.com] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - */ - -import Utils from "../Utils.js"; -import BigNumber from "bignumber.js"; - - -/** - * Math operations on numbers. - * - * @author bwhitn [brian.m.whitney@outlook.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Arithmetic = { - - /** - * @constant - * @default - */ - DELIM_OPTIONS: ["Line feed", "Space", "Comma", "Semi-colon", "Colon", "CRLF"], - - - /** - * Splits a string based on a delimiter and calculates the sum of numbers. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runSum: function(input, args) { - const val = Arithmetic._sum(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Splits a string based on a delimiter and subtracts all the numbers. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runSub: function(input, args) { - let val = Arithmetic._sub(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Splits a string based on a delimiter and multiplies the numbers. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runMulti: function(input, args) { - let val = Arithmetic._multi(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Splits a string based on a delimiter and divides the numbers. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runDiv: function(input, args) { - let val = Arithmetic._div(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Splits a string based on a delimiter and computes the mean (average). - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runMean: function(input, args) { - let val = Arithmetic._mean(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Splits a string based on a delimiter and finds the median. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runMedian: function(input, args) { - let val = Arithmetic._median(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * splits a string based on a delimiter and computes the standard deviation. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runStdDev: function(input, args) { - let val = Arithmetic._stdDev(Arithmetic._createNumArray(input, args[0])); - return val instanceof BigNumber ? val : new BigNumber(NaN); - }, - - - /** - * Converts a string array to a number array. - * - * @private - * @param {string[]} input - * @param {string} delim - * @returns {BigNumber[]} - */ - _createNumArray: function(input, delim) { - delim = Utils.charRep(delim || "Space"); - let splitNumbers = input.split(delim), - numbers = [], - num; - - for (let i = 0; i < splitNumbers.length; i++) { - try { - num = BigNumber(splitNumbers[i].trim()); - if (!num.isNaN()) { - numbers.push(num); - } - } catch (err) { - // This line is not a valid number - } - } - return numbers; - }, - - - /** - * Adds an array of numbers and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _sum: function(data) { - if (data.length > 0) { - return data.reduce((acc, curr) => acc.plus(curr)); - } - }, - - - /** - * Subtracts an array of numbers and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _sub: function(data) { - if (data.length > 0) { - return data.reduce((acc, curr) => acc.minus(curr)); - } - }, - - - /** - * Multiplies an array of numbers and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _multi: function(data) { - if (data.length > 0) { - return data.reduce((acc, curr) => acc.times(curr)); - } - }, - - - /** - * Divides an array of numbers and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _div: function(data) { - if (data.length > 0) { - return data.reduce((acc, curr) => acc.div(curr)); - } - }, - - - /** - * Computes mean of a number array and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _mean: function(data) { - if (data.length > 0) { - return Arithmetic._sum(data).div(data.length); - } - }, - - - /** - * Computes median of a number array and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _median: function (data) { - if ((data.length % 2) === 0 && data.length > 0) { - let first, second; - data.sort(function(a, b){ - return a.minus(b); - }); - first = data[Math.floor(data.length / 2)]; - second = data[Math.floor(data.length / 2) - 1]; - return Arithmetic._mean([first, second]); - } else { - return data[Math.floor(data.length / 2)]; - } - }, - - - /** - * Computes standard deviation of a number array and returns the value. - * - * @private - * @param {BigNumber[]} data - * @returns {BigNumber} - */ - _stdDev: function (data) { - if (data.length > 0) { - let avg = Arithmetic._mean(data); - let devSum = new BigNumber(0); - for (let i = 0; i < data.length; i++) { - devSum = devSum.plus(data[i].minus(avg).pow(2)); - } - return devSum.div(data.length).sqrt(); - } - }, -}; - -export default Arithmetic; diff --git a/src/core/operations/legacy/BCD.js b/src/core/operations/legacy/BCD.js deleted file mode 100755 index ee20f2df..00000000 --- a/src/core/operations/legacy/BCD.js +++ /dev/null @@ -1,215 +0,0 @@ -import Utils from "../Utils.js"; -import BigNumber from "bignumber.js"; - - -/** - * Binary-Coded Decimal operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const BCD = { - - /** - * @constant - * @default - */ - ENCODING_SCHEME: [ - "8 4 2 1", - "7 4 2 1", - "4 2 2 1", - "2 4 2 1", - "8 4 -2 -1", - "Excess-3", - "IBM 8 4 2 1", - ], - - /** - * Lookup table for the binary value of each digit representation. - * - * I wrote a very nice algorithm to generate 8 4 2 1 encoding programatically, - * but unfortunately it's much easier (if less elegant) to use lookup tables - * when supporting multiple encoding schemes. - * - * "Practicality beats purity" - PEP 20 - * - * In some schemes it is possible to represent the same value in multiple ways. - * For instance, in 4 2 2 1 encoding, 0100 and 0010 both represent 2. Support - * has not yet been added for this. - * - * @constant - */ - ENCODING_LOOKUP: { - "8 4 2 1": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], - "7 4 2 1": [0, 1, 2, 3, 4, 5, 6, 8, 9, 10], - "4 2 2 1": [0, 1, 4, 5, 8, 9, 12, 13, 14, 15], - "2 4 2 1": [0, 1, 2, 3, 4, 11, 12, 13, 14, 15], - "8 4 -2 -1": [0, 7, 6, 5, 4, 11, 10, 9, 8, 15], - "Excess-3": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12], - "IBM 8 4 2 1": [10, 1, 2, 3, 4, 5, 6, 7, 8, 9], - }, - - /** - * @default - * @constant - */ - FORMAT: ["Nibbles", "Bytes", "Raw"], - - - /** - * To BCD operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {string} - */ - runToBCD: function(input, args) { - if (input.isNaN()) - return "Invalid input"; - if (!input.integerValue(BigNumber.ROUND_DOWN).isEqualTo(input)) - return "Fractional values are not supported by BCD"; - - const encoding = BCD.ENCODING_LOOKUP[args[0]], - packed = args[1], - signed = args[2], - outputFormat = args[3]; - - // Split input number up into separate digits - const digits = input.toFixed().split(""); - - if (digits[0] === "-" || digits[0] === "+") { - digits.shift(); - } - - let nibbles = []; - - digits.forEach(d => { - const n = parseInt(d, 10); - nibbles.push(encoding[n]); - }); - - if (signed) { - if (packed && digits.length % 2 === 0) { - // If there are an even number of digits, we add a leading 0 so - // that the sign nibble doesn't sit in its own byte, leading to - // ambiguity around whether the number ends with a 0 or not. - nibbles.unshift(encoding[0]); - } - - nibbles.push(input > 0 ? 12 : 13); - // 12 ("C") for + (credit) - // 13 ("D") for - (debit) - } - - let bytes = []; - - if (packed) { - let encoded = 0, - little = false; - - nibbles.forEach(n => { - encoded ^= little ? n : (n << 4); - if (little) { - bytes.push(encoded); - encoded = 0; - } - little = !little; - }); - - if (little) bytes.push(encoded); - } else { - bytes = nibbles; - - // Add null high nibbles - nibbles = nibbles.map(n => { - return [0, n]; - }).reduce((a, b) => { - return a.concat(b); - }); - } - - // Output - switch (outputFormat) { - case "Nibbles": - return nibbles.map(n => { - return n.toString(2).padStart(4, "0"); - }).join(" "); - case "Bytes": - return bytes.map(b => { - return b.toString(2).padStart(8, "0"); - }).join(" "); - case "Raw": - default: - return Utils.byteArrayToChars(bytes); - } - }, - - - /** - * From BCD operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runFromBCD: function(input, args) { - const encoding = BCD.ENCODING_LOOKUP[args[0]], - packed = args[1], - signed = args[2], - inputFormat = args[3]; - - let nibbles = [], - output = "", - byteArray; - - // Normalise the input - switch (inputFormat) { - case "Nibbles": - case "Bytes": - input = input.replace(/\s/g, ""); - for (let i = 0; i < input.length; i += 4) { - nibbles.push(parseInt(input.substr(i, 4), 2)); - } - break; - case "Raw": - default: - byteArray = Utils.strToByteArray(input); - byteArray.forEach(b => { - nibbles.push(b >>> 4); - nibbles.push(b & 15); - }); - break; - } - - if (!packed) { - // Discard each high nibble - for (let i = 0; i < nibbles.length; i++) { - nibbles.splice(i, 1); - } - } - - if (signed) { - const sign = nibbles.pop(); - if (sign === 13 || - sign === 11) { - // Negative - output += "-"; - } - } - - nibbles.forEach(n => { - if (isNaN(n)) throw "Invalid input"; - let val = encoding.indexOf(n); - if (val < 0) throw `Value ${Utils.bin(n, 4)} not in encoding scheme`; - output += val.toString(); - }); - - return new BigNumber(output); - }, - -}; - -export default BCD; diff --git a/src/core/operations/legacy/BSON.js b/src/core/operations/legacy/BSON.js deleted file mode 100644 index 4f0d484f..00000000 --- a/src/core/operations/legacy/BSON.js +++ /dev/null @@ -1,59 +0,0 @@ -import bsonjs from "bson"; -import {Buffer} from "buffer"; - - -/** - * BSON operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - * - * @namespace - */ -const BSON = { - - /** - * BSON serialise operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {ArrayBuffer} - */ - runBSONSerialise(input, args) { - if (!input) return new ArrayBuffer(); - - const bson = new bsonjs(); - - try { - const data = JSON.parse(input); - return bson.serialize(data).buffer; - } catch (err) { - throw err.toString(); - } - }, - - - /** - * BSON deserialise operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - * - */ - runBSONDeserialise(input, args) { - if (!input.byteLength) return ""; - - const bson = new bsonjs(); - - try { - const data = bson.deserialize(new Buffer(input)); - return JSON.stringify(data, null, 2); - } catch (err) { - return err.toString(); - } - }, -}; - -export default BSON; diff --git a/src/core/operations/legacy/Base.js b/src/core/operations/legacy/Base.js deleted file mode 100755 index 06bbeb7c..00000000 --- a/src/core/operations/legacy/Base.js +++ /dev/null @@ -1,68 +0,0 @@ -import BigNumber from "bignumber.js"; - -/** - * Numerical base operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Base = { - - /** - * @constant - * @default - */ - DEFAULT_RADIX: 36, - - /** - * To Base operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {string} - */ - runTo: function(input, args) { - if (!input) { - throw ("Error: Input must be a number"); - } - const radix = args[0] || Base.DEFAULT_RADIX; - if (radix < 2 || radix > 36) { - throw "Error: Radix argument must be between 2 and 36"; - } - return input.toString(radix); - }, - - - /** - * From Base operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runFrom: function(input, args) { - const radix = args[0] || Base.DEFAULT_RADIX; - if (radix < 2 || radix > 36) { - throw "Error: Radix argument must be between 2 and 36"; - } - - let number = input.replace(/\s/g, "").split("."), - result = new BigNumber(number[0], radix) || 0; - - if (number.length === 1) return result; - - // Fractional part - for (let i = 0; i < number[1].length; i++) { - const digit = new BigNumber(number[1][i], radix); - result += digit.div(Math.pow(radix, i+1)); - } - - return result; - }, - -}; - -export default Base; diff --git a/src/core/operations/legacy/Base58.js b/src/core/operations/legacy/Base58.js deleted file mode 100755 index 2eabf1da..00000000 --- a/src/core/operations/legacy/Base58.js +++ /dev/null @@ -1,137 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * Base58 operations. - * - * @author tlwr [toby@toby.codes] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const Base58 = { - - /** - * @constant - * @default - */ - ALPHABET_OPTIONS: [ - { - name: "Bitcoin", - value: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", - }, - { - name: "Ripple", - value: "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz", - }, - ], - /** - * @constant - * @default - */ - REMOVE_NON_ALPH_CHARS: true, - - /** - * To Base58 operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runTo: function(input, args) { - let alphabet = args[0] || Base58.ALPHABET_OPTIONS[0].value, - result = [0]; - - alphabet = Utils.expandAlphRange(alphabet).join(""); - - if (alphabet.length !== 58 || - [].unique.call(alphabet).length !== 58) { - throw ("Error: alphabet must be of length 58"); - } - - if (input.length === 0) return ""; - - input.forEach(function(b) { - let carry = (result[0] << 8) + b; - result[0] = carry % 58; - carry = (carry / 58) | 0; - - for (let i = 1; i < result.length; i++) { - carry += result[i] << 8; - result[i] = carry % 58; - carry = (carry / 58) | 0; - } - - while (carry > 0) { - result.push(carry % 58); - carry = (carry / 58) | 0; - } - }); - - result = result.map(function(b) { - return alphabet[b]; - }).reverse().join(""); - - while (result.length < input.length) { - result = alphabet[0] + result; - } - - return result; - }, - - - /** - * From Base58 operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFrom: function(input, args) { - let alphabet = args[0] || Base58.ALPHABET_OPTIONS[0].value, - removeNonAlphaChars = args[1] === undefined ? true : args[1], - result = [0]; - - alphabet = Utils.expandAlphRange(alphabet).join(""); - - if (alphabet.length !== 58 || - [].unique.call(alphabet).length !== 58) { - throw ("Alphabet must be of length 58"); - } - - if (input.length === 0) return []; - - [].forEach.call(input, function(c, charIndex) { - const index = alphabet.indexOf(c); - - if (index === -1) { - if (removeNonAlphaChars) { - return; - } else { - throw ("Char '" + c + "' at position " + charIndex + " not in alphabet"); - } - } - - let carry = result[0] * 58 + index; - result[0] = carry & 0xFF; - carry = carry >> 8; - - for (let i = 1; i < result.length; i++) { - carry += result[i] * 58; - result[i] = carry & 0xFF; - carry = carry >> 8; - } - - while (carry > 0) { - result.push(carry & 0xFF); - carry = carry >> 8; - } - }); - - return result.reverse(); - }, - -}; - -export default Base58; diff --git a/src/core/operations/legacy/ByteRepr.js b/src/core/operations/legacy/ByteRepr.js deleted file mode 100755 index 548db525..00000000 --- a/src/core/operations/legacy/ByteRepr.js +++ /dev/null @@ -1,355 +0,0 @@ -import Utils from "../Utils.js"; -import {toHex, fromHex} from "../lib/Hex"; - - -/** - * Byte representation operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const ByteRepr = { - - /** - * @constant - * @default - */ - DELIM_OPTIONS: ["Space", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF"], - /** - * @constant - * @default - */ - TO_HEX_DELIM_OPTIONS: ["Space", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "0x", "\\x", "None"], - /** - * @constant - * @default - */ - FROM_HEX_DELIM_OPTIONS: ["Auto", "Space", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "0x", "\\x", "None"], - /** - * @constant - * @default - */ - BIN_DELIM_OPTIONS: ["Space", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "None"], - - - /** - * To Octal operation. - * - * @author Matt C [matt@artemisbot.uk] - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runToOct: function(input, args) { - const delim = Utils.charRep(args[0] || "Space"); - return input.map(val => val.toString(8)).join(delim); - }, - - - /** - * From Octal operation. - * - * @author Matt C [matt@artemisbot.uk] - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFromOct: function(input, args) { - const delim = Utils.charRep(args[0] || "Space"); - if (input.length === 0) return []; - return input.split(delim).map(val => parseInt(val, 8)); - }, - - - /** - * @constant - * @default - */ - CHARCODE_BASE: 16, - - /** - * To Charcode operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToCharcode: function(input, args) { - let delim = Utils.charRep(args[0] || "Space"), - base = args[1], - output = "", - padding = 2, - ordinal; - - if (base < 2 || base > 36) { - throw "Error: Base argument must be between 2 and 36"; - } - - const charcode = Utils.strToCharcode(input); - for (let i = 0; i < charcode.length; i++) { - ordinal = charcode[i]; - - if (base === 16) { - if (ordinal < 256) padding = 2; - else if (ordinal < 65536) padding = 4; - else if (ordinal < 16777216) padding = 6; - else if (ordinal < 4294967296) padding = 8; - else padding = 2; - - if (padding > 2 && ENVIRONMENT_IS_WORKER()) self.setOption("attemptHighlight", false); - - output += Utils.hex(ordinal, padding) + delim; - } else { - if (ENVIRONMENT_IS_WORKER()) self.setOption("attemptHighlight", false); - output += ordinal.toString(base) + delim; - } - } - - return output.slice(0, -delim.length); - }, - - - /** - * From Charcode operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFromCharcode: function(input, args) { - let delim = Utils.charRep(args[0] || "Space"), - base = args[1], - bites = input.split(delim), - i = 0; - - if (base < 2 || base > 36) { - throw "Error: Base argument must be between 2 and 36"; - } - - if (input.length === 0) { - return []; - } - - if (base !== 16 && ENVIRONMENT_IS_WORKER()) self.setOption("attemptHighlight", false); - - // Split into groups of 2 if the whole string is concatenated and - // too long to be a single character - if (bites.length === 1 && input.length > 17) { - bites = []; - for (i = 0; i < input.length; i += 2) { - bites.push(input.slice(i, i+2)); - } - } - - let latin1 = ""; - for (i = 0; i < bites.length; i++) { - latin1 += Utils.chr(parseInt(bites[i], base)); - } - return Utils.strToByteArray(latin1); - }, - - - /** - * To Decimal operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runToDecimal: function(input, args) { - const delim = Utils.charRep(args[0]); - return input.join(delim); - }, - - - /** - * From Decimal operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFromDecimal: function(input, args) { - const delim = Utils.charRep(args[0]); - let byteStr = input.split(delim), output = []; - if (byteStr[byteStr.length-1] === "") - byteStr = byteStr.slice(0, byteStr.length-1); - - for (let i = 0; i < byteStr.length; i++) { - output[i] = parseInt(byteStr[i], 10); - } - return output; - }, - - - /** - * To Binary operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runToBinary: function(input, args) { - let delim = Utils.charRep(args[0] || "Space"), - output = "", - padding = 8; - - for (let i = 0; i < input.length; i++) { - output += input[i].toString(2).padStart(padding, "0") + delim; - } - - if (delim.length) { - return output.slice(0, -delim.length); - } else { - return output; - } - }, - - - /** - * From Binary operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFromBinary: function(input, args) { - const delimRegex = Utils.regexRep(args[0] || "Space"); - input = input.replace(delimRegex, ""); - - const output = []; - const byteLen = 8; - for (let i = 0; i < input.length; i += byteLen) { - output.push(parseInt(input.substr(i, byteLen), 2)); - } - return output; - }, - - - /** - * Highlight to binary - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlightToBinary: function(pos, args) { - const delim = Utils.charRep(args[0] || "Space"); - pos[0].start = pos[0].start * (8 + delim.length); - pos[0].end = pos[0].end * (8 + delim.length) - delim.length; - return pos; - }, - - - /** - * Highlight from binary - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlightFromBinary: function(pos, args) { - const delim = Utils.charRep(args[0] || "Space"); - pos[0].start = pos[0].start === 0 ? 0 : Math.floor(pos[0].start / (8 + delim.length)); - pos[0].end = pos[0].end === 0 ? 0 : Math.ceil(pos[0].end / (8 + delim.length)); - return pos; - }, - - - /** - * @constant - * @default - */ - HEX_CONTENT_CONVERT_WHICH: ["Only special chars", "Only special chars including spaces", "All chars"], - /** - * @constant - * @default - */ - HEX_CONTENT_SPACES_BETWEEN_BYTES: false, - - /** - * To Hex Content operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runToHexContent: function(input, args) { - const convert = args[0]; - const spaces = args[1]; - if (convert === "All chars") { - let result = "|" + toHex(input) + "|"; - if (!spaces) result = result.replace(/ /g, ""); - return result; - } - - let output = "", - inHex = false, - convertSpaces = convert === "Only special chars including spaces", - b; - for (let i = 0; i < input.length; i++) { - b = input[i]; - if ((b === 32 && convertSpaces) || (b < 48 && b !== 32) || (b > 57 && b < 65) || (b > 90 && b < 97) || b > 122) { - if (!inHex) { - output += "|"; - inHex = true; - } else if (spaces) output += " "; - output += toHex([b]); - } else { - if (inHex) { - output += "|"; - inHex = false; - } - output += Utils.chr(input[i]); - } - } - if (inHex) output += "|"; - return output; - }, - - - /** - * From Hex Content operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFromHexContent: function(input, args) { - const regex = /\|([a-f\d ]{2,})\|/gi; - let output = [], m, i = 0; - while ((m = regex.exec(input))) { - // Add up to match - for (; i < m.index;) - output.push(Utils.ord(input[i++])); - - // Add match - const bytes = fromHex(m[1]); - if (bytes) { - for (let a = 0; a < bytes.length;) - output.push(bytes[a++]); - } else { - // Not valid hex, print as normal - for (; i < regex.lastIndex;) - output.push(Utils.ord(input[i++])); - } - - i = regex.lastIndex; - } - // Add all after final match - for (; i < input.length;) - output.push(Utils.ord(input[i++])); - - return output; - }, - -}; - -export default ByteRepr; diff --git a/src/core/operations/legacy/CharEnc.js b/src/core/operations/legacy/CharEnc.js deleted file mode 100755 index 6b509e1e..00000000 --- a/src/core/operations/legacy/CharEnc.js +++ /dev/null @@ -1,97 +0,0 @@ -import cptable from "../vendor/js-codepage/cptable.js"; - - -/** - * Character encoding operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const CharEnc = { - - /** - * @constant - * @default - */ - IO_FORMAT: { - "UTF-8 (65001)": 65001, - "UTF-7 (65000)": 65000, - "UTF16LE (1200)": 1200, - "UTF16BE (1201)": 1201, - "UTF16 (1201)": 1201, - "IBM EBCDIC International (500)": 500, - "IBM EBCDIC US-Canada (37)": 37, - "Windows-874 Thai (874)": 874, - "Japanese Shift-JIS (932)": 932, - "Simplified Chinese GBK (936)": 936, - "Korean (949)": 949, - "Traditional Chinese Big5 (950)": 950, - "Windows-1250 Central European (1250)": 1250, - "Windows-1251 Cyrillic (1251)": 1251, - "Windows-1252 Latin (1252)": 1252, - "Windows-1253 Greek (1253)": 1253, - "Windows-1254 Turkish (1254)": 1254, - "Windows-1255 Hebrew (1255)": 1255, - "Windows-1256 Arabic (1256)": 1256, - "Windows-1257 Baltic (1257)": 1257, - "Windows-1258 Vietnam (1258)": 1258, - "US-ASCII (20127)": 20127, - "Simplified Chinese GB2312 (20936)": 20936, - "KOI8-R Russian Cyrillic (20866)": 20866, - "KOI8-U Ukrainian Cyrillic (21866)": 21866, - "ISO-8859-1 Latin 1 Western European (28591)": 28591, - "ISO-8859-2 Latin 2 Central European (28592)": 28592, - "ISO-8859-3 Latin 3 South European (28593)": 28593, - "ISO-8859-4 Latin 4 North European (28594)": 28594, - "ISO-8859-5 Latin/Cyrillic (28595)": 28595, - "ISO-8859-6 Latin/Arabic (28596)": 28596, - "ISO-8859-7 Latin/Greek (28597)": 28597, - "ISO-8859-8 Latin/Hebrew (28598)": 28598, - "ISO-8859-9 Latin 5 Turkish (28599)": 28599, - "ISO-8859-10 Latin 6 Nordic (28600)": 28600, - "ISO-8859-11 Latin/Thai (28601)": 28601, - "ISO-8859-13 Latin 7 Baltic Rim (28603)": 28603, - "ISO-8859-14 Latin 8 Celtic (28604)": 28604, - "ISO-8859-15 Latin 9 (28605)": 28605, - "ISO-8859-16 Latin 10 (28606)": 28606, - "ISO-2022 JIS Japanese (50222)": 50222, - "EUC Japanese (51932)": 51932, - "EUC Korean (51949)": 51949, - "Simplified Chinese GB18030 (54936)": 54936, - }, - - /** - * Encode text operation. - * @author tlwr [toby@toby.codes] - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runEncode: function(input, args) { - const format = CharEnc.IO_FORMAT[args[0]]; - let encoded = cptable.utils.encode(format, input); - encoded = Array.from(encoded); - return encoded; - }, - - - /** - * Decode text operation. - * @author tlwr [toby@toby.codes] - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runDecode: function(input, args) { - const format = CharEnc.IO_FORMAT[args[0]]; - let decoded = cptable.utils.decode(format, input); - return decoded; - }, -}; - -export default CharEnc; diff --git a/src/core/operations/legacy/Checksum.js b/src/core/operations/legacy/Checksum.js deleted file mode 100755 index 6b2cb31c..00000000 --- a/src/core/operations/legacy/Checksum.js +++ /dev/null @@ -1,179 +0,0 @@ -import * as CRC from "js-crc"; -import Utils from "../Utils.js"; - - -/** - * Checksum operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Checksum = { - - /** - * Fletcher-8 Checksum operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runFletcher8: function(input, args) { - let a = 0, - b = 0; - - for (let i = 0; i < input.length; i++) { - a = (a + input[i]) % 0xf; - b = (b + a) % 0xf; - } - - return Utils.hex(((b << 4) | a) >>> 0, 2); - }, - - - /** - * Fletcher-16 Checksum operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runFletcher16: function(input, args) { - let a = 0, - b = 0; - - for (let i = 0; i < input.length; i++) { - a = (a + input[i]) % 0xff; - b = (b + a) % 0xff; - } - - return Utils.hex(((b << 8) | a) >>> 0, 4); - }, - - - /** - * Fletcher-32 Checksum operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runFletcher32: function(input, args) { - let a = 0, - b = 0; - - for (let i = 0; i < input.length; i++) { - a = (a + input[i]) % 0xffff; - b = (b + a) % 0xffff; - } - - return Utils.hex(((b << 16) | a) >>> 0, 8); - }, - - - /** - * Fletcher-64 Checksum operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runFletcher64: function(input, args) { - let a = 0, - b = 0; - - for (let i = 0; i < input.length; i++) { - a = (a + input[i]) % 0xffffffff; - b = (b + a) % 0xffffffff; - } - - return Utils.hex(b >>> 0, 8) + Utils.hex(a >>> 0, 8); - }, - - - /** - * Adler-32 Checksum operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runAdler32: function(input, args) { - let MOD_ADLER = 65521, - a = 1, - b = 0; - - for (let i = 0; i < input.length; i++) { - a += input[i]; - b += a; - } - - a %= MOD_ADLER; - b %= MOD_ADLER; - - return Utils.hex(((b << 16) | a) >>> 0, 8); - }, - - - /** - * CRC-32 Checksum operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runCRC32: function(input, args) { - return CRC.crc32(input); - }, - - - /** - * CRC-16 Checksum operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runCRC16: function(input, args) { - return CRC.crc16(input); - }, - - - /** - * TCP/IP Checksum operation. - * - * @author GCHQ Contributor [1] - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - * - * @example - * // returns '3f2c' - * Checksum.runTcpIp([0x45,0x00,0x00,0x87,0xa3,0x1b,0x40,0x00,0x40,0x06, - * 0x00,0x00,0xac,0x11,0x00,0x04,0xac,0x11,0x00,0x03]) - * - * // returns 'a249' - * Checksum.runTcpIp([0x45,0x00,0x01,0x11,0x3f,0x74,0x40,0x00,0x40,0x06, - * 0x00,0x00,0xac,0x11,0x00,0x03,0xac,0x11,0x00,0x04]) - */ - runTCPIP: function(input, args) { - let csum = 0; - - for (let i = 0; i < input.length; i++) { - if (i % 2 === 0) { - csum += (input[i] << 8); - } else { - csum += input[i]; - } - } - - csum = (csum >> 16) + (csum & 0xffff); - - return Utils.hex(0xffff - csum); - }, - -}; - -export default Checksum; diff --git a/src/core/operations/legacy/Compress.js b/src/core/operations/legacy/Compress.js deleted file mode 100755 index 2313541d..00000000 --- a/src/core/operations/legacy/Compress.js +++ /dev/null @@ -1,243 +0,0 @@ -import Utils from "../Utils.js"; -import bzip2 from "exports-loader?bzip2!../vendor/bzip2.js"; - - -/** - * Compression operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Compress = { - - /** - * Bzip2 Decompress operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runBzip2Decompress: function(input, args) { - let compressed = new Uint8Array(input), - bzip2Reader, - plain = ""; - - bzip2Reader = bzip2.array(compressed); - plain = bzip2.simple(bzip2Reader); - return plain; - }, - - - /** - * @constant - * @default - */ - TAR_FILENAME: "file.txt", - - - /** - * Tar pack operation. - * - * @author tlwr [toby@toby.codes] - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runTar: function(input, args) { - const Tarball = function() { - this.bytes = new Array(512); - this.position = 0; - }; - - Tarball.prototype.addEmptyBlock = function() { - const filler = new Array(512); - filler.fill(0); - this.bytes = this.bytes.concat(filler); - }; - - Tarball.prototype.writeBytes = function(bytes) { - const self = this; - - if (this.position + bytes.length > this.bytes.length) { - this.addEmptyBlock(); - } - - Array.prototype.forEach.call(bytes, function(b, i) { - if (typeof b.charCodeAt !== "undefined") { - b = b.charCodeAt(); - } - - self.bytes[self.position] = b; - self.position += 1; - }); - }; - - Tarball.prototype.writeEndBlocks = function() { - const numEmptyBlocks = 2; - for (let i = 0; i < numEmptyBlocks; i++) { - this.addEmptyBlock(); - } - }; - - const fileSize = input.length.toString(8).padStart(11, "0"); - const currentUnixTimestamp = Math.floor(Date.now() / 1000); - const lastModTime = currentUnixTimestamp.toString(8).padStart(11, "0"); - - const file = { - fileName: Utils.padBytesRight(args[0], 100), - fileMode: Utils.padBytesRight("0000664", 8), - ownerUID: Utils.padBytesRight("0", 8), - ownerGID: Utils.padBytesRight("0", 8), - size: Utils.padBytesRight(fileSize, 12), - lastModTime: Utils.padBytesRight(lastModTime, 12), - checksum: " ", - type: "0", - linkedFileName: Utils.padBytesRight("", 100), - USTARFormat: Utils.padBytesRight("ustar", 6), - version: "00", - ownerUserName: Utils.padBytesRight("", 32), - ownerGroupName: Utils.padBytesRight("", 32), - deviceMajor: Utils.padBytesRight("", 8), - deviceMinor: Utils.padBytesRight("", 8), - fileNamePrefix: Utils.padBytesRight("", 155), - }; - - let checksum = 0; - for (const key in file) { - const bytes = file[key]; - Array.prototype.forEach.call(bytes, function(b) { - if (typeof b.charCodeAt !== "undefined") { - checksum += b.charCodeAt(); - } else { - checksum += b; - } - }); - } - checksum = Utils.padBytesRight(checksum.toString(8).padStart(7, "0"), 8); - file.checksum = checksum; - - const tarball = new Tarball(); - tarball.writeBytes(file.fileName); - tarball.writeBytes(file.fileMode); - tarball.writeBytes(file.ownerUID); - tarball.writeBytes(file.ownerGID); - tarball.writeBytes(file.size); - tarball.writeBytes(file.lastModTime); - tarball.writeBytes(file.checksum); - tarball.writeBytes(file.type); - tarball.writeBytes(file.linkedFileName); - tarball.writeBytes(file.USTARFormat); - tarball.writeBytes(file.version); - tarball.writeBytes(file.ownerUserName); - tarball.writeBytes(file.ownerGroupName); - tarball.writeBytes(file.deviceMajor); - tarball.writeBytes(file.deviceMinor); - tarball.writeBytes(file.fileNamePrefix); - tarball.writeBytes(Utils.padBytesRight("", 12)); - tarball.writeBytes(input); - tarball.writeEndBlocks(); - - return tarball.bytes; - }, - - - /** - * Untar unpack operation. - * - * @author tlwr [toby@toby.codes] - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {html} - */ - runUntar: function(input, args) { - const Stream = function(input) { - this.bytes = input; - this.position = 0; - }; - - Stream.prototype.getBytes = function(bytesToGet) { - const newPosition = this.position + bytesToGet; - const bytes = this.bytes.slice(this.position, newPosition); - this.position = newPosition; - return bytes; - }; - - Stream.prototype.readString = function(numBytes) { - let result = ""; - for (let i = this.position; i < this.position + numBytes; i++) { - const currentByte = this.bytes[i]; - if (currentByte === 0) break; - result += String.fromCharCode(currentByte); - } - this.position += numBytes; - return result; - }; - - Stream.prototype.readInt = function(numBytes, base) { - const string = this.readString(numBytes); - return parseInt(string, base); - }; - - Stream.prototype.hasMore = function() { - return this.position < this.bytes.length; - }; - - let stream = new Stream(input), - files = []; - - while (stream.hasMore()) { - const dataPosition = stream.position + 512; - - const file = { - fileName: stream.readString(100), - fileMode: stream.readString(8), - ownerUID: stream.readString(8), - ownerGID: stream.readString(8), - size: parseInt(stream.readString(12), 8), // Octal - lastModTime: new Date(1000 * stream.readInt(12, 8)), // Octal - checksum: stream.readString(8), - type: stream.readString(1), - linkedFileName: stream.readString(100), - USTARFormat: stream.readString(6).indexOf("ustar") >= 0, - }; - - if (file.USTARFormat) { - file.version = stream.readString(2); - file.ownerUserName = stream.readString(32); - file.ownerGroupName = stream.readString(32); - file.deviceMajor = stream.readString(8); - file.deviceMinor = stream.readString(8); - file.filenamePrefix = stream.readString(155); - } - - stream.position = dataPosition; - - if (file.type === "0") { - // File - files.push(file); - let endPosition = stream.position + file.size; - if (file.size % 512 !== 0) { - endPosition += 512 - (file.size % 512); - } - - file.bytes = stream.getBytes(file.size); - file.contents = Utils.byteArrayToUtf8(file.bytes); - stream.position = endPosition; - } else if (file.type === "5") { - // Directory - files.push(file); - } else { - // Symlink or empty bytes - } - } - - return Utils.displayFilesAsHTML(files); - }, -}; - -export default Compress; diff --git a/src/core/operations/legacy/Convert.js b/src/core/operations/legacy/Convert.js deleted file mode 100755 index a79a5c3f..00000000 --- a/src/core/operations/legacy/Convert.js +++ /dev/null @@ -1,413 +0,0 @@ -/** - * Unit conversion operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Convert = { - - /** - * @constant - * @default - */ - DISTANCE_UNITS: [ - "[Metric]", "Nanometres (nm)", "Micrometres (µm)", "Millimetres (mm)", "Centimetres (cm)", "Metres (m)", "Kilometers (km)", "[/Metric]", - "[Imperial]", "Thou (th)", "Inches (in)", "Feet (ft)", "Yards (yd)", "Chains (ch)", "Furlongs (fur)", "Miles (mi)", "Leagues (lea)", "[/Imperial]", - "[Maritime]", "Fathoms (ftm)", "Cables", "Nautical miles", "[/Maritime]", - "[Comparisons]", "Cars (4m)", "Buses (8.4m)", "American football fields (91m)", "Football pitches (105m)", "[/Comparisons]", - "[Astronomical]", "Earth-to-Moons", "Earth's equators", "Astronomical units (au)", "Light-years (ly)", "Parsecs (pc)", "[/Astronomical]", - ], - /** - * @constant - * @default - */ - DISTANCE_FACTOR: { // Multiples of a metre - "Nanometres (nm)": 1e-9, - "Micrometres (µm)": 1e-6, - "Millimetres (mm)": 1e-3, - "Centimetres (cm)": 1e-2, - "Metres (m)": 1, - "Kilometers (km)": 1e3, - - "Thou (th)": 0.0000254, - "Inches (in)": 0.0254, - "Feet (ft)": 0.3048, - "Yards (yd)": 0.9144, - "Chains (ch)": 20.1168, - "Furlongs (fur)": 201.168, - "Miles (mi)": 1609.344, - "Leagues (lea)": 4828.032, - - "Fathoms (ftm)": 1.853184, - "Cables": 185.3184, - "Nautical miles": 1853.184, - - "Cars (4m)": 4, - "Buses (8.4m)": 8.4, - "American football fields (91m)": 91, - "Football pitches (105m)": 105, - - "Earth-to-Moons": 380000000, - "Earth's equators": 40075016.686, - "Astronomical units (au)": 149597870700, - "Light-years (ly)": 9460730472580800, - "Parsecs (pc)": 3.0856776e16 - }, - - /** - * Convert distance operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runDistance: function (input, args) { - let inputUnits = args[0], - outputUnits = args[1]; - - input = input.times(Convert.DISTANCE_FACTOR[inputUnits]); - return input.div(Convert.DISTANCE_FACTOR[outputUnits]); - }, - - - /** - * @constant - * @default - */ - DATA_UNITS: [ - "Bits (b)", "Nibbles", "Octets", "Bytes (B)", - "[Binary bits (2^n)]", "Kibibits (Kib)", "Mebibits (Mib)", "Gibibits (Gib)", "Tebibits (Tib)", "Pebibits (Pib)", "Exbibits (Eib)", "Zebibits (Zib)", "Yobibits (Yib)", "[/Binary bits (2^n)]", - "[Decimal bits (10^n)]", "Decabits", "Hectobits", "Kilobits (kb)", "Megabits (Mb)", "Gigabits (Gb)", "Terabits (Tb)", "Petabits (Pb)", "Exabits (Eb)", "Zettabits (Zb)", "Yottabits (Yb)", "[/Decimal bits (10^n)]", - "[Binary bytes (8 x 2^n)]", "Kibibytes (KiB)", "Mebibytes (MiB)", "Gibibytes (GiB)", "Tebibytes (TiB)", "Pebibytes (PiB)", "Exbibytes (EiB)", "Zebibytes (ZiB)", "Yobibytes (YiB)", "[/Binary bytes (8 x 2^n)]", - "[Decimal bytes (8 x 10^n)]", "Kilobytes (KB)", "Megabytes (MB)", "Gigabytes (GB)", "Terabytes (TB)", "Petabytes (PB)", "Exabytes (EB)", "Zettabytes (ZB)", "Yottabytes (YB)", "[/Decimal bytes (8 x 10^n)]" - ], - /** - * @constant - * @default - */ - DATA_FACTOR: { // Multiples of a bit - "Bits (b)": 1, - "Nibbles": 4, - "Octets": 8, - "Bytes (B)": 8, - - // Binary bits (2^n) - "Kibibits (Kib)": 1024, - "Mebibits (Mib)": 1048576, - "Gibibits (Gib)": 1073741824, - "Tebibits (Tib)": 1099511627776, - "Pebibits (Pib)": 1125899906842624, - "Exbibits (Eib)": 1152921504606846976, - "Zebibits (Zib)": 1180591620717411303424, - "Yobibits (Yib)": 1208925819614629174706176, - - // Decimal bits (10^n) - "Decabits": 10, - "Hectobits": 100, - "Kilobits (Kb)": 1e3, - "Megabits (Mb)": 1e6, - "Gigabits (Gb)": 1e9, - "Terabits (Tb)": 1e12, - "Petabits (Pb)": 1e15, - "Exabits (Eb)": 1e18, - "Zettabits (Zb)": 1e21, - "Yottabits (Yb)": 1e24, - - // Binary bytes (8 x 2^n) - "Kibibytes (KiB)": 8192, - "Mebibytes (MiB)": 8388608, - "Gibibytes (GiB)": 8589934592, - "Tebibytes (TiB)": 8796093022208, - "Pebibytes (PiB)": 9007199254740992, - "Exbibytes (EiB)": 9223372036854775808, - "Zebibytes (ZiB)": 9444732965739290427392, - "Yobibytes (YiB)": 9671406556917033397649408, - - // Decimal bytes (8 x 10^n) - "Kilobytes (KB)": 8e3, - "Megabytes (MB)": 8e6, - "Gigabytes (GB)": 8e9, - "Terabytes (TB)": 8e12, - "Petabytes (PB)": 8e15, - "Exabytes (EB)": 8e18, - "Zettabytes (ZB)": 8e21, - "Yottabytes (YB)": 8e24, - }, - - /** - * Convert data units operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runDataSize: function (input, args) { - let inputUnits = args[0], - outputUnits = args[1]; - - input = input.times(Convert.DATA_FACTOR[inputUnits]); - return input.div(Convert.DATA_FACTOR[outputUnits]); - }, - - - /** - * @constant - * @default - */ - AREA_UNITS: [ - "[Metric]", "Square metre (sq m)", "Square kilometre (sq km)", "Centiare (ca)", "Deciare (da)", "Are (a)", "Decare (daa)", "Hectare (ha)", "[/Metric]", - "[Imperial]", "Square inch (sq in)", "Square foot (sq ft)", "Square yard (sq yd)", "Square mile (sq mi)", "Perch (sq per)", "Rood (ro)", "International acre (ac)", "[/Imperial]", - "[US customary units]", "US survey acre (ac)", "US survey square mile (sq mi)", "US survey township", "[/US customary units]", - "[Nuclear physics]", "Yoctobarn (yb)", "Zeptobarn (zb)", "Attobarn (ab)", "Femtobarn (fb)", "Picobarn (pb)", "Nanobarn (nb)", "Microbarn (μb)", "Millibarn (mb)", "Barn (b)", "Kilobarn (kb)", "Megabarn (Mb)", "Outhouse", "Shed", "Planck area", "[/Nuclear physics]", - "[Comparisons]", "Washington D.C.", "Isle of Wight", "Wales", "Texas", "[/Comparisons]", - ], - /** - * @constant - * @default - */ - AREA_FACTOR: { // Multiples of a square metre - // Metric - "Square metre (sq m)": 1, - "Square kilometre (sq km)": 1e6, - - "Centiare (ca)": 1, - "Deciare (da)": 10, - "Are (a)": 100, - "Decare (daa)": 1e3, - "Hectare (ha)": 1e4, - - // Imperial - "Square inch (sq in)": 0.00064516, - "Square foot (sq ft)": 0.09290304, - "Square yard (sq yd)": 0.83612736, - "Square mile (sq mi)": 2589988.110336, - "Perch (sq per)": 42.21, - "Rood (ro)": 1011, - "International acre (ac)": 4046.8564224, - - // US customary units - "US survey acre (ac)": 4046.87261, - "US survey square mile (sq mi)": 2589998.470305239, - "US survey township": 93239944.9309886, - - // Nuclear physics - "Yoctobarn (yb)": 1e-52, - "Zeptobarn (zb)": 1e-49, - "Attobarn (ab)": 1e-46, - "Femtobarn (fb)": 1e-43, - "Picobarn (pb)": 1e-40, - "Nanobarn (nb)": 1e-37, - "Microbarn (μb)": 1e-34, - "Millibarn (mb)": 1e-31, - "Barn (b)": 1e-28, - "Kilobarn (kb)": 1e-25, - "Megabarn (Mb)": 1e-22, - - "Planck area": 2.6e-70, - "Shed": 1e-52, - "Outhouse": 1e-34, - - // Comparisons - "Washington D.C.": 176119191.502848, - "Isle of Wight": 380000000, - "Wales": 20779000000, - "Texas": 696241000000, - }, - - /** - * Convert area operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runArea: function (input, args) { - let inputUnits = args[0], - outputUnits = args[1]; - - input = input.times(Convert.AREA_FACTOR[inputUnits]); - return input.div(Convert.AREA_FACTOR[outputUnits]); - }, - - - /** - * @constant - * @default - */ - MASS_UNITS: [ - "[Metric]", "Yoctogram (yg)", "Zeptogram (zg)", "Attogram (ag)", "Femtogram (fg)", "Picogram (pg)", "Nanogram (ng)", "Microgram (μg)", "Milligram (mg)", "Centigram (cg)", "Decigram (dg)", "Gram (g)", "Decagram (dag)", "Hectogram (hg)", "Kilogram (kg)", "Megagram (Mg)", "Tonne (t)", "Gigagram (Gg)", "Teragram (Tg)", "Petagram (Pg)", "Exagram (Eg)", "Zettagram (Zg)", "Yottagram (Yg)", "[/Metric]", - "[Imperial Avoirdupois]", "Grain (gr)", "Dram (dr)", "Ounce (oz)", "Pound (lb)", "Nail", "Stone (st)", "Quarter (gr)", "Tod", "US hundredweight (cwt)", "Imperial hundredweight (cwt)", "US ton (t)", "Imperial ton (t)", "[/Imperial Avoirdupois]", - "[Imperial Troy]", "Grain (gr)", "Pennyweight (dwt)", "Troy dram (dr t)", "Troy ounce (oz t)", "Troy pound (lb t)", "Mark", "[/Imperial Troy]", - "[Archaic]", "Wey", "Wool wey", "Suffolk wey", "Wool sack", "Coal sack", "Load", "Last", "Flax or feather last", "Gunpowder last", "Picul", "Rice last", "[/Archaic]", - "[Comparisons]", "Big Ben (14 tonnes)", "Blue whale (180 tonnes)", "International Space Station (417 tonnes)", "Space Shuttle (2,041 tonnes)", "RMS Titanic (52,000 tonnes)", "Great Pyramid of Giza (6,000,000 tonnes)", "Earth's oceans (1.4 yottagrams)", "[/Comparisons]", - "[Astronomical]", "A teaspoon of neutron star (5,500 million tonnes)", "Lunar mass (ML)", "Earth mass (M⊕)", "Jupiter mass (MJ)", "Solar mass (M☉)", "Sagittarius A* (7.5 x 10^36 kgs-ish)", "Milky Way galaxy (1.2 x 10^42 kgs)", "The observable universe (1.45 x 10^53 kgs)", "[/Astronomical]", - ], - /** - * @constant - * @default - */ - MASS_FACTOR: { // Multiples of a gram - // Metric - "Yoctogram (yg)": 1e-24, - "Zeptogram (zg)": 1e-21, - "Attogram (ag)": 1e-18, - "Femtogram (fg)": 1e-15, - "Picogram (pg)": 1e-12, - "Nanogram (ng)": 1e-9, - "Microgram (μg)": 1e-6, - "Milligram (mg)": 1e-3, - "Centigram (cg)": 1e-2, - "Decigram (dg)": 1e-1, - "Gram (g)": 1, - "Decagram (dag)": 10, - "Hectogram (hg)": 100, - "Kilogram (kg)": 1000, - "Megagram (Mg)": 1e6, - "Tonne (t)": 1e6, - "Gigagram (Gg)": 1e9, - "Teragram (Tg)": 1e12, - "Petagram (Pg)": 1e15, - "Exagram (Eg)": 1e18, - "Zettagram (Zg)": 1e21, - "Yottagram (Yg)": 1e24, - - // Imperial Avoirdupois - "Grain (gr)": 64.79891e-3, - "Dram (dr)": 1.7718451953125, - "Ounce (oz)": 28.349523125, - "Pound (lb)": 453.59237, - "Nail": 3175.14659, - "Stone (st)": 6.35029318e3, - "Quarter (gr)": 12700.58636, - "Tod": 12700.58636, - "US hundredweight (cwt)": 45.359237e3, - "Imperial hundredweight (cwt)": 50.80234544e3, - "US ton (t)": 907.18474e3, - "Imperial ton (t)": 1016.0469088e3, - - // Imperial Troy - "Pennyweight (dwt)": 1.55517384, - "Troy dram (dr t)": 3.8879346, - "Troy ounce (oz t)": 31.1034768, - "Troy pound (lb t)": 373.2417216, - "Mark": 248.8278144, - - // Archaic - "Wey": 76.5e3, - "Wool wey": 101.7e3, - "Suffolk wey": 161.5e3, - "Wool sack": 153000, - "Coal sack": 50.80234544e3, - "Load": 918000, - "Last": 1836000, - "Flax or feather last": 770e3, - "Gunpowder last": 1090e3, - "Picul": 60.478982e3, - "Rice last": 1200e3, - - // Comparisons - "Big Ben (14 tonnes)": 14e6, - "Blue whale (180 tonnes)": 180e6, - "International Space Station (417 tonnes)": 417e6, - "Space Shuttle (2,041 tonnes)": 2041e6, - "RMS Titanic (52,000 tonnes)": 52000e6, - "Great Pyramid of Giza (6,000,000 tonnes)": 6e12, - "Earth's oceans (1.4 yottagrams)": 1.4e24, - - // Astronomical - "A teaspoon of neutron star (5,500 million tonnes)": 5.5e15, - "Lunar mass (ML)": 7.342e25, - "Earth mass (M⊕)": 5.97219e27, - "Jupiter mass (MJ)": 1.8981411476999997e30, - "Solar mass (M☉)": 1.98855e33, - "Sagittarius A* (7.5 x 10^36 kgs-ish)": 7.5e39, - "Milky Way galaxy (1.2 x 10^42 kgs)": 1.2e45, - "The observable universe (1.45 x 10^53 kgs)": 1.45e56, - }, - - /** - * Convert mass operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runMass: function (input, args) { - let inputUnits = args[0], - outputUnits = args[1]; - - input = input.times(Convert.MASS_FACTOR[inputUnits]); - return input.div(Convert.MASS_FACTOR[outputUnits]); - }, - - - /** - * @constant - * @default - */ - SPEED_UNITS: [ - "[Metric]", "Metres per second (m/s)", "Kilometres per hour (km/h)", "[/Metric]", - "[Imperial]", "Miles per hour (mph)", "Knots (kn)", "[/Imperial]", - "[Comparisons]", "Human hair growth rate", "Bamboo growth rate", "World's fastest snail", "Usain Bolt's top speed", "Jet airliner cruising speed", "Concorde", "SR-71 Blackbird", "Space Shuttle", "International Space Station", "[/Comparisons]", - "[Scientific]", "Sound in standard atmosphere", "Sound in water", "Lunar escape velocity", "Earth escape velocity", "Earth's solar orbit", "Solar system's Milky Way orbit", "Milky Way relative to the cosmic microwave background", "Solar escape velocity", "Neutron star escape velocity (0.3c)", "Light in a diamond (0.4136c)", "Signal in an optical fibre (0.667c)", "Light (c)", "[/Scientific]", - ], - /** - * @constant - * @default - */ - SPEED_FACTOR: { // Multiples of m/s - // Metric - "Metres per second (m/s)": 1, - "Kilometres per hour (km/h)": 0.2778, - - // Imperial - "Miles per hour (mph)": 0.44704, - "Knots (kn)": 0.5144, - - // Comparisons - "Human hair growth rate": 4.8e-9, - "Bamboo growth rate": 1.4e-5, - "World's fastest snail": 0.00275, - "Usain Bolt's top speed": 12.42, - "Jet airliner cruising speed": 250, - "Concorde": 603, - "SR-71 Blackbird": 981, - "Space Shuttle": 1400, - "International Space Station": 7700, - - // Scientific - "Sound in standard atmosphere": 340.3, - "Sound in water": 1500, - "Lunar escape velocity": 2375, - "Earth escape velocity": 11200, - "Earth's solar orbit": 29800, - "Solar system's Milky Way orbit": 200000, - "Milky Way relative to the cosmic microwave background": 552000, - "Solar escape velocity": 617700, - "Neutron star escape velocity (0.3c)": 100000000, - "Light in a diamond (0.4136c)": 124000000, - "Signal in an optical fibre (0.667c)": 200000000, - "Light (c)": 299792458, - }, - - /** - * Convert speed operation. - * - * @param {BigNumber} input - * @param {Object[]} args - * @returns {BigNumber} - */ - runSpeed: function (input, args) { - let inputUnits = args[0], - outputUnits = args[1]; - - input = input.times(Convert.SPEED_FACTOR[inputUnits]); - return input.div(Convert.SPEED_FACTOR[outputUnits]); - }, - -}; - -export default Convert; diff --git a/src/core/operations/legacy/DateTime.js b/src/core/operations/legacy/DateTime.js deleted file mode 100755 index b117a2ca..00000000 --- a/src/core/operations/legacy/DateTime.js +++ /dev/null @@ -1,484 +0,0 @@ -import moment from "moment-timezone"; - - -/** - * Date and time operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const DateTime = { - - /** - * @constant - * @default - */ - UNITS: ["Seconds (s)", "Milliseconds (ms)", "Microseconds (μs)", "Nanoseconds (ns)"], - - /** - * From UNIX Timestamp operation. - * - * @param {number} input - * @param {Object[]} args - * @returns {string} - */ - runFromUnixTimestamp: function(input, args) { - let units = args[0], - d; - - input = parseFloat(input); - - if (units === "Seconds (s)") { - d = moment.unix(input); - return d.tz("UTC").format("ddd D MMMM YYYY HH:mm:ss") + " UTC"; - } else if (units === "Milliseconds (ms)") { - d = moment(input); - return d.tz("UTC").format("ddd D MMMM YYYY HH:mm:ss.SSS") + " UTC"; - } else if (units === "Microseconds (μs)") { - d = moment(input / 1000); - return d.tz("UTC").format("ddd D MMMM YYYY HH:mm:ss.SSS") + " UTC"; - } else if (units === "Nanoseconds (ns)") { - d = moment(input / 1000000); - return d.tz("UTC").format("ddd D MMMM YYYY HH:mm:ss.SSS") + " UTC"; - } else { - throw "Unrecognised unit"; - } - }, - - - /** - * @constant - * @default - */ - TREAT_AS_UTC: true, - - /** - * To UNIX Timestamp operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToUnixTimestamp: function(input, args) { - const units = args[0], - treatAsUTC = args[1], - showDateTime = args[2], - d = treatAsUTC ? moment.utc(input) : moment(input); - - let result = ""; - - if (units === "Seconds (s)") { - result = d.unix(); - } else if (units === "Milliseconds (ms)") { - result = d.valueOf(); - } else if (units === "Microseconds (μs)") { - result = d.valueOf() * 1000; - } else if (units === "Nanoseconds (ns)") { - result = d.valueOf() * 1000000; - } else { - throw "Unrecognised unit"; - } - - return showDateTime ? `${result} (${d.tz("UTC").format("ddd D MMMM YYYY HH:mm:ss")} UTC)` : result.toString(); - }, - - - /** - * @constant - * @default - */ - DATETIME_FORMATS: [ - { - name: "Standard date and time", - value: "DD/MM/YYYY HH:mm:ss" - }, - { - name: "American-style date and time", - value: "MM/DD/YYYY HH:mm:ss" - }, - { - name: "International date and time", - value: "YYYY-MM-DD HH:mm:ss" - }, - { - name: "Verbose date and time", - value: "dddd Do MMMM YYYY HH:mm:ss Z z" - }, - { - name: "UNIX timestamp (seconds)", - value: "X" - }, - { - name: "UNIX timestamp offset (milliseconds)", - value: "x" - }, - { - name: "Automatic", - value: "" - }, - ], - /** - * @constant - * @default - */ - INPUT_FORMAT_STRING: "DD/MM/YYYY HH:mm:ss", - /** - * @constant - * @default - */ - OUTPUT_FORMAT_STRING: "dddd Do MMMM YYYY HH:mm:ss Z z", - /** - * @constant - * @default - */ - TIMEZONES: ["UTC"].concat(moment.tz.names()), - - /** - * Translate DateTime Format operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runTranslateFormat: function(input, args) { - let inputFormat = args[1], - inputTimezone = args[2], - outputFormat = args[3], - outputTimezone = args[4], - date; - - try { - date = moment.tz(input, inputFormat, inputTimezone); - if (!date || date.format() === "Invalid date") throw Error; - } catch (err) { - return "Invalid format.\n\n" + DateTime.FORMAT_EXAMPLES; - } - - return date.tz(outputTimezone).format(outputFormat); - }, - - - /** - * Parse DateTime operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runParse: function(input, args) { - let inputFormat = args[1], - inputTimezone = args[2], - date, - output = ""; - - try { - date = moment.tz(input, inputFormat, inputTimezone); - if (!date || date.format() === "Invalid date") throw Error; - } catch (err) { - return "Invalid format.\n\n" + DateTime.FORMAT_EXAMPLES; - } - - output += "Date: " + date.format("dddd Do MMMM YYYY") + - "\nTime: " + date.format("HH:mm:ss") + - "\nPeriod: " + date.format("A") + - "\nTimezone: " + date.format("z") + - "\nUTC offset: " + date.format("ZZ") + - "\n\nDaylight Saving Time: " + date.isDST() + - "\nLeap year: " + date.isLeapYear() + - "\nDays in this month: " + date.daysInMonth() + - "\n\nDay of year: " + date.dayOfYear() + - "\nWeek number: " + date.weekYear() + - "\nQuarter: " + date.quarter(); - - return output; - }, - - - /** - * Sleep operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {ArrayBuffer} - */ - runSleep: async function(input, args) { - const ms = args[0]; - await new Promise(r => setTimeout(r, ms)); - return input; - }, - - - /** - * @constant - */ - FORMAT_EXAMPLES: `Format string tokens: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CategoryTokenOutput
MonthM1 2 ... 11 12
Mo1st 2nd ... 11th 12th
MM01 02 ... 11 12
MMMJan Feb ... Nov Dec
MMMMJanuary February ... November December
QuarterQ1 2 3 4
Day of MonthD1 2 ... 30 31
Do1st 2nd ... 30th 31st
DD01 02 ... 30 31
Day of YearDDD1 2 ... 364 365
DDDo1st 2nd ... 364th 365th
DDDD001 002 ... 364 365
Day of Weekd0 1 ... 5 6
do0th 1st ... 5th 6th
ddSu Mo ... Fr Sa
dddSun Mon ... Fri Sat
ddddSunday Monday ... Friday Saturday
Day of Week (Locale)e0 1 ... 5 6
Day of Week (ISO)E1 2 ... 6 7
Week of Yearw1 2 ... 52 53
wo1st 2nd ... 52nd 53rd
ww01 02 ... 52 53
Week of Year (ISO)W1 2 ... 52 53
Wo1st 2nd ... 52nd 53rd
WW01 02 ... 52 53
YearYY70 71 ... 29 30
YYYY1970 1971 ... 2029 2030
Week Yeargg70 71 ... 29 30
gggg1970 1971 ... 2029 2030
Week Year (ISO)GG70 71 ... 29 30
GGGG1970 1971 ... 2029 2030
AM/PMAAM PM
aam pm
HourH0 1 ... 22 23
HH00 01 ... 22 23
h1 2 ... 11 12
hh01 02 ... 11 12
Minutem0 1 ... 58 59
mm00 01 ... 58 59
Seconds0 1 ... 58 59
ss00 01 ... 58 59
Fractional SecondS0 1 ... 8 9
SS00 01 ... 98 99
SSS000 001 ... 998 999
SSSS ... SSSSSSSSS000[0..] 001[0..] ... 998[0..] 999[0..]
Timezonez or zzEST CST ... MST PST
Z-07:00 -06:00 ... +06:00 +07:00
ZZ-0700 -0600 ... +0600 +0700
Unix TimestampX1360013296
Unix Millisecond Timestampx1360013296123
`, - -}; - -export default DateTime; diff --git a/src/core/operations/legacy/Diff.js b/src/core/operations/legacy/Diff.js deleted file mode 100644 index afa00c37..00000000 --- a/src/core/operations/legacy/Diff.js +++ /dev/null @@ -1,94 +0,0 @@ -import Utils from "../Utils.js"; -import * as JsDiff from "diff"; - - -/** - * Diff operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Diff = { - - /** - * @constant - * @default - */ - DIFF_SAMPLE_DELIMITER: "\\n\\n", - /** - * @constant - * @default - */ - DIFF_BY: ["Character", "Word", "Line", "Sentence", "CSS", "JSON"], - - /** - * Diff operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runDiff: function(input, args) { - let sampleDelim = args[0], - diffBy = args[1], - showAdded = args[2], - showRemoved = args[3], - ignoreWhitespace = args[4], - samples = input.split(sampleDelim), - output = "", - diff; - - if (!samples || samples.length !== 2) { - return "Incorrect number of samples, perhaps you need to modify the sample delimiter or add more samples?"; - } - - switch (diffBy) { - case "Character": - diff = JsDiff.diffChars(samples[0], samples[1]); - break; - case "Word": - if (ignoreWhitespace) { - diff = JsDiff.diffWords(samples[0], samples[1]); - } else { - diff = JsDiff.diffWordsWithSpace(samples[0], samples[1]); - } - break; - case "Line": - if (ignoreWhitespace) { - diff = JsDiff.diffTrimmedLines(samples[0], samples[1]); - } else { - diff = JsDiff.diffLines(samples[0], samples[1]); - } - break; - case "Sentence": - diff = JsDiff.diffSentences(samples[0], samples[1]); - break; - case "CSS": - diff = JsDiff.diffCss(samples[0], samples[1]); - break; - case "JSON": - diff = JsDiff.diffJson(samples[0], samples[1]); - break; - default: - return "Invalid 'Diff by' option."; - } - - for (let i = 0; i < diff.length; i++) { - if (diff[i].added) { - if (showAdded) output += "" + Utils.escapeHtml(diff[i].value) + ""; - } else if (diff[i].removed) { - if (showRemoved) output += "" + Utils.escapeHtml(diff[i].value) + ""; - } else { - output += Utils.escapeHtml(diff[i].value); - } - } - - return output; - }, - -}; - -export default Diff; diff --git a/src/core/operations/legacy/Endian.js b/src/core/operations/legacy/Endian.js deleted file mode 100755 index a2ec7703..00000000 --- a/src/core/operations/legacy/Endian.js +++ /dev/null @@ -1,100 +0,0 @@ -import Utils from "../Utils.js"; -import {toHex, fromHex} from "../lib/Hex"; - - -/** - * Endian operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Endian = { - - /** - * @constant - * @default - */ - DATA_FORMAT: ["Hex", "Raw"], - /** - * @constant - * @default - */ - WORD_LENGTH: 4, - /** - * @constant - * @default - */ - PAD_INCOMPLETE_WORDS: true, - - /** - * Swap endianness operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSwapEndianness: function(input, args) { - let dataFormat = args[0], - wordLength = args[1], - padIncompleteWords = args[2], - data = [], - result = [], - words = [], - i = 0, - j = 0; - - if (wordLength <= 0) { - return "Word length must be greater than 0"; - } - - // Convert input to raw data based on specified data format - switch (dataFormat) { - case "Hex": - data = fromHex(input); - break; - case "Raw": - data = Utils.strToByteArray(input); - break; - default: - data = input; - } - - // Split up into words - for (i = 0; i < data.length; i += wordLength) { - const word = data.slice(i, i + wordLength); - - // Pad word if too short - if (padIncompleteWords && word.length < wordLength){ - for (j = word.length; j < wordLength; j++) { - word.push(0); - } - } - - words.push(word); - } - - // Swap endianness and flatten - for (i = 0; i < words.length; i++) { - j = words[i].length; - while (j--) { - result.push(words[i][j]); - } - } - - // Convert data back to specified data format - switch (dataFormat) { - case "Hex": - return toHex(result); - case "Raw": - return Utils.byteArrayToUtf8(result); - default: - return result; - } - }, - -}; - -export default Endian; diff --git a/src/core/operations/legacy/Entropy.js b/src/core/operations/legacy/Entropy.js deleted file mode 100755 index baf9edb3..00000000 --- a/src/core/operations/legacy/Entropy.js +++ /dev/null @@ -1,195 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * Entropy operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Entropy = { - - /** - * @constant - * @default - */ - CHUNK_SIZE: 1000, - - /** - * Entropy operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {html} - */ - runEntropy: function(input, args) { - let chunkSize = args[0], - output = "", - entropy = Entropy._calcEntropy(input); - - output += "Shannon entropy: " + entropy + "\n" + - "

\n" + - "- 0 represents no randomness (i.e. all the bytes in the data have the same value) whereas 8, the maximum, represents a completely random string.\n" + - "- Standard English text usually falls somewhere between 3.5 and 5.\n" + - "- Properly encrypted or compressed data of a reasonable length should have an entropy of over 7.5.\n\n" + - "The following results show the entropy of chunks of the input data. Chunks with particularly high entropy could suggest encrypted or compressed sections.\n\n" + - "
"; - - let chunkEntropy = 0; - if (chunkSize !== 0) { - for (let i = 0; i < input.length; i += chunkSize) { - chunkEntropy = Entropy._calcEntropy(input.slice(i, i+chunkSize)); - output += "Bytes " + i + " to " + (i+chunkSize) + ": " + chunkEntropy + "\n"; - } - } else { - output += "Chunk size cannot be 0."; - } - - return output; - }, - - - /** - * @constant - * @default - */ - FREQ_ZEROS: false, - - /** - * Frequency distribution operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {html} - */ - runFreqDistrib: function (input, args) { - const data = new Uint8Array(input); - if (!data.length) return "No data"; - - let distrib = new Array(256).fill(0), - percentages = new Array(256), - len = data.length, - showZeroes = args[0], - i; - - // Count bytes - for (i = 0; i < len; i++) { - distrib[data[i]]++; - } - - // Calculate percentages - let repr = 0; - for (i = 0; i < 256; i++) { - if (distrib[i] > 0) repr++; - percentages[i] = distrib[i] / len * 100; - } - - // Print - let output = "
" + - "Total data length: " + len + - "\nNumber of bytes represented: " + repr + - "\nNumber of bytes not represented: " + (256-repr) + - "\n\nByte Percentage\n" + - ""; - - for (i = 0; i < 256; i++) { - if (distrib[i] || showZeroes) { - output += " " + Utils.hex(i, 2) + " (" + - (percentages[i].toFixed(2).replace(".00", "") + "%)").padEnd(8, " ") + - Array(Math.ceil(percentages[i])+1).join("|") + "\n"; - } - } - - return output; - }, - - - /** - * Chi Square operation. - * - * @param {ArrayBuffer} data - * @param {Object[]} args - * @returns {number} - */ - runChiSq: function(input, args) { - const data = new Uint8Array(input); - let distArray = new Array(256).fill(0), - total = 0; - - for (let i = 0; i < data.length; i++) { - distArray[data[i]]++; - } - - for (let i = 0; i < distArray.length; i++) { - if (distArray[i] > 0) { - total += Math.pow(distArray[i] - data.length / 256, 2) / (data.length / 256); - } - } - - return total; - }, - - - /** - * Calculates the Shannon entropy for a given chunk of data. - * - * @private - * @param {byteArray} data - * @returns {number} - */ - _calcEntropy: function(data) { - let prob = [], - uniques = data.unique(), - str = Utils.byteArrayToChars(data), - i; - - for (i = 0; i < uniques.length; i++) { - prob.push(str.count(Utils.chr(uniques[i])) / data.length); - } - - let entropy = 0, - p; - - for (i = 0; i < prob.length; i++) { - p = prob[i]; - entropy += p * Math.log(p) / Math.log(2); - } - - return -entropy; - }, - -}; - -export default Entropy; diff --git a/src/core/operations/legacy/FileType.js b/src/core/operations/legacy/FileType.js deleted file mode 100755 index b9d399cd..00000000 --- a/src/core/operations/legacy/FileType.js +++ /dev/null @@ -1,542 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * File type operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const FileType = { - - /** - * Detect File Type operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runDetect: function(input, args) { - const data = new Uint8Array(input), - type = FileType.magicType(data); - - if (!type) { - return "Unknown file type. Have you tried checking the entropy of this data to determine whether it might be encrypted or compressed?"; - } else { - let output = "File extension: " + type.ext + "\n" + - "MIME type: " + type.mime; - - if (type.desc && type.desc.length) { - output += "\nDescription: " + type.desc; - } - - return output; - } - }, - - - /** - * @constant - * @default - */ - IGNORE_COMMON_BYTE_SEQUENCES: true, - - /** - * Scan for Embedded Files operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runScanForEmbeddedFiles: function(input, args) { - let output = "Scanning data for 'magic bytes' which may indicate embedded files. The following results may be false positives and should not be treat as reliable. Any suffiently long file is likely to contain these magic bytes coincidentally.\n", - type, - numFound = 0, - numCommonFound = 0; - const ignoreCommon = args[0], - commonExts = ["ico", "ttf", ""], - data = new Uint8Array(input); - - for (let i = 0; i < data.length; i++) { - type = FileType.magicType(data.slice(i)); - if (type) { - if (ignoreCommon && commonExts.indexOf(type.ext) > -1) { - numCommonFound++; - continue; - } - numFound++; - output += "\nOffset " + i + " (0x" + Utils.hex(i) + "):\n" + - " File extension: " + type.ext + "\n" + - " MIME type: " + type.mime + "\n"; - - if (type.desc && type.desc.length) { - output += " Description: " + type.desc + "\n"; - } - } - } - - if (numFound === 0) { - output += "\nNo embedded files were found."; - } - - if (numCommonFound > 0) { - output += "\n\n" + numCommonFound; - output += numCommonFound === 1 ? - " file type was detected that has a common byte sequence. This is likely to be a false positive." : - " file types were detected that have common byte sequences. These are likely to be false positives."; - output += " Run this operation with the 'Ignore common byte sequences' option unchecked to see details."; - } - - return output; - }, - - - /** - * Given a buffer, detects magic byte sequences at specific positions and returns the - * extension and mime type. - * - * @param {Uint8Array} buf - * @returns {Object} type - * @returns {string} type.ext - File extension - * @returns {string} type.mime - Mime type - * @returns {string} [type.desc] - Description - */ - magicType: function (buf) { - if (!(buf && buf.length > 1)) { - return null; - } - - if (buf[0] === 0xFF && buf[1] === 0xD8 && buf[2] === 0xFF) { - return { - ext: "jpg", - mime: "image/jpeg" - }; - } - - if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4E && buf[3] === 0x47) { - return { - ext: "png", - mime: "image/png" - }; - } - - if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) { - return { - ext: "gif", - mime: "image/gif" - }; - } - - if (buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50) { - return { - ext: "webp", - mime: "image/webp" - }; - } - - // needs to be before `tif` check - if (((buf[0] === 0x49 && buf[1] === 0x49 && buf[2] === 0x2A && buf[3] === 0x0) || (buf[0] === 0x4D && buf[1] === 0x4D && buf[2] === 0x0 && buf[3] === 0x2A)) && buf[8] === 0x43 && buf[9] === 0x52) { - return { - ext: "cr2", - mime: "image/x-canon-cr2" - }; - } - - if ((buf[0] === 0x49 && buf[1] === 0x49 && buf[2] === 0x2A && buf[3] === 0x0) || (buf[0] === 0x4D && buf[1] === 0x4D && buf[2] === 0x0 && buf[3] === 0x2A)) { - return { - ext: "tif", - mime: "image/tiff" - }; - } - - if (buf[0] === 0x42 && buf[1] === 0x4D) { - return { - ext: "bmp", - mime: "image/bmp" - }; - } - - if (buf[0] === 0x49 && buf[1] === 0x49 && buf[2] === 0xBC) { - return { - ext: "jxr", - mime: "image/vnd.ms-photo" - }; - } - - if (buf[0] === 0x38 && buf[1] === 0x42 && buf[2] === 0x50 && buf[3] === 0x53) { - return { - ext: "psd", - mime: "image/vnd.adobe.photoshop" - }; - } - - // needs to be before `zip` check - if (buf[0] === 0x50 && buf[1] === 0x4B && buf[2] === 0x3 && buf[3] === 0x4 && buf[30] === 0x6D && buf[31] === 0x69 && buf[32] === 0x6D && buf[33] === 0x65 && buf[34] === 0x74 && buf[35] === 0x79 && buf[36] === 0x70 && buf[37] === 0x65 && buf[38] === 0x61 && buf[39] === 0x70 && buf[40] === 0x70 && buf[41] === 0x6C && buf[42] === 0x69 && buf[43] === 0x63 && buf[44] === 0x61 && buf[45] === 0x74 && buf[46] === 0x69 && buf[47] === 0x6F && buf[48] === 0x6E && buf[49] === 0x2F && buf[50] === 0x65 && buf[51] === 0x70 && buf[52] === 0x75 && buf[53] === 0x62 && buf[54] === 0x2B && buf[55] === 0x7A && buf[56] === 0x69 && buf[57] === 0x70) { - return { - ext: "epub", - mime: "application/epub+zip" - }; - } - - if (buf[0] === 0x50 && buf[1] === 0x4B && (buf[2] === 0x3 || buf[2] === 0x5 || buf[2] === 0x7) && (buf[3] === 0x4 || buf[3] === 0x6 || buf[3] === 0x8)) { - return { - ext: "zip", - mime: "application/zip" - }; - } - - if (buf[257] === 0x75 && buf[258] === 0x73 && buf[259] === 0x74 && buf[260] === 0x61 && buf[261] === 0x72) { - return { - ext: "tar", - mime: "application/x-tar" - }; - } - - if (buf[0] === 0x52 && buf[1] === 0x61 && buf[2] === 0x72 && buf[3] === 0x21 && buf[4] === 0x1A && buf[5] === 0x7 && (buf[6] === 0x0 || buf[6] === 0x1)) { - return { - ext: "rar", - mime: "application/x-rar-compressed" - }; - } - - if (buf[0] === 0x1F && buf[1] === 0x8B && buf[2] === 0x8) { - return { - ext: "gz", - mime: "application/gzip" - }; - } - - if (buf[0] === 0x42 && buf[1] === 0x5A && buf[2] === 0x68) { - return { - ext: "bz2", - mime: "application/x-bzip2" - }; - } - - if (buf[0] === 0x37 && buf[1] === 0x7A && buf[2] === 0xBC && buf[3] === 0xAF && buf[4] === 0x27 && buf[5] === 0x1C) { - return { - ext: "7z", - mime: "application/x-7z-compressed" - }; - } - - if (buf[0] === 0x78 && buf[1] === 0x01) { - return { - ext: "dmg, zlib", - mime: "application/x-apple-diskimage, application/x-deflate" - }; - } - - if ((buf[0] === 0x0 && buf[1] === 0x0 && buf[2] === 0x0 && (buf[3] === 0x18 || buf[3] === 0x20) && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70) || (buf[0] === 0x33 && buf[1] === 0x67 && buf[2] === 0x70 && buf[3] === 0x35) || (buf[0] === 0x0 && buf[1] === 0x0 && buf[2] === 0x0 && buf[3] === 0x1C && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70 && buf[8] === 0x6D && buf[9] === 0x70 && buf[10] === 0x34 && buf[11] === 0x32 && buf[16] === 0x6D && buf[17] === 0x70 && buf[18] === 0x34 && buf[19] === 0x31 && buf[20] === 0x6D && buf[21] === 0x70 && buf[22] === 0x34 && buf[23] === 0x32 && buf[24] === 0x69 && buf[25] === 0x73 && buf[26] === 0x6F && buf[27] === 0x6D)) { - return { - ext: "mp4", - mime: "video/mp4" - }; - } - - if ((buf[0] === 0x0 && buf[1] === 0x0 && buf[2] === 0x0 && buf[3] === 0x1C && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70 && buf[8] === 0x4D && buf[9] === 0x34 && buf[10] === 0x56)) { - return { - ext: "m4v", - mime: "video/x-m4v" - }; - } - - if (buf[0] === 0x4D && buf[1] === 0x54 && buf[2] === 0x68 && buf[3] === 0x64) { - return { - ext: "mid", - mime: "audio/midi" - }; - } - - // needs to be before the `webm` check - if (buf[31] === 0x6D && buf[32] === 0x61 && buf[33] === 0x74 && buf[34] === 0x72 && buf[35] === 0x6f && buf[36] === 0x73 && buf[37] === 0x6B && buf[38] === 0x61) { - return { - ext: "mkv", - mime: "video/x-matroska" - }; - } - - if (buf[0] === 0x1A && buf[1] === 0x45 && buf[2] === 0xDF && buf[3] === 0xA3) { - return { - ext: "webm", - mime: "video/webm" - }; - } - - if (buf[0] === 0x0 && buf[1] === 0x0 && buf[2] === 0x0 && buf[3] === 0x14 && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70) { - return { - ext: "mov", - mime: "video/quicktime" - }; - } - - if (buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 && buf[8] === 0x41 && buf[9] === 0x56 && buf[10] === 0x49) { - return { - ext: "avi", - mime: "video/x-msvideo" - }; - } - - if (buf[0] === 0x30 && buf[1] === 0x26 && buf[2] === 0xB2 && buf[3] === 0x75 && buf[4] === 0x8E && buf[5] === 0x66 && buf[6] === 0xCF && buf[7] === 0x11 && buf[8] === 0xA6 && buf[9] === 0xD9) { - return { - ext: "wmv", - mime: "video/x-ms-wmv" - }; - } - - if (buf[0] === 0x0 && buf[1] === 0x0 && buf[2] === 0x1 && buf[3].toString(16)[0] === "b") { - return { - ext: "mpg", - mime: "video/mpeg" - }; - } - - if ((buf[0] === 0x49 && buf[1] === 0x44 && buf[2] === 0x33) || (buf[0] === 0xFF && buf[1] === 0xfb)) { - return { - ext: "mp3", - mime: "audio/mpeg" - }; - } - - if ((buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70 && buf[8] === 0x4D && buf[9] === 0x34 && buf[10] === 0x41) || (buf[0] === 0x4D && buf[1] === 0x34 && buf[2] === 0x41 && buf[3] === 0x20)) { - return { - ext: "m4a", - mime: "audio/m4a" - }; - } - - if (buf[0] === 0x4F && buf[1] === 0x67 && buf[2] === 0x67 && buf[3] === 0x53) { - return { - ext: "ogg", - mime: "audio/ogg" - }; - } - - if (buf[0] === 0x66 && buf[1] === 0x4C && buf[2] === 0x61 && buf[3] === 0x43) { - return { - ext: "flac", - mime: "audio/x-flac" - }; - } - - if (buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 && buf[8] === 0x57 && buf[9] === 0x41 && buf[10] === 0x56 && buf[11] === 0x45) { - return { - ext: "wav", - mime: "audio/x-wav" - }; - } - - if (buf[0] === 0x23 && buf[1] === 0x21 && buf[2] === 0x41 && buf[3] === 0x4D && buf[4] === 0x52 && buf[5] === 0x0A) { - return { - ext: "amr", - mime: "audio/amr" - }; - } - - if (buf[0] === 0x25 && buf[1] === 0x50 && buf[2] === 0x44 && buf[3] === 0x46) { - return { - ext: "pdf", - mime: "application/pdf" - }; - } - - if (buf[0] === 0x4D && buf[1] === 0x5A) { - return { - ext: "exe", - mime: "application/x-msdownload" - }; - } - - if ((buf[0] === 0x43 || buf[0] === 0x46) && buf[1] === 0x57 && buf[2] === 0x53) { - return { - ext: "swf", - mime: "application/x-shockwave-flash" - }; - } - - if (buf[0] === 0x7B && buf[1] === 0x5C && buf[2] === 0x72 && buf[3] === 0x74 && buf[4] === 0x66) { - return { - ext: "rtf", - mime: "application/rtf" - }; - } - - if (buf[0] === 0x77 && buf[1] === 0x4F && buf[2] === 0x46 && buf[3] === 0x46 && buf[4] === 0x00 && buf[5] === 0x01 && buf[6] === 0x00 && buf[7] === 0x00) { - return { - ext: "woff", - mime: "application/font-woff" - }; - } - - if (buf[0] === 0x77 && buf[1] === 0x4F && buf[2] === 0x46 && buf[3] === 0x32 && buf[4] === 0x00 && buf[5] === 0x01 && buf[6] === 0x00 && buf[7] === 0x00) { - return { - ext: "woff2", - mime: "application/font-woff" - }; - } - - if (buf[34] === 0x4C && buf[35] === 0x50 && ((buf[8] === 0x02 && buf[9] === 0x00 && buf[10] === 0x01) || (buf[8] === 0x01 && buf[9] === 0x00 && buf[10] === 0x00) || (buf[8] === 0x02 && buf[9] === 0x00 && buf[10] === 0x02))) { - return { - ext: "eot", - mime: "application/octet-stream" - }; - } - - if (buf[0] === 0x00 && buf[1] === 0x01 && buf[2] === 0x00 && buf[3] === 0x00 && buf[4] === 0x00) { - return { - ext: "ttf", - mime: "application/font-sfnt" - }; - } - - if (buf[0] === 0x4F && buf[1] === 0x54 && buf[2] === 0x54 && buf[3] === 0x4F && buf[4] === 0x00) { - return { - ext: "otf", - mime: "application/font-sfnt" - }; - } - - if (buf[0] === 0x00 && buf[1] === 0x00 && buf[2] === 0x01 && buf[3] === 0x00) { - return { - ext: "ico", - mime: "image/x-icon" - }; - } - - if (buf[0] === 0x46 && buf[1] === 0x4C && buf[2] === 0x56 && buf[3] === 0x01) { - return { - ext: "flv", - mime: "video/x-flv" - }; - } - - if (buf[0] === 0x25 && buf[1] === 0x21) { - return { - ext: "ps", - mime: "application/postscript" - }; - } - - if (buf[0] === 0xFD && buf[1] === 0x37 && buf[2] === 0x7A && buf[3] === 0x58 && buf[4] === 0x5A && buf[5] === 0x00) { - return { - ext: "xz", - mime: "application/x-xz" - }; - } - - if (buf[0] === 0x53 && buf[1] === 0x51 && buf[2] === 0x4C && buf[3] === 0x69) { - return { - ext: "sqlite", - mime: "application/x-sqlite3" - }; - } - - /** - * - * Added by n1474335 [n1474335@gmail.com] from here on - * - */ - if ((buf[0] === 0x1F && buf[1] === 0x9D) || (buf[0] === 0x1F && buf[1] === 0xA0)) { - return { - ext: "z, tar.z", - mime: "application/x-gtar" - }; - } - - if (buf[0] === 0x7F && buf[1] === 0x45 && buf[2] === 0x4C && buf[3] === 0x46) { - return { - ext: "none, axf, bin, elf, o, prx, puff, so", - mime: "application/x-executable", - desc: "Executable and Linkable Format file. No standard file extension." - }; - } - - if (buf[0] === 0xCA && buf[1] === 0xFE && buf[2] === 0xBA && buf[3] === 0xBE) { - return { - ext: "class", - mime: "application/java-vm" - }; - } - - if (buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF) { - return { - ext: "txt", - mime: "text/plain", - desc: "UTF-8 encoded Unicode byte order mark detected, commonly but not exclusively seen in text files." - }; - } - - // Must be before Little-endian UTF-16 BOM - if (buf[0] === 0xFF && buf[1] === 0xFE && buf[2] === 0x00 && buf[3] === 0x00) { - return { - ext: "UTF32LE", - mime: "charset/utf32le", - desc: "Little-endian UTF-32 encoded Unicode byte order mark detected." - }; - } - - if (buf[0] === 0xFF && buf[1] === 0xFE) { - return { - ext: "UTF16LE", - mime: "charset/utf16le", - desc: "Little-endian UTF-16 encoded Unicode byte order mark detected." - }; - } - - if ((buf[0x8001] === 0x43 && buf[0x8002] === 0x44 && buf[0x8003] === 0x30 && buf[0x8004] === 0x30 && buf[0x8005] === 0x31) || - (buf[0x8801] === 0x43 && buf[0x8802] === 0x44 && buf[0x8803] === 0x30 && buf[0x8804] === 0x30 && buf[0x8805] === 0x31) || - (buf[0x9001] === 0x43 && buf[0x9002] === 0x44 && buf[0x9003] === 0x30 && buf[0x9004] === 0x30 && buf[0x9005] === 0x31)) { - return { - ext: "iso", - mime: "application/octet-stream", - desc: "ISO 9660 CD/DVD image file" - }; - } - - if (buf[0] === 0xD0 && buf[1] === 0xCF && buf[2] === 0x11 && buf[3] === 0xE0 && buf[4] === 0xA1 && buf[5] === 0xB1 && buf[6] === 0x1A && buf[7] === 0xE1) { - return { - ext: "doc, xls, ppt", - mime: "application/msword, application/vnd.ms-excel, application/vnd.ms-powerpoint", - desc: "Microsoft Office documents" - }; - } - - if (buf[0] === 0x64 && buf[1] === 0x65 && buf[2] === 0x78 && buf[3] === 0x0A && buf[4] === 0x30 && buf[5] === 0x33 && buf[6] === 0x35 && buf[7] === 0x00) { - return { - ext: "dex", - mime: "application/octet-stream", - desc: "Dalvik Executable (Android)" - }; - } - - if (buf[0] === 0x4B && buf[1] === 0x44 && buf[2] === 0x4D) { - return { - ext: "vmdk", - mime: "application/vmdk, application/x-virtualbox-vmdk" - }; - } - - if (buf[0] === 0x43 && buf[1] === 0x72 && buf[2] === 0x32 && buf[3] === 0x34) { - return { - ext: "crx", - mime: "application/crx", - desc: "Google Chrome extension or packaged app" - }; - } - - if (buf[0] === 0x78 && (buf[1] === 0x01 || buf[1] === 0x9C || buf[1] === 0xDA || buf[1] === 0x5e)) { - return { - ext: "zlib", - mime: "application/x-deflate" - }; - } - - return null; - }, - -}; - -export default FileType; diff --git a/src/core/operations/legacy/Filetime.js b/src/core/operations/legacy/Filetime.js deleted file mode 100644 index 9a21088d..00000000 --- a/src/core/operations/legacy/Filetime.js +++ /dev/null @@ -1,103 +0,0 @@ -import BigNumber from "bignumber.js"; - -/** - * Windows Filetime operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const Filetime = { - - /** - * @constant - * @default - */ - UNITS: ["Seconds (s)", "Milliseconds (ms)", "Microseconds (μs)", "Nanoseconds (ns)"], - - /** - * @constant - * @default - */ - FILETIME_FORMATS: ["Decimal", "Hex"], - - /** - * Windows Filetime to Unix Timestamp operation. - * - * @author bwhitn [brian.m.whitney@outlook.com] - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFromFiletimeToUnix: function(input, args) { - let units = args[0], - format = args[1]; - - if (!input) return ""; - - if (format === "Hex") { - input = new BigNumber(input, 16); - } else { - input = new BigNumber(input); - } - - input = input.minus(new BigNumber("116444736000000000")); - - if (units === "Seconds (s)"){ - input = input.dividedBy(new BigNumber("10000000")); - } else if (units === "Milliseconds (ms)") { - input = input.dividedBy(new BigNumber("10000")); - } else if (units === "Microseconds (μs)") { - input = input.dividedBy(new BigNumber("10")); - } else if (units === "Nanoseconds (ns)") { - input = input.multipliedBy(new BigNumber("100")); - } else { - throw "Unrecognised unit"; - } - - return input.toFixed(); - }, - - - /** - * Unix Timestamp to Windows Filetime operation. - * - * @author bwhitn [brian.m.whitney@outlook.com] - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToFiletimeFromUnix: function(input, args) { - let units = args[0], - format = args[1]; - - if (!input) return ""; - - input = new BigNumber(input); - - if (units === "Seconds (s)"){ - input = input.multipliedBy(new BigNumber("10000000")); - } else if (units === "Milliseconds (ms)") { - input = input.multipliedBy(new BigNumber("10000")); - } else if (units === "Microseconds (μs)") { - input = input.multiplyiedBy(new BigNumber("10")); - } else if (units === "Nanoseconds (ns)") { - input = input.dividedBy(new BigNumber("100")); - } else { - throw "Unrecognised unit"; - } - - input = input.plus(new BigNumber("116444736000000000")); - - if (format === "Hex"){ - return input.toString(16); - } else { - return input.toFixed(); - } - }, - -}; - -export default Filetime; diff --git a/src/core/operations/legacy/HTML.js b/src/core/operations/legacy/HTML.js deleted file mode 100755 index b1f7e065..00000000 --- a/src/core/operations/legacy/HTML.js +++ /dev/null @@ -1,857 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * HTML operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const HTML = { - - /** - * @constant - * @default - */ - CONVERT_ALL: false, - /** - * @constant - * @default - */ - CONVERT_OPTIONS: ["Named entities where possible", "Numeric entities", "Hex entities"], - - /** - * To HTML Entity operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToEntity: function(input, args) { - let convertAll = args[0], - numeric = args[1] === "Numeric entities", - hexa = args[1] === "Hex entities"; - - const charcodes = Utils.strToCharcode(input); - let output = ""; - - for (let i = 0; i < charcodes.length; i++) { - if (convertAll && numeric) { - output += "&#" + charcodes[i] + ";"; - } else if (convertAll && hexa) { - output += "&#x" + Utils.hex(charcodes[i]) + ";"; - } else if (convertAll) { - output += HTML._byteToEntity[charcodes[i]] || "&#" + charcodes[i] + ";"; - } else if (numeric) { - if (charcodes[i] > 255 || HTML._byteToEntity.hasOwnProperty(charcodes[i])) { - output += "&#" + charcodes[i] + ";"; - } else { - output += Utils.chr(charcodes[i]); - } - } else if (hexa) { - if (charcodes[i] > 255 || HTML._byteToEntity.hasOwnProperty(charcodes[i])) { - output += "&#x" + Utils.hex(charcodes[i]) + ";"; - } else { - output += Utils.chr(charcodes[i]); - } - } else { - output += HTML._byteToEntity[charcodes[i]] || ( - charcodes[i] > 255 ? - "&#" + charcodes[i] + ";" : - Utils.chr(charcodes[i]) - ); - } - } - return output; - }, - - - /** - * From HTML Entity operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFromEntity: function(input, args) { - let regex = /&(#?x?[a-zA-Z0-9]{1,8});/g, - output = "", - m, - i = 0; - - while ((m = regex.exec(input))) { - // Add up to match - for (; i < m.index;) - output += input[i++]; - - // Add match - const bite = HTML._entityToByte[m[1]]; - if (bite) { - output += Utils.chr(bite); - } else if (!bite && m[1][0] === "#" && m[1].length > 1 && /^#\d{1,6}$/.test(m[1])) { - // Numeric entity (e.g. ) - const num = m[1].slice(1, m[1].length); - output += Utils.chr(parseInt(num, 10)); - } else if (!bite && m[1][0] === "#" && m[1].length > 3 && /^#x[\dA-F]{2,8}$/i.test(m[1])) { - // Hex entity (e.g. :) - const hex = m[1].slice(2, m[1].length); - output += Utils.chr(parseInt(hex, 16)); - } else { - // Not a valid entity, print as normal - for (; i < regex.lastIndex;) - output += input[i++]; - } - - i = regex.lastIndex; - } - // Add all after final match - for (; i < input.length;) - output += input[i++]; - - return output; - }, - - - /** - * @constant - * @default - */ - REMOVE_INDENTATION: true, - /** - * @constant - * @default - */ - REMOVE_LINE_BREAKS: true, - - /** - * Strip HTML tags operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runStripTags: function(input, args) { - let removeIndentation = args[0], - removeLineBreaks = args[1]; - - input = Utils.stripHtmlTags(input); - - if (removeIndentation) { - input = input.replace(/\n[ \f\t]+/g, "\n"); - } - - if (removeLineBreaks) { - input = input - .replace(/^\s*\n/, "") // first line - .replace(/(\n\s*){2,}/g, "\n"); // all others - } - - return input; - }, - - - /** - * Parse colour code operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runParseColourCode: function(input, args) { - let m = null, - r = 0, g = 0, b = 0, a = 1; - - // Read in the input - if ((m = input.match(/#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/i))) { - // Hex - #d9edf7 - r = parseInt(m[1], 16); - g = parseInt(m[2], 16); - b = parseInt(m[3], 16); - } else if ((m = input.match(/rgba?\((\d{1,3}(?:\.\d+)?),\s?(\d{1,3}(?:\.\d+)?),\s?(\d{1,3}(?:\.\d+)?)(?:,\s?(\d(?:\.\d+)?))?\)/i))) { - // RGB or RGBA - rgb(217,237,247) or rgba(217,237,247,1) - r = parseFloat(m[1]); - g = parseFloat(m[2]); - b = parseFloat(m[3]); - a = m[4] ? parseFloat(m[4]) : 1; - } else if ((m = input.match(/hsla?\((\d{1,3}(?:\.\d+)?),\s?(\d{1,3}(?:\.\d+)?)%,\s?(\d{1,3}(?:\.\d+)?)%(?:,\s?(\d(?:\.\d+)?))?\)/i))) { - // HSL or HSLA - hsl(200, 65%, 91%) or hsla(200, 65%, 91%, 1) - let h_ = parseFloat(m[1]) / 360, - s_ = parseFloat(m[2]) / 100, - l_ = parseFloat(m[3]) / 100, - rgb_ = HTML._hslToRgb(h_, s_, l_); - - r = rgb_[0]; - g = rgb_[1]; - b = rgb_[2]; - a = m[4] ? parseFloat(m[4]) : 1; - } else if ((m = input.match(/cmyk\((\d(?:\.\d+)?),\s?(\d(?:\.\d+)?),\s?(\d(?:\.\d+)?),\s?(\d(?:\.\d+)?)\)/i))) { - // CMYK - cmyk(0.12, 0.04, 0.00, 0.03) - let c_ = parseFloat(m[1]), - m_ = parseFloat(m[2]), - y_ = parseFloat(m[3]), - k_ = parseFloat(m[4]); - - r = Math.round(255 * (1 - c_) * (1 - k_)); - g = Math.round(255 * (1 - m_) * (1 - k_)); - b = Math.round(255 * (1 - y_) * (1 - k_)); - } - - let hsl_ = HTML._rgbToHsl(r, g, b), - h = Math.round(hsl_[0] * 360), - s = Math.round(hsl_[1] * 100), - l = Math.round(hsl_[2] * 100), - k = 1 - Math.max(r/255, g/255, b/255), - c = (1 - r/255 - k) / (1 - k), - y = (1 - b/255 - k) / (1 - k); - - m = (1 - g/255 - k) / (1 - k); - - c = isNaN(c) ? "0" : c.toFixed(2); - m = isNaN(m) ? "0" : m.toFixed(2); - y = isNaN(y) ? "0" : y.toFixed(2); - k = k.toFixed(2); - - let hex = "#" + - Math.round(r).toString(16).padStart(2, "0") + - Math.round(g).toString(16).padStart(2, "0") + - Math.round(b).toString(16).padStart(2, "0"), - rgb = "rgb(" + r + ", " + g + ", " + b + ")", - rgba = "rgba(" + r + ", " + g + ", " + b + ", " + a + ")", - hsl = "hsl(" + h + ", " + s + "%, " + l + "%)", - hsla = "hsla(" + h + ", " + s + "%, " + l + "%, " + a + ")", - cmyk = "cmyk(" + c + ", " + m + ", " + y + ", " + k + ")"; - - // Generate output - return `
-Hex: ${hex} -RGB: ${rgb} -RGBA: ${rgba} -HSL: ${hsl} -HSLA: ${hsla} -CMYK: ${cmyk} -`; - }, - - - /** - * Converts an HSL color value to RGB. Conversion formula - * adapted from http://en.wikipedia.org/wiki/HSL_colorSpace. - * Assumes h, s, and l are contained in the set [0, 1] and - * returns r, g, and b in the set [0, 255]. - * - * @private - * @author Mohsen (http://stackoverflow.com/a/9493060) - * - * @param {number} h - The hue - * @param {number} s - The saturation - * @param {number} l - The lightness - * @return {Array} The RGB representation - */ - _hslToRgb: function(h, s, l){ - let r, g, b; - - if (s === 0){ - r = g = b = l; // achromatic - } else { - const hue2rgb = function hue2rgb(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; - }; - - const q = l < 0.5 ? l * (1 + s) : l + s - l * s; - const p = 2 * l - q; - r = hue2rgb(p, q, h + 1/3); - g = hue2rgb(p, q, h); - b = hue2rgb(p, q, h - 1/3); - } - - return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)]; - }, - - - /** - * Converts an RGB color value to HSL. Conversion formula - * adapted from http://en.wikipedia.org/wiki/HSL_colorSpace. - * Assumes r, g, and b are contained in the set [0, 255] and - * returns h, s, and l in the set [0, 1]. - * - * @private - * @author Mohsen (http://stackoverflow.com/a/9493060) - * - * @param {number} r - The red color value - * @param {number} g - The green color value - * @param {number} b - The blue color value - * @return {Array} The HSL representation - */ - _rgbToHsl: function(r, g, b) { - r /= 255; g /= 255; b /= 255; - let max = Math.max(r, g, b), - min = Math.min(r, g, b), - h, s, l = (max + min) / 2; - - if (max === min) { - h = s = 0; // achromatic - } else { - const d = max - min; - s = l > 0.5 ? d / (2 - max - min) : d / (max + min); - switch (max) { - case r: h = (g - b) / d + (g < b ? 6 : 0); break; - case g: h = (b - r) / d + 2; break; - case b: h = (r - g) / d + 4; break; - } - h /= 6; - } - - return [h, s, l]; - }, - - - /** - * Lookup table to translate byte values to their HTML entity codes. - * - * @private - * @constant - */ - _byteToEntity: { - 34: """, - 38: "&", - 39: "'", - 60: "<", - 62: ">", - 160: " ", - 161: "¡", - 162: "¢", - 163: "£", - 164: "¤", - 165: "¥", - 166: "¦", - 167: "§", - 168: "¨", - 169: "©", - 170: "ª", - 171: "«", - 172: "¬", - 173: "­", - 174: "®", - 175: "¯", - 176: "°", - 177: "±", - 178: "²", - 179: "³", - 180: "´", - 181: "µ", - 182: "¶", - 183: "·", - 184: "¸", - 185: "¹", - 186: "º", - 187: "»", - 188: "¼", - 189: "½", - 190: "¾", - 191: "¿", - 192: "À", - 193: "Á", - 194: "Â", - 195: "Ã", - 196: "Ä", - 197: "Å", - 198: "Æ", - 199: "Ç", - 200: "È", - 201: "É", - 202: "Ê", - 203: "Ë", - 204: "Ì", - 205: "Í", - 206: "Î", - 207: "Ï", - 208: "Ð", - 209: "Ñ", - 210: "Ò", - 211: "Ó", - 212: "Ô", - 213: "Õ", - 214: "Ö", - 215: "×", - 216: "Ø", - 217: "Ù", - 218: "Ú", - 219: "Û", - 220: "Ü", - 221: "Ý", - 222: "Þ", - 223: "ß", - 224: "à", - 225: "á", - 226: "â", - 227: "ã", - 228: "ä", - 229: "å", - 230: "æ", - 231: "ç", - 232: "è", - 233: "é", - 234: "ê", - 235: "ë", - 236: "ì", - 237: "í", - 238: "î", - 239: "ï", - 240: "ð", - 241: "ñ", - 242: "ò", - 243: "ó", - 244: "ô", - 245: "õ", - 246: "ö", - 247: "÷", - 248: "ø", - 249: "ù", - 250: "ú", - 251: "û", - 252: "ü", - 253: "ý", - 254: "þ", - 255: "ÿ", - 338: "Œ", - 339: "œ", - 352: "Š", - 353: "š", - 376: "Ÿ", - 402: "ƒ", - 710: "ˆ", - 732: "˜", - 913: "Α", - 914: "Β", - 915: "Γ", - 916: "Δ", - 917: "Ε", - 918: "Ζ", - 919: "Η", - 920: "Θ", - 921: "Ι", - 922: "Κ", - 923: "Λ", - 924: "Μ", - 925: "Ν", - 926: "Ξ", - 927: "Ο", - 928: "Π", - 929: "Ρ", - 931: "Σ", - 932: "Τ", - 933: "Υ", - 934: "Φ", - 935: "Χ", - 936: "Ψ", - 937: "Ω", - 945: "α", - 946: "β", - 947: "γ", - 948: "δ", - 949: "ε", - 950: "ζ", - 951: "η", - 952: "θ", - 953: "ι", - 954: "κ", - 955: "λ", - 956: "μ", - 957: "ν", - 958: "ξ", - 959: "ο", - 960: "π", - 961: "ρ", - 962: "ς", - 963: "σ", - 964: "τ", - 965: "υ", - 966: "φ", - 967: "χ", - 968: "ψ", - 969: "ω", - 977: "ϑ", - 978: "ϒ", - 982: "ϖ", - 8194: " ", - 8195: " ", - 8201: " ", - 8204: "‌", - 8205: "‍", - 8206: "‎", - 8207: "‏", - 8211: "–", - 8212: "—", - 8216: "‘", - 8217: "’", - 8218: "‚", - 8220: "“", - 8221: "”", - 8222: "„", - 8224: "†", - 8225: "‡", - 8226: "•", - 8230: "…", - 8240: "‰", - 8242: "′", - 8243: "″", - 8249: "‹", - 8250: "›", - 8254: "‾", - 8260: "⁄", - 8364: "€", - 8465: "ℑ", - 8472: "℘", - 8476: "ℜ", - 8482: "™", - 8501: "ℵ", - 8592: "←", - 8593: "↑", - 8594: "→", - 8595: "↓", - 8596: "↔", - 8629: "↵", - 8656: "⇐", - 8657: "⇑", - 8658: "⇒", - 8659: "⇓", - 8660: "⇔", - 8704: "∀", - 8706: "∂", - 8707: "∃", - 8709: "∅", - 8711: "∇", - 8712: "∈", - 8713: "∉", - 8715: "∋", - 8719: "∏", - 8721: "∑", - 8722: "−", - 8727: "∗", - 8730: "√", - 8733: "∝", - 8734: "∞", - 8736: "∠", - 8743: "∧", - 8744: "∨", - 8745: "∩", - 8746: "∪", - 8747: "∫", - 8756: "∴", - 8764: "∼", - 8773: "≅", - 8776: "≈", - 8800: "≠", - 8801: "≡", - 8804: "≤", - 8805: "≥", - 8834: "⊂", - 8835: "⊃", - 8836: "⊄", - 8838: "⊆", - 8839: "⊇", - 8853: "⊕", - 8855: "⊗", - 8869: "⊥", - 8901: "⋅", - 8942: "⋮", - 8968: "⌈", - 8969: "⌉", - 8970: "⌊", - 8971: "⌋", - 9001: "⟨", - 9002: "⟩", - 9674: "◊", - 9824: "♠", - 9827: "♣", - 9829: "♥", - 9830: "♦", - }, - - - /** - * Lookup table to translate HTML entity codes to their byte values. - * - * @private - * @constant - */ - _entityToByte: { - "quot": 34, - "amp": 38, - "apos": 39, - "lt": 60, - "gt": 62, - "nbsp": 160, - "iexcl": 161, - "cent": 162, - "pound": 163, - "curren": 164, - "yen": 165, - "brvbar": 166, - "sect": 167, - "uml": 168, - "copy": 169, - "ordf": 170, - "laquo": 171, - "not": 172, - "shy": 173, - "reg": 174, - "macr": 175, - "deg": 176, - "plusmn": 177, - "sup2": 178, - "sup3": 179, - "acute": 180, - "micro": 181, - "para": 182, - "middot": 183, - "cedil": 184, - "sup1": 185, - "ordm": 186, - "raquo": 187, - "frac14": 188, - "frac12": 189, - "frac34": 190, - "iquest": 191, - "Agrave": 192, - "Aacute": 193, - "Acirc": 194, - "Atilde": 195, - "Auml": 196, - "Aring": 197, - "AElig": 198, - "Ccedil": 199, - "Egrave": 200, - "Eacute": 201, - "Ecirc": 202, - "Euml": 203, - "Igrave": 204, - "Iacute": 205, - "Icirc": 206, - "Iuml": 207, - "ETH": 208, - "Ntilde": 209, - "Ograve": 210, - "Oacute": 211, - "Ocirc": 212, - "Otilde": 213, - "Ouml": 214, - "times": 215, - "Oslash": 216, - "Ugrave": 217, - "Uacute": 218, - "Ucirc": 219, - "Uuml": 220, - "Yacute": 221, - "THORN": 222, - "szlig": 223, - "agrave": 224, - "aacute": 225, - "acirc": 226, - "atilde": 227, - "auml": 228, - "aring": 229, - "aelig": 230, - "ccedil": 231, - "egrave": 232, - "eacute": 233, - "ecirc": 234, - "euml": 235, - "igrave": 236, - "iacute": 237, - "icirc": 238, - "iuml": 239, - "eth": 240, - "ntilde": 241, - "ograve": 242, - "oacute": 243, - "ocirc": 244, - "otilde": 245, - "ouml": 246, - "divide": 247, - "oslash": 248, - "ugrave": 249, - "uacute": 250, - "ucirc": 251, - "uuml": 252, - "yacute": 253, - "thorn": 254, - "yuml": 255, - "OElig": 338, - "oelig": 339, - "Scaron": 352, - "scaron": 353, - "Yuml": 376, - "fnof": 402, - "circ": 710, - "tilde": 732, - "Alpha": 913, - "Beta": 914, - "Gamma": 915, - "Delta": 916, - "Epsilon": 917, - "Zeta": 918, - "Eta": 919, - "Theta": 920, - "Iota": 921, - "Kappa": 922, - "Lambda": 923, - "Mu": 924, - "Nu": 925, - "Xi": 926, - "Omicron": 927, - "Pi": 928, - "Rho": 929, - "Sigma": 931, - "Tau": 932, - "Upsilon": 933, - "Phi": 934, - "Chi": 935, - "Psi": 936, - "Omega": 937, - "alpha": 945, - "beta": 946, - "gamma": 947, - "delta": 948, - "epsilon": 949, - "zeta": 950, - "eta": 951, - "theta": 952, - "iota": 953, - "kappa": 954, - "lambda": 955, - "mu": 956, - "nu": 957, - "xi": 958, - "omicron": 959, - "pi": 960, - "rho": 961, - "sigmaf": 962, - "sigma": 963, - "tau": 964, - "upsilon": 965, - "phi": 966, - "chi": 967, - "psi": 968, - "omega": 969, - "thetasym": 977, - "upsih": 978, - "piv": 982, - "ensp": 8194, - "emsp": 8195, - "thinsp": 8201, - "zwnj": 8204, - "zwj": 8205, - "lrm": 8206, - "rlm": 8207, - "ndash": 8211, - "mdash": 8212, - "lsquo": 8216, - "rsquo": 8217, - "sbquo": 8218, - "ldquo": 8220, - "rdquo": 8221, - "bdquo": 8222, - "dagger": 8224, - "Dagger": 8225, - "bull": 8226, - "hellip": 8230, - "permil": 8240, - "prime": 8242, - "Prime": 8243, - "lsaquo": 8249, - "rsaquo": 8250, - "oline": 8254, - "frasl": 8260, - "euro": 8364, - "image": 8465, - "weierp": 8472, - "real": 8476, - "trade": 8482, - "alefsym": 8501, - "larr": 8592, - "uarr": 8593, - "rarr": 8594, - "darr": 8595, - "harr": 8596, - "crarr": 8629, - "lArr": 8656, - "uArr": 8657, - "rArr": 8658, - "dArr": 8659, - "hArr": 8660, - "forall": 8704, - "part": 8706, - "exist": 8707, - "empty": 8709, - "nabla": 8711, - "isin": 8712, - "notin": 8713, - "ni": 8715, - "prod": 8719, - "sum": 8721, - "minus": 8722, - "lowast": 8727, - "radic": 8730, - "prop": 8733, - "infin": 8734, - "ang": 8736, - "and": 8743, - "or": 8744, - "cap": 8745, - "cup": 8746, - "int": 8747, - "there4": 8756, - "sim": 8764, - "cong": 8773, - "asymp": 8776, - "ne": 8800, - "equiv": 8801, - "le": 8804, - "ge": 8805, - "sub": 8834, - "sup": 8835, - "nsub": 8836, - "sube": 8838, - "supe": 8839, - "oplus": 8853, - "otimes": 8855, - "perp": 8869, - "sdot": 8901, - "vellip": 8942, - "lceil": 8968, - "rceil": 8969, - "lfloor": 8970, - "rfloor": 8971, - "lang": 9001, - "rang": 9002, - "loz": 9674, - "spades": 9824, - "clubs": 9827, - "hearts": 9829, - "diams": 9830, - }, - -}; - -export default HTML; diff --git a/src/core/operations/legacy/HTTP.js b/src/core/operations/legacy/HTTP.js deleted file mode 100755 index dcb1cc50..00000000 --- a/src/core/operations/legacy/HTTP.js +++ /dev/null @@ -1,158 +0,0 @@ -import UAParser from "ua-parser-js"; - - -/** - * HTTP operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const HTTP = { - - /** - * @constant - * @default - */ - METHODS: [ - "GET", "POST", "HEAD", - "PUT", "PATCH", "DELETE", - "CONNECT", "TRACE", "OPTIONS" - ], - - - /** - * Strip HTTP headers operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runStripHeaders: function(input, args) { - let headerEnd = input.indexOf("\r\n\r\n"); - headerEnd = (headerEnd < 0) ? input.indexOf("\n\n") + 2 : headerEnd + 4; - - return (headerEnd < 2) ? input : input.slice(headerEnd, input.length); - }, - - - /** - * Parse User Agent operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseUserAgent: function(input, args) { - const ua = UAParser(input); - return `Browser - Name: ${ua.browser.name || "unknown"} - Version: ${ua.browser.version || "unknown"} -Device - Model: ${ua.device.model || "unknown"} - Type: ${ua.device.type || "unknown"} - Vendor: ${ua.device.vendor || "unknown"} -Engine - Name: ${ua.engine.name || "unknown"} - Version: ${ua.engine.version || "unknown"} -OS - Name: ${ua.os.name || "unknown"} - Version: ${ua.os.version || "unknown"} -CPU - Architecture: ${ua.cpu.architecture || "unknown"}`; - }, - - - /** - * @constant - * @default - */ - MODE: [ - "Cross-Origin Resource Sharing", - "No CORS (limited to HEAD, GET or POST)", - ], - - /** - * Lookup table for HTTP modes - * - * @private - * @constant - */ - _modeLookup: { - "Cross-Origin Resource Sharing": "cors", - "No CORS (limited to HEAD, GET or POST)": "no-cors", - }, - - /** - * HTTP request operation. - * - * @author tlwr [toby@toby.codes] - * @author n1474335 [n1474335@gmail.com] - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runHTTPRequest(input, args) { - const method = args[0], - url = args[1], - headersText = args[2], - mode = args[3], - showResponseMetadata = args[4]; - - if (url.length === 0) return ""; - - let headers = new Headers(); - headersText.split(/\r?\n/).forEach(line => { - line = line.trim(); - - if (line.length === 0) return; - - let split = line.split(":"); - if (split.length !== 2) throw `Could not parse header in line: ${line}`; - - headers.set(split[0].trim(), split[1].trim()); - }); - - let config = { - method: method, - headers: headers, - mode: HTTP._modeLookup[mode], - cache: "no-cache", - }; - - if (method !== "GET" && method !== "HEAD") { - config.body = input; - } - - return fetch(url, config) - .then(r => { - if (r.status === 0 && r.type === "opaque") { - return "Error: Null response. Try setting the connection mode to CORS."; - } - - if (showResponseMetadata) { - let headers = ""; - for (let pair of r.headers.entries()) { - headers += " " + pair[0] + ": " + pair[1] + "\n"; - } - return r.text().then(b => { - return "####\n Status: " + r.status + " " + r.statusText + - "\n Exposed headers:\n" + headers + "####\n\n" + b; - }); - } - return r.text(); - }) - .catch(e => { - return e.toString() + - "\n\nThis error could be caused by one of the following:\n" + - " - An invalid URL\n" + - " - Making a request to an insecure resource (HTTP) from a secure source (HTTPS)\n" + - " - Making a cross-origin request to a server which does not support CORS\n"; - }); - }, - -}; - -export default HTTP; diff --git a/src/core/operations/legacy/Hash.js b/src/core/operations/legacy/Hash.js deleted file mode 100755 index f09f7c75..00000000 --- a/src/core/operations/legacy/Hash.js +++ /dev/null @@ -1,785 +0,0 @@ -import Utils from "../Utils.js"; -import CryptoApi from "babel-loader!crypto-api"; -import MD6 from "node-md6"; -import * as SHA3 from "js-sha3"; -import Checksum from "./Checksum.js"; -import ctph from "ctph.js"; -import ssdeep from "ssdeep.js"; -import bcrypt from "bcryptjs"; -import scrypt from "scryptsy"; - - -/** - * Hashing operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Hash = { - - /** - * Generic hash function. - * - * @param {string} name - * @param {ArrayBuffer} input - * @param {Object} [options={}] - * @returns {string} - */ - runHash: function(name, input, options={}) { - const msg = Utils.arrayBufferToStr(input, false), - hasher = CryptoApi.getHasher(name, options); - hasher.update(msg); - return CryptoApi.encoder.toHex(hasher.finalize()); - }, - - - /** - * MD2 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runMD2: function (input, args) { - return Hash.runHash("md2", input); - }, - - - /** - * MD4 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runMD4: function (input, args) { - return Hash.runHash("md4", input); - }, - - - /** - * MD5 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runMD5: function (input, args) { - return Hash.runHash("md5", input); - }, - - - /** - * @constant - * @default - */ - MD6_SIZE: 256, - /** - * @constant - * @default - */ - MD6_LEVELS: 64, - - /** - * MD6 operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runMD6: function (input, args) { - const size = args[0], - levels = args[1], - key = args[2]; - - if (size < 0 || size > 512) - return "Size must be between 0 and 512"; - if (levels < 0) - return "Levels must be greater than 0"; - - return MD6.getHashOfText(input, size, key, levels); - }, - - - /** - * SHA0 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runSHA0: function (input, args) { - return Hash.runHash("sha0", input); - }, - - - /** - * SHA1 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runSHA1: function (input, args) { - return Hash.runHash("sha1", input); - }, - - - /** - * @constant - * @default - */ - SHA2_SIZE: ["512", "256", "384", "224", "512/256", "512/224"], - - /** - * SHA2 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runSHA2: function (input, args) { - const size = args[0]; - return Hash.runHash("sha" + size, input); - }, - - - /** - * @constant - * @default - */ - SHA3_SIZE: ["512", "384", "256", "224"], - - /** - * SHA3 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runSHA3: function (input, args) { - const size = parseInt(args[0], 10); - let algo; - - switch (size) { - case 224: - algo = SHA3.sha3_224; - break; - case 384: - algo = SHA3.sha3_384; - break; - case 256: - algo = SHA3.sha3_256; - break; - case 512: - algo = SHA3.sha3_512; - break; - default: - return "Invalid size"; - } - - return algo(input); - }, - - - /** - * @constant - * @default - */ - KECCAK_SIZE: ["512", "384", "256", "224"], - - /** - * Keccak operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runKeccak: function (input, args) { - const size = parseInt(args[0], 10); - let algo; - - switch (size) { - case 224: - algo = SHA3.keccak224; - break; - case 384: - algo = SHA3.keccak384; - break; - case 256: - algo = SHA3.keccak256; - break; - case 512: - algo = SHA3.keccak512; - break; - default: - return "Invalid size"; - } - - return algo(input); - }, - - - /** - * @constant - * @default - */ - SHAKE_CAPACITY: ["256", "128"], - /** - * @constant - * @default - */ - SHAKE_SIZE: 512, - - /** - * Shake operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runShake: function (input, args) { - const capacity = parseInt(args[0], 10), - size = args[1]; - let algo; - - if (size < 0) - return "Size must be greater than 0"; - - switch (capacity) { - case 128: - algo = SHA3.shake128; - break; - case 256: - algo = SHA3.shake256; - break; - default: - return "Invalid size"; - } - - return algo(input, size); - }, - - - /** - * @constant - * @default - */ - RIPEMD_SIZE: ["320", "256", "160", "128"], - - /** - * RIPEMD operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runRIPEMD: function (input, args) { - const size = args[0]; - return Hash.runHash("ripemd" + size, input); - }, - - - /** - * HAS-160 operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runHAS: function (input, args) { - return Hash.runHash("has160", input); - }, - - - /** - * @constant - * @default - */ - WHIRLPOOL_VARIANT: ["Whirlpool", "Whirlpool-T", "Whirlpool-0"], - - /** - * Whirlpool operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runWhirlpool: function (input, args) { - const variant = args[0].toLowerCase(); - return Hash.runHash(variant, input); - }, - - - /** - * @constant - * @default - */ - SNEFRU_ROUNDS: ["8", "4", "2"], - /** - * @constant - * @default - */ - SNEFRU_SIZE: ["256", "128"], - - /** - * Snefru operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runSnefru: function (input, args) { - return Hash.runHash("snefru", input, { - rounds: args[0], - length: args[1] - }); - }, - - - /** - * CTPH operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runCTPH: function (input, args) { - return ctph.digest(input); - }, - - - /** - * SSDEEP operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSSDEEP: function (input, args) { - return ssdeep.digest(input); - }, - - - /** - * @constant - * @default - */ - DELIM_OPTIONS: ["Line feed", "CRLF", "Space", "Comma"], - - /** - * Compare CTPH hashes operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {Number} - */ - runCompareCTPH: function (input, args) { - const samples = input.split(Utils.charRep(args[0])); - if (samples.length !== 2) throw "Incorrect number of samples."; - return ctph.similarity(samples[0], samples[1]); - }, - - - /** - * Compare SSDEEP hashes operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {Number} - */ - runCompareSSDEEP: function (input, args) { - const samples = input.split(Utils.charRep(args[0])); - if (samples.length !== 2) throw "Incorrect number of samples."; - return ssdeep.similarity(samples[0], samples[1]); - }, - - - /** - * @constant - * @default - */ - HMAC_FUNCTIONS: [ - "MD2", - "MD4", - "MD5", - "SHA0", - "SHA1", - "SHA224", - "SHA256", - "SHA384", - "SHA512", - "SHA512/224", - "SHA512/256", - "RIPEMD128", - "RIPEMD160", - "RIPEMD256", - "RIPEMD320", - "HAS160", - "Whirlpool", - "Whirlpool-0", - "Whirlpool-T", - "Snefru" - ], - - /** - * HMAC operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runHMAC: function (input, args) { - const key = args[0], - hashFunc = args[1].toLowerCase(), - msg = Utils.arrayBufferToStr(input, false), - hasher = CryptoApi.getHasher(hashFunc); - - // Horrible shim to fix constructor bug. Reported in nf404/crypto-api#8 - hasher.reset = () => { - hasher.state = {}; - const tmp = new hasher.constructor(); - hasher.state = tmp.state; - }; - - const mac = CryptoApi.getHmac(CryptoApi.encoder.fromUtf(key), hasher); - mac.update(msg); - return CryptoApi.encoder.toHex(mac.finalize()); - }, - - - /** - * @constant - * @default - */ - BCRYPT_ROUNDS: 10, - - /** - * Bcrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBcrypt: async function (input, args) { - const rounds = args[0]; - const salt = await bcrypt.genSalt(rounds); - - return await bcrypt.hash(input, salt, null, p => { - // Progress callback - if (ENVIRONMENT_IS_WORKER()) - self.sendStatusMessage(`Progress: ${(p * 100).toFixed(0)}%`); - }); - }, - - - /** - * Bcrypt compare operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBcryptCompare: async function (input, args) { - const hash = args[0]; - - const match = await bcrypt.compare(input, hash, null, p => { - // Progress callback - if (ENVIRONMENT_IS_WORKER()) - self.sendStatusMessage(`Progress: ${(p * 100).toFixed(0)}%`); - }); - - return match ? "Match: " + input : "No match"; - }, - - - /** - * Bcrypt parse operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runBcryptParse: async function (input, args) { - try { - return `Rounds: ${bcrypt.getRounds(input)} -Salt: ${bcrypt.getSalt(input)} -Password hash: ${input.split(bcrypt.getSalt(input))[1]} -Full hash: ${input}`; - } catch (err) { - return "Error: " + err.toString(); - } - }, - - - /** - * @constant - * @default - */ - KEY_FORMAT: ["Hex", "Base64", "UTF8", "Latin1"], - /** - * @constant - * @default - */ - SCRYPT_ITERATIONS: 16384, - /** - * @constant - * @default - */ - SCRYPT_MEM_FACTOR: 8, - /** - * @constant - * @default - */ - SCRYPT_PARALLEL_FACTOR: 1, - /** - * @constant - * @default - */ - SCRYPT_KEY_LENGTH: 64, - - /** - * Scrypt operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runScrypt: function (input, args) { - const salt = Utils.convertToByteString(args[0].string || "", args[0].option), - iterations = args[1], - memFactor = args[2], - parallelFactor = args[3], - keyLength = args[4]; - - try { - const data = scrypt( - input, salt, iterations, memFactor, parallelFactor, keyLength, - p => { - // Progress callback - if (ENVIRONMENT_IS_WORKER()) - self.sendStatusMessage(`Progress: ${p.percent.toFixed(0)}%`); - } - ); - - return data.toString("hex"); - } catch (err) { - return "Error: " + err.toString(); - } - }, - - - /** - * Generate all hashes operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runAll: function (input, args) { - const arrayBuffer = input, - str = Utils.arrayBufferToStr(arrayBuffer, false), - byteArray = new Uint8Array(arrayBuffer), - output = "MD2: " + Hash.runMD2(arrayBuffer, []) + - "\nMD4: " + Hash.runMD4(arrayBuffer, []) + - "\nMD5: " + Hash.runMD5(arrayBuffer, []) + - "\nMD6: " + Hash.runMD6(str, []) + - "\nSHA0: " + Hash.runSHA0(arrayBuffer, []) + - "\nSHA1: " + Hash.runSHA1(arrayBuffer, []) + - "\nSHA2 224: " + Hash.runSHA2(arrayBuffer, ["224"]) + - "\nSHA2 256: " + Hash.runSHA2(arrayBuffer, ["256"]) + - "\nSHA2 384: " + Hash.runSHA2(arrayBuffer, ["384"]) + - "\nSHA2 512: " + Hash.runSHA2(arrayBuffer, ["512"]) + - "\nSHA3 224: " + Hash.runSHA3(arrayBuffer, ["224"]) + - "\nSHA3 256: " + Hash.runSHA3(arrayBuffer, ["256"]) + - "\nSHA3 384: " + Hash.runSHA3(arrayBuffer, ["384"]) + - "\nSHA3 512: " + Hash.runSHA3(arrayBuffer, ["512"]) + - "\nKeccak 224: " + Hash.runKeccak(arrayBuffer, ["224"]) + - "\nKeccak 256: " + Hash.runKeccak(arrayBuffer, ["256"]) + - "\nKeccak 384: " + Hash.runKeccak(arrayBuffer, ["384"]) + - "\nKeccak 512: " + Hash.runKeccak(arrayBuffer, ["512"]) + - "\nShake 128: " + Hash.runShake(arrayBuffer, ["128", 256]) + - "\nShake 256: " + Hash.runShake(arrayBuffer, ["256", 512]) + - "\nRIPEMD-128: " + Hash.runRIPEMD(arrayBuffer, ["128"]) + - "\nRIPEMD-160: " + Hash.runRIPEMD(arrayBuffer, ["160"]) + - "\nRIPEMD-256: " + Hash.runRIPEMD(arrayBuffer, ["256"]) + - "\nRIPEMD-320: " + Hash.runRIPEMD(arrayBuffer, ["320"]) + - "\nHAS-160: " + Hash.runHAS(arrayBuffer, []) + - "\nWhirlpool-0: " + Hash.runWhirlpool(arrayBuffer, ["Whirlpool-0"]) + - "\nWhirlpool-T: " + Hash.runWhirlpool(arrayBuffer, ["Whirlpool-T"]) + - "\nWhirlpool: " + Hash.runWhirlpool(arrayBuffer, ["Whirlpool"]) + - "\nSSDEEP: " + Hash.runSSDEEP(str) + - "\nCTPH: " + Hash.runCTPH(str) + - "\n\nChecksums:" + - "\nFletcher-8: " + Checksum.runFletcher8(byteArray, []) + - "\nFletcher-16: " + Checksum.runFletcher16(byteArray, []) + - "\nFletcher-32: " + Checksum.runFletcher32(byteArray, []) + - "\nFletcher-64: " + Checksum.runFletcher64(byteArray, []) + - "\nAdler-32: " + Checksum.runAdler32(byteArray, []) + - "\nCRC-16: " + Checksum.runCRC16(str, []) + - "\nCRC-32: " + Checksum.runCRC32(str, []); - - return output; - }, - - - /** - * Analyse hash operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runAnalyse: function(input, args) { - input = input.replace(/\s/g, ""); - - let output = "", - byteLength = input.length / 2, - bitLength = byteLength * 8, - possibleHashFunctions = []; - - if (!/^[a-f0-9]+$/i.test(input)) { - return "Invalid hash"; - } - - output += "Hash length: " + input.length + "\n" + - "Byte length: " + byteLength + "\n" + - "Bit length: " + bitLength + "\n\n" + - "Based on the length, this hash could have been generated by one of the following hashing functions:\n"; - - switch (bitLength) { - case 4: - possibleHashFunctions = [ - "Fletcher-4", - "Luhn algorithm", - "Verhoeff algorithm", - ]; - break; - case 8: - possibleHashFunctions = [ - "Fletcher-8", - ]; - break; - case 16: - possibleHashFunctions = [ - "BSD checksum", - "CRC-16", - "SYSV checksum", - "Fletcher-16" - ]; - break; - case 32: - possibleHashFunctions = [ - "CRC-32", - "Fletcher-32", - "Adler-32", - ]; - break; - case 64: - possibleHashFunctions = [ - "CRC-64", - "RIPEMD-64", - "SipHash", - ]; - break; - case 128: - possibleHashFunctions = [ - "MD5", - "MD4", - "MD2", - "HAVAL-128", - "RIPEMD-128", - "Snefru", - "Tiger-128", - ]; - break; - case 160: - possibleHashFunctions = [ - "SHA-1", - "SHA-0", - "FSB-160", - "HAS-160", - "HAVAL-160", - "RIPEMD-160", - "Tiger-160", - ]; - break; - case 192: - possibleHashFunctions = [ - "Tiger", - "HAVAL-192", - ]; - break; - case 224: - possibleHashFunctions = [ - "SHA-224", - "SHA3-224", - "ECOH-224", - "FSB-224", - "HAVAL-224", - ]; - break; - case 256: - possibleHashFunctions = [ - "SHA-256", - "SHA3-256", - "BLAKE-256", - "ECOH-256", - "FSB-256", - "GOST", - "Grøstl-256", - "HAVAL-256", - "PANAMA", - "RIPEMD-256", - "Snefru", - ]; - break; - case 320: - possibleHashFunctions = [ - "RIPEMD-320", - ]; - break; - case 384: - possibleHashFunctions = [ - "SHA-384", - "SHA3-384", - "ECOH-384", - "FSB-384", - ]; - break; - case 512: - possibleHashFunctions = [ - "SHA-512", - "SHA3-512", - "BLAKE-512", - "ECOH-512", - "FSB-512", - "Grøstl-512", - "JH", - "MD6", - "Spectral Hash", - "SWIFFT", - "Whirlpool", - ]; - break; - case 1024: - possibleHashFunctions = [ - "Fowler-Noll-Vo", - ]; - break; - default: - possibleHashFunctions = [ - "Unknown" - ]; - break; - } - - return output + possibleHashFunctions.join("\n"); - }, - -}; - -export default Hash; diff --git a/src/core/operations/legacy/Hexdump.js b/src/core/operations/legacy/Hexdump.js deleted file mode 100755 index 2626217a..00000000 --- a/src/core/operations/legacy/Hexdump.js +++ /dev/null @@ -1,203 +0,0 @@ -import Utils from "../Utils.js"; -import {fromHex} from "../lib/Hex"; - - -/** - * Hexdump operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Hexdump = { - - /** - * @constant - * @default - */ - WIDTH: 16, - /** - * @constant - * @default - */ - UPPER_CASE: false, - /** - * @constant - * @default - */ - INCLUDE_FINAL_LENGTH: false, - - /** - * To Hexdump operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {string} - */ - runTo: function(input, args) { - const data = new Uint8Array(input); - const length = args[0] || Hexdump.WIDTH; - const upperCase = args[1]; - const includeFinalLength = args[2]; - - let output = "", padding = 2; - for (let i = 0; i < data.length; i += length) { - const buff = data.slice(i, i+length); - let hexa = ""; - for (let j = 0; j < buff.length; j++) { - hexa += Utils.hex(buff[j], padding) + " "; - } - - let lineNo = Utils.hex(i, 8); - - if (upperCase) { - hexa = hexa.toUpperCase(); - lineNo = lineNo.toUpperCase(); - } - - output += lineNo + " " + - hexa.padEnd(length*(padding+1), " ") + - " |" + Utils.printable(Utils.byteArrayToChars(buff)).padEnd(buff.length, " ") + "|\n"; - - if (includeFinalLength && i+buff.length === data.length) { - output += Utils.hex(i+buff.length, 8) + "\n"; - } - } - - return output.slice(0, -1); - }, - - - /** - * From Hexdump operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFrom: function(input, args) { - let output = [], - regex = /^\s*(?:[\dA-F]{4,16}h?:?)?\s*((?:[\dA-F]{2}\s){1,8}(?:\s|[\dA-F]{2}-)(?:[\dA-F]{2}\s){1,8}|(?:[\dA-F]{2}\s|[\dA-F]{4}\s)+)/igm, - block, line; - - while ((block = regex.exec(input))) { - line = fromHex(block[1].replace(/-/g, " ")); - for (let i = 0; i < line.length; i++) { - output.push(line[i]); - } - } - // Is this a CyberChef hexdump or is it from a different tool? - const width = input.indexOf("\n"); - const w = (width - 13) / 4; - // w should be the specified width of the hexdump and therefore a round number - if (Math.floor(w) !== w || input.indexOf("\r") !== -1 || output.indexOf(13) !== -1) { - if (ENVIRONMENT_IS_WORKER()) self.setOption("attemptHighlight", false); - } - return output; - }, - - - /** - * Highlight to hexdump - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlightTo: function(pos, args) { - // Calculate overall selection - let w = args[0] || 16, - width = 14 + (w*4), - line = Math.floor(pos[0].start / w), - offset = pos[0].start % w, - start = 0, - end = 0; - - pos[0].start = line*width + 10 + offset*3; - - line = Math.floor(pos[0].end / w); - offset = pos[0].end % w; - if (offset === 0) { - line--; - offset = w; - } - pos[0].end = line*width + 10 + offset*3 - 1; - - // Set up multiple selections for bytes - let startLineNum = Math.floor(pos[0].start / width); - const endLineNum = Math.floor(pos[0].end / width); - - if (startLineNum === endLineNum) { - pos.push(pos[0]); - } else { - start = pos[0].start; - end = (startLineNum+1) * width - w - 5; - pos.push({ start: start, end: end }); - while (end < pos[0].end) { - startLineNum++; - start = startLineNum * width + 10; - end = (startLineNum+1) * width - w - 5; - if (end > pos[0].end) end = pos[0].end; - pos.push({ start: start, end: end }); - } - } - - // Set up multiple selections for ASCII - let len = pos.length, lineNum = 0; - start = 0; - end = 0; - for (let i = 1; i < len; i++) { - lineNum = Math.floor(pos[i].start / width); - start = (((pos[i].start - (lineNum * width)) - 10) / 3) + (width - w -2) + (lineNum * width); - end = (((pos[i].end + 1 - (lineNum * width)) - 10) / 3) + (width - w -2) + (lineNum * width); - pos.push({ start: start, end: end }); - } - return pos; - }, - - - /** - * Highlight from hexdump - * - * @param {Object[]} pos - * @param {number} pos[].start - * @param {number} pos[].end - * @param {Object[]} args - * @returns {Object[]} pos - */ - highlightFrom: function(pos, args) { - const w = args[0] || 16; - const width = 14 + (w*4); - - let line = Math.floor(pos[0].start / width); - let offset = pos[0].start % width; - - if (offset < 10) { // In line number section - pos[0].start = line*w; - } else if (offset > 10+(w*3)) { // In ASCII section - pos[0].start = (line+1)*w; - } else { // In byte section - pos[0].start = line*w + Math.floor((offset-10)/3); - } - - line = Math.floor(pos[0].end / width); - offset = pos[0].end % width; - - if (offset < 10) { // In line number section - pos[0].end = line*w; - } else if (offset > 10+(w*3)) { // In ASCII section - pos[0].end = (line+1)*w; - } else { // In byte section - pos[0].end = line*w + Math.ceil((offset-10)/3); - } - - return pos; - }, - -}; - -export default Hexdump; diff --git a/src/core/operations/legacy/IP.js b/src/core/operations/legacy/IP.js deleted file mode 100755 index c4c3c18f..00000000 --- a/src/core/operations/legacy/IP.js +++ /dev/null @@ -1,1086 +0,0 @@ -import Utils from "../Utils.js"; -import {toHex, fromHex} from "../lib/Hex"; -import Checksum from "./Checksum.js"; -import {BigInteger} from "jsbn"; - - -/** - * Internet Protocol address operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const IP = { - - /** - * @constant - * @default - */ - INCLUDE_NETWORK_INFO: true, - /** - * @constant - * @default - */ - ENUMERATE_ADDRESSES: true, - /** - * @constant - * @default - */ - ALLOW_LARGE_LIST: false, - - /** - * Parse IP range operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseIpRange: function (input, args) { - let includeNetworkInfo = args[0], - enumerateAddresses = args[1], - allowLargeList = args[2]; - - // Check what type of input we are looking at - let ipv4CidrRegex = /^\s*((?:\d{1,3}\.){3}\d{1,3})\/(\d\d?)\s*$/, - ipv4RangeRegex = /^\s*((?:\d{1,3}\.){3}\d{1,3})\s*-\s*((?:\d{1,3}\.){3}\d{1,3})\s*$/, - ipv6CidrRegex = /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\/(\d\d?\d?)\s*$/i, - ipv6RangeRegex = /^\s*(((?=.*::)(?!.*::[^-]+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*-\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\17)::|:\b|(?![\dA-F])))|(?!\16\17)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*$/i, - match; - - if ((match = ipv4CidrRegex.exec(input))) { - return IP._ipv4CidrRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); - } else if ((match = ipv4RangeRegex.exec(input))) { - return IP._ipv4HyphenatedRange(match, includeNetworkInfo, enumerateAddresses, allowLargeList); - } else if ((match = ipv6CidrRegex.exec(input))) { - return IP._ipv6CidrRange(match, includeNetworkInfo); - } else if ((match = ipv6RangeRegex.exec(input))) { - return IP._ipv6HyphenatedRange(match, includeNetworkInfo); - } else { - return "Invalid input.\n\nEnter either a CIDR range (e.g. 10.0.0.0/24) or a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0). IPv6 also supported."; - } - }, - - - /** - * @constant - * @default - */ - IPV4_REGEX: /^\s*((?:\d{1,3}\.){3}\d{1,3})\s*$/, - /** - * @constant - * @default - */ - IPV6_REGEX: /^\s*(((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\4)::|:\b|(?![\dA-F])))|(?!\3\4)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4}))\s*$/i, - - /** - * Parse IPv6 address operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseIPv6: function (input, args) { - let match, - output = ""; - - if ((match = IP.IPV6_REGEX.exec(input))) { - let ipv6 = IP._strToIpv6(match[1]), - longhand = IP._ipv6ToStr(ipv6), - shorthand = IP._ipv6ToStr(ipv6, true); - - output += "Longhand: " + longhand + "\nShorthand: " + shorthand + "\n"; - - // Detect reserved addresses - if (shorthand === "::") { - // Unspecified address - output += "\nUnspecified address corresponding to 0.0.0.0/32 in IPv4."; - output += "\nUnspecified address range: ::/128"; - } else if (shorthand === "::1") { - // Loopback address - output += "\nLoopback address to the local host corresponding to 127.0.0.1/8 in IPv4."; - output += "\nLoopback addresses range: ::1/128"; - } else if (ipv6[0] === 0 && ipv6[1] === 0 && ipv6[2] === 0 && - ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0xffff) { - // IPv4-mapped IPv6 address - output += "\nIPv4-mapped IPv6 address detected. IPv6 clients will be handled natively by default, and IPv4 clients appear as IPv6 clients at their IPv4-mapped IPv6 address."; - output += "\nMapped IPv4 address: " + IP._ipv4ToStr((ipv6[6] << 16) + ipv6[7]); - output += "\nIPv4-mapped IPv6 addresses range: ::ffff:0:0/96"; - } else if (ipv6[0] === 0 && ipv6[1] === 0 && ipv6[2] === 0 && - ipv6[3] === 0 && ipv6[4] === 0xffff && ipv6[5] === 0) { - // IPv4-translated address - output += "\nIPv4-translated address detected. Used by Stateless IP/ICMP Translation (SIIT). See RFCs 6145 and 6052 for more details."; - output += "\nTranslated IPv4 address: " + IP._ipv4ToStr((ipv6[6] << 16) + ipv6[7]); - output += "\nIPv4-translated addresses range: ::ffff:0:0:0/96"; - } else if (ipv6[0] === 0x100) { - // Discard prefix per RFC 6666 - output += "\nDiscard prefix detected. This is used when forwarding traffic to a sinkhole router to mitigate the effects of a denial-of-service attack. See RFC 6666 for more details."; - output += "\nDiscard range: 100::/64"; - } else if (ipv6[0] === 0x64 && ipv6[1] === 0xff9b && ipv6[2] === 0 && - ipv6[3] === 0 && ipv6[4] === 0 && ipv6[5] === 0) { - // IPv4/IPv6 translation per RFC 6052 - output += "\n'Well-Known' prefix for IPv4/IPv6 translation detected. See RFC 6052 for more details."; - output += "\nTranslated IPv4 address: " + IP._ipv4ToStr((ipv6[6] << 16) + ipv6[7]); - output += "\n'Well-Known' prefix range: 64:ff9b::/96"; - } else if (ipv6[0] === 0x2001 && ipv6[1] === 0) { - // Teredo tunneling - output += "\nTeredo tunneling IPv6 address detected\n"; - let serverIpv4 = (ipv6[2] << 16) + ipv6[3], - udpPort = (~ipv6[5]) & 0xffff, - clientIpv4 = ~((ipv6[6] << 16) + ipv6[7]), - flagCone = (ipv6[4] >>> 15) & 1, - flagR = (ipv6[4] >>> 14) & 1, - flagRandom1 = (ipv6[4] >>> 10) & 15, - flagUg = (ipv6[4] >>> 8) & 3, - flagRandom2 = ipv6[4] & 255; - - output += "\nServer IPv4 address: " + IP._ipv4ToStr(serverIpv4) + - "\nClient IPv4 address: " + IP._ipv4ToStr(clientIpv4) + - "\nClient UDP port: " + udpPort + - "\nFlags:" + - "\n\tCone: " + flagCone; - - if (flagCone) { - output += " (Client is behind a cone NAT)"; - } else { - output += " (Client is not behind a cone NAT)"; - } - - output += "\n\tR: " + flagR; - - if (flagR) { - output += " Error: This flag should be set to 0. See RFC 5991 and RFC 4380."; - } - - output += "\n\tRandom1: " + Utils.bin(flagRandom1, 4) + - "\n\tUG: " + Utils.bin(flagUg, 2); - - if (flagUg) { - output += " Error: This flag should be set to 00. See RFC 4380."; - } - - output += "\n\tRandom2: " + Utils.bin(flagRandom2, 8); - - if (!flagR && !flagUg && flagRandom1 && flagRandom2) { - output += "\n\nThis is a valid Teredo address which complies with RFC 4380 and RFC 5991."; - } else if (!flagR && !flagUg) { - output += "\n\nThis is a valid Teredo address which complies with RFC 4380, however it does not comply with RFC 5991 (Teredo Security Updates) as there are no randomised bits in the flag field."; - } else { - output += "\n\nThis is an invalid Teredo address."; - } - output += "\n\nTeredo prefix range: 2001::/32"; - } else if (ipv6[0] === 0x2001 && ipv6[1] === 0x2 && ipv6[2] === 0) { - // Benchmarking - output += "\nAssigned to the Benchmarking Methodology Working Group (BMWG) for benchmarking IPv6. Corresponds to 198.18.0.0/15 for benchmarking IPv4. See RFC 5180 for more details."; - output += "\nBMWG range: 2001:2::/48"; - } else if (ipv6[0] === 0x2001 && ipv6[1] >= 0x10 && ipv6[1] <= 0x1f) { - // ORCHIDv1 - output += "\nDeprecated, previously ORCHIDv1 (Overlay Routable Cryptographic Hash Identifiers).\nORCHIDv1 range: 2001:10::/28\nORCHIDv2 now uses 2001:20::/28."; - } else if (ipv6[0] === 0x2001 && ipv6[1] >= 0x20 && ipv6[1] <= 0x2f) { - // ORCHIDv2 - output += "\nORCHIDv2 (Overlay Routable Cryptographic Hash Identifiers).\nThese are non-routed IPv6 addresses used for Cryptographic Hash Identifiers."; - output += "\nORCHIDv2 range: 2001:20::/28"; - } else if (ipv6[0] === 0x2001 && ipv6[1] === 0xdb8) { - // Documentation - output += "\nThis is a documentation IPv6 address. This range should be used whenever an example IPv6 address is given or to model networking scenarios. Corresponds to 192.0.2.0/24, 198.51.100.0/24, and 203.0.113.0/24 in IPv4."; - output += "\nDocumentation range: 2001:db8::/32"; - } else if (ipv6[0] === 0x2002) { - // 6to4 - output += "\n6to4 transition IPv6 address detected. See RFC 3056 for more details." + - "\n6to4 prefix range: 2002::/16"; - - let v4Addr = IP._ipv4ToStr((ipv6[1] << 16) + ipv6[2]), - slaId = ipv6[3], - interfaceIdStr = ipv6[4].toString(16) + ipv6[5].toString(16) + ipv6[6].toString(16) + ipv6[7].toString(16), - interfaceId = new BigInteger(interfaceIdStr, 16); - - output += "\n\nEncapsulated IPv4 address: " + v4Addr + - "\nSLA ID: " + slaId + - "\nInterface ID (base 16): " + interfaceIdStr + - "\nInterface ID (base 10): " + interfaceId.toString(); - } else if (ipv6[0] >= 0xfc00 && ipv6[0] <= 0xfdff) { - // Unique local address - output += "\nThis is a unique local address comparable to the IPv4 private addresses 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16. See RFC 4193 for more details."; - output += "\nUnique local addresses range: fc00::/7"; - } else if (ipv6[0] >= 0xfe80 && ipv6[0] <= 0xfebf) { - // Link-local address - output += "\nThis is a link-local address comparable to the auto-configuration addresses 169.254.0.0/16 in IPv4."; - output += "\nLink-local addresses range: fe80::/10"; - } else if (ipv6[0] >= 0xff00) { - // Multicast - output += "\nThis is a reserved multicast address."; - output += "\nMulticast addresses range: ff00::/8"; - } - - - // Detect possible EUI-64 addresses - if ((ipv6[5] & 0xff === 0xff) && (ipv6[6] >>> 8 === 0xfe)) { - output += "\n\nThis IPv6 address contains a modified EUI-64 address, identified by the presence of FF:FE in the 12th and 13th octets."; - - let intIdent = Utils.hex(ipv6[4] >>> 8) + ":" + Utils.hex(ipv6[4] & 0xff) + ":" + - Utils.hex(ipv6[5] >>> 8) + ":" + Utils.hex(ipv6[5] & 0xff) + ":" + - Utils.hex(ipv6[6] >>> 8) + ":" + Utils.hex(ipv6[6] & 0xff) + ":" + - Utils.hex(ipv6[7] >>> 8) + ":" + Utils.hex(ipv6[7] & 0xff), - mac = Utils.hex((ipv6[4] >>> 8) ^ 2) + ":" + Utils.hex(ipv6[4] & 0xff) + ":" + - Utils.hex(ipv6[5] >>> 8) + ":" + Utils.hex(ipv6[6] & 0xff) + ":" + - Utils.hex(ipv6[7] >>> 8) + ":" + Utils.hex(ipv6[7] & 0xff); - output += "\nInterface identifier: " + intIdent + - "\nMAC address: " + mac; - } - } else { - return "Invalid IPv6 address"; - } - return output; - }, - - - /** - * @constant - * @default - */ - IP_FORMAT_LIST: ["Dotted Decimal", "Decimal", "Hex"], - - /** - * Change IP format operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runChangeIpFormat: function(input, args) { - let inFormat = args[0], - outFormat = args[1], - lines = input.split("\n"), - output = "", - j = 0; - - - for (let i = 0; i < lines.length; i++) { - if (lines[i] === "") continue; - let baIp = []; - let octets; - let decimal; - - if (inFormat === outFormat) { - output += lines[i] + "\n"; - continue; - } - - // Convert to byte array IP from input format - switch (inFormat) { - case "Dotted Decimal": - octets = lines[i].split("."); - for (j = 0; j < octets.length; j++) { - baIp.push(parseInt(octets[j], 10)); - } - break; - case "Decimal": - decimal = lines[i].toString(); - baIp.push(decimal >> 24 & 255); - baIp.push(decimal >> 16 & 255); - baIp.push(decimal >> 8 & 255); - baIp.push(decimal & 255); - break; - case "Hex": - baIp = fromHex(lines[i]); - break; - default: - throw "Unsupported input IP format"; - } - - let ddIp; - let decIp; - let hexIp; - - // Convert byte array IP to output format - switch (outFormat) { - case "Dotted Decimal": - ddIp = ""; - for (j = 0; j < baIp.length; j++) { - ddIp += baIp[j] + "."; - } - output += ddIp.slice(0, ddIp.length-1) + "\n"; - break; - case "Decimal": - decIp = ((baIp[0] << 24) | (baIp[1] << 16) | (baIp[2] << 8) | baIp[3]) >>> 0; - output += decIp.toString() + "\n"; - break; - case "Hex": - hexIp = ""; - for (j = 0; j < baIp.length; j++) { - hexIp += Utils.hex(baIp[j]); - } - output += hexIp + "\n"; - break; - default: - throw "Unsupported output IP format"; - } - } - - return output.slice(0, output.length-1); - }, - - - /** - * @constant - * @default - */ - DELIM_OPTIONS: ["Line feed", "CRLF", "Space", "Comma", "Semi-colon"], - /** - * @constant - * @default - */ - GROUP_CIDR: 24, - /** - * @constant - * @default - */ - GROUP_ONLY_SUBNET: false, - - /** - * Group IP addresses operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runGroupIps: function(input, args) { - let delim = Utils.charRep(args[0]), - cidr = args[1], - onlySubnets = args[2], - ipv4Mask = cidr < 32 ? ~(0xFFFFFFFF >>> cidr) : 0xFFFFFFFF, - ipv6Mask = IP._genIpv6Mask(cidr), - ips = input.split(delim), - ipv4Networks = {}, - ipv6Networks = {}, - match = null, - output = "", - ip = null, - network = null, - networkStr = "", - i; - - if (cidr < 0 || cidr > 127) { - return "CIDR must be less than 32 for IPv4 or 128 for IPv6"; - } - - // Parse all IPs and add to network dictionary - for (i = 0; i < ips.length; i++) { - if ((match = IP.IPV4_REGEX.exec(ips[i]))) { - ip = IP._strToIpv4(match[1]) >>> 0; - network = ip & ipv4Mask; - - if (ipv4Networks.hasOwnProperty(network)) { - ipv4Networks[network].push(ip); - } else { - ipv4Networks[network] = [ip]; - } - } else if ((match = IP.IPV6_REGEX.exec(ips[i]))) { - ip = IP._strToIpv6(match[1]); - network = []; - networkStr = ""; - - for (let j = 0; j < 8; j++) { - network.push(ip[j] & ipv6Mask[j]); - } - - networkStr = IP._ipv6ToStr(network, true); - - if (ipv6Networks.hasOwnProperty(networkStr)) { - ipv6Networks[networkStr].push(ip); - } else { - ipv6Networks[networkStr] = [ip]; - } - } - } - - // Sort IPv4 network dictionaries and print - for (network in ipv4Networks) { - ipv4Networks[network] = ipv4Networks[network].sort(); - - output += IP._ipv4ToStr(network) + "/" + cidr + "\n"; - - if (!onlySubnets) { - for (i = 0; i < ipv4Networks[network].length; i++) { - output += " " + IP._ipv4ToStr(ipv4Networks[network][i]) + "\n"; - } - output += "\n"; - } - } - - // Sort IPv6 network dictionaries and print - for (networkStr in ipv6Networks) { - //ipv6Networks[networkStr] = ipv6Networks[networkStr].sort(); TODO - - output += networkStr + "/" + cidr + "\n"; - - if (!onlySubnets) { - for (i = 0; i < ipv6Networks[networkStr].length; i++) { - output += " " + IP._ipv6ToStr(ipv6Networks[networkStr][i], true) + "\n"; - } - output += "\n"; - } - } - - return output; - }, - - - /** - * @constant - * @default - */ - IP_HEADER_FORMAT: ["Hex", "Raw"], - - /** - * Parse IPv4 header operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {html} - */ - runParseIPv4Header: function(input, args) { - let format = args[0], - output; - - if (format === "Hex") { - input = fromHex(input); - } else if (format === "Raw") { - input = Utils.strToByteArray(input); - } else { - return "Unrecognised input format."; - } - - let version = (input[0] >>> 4) & 0x0f, - ihl = input[0] & 0x0f, - dscp = (input[1] >>> 2) & 0x3f, - ecn = input[1] & 0x03, - length = input[2] << 8 | input[3], - identification = input[4] << 8 | input[5], - flags = (input[6] >>> 5) & 0x07, - fragOffset = (input[6] & 0x1f) << 8 | input[7], - ttl = input[8], - protocol = input[9], - checksum = input[10] << 8 | input[11], - srcIP = input[12] << 24 | input[13] << 16 | input[14] << 8 | input[15], - dstIP = input[16] << 24 | input[17] << 16 | input[18] << 8 | input[19], - checksumHeader = input.slice(0, 10).concat([0, 0]).concat(input.slice(12, 20)), - options = []; - - // Version - if (version !== 4) { - version = version + " (Error: for IPv4 headers, this should always be set to 4)"; - } - - // IHL - if (ihl < 5) { - ihl = ihl + " (Error: this should always be at least 5)"; - } else if (ihl > 5) { - // sort out options... - const optionsLen = ihl * 4 - 20; - options = input.slice(20, optionsLen + 20); - } - - // Protocol - const protocolInfo = IP._protocolLookup[protocol] || {keyword: "", protocol: ""}; - - // Checksum - let correctChecksum = Checksum.runTCPIP(checksumHeader, []), - givenChecksum = Utils.hex(checksum), - checksumResult; - if (correctChecksum === givenChecksum) { - checksumResult = givenChecksum + " (correct)"; - } else { - checksumResult = givenChecksum + " (incorrect, should be " + correctChecksum + ")"; - } - - output = "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - "" + - ""; - - if (ihl > 5) { - output += ""; - } - - return output + "
FieldValue
Version" + version + "
Internet Header Length (IHL)" + ihl + " (" + (ihl * 4) + " bytes)
Differentiated Services Code Point (DSCP)" + dscp + "
Explicit Congestion Notification (ECN)" + ecn + "
Total length" + length + " bytes" + - "\n IP header: " + (ihl * 4) + " bytes" + - "\n Data: " + (length - ihl * 4) + " bytes
Identification0x" + Utils.hex(identification) + " (" + identification + ")
Flags0x" + Utils.hex(flags, 2) + - "\n Reserved bit:" + (flags >> 2) + " (must be 0)" + - "\n Don't fragment:" + (flags >> 1 & 1) + - "\n More fragments:" + (flags & 1) + "
Fragment offset" + fragOffset + "
Time-To-Live" + ttl + "
Protocol" + protocol + ", " + protocolInfo.protocol + " (" + protocolInfo.keyword + ")
Header checksum" + checksumResult + "
Source IP address" + IP._ipv4ToStr(srcIP) + "
Destination IP address" + IP._ipv4ToStr(dstIP) + "
Options" + toHex(options) + "
"; - }, - - - /** - * @constant - * @default - * @private - */ - _LARGE_RANGE_ERROR: "The specified range contains more than 65,536 addresses. Running this query could crash your browser. If you want to run it, select the \"Allow large queries\" option. You are advised to turn off \"Auto Bake\" whilst editing large ranges.", - - /** - * Parses an IPv4 CIDR range (e.g. 192.168.0.0/24) and displays information about it. - * - * @private - * @param {RegExp} cidr - * @param {boolean} includeNetworkInfo - * @param {boolean} enumerateAddresses - * @param {boolean} allowLargeList - * @returns {string} - */ - _ipv4CidrRange: function(cidr, includeNetworkInfo, enumerateAddresses, allowLargeList) { - let output = "", - network = IP._strToIpv4(cidr[1]), - cidrRange = parseInt(cidr[2], 10); - - if (cidrRange < 0 || cidrRange > 31) { - return "IPv4 CIDR must be less than 32"; - } - - let mask = ~(0xFFFFFFFF >>> cidrRange), - ip1 = network & mask, - ip2 = ip1 | ~mask; - - if (includeNetworkInfo) { - output += "Network: " + IP._ipv4ToStr(network) + "\n"; - output += "CIDR: " + cidrRange + "\n"; - output += "Mask: " + IP._ipv4ToStr(mask) + "\n"; - output += "Range: " + IP._ipv4ToStr(ip1) + " - " + IP._ipv4ToStr(ip2) + "\n"; - output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; - } - - if (enumerateAddresses) { - if (cidrRange >= 16 || allowLargeList) { - output += IP._generateIpv4Range(ip1, ip2).join("\n"); - } else { - output += IP._LARGE_RANGE_ERROR; - } - } - return output; - }, - - - /** - * Parses an IPv6 CIDR range (e.g. ff00::/48) and displays information about it. - * - * @private - * @param {RegExp} cidr - * @param {boolean} includeNetworkInfo - * @returns {string} - */ - _ipv6CidrRange: function(cidr, includeNetworkInfo) { - let output = "", - network = IP._strToIpv6(cidr[1]), - cidrRange = parseInt(cidr[cidr.length-1], 10); - - if (cidrRange < 0 || cidrRange > 127) { - return "IPv6 CIDR must be less than 128"; - } - - let mask = IP._genIpv6Mask(cidrRange), - ip1 = new Array(8), - ip2 = new Array(8), - totalDiff = "", - total = new Array(128); - - for (let i = 0; i < 8; i++) { - ip1[i] = network[i] & mask[i]; - ip2[i] = ip1[i] | (~mask[i] & 0x0000FFFF); - totalDiff = (ip2[i] - ip1[i]).toString(2); - - if (totalDiff !== "0") { - for (let n = 0; n < totalDiff.length; n++) { - total[i*16 + 16-(totalDiff.length-n)] = totalDiff[n]; - } - } - } - - if (includeNetworkInfo) { - output += "Network: " + IP._ipv6ToStr(network) + "\n"; - output += "Shorthand: " + IP._ipv6ToStr(network, true) + "\n"; - output += "CIDR: " + cidrRange + "\n"; - output += "Mask: " + IP._ipv6ToStr(mask) + "\n"; - output += "Range: " + IP._ipv6ToStr(ip1) + " - " + IP._ipv6ToStr(ip2) + "\n"; - output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; - } - - return output; - }, - - - /** - * Generates an IPv6 subnet mask given a CIDR value. - * - * @private - * @param {number} cidr - * @returns {number[]} - */ - _genIpv6Mask: function(cidr) { - let mask = new Array(8), - shift; - - for (let i = 0; i < 8; i++) { - if (cidr > ((i+1)*16)) { - mask[i] = 0x0000FFFF; - } else { - shift = cidr-(i*16); - if (shift < 0) shift = 0; - mask[i] = ~((0x0000FFFF >>> shift) | 0xFFFF0000); - } - } - - return mask; - }, - - - /** - * Parses an IPv4 hyphenated range (e.g. 192.168.0.0 - 192.168.0.255) and displays information - * about it. - * - * @private - * @param {RegExp} range - * @param {boolean} includeNetworkInfo - * @param {boolean} enumerateAddresses - * @param {boolean} allowLargeList - * @returns {string} - */ - _ipv4HyphenatedRange: function(range, includeNetworkInfo, enumerateAddresses, allowLargeList) { - let output = "", - ip1 = IP._strToIpv4(range[1]), - ip2 = IP._strToIpv4(range[2]); - - // Calculate mask - let diff = ip1 ^ ip2, - cidr = 32, - mask = 0; - - while (diff !== 0) { - diff >>= 1; - cidr--; - mask = (mask << 1) | 1; - } - - mask = ~mask >>> 0; - let network = ip1 & mask, - subIp1 = network & mask, - subIp2 = subIp1 | ~mask; - - if (includeNetworkInfo) { - output += "Minimum subnet required to hold this range:\n"; - output += "\tNetwork: " + IP._ipv4ToStr(network) + "\n"; - output += "\tCIDR: " + cidr + "\n"; - output += "\tMask: " + IP._ipv4ToStr(mask) + "\n"; - output += "\tSubnet range: " + IP._ipv4ToStr(subIp1) + " - " + IP._ipv4ToStr(subIp2) + "\n"; - output += "\tTotal addresses in subnet: " + (((subIp2 - subIp1) >>> 0) + 1) + "\n\n"; - output += "Range: " + IP._ipv4ToStr(ip1) + " - " + IP._ipv4ToStr(ip2) + "\n"; - output += "Total addresses in range: " + (((ip2 - ip1) >>> 0) + 1) + "\n\n"; - } - - if (enumerateAddresses) { - if (((ip2 - ip1) >>> 0) <= 65536 || allowLargeList) { - output += IP._generateIpv4Range(ip1, ip2).join("\n"); - } else { - output += IP._LARGE_RANGE_ERROR; - } - } - return output; - }, - - - /** - * Parses an IPv6 hyphenated range (e.g. ff00:: - ffff::) and displays information about it. - * - * @private - * @param {RegExp} range - * @param {boolean} includeNetworkInfo - * @returns {string} - */ - _ipv6HyphenatedRange: function(range, includeNetworkInfo) { - let output = "", - ip1 = IP._strToIpv6(range[1]), - ip2 = IP._strToIpv6(range[14]); - - let t = "", - total = new Array(128).fill(), - i; - - for (i = 0; i < 8; i++) { - t = (ip2[i] - ip1[i]).toString(2); - if (t !== "0") { - for (let n = 0; n < t.length; n++) { - total[i*16 + 16-(t.length-n)] = t[n]; - } - } - } - - if (includeNetworkInfo) { - output += "Range: " + IP._ipv6ToStr(ip1) + " - " + IP._ipv6ToStr(ip2) + "\n"; - output += "Shorthand range: " + IP._ipv6ToStr(ip1, true) + " - " + IP._ipv6ToStr(ip2, true) + "\n"; - output += "Total addresses in range: " + (parseInt(total.join(""), 2) + 1) + "\n\n"; - } - - return output; - }, - - - /** - * Converts an IPv4 address from string format to numerical format. - * - * @private - * @param {string} ipStr - * @returns {number} - * - * @example - * // returns 168427520 - * IP._strToIpv4("10.10.0.0"); - */ - _strToIpv4: function (ipStr) { - let blocks = ipStr.split("."), - numBlocks = parseBlocks(blocks), - result = 0; - - result += numBlocks[0] << 24; - result += numBlocks[1] << 16; - result += numBlocks[2] << 8; - result += numBlocks[3]; - - return result; - - /** - * Converts a list of 4 numeric strings in the range 0-255 to a list of numbers. - */ - function parseBlocks(blocks) { - if (blocks.length !== 4) - throw "More than 4 blocks."; - - const numBlocks = []; - for (let i = 0; i < 4; i++) { - numBlocks[i] = parseInt(blocks[i], 10); - if (numBlocks[i] < 0 || numBlocks[i] > 255) - throw "Block out of range."; - } - return numBlocks; - } - }, - - - /** - * Converts an IPv4 address from numerical format to string format. - * - * @private - * @param {number} ipInt - * @returns {string} - * - * @example - * // returns "10.10.0.0" - * IP._ipv4ToStr(168427520); - */ - _ipv4ToStr: function(ipInt) { - let blockA = (ipInt >> 24) & 255, - blockB = (ipInt >> 16) & 255, - blockC = (ipInt >> 8) & 255, - blockD = ipInt & 255; - - return blockA + "." + blockB + "." + blockC + "." + blockD; - }, - - - /** - * Converts an IPv6 address from string format to numerical array format. - * - * @private - * @param {string} ipStr - * @returns {number[]} - * - * @example - * // returns [65280, 0, 0, 0, 0, 0, 4369, 8738] - * IP._strToIpv6("ff00::1111:2222"); - */ - _strToIpv6: function(ipStr) { - let blocks = ipStr.split(":"), - numBlocks = parseBlocks(blocks), - j = 0, - ipv6 = new Array(8); - - for (let i = 0; i < 8; i++) { - if (isNaN(numBlocks[j])) { - ipv6[i] = 0; - if (i === (8-numBlocks.slice(j).length)) j++; - } else { - ipv6[i] = numBlocks[j]; - j++; - } - } - return ipv6; - - /** - * Converts a list of 3-8 numeric hex strings in the range 0-65535 to a list of numbers. - */ - function parseBlocks(blocks) { - if (blocks.length < 3 || blocks.length > 8) - throw "Badly formatted IPv6 address."; - const numBlocks = []; - for (let i = 0; i < blocks.length; i++) { - numBlocks[i] = parseInt(blocks[i], 16); - if (numBlocks[i] < 0 || numBlocks[i] > 65535) - throw "Block out of range."; - } - return numBlocks; - } - }, - - - /** - * Converts an IPv6 address from numerical array format to string format. - * - * @private - * @param {number[]} ipv6 - * @param {boolean} compact - Whether or not to return the address in shorthand or not - * @returns {string} - * - * @example - * // returns "ff00::1111:2222" - * IP._ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], true); - * - * // returns "ff00:0000:0000:0000:0000:0000:1111:2222" - * IP._ipv6ToStr([65280, 0, 0, 0, 0, 0, 4369, 8738], false); - */ - _ipv6ToStr: function(ipv6, compact) { - let output = "", - i = 0; - - if (compact) { - let start = -1, - end = -1, - s = 0, - e = -1; - - for (i = 0; i < 8; i++) { - if (ipv6[i] === 0 && e === (i-1)) { - e = i; - } else if (ipv6[i] === 0) { - s = i; e = i; - } - if (e >= 0 && (e-s) > (end - start)) { - start = s; - end = e; - } - } - - for (i = 0; i < 8; i++) { - if (i !== start) { - output += Utils.hex(ipv6[i], 1) + ":"; - } else { - output += ":"; - i = end; - if (end === 7) output += ":"; - } - } - if (output[0] === ":") - output = ":" + output; - } else { - for (i = 0; i < 8; i++) { - output += Utils.hex(ipv6[i], 4) + ":"; - } - } - return output.slice(0, output.length-1); - }, - - - /** - * Generates a list of IPv4 addresses in string format between two given numerical values. - * - * @private - * @param {number} ip - * @param {number} endIp - * @returns {string[]} - * - * @example - * // returns ["0.0.0.1", "0.0.0.2", "0.0.0.3"] - * IP._generateIpv4Range(1, 3); - */ - _generateIpv4Range: function(ip, endIp) { - const range = []; - if (endIp >= ip) { - for (; ip <= endIp; ip++) { - range.push(IP._ipv4ToStr(ip)); - } - } else { - range[0] = "Second IP address smaller than first."; - } - return range; - }, - - - /** - * Lookup table for Internet Protocols. - * Taken from https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml - * - * @private - * @constant - */ - _protocolLookup: { - 0: {keyword: "HOPOPT", protocol: "IPv6 Hop-by-Hop Option"}, - 1: {keyword: "ICMP", protocol: "Internet Control Message"}, - 2: {keyword: "IGMP", protocol: "Internet Group Management"}, - 3: {keyword: "GGP", protocol: "Gateway-to-Gateway"}, - 4: {keyword: "IPv4", protocol: "IPv4 encapsulation"}, - 5: {keyword: "ST", protocol: "Stream"}, - 6: {keyword: "TCP", protocol: "Transmission Control"}, - 7: {keyword: "CBT", protocol: "CBT"}, - 8: {keyword: "EGP", protocol: "Exterior Gateway Protocol"}, - 9: {keyword: "IGP", protocol: "any private interior gateway (used by Cisco for their IGRP)"}, - 10: {keyword: "BBN-RCC-MON", protocol: "BBN RCC Monitoring"}, - 11: {keyword: "NVP-II", protocol: "Network Voice Protocol"}, - 12: {keyword: "PUP", protocol: "PUP"}, - 13: {keyword: "ARGUS (deprecated)", protocol: "ARGUS"}, - 14: {keyword: "EMCON", protocol: "EMCON"}, - 15: {keyword: "XNET", protocol: "Cross Net Debugger"}, - 16: {keyword: "CHAOS", protocol: "Chaos"}, - 17: {keyword: "UDP", protocol: "User Datagram"}, - 18: {keyword: "MUX", protocol: "Multiplexing"}, - 19: {keyword: "DCN-MEAS", protocol: "DCN Measurement Subsystems"}, - 20: {keyword: "HMP", protocol: "Host Monitoring"}, - 21: {keyword: "PRM", protocol: "Packet Radio Measurement"}, - 22: {keyword: "XNS-IDP", protocol: "XEROX NS IDP"}, - 23: {keyword: "TRUNK-1", protocol: "Trunk-1"}, - 24: {keyword: "TRUNK-2", protocol: "Trunk-2"}, - 25: {keyword: "LEAF-1", protocol: "Leaf-1"}, - 26: {keyword: "LEAF-2", protocol: "Leaf-2"}, - 27: {keyword: "RDP", protocol: "Reliable Data Protocol"}, - 28: {keyword: "IRTP", protocol: "Internet Reliable Transaction"}, - 29: {keyword: "ISO-TP4", protocol: "ISO Transport Protocol Class 4"}, - 30: {keyword: "NETBLT", protocol: "Bulk Data Transfer Protocol"}, - 31: {keyword: "MFE-NSP", protocol: "MFE Network Services Protocol"}, - 32: {keyword: "MERIT-INP", protocol: "MERIT Internodal Protocol"}, - 33: {keyword: "DCCP", protocol: "Datagram Congestion Control Protocol"}, - 34: {keyword: "3PC", protocol: "Third Party Connect Protocol"}, - 35: {keyword: "IDPR", protocol: "Inter-Domain Policy Routing Protocol"}, - 36: {keyword: "XTP", protocol: "XTP"}, - 37: {keyword: "DDP", protocol: "Datagram Delivery Protocol"}, - 38: {keyword: "IDPR-CMTP", protocol: "IDPR Control Message Transport Proto"}, - 39: {keyword: "TP++", protocol: "TP++ Transport Protocol"}, - 40: {keyword: "IL", protocol: "IL Transport Protocol"}, - 41: {keyword: "IPv6", protocol: "IPv6 encapsulation"}, - 42: {keyword: "SDRP", protocol: "Source Demand Routing Protocol"}, - 43: {keyword: "IPv6-Route", protocol: "Routing Header for IPv6"}, - 44: {keyword: "IPv6-Frag", protocol: "Fragment Header for IPv6"}, - 45: {keyword: "IDRP", protocol: "Inter-Domain Routing Protocol"}, - 46: {keyword: "RSVP", protocol: "Reservation Protocol"}, - 47: {keyword: "GRE", protocol: "Generic Routing Encapsulation"}, - 48: {keyword: "DSR", protocol: "Dynamic Source Routing Protocol"}, - 49: {keyword: "BNA", protocol: "BNA"}, - 50: {keyword: "ESP", protocol: "Encap Security Payload"}, - 51: {keyword: "AH", protocol: "Authentication Header"}, - 52: {keyword: "I-NLSP", protocol: "Integrated Net Layer Security TUBA"}, - 53: {keyword: "SWIPE (deprecated)", protocol: "IP with Encryption"}, - 54: {keyword: "NARP", protocol: "NBMA Address Resolution Protocol"}, - 55: {keyword: "MOBILE", protocol: "IP Mobility"}, - 56: {keyword: "TLSP", protocol: "Transport Layer Security Protocol using Kryptonet key management"}, - 57: {keyword: "SKIP", protocol: "SKIP"}, - 58: {keyword: "IPv6-ICMP", protocol: "ICMP for IPv6"}, - 59: {keyword: "IPv6-NoNxt", protocol: "No Next Header for IPv6"}, - 60: {keyword: "IPv6-Opts", protocol: "Destination Options for IPv6"}, - 61: {keyword: "", protocol: "any host internal protocol"}, - 62: {keyword: "CFTP", protocol: "CFTP"}, - 63: {keyword: "", protocol: "any local network"}, - 64: {keyword: "SAT-EXPAK", protocol: "SATNET and Backroom EXPAK"}, - 65: {keyword: "KRYPTOLAN", protocol: "Kryptolan"}, - 66: {keyword: "RVD", protocol: "MIT Remote Virtual Disk Protocol"}, - 67: {keyword: "IPPC", protocol: "Internet Pluribus Packet Core"}, - 68: {keyword: "", protocol: "any distributed file system"}, - 69: {keyword: "SAT-MON", protocol: "SATNET Monitoring"}, - 70: {keyword: "VISA", protocol: "VISA Protocol"}, - 71: {keyword: "IPCV", protocol: "Internet Packet Core Utility"}, - 72: {keyword: "CPNX", protocol: "Computer Protocol Network Executive"}, - 73: {keyword: "CPHB", protocol: "Computer Protocol Heart Beat"}, - 74: {keyword: "WSN", protocol: "Wang Span Network"}, - 75: {keyword: "PVP", protocol: "Packet Video Protocol"}, - 76: {keyword: "BR-SAT-MON", protocol: "Backroom SATNET Monitoring"}, - 77: {keyword: "SUN-ND", protocol: "SUN ND PROTOCOL-Temporary"}, - 78: {keyword: "WB-MON", protocol: "WIDEBAND Monitoring"}, - 79: {keyword: "WB-EXPAK", protocol: "WIDEBAND EXPAK"}, - 80: {keyword: "ISO-IP", protocol: "ISO Internet Protocol"}, - 81: {keyword: "VMTP", protocol: "VMTP"}, - 82: {keyword: "SECURE-VMTP", protocol: "SECURE-VMTP"}, - 83: {keyword: "VINES", protocol: "VINES"}, - 84: {keyword: "TTP", protocol: "Transaction Transport Protocol"}, - 85: {keyword: "NSFNET-IGP", protocol: "NSFNET-IGP"}, - 86: {keyword: "DGP", protocol: "Dissimilar Gateway Protocol"}, - 87: {keyword: "TCF", protocol: "TCF"}, - 88: {keyword: "EIGRP", protocol: "EIGRP"}, - 89: {keyword: "OSPFIGP", protocol: "OSPFIGP"}, - 90: {keyword: "Sprite-RPC", protocol: "Sprite RPC Protocol"}, - 91: {keyword: "LARP", protocol: "Locus Address Resolution Protocol"}, - 92: {keyword: "MTP", protocol: "Multicast Transport Protocol"}, - 93: {keyword: "AX.25", protocol: "AX.25 Frames"}, - 94: {keyword: "IPIP", protocol: "IP-within-IP Encapsulation Protocol"}, - 95: {keyword: "MICP (deprecated)", protocol: "Mobile Internetworking Control Pro."}, - 96: {keyword: "SCC-SP", protocol: "Semaphore Communications Sec. Pro."}, - 97: {keyword: "ETHERIP", protocol: "Ethernet-within-IP Encapsulation"}, - 98: {keyword: "ENCAP", protocol: "Encapsulation Header"}, - 99: {keyword: "", protocol: "any private encryption scheme"}, - 100: {keyword: "GMTP", protocol: "GMTP"}, - 101: {keyword: "IFMP", protocol: "Ipsilon Flow Management Protocol"}, - 102: {keyword: "PNNI", protocol: "PNNI over IP"}, - 103: {keyword: "PIM", protocol: "Protocol Independent Multicast"}, - 104: {keyword: "ARIS", protocol: "ARIS"}, - 105: {keyword: "SCPS", protocol: "SCPS"}, - 106: {keyword: "QNX", protocol: "QNX"}, - 107: {keyword: "A/N", protocol: "Active Networks"}, - 108: {keyword: "IPComp", protocol: "IP Payload Compression Protocol"}, - 109: {keyword: "SNP", protocol: "Sitara Networks Protocol"}, - 110: {keyword: "Compaq-Peer", protocol: "Compaq Peer Protocol"}, - 111: {keyword: "IPX-in-IP", protocol: "IPX in IP"}, - 112: {keyword: "VRRP", protocol: "Virtual Router Redundancy Protocol"}, - 113: {keyword: "PGM", protocol: "PGM Reliable Transport Protocol"}, - 114: {keyword: "", protocol: "any 0-hop protocol"}, - 115: {keyword: "L2TP", protocol: "Layer Two Tunneling Protocol"}, - 116: {keyword: "DDX", protocol: "D-II Data Exchange (DDX)"}, - 117: {keyword: "IATP", protocol: "Interactive Agent Transfer Protocol"}, - 118: {keyword: "STP", protocol: "Schedule Transfer Protocol"}, - 119: {keyword: "SRP", protocol: "SpectraLink Radio Protocol"}, - 120: {keyword: "UTI", protocol: "UTI"}, - 121: {keyword: "SMP", protocol: "Simple Message Protocol"}, - 122: {keyword: "SM (deprecated)", protocol: "Simple Multicast Protocol"}, - 123: {keyword: "PTP", protocol: "Performance Transparency Protocol"}, - 124: {keyword: "ISIS over IPv4", protocol: ""}, - 125: {keyword: "FIRE", protocol: ""}, - 126: {keyword: "CRTP", protocol: "Combat Radio Transport Protocol"}, - 127: {keyword: "CRUDP", protocol: "Combat Radio User Datagram"}, - 128: {keyword: "SSCOPMCE", protocol: ""}, - 129: {keyword: "IPLT", protocol: ""}, - 130: {keyword: "SPS", protocol: "Secure Packet Shield"}, - 131: {keyword: "PIPE", protocol: "Private IP Encapsulation within IP"}, - 132: {keyword: "SCTP", protocol: "Stream Control Transmission Protocol"}, - 133: {keyword: "FC", protocol: "Fibre Channel"}, - 134: {keyword: "RSVP-E2E-IGNORE", protocol: ""}, - 135: {keyword: "Mobility Header", protocol: ""}, - 136: {keyword: "UDPLite", protocol: ""}, - 137: {keyword: "MPLS-in-IP", protocol: ""}, - 138: {keyword: "manet", protocol: "MANET Protocols"}, - 139: {keyword: "HIP", protocol: "Host Identity Protocol"}, - 140: {keyword: "Shim6", protocol: "Shim6 Protocol"}, - 141: {keyword: "WESP", protocol: "Wrapped Encapsulating Security Payload"}, - 142: {keyword: "ROHC", protocol: "Robust Header Compression"}, - 253: {keyword: "", protocol: "Use for experimentation and testing"}, - 254: {keyword: "", protocol: "Use for experimentation and testing"}, - 255: {keyword: "Reserved", protocol: ""} - }, - -}; - -export default IP; diff --git a/src/core/operations/legacy/MAC.js b/src/core/operations/legacy/MAC.js deleted file mode 100755 index b909287f..00000000 --- a/src/core/operations/legacy/MAC.js +++ /dev/null @@ -1,105 +0,0 @@ -/** - * MAC address operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const MAC = { - - /** - * @constant - * @default - */ - OUTPUT_CASE: ["Both", "Upper only", "Lower only"], - /** - * @constant - * @default - */ - NO_DELIM: true, - /** - * @constant - * @default - */ - DASH_DELIM: true, - /** - * @constant - * @default - */ - COLON_DELIM: true, - /** - * @constant - * @default - */ - CISCO_STYLE: false, - /** - * @constant - * @default - */ - IPV6_INTERFACE_ID: false, - - /** - * Format MAC addresses operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFormat: function(input, args) { - if (!input) return ""; - - let outputCase = args[0], - noDelim = args[1], - dashDelim = args[2], - colonDelim = args[3], - ciscoStyle = args[4], - ipv6IntID = args[5], - outputList = [], - macs = input.toLowerCase().split(/[,\s\r\n]+/); - - macs.forEach(function(mac) { - let cleanMac = mac.replace(/[:.-]+/g, ""), - macHyphen = cleanMac.replace(/(.{2}(?=.))/g, "$1-"), - macColon = cleanMac.replace(/(.{2}(?=.))/g, "$1:"), - macCisco = cleanMac.replace(/(.{4}(?=.))/g, "$1."), - macIPv6 = cleanMac.slice(0, 6) + "fffe" + cleanMac.slice(6); - - macIPv6 = macIPv6.replace(/(.{4}(?=.))/g, "$1:"); - let bite = parseInt(macIPv6.slice(0, 2), 16) ^ 2; - bite = bite.toString(16).padStart(2, "0"); - macIPv6 = bite + macIPv6.slice(2); - - if (outputCase === "Lower only") { - if (noDelim) outputList.push(cleanMac); - if (dashDelim) outputList.push(macHyphen); - if (colonDelim) outputList.push(macColon); - if (ciscoStyle) outputList.push(macCisco); - if (ipv6IntID) outputList.push(macIPv6); - } else if (outputCase === "Upper only") { - if (noDelim) outputList.push(cleanMac.toUpperCase()); - if (dashDelim) outputList.push(macHyphen.toUpperCase()); - if (colonDelim) outputList.push(macColon.toUpperCase()); - if (ciscoStyle) outputList.push(macCisco.toUpperCase()); - if (ipv6IntID) outputList.push(macIPv6.toUpperCase()); - } else { - if (noDelim) outputList.push(cleanMac, cleanMac.toUpperCase()); - if (dashDelim) outputList.push(macHyphen, macHyphen.toUpperCase()); - if (colonDelim) outputList.push(macColon, macColon.toUpperCase()); - if (ciscoStyle) outputList.push(macCisco, macCisco.toUpperCase()); - if (ipv6IntID) outputList.push(macIPv6, macIPv6.toUpperCase()); - } - - outputList.push( - "" // Empty line to delimit groups - ); - }); - - // Return the data as a string - return outputList.join("\n"); - }, - -}; - -export default MAC; diff --git a/src/core/operations/legacy/MS.js b/src/core/operations/legacy/MS.js deleted file mode 100644 index a74dbe17..00000000 --- a/src/core/operations/legacy/MS.js +++ /dev/null @@ -1,213 +0,0 @@ -/** - * Microsoft operations. - * - * @author bmwhitn [brian.m.whitney@outlook.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const MS = { - - /** - * @constant - * @default - */ - D_DECODE: [ - "", - "", - "", - "", - "", - "", - "", - "", - "", - "\x57\x6E\x7B", - "\x4A\x4C\x41", - "\x0B\x0B\x0B", - "\x0C\x0C\x0C", - "\x4A\x4C\x41", - "\x0E\x0E\x0E", - "\x0F\x0F\x0F", - "\x10\x10\x10", - "\x11\x11\x11", - "\x12\x12\x12", - "\x13\x13\x13", - "\x14\x14\x14", - "\x15\x15\x15", - "\x16\x16\x16", - "\x17\x17\x17", - "\x18\x18\x18", - "\x19\x19\x19", - "\x1A\x1A\x1A", - "\x1B\x1B\x1B", - "\x1C\x1C\x1C", - "\x1D\x1D\x1D", - "\x1E\x1E\x1E", - "\x1F\x1F\x1F", - "\x2E\x2D\x32", - "\x47\x75\x30", - "\x7A\x52\x21", - "\x56\x60\x29", - "\x42\x71\x5B", - "\x6A\x5E\x38", - "\x2F\x49\x33", - "\x26\x5C\x3D", - "\x49\x62\x58", - "\x41\x7D\x3A", - "\x34\x29\x35", - "\x32\x36\x65", - "\x5B\x20\x39", - "\x76\x7C\x5C", - "\x72\x7A\x56", - "\x43\x7F\x73", - "\x38\x6B\x66", - "\x39\x63\x4E", - "\x70\x33\x45", - "\x45\x2B\x6B", - "\x68\x68\x62", - "\x71\x51\x59", - "\x4F\x66\x78", - "\x09\x76\x5E", - "\x62\x31\x7D", - "\x44\x64\x4A", - "\x23\x54\x6D", - "\x75\x43\x71", - "\x4A\x4C\x41", - "\x7E\x3A\x60", - "\x4A\x4C\x41", - "\x5E\x7E\x53", - "\x40\x4C\x40", - "\x77\x45\x42", - "\x4A\x2C\x27", - "\x61\x2A\x48", - "\x5D\x74\x72", - "\x22\x27\x75", - "\x4B\x37\x31", - "\x6F\x44\x37", - "\x4E\x79\x4D", - "\x3B\x59\x52", - "\x4C\x2F\x22", - "\x50\x6F\x54", - "\x67\x26\x6A", - "\x2A\x72\x47", - "\x7D\x6A\x64", - "\x74\x39\x2D", - "\x54\x7B\x20", - "\x2B\x3F\x7F", - "\x2D\x38\x2E", - "\x2C\x77\x4C", - "\x30\x67\x5D", - "\x6E\x53\x7E", - "\x6B\x47\x6C", - "\x66\x34\x6F", - "\x35\x78\x79", - "\x25\x5D\x74", - "\x21\x30\x43", - "\x64\x23\x26", - "\x4D\x5A\x76", - "\x52\x5B\x25", - "\x63\x6C\x24", - "\x3F\x48\x2B", - "\x7B\x55\x28", - "\x78\x70\x23", - "\x29\x69\x41", - "\x28\x2E\x34", - "\x73\x4C\x09", - "\x59\x21\x2A", - "\x33\x24\x44", - "\x7F\x4E\x3F", - "\x6D\x50\x77", - "\x55\x09\x3B", - "\x53\x56\x55", - "\x7C\x73\x69", - "\x3A\x35\x61", - "\x5F\x61\x63", - "\x65\x4B\x50", - "\x46\x58\x67", - "\x58\x3B\x51", - "\x31\x57\x49", - "\x69\x22\x4F", - "\x6C\x6D\x46", - "\x5A\x4D\x68", - "\x48\x25\x7C", - "\x27\x28\x36", - "\x5C\x46\x70", - "\x3D\x4A\x6E", - "\x24\x32\x7A", - "\x79\x41\x2F", - "\x37\x3D\x5F", - "\x60\x5F\x4B", - "\x51\x4F\x5A", - "\x20\x42\x2C", - "\x36\x65\x57" - ], - - /** - * @constant - * @default - */ - D_COMBINATION: [ - 0, 1, 2, 0, 1, 2, 1, 2, 2, 1, 2, 1, 0, 2, 1, 2, 0, 2, 1, 2, 0, 0, 1, 2, 2, 1, 0, 2, 1, 2, 2, 1, - 0, 0, 2, 1, 2, 1, 2, 0, 2, 0, 0, 1, 2, 0, 2, 1, 0, 2, 1, 2, 0, 0, 1, 2, 2, 0, 0, 1, 2, 0, 2, 1 - ], - - - /** - * Decodes Microsoft Encoded Script files that can be read and executed by cscript.exe/wscript.exe. - * This is a conversion of a Python script that was originally created by Didier Stevens - * (https://DidierStevens.com). - * - * @private - * @param {string} data - * @returns {string} - */ - _decode: function (data) { - let result = []; - let index = -1; - data = data.replace(/@&/g, String.fromCharCode(10)) - .replace(/@#/g, String.fromCharCode(13)) - .replace(/@\*/g, ">") - .replace(/@!/g, "<") - .replace(/@\$/g, "@"); - - for (let i = 0; i < data.length; i++) { - let byte = data.charCodeAt(i); - let char = data.charAt(i); - if (byte < 128) { - index++; - } - - if ((byte === 9 || byte > 31 && byte < 128) && - byte !== 60 && - byte !== 62 && - byte !== 64) { - char = MS.D_DECODE[byte].charAt(MS.D_COMBINATION[index % 64]); - } - result.push(char); - } - return result.join(""); - }, - - - /** - * Microsoft Script Decoder operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runDecodeScript: function (input, args) { - let matcher = /#@~\^.{6}==(.+).{6}==\^#~@/; - let encodedData = matcher.exec(input); - if (encodedData){ - return MS._decode(encodedData[1]); - } else { - return ""; - } - } - -}; - -export default MS; diff --git a/src/core/operations/legacy/MorseCode.js b/src/core/operations/legacy/MorseCode.js deleted file mode 100644 index de81ce89..00000000 --- a/src/core/operations/legacy/MorseCode.js +++ /dev/null @@ -1,190 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * Morse Code translation operations. - * - * @author tlwr [toby@toby.codes] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const MorseCode = { - - /** - * @constant - * @default - */ - FORMAT_OPTIONS: ["-/.", "_/.", "Dash/Dot", "DASH/DOT", "dash/dot"], - /** - * @constant - * @default - */ - LETTER_DELIM_OPTIONS: ["Space", "Line feed", "CRLF", "Forward slash", "Backslash", "Comma", "Semi-colon", "Colon"], - /** - * @constant - * @default - */ - WORD_DELIM_OPTIONS: ["Line feed", "CRLF", "Forward slash", "Backslash", "Comma", "Semi-colon", "Colon"], - /** - * @constant - * @default - */ - MORSE_TABLE: { - "A": "", - "B": "", - "C": "", - "D": "", - "E": "", - "F": "", - "G": "", - "H": "", - "I": "", - "J": "", - "K": "", - "L": "", - "M": "", - "N": "", - "O": "", - "P": "", - "Q": "", - "R": "", - "S": "", - "T": "", - "U": "", - "V": "", - "W": "", - "X": "", - "Y": "", - "Z": "", - "1": "", - "2": "", - "3": "", - "4": "", - "5": "", - "6": "", - "7": "", - "8": "", - "9": "", - "0": "", - ".": "", - ",": "", - ":": "", - ";": "", - "!": "", - "?": "", - "'": "", - "\"": "", - "/": "", - "-": "", - "+": "", - "(": "", - ")": "", - "@": "", - "=": "", - "&": "", - "_": "", - "$": "" - }, - - - /** - * To Morse Code operation. - * - * @param {number} input - * @param {Object[]} args - * @returns {string} - */ - runTo: function(input, args) { - const format = args[0].split("/"); - const dash = format[0]; - const dot = format[1]; - - const letterDelim = Utils.charRep(args[1]); - const wordDelim = Utils.charRep(args[2]); - - input = input.split(/\r?\n/); - input = Array.prototype.map.call(input, function(line) { - let words = line.split(/ +/); - words = Array.prototype.map.call(words, function(word) { - const letters = Array.prototype.map.call(word, function(character) { - const letter = character.toUpperCase(); - if (typeof MorseCode.MORSE_TABLE[letter] == "undefined") { - return ""; - } - - return MorseCode.MORSE_TABLE[letter]; - }); - - return letters.join(""); - }); - line = words.join(""); - return line; - }); - input = input.join("\n"); - - input = input.replace( - /|||/g, - function(match) { - switch (match) { - case "": return dash; - case "": return dot; - case "": return letterDelim; - case "": return wordDelim; - } - } - ); - - return input; - }, - - - /** - * From Morse Code operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFrom: (function() { - let reversedTable = null; - const reverseTable = function() { - reversedTable = {}; - - for (const letter in MorseCode.MORSE_TABLE) { - const signal = MorseCode.MORSE_TABLE[letter]; - reversedTable[signal] = letter; - } - }; - - return function(input, args) { - if (reversedTable === null) { - reverseTable(); - } - - const letterDelim = Utils.charRep(args[0]); - const wordDelim = Utils.charRep(args[1]); - - input = input.replace(/-|‐|−|_|–|—|dash/ig, ""); //hyphen-minus|hyphen|minus-sign|undersore|en-dash|em-dash - input = input.replace(/\.|·|dot/ig, ""); - - let words = input.split(wordDelim); - words = Array.prototype.map.call(words, function(word) { - const signals = word.split(letterDelim); - - const letters = signals.map(function(signal) { - return reversedTable[signal]; - }); - - return letters.join(""); - }); - words = words.join(" "); - - return words; - }; - })(), - -}; - -export default MorseCode; diff --git a/src/core/operations/legacy/NetBIOS.js b/src/core/operations/legacy/NetBIOS.js deleted file mode 100644 index 60866b65..00000000 --- a/src/core/operations/legacy/NetBIOS.js +++ /dev/null @@ -1,70 +0,0 @@ -/** - * NetBIOS operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const NetBIOS = { - - /** - * @constant - * @default - */ - OFFSET: 65, - - /** - * Encode NetBIOS Name operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runEncodeName: function(input, args) { - let output = [], - offset = args[0]; - - if (input.length <= 16) { - let len = input.length; - input.length = 16; - input.fill(32, len, 16); - for (let i = 0; i < input.length; i++) { - output.push((input[i] >> 4) + offset); - output.push((input[i] & 0xf) + offset); - } - } - - return output; - }, - - - /** - * Decode NetBIOS Name operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runDecodeName: function(input, args) { - let output = [], - offset = args[0]; - - if (input.length <= 32 && (input.length % 2) === 0) { - for (let i = 0; i < input.length; i += 2) { - output.push((((input[i] & 0xff) - offset) << 4) | - (((input[i + 1] & 0xff) - offset) & 0xf)); - } - for (let i = output.length - 1; i > 0; i--) { - if (output[i] === 32) output.splice(i, i); - else break; - } - } - - return output; - }, - -}; - -export default NetBIOS; diff --git a/src/core/operations/legacy/Numberwang.js b/src/core/operations/legacy/Numberwang.js deleted file mode 100755 index e323f74c..00000000 --- a/src/core/operations/legacy/Numberwang.js +++ /dev/null @@ -1,85 +0,0 @@ -/** - * Numberwang operations. - * - * @author Unknown Male 282 - * @namespace - */ -const Numberwang = { - - /** - * Numberwang operation. Remain indoors. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - run: function(input, args) { - let output; - if (!input) { - output = "Let's play Wangernumb!"; - } else { - const match = input.match(/(f0rty-s1x|shinty-six|filth-hundred and neeb|-?√?\d+(\.\d+)?i?([a-z]?)%?)/i); - if (match) { - if (match[3]) output = match[0] + "! That's AlphaNumericWang!"; - else output = match[0] + "! That's Numberwang!"; - } else { - // That's a bad miss! - output = "Sorry, that's not Numberwang. Let's rotate the board!"; - } - } - - const rand = Math.floor(Math.random() * Numberwang._didYouKnow.length); - return output + "\n\nDid you know: " + Numberwang._didYouKnow[rand]; - }, - - - /** - * Taken from http://numberwang.wikia.com/wiki/Numberwang_Wikia - * - * @private - * @constant - */ - _didYouKnow: [ - "Numberwang, contrary to popular belief, is a fruit and not a vegetable.", - "Robert Webb once got WordWang while presenting an episode of Numberwang.", - "The 6705th digit of pi is Numberwang.", - "Numberwang was invented on a Sevenday.", - "Contrary to popular belief, Albert Einstein always got good grades in Numberwang at school. He once scored ^4$ on a test.", - "680 asteroids have been named after Numberwang.", - "Archimedes is most famous for proclaiming \"That's Numberwang!\" during an epiphany about water displacement he had while taking a bath.", - "Numberwang Day is celebrated in Japan on every day of the year apart from June 6.", - "Biologists recently discovered Numberwang within a strand of human DNA.", - "Numbernot is a special type of non-Numberwang number. It is divisible by 3 and the letter \"y\".", - "Julie once got 612.04 Numberwangs in a single episode of Emmerdale.", - "In India, it is traditional to shout out \"Numberwang!\" instead of checkmate during games of chess.", - "There is a rule on Countdown which states that if you get Numberwang in the numbers round, you automatically win. It has only ever been invoked twice.", - "\"Numberwang\" was the third-most common baby name for a brief period in 1722.", - "\"The Lion King\" was loosely based on Numberwang.", - "\"A Numberwang a day keeps the doctor away\" is how Donny Cosy, the oldest man in the world, explained how he was in such good health at the age of 136.", - "The \"number lock\" button on a keyboard is based on the popular round of the same name in \"Numberwang\".", - "Cambridge became the first university to offer a course in Numberwang in 1567.", - "Schrödinger's Numberwang is a number that has been confusing dentists for centuries.", - "\"Harry Potter and the Numberwang of Numberwang\" was rejected by publishers -41 times before it became a bestseller.", - "\"Numberwang\" is the longest-running British game show in history; it has aired 226 seasons, each containing 19 episodes, which makes a grand total of 132 episodes.", - "The triple Numberwang bonus was discovered by archaeologist Thomas Jefferson in Somerset.", - "Numberwang is illegal in parts of Czechoslovakia.", - "Numberwang was discovered in India in the 12th century.", - "Numberwang has the chemical formula Zn4SO2(HgEs)3.", - "The first pack of cards ever created featured two \"Numberwang\" cards instead of jokers.", - "Julius Caesar was killed by an overdose of Numberwang.", - "The most Numberwang musical note is G#.", - "In 1934, the forty-third Google Doodle promoted the upcoming television show \"Numberwang on Ice\".", - "A recent psychology study found that toddlers were 17% faster at identifying numbers which were Numberwang.", - "There are 700 ways to commit a foul in the television show \"Numberwang\". All 700 of these fouls were committed by Julie in one single episode in 1473.", - "Astronomers suspect God is Numberwang.", - "Numberwang is the official beverage of Canada.", - "In the pilot episode of \"The Price is Right\", if a contestant got the value of an item exactly right they were told \"That's Numberwang!\" and immediately won ₹5.7032.", - "The first person to get three Numberwangs in a row was Madonna.", - "\"Numberwang\" has the code U+46402 in Unicode.", - "The musical note \"Numberwang\" is between D# and E♮.", - "Numberwang was first played on the moon in 1834.", - ], - -}; - -export default Numberwang; diff --git a/src/core/operations/legacy/OS.js b/src/core/operations/legacy/OS.js deleted file mode 100755 index 93a780f1..00000000 --- a/src/core/operations/legacy/OS.js +++ /dev/null @@ -1,311 +0,0 @@ -/** - * Operating system operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const OS = { - - /** - * Parse UNIX file permissions operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseUnixPerms: function(input, args) { - let perms = { - d: false, // directory - sl: false, // symbolic link - np: false, // named pipe - s: false, // socket - cd: false, // character device - bd: false, // block device - dr: false, // door - sb: false, // sticky bit - su: false, // setuid - sg: false, // setgid - ru: false, // read user - wu: false, // write user - eu: false, // execute user - rg: false, // read group - wg: false, // write group - eg: false, // execute group - ro: false, // read other - wo: false, // write other - eo: false // execute other - }, - d = 0, - u = 0, - g = 0, - o = 0, - output = "", - octal = null, - textual = null; - - if (input.search(/\s*[0-7]{1,4}\s*/i) === 0) { - // Input is octal - octal = input.match(/\s*([0-7]{1,4})\s*/i)[1]; - - if (octal.length === 4) { - d = parseInt(octal[0], 8); - u = parseInt(octal[1], 8); - g = parseInt(octal[2], 8); - o = parseInt(octal[3], 8); - } else { - if (octal.length > 0) u = parseInt(octal[0], 8); - if (octal.length > 1) g = parseInt(octal[1], 8); - if (octal.length > 2) o = parseInt(octal[2], 8); - } - - perms.su = d >> 2 & 0x1; - perms.sg = d >> 1 & 0x1; - perms.sb = d & 0x1; - - perms.ru = u >> 2 & 0x1; - perms.wu = u >> 1 & 0x1; - perms.eu = u & 0x1; - - perms.rg = g >> 2 & 0x1; - perms.wg = g >> 1 & 0x1; - perms.eg = g & 0x1; - - perms.ro = o >> 2 & 0x1; - perms.wo = o >> 1 & 0x1; - perms.eo = o & 0x1; - } else if (input.search(/\s*[dlpcbDrwxsStT-]{1,10}\s*/) === 0) { - // Input is textual - textual = input.match(/\s*([dlpcbDrwxsStT-]{1,10})\s*/)[1]; - - switch (textual[0]) { - case "d": - perms.d = true; - break; - case "l": - perms.sl = true; - break; - case "p": - perms.np = true; - break; - case "s": - perms.s = true; - break; - case "c": - perms.cd = true; - break; - case "b": - perms.bd = true; - break; - case "D": - perms.dr = true; - break; - } - - if (textual.length > 1) perms.ru = textual[1] === "r"; - if (textual.length > 2) perms.wu = textual[2] === "w"; - if (textual.length > 3) { - switch (textual[3]) { - case "x": - perms.eu = true; - break; - case "s": - perms.eu = true; - perms.su = true; - break; - case "S": - perms.su = true; - break; - } - } - - if (textual.length > 4) perms.rg = textual[4] === "r"; - if (textual.length > 5) perms.wg = textual[5] === "w"; - if (textual.length > 6) { - switch (textual[6]) { - case "x": - perms.eg = true; - break; - case "s": - perms.eg = true; - perms.sg = true; - break; - case "S": - perms.sg = true; - break; - } - } - - if (textual.length > 7) perms.ro = textual[7] === "r"; - if (textual.length > 8) perms.wo = textual[8] === "w"; - if (textual.length > 9) { - switch (textual[9]) { - case "x": - perms.eo = true; - break; - case "t": - perms.eo = true; - perms.sb = true; - break; - case "T": - perms.sb = true; - break; - } - } - } else { - return "Invalid input format.\nPlease enter the permissions in either octal (e.g. 755) or textual (e.g. drwxr-xr-x) format."; - } - - output += "Textual representation: " + OS._permsToStr(perms); - output += "\nOctal representation: " + OS._permsToOctal(perms); - - // File type - if (textual) { - output += "\nFile type: " + OS._ftFromPerms(perms); - } - - // setuid, setgid - if (perms.su) { - output += "\nThe setuid flag is set"; - } - if (perms.sg) { - output += "\nThe setgid flag is set"; - } - - // sticky bit - if (perms.sb) { - output += "\nThe sticky bit is set"; - } - - // Permission matrix - output += "\n\n +---------+-------+-------+-------+\n" + - " | | User | Group | Other |\n" + - " +---------+-------+-------+-------+\n" + - " | Read | " + (perms.ru ? "X" : " ") + " | " + (perms.rg ? "X" : " ") + " | " + (perms.ro ? "X" : " ") + " |\n" + - " +---------+-------+-------+-------+\n" + - " | Write | " + (perms.wu ? "X" : " ") + " | " + (perms.wg ? "X" : " ") + " | " + (perms.wo ? "X" : " ") + " |\n" + - " +---------+-------+-------+-------+\n" + - " | Execute | " + (perms.eu ? "X" : " ") + " | " + (perms.eg ? "X" : " ") + " | " + (perms.eo ? "X" : " ") + " |\n" + - " +---------+-------+-------+-------+\n"; - - return output; - }, - - - /** - * Given a permissions object dictionary, generates a textual permissions string. - * - * @private - * @param {Object} perms - * @returns {string} - */ - _permsToStr: function(perms) { - let str = "", - type = "-"; - - if (perms.d) type = "d"; - if (perms.sl) type = "l"; - if (perms.np) type = "p"; - if (perms.s) type = "s"; - if (perms.cd) type = "c"; - if (perms.bd) type = "b"; - if (perms.dr) type = "D"; - - str = type; - - str += perms.ru ? "r" : "-"; - str += perms.wu ? "w" : "-"; - if (perms.eu && perms.su) { - str += "s"; - } else if (perms.su) { - str += "S"; - } else if (perms.eu) { - str += "x"; - } else { - str += "-"; - } - - str += perms.rg ? "r" : "-"; - str += perms.wg ? "w" : "-"; - if (perms.eg && perms.sg) { - str += "s"; - } else if (perms.sg) { - str += "S"; - } else if (perms.eg) { - str += "x"; - } else { - str += "-"; - } - - str += perms.ro ? "r" : "-"; - str += perms.wo ? "w" : "-"; - if (perms.eo && perms.sb) { - str += "t"; - } else if (perms.sb) { - str += "T"; - } else if (perms.eo) { - str += "x"; - } else { - str += "-"; - } - - return str; - }, - - - /** - * Given a permissions object dictionary, generates an octal permissions string. - * - * @private - * @param {Object} perms - * @returns {string} - */ - _permsToOctal: function(perms) { - let d = 0, - u = 0, - g = 0, - o = 0; - - if (perms.su) d += 4; - if (perms.sg) d += 2; - if (perms.sb) d += 1; - - if (perms.ru) u += 4; - if (perms.wu) u += 2; - if (perms.eu) u += 1; - - if (perms.rg) g += 4; - if (perms.wg) g += 2; - if (perms.eg) g += 1; - - if (perms.ro) o += 4; - if (perms.wo) o += 2; - if (perms.eo) o += 1; - - return d.toString() + u.toString() + g.toString() + o.toString(); - }, - - - /** - * Given a permissions object dictionary, returns the file type. - * - * @private - * @param {Object} perms - * @returns {string} - */ - _ftFromPerms: function(perms) { - if (perms.d) return "Directory"; - if (perms.sl) return "Symbolic link"; - if (perms.np) return "Named pipe"; - if (perms.s) return "Socket"; - if (perms.cd) return "Character device"; - if (perms.bd) return "Block device"; - if (perms.dr) return "Door"; - return "Regular file"; - }, - -}; - -export default OS; diff --git a/src/core/operations/legacy/OTP.js b/src/core/operations/legacy/OTP.js deleted file mode 100755 index f7862310..00000000 --- a/src/core/operations/legacy/OTP.js +++ /dev/null @@ -1,56 +0,0 @@ -import otp from "otp"; -import Base64 from "./Base64.js"; - - -/** - * One-Time Password operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const OTP = { - - /** - * Generate TOTP operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runTOTP: function(input, args) { - const otpObj = otp({ - name: args[0], - keySize: args[1], - codeLength: args[2], - secret: Base64.runTo32(input, []), - epoch: args[3], - timeSlice: args[4] - }); - return `URI: ${otpObj.totpURL}\n\nPassword: ${otpObj.totp()}`; - }, - - - /** - * Generate HOTP operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runHOTP: function(input, args) { - const otpObj = otp({ - name: args[0], - keySize: args[1], - codeLength: args[2], - secret: Base64.runTo32(input, []), - }); - const counter = args[3]; - return `URI: ${otpObj.hotpURL}\n\nPassword: ${otpObj.hotp(counter)}`; - }, - -}; - -export default OTP; diff --git a/src/core/operations/legacy/PHP.js b/src/core/operations/legacy/PHP.js deleted file mode 100644 index e4bb0b5b..00000000 --- a/src/core/operations/legacy/PHP.js +++ /dev/null @@ -1,160 +0,0 @@ -/** - * PHP operations. - * - * @author Jarmo van Lenthe [github.com/jarmovanlenthe] - * @copyright Jarmo van Lenthe - * @license Apache-2.0 - * - * @namespace - */ -const PHP = { - - /** - * @constant - * @default - */ - OUTPUT_VALID_JSON: true, - - /** - * PHP Deserialize operation. - * - * This Javascript implementation is based on the Python implementation by - * Armin Ronacher (2016), who released it under the 3-Clause BSD license. - * See: https://github.com/mitsuhiko/phpserialize/ - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runDeserialize: function (input, args) { - /** - * Recursive method for deserializing. - * @returns {*} - */ - function handleInput() { - /** - * Read `length` characters from the input, shifting them out the input. - * @param length - * @returns {string} - */ - function read(length) { - let result = ""; - for (let idx = 0; idx < length; idx++) { - let char = inputPart.shift(); - if (char === undefined) { - throw "End of input reached before end of script"; - } - result += char; - } - return result; - } - - /** - * Read characters from the input until `until` is found. - * @param until - * @returns {string} - */ - function readUntil(until) { - let result = ""; - for (;;) { - let char = read(1); - if (char === until) { - break; - } else { - result += char; - } - } - return result; - - } - - /** - * Read characters from the input that must be equal to `expect` - * @param expect - * @returns {string} - */ - function expect(expect) { - let result = read(expect.length); - if (result !== expect) { - throw "Unexpected input found"; - } - return result; - } - - /** - * Helper function to handle deserialized arrays. - * @returns {Array} - */ - function handleArray() { - let items = parseInt(readUntil(":"), 10) * 2; - expect("{"); - let result = []; - let isKey = true; - let lastItem = null; - for (let idx = 0; idx < items; idx++) { - let item = handleInput(); - if (isKey) { - lastItem = item; - isKey = false; - } else { - let numberCheck = lastItem.match(/[0-9]+/); - if (args[0] && numberCheck && numberCheck[0].length === lastItem.length) { - result.push("\"" + lastItem + "\": " + item); - } else { - result.push(lastItem + ": " + item); - } - isKey = true; - } - } - expect("}"); - return result; - } - - - let kind = read(1).toLowerCase(); - - switch (kind) { - case "n": - expect(";"); - return ""; - - case "i": - case "d": - case "b": { - expect(":"); - let data = readUntil(";"); - if (kind === "b") { - return (parseInt(data, 10) !== 0); - } - return data; - } - - case "a": - expect(":"); - return "{" + handleArray() + "}"; - - case "s": { - expect(":"); - let length = readUntil(":"); - expect("\""); - let value = read(length); - expect("\";"); - if (args[0]) { - return "\"" + value.replace(/"/g, "\\\"") + "\""; - } else { - return "\"" + value + "\""; - } - } - - default: - throw "Unknown type: " + kind; - } - } - - let inputPart = input.split(""); - return handleInput(); - } - -}; - -export default PHP; diff --git a/src/core/operations/legacy/PublicKey.js b/src/core/operations/legacy/PublicKey.js deleted file mode 100755 index a52caf25..00000000 --- a/src/core/operations/legacy/PublicKey.js +++ /dev/null @@ -1,348 +0,0 @@ -import Utils from "../Utils.js"; -import {fromBase64} from "../lib/Base64"; -import {toHex, fromHex} from "../lib/Hex"; -import * as r from "jsrsasign"; - - -/** - * Public Key operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const PublicKey = { - - /** - * @constant - * @default - */ - X509_INPUT_FORMAT: ["PEM", "DER Hex", "Base64", "Raw"], - - /** - * Parse X.509 certificate operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseX509: function (input, args) { - if (!input.length) { - return "No input"; - } - - let cert = new r.X509(), - inputFormat = args[0]; - - switch (inputFormat) { - case "DER Hex": - input = input.replace(/\s/g, ""); - cert.readCertHex(input); - break; - case "PEM": - cert.readCertPEM(input); - break; - case "Base64": - cert.readCertHex(toHex(fromBase64(input, null, "byteArray"), "")); - break; - case "Raw": - cert.readCertHex(toHex(Utils.strToByteArray(input), "")); - break; - default: - throw "Undefined input format"; - } - - let sn = cert.getSerialNumberHex(), - issuer = cert.getIssuerString(), - subject = cert.getSubjectString(), - pk = cert.getPublicKey(), - pkFields = [], - pkStr = "", - sig = cert.getSignatureValueHex(), - sigStr = "", - extensions = ""; - - // Public Key fields - pkFields.push({ - key: "Algorithm", - value: pk.type - }); - - if (pk.type === "EC") { // ECDSA - pkFields.push({ - key: "Curve Name", - value: pk.curveName - }); - pkFields.push({ - key: "Length", - value: (((new r.BigInteger(pk.pubKeyHex, 16)).bitLength()-3) /2) + " bits" - }); - pkFields.push({ - key: "pub", - value: PublicKey._formatByteStr(pk.pubKeyHex, 16, 18) - }); - } else if (pk.type === "DSA") { // DSA - pkFields.push({ - key: "pub", - value: PublicKey._formatByteStr(pk.y.toString(16), 16, 18) - }); - pkFields.push({ - key: "P", - value: PublicKey._formatByteStr(pk.p.toString(16), 16, 18) - }); - pkFields.push({ - key: "Q", - value: PublicKey._formatByteStr(pk.q.toString(16), 16, 18) - }); - pkFields.push({ - key: "G", - value: PublicKey._formatByteStr(pk.g.toString(16), 16, 18) - }); - } else if (pk.e) { // RSA - pkFields.push({ - key: "Length", - value: pk.n.bitLength() + " bits" - }); - pkFields.push({ - key: "Modulus", - value: PublicKey._formatByteStr(pk.n.toString(16), 16, 18) - }); - pkFields.push({ - key: "Exponent", - value: pk.e + " (0x" + pk.e.toString(16) + ")" - }); - } else { - pkFields.push({ - key: "Error", - value: "Unknown Public Key type" - }); - } - - // Format Public Key fields - for (let i = 0; i < pkFields.length; i++) { - pkStr += " " + pkFields[i].key + ":" + - (pkFields[i].value + "\n").padStart( - 18 - (pkFields[i].key.length + 3) + pkFields[i].value.length + 1, - " " - ); - } - - // Signature fields - let breakoutSig = false; - try { - breakoutSig = r.ASN1HEX.dump(sig).indexOf("SEQUENCE") === 0; - } catch (err) { - // Error processing signature, output without further breakout - } - - if (breakoutSig) { // DSA or ECDSA - sigStr = " r: " + PublicKey._formatByteStr(r.ASN1HEX.getV(sig, 4), 16, 18) + "\n" + - " s: " + PublicKey._formatByteStr(r.ASN1HEX.getV(sig, 48), 16, 18); - } else { // RSA or unknown - sigStr = " Signature: " + PublicKey._formatByteStr(sig, 16, 18); - } - - // Extensions - try { - extensions = cert.getInfo().split("X509v3 Extensions:\n")[1].split("signature")[0]; - } catch (err) {} - - let issuerStr = PublicKey._formatDnStr(issuer, 2), - nbDate = PublicKey._formatDate(cert.getNotBefore()), - naDate = PublicKey._formatDate(cert.getNotAfter()), - subjectStr = PublicKey._formatDnStr(subject, 2); - - return `Version: ${cert.version} (0x${Utils.hex(cert.version - 1)}) -Serial number: ${new r.BigInteger(sn, 16).toString()} (0x${sn}) -Algorithm ID: ${cert.getSignatureAlgorithmField()} -Validity - Not Before: ${nbDate} (dd-mm-yy hh:mm:ss) (${cert.getNotBefore()}) - Not After: ${naDate} (dd-mm-yy hh:mm:ss) (${cert.getNotAfter()}) -Issuer -${issuerStr} -Subject -${subjectStr} -Public Key -${pkStr.slice(0, -1)} -Certificate Signature - Algorithm: ${cert.getSignatureAlgorithmName()} -${sigStr} - -Extensions -${extensions}`; - }, - - - /** - * PEM to Hex operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runPemToHex: function(input, args) { - if (input.indexOf("-----BEGIN") < 0) { - // Add header so that the KEYUTIL function works - input = "-----BEGIN CERTIFICATE-----" + input; - } - if (input.indexOf("-----END") < 0) { - // Add footer so that the KEYUTIL function works - input = input + "-----END CERTIFICATE-----"; - } - let cert = new r.X509(); - cert.readCertPEM(input); - return cert.hex; - }, - - - /** - * @constant - * @default - */ - PEM_HEADER_STRING: "CERTIFICATE", - - /** - * Hex to PEM operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runHexToPem: function(input, args) { - return r.KJUR.asn1.ASN1Util.getPEMStringFromHex(input.replace(/\s/g, ""), args[0]); - }, - - - /** - * Hex to Object Identifier operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runHexToObjectIdentifier: function(input, args) { - return r.KJUR.asn1.ASN1Util.oidHexToInt(input.replace(/\s/g, "")); - }, - - - /** - * Object Identifier to Hex operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runObjectIdentifierToHex: function(input, args) { - return r.KJUR.asn1.ASN1Util.oidIntToHex(input); - }, - - - /** - * @constant - * @default - */ - ASN1_TRUNCATE_LENGTH: 32, - - /** - * Parse ASN.1 hex string operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runParseAsn1HexString: function(input, args) { - let truncateLen = args[1], - index = args[0]; - return r.ASN1HEX.dump(input.replace(/\s/g, ""), { - "ommitLongOctet": truncateLen - }, index); - }, - - - /** - * Formats Distinguished Name (DN) strings. - * - * @private - * @param {string} dnStr - * @param {number} indent - * @returns {string} - */ - _formatDnStr: function(dnStr, indent) { - let output = "", - fields = dnStr.substr(1).replace(/([^\\])\//g, "$1$1/").split(/[^\\]\//), - maxKeyLen = 0, - key, - value, - i, - str; - - for (i = 0; i < fields.length; i++) { - if (!fields[i].length) continue; - - key = fields[i].split("=")[0]; - - maxKeyLen = key.length > maxKeyLen ? key.length : maxKeyLen; - } - - for (i = 0; i < fields.length; i++) { - if (!fields[i].length) continue; - - key = fields[i].split("=")[0]; - value = fields[i].split("=")[1]; - str = key.padEnd(maxKeyLen, " ") + " = " + value + "\n"; - - output += str.padStart(indent + str.length, " "); - } - - return output.slice(0, -1); - }, - - - /** - * Formats byte strings by adding line breaks and delimiters. - * - * @private - * @param {string} byteStr - * @param {number} length - Line width - * @param {number} indent - * @returns {string} - */ - _formatByteStr: function(byteStr, length, indent) { - byteStr = toHex(fromHex(byteStr), ":"); - length = length * 3; - let output = ""; - - for (let i = 0; i < byteStr.length; i += length) { - const str = byteStr.slice(i, i + length) + "\n"; - if (i === 0) { - output += str; - } else { - output += str.padStart(indent + str.length, " "); - } - } - - return output.slice(0, output.length-1); - }, - - - /** - * Formats dates. - * - * @private - * @param {string} dateStr - * @returns {string} - */ - _formatDate: function(dateStr) { - return dateStr[4] + dateStr[5] + "/" + - dateStr[2] + dateStr[3] + "/" + - dateStr[0] + dateStr[1] + " " + - dateStr[6] + dateStr[7] + ":" + - dateStr[8] + dateStr[9] + ":" + - dateStr[10] + dateStr[11]; - }, - -}; - -export default PublicKey; diff --git a/src/core/operations/legacy/Punycode.js b/src/core/operations/legacy/Punycode.js deleted file mode 100755 index d3f94e69..00000000 --- a/src/core/operations/legacy/Punycode.js +++ /dev/null @@ -1,58 +0,0 @@ -import punycode from "punycode"; - - -/** - * Punycode operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Punycode = { - - /** - * @constant - * @default - */ - IDN: false, - - /** - * To Punycode operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToAscii: function(input, args) { - const idn = args[0]; - - if (idn) { - return punycode.toASCII(input); - } else { - return punycode.encode(input); - } - }, - - - /** - * From Punycode operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runToUnicode: function(input, args) { - const idn = args[0]; - - if (idn) { - return punycode.toUnicode(input); - } else { - return punycode.decode(input); - } - }, - -}; - -export default Punycode; diff --git a/src/core/operations/legacy/QuotedPrintable.js b/src/core/operations/legacy/QuotedPrintable.js deleted file mode 100755 index a53ea0ca..00000000 --- a/src/core/operations/legacy/QuotedPrintable.js +++ /dev/null @@ -1,272 +0,0 @@ -/** @license -======================================================================== - mimelib: http://github.com/andris9/mimelib - Copyright (c) 2011-2012 Andris Reinman - - 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 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. -*/ - -/** - * Quoted Printable operations. - * Some parts taken from mimelib (http://github.com/andris9/mimelib) - * - * @author Andris Reinman - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const QuotedPrintable = { - - /** - * To Quoted Printable operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {string} - */ - runTo: function (input, args) { - let mimeEncodedStr = QuotedPrintable.mimeEncode(input); - - // fix line breaks - mimeEncodedStr = mimeEncodedStr.replace(/\r?\n|\r/g, function() { - return "\r\n"; - }).replace(/[\t ]+$/gm, function(spaces) { - return spaces.replace(/ /g, "=20").replace(/\t/g, "=09"); - }); - - return QuotedPrintable._addSoftLinebreaks(mimeEncodedStr, "qp"); - }, - - - /** - * From Quoted Printable operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {byteArray} - */ - runFrom: function (input, args) { - const str = input.replace(/=(?:\r?\n|$)/g, ""); - return QuotedPrintable.mimeDecode(str); - }, - - - /** - * Decodes mime-encoded data. - * - * @param {string} str - * @returns {byteArray} - */ - mimeDecode: function(str) { - let encodedBytesCount = (str.match(/=[\da-fA-F]{2}/g) || []).length, - bufferLength = str.length - encodedBytesCount * 2, - chr, hex, - buffer = new Array(bufferLength), - bufferPos = 0; - - for (let i = 0, len = str.length; i < len; i++) { - chr = str.charAt(i); - if (chr === "=" && (hex = str.substr(i + 1, 2)) && /[\da-fA-F]{2}/.test(hex)) { - buffer[bufferPos++] = parseInt(hex, 16); - i += 2; - continue; - } - buffer[bufferPos++] = chr.charCodeAt(0); - } - - return buffer; - }, - - - /** - * Encodes mime data. - * - * @param {byteArray} buffer - * @returns {string} - */ - mimeEncode: function(buffer) { - let ranges = [ - [0x09], - [0x0A], - [0x0D], - [0x20], - [0x21], - [0x23, 0x3C], - [0x3E], - [0x40, 0x5E], - [0x60, 0x7E] - ], - result = ""; - - for (let i = 0, len = buffer.length; i < len; i++) { - if (this._checkRanges(buffer[i], ranges)) { - result += String.fromCharCode(buffer[i]); - continue; - } - result += "=" + (buffer[i] < 0x10 ? "0" : "") + buffer[i].toString(16).toUpperCase(); - } - - return result; - }, - - - /** - * Checks if a given number falls within a given set of ranges. - * - * @private - * @param {number} nr - * @param {byteArray[]} ranges - * @returns {bolean} - */ - _checkRanges: function(nr, ranges) { - for (let i = ranges.length - 1; i >= 0; i--) { - if (!ranges[i].length) - continue; - if (ranges[i].length === 1 && nr === ranges[i][0]) - return true; - if (ranges[i].length === 2 && nr >= ranges[i][0] && nr <= ranges[i][1]) - return true; - } - return false; - }, - - - /** - * Adds soft line breaks to a string. - * Lines can't be longer that 76 + = 78 bytes - * http://tools.ietf.org/html/rfc2045#section-6.7 - * - * @private - * @param {string} str - * @param {string} encoding - * @returns {string} - */ - _addSoftLinebreaks: function(str, encoding) { - const lineLengthMax = 76; - - encoding = (encoding || "base64").toString().toLowerCase().trim(); - - if (encoding === "qp") { - return this._addQPSoftLinebreaks(str, lineLengthMax); - } else { - return this._addBase64SoftLinebreaks(str, lineLengthMax); - } - }, - - - /** - * Adds soft line breaks to a base64 string. - * - * @private - * @param {string} base64EncodedStr - * @param {number} lineLengthMax - * @returns {string} - */ - _addBase64SoftLinebreaks: function(base64EncodedStr, lineLengthMax) { - base64EncodedStr = (base64EncodedStr || "").toString().trim(); - return base64EncodedStr.replace(new RegExp(".{" + lineLengthMax + "}", "g"), "$&\r\n").trim(); - }, - - - /** - * Adds soft line breaks to a quoted printable string. - * - * @private - * @param {string} mimeEncodedStr - * @param {number} lineLengthMax - * @returns {string} - */ - _addQPSoftLinebreaks: function(mimeEncodedStr, lineLengthMax) { - let pos = 0, - len = mimeEncodedStr.length, - match, code, line, - lineMargin = Math.floor(lineLengthMax / 3), - result = ""; - - // insert soft linebreaks where needed - while (pos < len) { - line = mimeEncodedStr.substr(pos, lineLengthMax); - if ((match = line.match(/\r\n/))) { - line = line.substr(0, match.index + match[0].length); - result += line; - pos += line.length; - continue; - } - - if (line.substr(-1) === "\n") { - // nothing to change here - result += line; - pos += line.length; - continue; - } else if ((match = line.substr(-lineMargin).match(/\n.*?$/))) { - // truncate to nearest line break - line = line.substr(0, line.length - (match[0].length - 1)); - result += line; - pos += line.length; - continue; - } else if (line.length > lineLengthMax - lineMargin && (match = line.substr(-lineMargin).match(/[ \t.,!?][^ \t.,!?]*$/))) { - // truncate to nearest space - line = line.substr(0, line.length - (match[0].length - 1)); - } else if (line.substr(-1) === "\r") { - line = line.substr(0, line.length - 1); - } else { - if (line.match(/=[\da-f]{0,2}$/i)) { - - // push incomplete encoding sequences to the next line - if ((match = line.match(/=[\da-f]{0,1}$/i))) { - line = line.substr(0, line.length - match[0].length); - } - - // ensure that utf-8 sequences are not split - while (line.length > 3 && line.length < len - pos && !line.match(/^(?:=[\da-f]{2}){1,4}$/i) && (match = line.match(/=[\da-f]{2}$/ig))) { - code = parseInt(match[0].substr(1, 2), 16); - if (code < 128) { - break; - } - - line = line.substr(0, line.length - 3); - - if (code >= 0xC0) { - break; - } - } - - } - } - - if (pos + line.length < len && line.substr(-1) !== "\n") { - if (line.length === 76 && line.match(/=[\da-f]{2}$/i)) { - line = line.substr(0, line.length - 3); - } else if (line.length === 76) { - line = line.substr(0, line.length - 1); - } - pos += line.length; - line += "=\r\n"; - } else { - pos += line.length; - } - - result += line; - } - - return result; - }, - -}; - -export default QuotedPrintable; diff --git a/src/core/operations/legacy/Regex.js b/src/core/operations/legacy/Regex.js deleted file mode 100644 index a4f544ef..00000000 --- a/src/core/operations/legacy/Regex.js +++ /dev/null @@ -1,278 +0,0 @@ -import XRegExp from "xregexp"; -import Utils from "../Utils.js"; - - -/** - * Regex operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - * - * @namespace - */ -const Regex = { - - /** - * @constant - * @default - */ - REGEX_PRE_POPULATE: [ - { - name: "User defined", - value: "" - }, - { - name: "IPv4 address", - value: "(?:(?:\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d|\\d)(?:\\/\\d{1,2})?" - }, - { - name: "IPv6 address", - value: "((?=.*::)(?!.*::.+::)(::)?([\\dA-Fa-f]{1,4}:(:|\\b)|){5}|([\\dA-Fa-f]{1,4}:){6})((([\\dA-Fa-f]{1,4}((?!\\3)::|:\\b|(?![\\dA-Fa-f])))|(?!\\2\\3)){2}|(((2[0-4]|1\\d|[1-9])?\\d|25[0-5])\\.?\\b){4})" - }, - { - name: "Email address", - value: "\\b(\\w[-.\\w]*)@([-\\w]+(?:\\.[-\\w]+)*)\\.([A-Za-z]{2,4})\\b" - }, - { - name: "URL", - value: "([A-Za-z]+://)([-\\w]+(?:\\.\\w[-\\w]*)+)(:\\d+)?(/[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]*(?:[.!,?]+[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]+)*)?" - }, - { - name: "Domain", - value: "\\b((?=[a-z0-9-]{1,63}\\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,63}\\b" - }, - { - name: "Windows file path", - value: "([A-Za-z]):\\\\((?:[A-Za-z\\d][A-Za-z\\d\\- \\x27_\\(\\)~]{0,61}\\\\?)*[A-Za-z\\d][A-Za-z\\d\\- \\x27_\\(\\)]{0,61})(\\.[A-Za-z\\d]{1,6})?" - }, - { - name: "UNIX file path", - value: "(?:/[A-Za-z\\d.][A-Za-z\\d\\-.]{0,61})+" - }, - { - name: "MAC address", - value: "[A-Fa-f\\d]{2}(?:[:-][A-Fa-f\\d]{2}){5}" - }, - { - name: "Date (yyyy-mm-dd)", - value: "((?:19|20)\\d\\d)[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])" - }, - { - name: "Date (dd/mm/yyyy)", - value: "(0[1-9]|[12][0-9]|3[01])[- /.](0[1-9]|1[012])[- /.]((?:19|20)\\d\\d)" - }, - { - name: "Date (mm/dd/yyyy)", - value: "(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.]((?:19|20)\\d\\d)" - }, - { - name: "Strings", - value: "[A-Za-z\\d/\\-:.,_$%\\x27\"()<>= !\\[\\]{}@]{4,}" - }, - ], - /** - * @constant - * @default - */ - OUTPUT_FORMAT: ["Highlight matches", "List matches", "List capture groups", "List matches with capture groups"], - /** - * @constant - * @default - */ - DISPLAY_TOTAL: false, - - /** - * Regular expression operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runRegex: function(input, args) { - const userRegex = args[1], - i = args[2], - m = args[3], - s = args[4], - u = args[5], - a = args[6], - displayTotal = args[7], - outputFormat = args[8]; - let modifiers = "g"; - - if (i) modifiers += "i"; - if (m) modifiers += "m"; - if (s) modifiers += "s"; - if (u) modifiers += "u"; - if (a) modifiers += "A"; - - if (userRegex && userRegex !== "^" && userRegex !== "$") { - try { - const regex = new XRegExp(userRegex, modifiers); - - switch (outputFormat) { - case "Highlight matches": - return Regex._regexHighlight(input, regex, displayTotal); - case "List matches": - return Utils.escapeHtml(Regex._regexList(input, regex, displayTotal, true, false)); - case "List capture groups": - return Utils.escapeHtml(Regex._regexList(input, regex, displayTotal, false, true)); - case "List matches with capture groups": - return Utils.escapeHtml(Regex._regexList(input, regex, displayTotal, true, true)); - default: - return "Error: Invalid output format"; - } - } catch (err) { - return "Invalid regex. Details: " + err.message; - } - } else { - return Utils.escapeHtml(input); - } - }, - - - /** - * @constant - * @default - */ - SEARCH_TYPE: ["Regex", "Extended (\\n, \\t, \\x...)", "Simple string"], - /** - * @constant - * @default - */ - FIND_REPLACE_GLOBAL: true, - /** - * @constant - * @default - */ - FIND_REPLACE_CASE: false, - /** - * @constant - * @default - */ - FIND_REPLACE_MULTILINE: true, - - /** - * Find / Replace operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFindReplace: function(input, args) { - let find = args[0].string, - type = args[0].option, - replace = args[1], - g = args[2], - i = args[3], - m = args[4], - modifiers = ""; - - if (g) modifiers += "g"; - if (i) modifiers += "i"; - if (m) modifiers += "m"; - - if (type === "Regex") { - find = new RegExp(find, modifiers); - return input.replace(find, replace); - } - - if (type.indexOf("Extended") === 0) { - find = Utils.parseEscapedChars(find); - } - - find = new RegExp(Utils.escapeRegex(find), modifiers); - - return input.replace(find, replace); - }, - - - /** - * Adds HTML highlights to matches within a string. - * - * @private - * @param {string} input - * @param {RegExp} regex - * @param {boolean} displayTotal - * @returns {string} - */ - _regexHighlight: function(input, regex, displayTotal) { - let output = "", - m, - hl = 1, - i = 0, - total = 0; - - while ((m = regex.exec(input))) { - // Moves pointer when an empty string is matched (prevents infinite loop) - if (m.index === regex.lastIndex) { - regex.lastIndex++; - } - - // Add up to match - output += Utils.escapeHtml(input.slice(i, m.index)); - - // Add match with highlighting - output += "" + Utils.escapeHtml(m[0]) + ""; - - // Switch highlight - hl = hl === 1 ? 2 : 1; - - i = regex.lastIndex; - total++; - } - - // Add all after final match - output += Utils.escapeHtml(input.slice(i, input.length)); - - if (displayTotal) - output = "Total found: " + total + "\n\n" + output; - - return output; - }, - - - /** - * Creates a string listing the matches within a string. - * - * @private - * @param {string} input - * @param {RegExp} regex - * @param {boolean} displayTotal - * @param {boolean} matches - Display full match - * @param {boolean} captureGroups - Display each of the capture groups separately - * @returns {string} - */ - _regexList: function(input, regex, displayTotal, matches, captureGroups) { - let output = "", - total = 0, - match; - - while ((match = regex.exec(input))) { - // Moves pointer when an empty string is matched (prevents infinite loop) - if (match.index === regex.lastIndex) { - regex.lastIndex++; - } - - total++; - if (matches) { - output += match[0] + "\n"; - } - if (captureGroups) { - for (let i = 1; i < match.length; i++) { - if (matches) { - output += " Group " + i + ": "; - } - output += match[i] + "\n"; - } - } - } - - if (displayTotal) - output = "Total found: " + total + "\n\n" + output; - - return output.slice(0, -1); - }, -}; - -export default Regex; diff --git a/src/core/operations/legacy/SeqUtils.js b/src/core/operations/legacy/SeqUtils.js deleted file mode 100755 index 4080528a..00000000 --- a/src/core/operations/legacy/SeqUtils.js +++ /dev/null @@ -1,257 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * Sequence utility operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const SeqUtils = { - - /** - * @constant - * @default - */ - DELIMITER_OPTIONS: ["Line feed", "CRLF", "Space", "Comma", "Semi-colon", "Colon", "Nothing (separate chars)"], - /** - * @constant - * @default - */ - SORT_REVERSE: false, - /** - * @constant - * @default - */ - SORT_ORDER: ["Alphabetical (case sensitive)", "Alphabetical (case insensitive)", "IP address", "Numeric"], - - /** - * Sort operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSort: function (input, args) { - let delim = Utils.charRep(args[0]), - sortReverse = args[1], - order = args[2], - sorted = input.split(delim); - - if (order === "Alphabetical (case sensitive)") { - sorted = sorted.sort(); - } else if (order === "Alphabetical (case insensitive)") { - sorted = sorted.sort(SeqUtils._caseInsensitiveSort); - } else if (order === "IP address") { - sorted = sorted.sort(SeqUtils._ipSort); - } else if (order === "Numeric") { - sorted = sorted.sort(SeqUtils._numericSort); - } - - if (sortReverse) sorted.reverse(); - return sorted.join(delim); - }, - - - /** - * Unique operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runUnique: function (input, args) { - const delim = Utils.charRep(args[0]); - return input.split(delim).unique().join(delim); - }, - - - /** - * @constant - * @default - */ - SEARCH_TYPE: ["Regex", "Extended (\\n, \\t, \\x...)", "Simple string"], - - /** - * Count occurrences operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {number} - */ - runCount: function(input, args) { - let search = args[0].string, - type = args[0].option; - - if (type === "Regex" && search) { - try { - let regex = new RegExp(search, "gi"), - matches = input.match(regex); - return matches.length; - } catch (err) { - return 0; - } - } else if (search) { - if (type.indexOf("Extended") === 0) { - search = Utils.parseEscapedChars(search); - } - return input.count(search); - } else { - return 0; - } - }, - - - /** - * @constant - * @default - */ - REVERSE_BY: ["Character", "Line"], - - /** - * Reverse operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runReverse: function (input, args) { - let i; - if (args[0] === "Line") { - let lines = [], - line = [], - result = []; - for (i = 0; i < input.length; i++) { - if (input[i] === 0x0a) { - lines.push(line); - line = []; - } else { - line.push(input[i]); - } - } - lines.push(line); - lines.reverse(); - for (i = 0; i < lines.length; i++) { - result = result.concat(lines[i]); - result.push(0x0a); - } - return result.slice(0, input.length); - } else { - return input.reverse(); - } - }, - - - /** - * Add line numbers operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runAddLineNumbers: function(input, args) { - let lines = input.split("\n"), - output = "", - width = lines.length.toString().length; - - for (let n = 0; n < lines.length; n++) { - output += (n+1).toString().padStart(width, " ") + " " + lines[n] + "\n"; - } - return output.slice(0, output.length-1); - }, - - - /** - * Remove line numbers operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runRemoveLineNumbers: function(input, args) { - return input.replace(/^[ \t]{0,5}\d+[\s:|\-,.)\]]/gm, ""); - }, - - - /** - * Expand alphabet range operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runExpandAlphRange: function(input, args) { - return Utils.expandAlphRange(input).join(args[0]); - }, - - - /** - * Comparison operation for sorting of strings ignoring case. - * - * @private - * @param {string} a - * @param {string} b - * @returns {number} - */ - _caseInsensitiveSort: function(a, b) { - return a.toLowerCase().localeCompare(b.toLowerCase()); - }, - - - /** - * Comparison operation for sorting of IPv4 addresses. - * - * @private - * @param {string} a - * @param {string} b - * @returns {number} - */ - _ipSort: function(a, b) { - let a_ = a.split("."), - b_ = b.split("."); - - a_ = a_[0] * 0x1000000 + a_[1] * 0x10000 + a_[2] * 0x100 + a_[3] * 1; - b_ = b_[0] * 0x1000000 + b_[1] * 0x10000 + b_[2] * 0x100 + b_[3] * 1; - - if (isNaN(a_) && !isNaN(b_)) return 1; - if (!isNaN(a_) && isNaN(b_)) return -1; - if (isNaN(a_) && isNaN(b_)) return a.localeCompare(b); - - return a_ - b_; - }, - - - /** - * Comparison operation for sorting of numeric values. - * - * @author Chris van Marle - * @private - * @param {string} a - * @param {string} b - * @returns {number} - */ - _numericSort: function _numericSort(a, b) { - let a_ = a.split(/([^\d]+)/), - b_ = b.split(/([^\d]+)/); - - for (let i = 0; i < a_.length && i < b.length; ++i) { - if (isNaN(a_[i]) && !isNaN(b_[i])) return 1; // Numbers after non-numbers - if (!isNaN(a_[i]) && isNaN(b_[i])) return -1; - if (isNaN(a_[i]) && isNaN(b_[i])) { - let ret = a_[i].localeCompare(b_[i]); // Compare strings - if (ret !== 0) return ret; - } - if (!isNaN(a_[i]) && !isNaN(a_[i])) { // Compare numbers - if (a_[i] - b_[i] !== 0) return a_[i] - b_[i]; - } - } - - return a.localeCompare(b); - }, - -}; - -export default SeqUtils; diff --git a/src/core/operations/legacy/Shellcode.js b/src/core/operations/legacy/Shellcode.js deleted file mode 100644 index 920b12c6..00000000 --- a/src/core/operations/legacy/Shellcode.js +++ /dev/null @@ -1,96 +0,0 @@ -import disassemble from "../vendor/DisassembleX86-64.js"; - - -/** - * Shellcode operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2017 - * @license Apache-2.0 - * - * @namespace - */ -const Shellcode = { - - /** - * @constant - * @default - */ - MODE: ["64", "32", "16"], - /** - * @constant - * @default - */ - COMPATIBILITY: [ - "Full x86 architecture", - "Knights Corner", - "Larrabee", - "Cyrix", - "Geode", - "Centaur", - "X86/486" - ], - - /** - * Disassemble x86 operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runDisassemble: function(input, args) { - const mode = args[0], - compatibility = args[1], - codeSegment = args[2], - offset = args[3], - showInstructionHex = args[4], - showInstructionPos = args[5]; - - switch (mode) { - case "64": - disassemble.setBitMode(2); - break; - case "32": - disassemble.setBitMode(1); - break; - case "16": - disassemble.setBitMode(0); - break; - default: - throw "Invalid mode value"; - } - - switch (compatibility) { - case "Full x86 architecture": - disassemble.CompatibilityMode(0); - break; - case "Knights Corner": - disassemble.CompatibilityMode(1); - break; - case "Larrabee": - disassemble.CompatibilityMode(2); - break; - case "Cyrix": - disassemble.CompatibilityMode(3); - break; - case "Geode": - disassemble.CompatibilityMode(4); - break; - case "Centaur": - disassemble.CompatibilityMode(5); - break; - case "X86/486": - disassemble.CompatibilityMode(6); - break; - } - - disassemble.SetBasePosition(codeSegment + ":" + offset); - disassemble.setShowInstructionHex(showInstructionHex); - disassemble.setShowInstructionPos(showInstructionPos); - disassemble.LoadBinCode(input.replace(/\s/g, "")); - return disassemble.LDisassemble(); - }, - -}; - -export default Shellcode; diff --git a/src/core/operations/legacy/StrUtils.js b/src/core/operations/legacy/StrUtils.js deleted file mode 100755 index 9a5c010e..00000000 --- a/src/core/operations/legacy/StrUtils.js +++ /dev/null @@ -1,413 +0,0 @@ -import Utils from "../Utils.js"; -import {fromHex} from "../lib/Hex"; -import jsesc from "jsesc"; - - -/** - * String utility operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const StrUtils = { - - /** - * @constant - * @default - */ - CASE_SCOPE: ["All", "Word", "Sentence", "Paragraph"], - - /** - * To Upper case operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runUpper: function (input, args) { - const scope = args[0]; - - switch (scope) { - case "Word": - return input.replace(/(\b\w)/gi, function(m) { - return m.toUpperCase(); - }); - case "Sentence": - return input.replace(/(?:\.|^)\s*(\b\w)/gi, function(m) { - return m.toUpperCase(); - }); - case "Paragraph": - return input.replace(/(?:\n|^)\s*(\b\w)/gi, function(m) { - return m.toUpperCase(); - }); - case "All": - /* falls through */ - default: - return input.toUpperCase(); - } - }, - - - /** - * To Upper case operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runLower: function (input, args) { - return input.toLowerCase(); - }, - - - /** - * @constant - * @default - */ - SPLIT_DELIM_OPTIONS: [ - {name: "Comma", value: ","}, - {name: "Space", value: " "}, - {name: "Line feed", value: "\\n"}, - {name: "CRLF", value: "\\r\\n"}, - {name: "Semi-colon", value: ";"}, - {name: "Colon", value: ":"}, - {name: "Nothing (separate chars)", value: ""} - ], - /** - * @constant - * @default - */ - JOIN_DELIM_OPTIONS: [ - {name: "Line feed", value: "\\n"}, - {name: "CRLF", value: "\\r\\n"}, - {name: "Space", value: " "}, - {name: "Comma", value: ","}, - {name: "Semi-colon", value: ";"}, - {name: "Colon", value: ":"}, - {name: "Nothing (join chars)", value: ""} - ], - - /** - * Split operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runSplit: function(input, args) { - let splitDelim = args[0], - joinDelim = args[1], - sections = input.split(splitDelim); - - return sections.join(joinDelim); - }, - - - /** - * @constant - * @default - */ - DELIMITER_OPTIONS: ["Line feed", "CRLF", "Space", "Comma", "Semi-colon", "Colon", "Nothing (separate chars)"], - - /** - * Filter operation. - * - * @author Mikescher (https://github.com/Mikescher | https://mikescher.com) - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runFilter: function(input, args) { - let delim = Utils.charRep(args[0]), - regex, - reverse = args[2]; - - try { - regex = new RegExp(args[1]); - } catch (err) { - return "Invalid regex. Details: " + err.message; - } - - const regexFilter = function(value) { - return reverse ^ regex.test(value); - }; - - return input.split(delim).filter(regexFilter).join(delim); - }, - - - /** - * @constant - * @default - */ - OFF_CHK_SAMPLE_DELIMITER: "\\n\\n", - - /** - * Offset checker operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runOffsetChecker: function(input, args) { - let sampleDelim = args[0], - samples = input.split(sampleDelim), - outputs = new Array(samples.length), - i = 0, - s = 0, - match = false, - inMatch = false, - chr; - - if (!samples || samples.length < 2) { - return "Not enough samples, perhaps you need to modify the sample delimiter or add more data?"; - } - - // Initialise output strings - outputs.fill("", 0, samples.length); - - // Loop through each character in the first sample - for (i = 0; i < samples[0].length; i++) { - chr = samples[0][i]; - match = false; - - // Loop through each sample to see if the chars are the same - for (s = 1; s < samples.length; s++) { - if (samples[s][i] !== chr) { - match = false; - break; - } - match = true; - } - - // Write output for each sample - for (s = 0; s < samples.length; s++) { - if (samples[s].length <= i) { - if (inMatch) outputs[s] += ""; - if (s === samples.length - 1) inMatch = false; - continue; - } - - if (match && !inMatch) { - outputs[s] += "" + Utils.escapeHtml(samples[s][i]); - if (samples[s].length === i + 1) outputs[s] += ""; - if (s === samples.length - 1) inMatch = true; - } else if (!match && inMatch) { - outputs[s] += "" + Utils.escapeHtml(samples[s][i]); - if (s === samples.length - 1) inMatch = false; - } else { - outputs[s] += Utils.escapeHtml(samples[s][i]); - if (inMatch && samples[s].length === i + 1) { - outputs[s] += ""; - if (samples[s].length - 1 !== i) inMatch = false; - } - } - - if (samples[0].length - 1 === i) { - if (inMatch) outputs[s] += ""; - outputs[s] += Utils.escapeHtml(samples[s].substring(i + 1)); - } - } - } - - return outputs.join(sampleDelim); - }, - - - /** - * @constant - * @default - */ - QUOTE_TYPES: ["Single", "Double", "Backtick"], - /** - * @constant - * @default - */ - ESCAPE_LEVEL: ["Special chars", "Everything", "Minimal"], - - /** - * Escape string operation. - * - * @author Vel0x [dalemy@microsoft.com] - * @author n1474335 [n1474335@gmail.com] - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - * - * @example - * StrUtils.runEscape("Don't do that", []) - * > "Don\'t do that" - * StrUtils.runEscape(`Hello - * World`, []) - * > "Hello\nWorld" - */ - runEscape: function(input, args) { - const level = args[0], - quotes = args[1], - jsonCompat = args[2], - es6Compat = args[3], - lowercaseHex = !args[4]; - - return jsesc(input, { - quotes: quotes.toLowerCase(), - es6: es6Compat, - escapeEverything: level === "Everything", - minimal: level === "Minimal", - json: jsonCompat, - lowercaseHex: lowercaseHex, - }); - }, - - - /** - * Unescape string operation. - * - * @author Vel0x [dalemy@microsoft.com] - * @author n1474335 [n1474335@gmail.com] - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - * - * @example - * StrUtils.runUnescape("Don\'t do that", []) - * > "Don't do that" - * StrUtils.runUnescape("Hello\nWorld", []) - * > `Hello - * World` - */ - runUnescape: function(input, args) { - return Utils.parseEscapedChars(input); - }, - - - /** - * Head lines operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runHead: function(input, args) { - let delimiter = args[0], - number = args[1]; - - delimiter = Utils.charRep(delimiter); - const splitInput = input.split(delimiter); - - return splitInput - .filter((line, lineIndex) => { - lineIndex += 1; - - if (number < 0) { - return lineIndex <= splitInput.length + number; - } else { - return lineIndex <= number; - } - }) - .join(delimiter); - }, - - - /** - * Tail lines operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runTail: function(input, args) { - let delimiter = args[0], - number = args[1]; - - delimiter = Utils.charRep(delimiter); - const splitInput = input.split(delimiter); - - return splitInput - .filter((line, lineIndex) => { - lineIndex += 1; - - if (number < 0) { - return lineIndex > -number; - } else { - return lineIndex > splitInput.length - number; - } - }) - .join(delimiter); - }, - - - /** - * @constant - * @default - */ - HAMMING_DELIM: "\\n\\n", - /** - * @constant - * @default - */ - HAMMING_INPUT_TYPE: ["Raw string", "Hex"], - /** - * @constant - * @default - */ - HAMMING_UNIT: ["Byte", "Bit"], - - /** - * Hamming Distance operation. - * - * @author GCHQ Contributor [2] - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runHamming: function(input, args) { - const delim = args[0], - byByte = args[1] === "Byte", - inputType = args[2], - samples = input.split(delim); - - if (samples.length !== 2) { - return "Error: You can only calculae the edit distance between 2 strings. Please ensure exactly two inputs are provided, separated by the specified delimiter."; - } - - if (samples[0].length !== samples[1].length) { - return "Error: Both inputs must be of the same length."; - } - - if (inputType === "Hex") { - samples[0] = fromHex(samples[0]); - samples[1] = fromHex(samples[1]); - } else { - samples[0] = Utils.strToByteArray(samples[0]); - samples[1] = Utils.strToByteArray(samples[1]); - } - - let dist = 0; - - for (let i = 0; i < samples[0].length; i++) { - const lhs = samples[0][i], - rhs = samples[1][i]; - - if (byByte && lhs !== rhs) { - dist++; - } else if (!byByte) { - let xord = lhs ^ rhs; - - while (xord) { - dist++; - xord &= xord - 1; - } - } - } - - return dist.toString(); - }, -}; - -export default StrUtils; diff --git a/src/core/operations/legacy/Tidy.js b/src/core/operations/legacy/Tidy.js deleted file mode 100755 index 175d888e..00000000 --- a/src/core/operations/legacy/Tidy.js +++ /dev/null @@ -1,250 +0,0 @@ -/** - * Tidy operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Tidy = { - - /** - * @constant - * @default - */ - REMOVE_SPACES: true, - /** - * @constant - * @default - */ - REMOVE_CARIAGE_RETURNS: true, - /** - * @constant - * @default - */ - REMOVE_LINE_FEEDS: true, - /** - * @constant - * @default - */ - REMOVE_TABS: true, - /** - * @constant - * @default - */ - REMOVE_FORM_FEEDS: true, - /** - * @constant - * @default - */ - REMOVE_FULL_STOPS: false, - - /** - * Remove whitespace operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runRemoveWhitespace: function (input, args) { - let removeSpaces = args[0], - removeCariageReturns = args[1], - removeLineFeeds = args[2], - removeTabs = args[3], - removeFormFeeds = args[4], - removeFullStops = args[5], - data = input; - - if (removeSpaces) data = data.replace(/ /g, ""); - if (removeCariageReturns) data = data.replace(/\r/g, ""); - if (removeLineFeeds) data = data.replace(/\n/g, ""); - if (removeTabs) data = data.replace(/\t/g, ""); - if (removeFormFeeds) data = data.replace(/\f/g, ""); - if (removeFullStops) data = data.replace(/\./g, ""); - return data; - }, - - - /** - * Remove null bytes operation. - * - * @param {byteArray} input - * @param {Object[]} args - * @returns {byteArray} - */ - runRemoveNulls: function (input, args) { - const output = []; - for (let i = 0; i < input.length; i++) { - if (input[i] !== 0) output.push(input[i]); - } - return output; - }, - - - /** - * @constant - * @default - */ - APPLY_TO_EACH_LINE: false, - /** - * @constant - * @default - */ - DROP_START: 0, - /** - * @constant - * @default - */ - DROP_LENGTH: 5, - - /** - * Drop bytes operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {ArrayBuffer} - */ - runDropBytes: function(input, args) { - const start = args[0], - length = args[1], - applyToEachLine = args[2]; - - if (start < 0 || length < 0) - throw "Error: Invalid value"; - - if (!applyToEachLine) { - const left = input.slice(0, start), - right = input.slice(start + length, input.byteLength); - let result = new Uint8Array(left.byteLength + right.byteLength); - result.set(new Uint8Array(left), 0); - result.set(new Uint8Array(right), left.byteLength); - return result.buffer; - } - - // Split input into lines - const data = new Uint8Array(input); - let lines = [], - line = [], - i; - - for (i = 0; i < data.length; i++) { - if (data[i] === 0x0a) { - lines.push(line); - line = []; - } else { - line.push(data[i]); - } - } - lines.push(line); - - let output = []; - for (i = 0; i < lines.length; i++) { - output = output.concat(lines[i].slice(0, start).concat(lines[i].slice(start+length, lines[i].length))); - output.push(0x0a); - } - return new Uint8Array(output.slice(0, output.length-1)).buffer; - }, - - - /** - * @constant - * @default - */ - TAKE_START: 0, - /** - * @constant - * @default - */ - TAKE_LENGTH: 5, - - /** - * Take bytes operation. - * - * @param {ArrayBuffer} input - * @param {Object[]} args - * @returns {ArrayBuffer} - */ - runTakeBytes: function(input, args) { - const start = args[0], - length = args[1], - applyToEachLine = args[2]; - - if (start < 0 || length < 0) - throw "Error: Invalid value"; - - if (!applyToEachLine) - return input.slice(start, start+length); - - // Split input into lines - const data = new Uint8Array(input); - let lines = [], - line = [], - i; - - for (i = 0; i < data.length; i++) { - if (data[i] === 0x0a) { - lines.push(line); - line = []; - } else { - line.push(data[i]); - } - } - lines.push(line); - - let output = []; - for (i = 0; i < lines.length; i++) { - output = output.concat(lines[i].slice(start, start+length)); - output.push(0x0a); - } - return new Uint8Array(output.slice(0, output.length-1)).buffer; - }, - - - /** - * @constant - * @default - */ - PAD_POSITION: ["Start", "End"], - /** - * @constant - * @default - */ - PAD_LENGTH: 5, - /** - * @constant - * @default - */ - PAD_CHAR: " ", - - /** - * Pad lines operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runPad: function(input, args) { - let position = args[0], - len = args[1], - chr = args[2], - lines = input.split("\n"), - output = "", - i = 0; - - if (position === "Start") { - for (i = 0; i < lines.length; i++) { - output += lines[i].padStart(lines[i].length+len, chr) + "\n"; - } - } else if (position === "End") { - for (i = 0; i < lines.length; i++) { - output += lines[i].padEnd(lines[i].length+len, chr) + "\n"; - } - } - - return output.slice(0, output.length-1); - }, - -}; - -export default Tidy; diff --git a/src/core/operations/legacy/ToTable.js b/src/core/operations/legacy/ToTable.js deleted file mode 100644 index b18b56f1..00000000 --- a/src/core/operations/legacy/ToTable.js +++ /dev/null @@ -1,164 +0,0 @@ -/** - * ToTable operations. - * - * @author Mark Jones [github.com/justanothermark] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - * - * @namespace - */ -import Utils from "../Utils.js"; - -const ToTable = { - - /** - * @constant - * @default - */ - FORMATS: [ - "ASCII", - "HTML" - ], - - - /** - * To Table operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {html} - */ - runToTable: function (input, args) { - const [cellDelims, rowDelims, firstRowHeader, format] = args; - - // Process the input into a nested array of elements. - const tableData = Utils.parseCSV(input, cellDelims.split(""), rowDelims.split("")); - - if (!tableData.length) return ""; - - // Render the data in the requested format. - switch (format) { - case "ASCII": - return asciiOutput(tableData); - case "HTML": - default: - return htmlOutput(tableData); - } - - /** - * Outputs an array of data as an ASCII table. - * - * @param {string[][]} tableData - * @returns {string} - */ - function asciiOutput(tableData) { - const horizontalBorder = "-"; - const verticalBorder = "|"; - const crossBorder = "+"; - - let output = ""; - let longestCells = []; - - // Find longestCells value per column to pad cells equally. - tableData.forEach(function(row, index) { - row.forEach(function(cell, cellIndex) { - if (longestCells[cellIndex] === undefined || cell.length > longestCells[cellIndex]) { - longestCells[cellIndex] = cell.length; - } - }); - }); - - // Add the top border of the table to the output. - output += outputHorizontalBorder(longestCells); - - // If the first row is a header, remove the row from the data and - // add it to the output with another horizontal border. - if (firstRowHeader) { - let row = tableData.shift(); - output += outputRow(row, longestCells); - output += outputHorizontalBorder(longestCells); - } - - // Add the rest of the table rows. - tableData.forEach(function(row, index) { - output += outputRow(row, longestCells); - }); - - // Close the table with a final horizontal border. - output += outputHorizontalBorder(longestCells); - - return output; - - /** - * Outputs a row of correctly padded cells. - */ - function outputRow(row, longestCells) { - let rowOutput = verticalBorder; - row.forEach(function(cell, index) { - rowOutput += " " + cell + " ".repeat(longestCells[index] - cell.length) + " " + verticalBorder; - }); - rowOutput += "\n"; - return rowOutput; - } - - /** - * Outputs a horizontal border with a different character where - * the horizontal border meets a vertical border. - */ - function outputHorizontalBorder(longestCells) { - let rowOutput = crossBorder; - longestCells.forEach(function(cellLength) { - rowOutput += horizontalBorder.repeat(cellLength + 2) + crossBorder; - }); - rowOutput += "\n"; - return rowOutput; - } - } - - /** - * Outputs a table of data as a HTML table. - * - * @param {string[][]} tableData - * @returns {string} - */ - function htmlOutput(tableData) { - // Start the HTML output with suitable classes for styling. - let output = ""; - - // If the first row is a header then put it in with "; - output += outputRow(row, "th"); - output += ""; - } - - // Output the rest of the rows in the . - output += ""; - tableData.forEach(function(row, index) { - output += outputRow(row, "td"); - }); - - // Close the body and table elements. - output += "
cells. - if (firstRowHeader) { - let row = tableData.shift(); - output += "
"; - return output; - - /** - * Outputs a table row. - * - * @param {string[]} row - * @param {string} cellType - */ - function outputRow(row, cellType) { - let output = ""; - row.forEach(function(cell) { - output += "<" + cellType + ">" + cell + ""; - }); - output += ""; - return output; - } - } - } -}; - -export default ToTable; diff --git a/src/core/operations/legacy/UUID.js b/src/core/operations/legacy/UUID.js deleted file mode 100755 index 7b485579..00000000 --- a/src/core/operations/legacy/UUID.js +++ /dev/null @@ -1,36 +0,0 @@ -import crypto from "crypto"; - - -/** - * UUID operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const UUID = { - - /** - * Generate UUID operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runGenerateV4: function(input, args) { - const buf = new Uint32Array(4).map(() => { - return crypto.randomBytes(4).readUInt32BE(0, true); - }); - let i = 0; - return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) { - let r = (buf[i >> 3] >> ((i % 8) * 4)) & 0xf, - v = c === "x" ? r : (r & 0x3 | 0x8); - i++; - return v.toString(16); - }); - } -}; - -export default UUID; diff --git a/src/core/operations/legacy/Unicode.js b/src/core/operations/legacy/Unicode.js deleted file mode 100755 index 104ef07e..00000000 --- a/src/core/operations/legacy/Unicode.js +++ /dev/null @@ -1,101 +0,0 @@ -import Utils from "../Utils.js"; - - -/** - * Unicode operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - * - * @namespace - */ -const Unicode = { - - /** - * @constant - * @default - */ - PREFIXES: ["\\u", "%u", "U+"], - - /** - * Unescape Unicode Characters operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runUnescape: function(input, args) { - let prefix = Unicode._prefixToRegex[args[0]], - regex = new RegExp(prefix+"([a-f\\d]{4})", "ig"), - output = "", - m, - i = 0; - - while ((m = regex.exec(input))) { - // Add up to match - output += input.slice(i, m.index); - i = m.index; - - // Add match - output += Utils.chr(parseInt(m[1], 16)); - - i = regex.lastIndex; - } - - // Add all after final match - output += input.slice(i, input.length); - - return output; - }, - - - /** - * Escape Unicode Characters operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {string} - */ - runEscape: function(input, args) { - const regexWhitelist = /[ -~]/i, - prefix = args[0], - encodeAll = args[1], - padding = args[2], - uppercaseHex = args[3]; - - let output = "", - character = ""; - - for (let i = 0; i < input.length; i++) { - character = input[i]; - if (!encodeAll && regexWhitelist.test(character)) { - // It’s a printable ASCII character so don’t escape it. - output += character; - continue; - } - - let cp = character.codePointAt(0).toString(16); - if (uppercaseHex) cp = cp.toUpperCase(); - output += prefix + cp.padStart(padding, "0"); - } - - return output; - }, - - - /** - * Lookup table to add prefixes to unicode delimiters so that they can be used in a regex. - * - * @private - * @constant - */ - _prefixToRegex: { - "\\u": "\\\\u", - "%u": "%u", - "U+": "U\\+" - }, - -}; - -export default Unicode; diff --git a/src/core/operations/legacy/XKCD.js b/src/core/operations/legacy/XKCD.js deleted file mode 100755 index 4144d88f..00000000 --- a/src/core/operations/legacy/XKCD.js +++ /dev/null @@ -1,26 +0,0 @@ -/** - * XKCD operations. - * - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2018 - * @license Apache-2.0 - * - * @namespace - */ -const XKCD = { - - /** - * XKCD Random Number operation. - * - * @param {string} input - * @param {Object[]} args - * @returns {number} - */ - runRandomNumber: function(input, args) { - return 4; // chosen by fair dice roll. - // guaranteed to be random. - }, - -}; - -export default XKCD; diff --git a/src/web/App.js b/src/web/App.js deleted file mode 100644 index c08658a7..00000000 --- a/src/web/App.js +++ /dev/null @@ -1,753 +0,0 @@ -/** - * @author n1474335 [n1474335@gmail.com] - * @copyright Crown Copyright 2016 - * @license Apache-2.0 - */ - -import Utils from "../core/Utils"; -import {fromBase64} from "../core/lib/Base64"; -import Manager from "./Manager"; -import HTMLCategory from "./HTMLCategory"; -import HTMLOperation from "./HTMLOperation"; -import Split from "split.js"; - - -/** - * HTML view for CyberChef responsible for building the web page and dealing with all user - * interactions. - */ -class App { - - /** - * App constructor. - * - * @param {CatConf[]} categories - The list of categories and operations to be populated. - * @param {Object.} operations - The list of operation configuration objects. - * @param {String[]} defaultFavourites - A list of default favourite operations. - * @param {Object} options - Default setting for app options. - */ - constructor(categories, operations, defaultFavourites, defaultOptions) { - this.categories = categories; - this.operations = operations; - this.dfavourites = defaultFavourites; - this.doptions = defaultOptions; - this.options = Object.assign({}, defaultOptions); - - this.manager = new Manager(this); - - this.baking = false; - this.autoBake_ = false; - this.autoBakePause = false; - this.progress = 0; - this.ingId = 0; - } - - - /** - * This function sets up the stage and creates listeners for all events. - * - * @fires Manager#appstart - */ - setup() { - document.dispatchEvent(this.manager.appstart); - this.initialiseSplitter(); - this.loadLocalStorage(); - this.populateOperationsList(); - this.manager.setup(); - this.resetLayout(); - this.setCompileMessage(); - - log.debug("App loaded"); - this.appLoaded = true; - - this.loadURIParams(); - this.loaded(); - } - - - /** - * Fires once all setup activities have completed. - * - * @fires Manager#apploaded - */ - loaded() { - // Check that both the app and the worker have loaded successfully, and that - // we haven't already loaded before attempting to remove the loading screen. - if (!this.workerLoaded || !this.appLoaded || - !document.getElementById("loader-wrapper")) return; - - // Trigger CSS animations to remove preloader - document.body.classList.add("loaded"); - - // Wait for animations to complete then remove the preloader and loaded style - // so that the animations for existing elements don't play again. - setTimeout(function() { - document.getElementById("loader-wrapper").remove(); - document.body.classList.remove("loaded"); - }, 1000); - - // Clear the loading message interval - clearInterval(window.loadingMsgsInt); - - // Remove the loading error handler - window.removeEventListener("error", window.loadingErrorHandler); - - document.dispatchEvent(this.manager.apploaded); - } - - - /** - * An error handler for displaying the error to the user. - * - * @param {Error} err - * @param {boolean} [logToConsole=false] - */ - handleError(err, logToConsole) { - if (logToConsole) log.error(err); - const msg = err.displayStr || err.toString(); - this.alert(msg, "danger", this.options.errorTimeout, !this.options.showErrors); - } - - - /** - * Asks the ChefWorker to bake the current input using the current recipe. - * - * @param {boolean} [step] - Set to true if we should only execute one operation instead of the - * whole recipe. - */ - bake(step) { - if (this.baking) return; - - // Reset attemptHighlight flag - this.options.attemptHighlight = true; - - this.manager.worker.bake( - this.getInput(), // The user's input - this.getRecipeConfig(), // The configuration of the recipe - this.options, // Options set by the user - this.progress, // The current position in the recipe - step // Whether or not to take one step or execute the whole recipe - ); - } - - - /** - * Runs Auto Bake if it is set. - */ - autoBake() { - // If autoBakePause is set, we are loading a full recipe (and potentially input), so there is no - // need to set the staleness indicator. Just exit and wait until auto bake is called after loading - // has completed. - if (this.autoBakePause) return false; - - if (this.autoBake_ && !this.baking) { - log.debug("Auto-baking"); - this.bake(); - } else { - this.manager.controls.showStaleIndicator(); - } - } - - - /** - * Runs a silent bake, forcing the browser to load and cache all the relevant JavaScript code needed - * to do a real bake. - * - * The output will not be modified (hence "silent" bake). This will only actually execute the recipe - * if auto-bake is enabled, otherwise it will just wake up the ChefWorker with an empty recipe. - */ - silentBake() { - let recipeConfig = []; - - if (this.autoBake_) { - // If auto-bake is not enabled we don't want to actually run the recipe as it may be disabled - // for a good reason. - recipeConfig = this.getRecipeConfig(); - } - - this.manager.worker.silentBake(recipeConfig); - } - - - /** - * Gets the user's input data. - * - * @returns {string} - */ - getInput() { - return this.manager.input.get(); - } - - - /** - * Sets the user's input data. - * - * @param {string} input - The string to set the input to - */ - setInput(input) { - this.manager.input.set(input); - } - - - /** - * Populates the operations accordion list with the categories and operations specified in the - * view constructor. - * - * @fires Manager#oplistcreate - */ - populateOperationsList() { - // Move edit button away before we overwrite it - document.body.appendChild(document.getElementById("edit-favourites")); - - let html = ""; - let i; - - for (i = 0; i < this.categories.length; i++) { - const catConf = this.categories[i], - selected = i === 0, - cat = new HTMLCategory(catConf.name, selected); - - for (let j = 0; j < catConf.ops.length; j++) { - const opName = catConf.ops[j]; - if (!this.operations.hasOwnProperty(opName)) { - log.warn(`${opName} could not be found.`); - continue; - } - - const op = new HTMLOperation(opName, this.operations[opName], this, this.manager); - cat.addOperation(op); - } - - html += cat.toHtml(); - } - - document.getElementById("categories").innerHTML = html; - - const opLists = document.querySelectorAll("#categories .op-list"); - - for (i = 0; i < opLists.length; i++) { - opLists[i].dispatchEvent(this.manager.oplistcreate); - } - - // Add edit button to first category (Favourites) - document.querySelector("#categories a").appendChild(document.getElementById("edit-favourites")); - } - - - /** - * Sets up the adjustable splitter to allow the user to resize areas of the page. - */ - initialiseSplitter() { - this.columnSplitter = Split(["#operations", "#recipe", "#IO"], { - sizes: [20, 30, 50], - minSize: [240, 325, 450], - gutterSize: 4, - onDrag: function() { - this.manager.controls.adjustWidth(); - this.manager.output.adjustWidth(); - }.bind(this) - }); - - this.ioSplitter = Split(["#input", "#output"], { - direction: "vertical", - gutterSize: 4, - }); - - this.resetLayout(); - } - - - /** - * Loads the information previously saved to the HTML5 local storage object so that user options - * and favourites can be restored. - */ - loadLocalStorage() { - // Load options - let lOptions; - if (this.isLocalStorageAvailable() && localStorage.options !== undefined) { - lOptions = JSON.parse(localStorage.options); - } - this.manager.options.load(lOptions); - - // Load favourites - this.loadFavourites(); - } - - - /** - * Loads the user's favourite operations from the HTML5 local storage object and populates the - * Favourites category with them. - * If the user currently has no saved favourites, the defaults from the view constructor are used. - */ - loadFavourites() { - let favourites; - - if (this.isLocalStorageAvailable()) { - favourites = localStorage.favourites && localStorage.favourites.length > 2 ? - JSON.parse(localStorage.favourites) : - this.dfavourites; - favourites = this.validFavourites(favourites); - this.saveFavourites(favourites); - } else { - favourites = this.dfavourites; - } - - const favCat = this.categories.filter(function(c) { - return c.name === "Favourites"; - })[0]; - - if (favCat) { - favCat.ops = favourites; - } else { - this.categories.unshift({ - name: "Favourites", - ops: favourites - }); - } - } - - - /** - * Filters the list of favourite operations that the user had stored and removes any that are no - * longer available. The user is notified if this is the case. - - * @param {string[]} favourites - A list of the user's favourite operations - * @returns {string[]} A list of the valid favourites - */ - validFavourites(favourites) { - const validFavs = []; - for (let i = 0; i < favourites.length; i++) { - if (this.operations.hasOwnProperty(favourites[i])) { - validFavs.push(favourites[i]); - } else { - this.alert("The operation \"" + Utils.escapeHtml(favourites[i]) + - "\" is no longer available. It has been removed from your favourites.", "info"); - } - } - return validFavs; - } - - - /** - * Saves a list of favourite operations to the HTML5 local storage object. - * - * @param {string[]} favourites - A list of the user's favourite operations - */ - saveFavourites(favourites) { - if (!this.isLocalStorageAvailable()) { - this.alert( - "Your security settings do not allow access to local storage so your favourites cannot be saved.", - "danger", - 5000 - ); - return false; - } - - localStorage.setItem("favourites", JSON.stringify(this.validFavourites(favourites))); - } - - - /** - * Resets favourite operations back to the default as specified in the view constructor and - * refreshes the operation list. - */ - resetFavourites() { - this.saveFavourites(this.dfavourites); - this.loadFavourites(); - this.populateOperationsList(); - this.manager.recipe.initialiseOperationDragNDrop(); - } - - - /** - * Adds an operation to the user's favourites. - * - * @param {string} name - The name of the operation - */ - addFavourite(name) { - const favourites = JSON.parse(localStorage.favourites); - - if (favourites.indexOf(name) >= 0) { - this.alert("'" + name + "' is already in your favourites", "info", 2000); - return; - } - - favourites.push(name); - this.saveFavourites(favourites); - this.loadFavourites(); - this.populateOperationsList(); - this.manager.recipe.initialiseOperationDragNDrop(); - } - - - /** - * Checks for input and recipe in the URI parameters and loads them if present. - */ - loadURIParams() { - // Load query string or hash from URI (depending on which is populated) - // We prefer getting the hash by splitting the href rather than referencing - // location.hash as some browsers (Firefox) automatically URL decode it, - // which cause issues. - const params = window.location.search || - window.location.href.split("#")[1] || - window.location.hash; - this.uriParams = Utils.parseURIParams(params); - this.autoBakePause = true; - - // Read in recipe from URI params - if (this.uriParams.recipe) { - try { - const recipeConfig = Utils.parseRecipeConfig(this.uriParams.recipe); - this.setRecipeConfig(recipeConfig); - } catch (err) {} - } else if (this.uriParams.op) { - // If there's no recipe, look for single operations - this.manager.recipe.clearRecipe(); - - // Search for nearest match and add it - const matchedOps = this.manager.ops.filterOperations(this.uriParams.op, false); - if (matchedOps.length) { - this.manager.recipe.addOperation(matchedOps[0].name); - } - - // Populate search with the string - const search = document.getElementById("search"); - - search.value = this.uriParams.op; - search.dispatchEvent(new Event("search")); - } - - // Read in input data from URI params - if (this.uriParams.input) { - try { - const inputData = fromBase64(this.uriParams.input); - this.setInput(inputData); - } catch (err) {} - } - - this.autoBakePause = false; - this.autoBake(); - } - - - /** - * Returns the next ingredient ID and increments it for next time. - * - * @returns {number} - */ - nextIngId() { - return this.ingId++; - } - - - /** - * Gets the current recipe configuration. - * - * @returns {Object[]} - */ - getRecipeConfig() { - return this.manager.recipe.getConfig(); - } - - - /** - * Given a recipe configuration, sets the recipe to that configuration. - * - * @fires Manager#statechange - * @param {Object[]} recipeConfig - The recipe configuration - */ - setRecipeConfig(recipeConfig) { - document.getElementById("rec-list").innerHTML = null; - - // Pause auto-bake while loading but don't modify `this.autoBake_` - // otherwise `manualBake` cannot trigger. - this.autoBakePause = true; - - for (let i = 0; i < recipeConfig.length; i++) { - const item = this.manager.recipe.addOperation(recipeConfig[i].op); - - // Populate arguments - const args = item.querySelectorAll(".arg"); - for (let j = 0; j < args.length; j++) { - if (recipeConfig[i].args[j] === undefined) continue; - if (args[j].getAttribute("type") === "checkbox") { - // checkbox - args[j].checked = recipeConfig[i].args[j]; - } else if (args[j].classList.contains("toggle-string")) { - // toggleString - args[j].value = recipeConfig[i].args[j].string; - args[j].previousSibling.children[0].innerHTML = - Utils.escapeHtml(recipeConfig[i].args[j].option) + - " "; - } else { - // all others - args[j].value = recipeConfig[i].args[j]; - } - } - - // Set disabled and breakpoint - if (recipeConfig[i].disabled) { - item.querySelector(".disable-icon").click(); - } - if (recipeConfig[i].breakpoint) { - item.querySelector(".breakpoint").click(); - } - - this.progress = 0; - } - - // Unpause auto bake - this.autoBakePause = false; - } - - - /** - * Resets the splitter positions to default. - */ - resetLayout() { - this.columnSplitter.setSizes([20, 30, 50]); - this.ioSplitter.setSizes([50, 50]); - - this.manager.controls.adjustWidth(); - this.manager.output.adjustWidth(); - } - - - /** - * Sets the compile message. - */ - setCompileMessage() { - // Display time since last build and compile message - const now = new Date(), - timeSinceCompile = Utils.fuzzyTime(now.getTime() - window.compileTime); - - // Calculate previous version to compare to - const prev = PKG_VERSION.split(".").map(n => { - return parseInt(n, 10); - }); - if (prev[2] > 0) prev[2]--; - else if (prev[1] > 0) prev[1]--; - else prev[0]--; - - const compareURL = `https://github.com/gchq/CyberChef/compare/v${prev.join(".")}...v${PKG_VERSION}`; - - let compileInfo = `Last build: ${timeSinceCompile.substr(0, 1).toUpperCase() + timeSinceCompile.substr(1)} ago`; - - if (window.compileMessage !== "") { - compileInfo += " - " + window.compileMessage; - } - - document.getElementById("notice").innerHTML = compileInfo; - } - - - /** - * Determines whether the browser supports Local Storage and if it is accessible. - * - * @returns {boolean} - */ - isLocalStorageAvailable() { - try { - if (!localStorage) return false; - return true; - } catch (err) { - // Access to LocalStorage is denied - return false; - } - } - - - /** - * Pops up a message to the user and writes it to the console log. - * - * @param {string} str - The message to display (HTML supported) - * @param {string} style - The colour of the popup - * "danger" = red - * "warning" = amber - * "info" = blue - * "success" = green - * @param {number} timeout - The number of milliseconds before the popup closes automatically - * 0 for never (until the user closes it) - * @param {boolean} [silent=false] - Don't show the message in the popup, only print it to the - * console - * - * @example - * // Pops up a red box with the message "[current time] Error: Something has gone wrong!" - * // that will need to be dismissed by the user. - * this.alert("Error: Something has gone wrong!", "danger", 0); - * - * // Pops up a blue information box with the message "[current time] Happy Christmas!" - * // that will disappear after 5 seconds. - * this.alert("Happy Christmas!", "info", 5000); - */ - alert(str, style, timeout, silent) { - const time = new Date(); - - log.info("[" + time.toLocaleString() + "] " + str); - if (silent) return; - - style = style || "danger"; - timeout = timeout || 0; - - const alertEl = document.getElementById("alert"), - alertContent = document.getElementById("alert-content"); - - alertEl.classList.remove("alert-danger"); - alertEl.classList.remove("alert-warning"); - alertEl.classList.remove("alert-info"); - alertEl.classList.remove("alert-success"); - alertEl.classList.add("alert-" + style); - - // If the box hasn't been closed, append to it rather than replacing - if (alertEl.style.display === "block") { - alertContent.innerHTML += - "

[" + time.toLocaleTimeString() + "] " + str; - } else { - alertContent.innerHTML = - "[" + time.toLocaleTimeString() + "] " + str; - } - - // Stop the animation if it is in progress - $("#alert").stop(); - alertEl.style.display = "block"; - alertEl.style.opacity = 1; - - if (timeout > 0) { - clearTimeout(this.alertTimeout); - this.alertTimeout = setTimeout(function(){ - $("#alert").slideUp(100); - }, timeout); - } - } - - - /** - * Pops up a box asking the user a question and sending the answer to a specified callback function. - * - * @param {string} title - The title of the box - * @param {string} body - The question (HTML supported) - * @param {function} callback - A function accepting one boolean argument which handles the - * response e.g. function(answer) {...} - * @param {Object} [scope=this] - The object to bind to the callback function - * - * @example - * // Pops up a box asking if the user would like a cookie. Prints the answer to the console. - * this.confirm("Question", "Would you like a cookie?", function(answer) {console.log(answer);}); - */ - confirm(title, body, callback, scope) { - scope = scope || this; - document.getElementById("confirm-title").innerHTML = title; - document.getElementById("confirm-body").innerHTML = body; - document.getElementById("confirm-modal").style.display = "block"; - - this.confirmClosed = false; - $("#confirm-modal").modal() - .one("show.bs.modal", function(e) { - this.confirmClosed = false; - }.bind(this)) - .one("click", "#confirm-yes", function() { - this.confirmClosed = true; - callback.bind(scope)(true); - $("#confirm-modal").modal("hide"); - }.bind(this)) - .one("hide.bs.modal", function(e) { - if (!this.confirmClosed) - callback.bind(scope)(false); - this.confirmClosed = true; - }.bind(this)); - } - - - /** - * Handler for the alert close button click event. - * Closes the alert box. - */ - alertCloseClick() { - document.getElementById("alert").style.display = "none"; - } - - - /** - * Handler for CyerChef statechange events. - * Fires whenever the input or recipe changes in any way. - * - * @listens Manager#statechange - * @param {event} e - */ - stateChange(e) { - this.autoBake(); - - // Set title - const recipeConfig = this.getRecipeConfig(); - let title = "CyberChef"; - if (recipeConfig.length === 1) { - title = `${recipeConfig[0].op} - ${title}`; - } else if (recipeConfig.length > 1) { - // See how long the full recipe is - const ops = recipeConfig.map(op => op.op).join(", "); - if (ops.length < 45) { - title = `${ops} - ${title}`; - } else { - // If it's too long, just use the first one and say how many more there are - title = `${recipeConfig[0].op}, ${recipeConfig.length - 1} more - ${title}`; - } - } - document.title = title; - - // Update the current history state (not creating a new one) - if (this.options.updateUrl) { - this.lastStateUrl = this.manager.controls.generateStateUrl(true, true, recipeConfig); - window.history.replaceState({}, title, this.lastStateUrl); - } - } - - - /** - * Handler for the history popstate event. - * Reloads parameters from the URL. - * - * @param {event} e - */ - popState(e) { - this.loadURIParams(); - } - - - /** - * Function to call an external API from this view. - */ - callApi(url, type, data, dataType, contentType) { - type = type || "POST"; - data = data || {}; - dataType = dataType || undefined; - contentType = contentType || "application/json"; - - let response = null, - success = false; - - $.ajax({ - url: url, - async: false, - type: type, - data: data, - dataType: dataType, - contentType: contentType, - success: function(data) { - success = true; - response = data; - }, - error: function(data) { - success = false; - response = data; - }, - }); - - return { - success: success, - response: response - }; - } - -} - -export default App; diff --git a/webpack.config.js b/webpack.config.js index 99552a9b..ae4ec119 100644 --- a/webpack.config.js +++ b/webpack.config.js @@ -12,10 +12,10 @@ const ExtractTextPlugin = require("extract-text-webpack-plugin"); const banner = `/** * CyberChef - The Cyber Swiss Army Knife * - * @copyright Crown Copyright 2017 + * @copyright Crown Copyright 2016 * @license Apache-2.0 * - * Copyright 2017 Crown Copyright + * Copyright 2016 Crown Copyright * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License.