loupe - npm Package Compare versions
Comparing version 3.0.1 to 3.0.2
@@ -1,10 +0,7 @@ | ||
| import { inspectList } from "./helpers.js"; | ||
| function inspectArguments(args, options) { | ||
| if (args.length === 0) | ||
| return "Arguments[]"; | ||
| options.truncate -= 13; | ||
| return `Arguments[ ${inspectList(args, options)} ]`; | ||
| import { inspectList } from './helpers.js'; | ||
| export default function inspectArguments(args, options) { | ||
| if (args.length === 0) | ||
| return 'Arguments[]'; | ||
| options.truncate -= 13; | ||
| return `Arguments[ ${inspectList(args, options)} ]`; | ||
| } | ||
| export { | ||
| inspectArguments as default | ||
| }; |
@@ -1,21 +0,16 @@ | ||
| import { inspectList, inspectProperty } from "./helpers.js"; | ||
| function inspectArray(array, options) { | ||
| 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}` : ""} ]`; | ||
| import { inspectList, inspectProperty } from './helpers.js'; | ||
| 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}` : ''} ]`; | ||
| } | ||
| export { | ||
| inspectArray as default | ||
| }; |
@@ -1,10 +0,7 @@ | ||
| import { truncate, truncator } from "./helpers.js"; | ||
| function inspectBigInt(number, options) { | ||
| let nums = truncate(number.toString(), options.truncate - 1); | ||
| if (nums !== truncator) | ||
| nums += "n"; | ||
| return options.stylize(nums, "bigint"); | ||
| import { truncate, truncator } from './helpers.js'; | ||
| export default function inspectBigInt(number, options) { | ||
| let nums = truncate(number.toString(), options.truncate - 1); | ||
| if (nums !== truncator) | ||
| nums += 'n'; | ||
| return options.stylize(nums, 'bigint'); | ||
| } | ||
| export { | ||
| inspectBigInt as default | ||
| }; |
@@ -1,17 +0,15 @@ | ||
| import inspectObject from "./object.js"; | ||
| const toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag ? Symbol.toStringTag : false; | ||
| function inspectClass(value, options) { | ||
| let name = ""; | ||
| if (toStringTag && toStringTag in value) { | ||
| name = value[toStringTag]; | ||
| } | ||
| name = name || value.constructor.name; | ||
| if (!name || name === "_class") { | ||
| name = "<Anonymous Class>"; | ||
| } | ||
| options.truncate -= name.length; | ||
| return `${name}${inspectObject(value, options)}`; | ||
| import inspectObject from './object.js'; | ||
| 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 || value.constructor.name; | ||
| // Babel transforms anonymous classes to the name `_class` | ||
| if (!name || name === '_class') { | ||
| name = '<Anonymous Class>'; | ||
| } | ||
| options.truncate -= name.length; | ||
| return `${name}${inspectObject(value, options)}`; | ||
| } | ||
| export { | ||
| inspectClass as default | ||
| }; |
@@ -1,13 +0,11 @@ | ||
| import { truncate } from "./helpers.js"; | ||
| function inspectDate(dateObject, options) { | ||
| const stringRepresentation = dateObject.toJSON(); | ||
| if (stringRepresentation === null) { | ||
| return "Invalid Date"; | ||
| } | ||
| const split = stringRepresentation.split("T"); | ||
| const date = split[0]; | ||
| return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, "date"); | ||
| import { truncate } from './helpers.js'; | ||
| export default function inspectDate(dateObject, options) { | ||
| const stringRepresentation = dateObject.toJSON(); | ||
| if (stringRepresentation === null) { | ||
| return 'Invalid Date'; | ||
| } | ||
| const split = stringRepresentation.split('T'); | ||
| const date = split[0]; | ||
| // If we need to - truncate the time portion, but never the date | ||
| return options.stylize(`${date}T${truncate(split[1], options.truncate - date.length - 1)}`, 'date'); | ||
| } | ||
| export { | ||
| inspectDate as default | ||
| }; |
@@ -1,35 +0,29 @@ | ||
| import { inspectList, inspectProperty, truncate } from "./helpers.js"; | ||
| import { inspectList, inspectProperty, truncate } from './helpers.js'; | ||
| const errorKeys = [ | ||
| "stack", | ||
| "line", | ||
| "column", | ||
| "name", | ||
| "message", | ||
| "fileName", | ||
| "lineNumber", | ||
| "columnNumber", | ||
| "number", | ||
| "description" | ||
| 'stack', | ||
| 'line', | ||
| 'column', | ||
| 'name', | ||
| 'message', | ||
| 'fileName', | ||
| 'lineNumber', | ||
| 'columnNumber', | ||
| 'number', | ||
| 'description', | ||
| ]; | ||
| 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} }` : ""}`; | ||
| 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} }` : ''}`; | ||
| } | ||
| export { | ||
| inspectObject as default | ||
| }; |
@@ -1,11 +0,8 @@ | ||
| import { truncate } from "./helpers.js"; | ||
| function inspectFunction(func, options) { | ||
| const name = func.name; | ||
| if (!name) { | ||
| return options.stylize("[Function]", "special"); | ||
| } | ||
| return options.stylize(`[Function ${truncate(name, options.truncate - 11)}]`, "special"); | ||
| import { truncate } from './helpers.js'; | ||
| export default function inspectFunction(func, options) { | ||
| const name = func.name; | ||
| if (!name) { | ||
| return options.stylize('[Function]', 'special'); | ||
| } | ||
| return options.stylize(`[Function ${truncate(name, options.truncate - 11)}]`, 'special'); | ||
| } | ||
| export { | ||
| inspectFunction as default | ||
| }; |
| 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"] | ||
| 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" | ||
| special: 'cyan', | ||
| number: 'yellow', | ||
| bigint: 'yellow', | ||
| boolean: 'yellow', | ||
| undefined: 'grey', | ||
| null: 'bold', | ||
| string: 'green', | ||
| symbol: 'green', | ||
| date: 'magenta', | ||
| regexp: 'red', | ||
| }; | ||
| const truncator = "\u2026"; | ||
| export const truncator = '…'; | ||
| function colorise(value, styleType) { | ||
| const color = ansiColors[styles[styleType]] || ansiColors[styleType] || ""; | ||
| if (!color) { | ||
| return String(value); | ||
| } | ||
| return `\x1B[${color[0]}m${String(value)}\x1B[${color[1]}m`; | ||
| const color = ansiColors[styles[styleType]] || ansiColors[styleType] || ''; | ||
| if (!color) { | ||
| return String(value); | ||
| } | ||
| return `\u001b[${color[0]}m${String(value)}\u001b[${color[1]}m`; | ||
| } | ||
| function normaliseOptions({ | ||
| showHidden = false, | ||
| depth = 2, | ||
| colors = false, | ||
| customInspect = true, | ||
| showProxy = false, | ||
| maxArrayLength = Infinity, | ||
| breakLength = Infinity, | ||
| seen = [], | ||
| // eslint-disable-next-line no-shadow | ||
| truncate: truncate2 = Infinity, | ||
| stylize = String | ||
| } = {}, inspect) { | ||
| 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(truncate2), | ||
| seen, | ||
| inspect, | ||
| stylize | ||
| }; | ||
| if (options.colors) { | ||
| options.stylize = colorise; | ||
| } | ||
| return options; | ||
| 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, } = {}, inspect) { | ||
| 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, | ||
| inspect, | ||
| stylize, | ||
| }; | ||
| if (options.colors) { | ||
| options.stylize = colorise; | ||
| } | ||
| return options; | ||
| } | ||
| 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; | ||
| } | ||
| 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]; | ||
| 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 (last && nextLength > originalLength && output.length + truncated.length <= originalLength) { | ||
| break; | ||
| 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 (!last && !secondToLast && truncatedLength > originalLength) { | ||
| break; | ||
| if (stringLength > length && stringLength > tailLength) { | ||
| return `${string.slice(0, length - tailLength)}${tail}`; | ||
| } | ||
| peek = last ? "" : inspectItem(list[i + 1], options) + (secondToLast ? "" : separator); | ||
| if (!last && secondToLast && truncatedLength > originalLength && nextLength + peek.length > originalLength) { | ||
| break; | ||
| 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 = ''; | ||
| } | ||
| output += string; | ||
| if (!last && !secondToLast && nextLength + peek.length >= originalLength) { | ||
| truncated = `${truncator}(${list.length - i - 1})`; | ||
| break; | ||
| } | ||
| truncated = ""; | ||
| } | ||
| return `${output}${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, "'"); | ||
| if (key.match(/^[a-zA-Z_][a-zA-Z_0-9]*$/)) { | ||
| return key; | ||
| } | ||
| return JSON.stringify(key) | ||
| .replace(/'/g, "\\'") | ||
| .replace(/\\"/g, '"') | ||
| .replace(/(^"|"$)/g, "'"); | ||
| } | ||
| 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}`; | ||
| 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}`; | ||
| } | ||
| export { | ||
| inspectList, | ||
| inspectProperty, | ||
| normaliseOptions, | ||
| truncate, | ||
| truncator | ||
| }; |
@@ -1,41 +0,34 @@ | ||
| import { inspectList, truncator } from "./helpers.js"; | ||
| function inspectAttribute([key, value], options) { | ||
| options.truncate -= 3; | ||
| if (!value) { | ||
| return `${options.stylize(String(key), "yellow")}`; | ||
| } | ||
| return `${options.stylize(String(key), "yellow")}=${options.stylize(`"${value}"`, "string")}`; | ||
| import { inspectList, truncator } from './helpers.js'; | ||
| export function inspectAttribute([key, value], options) { | ||
| options.truncate -= 3; | ||
| if (!value) { | ||
| return `${options.stylize(String(key), 'yellow')}`; | ||
| } | ||
| return `${options.stylize(String(key), 'yellow')}=${options.stylize(`"${value}"`, 'string')}`; | ||
| } | ||
| function inspectHTMLCollection(collection, options) { | ||
| return inspectList(collection, options, inspectHTML, "\n"); | ||
| // @ts-ignore (Deno doesn't have Element) | ||
| export function inspectHTMLCollection(collection, options) { | ||
| // eslint-disable-next-line no-use-before-define | ||
| return inspectList(collection, options, inspectHTML, '\n'); | ||
| } | ||
| 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}`; | ||
| // @ts-ignore (Deno doesn't have Element) | ||
| 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}`; | ||
| } | ||
| export { | ||
| inspectHTML as default, | ||
| inspectAttribute, | ||
| inspectHTMLCollection | ||
| }; |
282
lib/index.js
@@ -1,149 +0,161 @@ | ||
| import inspectArray from "./array.js"; | ||
| import inspectTypedArray from "./typedarray.js"; | ||
| import inspectDate from "./date.js"; | ||
| import inspectFunction from "./function.js"; | ||
| import inspectMap from "./map.js"; | ||
| import inspectNumber from "./number.js"; | ||
| import inspectBigInt from "./bigint.js"; | ||
| import inspectRegExp from "./regexp.js"; | ||
| import inspectSet from "./set.js"; | ||
| import inspectString from "./string.js"; | ||
| import inspectSymbol from "./symbol.js"; | ||
| import inspectPromise from "./promise.js"; | ||
| import inspectClass from "./class.js"; | ||
| import inspectObject from "./object.js"; | ||
| import inspectArguments from "./arguments.js"; | ||
| import inspectError from "./error.js"; | ||
| import inspectHTMLElement, { inspectHTMLCollection } from "./html.js"; | ||
| import { normaliseOptions } from "./helpers.js"; | ||
| const symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function"; | ||
| const chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect"; | ||
| /* ! | ||
| * loupe | ||
| * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com> | ||
| * MIT Licensed | ||
| */ | ||
| import inspectArray from './array.js'; | ||
| import inspectTypedArray from './typedarray.js'; | ||
| import inspectDate from './date.js'; | ||
| import inspectFunction from './function.js'; | ||
| import inspectMap from './map.js'; | ||
| import inspectNumber from './number.js'; | ||
| import inspectBigInt from './bigint.js'; | ||
| import inspectRegExp from './regexp.js'; | ||
| import inspectSet from './set.js'; | ||
| import inspectString from './string.js'; | ||
| import inspectSymbol from './symbol.js'; | ||
| import inspectPromise from './promise.js'; | ||
| import inspectClass from './class.js'; | ||
| import inspectObject from './object.js'; | ||
| import inspectArguments from './arguments.js'; | ||
| import inspectError from './error.js'; | ||
| import inspectHTMLElement, { inspectHTMLCollection } from './html.js'; | ||
| import { normaliseOptions } from './helpers.js'; | ||
| const symbolsSupported = typeof Symbol === 'function' && typeof Symbol.for === 'function'; | ||
| const chaiInspect = symbolsSupported ? Symbol.for('chai/inspect') : '@@chai/inspect'; | ||
| let nodeInspect = false; | ||
| try { | ||
| const nodeUtil = require("util"); | ||
| nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false; | ||
| } catch (noNodeInspect) { | ||
| nodeInspect = false; | ||
| // eslint-disable-next-line global-require | ||
| // @ts-ignore | ||
| const nodeUtil = require('util'); | ||
| nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false; | ||
| } | ||
| const constructorMap = /* @__PURE__ */ new WeakMap(); | ||
| 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(String(value), "boolean"), | ||
| Boolean: (value, options) => options.stylize(String(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{\u2026}", "special"), | ||
| WeakMap: (value, options) => options.stylize("WeakMap{\u2026}", "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 | ||
| undefined: (value, options) => options.stylize('undefined', 'undefined'), | ||
| null: (value, options) => options.stylize('null', 'null'), | ||
| boolean: (value, options) => options.stylize(String(value), 'boolean'), | ||
| Boolean: (value, options) => options.stylize(String(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 ""; | ||
| 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; | ||
| function inspect(value, opts = {}) { | ||
| const options = normaliseOptions(opts, inspect); | ||
| const { customInspect } = options; | ||
| let type = value === null ? "null" : typeof value; | ||
| if (type === "object") { | ||
| type = toString.call(value).slice(8, -1); | ||
| } | ||
| if (type in baseTypesMap) { | ||
| return baseTypesMap[type](value, options); | ||
| } | ||
| if (customInspect && value) { | ||
| const output = inspectCustom(value, options, type); | ||
| if (output) { | ||
| if (typeof output === "string") | ||
| return output; | ||
| return inspect(output, options); | ||
| // eslint-disable-next-line complexity | ||
| export function inspect(value, opts = {}) { | ||
| const options = normaliseOptions(opts, inspect); | ||
| const { customInspect } = options; | ||
| let type = value === null ? 'null' : typeof value; | ||
| if (type === 'object') { | ||
| type = toString.call(value).slice(8, -1); | ||
| } | ||
| } | ||
| const proto = value ? Object.getPrototypeOf(value) : false; | ||
| if (proto === Object.prototype || proto === null) { | ||
| return inspectObject(value, options); | ||
| } | ||
| if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) { | ||
| return inspectHTMLElement(value, options); | ||
| } | ||
| if ("constructor" in value) { | ||
| if (value.constructor !== Object) { | ||
| return inspectClass(value, options); | ||
| // If it is a base value that we already support, then use Loupe's inspector | ||
| if (type in baseTypesMap) { | ||
| return baseTypesMap[type](value, options); | ||
| } | ||
| return inspectObject(value, options); | ||
| } | ||
| if (value === Object(value)) { | ||
| return inspectObject(value, options); | ||
| } | ||
| return options.stylize(String(value), type); | ||
| // 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 | ||
| // @ts-ignore | ||
| 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); | ||
| } | ||
| function registerConstructor(constructor, inspector) { | ||
| if (constructorMap.has(constructor)) { | ||
| return false; | ||
| } | ||
| constructorMap.set(constructor, inspector); | ||
| return true; | ||
| export function registerConstructor(constructor, inspector) { | ||
| if (constructorMap.has(constructor)) { | ||
| return false; | ||
| } | ||
| constructorMap.set(constructor, inspector); | ||
| return true; | ||
| } | ||
| function registerStringTag(stringTag, inspector) { | ||
| if (stringTag in stringTagMap) { | ||
| return false; | ||
| } | ||
| stringTagMap[stringTag] = inspector; | ||
| return true; | ||
| export function registerStringTag(stringTag, inspector) { | ||
| if (stringTag in stringTagMap) { | ||
| return false; | ||
| } | ||
| stringTagMap[stringTag] = inspector; | ||
| return true; | ||
| } | ||
| const custom = chaiInspect; | ||
| var src_default = inspect; | ||
| export { | ||
| custom, | ||
| src_default as default, | ||
| inspect, | ||
| registerConstructor, | ||
| registerStringTag | ||
| }; | ||
| export const custom = chaiInspect; | ||
| export default inspect; |
@@ -1,26 +0,24 @@ | ||
| import { inspectList } from "./helpers.js"; | ||
| import { inspectList } from './helpers.js'; | ||
| 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}`; | ||
| 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; | ||
| const entries = []; | ||
| map.forEach((value, key) => { | ||
| entries.push([key, value]); | ||
| }); | ||
| return entries; | ||
| } | ||
| function inspectMap(map, options) { | ||
| const size = map.size - 1; | ||
| if (size <= 0) { | ||
| return "Map{}"; | ||
| } | ||
| options.truncate -= 7; | ||
| return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`; | ||
| 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)} }`; | ||
| } | ||
| export { | ||
| inspectMap as default | ||
| }; |
@@ -1,20 +0,17 @@ | ||
| import { truncate } from "./helpers.js"; | ||
| const isNaN = Number.isNaN || ((i) => i !== i); | ||
| 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(String(number), options.truncate), "number"); | ||
| import { truncate } from './helpers.js'; | ||
| 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(String(number), options.truncate), 'number'); | ||
| } | ||
| export { | ||
| inspectNumber as default | ||
| }; |
@@ -1,33 +0,22 @@ | ||
| import { inspectList, inspectProperty } from "./helpers.js"; | ||
| 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} }`; | ||
| import { inspectList, inspectProperty } from './helpers.js'; | ||
| 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} }`; | ||
| } | ||
| export { | ||
| inspectObject as default | ||
| }; |
@@ -1,18 +0,18 @@ | ||
| let getPromiseValue = () => "Promise{\u2026}"; | ||
| 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) { | ||
| // @ts-ignore | ||
| 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)}}`; | ||
| }; | ||
| } | ||
| } | ||
| var promise_default = getPromiseValue; | ||
| export { | ||
| promise_default as default | ||
| }; | ||
| catch (notNode) { | ||
| /* ignore */ | ||
| } | ||
| export default getPromiseValue; |
@@ -1,10 +0,7 @@ | ||
| import { truncate } from "./helpers.js"; | ||
| 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"); | ||
| import { truncate } from './helpers.js'; | ||
| 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'); | ||
| } | ||
| export { | ||
| inspectRegExp as default | ||
| }; |
@@ -1,17 +0,15 @@ | ||
| import { inspectList } from "./helpers.js"; | ||
| import { inspectList } from './helpers.js'; | ||
| // IE11 doesn't support `Array.from(set)` | ||
| function arrayFromSet(set) { | ||
| const values = []; | ||
| set.forEach((value) => { | ||
| values.push(value); | ||
| }); | ||
| return values; | ||
| const values = []; | ||
| set.forEach(value => { | ||
| values.push(value); | ||
| }); | ||
| return values; | ||
| } | ||
| function inspectSet(set, options) { | ||
| if (set.size === 0) | ||
| return "Set{}"; | ||
| options.truncate -= 7; | ||
| return `Set{ ${inspectList(arrayFromSet(set), options)} }`; | ||
| export default function inspectSet(set, options) { | ||
| if (set.size === 0) | ||
| return 'Set{}'; | ||
| options.truncate -= 7; | ||
| return `Set{ ${inspectList(arrayFromSet(set), options)} }`; | ||
| } | ||
| export { | ||
| inspectSet as default | ||
| }; |
@@ -1,14 +0,12 @@ | ||
| import { truncate } from "./helpers.js"; | ||
| const stringEscapeChars = new RegExp( | ||
| "['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", | ||
| "g" | ||
| ); | ||
| import { truncate } from './helpers.js'; | ||
| 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", | ||
| "\n": "\\n", | ||
| "\f": "\\f", | ||
| "\r": "\\r", | ||
| "'": "\\'", | ||
| "\\": "\\\\" | ||
| '\b': '\\b', | ||
| '\t': '\\t', | ||
| '\n': '\\n', | ||
| '\f': '\\f', | ||
| '\r': '\\r', | ||
| "'": "\\'", | ||
| '\\': '\\\\', | ||
| }; | ||
@@ -18,12 +16,10 @@ const hex = 16; | ||
| function escape(char) { | ||
| return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`; | ||
| return (escapeCharacters[char] || | ||
| `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`); | ||
| } | ||
| function inspectString(string, options) { | ||
| if (stringEscapeChars.test(string)) { | ||
| string = string.replace(stringEscapeChars, escape); | ||
| } | ||
| return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string"); | ||
| export default function inspectString(string, options) { | ||
| if (stringEscapeChars.test(string)) { | ||
| string = string.replace(stringEscapeChars, escape); | ||
| } | ||
| return options.stylize(`'${truncate(string, options.truncate - 2)}'`, 'string'); | ||
| } | ||
| export { | ||
| inspectString as default | ||
| }; |
@@ -1,9 +0,6 @@ | ||
| function inspectSymbol(value) { | ||
| if ("description" in Symbol.prototype) { | ||
| return value.description ? `Symbol(${value.description})` : "Symbol()"; | ||
| } | ||
| return value.toString(); | ||
| export default function inspectSymbol(value) { | ||
| if ('description' in Symbol.prototype) { | ||
| return value.description ? `Symbol(${value.description})` : 'Symbol()'; | ||
| } | ||
| return value.toString(); | ||
| } | ||
| export { | ||
| inspectSymbol as default | ||
| }; |
@@ -1,39 +0,38 @@ | ||
| import { inspectList, inspectProperty, truncate, truncator } from "./helpers.js"; | ||
| import { inspectList, inspectProperty, truncate, truncator } from './helpers.js'; | ||
| const getArrayName = (array) => { | ||
| if (typeof Buffer === "function" && array instanceof Buffer) { | ||
| return "Buffer"; | ||
| } | ||
| if (array[Symbol.toStringTag]) { | ||
| return array[Symbol.toStringTag]; | ||
| } | ||
| return array.constructor.name; | ||
| // We need to special case Node.js' Buffers, which report to be Uint8Array | ||
| // @ts-ignore | ||
| if (typeof Buffer === 'function' && array instanceof Buffer) { | ||
| return 'Buffer'; | ||
| } | ||
| if (array[Symbol.toStringTag]) { | ||
| return array[Symbol.toStringTag]; | ||
| } | ||
| return array.constructor.name; | ||
| }; | ||
| function inspectTypedArray(array, options) { | ||
| const name = getArrayName(array); | ||
| options.truncate -= name.length + 4; | ||
| const nonIndexProperties = Object.keys(array).slice(array.length); | ||
| if (!array.length && !nonIndexProperties.length) | ||
| return `${name}[]`; | ||
| 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; | ||
| 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; | ||
| } | ||
| output += string; | ||
| } | ||
| let propertyContents = ""; | ||
| if (nonIndexProperties.length) { | ||
| propertyContents = inspectList( | ||
| nonIndexProperties.map((key) => [key, array[key]]), | ||
| options, | ||
| inspectProperty | ||
| ); | ||
| } | ||
| return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`; | ||
| let propertyContents = ''; | ||
| if (nonIndexProperties.length) { | ||
| propertyContents = inspectList(nonIndexProperties.map(key => [key, array[key]]), options, inspectProperty); | ||
| } | ||
| return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ''} ]`; | ||
| } | ||
| export { | ||
| inspectTypedArray as default | ||
| }; |
| { | ||
| "name": "loupe", | ||
| "version": "3.0.1", | ||
| "version": "3.0.2", | ||
| "description": "Inspect utility for Node.js and browsers", | ||
@@ -36,3 +36,3 @@ "homepage": "https://github.com/chaijs/loupe", | ||
| "build": "npm run build:lib && npm run build:esm-bundle && npm run build:cjs-bundle", | ||
| "build:lib": "esbuild \"src/*.ts\" --outdir=lib --format=esm", | ||
| "build:lib": "tsc", | ||
| "build:esm-bundle": "esbuild --bundle src/index.ts --outfile=loupe.js --format=esm", | ||
@@ -39,0 +39,0 @@ "build:cjs-bundle": "esbuild --bundle src/index.ts --outfile=loupe.js --format=cjs", |
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
- Total package byte prevSize
- increased by29.48%
59770
- Number of package files
- increased by166.67%
64
- Lines of code
- increased by1.49%
1294
No dependency changes