Files F122203443

index.js
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 16, 14:38

index.js
View Options

	'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) {}
	}

Event Timeline