$

node_modules/loupe/CHANGELOG.md

@@ -0,0 +1,5 @@
+
+0.0.1 / 2013-12-17
+==================
+
+  * Initial port from chai.js

node_modules/loupe/LICENSE

@@ -0,0 +1,9 @@
+(The MIT License)
+
+Copyright (c) 2011-2013 Jake Luer jake@alogicalparadox.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/loupe/README.md

@@ -0,0 +1,63 @@
+![npm](https://img.shields.io/npm/v/loupe?logo=npm)
+![Build](https://github.com/chaijs/loupe/workflows/Build/badge.svg?branch=master)
+![Codecov branch](https://img.shields.io/codecov/c/github/chaijs/loupe/master?logo=codecov)
+
+# What is loupe?
+
+Loupe turns the object you give it into a string. It's similar to Node.js' `util.inspect()` function, but it works cross platform, in most modern browsers as well as Node.
+
+## Installation
+
+### Node.js
+
+`loupe` is available on [npm](http://npmjs.org). To install it, type:
+
+    $ npm install loupe
+
+### Browsers
+
+You can also use it within the browser; install via npm and use the `loupe.js` file found within the download. For example:
+
+```html
+<script src="./node_modules/loupe/loupe.js"></script>
+```
+
+## Usage
+
+``` js
+const { inspect } = require('loupe');
+```
+
+```js
+inspect({ foo: 'bar' }); // => "{ foo: 'bar' }"
+inspect(1); // => '1'
+inspect('foo'); // => "'foo'"
+inspect([ 1, 2, 3 ]); // => '[ 1, 2, 3 ]'
+inspect(/Test/g); // => '/Test/g'
+
+// ...
+```
+
+## Tests
+
+```bash
+$ npm test
+```
+
+Coverage:
+
+```bash
+$ npm run upload-coverage
+```
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2011-2013 Jake Luer jake@alogicalparadox.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/loupe/index.js

@@ -0,0 +1,195 @@
+/* !
+ * loupe
+ * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+import inspectArray from './lib/array'
+import inspectTypedArray from './lib/typedarray'
+import inspectDate from './lib/date'
+import inspectFunction from './lib/function'
+import inspectMap from './lib/map'
+import inspectNumber from './lib/number'
+import inspectBigInt from './lib/bigint'
+import inspectRegExp from './lib/regexp'
+import inspectSet from './lib/set'
+import inspectString from './lib/string'
+import inspectSymbol from './lib/symbol'
+import inspectPromise from './lib/promise'
+import inspectClass from './lib/class'
+import inspectObject from './lib/object'
+import inspectArguments from './lib/arguments'
+import inspectError from './lib/error'
+import inspectHTMLElement, { inspectHTMLCollection } from './lib/html'
+
+import { normaliseOptions } from './lib/helpers'
+
+const symbolsSupported = typeof Symbol === 'function' && typeof Symbol.for === 'function'
+const chaiInspect = symbolsSupported ? Symbol.for('chai/inspect') : '@@chai/inspect'
+let nodeInspect = false
+try {
+  // eslint-disable-next-line global-require
+  const nodeUtil = require('util')
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false
+} catch (noNodeInspect) {
+  nodeInspect = false
+}
+
+const constructorMap = new WeakMap()
+const stringTagMap = {}
+const baseTypesMap = {
+  undefined: (value, options) => options.stylize('undefined', 'undefined'),
+  null: (value, options) => options.stylize(null, 'null'),
+
+  boolean: (value, options) => options.stylize(value, 'boolean'),
+  Boolean: (value, options) => options.stylize(value, 'boolean'),
+
+  number: inspectNumber,
+  Number: inspectNumber,
+
+  bigint: inspectBigInt,
+  BigInt: inspectBigInt,
+
+  string: inspectString,
+  String: inspectString,
+
+  function: inspectFunction,
+  Function: inspectFunction,
+
+  symbol: inspectSymbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: inspectSymbol,
+
+  Array: inspectArray,
+  Date: inspectDate,
+  Map: inspectMap,
+  Set: inspectSet,
+  RegExp: inspectRegExp,
+  Promise: inspectPromise,
+
+  // WeakSet, WeakMap are totally opaque to us
+  WeakSet: (value, options) => options.stylize('WeakSet{…}', 'special'),
+  WeakMap: (value, options) => options.stylize('WeakMap{…}', 'special'),
+
+  Arguments: inspectArguments,
+  Int8Array: inspectTypedArray,
+  Uint8Array: inspectTypedArray,
+  Uint8ClampedArray: inspectTypedArray,
+  Int16Array: inspectTypedArray,
+  Uint16Array: inspectTypedArray,
+  Int32Array: inspectTypedArray,
+  Uint32Array: inspectTypedArray,
+  Float32Array: inspectTypedArray,
+  Float64Array: inspectTypedArray,
+
+  Generator: () => '',
+  DataView: () => '',
+  ArrayBuffer: () => '',
+
+  Error: inspectError,
+
+  HTMLCollection: inspectHTMLCollection,
+  NodeList: inspectHTMLCollection,
+}
+
+// eslint-disable-next-line complexity
+const inspectCustom = (value, options, type) => {
+  if (chaiInspect in value && typeof value[chaiInspect] === 'function') {
+    return value[chaiInspect](options)
+  }
+
+  if (nodeInspect && nodeInspect in value && typeof value[nodeInspect] === 'function') {
+    return value[nodeInspect](options.depth, options)
+  }
+
+  if ('inspect' in value && typeof value.inspect === 'function') {
+    return value.inspect(options.depth, options)
+  }
+
+  if ('constructor' in value && constructorMap.has(value.constructor)) {
+    return constructorMap.get(value.constructor)(value, options)
+  }
+
+  if (stringTagMap[type]) {
+    return stringTagMap[type](value, options)
+  }
+
+  return ''
+}
+
+const toString = Object.prototype.toString
+
+// eslint-disable-next-line complexity
+export function inspect(value, options) {
+  options = normaliseOptions(options)
+  options.inspect = inspect
+  const { customInspect } = options
+  let type = value === null ? 'null' : typeof value
+  if (type === 'object') {
+    type = toString.call(value).slice(8, -1)
+  }
+
+  // If it is a base value that we already support, then use Loupe's inspector
+  if (baseTypesMap[type]) {
+    return baseTypesMap[type](value, options)
+  }
+
+  // If `options.customInspect` is set to true then try to use the custom inspector
+  if (customInspect && value) {
+    const output = inspectCustom(value, options, type)
+    if (output) {
+      if (typeof output === 'string') return output
+      return inspect(output, options)
+    }
+  }
+
+  const proto = value ? Object.getPrototypeOf(value) : false
+  // If it's a plain Object then use Loupe's inspector
+  if (proto === Object.prototype || proto === null) {
+    return inspectObject(value, options)
+  }
+
+  // Specifically account for HTMLElements
+  // eslint-disable-next-line no-undef
+  if (value && typeof HTMLElement === 'function' && value instanceof HTMLElement) {
+    return inspectHTMLElement(value, options)
+  }
+
+  if ('constructor' in value) {
+    // If it is a class, inspect it like an object but add the constructor name
+    if (value.constructor !== Object) {
+      return inspectClass(value, options)
+    }
+
+    // If it is an object with an anonymous prototype, display it as an object.
+    return inspectObject(value, options)
+  }
+
+  // last chance to check if it's an object
+  if (value === Object(value)) {
+    return inspectObject(value, options)
+  }
+
+  // We have run out of options! Just stringify the value
+  return options.stylize(String(value), type)
+}
+
+export function registerConstructor(constructor, inspector) {
+  if (constructorMap.has(constructor)) {
+    return false
+  }
+  constructorMap.add(constructor, inspector)
+  return true
+}
+
+export function registerStringTag(stringTag, inspector) {
+  if (stringTag in stringTagMap) {
+    return false
+  }
+  stringTagMap[stringTag] = inspector
+  return true
+}
+
+export const custom = chaiInspect
+
+export default inspect

node_modules/loupe/lib/arguments.js

@@ -0,0 +1,7 @@
+import { inspectList } from './helpers'
+
+export default function inspectArguments(args, options) {
+  if (args.length === 0) return 'Arguments[]'
+  options.truncate -= 13
+  return `Arguments[ ${inspectList(args, options)} ]`
+}

node_modules/loupe/lib/array.js

@@ -0,0 +1,20 @@
+import { inspectProperty, inspectList } from './helpers'
+
+export default function inspectArray(array, options) {
+  // Object.keys will always output the Array indices first, so we can slice by
+  // `array.length` to get non-index properties
+  const nonIndexProperties = Object.keys(array).slice(array.length)
+  if (!array.length && !nonIndexProperties.length) return '[]'
+  options.truncate -= 4
+  const listContents = inspectList(array, options)
+  options.truncate -= listContents.length
+  let propertyContents = ''
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(
+      nonIndexProperties.map(key => [key, array[key]]),
+      options,
+      inspectProperty
+    )
+  }
+  return `[ ${listContents}${propertyContents ? `, ${propertyContents}` : ''} ]`
+}

node_modules/loupe/lib/bigint.js

@@ -0,0 +1,7 @@
+import { truncate, truncator } from './helpers'
+
+export default function inspectBigInt(number, options) {
+  let nums = truncate(number.toString(), options.truncate - 1)
+  if (nums !== truncator) nums += 'n'
+  return options.stylize(nums, 'bigint')
+}

node_modules/loupe/lib/class.js

@@ -0,0 +1,18 @@
+import getFuncName from 'get-func-name'
+import inspectObject from './object'
+
+const toStringTag = typeof Symbol !== 'undefined' && Symbol.toStringTag ? Symbol.toStringTag : false
+
+export default function inspectClass(value, options) {
+  let name = ''
+  if (toStringTag && toStringTag in value) {
+    name = value[toStringTag]
+  }
+  name = name || getFuncName(value.constructor)
+  // Babel transforms anonymous classes to the name `_class`
+  if (!name || name === '_class') {
+    name = '<Anonymous Class>'
+  }
+  options.truncate -= name.length
+  return `${name}${inspectObject(value, options)}`
+}

node_modules/loupe/lib/date.js

@@ -0,0 +1,8 @@
+import { truncate } from './helpers'
+
+export default function inspectDate(dateObject, options) {
+  // If we need to - truncate the time portion, but never the date
+  const split = dateObject.toJSON().split('T')
+  const date = split[0]
+  return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, 'date')
+}

node_modules/loupe/lib/error.js

@@ -0,0 +1,34 @@
+import { truncate, inspectList, inspectProperty } from './helpers'
+
+const errorKeys = [
+  'stack',
+  'line',
+  'column',
+  'name',
+  'message',
+  'fileName',
+  'lineNumber',
+  'columnNumber',
+  'number',
+  'description',
+]
+
+export default function inspectObject(error, options) {
+  const properties = Object.getOwnPropertyNames(error).filter(key => errorKeys.indexOf(key) === -1)
+  const name = error.name
+  options.truncate -= name.length
+  let message = ''
+  if (typeof error.message === 'string') {
+    message = truncate(error.message, options.truncate)
+  } else {
+    properties.unshift('message')
+  }
+  message = message ? `: ${message}` : ''
+  options.truncate -= message.length + 5
+  const propertyContents = inspectList(
+    properties.map(key => [key, error[key]]),
+    options,
+    inspectProperty
+  )
+  return `${name}${message}${propertyContents ? ` { ${propertyContents} }` : ''}`
+}

node_modules/loupe/lib/function.js

@@ -0,0 +1,10 @@
+import getFunctionName from 'get-func-name'
+import { truncate } from './helpers'
+
+export default function inspectFunction(func, options) {
+  const name = getFunctionName(func)
+  if (!name) {
+    return options.stylize('[Function]', 'special')
+  }
+  return options.stylize(`[Function ${truncate(name, options.truncate - 11)}]`, 'special')
+}

node_modules/loupe/lib/helpers.js

@@ -0,0 +1,177 @@
+const ansiColors = {
+  bold: ['1', '22'],
+  dim: ['2', '22'],
+  italic: ['3', '23'],
+  underline: ['4', '24'],
+  // 5 & 6 are blinking
+  inverse: ['7', '27'],
+  hidden: ['8', '28'],
+  strike: ['9', '29'],
+  // 10-20 are fonts
+  // 21-29 are resets for 1-9
+  black: ['30', '39'],
+  red: ['31', '39'],
+  green: ['32', '39'],
+  yellow: ['33', '39'],
+  blue: ['34', '39'],
+  magenta: ['35', '39'],
+  cyan: ['36', '39'],
+  white: ['37', '39'],
+
+  brightblack: ['30;1', '39'],
+  brightred: ['31;1', '39'],
+  brightgreen: ['32;1', '39'],
+  brightyellow: ['33;1', '39'],
+  brightblue: ['34;1', '39'],
+  brightmagenta: ['35;1', '39'],
+  brightcyan: ['36;1', '39'],
+  brightwhite: ['37;1', '39'],
+
+  grey: ['90', '39'],
+}
+
+const styles = {
+  special: 'cyan',
+  number: 'yellow',
+  bigint: 'yellow',
+  boolean: 'yellow',
+  undefined: 'grey',
+  null: 'bold',
+  string: 'green',
+  symbol: 'green',
+  date: 'magenta',
+  regexp: 'red',
+}
+
+export const truncator = '…'
+
+function colorise(value, styleType) {
+  const color = ansiColors[styles[styleType]] || ansiColors[styleType]
+  if (!color) {
+    return String(value)
+  }
+  return `\u001b[${color[0]}m${String(value)}\u001b[${color[1]}m`
+}
+
+export function normaliseOptions({
+  showHidden = false,
+  depth = 2,
+  colors = false,
+  customInspect = true,
+  showProxy = false,
+  maxArrayLength = Infinity,
+  breakLength = Infinity,
+  seen = [],
+  // eslint-disable-next-line no-shadow
+  truncate = Infinity,
+  stylize = String,
+} = {}) {
+  const options = {
+    showHidden: Boolean(showHidden),
+    depth: Number(depth),
+    colors: Boolean(colors),
+    customInspect: Boolean(customInspect),
+    showProxy: Boolean(showProxy),
+    maxArrayLength: Number(maxArrayLength),
+    breakLength: Number(breakLength),
+    truncate: Number(truncate),
+    seen,
+    stylize,
+  }
+  if (options.colors) {
+    options.stylize = colorise
+  }
+  return options
+}
+
+export function truncate(string, length, tail = truncator) {
+  string = String(string)
+  const tailLength = tail.length
+  const stringLength = string.length
+  if (tailLength > length && stringLength > tailLength) {
+    return tail
+  }
+  if (stringLength > length && stringLength > tailLength) {
+    return `${string.slice(0, length - tailLength)}${tail}`
+  }
+  return string
+}
+
+// eslint-disable-next-line complexity
+export function inspectList(list, options, inspectItem, separator = ', ') {
+  inspectItem = inspectItem || options.inspect
+  const size = list.length
+  if (size === 0) return ''
+  const originalLength = options.truncate
+  let output = ''
+  let peek = ''
+  let truncated = ''
+  for (let i = 0; i < size; i += 1) {
+    const last = i + 1 === list.length
+    const secondToLast = i + 2 === list.length
+    truncated = `${truncator}(${list.length - i})`
+    const value = list[i]
+
+    // If there is more than one remaining we need to account for a separator of `, `
+    options.truncate = originalLength - output.length - (last ? 0 : separator.length)
+    const string = peek || inspectItem(value, options) + (last ? '' : separator)
+    const nextLength = output.length + string.length
+    const truncatedLength = nextLength + truncated.length
+
+    // If this is the last element, and adding it would
+    // take us over length, but adding the truncator wouldn't - then break now
+    if (last && nextLength > originalLength && output.length + truncated.length <= originalLength) {
+      break
+    }
+
+    // If this isn't the last or second to last element to scan,
+    // but the string is already over length then break here
+    if (!last && !secondToLast && truncatedLength > originalLength) {
+      break
+    }
+
+    // Peek at the next string to determine if we should
+    // break early before adding this item to the output
+    peek = last ? '' : inspectItem(list[i + 1], options) + (secondToLast ? '' : separator)
+
+    // If we have one element left, but this element and
+    // the next takes over length, the break early
+    if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) {
+      break
+    }
+
+    output += string
+
+    // If the next element takes us to length -
+    // but there are more after that, then we should truncate now
+    if (!last && !secondToLast && nextLength + peek.length >= originalLength) {
+      truncated = `${truncator}(${list.length - i - 1})`
+      break
+    }
+
+    truncated = ''
+  }
+  return `${output}${truncated}`
+}
+
+function quoteComplexKey(key) {
+  if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) {
+    return key
+  }
+  return JSON.stringify(key)
+    .replace(/'/g, "\\'")
+    .replace(/\\"/g, '"')
+    .replace(/(^"|"$)/g, "'")
+}
+
+export function inspectProperty([key, value], options) {
+  options.truncate -= 2
+  if (typeof key === 'string') {
+    key = quoteComplexKey(key)
+  } else if (typeof key !== 'number') {
+    key = `[${options.inspect(key, options)}]`
+  }
+  options.truncate -= key.length
+  value = options.inspect(value, options)
+  return `${key}: ${value}`
+}

node_modules/loupe/lib/html.js

@@ -0,0 +1,40 @@
+import { truncator, inspectList } from './helpers'
+
+export function inspectAttribute([key, value], options) {
+  options.truncate -= 3
+  if (!value) {
+    return `${options.stylize(key, 'yellow')}`
+  }
+  return `${options.stylize(key, 'yellow')}=${options.stylize(`"${value}"`, 'string')}`
+}
+
+export function inspectHTMLCollection(collection, options) {
+  // eslint-disable-next-line no-use-before-define
+  return inspectList(collection, options, inspectHTML, '\n')
+}
+
+export default function inspectHTML(element, options) {
+  const properties = element.getAttributeNames()
+  const name = element.tagName.toLowerCase()
+  const head = options.stylize(`<${name}`, 'special')
+  const headClose = options.stylize(`>`, 'special')
+  const tail = options.stylize(`</${name}>`, 'special')
+  options.truncate -= name.length * 2 + 5
+  let propertyContents = ''
+  if (properties.length > 0) {
+    propertyContents += ' '
+    propertyContents += inspectList(
+      properties.map(key => [key, element.getAttribute(key)]),
+      options,
+      inspectAttribute,
+      ' '
+    )
+  }
+  options.truncate -= propertyContents.length
+  const truncate = options.truncate
+  let children = inspectHTMLCollection(element.children, options)
+  if (children && children.length > truncate) {
+    children = `${truncator}(${element.children.length})`
+  }
+  return `${head}${propertyContents}${headClose}${children}${tail}`
+}

node_modules/loupe/lib/map.js

@@ -0,0 +1,27 @@
+import { inspectList } from './helpers'
+
+function inspectMapEntry([key, value], options) {
+  options.truncate -= 4
+  key = options.inspect(key, options)
+  options.truncate -= key.length
+  value = options.inspect(value, options)
+  return `${key} => ${value}`
+}
+
+// IE11 doesn't support `map.entries()`
+function mapToEntries(map) {
+  const entries = []
+  map.forEach((value, key) => {
+    entries.push([key, value])
+  })
+  return entries
+}
+
+export default function inspectMap(map, options) {
+  const size = map.size - 1
+  if (size <= 0) {
+    return 'Map{}'
+  }
+  options.truncate -= 7
+  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`
+}

node_modules/loupe/lib/number.js

@@ -0,0 +1,18 @@
+import { truncate } from './helpers'
+
+const isNaN = Number.isNaN || (i => i !== i) // eslint-disable-line no-self-compare
+export default function inspectNumber(number, options) {
+  if (isNaN(number)) {
+    return options.stylize('NaN', 'number')
+  }
+  if (number === Infinity) {
+    return options.stylize('Infinity', 'number')
+  }
+  if (number === -Infinity) {
+    return options.stylize('-Infinity', 'number')
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Infinity ? '+0' : '-0', 'number')
+  }
+  return options.stylize(truncate(number, options.truncate), 'number')
+}

node_modules/loupe/lib/object.js

@@ -0,0 +1,31 @@
+import { inspectProperty, inspectList } from './helpers'
+
+export default function inspectObject(object, options) {
+  const properties = Object.getOwnPropertyNames(object)
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []
+  if (properties.length === 0 && symbols.length === 0) {
+    return '{}'
+  }
+  options.truncate -= 4
+  options.seen = options.seen || []
+  if (options.seen.indexOf(object) >= 0) {
+    return '[Circular]'
+  }
+  options.seen.push(object)
+  const propertyContents = inspectList(
+    properties.map(key => [key, object[key]]),
+    options,
+    inspectProperty
+  )
+  const symbolContents = inspectList(
+    symbols.map(key => [key, object[key]]),
+    options,
+    inspectProperty
+  )
+  options.seen.pop()
+  let sep = ''
+  if (propertyContents && symbolContents) {
+    sep = ', '
+  }
+  return `{ ${propertyContents}${sep}${symbolContents} }`
+}

node_modules/loupe/lib/promise.js

@@ -0,0 +1,16 @@
+let getPromiseValue = () => 'Promise{…}'
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding('util')
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value)
+      if (state === kPending) {
+        return 'Promise{<pending>}'
+      }
+      return `Promise${state === kRejected ? '!' : ''}{${options.inspect(innerValue, options)}}`
+    }
+  }
+} catch (notNode) {
+  /* ignore */
+}
+export default getPromiseValue

node_modules/loupe/lib/regexp.js

@@ -0,0 +1,8 @@
+import { truncate } from './helpers'
+
+export default function inspectRegExp(value, options) {
+  const flags = value.toString().split('/')[2]
+  const sourceLength = options.truncate - (2 + flags.length)
+  const source = value.source
+  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, 'regexp')
+}

node_modules/loupe/lib/set.js

@@ -0,0 +1,16 @@
+import { inspectList } from './helpers'
+
+// IE11 doesn't support `Array.from(set)`
+function arrayFromSet(set) {
+  const values = []
+  set.forEach(value => {
+    values.push(value)
+  })
+  return values
+}
+
+export default function inspectSet(set, options) {
+  if (set.size === 0) return 'Set{}'
+  options.truncate -= 7
+  return `Set{ ${inspectList(arrayFromSet(set), options)} }`
+}

node_modules/loupe/lib/string.js

@@ -0,0 +1,29 @@
+import { truncate } from './helpers'
+
+const stringEscapeChars = new RegExp(
+  "['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5" +
+    '\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]',
+  'g'
+)
+
+const escapeCharacters = {
+  '\b': '\\b',
+  '\t': '\\t',
+  '\n': '\\n',
+  '\f': '\\f',
+  '\r': '\\r',
+  "'": "\\'",
+  '\\': '\\\\',
+}
+const hex = 16
+const unicodeLength = 4
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`
+}
+
+export default function inspectString(string, options) {
+  if (stringEscapeChars.test(string)) {
+    string = string.replace(stringEscapeChars, escape)
+  }
+  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, 'string')
+}

node_modules/loupe/lib/symbol.js

@@ -0,0 +1,6 @@
+export default function inspectSymbol(value) {
+  if ('description' in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : 'Symbol()'
+  }
+  return value.toString()
+}

node_modules/loupe/lib/typedarray.js

@@ -0,0 +1,45 @@
+import getFuncName from 'get-func-name'
+import { truncator, truncate, inspectProperty, inspectList } from './helpers'
+
+const getArrayName = array => {
+  // We need to special case Node.js' Buffers, which report to be Uint8Array
+  if (typeof Buffer === 'function' && array instanceof Buffer) {
+    return 'Buffer'
+  }
+  if (array[Symbol.toStringTag]) {
+    return array[Symbol.toStringTag]
+  }
+  return getFuncName(array.constructor)
+}
+
+export default function inspectTypedArray(array, options) {
+  const name = getArrayName(array)
+  options.truncate -= name.length + 4
+  // Object.keys will always output the Array indices first, so we can slice by
+  // `array.length` to get non-index properties
+  const nonIndexProperties = Object.keys(array).slice(array.length)
+  if (!array.length && !nonIndexProperties.length) return `${name}[]`
+  // As we know TypedArrays only contain Unsigned Integers, we can skip inspecting each one and simply
+  // stylise the toString() value of them
+  let output = ''
+  for (let i = 0; i < array.length; i++) {
+    const string = `${options.stylize(truncate(array[i], options.truncate), 'number')}${
+      i === array.length - 1 ? '' : ', '
+    }`
+    options.truncate -= string.length
+    if (array[i] !== array.length && options.truncate <= 3) {
+      output += `${truncator}(${array.length - array[i] + 1})`
+      break
+    }
+    output += string
+  }
+  let propertyContents = ''
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(
+      nonIndexProperties.map(key => [key, array[key]]),
+      options,
+      inspectProperty
+    )
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ''} ]`
+}

node_modules/loupe/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "loupe",
+  "version": "2.3.4",
+  "description": "Inspect utility for Node.js and browsers",
+  "homepage": "https://github.com/chaijs/loupe",
+  "license": "MIT",
+  "author": "Veselin Todorov <hi@vesln.com>",
+  "contributors": [
+    "Keith Cirkel (https://github.com/keithamus)"
+  ],
+  "main": "./loupe.js",
+  "module": "./index.js",
+  "browser": {
+    "./index.js": "./loupe.js",
+    "util": false
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chaijs/loupe"
+  },
+  "files": [
+    "loupe.js",
+    "index.js",
+    "lib/*"
+  ],
+  "scripts": {
+    "bench": "node -r esm bench",
+    "commit-msg": "commitlint -x angular",
+    "lint": "eslint --ignore-path .gitignore .",
+    "prepare": "rollup -c rollup.conf.js",
+    "semantic-release": "semantic-release pre && npm publish && semantic-release post",
+    "test": "npm run test:node && npm run test:browser",
+    "pretest:browser": "npm run prepare",
+    "test:browser": "karma start --singleRun=true",
+    "posttest:browser": "npm run upload-coverage",
+    "test:node": "nyc mocha -r esm",
+    "posttest:node": "nyc report --report-dir \"coverage/node-$(node --version)\" --reporter=lcovonly && npm run upload-coverage",
+    "upload-coverage": "codecov"
+  },
+  "eslintConfig": {
+    "root": true,
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "env": {
+      "es6": true
+    },
+    "plugins": [
+      "filenames",
+      "prettier"
+    ],
+    "extends": [
+      "strict/es6"
+    ],
+    "rules": {
+      "comma-dangle": "off",
+      "func-style": "off",
+      "no-magic-numbers": "off",
+      "class-methods-use-this": "off",
+      "array-bracket-spacing": "off",
+      "array-element-newline": "off",
+      "space-before-function-paren": "off",
+      "arrow-parens": "off",
+      "template-curly-spacing": "off",
+      "quotes": "off",
+      "generator-star-spacing": "off",
+      "prefer-destructuring": "off",
+      "no-mixed-operators": "off",
+      "id-blacklist": "off",
+      "curly": "off",
+      "semi": [
+        "error",
+        "never"
+      ],
+      "prettier/prettier": [
+        "error",
+        {
+          "printWidth": 120,
+          "tabWidth": 2,
+          "useTabs": false,
+          "semi": false,
+          "singleQuote": true,
+          "trailingComma": "es5",
+          "arrowParens": "avoid",
+          "bracketSpacing": true
+        }
+      ]
+    }
+  },
+  "prettier": {
+    "printWidth": 120,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "es5",
+    "arrowParens": "avoid",
+    "bracketSpacing": true
+  },
+  "dependencies": {
+    "get-func-name": "^2.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "@commitlint/cli": "^11.0.0",
+    "@rollup/plugin-commonjs": "^17.0.0",
+    "@rollup/plugin-node-resolve": "^11.1.0",
+    "benchmark": "^2.1.4",
+    "chai": "^4.2.0",
+    "codecov": "^3.8.1",
+    "commitlint-config-angular": "^11.0.0",
+    "core-js": "^3.8.3",
+    "cross-env": "^7.0.3",
+    "eslint": "^7.18.0",
+    "eslint-config-strict": "^14.0.1",
+    "eslint-plugin-filenames": "^1.3.2",
+    "eslint-plugin-prettier": "^3.3.1",
+    "esm": "^3.2.25",
+    "husky": "^4.3.8",
+    "karma": "^5.2.3",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-coverage": "^2.0.3",
+    "karma-edge-launcher": "^0.4.2",
+    "karma-firefox-launcher": "^2.1.0",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-mocha": "^2.0.1",
+    "karma-opera-launcher": "^1.0.0",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-safaritechpreview-launcher": "^2.0.2",
+    "karma-sauce-launcher": "^4.3.4",
+    "mocha": "^8.2.1",
+    "nyc": "^15.1.0",
+    "prettier": "^2.2.1",
+    "rollup": "^2.37.1",
+    "rollup-plugin-babel": "^4.4.0",
+    "rollup-plugin-istanbul": "^3.0.0",
+    "semantic-release": "^17.3.6",
+    "simple-assert": "^1.0.0"
+  }
+}