micro-utilities.json

{
  "replacements": {
    "snippet::array-coerce": {
      "id": "snippet::array-coerce",
      "type": "simple",
      "description": "You can use a combination of a ternary operator and `Array.isArray` to make sure a value, `undefined`, `null` or an array is always returned as an array.",
      "example": "(val == null ? [] : Array.isArray(val) ? val : [val])\n// Or if you need to convert an iterable into an array\nArray.from(iterable)"
    },
    "snippet::array-difference": {
      "id": "snippet::array-difference",
      "type": "simple",
      "description": "You can use a combination of `filter` and `includes` to calculate the difference between two arrays.",
      "example": "const difference = (a, b) => a.filter((item) => !b.includes(item))"
    },
    "snippet::array-flatten": {
      "id": "snippet::array-flatten",
      "type": "simple",
      "description": "You can use `Array.prototype.flat` with `Infinity` as an argument to fully flatten an array.",
      "example": "array.flat(Infinity)"
    },
    "snippet::array-from-count": {
      "id": "snippet::array-from-count",
      "type": "simple",
      "description": "You can use `Array.from` to create an array of sequential integers",
      "example": "Array.from({ length: n }, (_, i) => i);"
    },
    "snippet::array-from-count-with-start": {
      "id": "snippet::array-from-count-with-start",
      "type": "simple",
      "description": "You can use `Array.from` to create an array of sequential integers starting from a specific integer",
      "example": "Array.from({ length: end - start }, (_, i) => i + start);"
    },
    "snippet::array-last": {
      "id": "snippet::array-last",
      "type": "simple",
      "description": "You can use `arr.at(-1)` if supported or `arr[arr.length - 1]` to get the last element of an array.",
      "example": "const last = (arr) => arr.at(-1);\n// or in older environments\nconst lastLegacy = (arr) => arr[arr.length - 1]"
    },
    "snippet::array-slice-exclude-last-n": {
      "id": "snippet::array-slice-exclude-last-n",
      "type": "simple",
      "description": "You can get all but the last n elements using `array.slice`",
      "example": "array.slice(0, array.length - n)"
    },
    "snippet::array-union": {
      "id": "snippet::array-union",
      "type": "simple",
      "description": "You can use a combination of the spread operator and `Set` to create a union of two arrays.",
      "example": "const union = (a, b) => [...new Set([...a, ...b])]"
    },
    "snippet::array-unique": {
      "id": "snippet::array-unique",
      "type": "simple",
      "description": "You can convert to and from a `Set` to remove duplicates from an array.",
      "example": "const unique = (arr) => [...new Set(arr)]"
    },
    "snippet::async-function-constructor": {
      "id": "snippet::async-function-constructor",
      "type": "simple",
      "description": "You can get the `AsyncFunction` using `async function`.",
      "example": "const AsyncFunction = (async () => {}).constructor"
    },
    "snippet::base64": {
      "id": "snippet::base64",
      "type": "simple",
      "description": "Every modern runtime provides a way to convert byte array to and from base64.",
      "example": "// From base64 to Uint8Array\nconst bytes = Uint8Array.fromBase64(base64)\n// From Uint8Array to base64\nconst base64 = bytes.toBase64()"
    },
    "snippet::base64-id": {
      "id": "snippet::base64-id",
      "type": "simple",
      "description": "You can use `crypto.randomBytes` with `Buffer.prototype.toString` to generate a random base64 id",
      "example": "import crypto from 'node:crypto'\nconst id = crypto.randomBytes(15).toString('base64').replaceAll('+', '-').replaceAll('/', '_')"
    },
    "snippet::call-bind": {
      "id": "snippet::call-bind",
      "type": "simple",
      "description": "Every modern runtime provides a way to bind to the `call` method of a function.",
      "example": "const fnBound = Function.call.bind(fn)"
    },
    "snippet::char-last": {
      "id": "snippet::char-last",
      "type": "simple",
      "description": "You can use `str.at(-1)` if supported or `str[str.length - 1]` to get the last character of a string.",
      "example": "const last = (str) => str.at(-1);\n// or in older environments\nconst lastLegacy = (str) => str[str.length - 1]"
    },
    "snippet::for-own": {
      "id": "snippet::for-own",
      "type": "simple",
      "description": "You can use `Object.keys(obj).forEach` to iterate over the own enumerable properties of an object.",
      "example": "Object.keys(obj).forEach(key => {\n  const value = obj[key];\n  // do something\n});"
    },
    "snippet::get-iterator": {
      "id": "snippet::get-iterator",
      "type": "simple",
      "description": "Every modern runtime provides a way to get the iterator function through the `Symbol.iterator` symbol.",
      "example": "const iterator = obj[Symbol.iterator]?.()"
    },
    "snippet::has-ansi": {
      "id": "snippet::has-ansi",
      "type": "simple",
      "description": "You can use the `includes` method on the string to check if a specific ANSI byte is present.",
      "example": "string.includes(\"\\u001b\") || string.includes(\"\\u009b\")"
    },
    "snippet::has-argv": {
      "id": "snippet::has-argv",
      "type": "simple",
      "description": "You can use the `includes` method on the `process.argv` array to check if a flag is present.",
      "example": "process.argv.includes('--flag')"
    },
    "snippet::is-arguments": {
      "id": "snippet::is-arguments",
      "type": "simple",
      "description": "You can use `Object.prototype.toString.call(obj) === \"[object Arguments]\"`",
      "example": "const isArguments = (val) => Object.prototype.toString.call(val) === \"[object Arguments]\";"
    },
    "snippet::is-arraybuffer": {
      "id": "snippet::is-arraybuffer",
      "type": "simple",
      "description": "You can use `instanceof ArrayBuffer`, or if cross-realm, use `Object.prototype.toString.call(obj) === \"[object ArrayBuffer]\"`",
      "example": "const isArrayBuffer = obj instanceof ArrayBuffer;\n// for cross-realm\nconst isArrayBufferCrossRealm = Object.prototype.toString.call(obj) === \"[object ArrayBuffer]\""
    },
    "snippet::is-async-function": {
      "id": "snippet::is-async-function",
      "type": "simple",
      "description": "You can use `typeof` and `Object.prototype.toString.call` to check if it's an async function",
      "example": "const isAsyncFunction = (obj) => typeof obj === \"function\" && Object.prototype.toString.call(obj) === \"[object AsyncFunction]\""
    },
    "snippet::is-bigint": {
      "id": "snippet::is-bigint",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is a bigint.",
      "example": "const isString = (value) => typeof value === \"bigint\";"
    },
    "snippet::is-boolean": {
      "id": "snippet::is-boolean",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is a boolean primitive, and `Object.prototype.toString.call` to check if it's a `Boolean` object.",
      "example": "Object.prototype.toString.call(v) === \"[object Boolean]\""
    },
    "snippet::is-ci": {
      "id": "snippet::is-ci",
      "type": "simple",
      "description": "Every major CI provider sets a `CI` environment variable that you can use to detect if you're running in a CI environment.",
      "example": "Boolean(process.env.CI)"
    },
    "snippet::is-date": {
      "id": "snippet::is-date",
      "type": "simple",
      "description": "You can use `instanceof Date`, or if cross-realm, use `Object.prototype.toString.call(v) === \"[object Date]\"`",
      "example": "const isDate = v instanceof Date;\n// for cross-realm\nconst isDateCrossRealm = Object.prototype.toString.call(v) === \"[object Date]\""
    },
    "snippet::is-deflate-buffer": {
      "id": "snippet::is-deflate-buffer",
      "type": "simple",
      "description": "You can check the first two bytes of a buffer to detect if it's compressed using deflate.",
      "example": "function isDeflate(buf) {\n  if (buf.length < 2 || buf[0] !== 0x78) return false;\n  const b = buf[1];\n  return b === 1 || b === 0x9c || b === 0xda;\n}"
    },
    "snippet::is-electron": {
      "id": "snippet::is-electron",
      "type": "simple",
      "description": "You can detect Electron by checking the renderer process type, `process.versions.electron`, or the user agent.",
      "example": "function isElectron() {\n  return Boolean(\n    globalThis.window?.process?.type === \"renderer\" ||\n      globalThis.process?.versions?.electron ||\n      globalThis.navigator?.userAgent?.includes(\"Electron\")\n  );\n}"
    },
    "snippet::is-equal": {
      "id": "snippet::is-equal",
      "type": "simple",
      "description": "You can determine if two values are equal using regular equality checks.",
      "example": "a === b"
    },
    "snippet::is-even": {
      "id": "snippet::is-even",
      "type": "simple",
      "description": "You can use the modulo operator to check if a number is even.",
      "example": "(n % 2) === 0"
    },
    "snippet::is-function": {
      "id": "snippet::is-function",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is a function.",
      "example": "typeof value === \"function\""
    },
    "snippet::is-generator-function": {
      "id": "snippet::is-generator-function",
      "type": "simple",
      "description": "You can use `typeof` and `Object.prototype.toString.call` to check if a value is a generator function",
      "example": "const isGeneratorFunction = (obj) => typeof obj === \"function\" && Object.prototype.toString.call(obj) === \"[object GeneratorFunction]\""
    },
    "snippet::is-gzip-buffer": {
      "id": "snippet::is-gzip-buffer",
      "type": "simple",
      "description": "You can check first three bytes of a buffer to detect if it is a gzip file.",
      "example": "function isGzip(buf) {\n  if (buf.length < 3) return false;\n  return buf[0] === 31 && buf[1] === 139 && buf[2] === 8;\n}"
    },
    "snippet::is-in-ssh": {
      "id": "snippet::is-in-ssh",
      "type": "simple",
      "description": "You can check if the current environment is SSH by checking if the `SSH_CONNECTION` environment variable is set.",
      "example": "const isInSsh = Boolean(process.env.SSH_CONNECTION);"
    },
    "snippet::is-negative": {
      "id": "snippet::is-negative",
      "type": "simple",
      "description": "You can check if a number is less than 0 to determine if it's negative.",
      "example": "(n) => n < 0"
    },
    "snippet::is-negative-zero": {
      "id": "snippet::is-negative-zero",
      "type": "simple",
      "description": "You can use `Object.is` to check if a value is negative zero.",
      "example": "Object.is(n, -0)"
    },
    "snippet::is-npm": {
      "id": "snippet::is-npm",
      "type": "simple",
      "description": "If the current environment is npm the `npm_config_user_agent` environment variable will be set and start with `\"npm\"`.",
      "example": "const isNpm = process.env.npm_config_user_agent?.startsWith(\"npm\")"
    },
    "snippet::is-null": {
      "id": "snippet::is-null",
      "type": "simple",
      "description": "You can check if a value is `null` using regular equality checks.",
      "example": "value === null"
    },
    "snippet::is-number": {
      "id": "snippet::is-number",
      "type": "simple",
      "description": "You can check if a value is a number by using `typeof` or coercing it to a number and using `Number.isFinite`.",
      "example": "const isNumber = (v) => typeof v === \"number\" || (typeof v === \"string\" && Number.isFinite(+v));"
    },
    "snippet::is-object": {
      "id": "snippet::is-object",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is an object and `Object.getPrototypeOf` to ensure it's a plain object.",
      "example": "const isObject = (obj) => obj && typeof obj === \"object\" && (Object.getPrototypeOf(obj) === null || Object.getPrototypeOf(obj) === Object.prototype);"
    },
    "snippet::is-object-or-function": {
      "id": "snippet::is-object-or-function",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is an object or a function.",
      "example": "const isObjectOrFunction = (v) => v !== null && (typeof v === \"object\" || typeof v === \"function\");"
    },
    "snippet::is-odd": {
      "id": "snippet::is-odd",
      "type": "simple",
      "description": "You can use the modulo operator to check if a number is odd.",
      "example": "(n % 2) === 1"
    },
    "snippet::is-primitve": {
      "id": "snippet::is-primitve",
      "type": "simple",
      "description": "You can check `typeof` of a value to determine if it's a primitive. Note that `typeof null` is `\"object\"` so you need to check for `null` separately.",
      "example": "const isPrimitive = (value) => value === null || (typeof value !== \"function\" && typeof value !== \"object\");"
    },
    "snippet::is-regexp": {
      "id": "snippet::is-regexp",
      "type": "simple",
      "description": "You can use `instanceof RegExp` to check if a value is a regular expression, or if cross-realm, use `Object.prototype.toString.call(v) === \"[object RegExp]\"`.",
      "example": "const isRegExp = (v) => v instanceof RegExp;\n// for cross-realm\nconst isRegExpCrossRealm = Object.prototype.toString.call(v) === \"[object RegExp]\";"
    },
    "snippet::is-set": {
      "id": "snippet::is-set",
      "type": "simple",
      "description": "You can use `instanceof Set` to check if a value is a `Set`, or if cross-realm, use `Object.prototype.toString.call(v) === \"[object Set]\"`",
      "example": "const isSet = v instanceof Set;\n// for cross-realm\nconst isSetCrossRealm = Object.prototype.toString.call(v) === \"[object Set]\""
    },
    "snippet::is-stream": {
      "id": "snippet::is-stream",
      "type": "simple",
      "description": "`node:stream` provides `isReadable` and `isWritable` methods that can be used to check if a stream is readable or writable.",
      "example": "import { isReadable, isWritable } from 'node:stream';\nconst isStream = (stream) => isReadable(stream) || isWritable(stream);"
    },
    "snippet::is-string": {
      "id": "snippet::is-string",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is a string.",
      "example": "const isString = (value) => typeof value === \"string\";"
    },
    "snippet::is-symbol": {
      "id": "snippet::is-symbol",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is a symbol.",
      "example": "const isSymbol = (value) => typeof value === \"symbol\";"
    },
    "snippet::is-travis": {
      "id": "snippet::is-travis",
      "type": "simple",
      "description": "You can check if the current environment is Travis CI by checking if the `TRAVIS` environment variable is set.",
      "example": "const isTravis = () => \"TRAVIS\" in process.env;"
    },
    "snippet::is-undefined": {
      "id": "snippet::is-undefined",
      "type": "simple",
      "description": "You can use `typeof` to check if a value is `undefined`.",
      "example": "typeof value === \"undefined\";"
    },
    "snippet::is-whitespace": {
      "id": "snippet::is-whitespace",
      "type": "simple",
      "description": "You can check if a string contains only whitespace with RegExp or by trimming it and comparing it to an empty string.",
      "example": "const isWhitespace = (str) => /^\\s*$/.test(str);"
    },
    "snippet::is-windows": {
      "id": "snippet::is-windows",
      "type": "simple",
      "description": "You can check if the current environment is Windows by checking if `process.platform` is equal to \"win32\".",
      "example": "const isWindows = () => process.platform === \"win32\";"
    },
    "snippet::is-wsl": {
      "id": "snippet::is-wsl",
      "type": "simple",
      "description": "You can check if the current environment is WSL by checking if the `WSL_DISTRO_NAME` environment variable is set.",
      "example": "const isWsl = Boolean(process.env.WSL_DISTRO_NAME);"
    },
    "snippet::json-file": {
      "id": "snippet::json-file",
      "type": "simple",
      "description": "You can use `JSON` and `node:fs` to read and write JSON files.",
      "example": "import * as fs from 'node:fs/promises'\nfs.readFile(file, 'utf8').then(JSON.parse)\nfs.writeFile(file, JSON.stringify(data, null, 2) + '\\n')"
    },
    "snippet::math-random": {
      "id": "snippet::math-random",
      "type": "simple",
      "description": "You can use `Math.random()` or `crypto.getRandomValues` if cryptographic randomness is required.",
      "example": "crypto.getRandomValues(new Uint32Array(1))[0] / (2 ** 32);\n// or\nMath.random();"
    },
    "snippet::noop": {
      "id": "snippet::noop",
      "type": "simple",
      "description": "You can use an arrow function `() => {}` for a noop function.",
      "example": "const noop = () => {}"
    },
    "snippet::object-exclude": {
      "id": "snippet::object-exclude",
      "type": "simple",
      "description": "You can use `Object.fromEntries` with `Object.entries` and `Array.prototype.filter` to exclude specific keys from an object.",
      "example": "const objectExclude = (obj, keys) => Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));"
    },
    "snippet::object-filter": {
      "id": "snippet::object-filter",
      "type": "simple",
      "description": "You can use `Object.fromEntries` with `Object.entries` and `Array.prototype.filter` to filter an object's properties.",
      "example": "const objectFilter = (obj, fn) => Object.fromEntries(Object.entries(obj).filter(fn));"
    },
    "snippet::object-map": {
      "id": "snippet::object-map",
      "type": "simple",
      "description": "You can use `Object.fromEntries` with `Object.entries` and `Array.prototype.map` to map an object's properties.",
      "example": "const objectMap = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([k, v]) => fn(k, v)));"
    },
    "snippet::object-reduce": {
      "id": "snippet::object-reduce",
      "type": "simple",
      "description": "You can use `Object.entries` and `Array.prototype.reduce`.",
      "example": "const objectReduce = (obj, fn, initial) => Object.entries(obj).reduce((acc, [k, v]) => fn(acc, k, v), initial);"
    },
    "snippet::path-key": {
      "id": "snippet::path-key",
      "type": "simple",
      "description": "You can use `Object.keys` with `Array.prototype.findLast` to find the case-insensitive `PATH` environment variable key.",
      "example": "const pathKey = Object.keys(process.env).findLast((k) => k.toUpperCase() === 'PATH') ?? 'PATH';"
    },
    "snippet::regexp-copy": {
      "id": "snippet::regexp-copy",
      "type": "simple",
      "description": "You can create a copy of a regular expression using the `RegExp` constructor.",
      "example": "const copyRegExp = (regexp) => new RegExp(regexp);"
    },
    "snippet::set-tostringtag": {
      "id": "snippet::set-tostringtag",
      "type": "simple",
      "description": "You can set the `toStringTag` of an object using `Object.defineProperty`.",
      "example": "const setToStringTag = (target, value) => Object.defineProperty(target, Symbol.toStringTag, { value, configurable: true });"
    },
    "snippet::shebang-regex": {
      "id": "snippet::shebang-regex",
      "type": "simple",
      "description": "You can use `/^#!(.+)/` regex.",
      "example": "const shebangRegex = /^#!(.+)/;"
    },
    "snippet::split-lines": {
      "id": "snippet::split-lines",
      "type": "simple",
      "description": "You can split a string into lines using a regular expression.",
      "example": "const splitLines = (str) => str.split(/\\r?\\n/);"
    },
    "snippet::strip-bom": {
      "id": "snippet::strip-bom",
      "type": "simple",
      "description": "You can check if the first character of the string is the BOM and strip it using `String.prototype.slice` if it is.",
      "example": "str.charCodeAt(0) === 0xFEFF ? str.slice(1) : str;"
    },
    "snippet::to-lower": {
      "id": "snippet::to-lower",
      "type": "simple",
      "description": "You can convert a string to lowercase using `toLocaleLowerCase` or `toLowerCase`.",
      "example": "const toLower = (str) => str.toLocaleLowerCase();"
    },
    "snippet::to-uppercase": {
      "id": "snippet::to-uppercase",
      "type": "simple",
      "description": "You can convert a string to uppercase using `toLocaleUpperCase` or `toUpperCase`.",
      "example": "const toUpper = (str) => str.toLocaleUpperCase();"
    },
    "snippet::typeof": {
      "id": "snippet::typeof",
      "type": "simple",
      "description": "You can use `typeof` to get the type of a value, or `Object.prototype.toString.call` to get the internal [[Class]] of an object.",
      "example": "const typeOf = (value) => typeof value;\n// for more specific types\nconst classOf = (value) => Object.prototype.toString.call(value);"
    },
    "snippet::unix-paths": {
      "id": "snippet::unix-paths",
      "type": "simple",
      "description": "You can check the start of a path for the Windows extended-length path prefix and if it's not present, replace backslashes with forward slashes.",
      "example": "path.startsWith('\\\\\\\\?\\\\') ? path : path.replace(/\\\\/g, '/')"
    },
    "snippet::year": {
      "id": "snippet::year",
      "type": "simple",
      "description": "You can use `new Date().getUTCFullYear()` to get the current year.",
      "example": "new Date().getUTCFullYear()"
    }
  },
  "mappings": {
    "arr-diff": {
      "type": "module",
      "moduleName": "arr-diff",
      "replacements": ["snippet::array-difference"]
    },
    "arr-flatten": {
      "type": "module",
      "moduleName": "arr-flatten",
      "replacements": ["snippet::array-flatten"]
    },
    "array-back": {
      "type": "module",
      "moduleName": "array-back",
      "replacements": ["snippet::array-coerce"]
    },
    "array-ify": {
      "type": "module",
      "moduleName": "array-ify",
      "replacements": ["snippet::array-coerce"]
    },
    "array-initial": {
      "type": "module",
      "moduleName": "array-initial",
      "replacements": ["snippet::array-slice-exclude-last-n"]
    },
    "array-last": {
      "type": "module",
      "moduleName": "array-last",
      "replacements": ["snippet::array-last"]
    },
    "array-range": {
      "type": "module",
      "moduleName": "array-range",
      "replacements": ["snippet::array-from-count-with-start"]
    },
    "array-union": {
      "type": "module",
      "moduleName": "array-union",
      "replacements": ["snippet::array-union"]
    },
    "array-uniq": {
      "type": "module",
      "moduleName": "array-uniq",
      "replacements": ["snippet::array-unique"]
    },
    "array-unique": {
      "type": "module",
      "moduleName": "array-unique",
      "replacements": ["snippet::array-unique"]
    },
    "arrify": {
      "type": "module",
      "moduleName": "arrify",
      "replacements": ["snippet::array-coerce"]
    },
    "as-array": {
      "type": "module",
      "moduleName": "as-array",
      "replacements": ["snippet::array-coerce"]
    },
    "async-function": {
      "type": "module",
      "moduleName": "async-function",
      "replacements": ["snippet::async-function-constructor"]
    },
    "base64-js": {
      "type": "module",
      "moduleName": "base64-js",
      "replacements": ["snippet::base64"]
    },
    "base64id": {
      "type": "module",
      "moduleName": "base64id",
      "replacements": ["snippet::base64-id"]
    },
    "call-bind": {
      "type": "module",
      "moduleName": "call-bind",
      "replacements": ["snippet::call-bind"]
    },
    "clone-regexp": {
      "type": "module",
      "moduleName": "clone-regexp",
      "replacements": ["snippet::regexp-copy"]
    },
    "es-get-iterator": {
      "type": "module",
      "moduleName": "es-get-iterator",
      "replacements": ["snippet::get-iterator"]
    },
    "es-set-tostringtag": {
      "type": "module",
      "moduleName": "es-set-tostringtag",
      "replacements": ["snippet::set-tostringtag"]
    },
    "except": {
      "type": "module",
      "moduleName": "except",
      "replacements": ["snippet::object-exclude"]
    },
    "filter-obj": {
      "type": "module",
      "moduleName": "filter-obj",
      "replacements": ["snippet::object-filter"]
    },
    "for-own": {
      "type": "module",
      "moduleName": "for-own",
      "replacements": ["snippet::for-own"]
    },
    "has-ansi": {
      "type": "module",
      "moduleName": "has-ansi",
      "replacements": ["snippet::has-ansi"]
    },
    "has-flag": {
      "type": "module",
      "moduleName": "has-flag",
      "replacements": ["snippet::has-argv"]
    },
    "iota-array": {
      "type": "module",
      "moduleName": "iota-array",
      "replacements": ["snippet::array-from-count"]
    },
    "is-arguments": {
      "type": "module",
      "moduleName": "is-arguments",
      "replacements": ["snippet::is-arguments"]
    },
    "is-array-buffer": {
      "type": "module",
      "moduleName": "is-array-buffer",
      "replacements": ["snippet::is-arraybuffer"]
    },
    "is-async-function": {
      "type": "module",
      "moduleName": "is-async-function",
      "replacements": ["snippet::is-async-function"]
    },
    "is-bigint": {
      "type": "module",
      "moduleName": "is-bigint",
      "replacements": ["snippet::is-bigint"]
    },
    "is-boolean-object": {
      "type": "module",
      "moduleName": "is-boolean-object",
      "replacements": ["snippet::is-boolean"]
    },
    "is-ci": {
      "type": "module",
      "moduleName": "is-ci",
      "replacements": ["snippet::is-ci"]
    },
    "is-date-object": {
      "type": "module",
      "moduleName": "is-date-object",
      "replacements": ["snippet::is-date"]
    },
    "is-deflate": {
      "type": "module",
      "moduleName": "is-deflate",
      "replacements": ["snippet::is-deflate-buffer"]
    },
    "is-electron": {
      "type": "module",
      "moduleName": "is-electron",
      "replacements": ["snippet::is-electron"]
    },
    "is-even": {
      "type": "module",
      "moduleName": "is-even",
      "replacements": ["snippet::is-even"]
    },
    "is-generator-function": {
      "type": "module",
      "moduleName": "is-generator-function",
      "replacements": ["snippet::is-generator-function"]
    },
    "is-gzip": {
      "type": "module",
      "moduleName": "is-gzip",
      "replacements": ["snippet::is-gzip-buffer"]
    },
    "is-in-ci": {
      "type": "module",
      "moduleName": "is-in-ci",
      "replacements": ["snippet::is-ci"]
    },
    "is-in-ssh": {
      "type": "module",
      "moduleName": "is-in-ssh",
      "replacements": ["snippet::is-in-ssh"]
    },
    "is-negative": {
      "type": "module",
      "moduleName": "is-negative",
      "replacements": ["snippet::is-negative"]
    },
    "is-negative-zero": {
      "type": "module",
      "moduleName": "is-negative-zero",
      "replacements": ["snippet::is-negative-zero"]
    },
    "is-npm": {
      "type": "module",
      "moduleName": "is-npm",
      "replacements": ["snippet::is-npm"]
    },
    "is-number": {
      "type": "module",
      "moduleName": "is-number",
      "replacements": ["snippet::is-number"]
    },
    "is-number-object": {
      "type": "module",
      "moduleName": "is-number-object",
      "replacements": ["snippet::is-number"]
    },
    "is-obj": {
      "type": "module",
      "moduleName": "is-obj",
      "replacements": ["snippet::is-object-or-function"]
    },
    "is-object": {
      "type": "module",
      "moduleName": "is-object",
      "replacements": ["snippet::is-object"]
    },
    "is-odd": {
      "type": "module",
      "moduleName": "is-odd",
      "replacements": ["snippet::is-odd"]
    },
    "is-plain-obj": {
      "type": "module",
      "moduleName": "is-plain-obj",
      "replacements": ["snippet::is-object"]
    },
    "is-plain-object": {
      "type": "module",
      "moduleName": "is-plain-object",
      "replacements": ["snippet::is-object"]
    },
    "is-primitive": {
      "type": "module",
      "moduleName": "is-primitive",
      "replacements": ["snippet::is-primitve"]
    },
    "is-regex": {
      "type": "module",
      "moduleName": "is-regex",
      "replacements": ["snippet::is-regexp"]
    },
    "is-regexp": {
      "type": "module",
      "moduleName": "is-regexp",
      "replacements": ["snippet::is-regexp"]
    },
    "is-set": {
      "type": "module",
      "moduleName": "is-set",
      "replacements": ["snippet::is-set"]
    },
    "is-stream": {
      "type": "module",
      "moduleName": "is-stream",
      "replacements": ["snippet::is-stream"]
    },
    "is-string": {
      "type": "module",
      "moduleName": "is-string",
      "replacements": ["snippet::is-string"]
    },
    "is-symbol": {
      "type": "module",
      "moduleName": "is-symbol",
      "replacements": ["snippet::is-symbol"]
    },
    "is-travis": {
      "type": "module",
      "moduleName": "is-travis",
      "replacements": ["snippet::is-travis"]
    },
    "is-whitespace": {
      "type": "module",
      "moduleName": "is-whitespace",
      "replacements": ["snippet::is-whitespace"]
    },
    "is-windows": {
      "type": "module",
      "moduleName": "is-windows",
      "replacements": ["snippet::is-windows"]
    },
    "is-wsl": {
      "type": "module",
      "moduleName": "is-wsl",
      "replacements": ["snippet::is-wsl"]
    },
    "isobject": {
      "type": "module",
      "moduleName": "isobject",
      "replacements": ["snippet::is-object"]
    },
    "isstream": {
      "type": "module",
      "moduleName": "isstream",
      "replacements": ["snippet::is-stream"]
    },
    "js-base64": {
      "type": "module",
      "moduleName": "js-base64",
      "replacements": ["snippet::base64"]
    },
    "jsonfile": {
      "type": "module",
      "moduleName": "jsonfile",
      "replacements": ["snippet::json-file"]
    },
    "kind-of": {
      "type": "module",
      "moduleName": "kind-of",
      "replacements": ["snippet::typeof"]
    },
    "last-char": {
      "type": "module",
      "moduleName": "last-char",
      "replacements": ["snippet::char-last"]
    },
    "lodash.castarray": {
      "type": "module",
      "moduleName": "lodash.castarray",
      "replacements": ["snippet::array-coerce"]
    },
    "lodash.eq": {
      "type": "module",
      "moduleName": "lodash.eq",
      "replacements": ["snippet::is-equal"]
    },
    "lodash.isboolean": {
      "type": "module",
      "moduleName": "lodash.isboolean",
      "replacements": ["snippet::is-boolean"]
    },
    "lodash.isfunction": {
      "type": "module",
      "moduleName": "lodash.isfunction",
      "replacements": ["snippet::is-function"]
    },
    "lodash.isnull": {
      "type": "module",
      "moduleName": "lodash.isnull",
      "replacements": ["snippet::is-null"]
    },
    "lodash.isnumber": {
      "type": "module",
      "moduleName": "lodash.isnumber",
      "replacements": ["snippet::is-number"]
    },
    "lodash.isobject": {
      "type": "module",
      "moduleName": "lodash.isobject",
      "replacements": ["snippet::is-object"]
    },
    "lodash.isplainobject": {
      "type": "module",
      "moduleName": "lodash.isplainobject",
      "replacements": ["snippet::is-object"]
    },
    "lodash.isregexp": {
      "type": "module",
      "moduleName": "lodash.isregexp",
      "replacements": ["snippet::is-regexp"]
    },
    "lodash.isstring": {
      "type": "module",
      "moduleName": "lodash.isstring",
      "replacements": ["snippet::is-string"]
    },
    "lodash.issymbol": {
      "type": "module",
      "moduleName": "lodash.issymbol",
      "replacements": ["snippet::is-symbol"]
    },
    "lodash.isundefined": {
      "type": "module",
      "moduleName": "lodash.isundefined",
      "replacements": ["snippet::is-undefined"]
    },
    "lodash.noop": {
      "type": "module",
      "moduleName": "lodash.noop",
      "replacements": ["snippet::noop"]
    },
    "lower-case": {
      "type": "module",
      "moduleName": "lower-case",
      "replacements": ["snippet::to-lower"]
    },
    "map-obj": {
      "type": "module",
      "moduleName": "map-obj",
      "replacements": ["snippet::object-map"]
    },
    "math-random": {
      "type": "module",
      "moduleName": "math-random",
      "replacements": ["snippet::math-random"]
    },
    "object.map": {
      "type": "module",
      "moduleName": "object.map",
      "replacements": ["snippet::object-map"]
    },
    "object.reduce": {
      "type": "module",
      "moduleName": "object.reduce",
      "replacements": ["snippet::object-reduce"]
    },
    "path-key": {
      "type": "module",
      "moduleName": "path-key",
      "replacements": ["snippet::path-key"]
    },
    "shebang-regex": {
      "type": "module",
      "moduleName": "shebang-regex",
      "replacements": ["snippet::shebang-regex"]
    },
    "slash": {
      "type": "module",
      "moduleName": "slash",
      "replacements": ["snippet::unix-paths"]
    },
    "split-lines": {
      "type": "module",
      "moduleName": "split-lines",
      "replacements": ["snippet::split-lines"]
    },
    "strip-bom": {
      "type": "module",
      "moduleName": "strip-bom",
      "replacements": ["snippet::strip-bom"]
    },
    "strip-bom-string": {
      "type": "module",
      "moduleName": "strip-bom-string",
      "replacements": ["snippet::strip-bom"]
    },
    "toarray": {
      "type": "module",
      "moduleName": "toarray",
      "replacements": ["snippet::array-coerce"]
    },
    "uniq": {
      "type": "module",
      "moduleName": "uniq",
      "replacements": ["snippet::array-unique"]
    },
    "upper-case": {
      "type": "module",
      "moduleName": "upper-case",
      "replacements": ["snippet::to-uppercase"]
    },
    "validate.io-function": {
      "type": "module",
      "moduleName": "validate.io-function",
      "replacements": ["snippet::is-function"]
    },
    "year": {
      "type": "module",
      "moduleName": "year",
      "replacements": ["snippet::year"]
    }
  }
}