Spaces:
Build error
Build error
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) {} | |
} | |