json-6 1.1.3 → 1.1.5

package/lib/json6.js

@@ -1,10 +1,12 @@
+// GENERATED FILE -- do not edit.
+// Built from src/json6.js by build/src-to-lib.js (npm run build); edits here are overwritten.
 // json6.js
 // JSON for Humans. See README.md for details.
 //
 // This file is based off of https://github.com/d3x0r/sack  ./src/netlib/html5.websocket/json6_parser.c
 //
 "use strict";
-const version = "1.1.1";
+const version = "1.1.5";
 const VALUE_UNDEFINED = -1;
 const VALUE_UNSET = 0;
 const VALUE_NULL = 1;
@@ -60,33 +62,121 @@ const CONTEXT_IN_ARRAY = 1;
 const CONTEXT_OBJECT_FIELD = 3;
 const CONTEXT_OBJECT_FIELD_VALUE = 4;
 
+// Matches an ECMAScript `IdentifierName` (the production that may appear
+// unquoted as an object-literal property key in JavaScript). Used only by the
+// opt-in `esStrictCompatible` mode to reject unquoted keys JavaScript would
+// not accept.
+const ES_IDENTIFIER_NAME = /^[$_\p{ID_Start}][$_\p{ID_Continue}]*$/u;
+
+// Matches a NumericLiteralSeparator ('_') only where it is legal: between two
+// digits. Used only by `esStrictCompatible` to recognize unquoted numeric keys
+// like `1_000` as valid JS -- `Number()` itself rejects the underscore.
+const NUMERIC_SEPARATOR = /(\d)_(?=\d)/g;
+
+/**
+ * @typedef {{
+ *   n: number,
+ *   buf: null|string
+ * }} Json6Node
+ */
+
+/**
+ * Options accepted by {@link JSON6.parse} and {@link JSON6.begin}. All are
+ * off by default: with no options JSON6 accepts its full historical grammar.
+ *
+ * @typedef {object} Json6ParseOptions
+ * @property {boolean} [esStrictCompatible] When `true`, reject the JSON6
+ *   extensions that are not valid in ECMAScript strict mode, so accepted
+ *   input can be pasted into a module or `eval`'d unchanged: legacy-octal /
+ *   leading-zero numbers (`0123`); legacy octal string escapes (`"\012"`,
+ *   `"\1"`..`"\9"`); literal line terminators inside `'`/`"` strings
+ *   (backtick strings still allow them); backtick-quoted object keys;
+ *   unquoted object keys that are neither identifiers nor numbers; and two or
+ *   more consecutive unary `+`/`-` signs. Defaults to `false`.
+ * @property {boolean} [forbidTemplateSubstitution] When `true`, reject an
+ *   unescaped `${` inside a backtick-quoted string, so a document cannot
+ *   silently turn into a template-literal substitution if later evaluated as
+ *   JavaScript. Independent of `esStrictCompatible`. Defaults to `false`.
+ * @property {boolean} [warnWithCommentWithoutEOL] When `true`, a `//` comment
+ *   that reaches the end of the document with no terminating line break logs
+ *   a console warning. The input is accepted either way. Defaults to `false`.
+ * @property {boolean} [normalizeNumericKeys] When `true`, an unquoted object
+ *   key that parses as a number is replaced with `String(Number(key))`, so
+ *   `{1e3: true}` gets the key `"1000"` instead of the source text `"1e3"` --
+ *   matching what a real JS object literal would produce. Independent of
+ *   `esStrictCompatible` (does not require it). Note: `Number()` parses a
+ *   leading-zero digit string like `"0123"` as decimal (123), while a real JS
+ *   numeric literal `0123` is legacy octal (83) in sloppy mode; combine with
+ *   `esStrictCompatible` (which forbids leading-zero numbers outright) for a
+ *   guaranteed match. Defaults to `false`.
+ */
+
+/**
+ * @template T
+ * @typedef {object} NodeInfo
+ * @property {T} node
+ * @property {NodeInfo<T>|null|undefined} next
+ * @property {NodeInfo<T>|null} prior
+ */
+
+/**
+ * @typedef {object} Context
+ * @property {0|1|3|4} context
+ * @property {Record<string, unknown>|null|undefined} elements
+ * @property {unknown[]|null} element_array
+ * @property {string|null} name
+ */
+
+/**
+ * @type {Context[]}
+ */
 const contexts = [];
 function getContext() {
-	return contexts.pop() || {
+	return /** @type {Context} */ (contexts.pop()) || /** @type {Context} */ ({
 		context : CONTEXT_UNKNOWN,
 		elements : null,
-		element_array : null
-	};
+		element_array : null,
+		name : null
+	});
 }
+
+/**
+ * @param {Context} ctx
+ */
 function dropContext(ctx) {
 	contexts.push( ctx );
 }
 
+/** @type {Json6Node[]} */
 const buffers = [];
 function getBuffer() {
+	/** @type {Json6Node|undefined} */
 	let buf = buffers.pop();
 	if( !buf ) buf = { buf:null, n:0 };
 	else buf.n = 0;
-	return buf;
+	return /** @type {Json6Node} */ (buf);
 }
+
+/**
+ * @param {Json6Node} buf
+ */
 function dropBuffer(buf) {
 	buffers.push( buf );
 }
 
-const JSON6 = typeof exports === 'object'
-	? exports
-// istanbul ignore next
-	: {};
+/**
+ * @template T
+ * @param {T|undefined} value
+ * @param {string} [msg]
+ * @returns {T}
+ */
+function ensureDefined(value, msg) {
+	/* istanbul ignore next -- every call site checks buf.length before consuming a code point, so codePointAt never actually returns undefined here */
+	if( value === undefined ) throw new Error( msg || "Unexpected undefined value" );
+	return value;
+}
+
+const JSON6 = {};
 
 /*
 let _DEBUG_LL = true;
@@ -107,6 +197,10 @@ const log = function(type) {
 };
 */
 
