121 lines
3.8 KiB
JavaScript
121 lines
3.8 KiB
JavaScript
'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) {}
|
|
}
|