Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
jsesc - npm Package Compare versions
Comparing version 1.3.0 to 2.0.0
566
jsesc.js
@@ -1,345 +0,299 @@ | ||
| /*! https://mths.be/jsesc v1.3.0 by @mathias */ | ||
| ;(function(root) { | ||
| 'use strict'; | ||
| // Detect free variables `exports` | ||
| var freeExports = typeof exports == 'object' && exports; | ||
| const object = {}; | ||
| const hasOwnProperty = object.hasOwnProperty; | ||
| const forOwn = function(object, callback) { | ||
| for (const key in object) { | ||
| if (hasOwnProperty.call(object, key)) { | ||
| callback(key, object[key]); | ||
| } | ||
| } | ||
| }; | ||
| // Detect free variable `module` | ||
| var freeModule = typeof module == 'object' && module && | ||
| module.exports == freeExports && module; | ||
| const extend = function(destination, source) { | ||
| if (!source) { | ||
| return destination; | ||
| } | ||
| forOwn(source, function(key, value) { | ||
| destination[key] = value; | ||
| }); | ||
| return destination; | ||
| }; | ||
| // Detect free variable `global`, from Node.js or Browserified code, | ||
| // and use it as `root` | ||
| var freeGlobal = typeof global == 'object' && global; | ||
| if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) { | ||
| root = freeGlobal; | ||
| const forEach = function(array, callback) { | ||
| const length = array.length; | ||
| let index = -1; | ||
| while (++index < length) { | ||
| callback(array[index]); | ||
| } | ||
| }; | ||
| /*--------------------------------------------------------------------------*/ | ||
| const toString = object.toString; | ||
| const isArray = Array.isArray; | ||
| const isObject = function(value) { | ||
| // This is a very simple check, but it’s good enough for what we need. | ||
| return toString.call(value) == '[object Object]'; | ||
| }; | ||
| const isString = function(value) { | ||
| return typeof value == 'string' || | ||
| toString.call(value) == '[object String]'; | ||
| }; | ||
| const isNumber = function(value) { | ||
| return typeof value == 'number' || | ||
| toString.call(value) == '[object Number]'; | ||
| }; | ||
| const isFunction = function(value) { | ||
| return typeof value == 'function'; | ||
| }; | ||
| const isMap = function(value) { | ||
| return toString.call(value) == '[object Map]'; | ||
| }; | ||
| const isSet = function(value) { | ||
| return toString.call(value) == '[object Set]'; | ||
| }; | ||
| var object = {}; | ||
| var hasOwnProperty = object.hasOwnProperty; | ||
| var forOwn = function(object, callback) { | ||
| var key; | ||
| for (key in object) { | ||
| if (hasOwnProperty.call(object, key)) { | ||
| callback(key, object[key]); | ||
| } | ||
| } | ||
| }; | ||
| /*--------------------------------------------------------------------------*/ | ||
| var extend = function(destination, source) { | ||
| if (!source) { | ||
| return destination; | ||
| } | ||
| forOwn(source, function(key, value) { | ||
| destination[key] = value; | ||
| }); | ||
| return destination; | ||
| }; | ||
| // https://mathiasbynens.be/notes/javascript-escapes#single | ||
| const singleEscapes = { | ||
| '"': '\\"', | ||
| '\'': '\\\'', | ||
| '\\': '\\\\', | ||
| '\b': '\\b', | ||
| '\f': '\\f', | ||
| '\n': '\\n', | ||
| '\r': '\\r', | ||
| '\t': '\\t' | ||
| // `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'. | ||
| // '\v': '\\x0B' | ||
| }; | ||
| const regexSingleEscape = /["'\\\b\f\n\r\t]/; | ||
| var forEach = function(array, callback) { | ||
| var length = array.length; | ||
| var index = -1; | ||
| while (++index < length) { | ||
| callback(array[index]); | ||
| } | ||
| }; | ||
| const regexDigit = /[0-9]/; | ||
| const regexWhitelist = /[ !#-&\(-\[\]-~]/; | ||
| var toString = object.toString; | ||
| var isArray = function(value) { | ||
| return toString.call(value) == '[object Array]'; | ||
| const jsesc = function(argument, options) { | ||
| const increaseIndentation = function() { | ||
| oldIndent = indent; | ||
| ++options.__indentLevel__; | ||
| indent = options.indent.repeat(options.__indentLevel__) | ||
| }; | ||
| var isObject = function(value) { | ||
| // This is a very simple check, but it’s good enough for what we need. | ||
| return toString.call(value) == '[object Object]'; | ||
| // Handle options | ||
| const defaults = { | ||
| 'escapeEverything': false, | ||
| 'escapeEtago': false, | ||
| 'quotes': 'single', | ||
| 'wrap': false, | ||
| 'es6': false, | ||
| 'json': false, | ||
| 'compact': true, | ||
| 'lowercaseHex': false, | ||
| 'numbers': 'decimal', | ||
| 'indent': '\t', | ||
| '__indentLevel__': 0, | ||
| '__inline1__': false, | ||
| '__inline2__': false | ||
| }; | ||
| var isString = function(value) { | ||
| return typeof value == 'string' || | ||
| toString.call(value) == '[object String]'; | ||
| }; | ||
| var isNumber = function(value) { | ||
| return typeof value == 'number' || | ||
| toString.call(value) == '[object Number]'; | ||
| }; | ||
| var isFunction = function(value) { | ||
| // In a perfect world, the `typeof` check would be sufficient. However, | ||
| // in Chrome 1–12, `typeof /x/ == 'object'`, and in IE 6–8 | ||
| // `typeof alert == 'object'` and similar for other host objects. | ||
| return typeof value == 'function' || | ||
| toString.call(value) == '[object Function]'; | ||
| }; | ||
| var isMap = function(value) { | ||
| return toString.call(value) == '[object Map]'; | ||
| }; | ||
| var isSet = function(value) { | ||
| return toString.call(value) == '[object Set]'; | ||
| }; | ||
| const json = options && options.json; | ||
| if (json) { | ||
| defaults.quotes = 'double'; | ||
| defaults.wrap = true; | ||
| } | ||
| options = extend(defaults, options); | ||
| if (options.quotes != 'single' && options.quotes != 'double') { | ||
| options.quotes = 'single'; | ||
| } | ||
| const quote = options.quotes == 'double' ? '"' : '\''; | ||
| const compact = options.compact; | ||
| const lowercaseHex = options.lowercaseHex; | ||
| let indent = options.indent.repeat(options.__indentLevel__); | ||
| let oldIndent = ''; | ||
| const inline1 = options.__inline1__; | ||
| const inline2 = options.__inline2__; | ||
| const newLine = compact ? '' : '\n'; | ||
| let result; | ||
| let isEmpty = true; | ||
| const useBinNumbers = options.numbers == 'binary'; | ||
| const useOctNumbers = options.numbers == 'octal'; | ||
| const useDecNumbers = options.numbers == 'decimal'; | ||
| const useHexNumbers = options.numbers == 'hexadecimal'; | ||
| /*--------------------------------------------------------------------------*/ | ||
| if (json && argument && isFunction(argument.toJSON)) { | ||
| argument = argument.toJSON(); | ||
| } | ||
| // https://mathiasbynens.be/notes/javascript-escapes#single | ||
| var singleEscapes = { | ||
| '"': '\\"', | ||
| '\'': '\\\'', | ||
| '\\': '\\\\', | ||
| '\b': '\\b', | ||
| '\f': '\\f', | ||
| '\n': '\\n', | ||
| '\r': '\\r', | ||
| '\t': '\\t' | ||
| // `\v` is omitted intentionally, because in IE < 9, '\v' == 'v'. | ||
| // '\v': '\\x0B' | ||
| }; | ||
| var regexSingleEscape = /["'\\\b\f\n\r\t]/; | ||
| var regexDigit = /[0-9]/; | ||
| var regexWhitelist = /[ !#-&\(-\[\]-~]/; | ||
| var jsesc = function(argument, options) { | ||
| // Handle options | ||
| var defaults = { | ||
| 'escapeEverything': false, | ||
| 'escapeEtago': false, | ||
| 'quotes': 'single', | ||
| 'wrap': false, | ||
| 'es6': false, | ||
| 'json': false, | ||
| 'compact': true, | ||
| 'lowercaseHex': false, | ||
| 'numbers': 'decimal', | ||
| 'indent': '\t', | ||
| '__indent__': '', | ||
| '__inline1__': false, | ||
| '__inline2__': false | ||
| }; | ||
| var json = options && options.json; | ||
| if (json) { | ||
| defaults.quotes = 'double'; | ||
| defaults.wrap = true; | ||
| if (!isString(argument)) { | ||
| if (isMap(argument)) { | ||
| if (argument.size == 0) { | ||
| return 'new Map()'; | ||
| } | ||
| if (!compact) { | ||
| options.__inline1__ = true; | ||
| options.__inline2__ = false; | ||
| } | ||
| return 'new Map(' + jsesc(Array.from(argument), options) + ')'; | ||
| } | ||
| options = extend(defaults, options); | ||
| if (options.quotes != 'single' && options.quotes != 'double') { | ||
| options.quotes = 'single'; | ||
| if (isSet(argument)) { | ||
| if (argument.size == 0) { | ||
| return 'new Set()'; | ||
| } | ||
| return 'new Set(' + jsesc(Array.from(argument), options) + ')'; | ||
| } | ||
| var quote = options.quotes == 'double' ? '"' : '\''; | ||
| var compact = options.compact; | ||
| var indent = options.indent; | ||
| var lowercaseHex = options.lowercaseHex; | ||
| var oldIndent = ''; | ||
| var inline1 = options.__inline1__; | ||
| var inline2 = options.__inline2__; | ||
| var newLine = compact ? '' : '\n'; | ||
| var result; | ||
| var isEmpty = true; | ||
| var useBinNumbers = options.numbers == 'binary'; | ||
| var useOctNumbers = options.numbers == 'octal'; | ||
| var useDecNumbers = options.numbers == 'decimal'; | ||
| var useHexNumbers = options.numbers == 'hexadecimal'; | ||
| if (json && argument && isFunction(argument.toJSON)) { | ||
| argument = argument.toJSON(); | ||
| } | ||
| if (!isString(argument)) { | ||
| if (isMap(argument)) { | ||
| if (argument.size == 0) { | ||
| return 'new Map()'; | ||
| } | ||
| if (!compact) { | ||
| options.__inline1__ = true; | ||
| } | ||
| return 'new Map(' + jsesc(Array.from(argument), options) + ')'; | ||
| if (isArray(argument)) { | ||
| result = []; | ||
| options.wrap = true; | ||
| if (inline1) { | ||
| options.__inline1__ = false; | ||
| options.__inline2__ = true; | ||
| } | ||
| if (isSet(argument)) { | ||
| if (argument.size == 0) { | ||
| return 'new Set()'; | ||
| } | ||
| return 'new Set(' + jsesc(Array.from(argument), options) + ')'; | ||
| if (!inline2) { | ||
| increaseIndentation(); | ||
| } | ||
| if (isArray(argument)) { | ||
| result = []; | ||
| options.wrap = true; | ||
| if (inline1) { | ||
| options.__inline1__ = false; | ||
| options.__inline2__ = true; | ||
| } else { | ||
| oldIndent = options.__indent__; | ||
| indent += oldIndent; | ||
| options.__indent__ = indent; | ||
| } | ||
| forEach(argument, function(value) { | ||
| isEmpty = false; | ||
| if (inline2) { | ||
| options.__inline2__ = false; | ||
| } | ||
| result.push( | ||
| (compact || inline2 ? '' : indent) + | ||
| jsesc(value, options) | ||
| ); | ||
| }); | ||
| if (isEmpty) { | ||
| return '[]'; | ||
| } | ||
| forEach(argument, function(value) { | ||
| isEmpty = false; | ||
| if (inline2) { | ||
| return '[' + result.join(', ') + ']'; | ||
| options.__inline2__ = false; | ||
| } | ||
| return '[' + newLine + result.join(',' + newLine) + newLine + | ||
| (compact ? '' : oldIndent) + ']'; | ||
| } else if (isNumber(argument)) { | ||
| if (json) { | ||
| // Some number values (e.g. `Infinity`) cannot be represented in JSON. | ||
| return JSON.stringify(argument); | ||
| } | ||
| if (useDecNumbers) { | ||
| return String(argument); | ||
| } | ||
| if (useHexNumbers) { | ||
| var tmp = argument.toString(16); | ||
| if (!lowercaseHex) { | ||
| tmp = tmp.toUpperCase(); | ||
| } | ||
| return '0x' + tmp; | ||
| } | ||
| if (useBinNumbers) { | ||
| return '0b' + argument.toString(2); | ||
| } | ||
| if (useOctNumbers) { | ||
| return '0o' + argument.toString(8); | ||
| } | ||
| } else if (!isObject(argument)) { | ||
| if (json) { | ||
| // For some values (e.g. `undefined`, `function` objects), | ||
| // `JSON.stringify(value)` returns `undefined` (which isn’t valid | ||
| // JSON) instead of `'null'`. | ||
| return JSON.stringify(argument) || 'null'; | ||
| } | ||
| result.push( | ||
| (compact || inline2 ? '' : indent) + | ||
| jsesc(value, options) | ||
| ); | ||
| }); | ||
| if (isEmpty) { | ||
| return '[]'; | ||
| } | ||
| if (inline2) { | ||
| return '[' + result.join(', ') + ']'; | ||
| } | ||
| return '[' + newLine + result.join(',' + newLine) + newLine + | ||
| (compact ? '' : oldIndent) + ']'; | ||
| } else if (isNumber(argument)) { | ||
| if (json) { | ||
| // Some number values (e.g. `Infinity`) cannot be represented in JSON. | ||
| return JSON.stringify(argument); | ||
| } | ||
| if (useDecNumbers) { | ||
| return String(argument); | ||
| } else { // it’s an object | ||
| result = []; | ||
| options.wrap = true; | ||
| oldIndent = options.__indent__; | ||
| indent += oldIndent; | ||
| options.__indent__ = indent; | ||
| forOwn(argument, function(key, value) { | ||
| isEmpty = false; | ||
| result.push( | ||
| (compact ? '' : indent) + | ||
| jsesc(key, options) + ':' + | ||
| (compact ? '' : ' ') + | ||
| jsesc(value, options) | ||
| ); | ||
| }); | ||
| if (isEmpty) { | ||
| return '{}'; | ||
| } | ||
| if (useHexNumbers) { | ||
| let hexadecimal = argument.toString(16); | ||
| if (!lowercaseHex) { | ||
| hexadecimal = hexadecimal.toUpperCase(); | ||
| } | ||
| return '{' + newLine + result.join(',' + newLine) + newLine + | ||
| (compact ? '' : oldIndent) + '}'; | ||
| return '0x' + hexadecimal; | ||
| } | ||
| if (useBinNumbers) { | ||
| return '0b' + argument.toString(2); | ||
| } | ||
| if (useOctNumbers) { | ||
| return '0o' + argument.toString(8); | ||
| } | ||
| } else if (!isObject(argument)) { | ||
| if (json) { | ||
| // For some values (e.g. `undefined`, `function` objects), | ||
| // `JSON.stringify(value)` returns `undefined` (which isn’t valid | ||
| // JSON) instead of `'null'`. | ||
| return JSON.stringify(argument) || 'null'; | ||
| } | ||
| return String(argument); | ||
| } else { // it’s an object | ||
| result = []; | ||
| options.wrap = true; | ||
| increaseIndentation(); | ||
| forOwn(argument, function(key, value) { | ||
| isEmpty = false; | ||
| result.push( | ||
| (compact ? '' : indent) + | ||
| jsesc(key, options) + ':' + | ||
| (compact ? '' : ' ') + | ||
| jsesc(value, options) | ||
| ); | ||
| }); | ||
| if (isEmpty) { | ||
| return '{}'; | ||
| } | ||
| return '{' + newLine + result.join(',' + newLine) + newLine + | ||
| (compact ? '' : oldIndent) + '}'; | ||
| } | ||
| } | ||
| var string = argument; | ||
| // Loop over each code unit in the string and escape it | ||
| var index = -1; | ||
| var length = string.length; | ||
| var first; | ||
| var second; | ||
| var codePoint; | ||
| result = ''; | ||
| while (++index < length) { | ||
| var character = string.charAt(index); | ||
| if (options.es6) { | ||
| first = string.charCodeAt(index); | ||
| if ( // check if it’s the start of a surrogate pair | ||
| first >= 0xD800 && first <= 0xDBFF && // high surrogate | ||
| length > index + 1 // there is a next code unit | ||
| ) { | ||
| second = string.charCodeAt(index + 1); | ||
| if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate | ||
| // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae | ||
| codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; | ||
| var hexadecimal = codePoint.toString(16); | ||
| if (!lowercaseHex) { | ||
| hexadecimal = hexadecimal.toUpperCase(); | ||
| } | ||
| result += '\\u{' + hexadecimal + '}'; | ||
| index++; | ||
| continue; | ||
| const string = argument; | ||
| // Loop over each code unit in the string and escape it | ||
| let index = -1; | ||
| const length = string.length; | ||
| result = ''; | ||
| while (++index < length) { | ||
| const character = string.charAt(index); | ||
| if (options.es6) { | ||
| const first = string.charCodeAt(index); | ||
| if ( // check if it’s the start of a surrogate pair | ||
| first >= 0xD800 && first <= 0xDBFF && // high surrogate | ||
| length > index + 1 // there is a next code unit | ||
| ) { | ||
| const second = string.charCodeAt(index + 1); | ||
| if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate | ||
| // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae | ||
| const codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; | ||
| let hexadecimal = codePoint.toString(16); | ||
| if (!lowercaseHex) { | ||
| hexadecimal = hexadecimal.toUpperCase(); | ||
| } | ||
| } | ||
| } | ||
| if (!options.escapeEverything) { | ||
| if (regexWhitelist.test(character)) { | ||
| // It’s a printable ASCII character that is not `"`, `'` or `\`, | ||
| // so don’t escape it. | ||
| result += character; | ||
| result += '\\u{' + hexadecimal + '}'; | ||
| ++index; | ||
| continue; | ||
| } | ||
| if (character == '"') { | ||
| result += quote == character ? '\\"' : character; | ||
| continue; | ||
| } | ||
| if (character == '\'') { | ||
| result += quote == character ? '\\\'' : character; | ||
| continue; | ||
| } | ||
| } | ||
| if ( | ||
| character == '\0' && | ||
| !json && | ||
| !regexDigit.test(string.charAt(index + 1)) | ||
| ) { | ||
| result += '\\0'; | ||
| } | ||
| if (!options.escapeEverything) { | ||
| if (regexWhitelist.test(character)) { | ||
| // It’s a printable ASCII character that is not `"`, `'` or `\`, | ||
| // so don’t escape it. | ||
| result += character; | ||
| continue; | ||
| } | ||
| if (regexSingleEscape.test(character)) { | ||
| // no need for a `hasOwnProperty` check here | ||
| result += singleEscapes[character]; | ||
| if (character == '"') { | ||
| result += quote == character ? '\\"' : character; | ||
| continue; | ||
| } | ||
| var charCode = character.charCodeAt(0); | ||
| var hexadecimal = charCode.toString(16); | ||
| if (!lowercaseHex) { | ||
| hexadecimal = hexadecimal.toUpperCase(); | ||
| if (character == '\'') { | ||
| result += quote == character ? '\\\'' : character; | ||
| continue; | ||
| } | ||
| var longhand = hexadecimal.length > 2 || json; | ||
| var escaped = '\\' + (longhand ? 'u' : 'x') + | ||
| ('0000' + hexadecimal).slice(longhand ? -4 : -2); | ||
| result += escaped; | ||
| } | ||
| if ( | ||
| character == '\0' && | ||
| !json && | ||
| !regexDigit.test(string.charAt(index + 1)) | ||
| ) { | ||
| result += '\\0'; | ||
| continue; | ||
| } | ||
| if (options.wrap) { | ||
| result = quote + result + quote; | ||
| if (regexSingleEscape.test(character)) { | ||
| // no need for a `hasOwnProperty` check here | ||
| result += singleEscapes[character]; | ||
| continue; | ||
| } | ||
| if (options.escapeEtago) { | ||
| // https://mathiasbynens.be/notes/etago | ||
| return result.replace(/<\/(script|style)/gi, '<\\/$1'); | ||
| const charCode = character.charCodeAt(0); | ||
| let hexadecimal = charCode.toString(16); | ||
| if (!lowercaseHex) { | ||
| hexadecimal = hexadecimal.toUpperCase(); | ||
| } | ||
| return result; | ||
| }; | ||
| const longhand = hexadecimal.length > 2 || json; | ||
| const escaped = '\\' + (longhand ? 'u' : 'x') + | ||
| ('0000' + hexadecimal).slice(longhand ? -4 : -2); | ||
| result += escaped; | ||
| continue; | ||
| } | ||
| if (options.wrap) { | ||
| result = quote + result + quote; | ||
| } | ||
| if (options.escapeEtago) { | ||
| // https://mathiasbynens.be/notes/etago | ||
| return result.replace(/<\/(script|style)/gi, '<\\/$1'); | ||
| } | ||
| return result; | ||
| }; | ||
| jsesc.version = '1.3.0'; | ||
| jsesc.version = '2.0.0'; | ||
| /*--------------------------------------------------------------------------*/ | ||
| // Some AMD build optimizers, like r.js, check for specific condition patterns | ||
| // like the following: | ||
| if ( | ||
| typeof define == 'function' && | ||
| typeof define.amd == 'object' && | ||
| define.amd | ||
| ) { | ||
| define(function() { | ||
| return jsesc; | ||
| }); | ||
| } else if (freeExports && !freeExports.nodeType) { | ||
| if (freeModule) { // in Node.js or RingoJS v0.8.0+ | ||
| freeModule.exports = jsesc; | ||
| } else { // in Narwhal or RingoJS v0.7.0- | ||
| freeExports.jsesc = jsesc; | ||
| } | ||
| } else { // in Rhino or a web browser | ||
| root.jsesc = jsesc; | ||
| } | ||
| }(this)); | ||
| module.exports = jsesc; |
| { | ||
| "name": "jsesc", | ||
| "version": "1.3.0", | ||
| "description": "A JavaScript library for escaping JavaScript strings while generating the shortest possible valid output.", | ||
| "homepage": "https://mths.be/jsesc", | ||
| "main": "jsesc.js", | ||
| "bin": "bin/jsesc", | ||
| "man": "man/jsesc.1", | ||
| "keywords": [ | ||
| "string", | ||
| "escape", | ||
| "javascript", | ||
| "tool" | ||
| ], | ||
| "license": "MIT", | ||
| "author": { | ||
| "name": "Mathias Bynens", | ||
| "url": "https://mathiasbynens.be/" | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "https://github.com/mathiasbynens/jsesc.git" | ||
| }, | ||
| "bugs": "https://github.com/mathiasbynens/jsesc/issues", | ||
| "files": [ | ||
| "LICENSE-MIT.txt", | ||
| "jsesc.js", | ||
| "bin/", | ||
| "man/" | ||
| ], | ||
| "scripts": { | ||
| "test": "node tests/tests.js", | ||
| "build": "grunt template" | ||
| }, | ||
| "devDependencies": { | ||
| "coveralls": "^2.11.6", | ||
| "grunt": "^0.4.5", | ||
| "grunt-shell": "^1.1.2", | ||
| "grunt-template": "^0.2.3", | ||
| "istanbul": "^0.4.2", | ||
| "qunit-extras": "^1.4.5", | ||
| "qunitjs": "~1.11.0", | ||
| "regenerate": "^1.2.1", | ||
| "requirejs": "^2.1.22" | ||
| } | ||
| "name": "jsesc", | ||
| "version": "2.0.0", | ||
| "description": "A JavaScript library for escaping JavaScript strings while generating the shortest possible valid output.", | ||
| "homepage": "https://mths.be/jsesc", | ||
| "engines": { | ||
| "node": ">=4" | ||
| }, | ||
| "main": "jsesc.js", | ||
| "bin": "bin/jsesc", | ||
| "man": "man/jsesc.1", | ||
| "keywords": [ | ||
| "string", | ||
| "escape", | ||
| "javascript", | ||
| "tool" | ||
| ], | ||
| "license": "MIT", | ||
| "author": { | ||
| "name": "Mathias Bynens", | ||
| "url": "https://mathiasbynens.be/" | ||
| }, | ||
| "repository": { | ||
| "type": "git", | ||
| "url": "https://github.com/mathiasbynens/jsesc.git" | ||
| }, | ||
| "bugs": "https://github.com/mathiasbynens/jsesc/issues", | ||
| "files": [ | ||
| "LICENSE-MIT.txt", | ||
| "jsesc.js", | ||
| "bin/", | ||
| "man/" | ||
| ], | ||
| "scripts": { | ||
| "build": "grunt template", | ||
| "coveralls": "istanbul cover --verbose --dir 'coverage' 'tests/tests.js' && coveralls < coverage/lcov.info'", | ||
| "cover": "istanbul cover --report 'html' --verbose --dir 'coverage' 'tests/tests.js'", | ||
| "test": "mocha tests" | ||
| }, | ||
| "devDependencies": { | ||
| "coveralls": "^2.11.6", | ||
| "grunt": "^0.4.5", | ||
| "grunt-template": "^0.2.3", | ||
| "istanbul": "^0.4.2", | ||
| "mocha": "*", | ||
| "regenerate": "^1.3.0", | ||
| "requirejs": "^2.1.22" | ||
| } | ||
| } |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Dev dependency count
- decreased by-22.22%
7
Worsened metrics
- Total package byte prevSize
- decreased by-7.6%
16849
- Lines of code
- decreased by-12.27%
286
No dependency changes