+/**
+ * @param {string} string
+ * @returns {string}
+ */
 JSON6.escape = function(string) {
 	let output = '';
 	if( !string ) return string;
@@ -120,33 +214,56 @@ JSON6.escape = function(string) {
 	return output;
 };
 
-
-JSON6.begin = function( cb, reviver ) {
-
-	const val = { name : null,   // name of this value (if it's contained in an object)
+/**
+ * @callback Json6Reviver
+ * @param {string} key
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+
+/**
+ * @param {(value: unknown) => void} [cb]
+ * @param {Json6Reviver|undefined} [reviver]
+ * @param {Json6ParseOptions} [options]
+ */
+JSON6.begin = function( cb, reviver, options ) {
+
+	const beginOptions = options;
+	/** @type {boolean} */
+	let esStrictCompatible = !!( beginOptions && beginOptions.esStrictCompatible );
+	/** @type {boolean} */
+	let forbidTemplateSubstitution = !!( beginOptions && beginOptions.forbidTemplateSubstitution );
+	/** @type {boolean} */
+	let warnWithCommentWithoutEOL = !!( beginOptions && beginOptions.warnWithCommentWithoutEOL );
+	/** @type {boolean} */
+	let normalizeNumericKeys = !!( beginOptions && beginOptions.normalizeNumericKeys );
+
+	const val = /** @type {{ name: string|null, value_type: number, string: string, contains: unknown }} */ ({ name : null,   // name of this value (if it's contained in an object)
 		value_type: VALUE_UNSET, // value from above indiciating the type of this value
 		string : '',   // the string value of this value (strings and number types only)
 		contains : null,
-	};
-
-	const pos = { line:1, col:1 };
-	let n = 0;
-	let word = WORD_POS_RESET,
+	});
+	// col is incremented as each character is taken, so it starts at 0 and the first
+	// character of a line reports as column 1.
+	const pos = /** @type {{ line: number, col: number }} */ ({ line:1, col:0 });
+	/** @type {number} */ let n = 0;
+	/** @type {number} */ let word = WORD_POS_RESET,
 		status = true,
 		negative = false,
-		result = null,
-		elements = undefined,
-		element_array = [],
-		parse_context = CONTEXT_UNKNOWN,
+		/** @type {unknown} */ result = null,
+		/** @type {Record<string, unknown>|null|undefined} */ elements = undefined,
+		/** @type {unknown[]|null} */ element_array = [],
+		/** @type {0|1|3|4} */ parse_context = CONTEXT_UNKNOWN,
 		comment = 0,
 		fromHex = false,
 		decimal = false,
 		exponent = false,
 		exponent_sign = false,
 		exponent_digit = false,
-		gatheringStringFirstChar = null,
+		/** @type {number|null} */ gatheringStringFirstChar = null,
 		gatheringString = false,
 		gatheringNumber = false,
+		signSeen = false,  // '+' or '-' seen; no number or keyword has followed it yet
 		stringEscape = false,
 		cr_escaped = false,
 		unicodeWide = false,
@@ -154,61 +271,94 @@ JSON6.begin = function( cb, reviver ) {
 		stringHex = false,
 		hex_char = 0,
 		hex_char_len = 0,
-		completed = false
-		;
-
-	const context_stack = {
-		first : null,
-		last : null,
-		saved : null,
-		push(node) {
-			let recover = this.saved;
-			if( recover ) { this.saved = recover.next; recover.node = node; recover.next = null; recover.prior = this.last; }
-			else { recover = { node : node, next : null, prior : this.last }; }
-			if( !this.last ) this.first = recover;
-			this.last = recover;
-		},
-		pop() {
-			const result = this.last;
-			if( !(this.last = result.prior ) ) this.first = null;
-			result.next = this.saved; this.saved = result;
-			return result.node;
-		}
-	};
-
-	const inQueue = {
-		first : null,
-		last : null,
-		saved : null,
-		push(node) {
-			let recover = this.saved;
-			if( recover ) {this.saved = recover.next; recover.node = node; recover.next = null; recover.prior = this.last; }
-			else { recover = { node : node, next : null, prior : this.last }; }
-			if( !this.last ) this.first = recover;
-			else this.last.next = recover;
-			this.last = recover;
-		},
-		shift() {
-			const result = this.first;
-			if( !result ) return null;
-			this.first = result.next;
-			if( !this.first ) this.last = null;
-			result.next = this.saved;
-			this.saved = result;
-			// node is in saved...
-			return result.node;
-		},
-		unshift(node) {
-			// usage in this module, recover will ALWAYS have a saved to use.
-			const recover = this.saved;
-			//if( recover ) {
-			this.saved = recover.next; recover.node = node; recover.next = this.first; recover.prior = null;
-			//} else { recover = { node : node, next : this.first, prior : null }; }
-			if( !this.first ) this.last = recover;
-			this.first = recover;
-		}
-	};
+		completed = false,
+		dollarSeen = false;
+
+	const context_stack = /** @type {{
+		first: NodeInfo<Context>|null,
+		last: NodeInfo<Context>|null,
+		saved: NodeInfo<Context>|null|undefined,
+		push: (node: Context) => void,
+		pop: () => Context
+	}} */ ({
+			first : null,
+			last : null,
+			saved : null,
+			/**
+			 * @param {Context} node
+			 */
+			push(node) {
+				/** @type {NodeInfo<Context>|null|undefined} */
+				let recover = this.saved;
+				if( recover ) { this.saved = recover.next; recover.node = node; recover.next = null; recover.prior = this.last; }
+				else { recover = /** @type {NodeInfo<Context>} */ ({ node : node, next : null, prior : this.last }); }
+				if( !this.last ) this.first = recover;
+				this.last = recover;
+			},
+			pop() {
+				const resultNode = this.last;
+				/* istanbul ignore next -- pop() is only ever called from parse_context states that were entered via a matching push(), so the stack can never be empty here */
+				if( !resultNode ) throw new Error( "context stack underflow" );
+				if( !(this.last = resultNode.prior ) ) this.first = null;
+				resultNode.next = this.saved; this.saved = resultNode;
+				return resultNode.node;
+			}
+		});
+
+	const inQueue = /** @type {{
+		save: NodeInfo<Json6Node>|null|undefined,
+		first: NodeInfo<Json6Node>|null|undefined,
+		last: NodeInfo<Json6Node>|null,
+		saved: NodeInfo<Json6Node>|null|undefined,
+		push: (node: Json6Node) => void,
+		shift: () => Json6Node|null,
+		unshift: (node: Json6Node) => void
+	}} */ ({
+			/** @type {NodeInfo<Json6Node>|null|undefined} */
+			save: undefined,
+			/** @type {NodeInfo<Json6Node>|null|undefined} */
+			first : null,
+			/** @type {NodeInfo<Json6Node>|null} */
+			last : null,
+			/** @type {NodeInfo<Json6Node>|null|undefined} */
+			saved : null,
+			/**
+			 * @param {Json6Node} node
+			 */
+			push(node) {
+				/** @type {NodeInfo<Json6Node>|null|undefined} */
+				let recover = this.saved;
+				if( recover ) {this.saved = recover.next; recover.node = node; recover.next = null; recover.prior = this.last; }
+				else { recover = /** @type {NodeInfo<Json6Node>} */ ({ node : node, next : null, prior : this.last }); }
+				if( !this.last ) this.first = recover;
+				else this.last.next = recover;
+				this.last = recover;
+			},
+			shift() {
+				const resultNode = this.first;
+				if( !resultNode ) return null;
+				this.first = resultNode.next;
+				if( !this.first ) this.last = null;
+				resultNode.next = this.saved;
+				this.saved = resultNode;
+				// node is in saved...
+				return resultNode.node;
+			},
+			/**
+			 * @param {Json6Node} node
+			 */
+			unshift(node) {
+				// usage in this module, recover will ALWAYS have a saved to use.
+				const recover = /** @type {NodeInfo<Json6Node>} */ (this.saved);
+				this.saved = recover.next; recover.node = node; recover.next = this.first; recover.prior = null;
+				if( !this.first ) this.last = recover;
+				this.first = recover;
+			}
+		});
 
+	/**
+	 * @param {string} leader
+	 */
 	function throwEndError( leader /* , c */ ) {
 		throw new Error( `${leader} at ${n} [${pos.line}:${pos.col}]`);
 	}
@@ -221,7 +371,8 @@ JSON6.begin = function( cb, reviver ) {
 				case 1:
 					return throwEndError( "Comment began at end of document" );
 				case 2:
-					console.log( "Warning: '//' comment without end of line ended document" );
+					if( warnWithCommentWithoutEOL )
+						console.log( "Warning: '//' comment without end of line ended document" );
 					break;
 				case 3:
 					return throwEndError( "Open comment '/*' is missing close at end of document" );
@@ -237,14 +388,24 @@ JSON6.begin = function( cb, reviver ) {
 			result = undefined;
 			return r;
 		},
-		reset() {
+		/**
+		 * @param {Json6ParseOptions} [resetOptions] Options for the next parse.
+		 *   When omitted, the options passed to `begin()` (if any) stay in
+		 *   effect.
+		 */
+		reset( resetOptions ) {
+			const activeOptions = resetOptions === undefined ? beginOptions : resetOptions;
+			esStrictCompatible = !!( activeOptions && activeOptions.esStrictCompatible );
+			forbidTemplateSubstitution = !!( activeOptions && activeOptions.forbidTemplateSubstitution );
+			warnWithCommentWithoutEOL = !!( activeOptions && activeOptions.warnWithCommentWithoutEOL );
+			normalizeNumericKeys = !!( activeOptions && activeOptions.normalizeNumericKeys );
 			word = WORD_POS_RESET;
 			status = true;
 			if( inQueue.last ) inQueue.last.next = inQueue.save;
 			inQueue.save = inQueue.first;
 			inQueue.first = inQueue.last = null;
-			if( context_stack.last ) context_stack.last.next = context_stack.save;
-			context_stack.save = inQueue.first;
+			if( context_stack.last ) context_stack.last.next = context_stack.saved;
+			context_stack.saved = inQueue.first;
 			context_stack.first = context_stack.last = null;//= [];
 			element_array = null;
 			elements = undefined;
@@ -253,39 +414,61 @@ JSON6.begin = function( cb, reviver ) {
 			val.name = null;
 			val.string = '';
 			pos.line = 1;
-			pos.col = 1;
+			pos.col = 0;
 			negative = false;
+			signSeen = false;
 			comment = 0;
 			completed = false;
+			signSeen = false;
+			dollarSeen = false;
+			gatheringStringFirstChar = null;
 			gatheringString = false;
 			stringEscape = false;  // string stringEscape intro
 			cr_escaped = false;   // carraige return escaped
+			unicodeWide = false;
+			stringUnicode = false;
+			stringHex = false;
+			hex_char = 0;
+			hex_char_len = 0;
 			//stringUnicode = false;  // reading \u
 			//unicodeWide = false;  // reading \u{} in string
 			//stringHex = false;  // reading \x in string
 		},
+		/**
+		 * @param {unknown} [msg]
+		 */
 		write(msg) {
+			/** @type {number} */
 			let retcode;
+			// write() is the push interface; values only leave it through the callback.
+			// parse() drives the same parser through _write()/value() and needs no callback.
+			if( !cb ) throw new Error( "Callback function must be passed to begin, or you can't get values from the stream." );
 			if( msg !== undefined && typeof msg !== "string") msg = String(msg);
 			if( !status ) throw new Error( "Parser is in an error state, please reset." );
-			for( retcode = this._write(msg,false); retcode > 0; retcode = this._write() ) {
+			for( retcode = this._write(/** @type {string|undefined|null} */ (msg),false); retcode > 0; retcode = this._write() ) {
 				this.finalError();
-				if( typeof reviver === 'function' ) (function walk(holder, key) {
-					const value = holder[key];
-					if (value && typeof value === 'object') {
-						for (const k in value) {
-							if (Object.prototype.hasOwnProperty.call(value, k)) {
-								const v = walk(value, k);
-								if (v !== undefined) {
-									value[k] = v;
-								} else {
-									delete value[k];
+				if( typeof reviver === 'function' ) (/**
+					 * @param {Record<string, unknown>} holder
+					 * @param {string} key
+					 * @returns {unknown}
+					 */
+					function walk(holder, key) {
+						const value = holder[key];
+						if (value && typeof value === 'object') {
+							const record = /** @type {Record<string, unknown>} */ (value);
+							for (const k in record) {
+								if (Object.prototype.hasOwnProperty.call(record, k)) {
+									const v = walk(record, k);
+									if (v !== undefined) {
+										record[k] = v;
+									} else {
+										delete record[k];
+									}
 								}
 							}
 						}
-					}
-					return reviver.call(holder, key, value);
-				}({'': result}, ''));
+						return reviver.call(holder, key, value);
+					}({'': result}, ''));
 				cb( result );
 				result = undefined;
 
@@ -295,110 +478,191 @@ JSON6.begin = function( cb, reviver ) {
 			if( retcode )
 				this.finalError();
 		},
+		/**
+		 * @param {string|undefined|null} [msg]
+		 * @param {boolean} [complete_at_end]
+		 */
 		_write(msg,complete_at_end) {
+			/** @type {Json6Node|null} */
 			let input;
-			let buf;
+			/** @type {string} */
+			let buf = "";
+			/** @type {number} */
 			let retval = 0;
 
+			/**
+			 * @param {string} leader
+			 * @param {number} c
+			 */
 			function throwError( leader, c ) {
 				throw new Error( `${leader} '${String.fromCodePoint( c )}' unexpected at ${n} (near '${buf.substr(n>4?(n-4):0,n>4?3:(n-1))}[${String.fromCodePoint( c )}]${buf.substr(n, 10)}') [${pos.line}:${pos.col}]`);
 			}
 
+			// Line bookkeeping for a character that has just been taken (n is past it).
+			// CR, LF, LS and PS each end a line; a CR directly followed by LF counts once,
+			// at the LF.  (A CR that ends one write() chunk with the LF in the next counts
+			// twice; that is the one case this does not see.)  Column resets to 0 so the
+			// next character lands on column 1.
+			/**
+			 * @param {number} cInt
+			 */
+			function countLine( cInt ) {
+				if( cInt === 13/*'\r'*/ ) {
+					if( n < buf.length && buf.charCodeAt( n ) === 10 ) return;
+				}
+				else if( cInt !== 10/*'\n'*/ && cInt !== 0x2028 && cInt !== 0x2029 ) return;
+				pos.line++;
+				pos.col = 0;
+			}
+
 			function RESET_VAL()  {
 				val.value_type = VALUE_UNSET;
 				val.string = '';
+				signSeen = false;
+			}
+
+			// A delimiter, or the end of the document, arrived while a value was still
+			// being spelled out: 'tru', 'nul', or a sign with nothing after it.  Without
+			// this, '[tru]' was [] and 'tru' alone was undefined.
+			/**
+			 * @param {number} [cInt] the delimiter; omitted at end of document
+			 */
+			function checkPartialValue( cInt ) {
+				if( word > WORD_POS_RESET && word < WORD_POS_FIELD ) {
+					if( cInt === undefined ) throwEndError( "Incomplete keyword" );
+					else throwError( "Incomplete keyword", cInt );
+				}
+				if( signSeen && val.value_type == VALUE_UNSET ) {
+					if( cInt === undefined ) throwEndError( "Sign with no number following" );
+					else throwError( "Sign with no number following", cInt );
+				}
+			}
+
+			// A new value is starting; there must not already be a finished one waiting
+			// for a separator.  Without this, '[1 2]' kept only the 2.
+			/**
+			 * @param {number} cInt
+			 */
+			function checkValueSeparator( cInt ) {
+				if( val.value_type != VALUE_UNSET )
+					throwError( "Two values with no separator between them", cInt );
+			}
+
+			// collectNumber only admits digits, a sign, one '.', one 'e' and a radix
+			// prefix, so a token Number() cannot read is malformed: '1e', '.5.', '.e3', '0x'.
+			// These used to come back as NaN.
+			function checkNumber() {
+				if( Number.isNaN( Number( val.string ) ) ) {
+					status = false;
+					throw new Error( `Invalid number '${val.string}' at ${n} [${pos.line}:${pos.col}]` );
+				}
 			}
 
 			function arrayPush() {
+				// invariant: only called while parse_context is CONTEXT_IN_ARRAY, which is only
+				// entered after '[' sets element_array to a real array.
+				const arr = /** @type {unknown[]} */ (element_array);
 				switch( val.value_type ){
 				case VALUE_NUMBER:
-					element_array.push( (negative?-1:1) * Number( val.string ) );
+					arr.push( (negative?-1:1) * Number( val.string ) );
 					break;
 				case VALUE_STRING:
-					element_array.push( val.string );
+					arr.push( val.string );
 					break;
 				case VALUE_TRUE:
-					element_array.push( true );
+					arr.push( true );
 					break;
 				case VALUE_FALSE:
-					element_array.push( false );
+					arr.push( false );
 					break;
 				case VALUE_NEG_NAN:
-					element_array.push( -NaN );
+					arr.push( -NaN );
 					break;
 				case VALUE_NAN:
-					element_array.push( NaN );
+					arr.push( NaN );
 					break;
 				case VALUE_NEG_INFINITY:
-					element_array.push( -Infinity );
+					arr.push( -Infinity );
 					break;
 				case VALUE_INFINITY:
-					element_array.push( Infinity );
+					arr.push( Infinity );
 					break;
 				case VALUE_NULL:
-					element_array.push( null );
+					arr.push( null );
 					break;
 				case VALUE_UNDEFINED:
-					element_array.push( undefined );
+					arr.push( undefined );
 					break;
 				case VALUE_EMPTY:
-					element_array.push( undefined );
-					delete element_array[element_array.length-1];
+					arr.push( undefined );
+					delete arr[arr.length-1];
 					break;
 				case VALUE_OBJECT:
-					element_array.push( val.contains );
+					arr.push( val.contains );
 					break;
 				case VALUE_ARRAY:
-					element_array.push( val.contains );
+					arr.push( val.contains );
 					break;
 				}
 			}
 			function objectPush() {
+				// invariant: only called while parse_context is CONTEXT_OBJECT_FIELD_VALUE, which is
+				// only entered after '{' sets elements to a real object.
+				const obj = /** @type {Record<string, unknown>} */ (elements);
+				const name = /** @type {string} */ (val.name);
 				switch( val.value_type ){
 				case VALUE_NUMBER:
-					elements[val.name] = ((negative?-1:1) * Number( val.string ));
+					obj[name] = ((negative?-1:1) * Number( val.string ));
 					break;
 				case VALUE_STRING:
-					elements[val.name] = ( val.string );
+					obj[name] = ( val.string );
 					break;
 				case VALUE_TRUE:
-					elements[val.name] = ( true );
+					obj[name] = ( true );
 					break;
 				case VALUE_FALSE:
-					elements[val.name] = ( false );
+					obj[name] = ( false );
 					break;
 				case VALUE_NEG_NAN:
-					elements[val.name] = ( -NaN );
+					obj[name] = ( -NaN );
 					break;
 				case VALUE_NAN:
-					elements[val.name] = ( NaN );
+					obj[name] = ( NaN );
 					break;
 				case VALUE_NEG_INFINITY:
-					elements[val.name] = ( -Infinity );
+					obj[name] = ( -Infinity );
 					break;
 				case VALUE_INFINITY:
-					elements[val.name] = ( Infinity );
+					obj[name] = ( Infinity );
 					break;
 				case VALUE_NULL:
-					elements[val.name] = ( null );
+					obj[name] = ( null );
 					break;
 				case VALUE_UNDEFINED:
-					elements[val.name] = ( undefined );
+					obj[name] = ( undefined );
 					break;
 				case VALUE_OBJECT:
-					elements[val.name] = val.contains;
+					obj[name] = val.contains;
 					break;
 				case VALUE_ARRAY:
-					elements[val.name] = val.contains;
+					obj[name] = val.contains;
 					break;
 				}
 			}
 
+			/**
+			 * @param {number} start_c
+			 */
 			function gatherString( start_c ) {
 				let retval = 0;
+				// Hoisted out of the per-character loop: these are constant for
+				// the whole string, so the default (non-strict) path adds no
+				// work beyond one predictable branch.
+				const strictQuote = esStrictCompatible && start_c !== 96/*'`'*/;
+				const trackTemplate = start_c === 96/*'`'*/ && forbidTemplateSubstitution;
 				while( retval == 0 && ( n < buf.length ) ) {
 					let str = buf.charAt(n);
-					const cInt = buf.codePointAt(n++);
+					const cInt = ensureDefined( buf.codePointAt(n++), "Unexpected end of string" );
 					if( cInt >= 0x10000 ) { str += buf.charAt(n); n++; }
 					//console.log( "gathering....", stringEscape, str, cInt, unicodeWide, stringHex, stringUnicode, hex_char_len );
 					pos.col++;
@@ -470,22 +734,15 @@ JSON6.begin = function( cb, reviver ) {
 						}
 						switch( cInt ) {
 						case 13/*'\r'*/:
+							// \\ \r : a continuation; if \n follows it is counted there
 							cr_escaped = true;
-							pos.col = 1;
+							countLine( cInt );
 							continue;
 						case 0x2028: // LS (Line separator)
 						case 0x2029: // PS (paragraph separator)
-							pos.col = 1; // no return to get newline reset, so reset line pos.
-							// Fallthrough
 						case 10/*'\n'*/:
-							if( cr_escaped ) {
-								// \\ \r \n
-								cr_escaped = false;
-							} else {
-								// \\ \n
-								pos.col = 1;
-							}
-							pos.line++;
+							cr_escaped = false;
+							countLine( cInt );
 							break;
 						case 116/*'t'*/:
 							val.string += '\t';
@@ -494,6 +751,8 @@ JSON6.begin = function( cb, reviver ) {
 							val.string += '\b';
 							break;
 						case 48/*'0'*/:
+							if( esStrictCompatible && buf.charCodeAt( n ) >= 48/*'0'*/ && buf.charCodeAt( n ) <= 57/*'9'*/ )
+								throwError( "Legacy octal string escapes are not allowed when the 'esStrictCompatible' option is set", buf.charCodeAt( n ) );
 							val.string += '\0';
 							break;
 						case 110/*'n'*/:
@@ -519,6 +778,8 @@ JSON6.begin = function( cb, reviver ) {
 							hex_char = 0;
 							continue;
 						default:
+							if( esStrictCompatible && cInt >= 49/*'1'*/ && cInt <= 57/*'9'*/ )
+								throwError( "Legacy octal string escapes are not allowed when the 'esStrictCompatible' option is set", cInt );
 							val.string += str;
 							break;
 						}
@@ -527,14 +788,21 @@ JSON6.begin = function( cb, reviver ) {
 					}
 					else if( cInt === 92/*'\\'*/ ) {
 						stringEscape = true;
+						dollarSeen = false;
 					}
 					else {
-						if( cr_escaped ) {
-							cr_escaped = false;
-							// \\ \r <any other character>
-							pos.line++;
-							pos.col = 2; // newline, plus one character.
+						// U+2028/U+2029 are legal, unescaped, inside string literals since
+						// ES2019 (the JSON-superset proposal); only \n and \r are illegal.
+						if( strictQuote && ( cInt === 10/*'\n'*/ || cInt === 13/*'\r'*/ ) )
+							throwError( "Literal line terminators inside single- or double-quoted strings require the 'esStrictCompatible' option to be off", cInt );
+						if( trackTemplate ) {
+							if( dollarSeen && cInt === 123/*'{'*/ )
+								throwError( "Template substitution ${ } is not allowed when the 'forbidTemplateSubstitution' option is set", cInt );
+							dollarSeen = cInt === 36/*'$'*/;
 						}
+						// \\ \r <any other character> : the CR was counted when seen
+						cr_escaped = false;
+						countLine( cInt );
 						val.string += str;
 					}
 				}
@@ -546,16 +814,18 @@ JSON6.begin = function( cb, reviver ) {
 				let _n;
 				while( (_n = n) < buf.length ) {
 					const str = buf.charAt(_n);
-					const cInt = buf.codePointAt(n++);
+					const cInt = ensureDefined( buf.codePointAt(n++), "Unexpected end of number" );
 					if( cInt >= 0x10000 ) {
 						throwError( "fault while parsing number;", cInt );
 					}
 					//log('_DEBUG_PARSING', "in getting number:", n, cInt, String.fromCodePoint(cInt) );
+					pos.col++;
 					if( cInt == 95 /*_*/ )
 						continue;
-					pos.col++;
 					// leading zeros should be forbidden.
 					if( cInt >= 48/*'0'*/ && cInt <= 57/*'9'*/ ) {
+						if( esStrictCompatible && val.string === '0' )
+							throwError( "Legacy octal / leading-zero numbers are not allowed when the 'esStrictCompatible' option is set", cInt );
 						if( exponent ) {
 							exponent_digit = true;
 						}
@@ -604,6 +874,7 @@ JSON6.begin = function( cb, reviver ) {
 						}
 					} else {
 						if( cInt == 32/*' '*/ || cInt == 160/* &nbsp */ || cInt == 13 || cInt == 10 || cInt == 9
+					        || cInt == 11/*VT*/ || cInt == 12/*FF*/ || cInt == 0x2028/*LS*/ || cInt == 0x2029/*PS*/
 					        || cInt == 0xFEFF || cInt == 44/*','*/ || cInt == 125/*'}'*/ || cInt == 93/*']'*/
 					        || cInt == 58/*':'*/ ) {
 							break;
@@ -617,6 +888,9 @@ JSON6.begin = function( cb, reviver ) {
 						}
 					}
 				}
+				// the character that ended the number was counted here and is handed back to
+				// the main loop, which counts it again.
+				if( n > _n ) pos.col--;
 				n = _n;
 
 				if( (!complete_at_end) && n == buf.length ) {
@@ -624,6 +898,7 @@ JSON6.begin = function( cb, reviver ) {
 				}
 				else {
 					gatheringNumber = false;
+					checkNumber();
 					val.value_type = VALUE_NUMBER;
 					if( parse_context == CONTEXT_UNKNOWN ) {
 						completed = true;
@@ -641,6 +916,7 @@ JSON6.begin = function( cb, reviver ) {
 				if( gatheringNumber ) {
 					//console.log( "Force completed.")
 					gatheringNumber = false;
+					checkNumber();
 					val.value_type = VALUE_NUMBER;
 					if( parse_context == CONTEXT_UNKNOWN ) {
 						completed = true;
@@ -653,8 +929,13 @@ JSON6.begin = function( cb, reviver ) {
 
 			while( status && ( input = inQueue.shift() ) ) {
 				n = input.n;
-				buf = input.buf;
+				// invariant: queued buffers are always given a string via `input.buf = msg` before being pushed.
+				buf = /** @type {string} */ (input.buf);
 				if( gatheringString ) {
+					/* istanbul ignore next -- gatheringString and gatheringStringFirstChar are always set/cleared together; this guards state that the public API can never actually produce */
+					if( gatheringStringFirstChar === null ) {
+						throw new Error( "Parser string start was unset" );
+					}
 					const string_status = gatherString( gatheringStringFirstChar );
 					if( string_status > 0 ) {
 						gatheringString = false;
@@ -667,12 +948,13 @@ JSON6.begin = function( cb, reviver ) {
 
 				while( !completed && status && ( n < buf.length ) ) {
 					let str = buf.charAt(n);
-					const cInt = buf.codePointAt(n++);
+					const cInt = ensureDefined( buf.codePointAt(n++), "Unexpected end of input while parsing" );
 					if( cInt >= 0x10000 ) { str += buf.charAt(n); n++; }
 					//// log('_DEBUG_PARSING', "parsing at ", cInt, str );
 					//log('_DEBUG_LL', "processing: ", cInt, str, pos, comment, parse_context, word, val );
 					pos.col++;
 					if( comment ) { // '/'
+						countLine( cInt );
 						if( comment == 1 ) {  // '/'
 							if( cInt == 42/*'*'*/ ) { comment = 3; }  // '/*'
 							else if( cInt != 47/*'/'*/ ) {            // '//'(NOT)
@@ -682,7 +964,8 @@ JSON6.begin = function( cb, reviver ) {
 						}
 						else if( comment == 2 ) { // '// ...'
 							if( cInt == 10/*'\n'*/
-							  || cInt == 13/*'\r'*/ ) comment = 0;
+							  || cInt == 13/*'\r'*/
+							  || cInt == 0x2028/*LS*/ || cInt == 0x2029/*PS*/ ) comment = 0;
 						}
 						else if( comment == 3 ){ // '/*... '
 							if( cInt == 42/*'*'*/ ) comment = 4;
@@ -702,6 +985,7 @@ JSON6.begin = function( cb, reviver ) {
 							throwError( "fault while parsing; getting field name unexpected ", cInt );
 							// break;
 						}
+						checkValueSeparator( cInt );
 						{
 							const old_context = getContext();
 							//log('_DEBUG_PARSING', "Begin a new object; previously pushed into elements; but wait until trailing comma or close previously:%d", val.value_type );
@@ -734,13 +1018,15 @@ JSON6.begin = function( cb, reviver ) {
 							//log('_DEBUG_PARSING', "Begin a new array; previously pushed into elements; but wait until trailing comma or close previously:%d", val.value_type );
 
 							val.value_type = VALUE_ARRAY;
+							/** @type {unknown[]} */
 							const tmparr = [];
 							if( parse_context == CONTEXT_UNKNOWN )
 								result = element_array = tmparr;
 							//else if( parse_context == CONTEXT_IN_ARRAY )
 							//    element_array.push( tmparr );
 							else if( parse_context == CONTEXT_OBJECT_FIELD_VALUE )
-								elements[val.name] = tmparr;
+								// invariant: CONTEXT_OBJECT_FIELD_VALUE means elements/val.name were set by ':'.
+								/** @type {Record<string, unknown>} */ (elements)[/** @type {string} */ (val.name)] = tmparr;
 
 							old_context.context = parse_context;
 							old_context.elements = elements;
@@ -761,6 +1047,15 @@ JSON6.begin = function( cb, reviver ) {
 						////log('_DEBUG_PARSING', "colon context:", parse_context );
 						if( parse_context == CONTEXT_OBJECT_FIELD ) {
 							word = WORD_POS_RESET;
+							if( esStrictCompatible && val.value_type !== VALUE_STRING
+								&& !ES_IDENTIFIER_NAME.test( val.string )
+								&& Number.isNaN( Number( val.string.replace( NUMERIC_SEPARATOR, '$1' ) ) ) )
+								throwError( "Unquoted keys must be valid identifiers when the 'esStrictCompatible' option is set", cInt );
+							if( normalizeNumericKeys && val.value_type !== VALUE_STRING && val.string !== '' ) {
+								const numericKey = Number( val.string.replace( NUMERIC_SEPARATOR, '$1' ) );
+								if( !Number.isNaN( numericKey ) )
+									val.string = String( numericKey );
+							}
 							val.name = val.string;
 							val.string = '';
 							parse_context = CONTEXT_OBJECT_FIELD_VALUE;
@@ -779,8 +1074,13 @@ JSON6.begin = function( cb, reviver ) {
 							// allow starting a new word
 							word = WORD_POS_RESET;
 						}
+						checkPartialValue( cInt );
 						// coming back after pushing an array or sub-object will reset the context to FIELD, so an end with a field should still push value.
 						if( ( parse_context == CONTEXT_OBJECT_FIELD ) ) {
+							// a field name was collected but no ':' followed it: '{a}', '{a }', '{"a"}'.
+							// This used to silently produce {}.
+							if( word == WORD_POS_FIELD || word == WORD_POS_AFTER_FIELD || val.value_type == VALUE_STRING )
+								throwError( "Object field name with no value", cInt );
 							//log('_DEBUG_PARSING', "close object; empty object %d", val.value_type );
 							//RESET_VAL();
 							val.value_type = VALUE_OBJECT;
@@ -823,9 +1123,11 @@ JSON6.begin = function( cb, reviver ) {
 							throwError( "Fault while parsing; unexpected", cInt );
 						}
 						negative = false;
+						signSeen = false;
 						break;
 					case 93/*']'*/:
 						if( word == WORD_POS_END ) word = WORD_POS_RESET;
+						checkPartialValue( cInt );
 						if( parse_context == CONTEXT_IN_ARRAY ) {
 							//log('_DEBUG_PARSING', "close array, push last element: %d", val.value_type );
 							if( val.value_type != VALUE_UNSET ) {
@@ -850,9 +1152,11 @@ JSON6.begin = function( cb, reviver ) {
 							throwError( `bad context ${parse_context}; fault while parsing`, cInt );// fault
 						}
 						negative = false;
+						signSeen = false;
 						break;
 					case 44/*','*/:
 						if( word == WORD_POS_END ) word = WORD_POS_RESET;  // allow collect new keyword
+						checkPartialValue( cInt );
 						//log('_DEBUG_PARSING', "comma context:", parse_context, val );
 						if( parse_context == CONTEXT_IN_ARRAY ) {
 							if( val.value_type == VALUE_UNSET )
@@ -878,12 +1182,16 @@ JSON6.begin = function( cb, reviver ) {
 							throwError( "bad context; excessive commas while parsing;", cInt );// fault
 						}
 						negative = false;
+						signSeen = false;
 						break;
 
 					default:
 						if( parse_context == CONTEXT_OBJECT_FIELD ) {
 							switch( cInt ) {
 							case 96://'`':
+								if( esStrictCompatible )
+									throwError( "Backtick-quoted keys are not allowed when the 'esStrictCompatible' option is set", cInt );
+								// falls through
 							case 34://'"':
 							case 39://'\'':
 								if( word == WORD_POS_RESET ) {
@@ -903,14 +1211,16 @@ JSON6.begin = function( cb, reviver ) {
 
 								break;
 							case 10://'\n':
-								pos.line++;
-								pos.col = 1;
-								// fall through to normal space handling - just updated line/col position
 							case 13://'\r':
 							case 32://' ':
 							case 160://&nbsp:
 							case 9://'\t':
+							case 11://VT
+							case 12://FF
+							case 0x2028://LS
+							case 0x2029://PS
 							case 0xFEFF: // ZWNBS is WS though
+								countLine( cInt );
 								if( word == WORD_POS_END ) { // allow collect new keyword
 									word = WORD_POS_RESET;
 								}
@@ -947,16 +1257,19 @@ JSON6.begin = function( cb, reviver ) {
 							break;
 						}
 						case 10://'\n':
-							pos.line++;
-							pos.col = 1;
-							// Fallthrough
 						case 32://' ':
 						case 160:// &nbsp
 						case 9://'\t':
 						case 13://'\r':
+						case 11://VT
+						case 12://FF
+						case 0x2028://LS
+						case 0x2029://PS
 						case 0xFEFF://'\uFEFF':
+							countLine( cInt );
 							if( word == WORD_POS_END ) {
 								word = WORD_POS_RESET;
+								signSeen = false;
 								if( parse_context == CONTEXT_UNKNOWN ) {
 									completed = true;
 								}
@@ -970,7 +1283,7 @@ JSON6.begin = function( cb, reviver ) {
 							//----------------------------------------------------------
 							//  catch characters for true/false/null/undefined which are values outside of quotes
 						case 116://'t':
-							if( word == WORD_POS_RESET ) word = WORD_POS_TRUE_1;
+							if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_TRUE_1; }
 							else if( word == WORD_POS_INFINITY_6 ) word = WORD_POS_INFINITY_7;
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
@@ -981,7 +1294,7 @@ JSON6.begin = function( cb, reviver ) {
 						case 117://'u':
 							if( word == WORD_POS_TRUE_2 ) word = WORD_POS_TRUE_3;
 							else if( word == WORD_POS_NULL_1 ) word = WORD_POS_NULL_2;
-							else if( word == WORD_POS_RESET ) word = WORD_POS_UNDEFINED_1;
+							else if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_UNDEFINED_1; }
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 101://'e':
@@ -996,7 +1309,7 @@ JSON6.begin = function( cb, reviver ) {
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 110://'n':
-							if( word == WORD_POS_RESET ) word = WORD_POS_NULL_1;
+							if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_NULL_1; }
 							else if( word == WORD_POS_UNDEFINED_1 ) word = WORD_POS_UNDEFINED_2;
 							else if( word == WORD_POS_UNDEFINED_6 ) word = WORD_POS_UNDEFINED_7;
 							else if( word == WORD_POS_INFINITY_1 ) word = WORD_POS_INFINITY_2;
@@ -1023,7 +1336,7 @@ JSON6.begin = function( cb, reviver ) {
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 102://'f':
-							if( word == WORD_POS_RESET ) word = WORD_POS_FALSE_1;
+							if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_FALSE_1; }
 							else if( word == WORD_POS_UNDEFINED_4 ) word = WORD_POS_UNDEFINED_5;
 							else if( word == WORD_POS_INFINITY_2 ) word = WORD_POS_INFINITY_3;
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
@@ -1038,11 +1351,11 @@ JSON6.begin = function( cb, reviver ) {
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 73://'I':
-							if( word == WORD_POS_RESET ) word = WORD_POS_INFINITY_1;
+							if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_INFINITY_1; }
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 78://'N':
-							if( word == WORD_POS_RESET ) word = WORD_POS_NAN_1;
+							if( word == WORD_POS_RESET ) { checkValueSeparator( cInt ); word = WORD_POS_NAN_1; }
 							else if( word == WORD_POS_NAN_2 ) { val.value_type = negative ? VALUE_NEG_NAN : VALUE_NAN; negative = false; word = WORD_POS_END; }
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
@@ -1051,21 +1364,35 @@ JSON6.begin = function( cb, reviver ) {
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 45://'-':
-							if( word == WORD_POS_RESET ) negative = !negative;
+							if( word == WORD_POS_RESET ) {
+								checkValueSeparator( cInt );
+								if( esStrictCompatible && signSeen )
+									throwError( "Multiple consecutive signs are not allowed when the 'esStrictCompatible' option is set", cInt );
+								signSeen = true;
+								negative = !negative;
+							}
 							else { status = false; throwError( "fault parsing", cInt ); }// fault
 							break;
 						case 43://'+':
 							if( word !== WORD_POS_RESET ) { status = false; throwError( "fault parsing", cInt ); }// fault
+							else {
+								checkValueSeparator( cInt );
+								if( esStrictCompatible && signSeen )
+									throwError( "Multiple consecutive signs are not allowed when the 'esStrictCompatible' option is set", cInt );
+								signSeen = true;
+							}
 							break;
 							//
 							//----------------------------------------------------------
 						default:
 							if( ( cInt >= 48/*'0'*/ && cInt <= 57/*'9'*/ ) || ( cInt == 43/*'+'*/ ) || ( cInt == 46/*'.'*/ ) || ( cInt == 45/*'-'*/ ) ) {
+								checkValueSeparator( cInt );
 								fromHex = false;
 								exponent = false;
 								exponent_sign = false;
 								exponent_digit = false;
 								decimal = false;
+								signSeen = false;
 								val.string = str;
 								input.n = n;
 								collectNumber();
@@ -1088,6 +1415,7 @@ JSON6.begin = function( cb, reviver ) {
 
 				if( n == buf.length ) {
 					dropBuffer( input );
+					if( complete_at_end ) checkPartialValue();
 					if( gatheringString || gatheringNumber || parse_context == CONTEXT_OBJECT_FIELD ) {
 						retval = 0;
 					}
@@ -1161,61 +1489,105 @@ JSON6.begin = function( cb, reviver ) {
 
 const _parser = [Object.freeze( JSON6.begin() )];
 let _parse_level = 0;
-JSON6.parse = function( msg, reviver ) {
+
+/**
+ * @param {unknown} msg
+ * @param {Json6Reviver} [reviver]
+ * @param {Json6ParseOptions} [options]
+ */
+JSON6.parse = function( msg, reviver, options ) {
 	//var parser = JSON6.begin();
 	const parse_level = _parse_level++;
 	if( _parser.length <= parse_level )
 		_parser.push( Object.freeze( JSON6.begin() ) );
 	const parser = _parser[parse_level];
 	if (typeof msg !== "string") msg = String(msg);
-	parser.reset();
-	if( parser._write( msg, true ) > 0 ) {
+	parser.reset( options );
+	try {
+		if( parser._write( /** @type {string} */ (msg), true ) <= 0 ) {
+			// nothing completed: empty document, whitespace, or only comments.
+			parser.finalError();
+			throw new Error( "No value found in document" );
+		}
 		const result = parser.value();
-		if (typeof reviver === 'function') (function walk(holder, key) {
-			const value = holder[key];
-			if (value && typeof value === 'object') {
-				for (const k in value) {
-					if (Object.prototype.hasOwnProperty.call(value, k)) {
-						const v = walk(value, k);
-						if (v !== undefined) {
-							value[k] = v;
-						} else {
-							delete value[k];
+		if (typeof reviver === 'function') (/**
+			 * @param {Record<string, unknown>} holder
+			 * @param {string} key
+			 * @returns {unknown}
+			 */
+			function walk(holder, key) {
+				const value = holder[key];
+				if (value && typeof value === 'object') {
+					const record = /** @type {Record<string, unknown>} */ (value);
+					for (const k in record) {
+						if (Object.prototype.hasOwnProperty.call(record, k)) {
+							const v = walk(record, k);
+							if (v !== undefined) {
+								record[k] = v;
+							} else {
+								delete record[k];
+							}
 						}
 					}
 				}
-			}
-			return reviver.call(holder, key, value);
-		}({'': result}, ''));
-		_parse_level--;
+				return reviver.call(holder, key, value);
+			}({'': result}, ''));
 		return result;
-	} else parser.finalError();
-	return undefined;
+	} finally {
+		_parse_level--;
+	}
 };
-JSON6.stringify = JSON.stringify;
 
 //---------------------------------------------------------------------------
 //  Stringify
 //---------------------------------------------------------------------------
 
+/**
+ * @typedef {((key: string, value: unknown) => unknown) | Array<string|number> | null} Json6Replacer
+ */
+
+/**
+ * @typedef {object} Json6Stringifier
+ * @property {(o?: unknown, r?: Json6Replacer, s?: string|number|null, as?: string) => string|undefined} stringify
+ * @property {(q: string) => void} setQuote
+ * @property {boolean} ignoreNonEnumerable
+ * @property {boolean} sortKeys
+ */
+
+/** @type {Json6Stringifier|null} */
 JSON6.stringifierActive = null;
 JSON6.stringifier = function() {
 	const keywords = {	["true"]:true,["false"]:false,["null"]:null,["NaN"]:NaN,["Infinity"]:Infinity,["undefined"]:undefined };
 	let useQuote = '"';
 
 	let ignoreNonEnumerable = false;
+	// preserves the historical (sorted) output by default; set to `false` to
+	// emit keys in their own enumeration order instead.
+	let sortKeys = true;
 
 	return {
+		/**
+		 * @param {unknown} [o]
+		 * @param {Json6Replacer} [r]
+		 * @param {string|number|null} [s]
+		 * @param {string} [as]
+		 * @returns {string|undefined}
+		 */
 		stringify(o,r,s,as) { return stringify(this, o,r,s,as); },
+		/**
+		 * @param {string} q
+		 */
 		setQuote(q) { useQuote = q; },
 		get ignoreNonEnumerable() { return ignoreNonEnumerable; },
 		set ignoreNonEnumerable(val) { ignoreNonEnumerable = val; },
+		get sortKeys() { return sortKeys; },
+		set sortKeys(val) { sortKeys = val; },
 	};
 
+	/**
+	 * @param {string} s
+	 */
 	function getIdentifier(s) {
-		if( "number" === typeof s && !isNaN( s ) ) {
-			return ["'",s.toString(),"'"].join();
-		}
 		if( !s.length ) return useQuote+useQuote;
 		// should check also for if any non ident in string...
 		return ( ( s in keywords /* [ "true","false","null","NaN","Infinity","undefined"].find( keyword=>keyword===s )*/
@@ -1223,16 +1595,21 @@ JSON6.stringifier = function() {
 			|| /((\n|\r|\t)|[ #{}()<>!+\-*/.:,])/.test( s ) )?(useQuote + JSON6.escape(s) +useQuote):s );
 	}
 
+	/**
+	 * @param {Json6Stringifier} stringifier
+	 * @param {unknown} object
+	 * @param {Json6Replacer} [replacer]
+	 * @param {string|number|null} [space]
+	 * @param {string} [asField]
+	 * @returns {string|undefined}
+	 */
 	function stringify( stringifier, object, replacer, space, asField ) {
 		if( object === undefined ) return "undefined";
 		if( object === null ) return "null";
-		let gap;
-		let indent;
-		let i;
-		const spaceType = typeof space;
-		const repType = typeof replacer;
-		gap = "";
-		indent = "";
+		/** @type {string} */
+		let gap = "";
+		/** @type {string} */
+		let indent = "";
 		const stringifier_ = JSON6.stringifierActive;
 		JSON6.stringifierActive = stringifier;
 
@@ -1243,21 +1620,21 @@ JSON6.stringifier = function() {
 
 		// If the space parameter is a number, make an indent string containing that
 		// many spaces.
-		if (spaceType === "number") {
-			for (i = 0; i < space; i += 1) {
+		if (typeof space === "number") {
+			for (let i = 0; i < space; i += 1) {
 				indent += " ";
 			}
 
 		// If the space parameter is a string, it will be used as the indent string.
-		} else if (spaceType === "string") {
+		} else if (typeof space === "string") {
 			indent = space;
 		}
 
 		// If there is a replacer, it must be a function or an array.
 		// Otherwise, throw an error.
 		const rep = replacer;
-		if( replacer && repType !== "function"
-		    && ( repType !== "object"
+		if( replacer && typeof replacer !== "function"
+		    && ( typeof replacer !== "object"
 		       || typeof replacer.length !== "number"
 		   )) {
 			throw new Error("JSON6.stringify unknown replacer type.");
@@ -1270,16 +1647,26 @@ JSON6.stringifier = function() {
 
 
 		// from https://github.com/douglascrockford/JSON-js/blob/master/json2.js#L181
+		/**
+		 * @param {string} key
+		 * @param {Record<string, unknown>} holder
+		 * @returns {string|undefined}
+		 */
 		function str(key, holder) {
 			// Produce a string from holder[key].
-			let i;          // The loop counter.
-			let k;          // The member key.
-			let v;          // The member value.
-			let length;
 			const mind = gap;
-			let partial;
+			/** @type {unknown} */
 			let value = holder[key];
-			if( "string" === typeof value ) value = getIdentifier( value );
+			// A string *value* must always be quoted: unlike an object key,
+			//   a bareword here would parse back as an identifier/variable
+			//   reference rather than as the string itself, so `getIdentifier`
+			//   (which intentionally leaves identifier-shaped keys unquoted)
+			//   is not applicable to values. Using it here previously emitted
+			//   invalid, non-reparseable output for any identifier-shaped
+			//   string value (e.g. `"hello"` became the bare word `hello`).
+			if( "string" === typeof value ) {
+				value = useQuote + JSON6.escape( value ) + useQuote;
+			}
 
 			if( value !== undefined
 				&& value !== null
@@ -1305,7 +1692,7 @@ JSON6.stringifier = function() {
 				return '' + value;//useQuote+JSOX.escape( value )+useQuote;
 			case "boolean":
 				return String(value);
-			case "object":
+			case "object": {
 
 				//_DEBUG_STRINGIFY && console.log( "ENTERING OBJECT EMISSION WITH:", v );
 				//if( v ) return v;
@@ -1316,19 +1703,50 @@ JSON6.stringifier = function() {
 					return "null";
 				}
 
+				if( Array.isArray( value ) ) {
+					// Arrays used to fall through to the object path below and come out
+					// as {"0":..,"1":..}.  Holes stay holes ( [1,,3] ) and undefined stays
+					// undefined; both are JSON6 syntax and both parse back to what they were.
+					const arr = /** @type {unknown[]} */ (value);
+					const holder_ = /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (arr));
+					gap += indent;
+					/** @type {string[]} */
+					const items = [];
+					for( let i = 0; i < arr.length; i++ ) {
+						if( !( i in arr ) ) {
+							items.push( "" );
+							continue;
+						}
+						const v = str( String( i ), holder_ );
+						items.push( v === undefined ? "undefined" : v );
+					}
+					// a trailing hole needs its own comma, since "[1,]" parses as [1].
+					const trailingHole = arr.length > 0 && !( ( arr.length - 1 ) in arr );
+					const v = items.length === 0
+						? "[]"
+						: gap
+							? "[\n" + gap + items.join( ",\n" + gap ) + ( trailingHole ? "," : "" ) + "\n" + mind + "]"
+							: "[" + items.join( "," ) + ( trailingHole ? "," : "" ) + "]";
+					gap = mind;
+					return v;
+				}
+
+				const record = /** @type {Record<string, unknown>} */ (value);
+
 				// Make an array to hold the partial results of stringifying this object value.
 
 				gap += indent;
-				partial = [];
+				/** @type {string[]} */
+				const partial = [];
 
 				// If the replacer is an array, use it to select the members to be stringified.
 				if (rep && typeof rep === "object") {
-					length = rep.length;
+					const length = rep.length;
 					//_DEBUG_STRINGIFY && console.log( "Working through replacer" );
-					for (i = 0; i < length; i += 1) {
+					for (let i = 0; i < length; i += 1) {
 						if (typeof rep[i] === "string") {
-							k = rep[i];
-							v = str(k, value);
+							const k = /** @type {string} */ (rep[i]);
+							const v = str(k, record);
 							if (v) {
 								partial.push(getIdentifier(k) + (
 									(gap)
@@ -1341,32 +1759,37 @@ JSON6.stringifier = function() {
 				} else {
 
 					// Otherwise, iterate through all of the keys in the object.
+					/** @type {string[]} */
 					const keys = [];
 					//_DEBUG_STRINGIFY && console.log( "is something in something?", k, value );
-					for (k in value) {
+					for (const k in record) {
 						if( ignoreNonEnumerable )
-							if( !Object.prototype.propertyIsEnumerable.call( value, k ) ){
+							if( !Object.prototype.propertyIsEnumerable.call( record, k ) ){
 								//_DEBUG_STRINGIFY && console.log( "skipping non-enuerable?", k );
 								continue;
 							}
 
-						// sort properties into keys.
-						if (Object.prototype.hasOwnProperty.call(value, k)) {
-							let n;
-							for( n = 0; n < keys.length; n++ )
-								if( keys[n] > k ) {
-									keys.splice(n,0,k );
-									break;
-								}
-							if( n === keys.length )
+						if (Object.prototype.hasOwnProperty.call(record, k)) {
+							if( sortKeys ) {
+								// sort properties into keys.
+								let n;
+								for( n = 0; n < keys.length; n++ )
+									if( keys[n] > k ) {
+										keys.splice(n,0,k );
+										break;
+									}
+								if( n === keys.length )
+									keys.push(k);
+							} else {
 								keys.push(k);
+							}
 						}
 					}
 					//_DEBUG_STRINGIFY && console.log( "Expanding object keys:", v, keys );
 					for(let n = 0; n < keys.length; n++) {
-						k = keys[n];
-						if (Object.prototype.hasOwnProperty.call(value, k)) {
-							v = str(k, value);
+						const k = keys[n];
+						if (Object.prototype.hasOwnProperty.call(record, k)) {
+							const v = str(k, record);
 							if (v) {
 								partial.push(getIdentifier(k)+ (
 									(gap)
@@ -1381,7 +1804,7 @@ JSON6.stringifier = function() {
 				// Join all of the member texts together, separated with commas,
 				// and wrap them in braces.
 				//_DEBUG_STRINGIFY && console.log( "partial:", partial, protoConverter )
-				v = '' +
+				const v = '' +
 				        ( partial.length === 0
 				        ? "{}"
 				        : gap
@@ -1392,13 +1815,33 @@ JSON6.stringifier = function() {
 				//_DEBUG_STRINGIFY && console.log(" Resulting phrase from this part is:", v );
 				return v;
 			}
+			}
 		}
 	}
 };
 
-JSON6.stringify = function( object, replacer, space ) {
+/**
+ * @typedef {object} Json6StringifyOptions
+ * @property {boolean} [sortKeys] When `false`, object keys are emitted in their
+ *   own enumeration order instead of sorted. Defaults to `true`.
+ */
+
+/**
+ * @param {unknown} object
+ * @param {Json6Replacer} [replacer]
+ * @param {string|number} [space]
+ * @param {Json6StringifyOptions} [options]
+ * @returns {string|undefined}
+ */
+JSON6.stringify = function( object, replacer, space, options ) {
 	const stringifier = JSON6.stringifier();
+	if( options && options.sortKeys === false ) stringifier.sortKeys = false;
 	return stringifier.stringify( object, replacer, space );
 };
 
 JSON6.version = version;
+
+// CommonJS export; guarded so lib/json6.js can also be loaded directly with a
+// <script> tag, where JSON6 is simply left as a global.
+/* istanbul ignore next -- the non-CommonJS branch is only reachable from a browser <script> tag */
+if( typeof module === "object" && module && module.exports ) module.exports = JSON6;