New upstream version 1.0.2+~2.3.1

.gitignore

-/node_modules
-/.nyc_output
-/test/cache

.travis.yml

-language: node_js
-sudo: false
-node_js:
-  - "7"
-  - "6"
-  - "4"

json-parse-even-better-errors/CHANGELOG.md

+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## 2.0.0
+
+* Add custom error classes
+
+<a name="1.0.2"></a>
+## [1.0.2](https://github.com/npm/json-parse-even-better-errors/compare/v1.0.1...v1.0.2) (2018-03-30)
+
+
+### Bug Fixes
+
+* **messages:** More friendly messages for non-string ([#1](https://github.com/npm/json-parse-even-better-errors/issues/1)) ([a476d42](https://github.com/npm/json-parse-even-better-errors/commit/a476d42))
+
+
+
+<a name="1.0.1"></a>
+## [1.0.1](https://github.com/npm/json-parse-even-better-errors/compare/v1.0.0...v1.0.1) (2017-08-16)
+
+
+### Bug Fixes
+
+* **license:** oops. Forgot to update license.md ([efe2958](https://github.com/npm/json-parse-even-better-errors/commit/efe2958))
+
+
+
+<a name="1.0.0"></a>
+# 1.0.0 (2017-08-15)
+
+
+### Features
+
+* **init:** Initial Commit ([562c977](https://github.com/npm/json-parse-even-better-errors/commit/562c977))
+
+
+### BREAKING CHANGES
+
+* **init:** This is the first commit!
+
+
+
+<a name="0.1.0"></a>
+# 0.1.0 (2017-08-15)
+
+
+### Features
+
+* **init:** Initial Commit ([9dd1a19](https://github.com/npm/json-parse-even-better-errors/commit/9dd1a19))

json-parse-even-better-errors/LICENSE.md

+Copyright 2017 Kat Marchán
+Copyright npm, Inc.
+
+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.
+
+---
+
+This library is a fork of 'better-json-errors' by Kat Marchán, extended and
+distributed under the terms of the MIT license above.

json-parse-even-better-errors/README.md

+# json-parse-even-better-errors
+
+[`json-parse-even-better-errors`](https://github.com/npm/json-parse-even-better-errors)
+is a Node.js library for getting nicer errors out of `JSON.parse()`,
+including context and position of the parse errors.
+
+It also preserves the newline and indentation styles of the JSON data, by
+putting them in the object or array in the `Symbol.for('indent')` and
+`Symbol.for('newline')` properties.
+
+## Install
+
+`$ npm install --save json-parse-even-better-errors`
+
+## Table of Contents
+
+* [Example](#example)
+* [Features](#features)
+* [Contributing](#contributing)
+* [API](#api)
+  * [`parse`](#parse)
+
+### Example
+
+```javascript
+const parseJson = require('json-parse-even-better-errors')
+
+parseJson('"foo"') // returns the string 'foo'
+parseJson('garbage') // more useful error message
+parseJson.noExceptions('garbage') // returns undefined
+```
+
+### Features
+
+* Like JSON.parse, but the errors are better.
+* Strips a leading byte-order-mark that you sometimes get reading files.
+* Has a `noExceptions` method that returns undefined rather than throwing.
+* Attaches the newline character(s) used to the `Symbol.for('newline')`
+  property on objects and arrays.
+* Attaches the indentation character(s) used to the `Symbol.for('indent')`
+  property on objects and arrays.
+
+## Indentation
+
+To preserve indentation when the file is saved back to disk, use
+`data[Symbol.for('indent')]` as the third argument to `JSON.stringify`, and
+if you want to preserve windows `\r\n` newlines, replace the `\n` chars in
+the string with `data[Symbol.for('newline')]`.
+
+For example:
+
+```js
+const txt = await readFile('./package.json', 'utf8')
+const data = parseJsonEvenBetterErrors(txt)
+const indent = Symbol.for('indent')
+const newline = Symbol.for('newline')
+// .. do some stuff to the data ..
+const string = JSON.stringify(data, null, data[indent]) + '\n'
+const eolFixed = data[newline] === '\n' ? string
+  : string.replace(/\n/g, data[newline])
+await writeFile('./package.json', eolFixed)
+```
+
+Indentation is determined by looking at the whitespace between the initial
+`{` and `[` and the character that follows it.  If you have lots of weird
+inconsistent indentation, then it won't track that or give you any way to
+preserve it.  Whether this is a bug or a feature is debatable ;)
+
+### API
+
+#### <a name="parse"></a> `parse(txt, reviver = null, context = 20)`
+
+Works just like `JSON.parse`, but will include a bit more information when
+an error happens, and attaches a `Symbol.for('indent')` and
+`Symbol.for('newline')` on objects and arrays.  This throws a
+`JSONParseError`.
+
+#### <a name="parse"></a> `parse.noExceptions(txt, reviver = null)`
+
+Works just like `JSON.parse`, but will return `undefined` rather than
+throwing an error.
+
+#### <a name="jsonparseerror"></a> `class JSONParseError(er, text, context = 20, caller = null)`
+
+Extends the JavaScript `SyntaxError` class to parse the message and provide
+better metadata.
+
+Pass in the error thrown by the built-in `JSON.parse`, and the text being
+parsed, and it'll parse out the bits needed to be helpful.
+
+`context` defaults to 20.
+
+Set a `caller` function to trim internal implementation details out of the
+stack trace.  When calling `parseJson`, this is set to the `parseJson`
+function.  If not set, then the constructor defaults to itself, so the
+stack trace will point to the spot where you call `new JSONParseError`.

json-parse-even-better-errors/appveyor.yml

+environment:
+  matrix:
+    - nodejs_version: "7"
+    - nodejs_version: "6"
+    - nodejs_version: "4"
+
+platform:
+  - x64
+
+install:
+  - ps: Install-Product node $env:nodejs_version $env:platform
+  - npm config set spin false
+  - npm install
+
+test_script:
+  - npm test
+
+matrix:
+  fast_finish: true
+  
+build: off

json-parse-even-better-errors/index.js

+'use strict'
+
+const hexify = char => {
+  const h = char.charCodeAt(0).toString(16).toUpperCase()
+  return '0x' + (h.length % 2 ? '0' : '') + h
+}
+
+const parseError = (e, txt, context) => {
+  if (!txt) {
+    return {
+      message: e.message + ' while parsing empty string',
+      position: 0,
+    }
+  }
+  const badToken = e.message.match(/^Unexpected token (.) .*position\s+(\d+)/i)
+  const errIdx = badToken ? +badToken[2]
+    : e.message.match(/^Unexpected end of JSON.*/i) ? txt.length - 1
+    : null
+
+  const msg = badToken ? e.message.replace(/^Unexpected token ./, `Unexpected token ${
+      JSON.stringify(badToken[1])
+    } (${hexify(badToken[1])})`)
+    : e.message
+
+  if (errIdx !== null && errIdx !== undefined) {
+    const start = errIdx <= context ? 0
+      : errIdx - context
+
+    const end = errIdx + context >= txt.length ? txt.length
+      : errIdx + context
+
+    const slice = (start === 0 ? '' : '...') +
+      txt.slice(start, end) +
+      (end === txt.length ? '' : '...')
+
+    const near = txt === slice ? '' : 'near '
+
+    return {
+      message: msg + ` while parsing ${near}${JSON.stringify(slice)}`,
+      position: errIdx,
+    }
+  } else {
+    return {
+      message: msg + ` while parsing '${txt.slice(0, context * 2)}'`,
+      position: 0,
+    }
+  }
+}
+
+class JSONParseError extends SyntaxError {
+  constructor (er, txt, context, caller) {
+    context = context || 20
+    const metadata = parseError(er, txt, context)
+    super(metadata.message)
+    Object.assign(this, metadata)
+    this.code = 'EJSONPARSE'
+    this.systemError = er
+    Error.captureStackTrace(this, caller || this.constructor)
+  }
+  get name () { return this.constructor.name }
+  set name (n) {}
+  get [Symbol.toStringTag] () { return this.constructor.name }
+}
+
+const kIndent = Symbol.for('indent')
+const kNewline = Symbol.for('newline')
+// only respect indentation if we got a line break, otherwise squash it
+// things other than objects and arrays aren't indented, so ignore those
+// Important: in both of these regexps, the $1 capture group is the newline
+// or undefined, and the $2 capture group is the indent, or undefined.
+const formatRE = /^\s*[{\[]((?:\r?\n)+)([\s\t]*)/
+const emptyRE = /^(?:\{\}|\[\])((?:\r?\n)+)?$/
+
+const parseJson = (txt, reviver, context) => {
+  const parseText = stripBOM(txt)
+  context = context || 20
+  try {
+    // get the indentation so that we can save it back nicely
+    // if the file starts with {" then we have an indent of '', ie, none
+    // otherwise, pick the indentation of the next line after the first \n
+    // If the pattern doesn't match, then it means no indentation.
+    // JSON.stringify ignores symbols, so this is reasonably safe.
+    // if the string is '{}' or '[]', then use the default 2-space indent.
+    const [, newline = '\n', indent = '  '] = parseText.match(emptyRE) ||
+      parseText.match(formatRE) ||
+      [, '', '']
+
+    const result = JSON.parse(parseText, reviver)
+    if (result && typeof result === 'object') {
+      result[kNewline] = newline
+      result[kIndent] = indent
+    }
+    return result
+  } catch (e) {
+    if (typeof txt !== 'string' && !Buffer.isBuffer(txt)) {
+      const isEmptyArray = Array.isArray(txt) && txt.length === 0
+      throw Object.assign(new TypeError(
+        `Cannot parse ${isEmptyArray ? 'an empty array' : String(txt)}`
+      ), {
+        code: 'EJSONPARSE',
+        systemError: e,
+      })
+    }
+
+    throw new JSONParseError(e, parseText, context, parseJson)
+  }
+}
+
+// Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+// because the buffer-to-string conversion in `fs.readFileSync()`
+// translates it to FEFF, the UTF-16 BOM.
+const stripBOM = txt => String(txt).replace(/^\uFEFF/, '')
+
+module.exports = parseJson
+parseJson.JSONParseError = JSONParseError
+
+parseJson.noExceptions = (txt, reviver) => {
+  try {
+    return JSON.parse(stripBOM(txt), reviver)
+  } catch (e) {}
+}

json-parse-even-better-errors/package.json

+{
+  "name": "json-parse-even-better-errors",
+  "version": "2.3.1",
+  "description": "JSON.parse with context information on error",
+  "main": "index.js",
+  "files": [
+    "*.js"
+  ],
+  "scripts": {
+    "preversion": "npm t",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push --follow-tags",
+    "test": "tap",
+    "snap": "tap"
+  },
+  "repository": "https://github.com/npm/json-parse-even-better-errors",
+  "keywords": [
+    "JSON",
+    "parser"
+  ],
+  "author": {
+    "name": "Kat Marchán",
+    "email": "kzm@zkat.tech",
+    "twitter": "maybekatz"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "tap": "^14.6.5"
+  },
+  "tap": {
+    "check-coverage": true
+  }
+}

json-parse-even-better-errors/test/index.js

+'use strict'
+
+const t = require('tap')
+
+const parseJson = require('..')
+
+t.test('parses JSON', t => {
+  const cases = Object.entries({
+    object: {
+      foo: 1,
+      bar: {
+        baz: [1, 2, 3, 'four']
+      }
+    },
+    array: [ 1, 2, null, 'hello', { world: true }, false ],
+    num: 420.69,
+    null: null,
+    true: true,
+    false: false,
+  }).map(([name, obj]) => [name, JSON.stringify(obj)])
+  t.plan(cases.length)
+  for (const [name, data] of cases) {
+    t.deepEqual(parseJson(data), JSON.parse(data), name)
+  }
+})
+
+t.test('preserves indentation and newline styles', t => {
+  const kIndent = Symbol.for('indent')
+  const kNewline = Symbol.for('newline')
+  const object = { name: 'object', version: '1.2.3' }
+  const array = [ 1, 2, 3, { object: true }, null ]
+  for (const newline of ['\n', '\r\n', '\n\n', '\r\n\r\n']) {
+    for (const indent of ['', '  ', '\t', ' \t \t ']) {
+      for (const [type, obj] of Object.entries({object, array})) {
+        const n = JSON.stringify({type, newline, indent})
+        const txt = JSON.stringify(obj, null, indent).replace(/\n/g, newline)
+        t.test(n, t => {
+          const res = parseJson(txt)
+          // no newline if no indentation
+          t.equal(res[kNewline], indent && newline, 'preserved newline')
+          t.equal(res[kIndent], indent, 'preserved indent')
+          t.end()
+        })
+      }
+    }
+  }
+  t.end()
+})
+
+t.test('indentation is the default when object/array is empty', t => {
+  const kIndent = Symbol.for('indent')
+  const kNewline = Symbol.for('newline')
+  const obj = '{}'
+  const arr = '[]'
+  for (const newline of ['', '\n', '\r\n', '\n\n', '\r\n\r\n']) {
+    const expect = newline || '\n'
+    for (const str of [obj, arr]) {
+      t.test(JSON.stringify({str, newline, expect}), t => {
+        const res = parseJson(str + newline)
+        t.equal(res[kNewline], expect, 'got expected newline')
+        t.equal(res[kIndent], '  ', 'got expected default indentation')
+        t.end()
+      })
+    }
+  }
+  t.end()
+})
+
+t.test('parses JSON if it is a Buffer, removing BOM bytes', t => {
+  const str = JSON.stringify({
+    foo: 1,
+    bar: {
+      baz: [1, 2, 3, 'four']
+    }
+  })
+  const data = Buffer.from(str)
+  const bom = Buffer.concat([Buffer.from([0xEF, 0xBB, 0xBF]), data])
+  t.deepEqual(parseJson(data), JSON.parse(str))
+  t.deepEqual(parseJson(bom), JSON.parse(str), 'strips the byte order marker')
+  t.end()
+})
+
+t.test('better errors when faced with \\b and other malarky', t => {
+  const str = JSON.stringify({
+    foo: 1,
+    bar: {
+      baz: [1, 2, 3, 'four']
+    }
+  })
+  const data = Buffer.from(str)
+  const bombom = Buffer.concat([Buffer.from([0xEF, 0xBB, 0xBF, 0xEF, 0xBB, 0xBF]), data])
+  t.throws(() => parseJson(bombom), {
+    message: /\(0xFEFF\) in JSON at position 0/
+  }, 'only strips a single BOM, not multiple')
+  const bs = str + '\b\b\b\b\b\b\b\b\b\b\b\b'
+  t.throws(() => parseJson(bs), {
+    message: /^Unexpected token "\\b" \(0x08\) in JSON at position.*\\b"$/
+  })
+  t.end()
+})
+
+t.test('throws SyntaxError for unexpected token', t => {
+  const data = 'foo'
+  t.throws(
+    () => parseJson(data),
+    {
+      message: 'Unexpected token "o" (0x6F) in JSON at position 1 while parsing "foo"',
+      code: 'EJSONPARSE',
+      position: 1,
+      name: 'JSONParseError',
+      systemError: SyntaxError
+    }
+  )
+  t.end()
+})
+
+t.test('throws SyntaxError for unexpected end of JSON', t => {
+  const data = '{"foo: bar}'
+  t.throws(
+    () => parseJson(data),
+    {
+      message: 'Unexpected end of JSON input while parsing "{\\\"foo: bar}"',
+      code: 'EJSONPARSE',
+      position: 10,
+      name: 'JSONParseError',
+      systemError: SyntaxError
+    }
+  )
+  t.end()
+})
+
+t.test('throws SyntaxError for unexpected number', t => {
+  const data = '[[1,2],{3,3,3,3,3}]'
+  t.throws(
+    () => parseJson(data),
+    {
+      message: 'Unexpected number in JSON at position 8',
+      code: 'EJSONPARSE',
+      position: 0,
+      name: 'JSONParseError',
+      systemError: SyntaxError
+    }
+  )
+  t.end()
+})
+
+t.test('SyntaxError with less context (limited start)', t => {
+  const data = '{"6543210'
+  t.throws(
+    () => parseJson(data, null, 3),
+    {
+      message: 'Unexpected end of JSON input while parsing near "...3210"',
+      code: 'EJSONPARSE',
+      position: 8,
+      name: 'JSONParseError',
+      systemError: SyntaxError
+    })
+  t.end()
+})
+
+t.test('SyntaxError with less context (limited end)', t => {
+  const data = 'abcde'
+  t.throws(
+    () => parseJson(data, null, 2),
+    {
+      message: 'Unexpected token "a" \(0x61\) in JSON at position 0 while parsing near "ab..."',
+      code: 'EJSONPARSE',
+      position: 0,
+      name: 'JSONParseError',
+      systemError: SyntaxError
+    }
+  )
+  t.end()
+})
+
+t.test('throws TypeError for undefined', t => {
+  t.throws(
+    () => parseJson(undefined),
+    new TypeError('Cannot parse undefined')
+  )
+  t.end()
+})
+
+t.test('throws TypeError for non-strings', t => {
+  t.throws(
+    () => parseJson(new Map()),
+    new TypeError('Cannot parse [object Map]')
+  )
+  t.end()
+})
+
+t.test('throws TypeError for empty arrays', t => {
+  t.throws(
+    () => parseJson([]),
+    new TypeError('Cannot parse an empty array')
+  )
+  t.end()
+})
+
+t.test('handles empty string helpfully', t => {
+  t.throws(() => parseJson(''), {
+    message: 'Unexpected end of JSON input while parsing empty string',
+    name: 'JSONParseError',
+    position: 0,
+    code: 'EJSONPARSE',
+    systemError: SyntaxError
+  })
+  t.end()
+})
+
+t.test('json parse error class', t => {
+  t.isa(parseJson.JSONParseError, 'function')
+  // we already checked all the various index checking logic above
+  const poop = new Error('poop')
+  const fooShouldNotShowUpInStackTrace = () => {
+    return new parseJson.JSONParseError(poop, 'this is some json', undefined, bar)
+  }
+  const bar = () => fooShouldNotShowUpInStackTrace()
+  const err1 = bar()
+  t.equal(err1.systemError, poop, 'gets the original error attached')
+  t.equal(err1.position, 0)
+  t.equal(err1.message, `poop while parsing 'this is some json'`)
+  t.equal(err1.name, 'JSONParseError')
+  err1.name = 'something else'
+  t.equal(err1.name, 'JSONParseError')
+  t.notMatch(err1.stack, /fooShouldNotShowUpInStackTrace/)
+  // calling it directly, tho, it does
+  const fooShouldShowUpInStackTrace = () => {
+    return new parseJson.JSONParseError(poop, 'this is some json')
+  }
+  const err2 = fooShouldShowUpInStackTrace()
+  t.equal(err2.systemError, poop, 'gets the original error attached')
+  t.equal(err2.position, 0)
+  t.equal(err2.message, `poop while parsing 'this is some json'`)
+  t.match(err2.stack, /fooShouldShowUpInStackTrace/)
+
+  t.end()
+})
+
+t.test('parse without exception', t => {
+  const bad = 'this is not json'
+  t.equal(parseJson.noExceptions(bad), undefined, 'does not throw')
+  const obj = { this: 'is json' }
+  const good = JSON.stringify(obj)
+  t.deepEqual(parseJson.noExceptions(good), obj, 'parses json string')
+  const buf = Buffer.from(good)
+  t.deepEqual(parseJson.noExceptions(buf), obj, 'parses json buffer')
+  const bom = Buffer.concat([Buffer.from([0xEF, 0xBB, 0xBF]), buf])
+  t.deepEqual(parseJson.noExceptions(bom), obj, 'parses json buffer with bom')
+  t.end()
+})