		var jsonc = require('./lib/jsonc').jsonc;
		module.exports = jsonc;
		// adding circular ref to allow easy importing in both ES5/6 and TS projects
		module.exports.jsonc = jsonc;
		module.exports.safe = jsonc.safe;

+19

lib/helper.d.ts

		import * as mkdirp from 'mkdirp';
		import { IConfig, IStringifyOptions, Replacer } from './interfaces';
		declare const helper: {
		isObject(o: any): boolean;
		isPrimitive(value: any): boolean;
		strLog(value: any, pretty: boolean): string;
		getLogger(config: IConfig, pretty: boolean): Function;
		getStringifyOptions(options: IStringifyOptions \| Replacer, space: string \| number): IStringifyOptions;
		fs: any;
		mkdirp: typeof mkdirp;
		promise: {
		readFile: any;
		writeFile: any;
		mkdirp: any;
		};
		safeSync(fn: any): any;
		safeAsync(promise: Promise<any>): Promise<any>;
		};
		export { helper };

+116

lib/helper.js

		"use strict";
		var __assign = (this && this.__assign) \|\| function () {
		__assign = Object.assign \|\| function(t) {
		for (var s, i = 1, n = arguments.length; i < n; i++) {
		s = arguments[i];
		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		t[p] = s[p];
		}
		return t;
		};
		return __assign.apply(this, arguments);
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		// dep modules
		var fast_safe_stringify_1 = require("fast-safe-stringify");
		var fs = require("graceful-fs");
		var mkdirp = require("mkdirp");
		// vars
		var oproto = Object.prototype;
		// simple promisification. this won't work for callbacks with more than 2
		// args.
		function promisify(fn) {
		return function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		return new Promise(function (resolve, reject) {
		fn.apply(void 0, args.concat([function (err, result) {
		if (err) {
		reject(err);
		}
		else {
		resolve(result);
		}
		}]));
		});
		};
		}
		var defaultStringifyOpts = {
		replacer: null,
		space: 0,
		handleCircular: true
		};
		var helper = {
		isObject: function (o) {
		return oproto.toString.call(o) === '[object Object]';
		},
		isPrimitive: function (value) {
		var t = typeof value;
		return value === null
		\|\| value === undefined
		\|\| (t !== 'function' && t !== 'object');
		},
		strLog: function (value, pretty) {
		if (helper.isPrimitive(value))
		return value;
		var s = pretty ? ' ' : null;
		return fast_safe_stringify_1.default(value, null, s);
		},
		getLogger: function (config, pretty) {
		return function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		var stream = config.stream;
		var msg = args.map(function (arg) {
		if (arg instanceof Error) {
		stream = config.streamErr;
		return arg.stack
		/* istanbul ignore next */
		\|\| arg.message
		/* istanbul ignore next */
		\|\| String(arg);
		}
		return helper.strLog(arg, pretty);
		}).join(' ');
		stream.write(msg + '\n');
		};
		},
		getStringifyOptions: function (options, space) {
		if (helper.isObject(options)) {
		return __assign({}, defaultStringifyOpts, options); // as IStringifyOptions
		}
		if (typeof options === 'function' \|\| Array.isArray(options)) {
		return __assign({}, defaultStringifyOpts, { replacer: options, space: space });
		}
		return __assign({}, defaultStringifyOpts, { space: space });
		},
		fs: fs,
		mkdirp: mkdirp,
		promise: {
		readFile: promisify(fs.readFile),
		writeFile: promisify(fs.writeFile),
		mkdirp: promisify(mkdirp)
		},
		safeSync: function (fn) {
		return function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		try {
		return [null, fn.apply(void 0, args)];
		}
		catch (err) {
		return [err];
		}
		};
		},
		safeAsync: function (promise) {
		return promise.then(function (data) { return [null, data]; }).catch(function (err) { return [err]; });
		}
		};
		exports.helper = helper;

+24

lib/interfaces.d.ts

		/// <reference types="node" />
		export declare type Reviver = (key: string, value: any) => any;
		export declare type Replacer = (key: string, value: any) => any \| string[] \| number[];
		export interface IParseOptions {
		reviver?: Reviver;
		stripComments?: boolean;
		}
		export interface IStringifyOptions {
		replacer?: Replacer;
		space?: string \| number;
		handleCircular?: boolean;
		}
		export interface IReadOptions extends IParseOptions {
		}
		export interface IWriteOptions {
		mode?: number;
		autoPath?: boolean;
		replacer?: Replacer;
		space?: string \| number;
		}
		export interface IConfig {
		stream?: NodeJS.WriteStream;
		streamErr?: NodeJS.WriteStream;
		}

+2

lib/interfaces.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });

+808

lib/jsonc.d.ts

		import { IConfig, IParseOptions, IReadOptions, IStringifyOptions, IWriteOptions, Replacer, Reviver } from './interfaces';
		/**
		* JSON utility class that can handle comments and circular references; and
		* other extra functionality.
		* @class
		* @author Onur Yıldırım <onur@cutepilot.com>
		* @license MIT
		* @see {@link https://github.com/onury/jsonc\|GitHub Repo}
		* @see {@link https://github.com/onury/jsonc#related-modules\|Related Modules}
		*
		* @example
		* const jsonc = require('jsonc');
		* // or
		* import { jsonc } from 'jsonc';
		*
		* const result = jsonc.parse('// comments\n{ "key": "value" }');
		* console.log(result); // { key: "value" }
		*/
		declare class jsonc {
		/**
		* Configures `jsonc` object.
		*
		* @param {IConfig} cfg - Configurations.
		* @param {NodeJS.WriteStream} [stream] - Stream to write logs to. This is
		* used with `.log()` and `.logp()` methods.
		* @param {NodeJS.WriteStream} [streamErr] - Stream to write error logs to.
		* This is used with `.log()` and `.logp()` methods.
		*
		* @example
		* // Output logs to stdout but logs containing errors to a file.
		* jsonc.config({
		* stream: process.stdout,
		* streamErr: fs.createWriteStream('path/to/log.txt')
		* });
		* jsonc.log({ info: 'this is logged to console' });
		* jsonc.log(new Error('this is logged to file'));
		*/
		static config(cfg: IConfig): void;
		/**
		* Stringifies and logs the given arguments to console. This will
		* automatically handle circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		static log(...args: any[]): void;
		/**
		* Pretty version of `log()` method. Stringifies and logs the given
		* arguments to console, with indents. This will automatically handle
		* circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		static logp(...args: any[]): void;
		/**
		* Parses the given JSON string into a JavaScript object. The input string
		* can include comments.
		*
		* @param {string} str - JSON string to be parsed.
		* @param {IParseOptions\|Reviver} [options] - Either a parse options
		* object or a reviver function.
		* @param {Reviver} [options.reviver] - A function that can filter
		* and transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it returns
		* what it received, then the structure is not modified. If it returns
		* `undefined` then the member is deleted.
		* @param {Boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {any} - Parsed value.
		*
		* @throws {JSONError} - If JSON string is not valid. Note that any
		* comments within JSON are removed by default; so this will not throw for
		* comments unless you explicitly set `stripComments` to `false`.
		*
		* @example
		* const parsed = jsonc.parse('// comments\n{"success":true}\n');
		* console.log(parsed); // { success: true }
		*/
		static parse(str: string, options?: IParseOptions \| Reviver): any;
		/**
		* Outputs a JSON string from the given JavaScript object.
		*
		* @param {*} value - JavaScript value to be stringified.
		* @param {IStringifyOptions\|Replacer} [options] - Stringify options or a
		* replacer.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings or
		* numbers.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as `"\t"` or
		* `" "`), it contains the characters used to indent at each level.
		* @param {string\|number} [space] - This takes effect if second argument is
		* the `replacer` or a falsy value. This is for supporting the signature of
		* native `JSON.stringify()` method.
		* @param {boolean} [options.handleCircular=true] - Whether to handle
		* circular references (if any) by replacing their values with the string
		* `"[Circular]"`. You can also use a replacer function to replace or
		* remove circular references instead.
		*
		* @returns {string} - JSON string.
		*
		* @throws {Error} - If there are any circular references within the
		* original input. In this case, use `jsonc.safe.stringify()` method
		* instead.
		*
		* @example
		* const obj = { key: 'value' };
		* console.log(jsonc.stringify(obj)); // '{"key":"value"}'
		*
		* // pretty output with indents
		* let pretty = jsonc.stringify(obj, null, 2);
		* // equivalent to:
		* pretty = jsonc.stringify(obj, { reviver: null, space: 2 });
		* if (!err) console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		static stringify(value: any, optionsOrReplacer?: IStringifyOptions \| Replacer, space?: string \| number): string;
		/**
		* Specifies whether the given string has well-formed JSON structure.
		*
		* Note that, not all JSON-parsable strings are considered well-formed JSON
		* structures. JSON is built on two structures; a collection of name/value
		* pairs (object) or an ordered list of values (array).
		*
		* For example, `JSON.parse('true')` will parse successfully but
		* `jsonc.isJSON('true')` will return `false` since it has no object or
		* array structure.
		*
		* @param {string} str - String to be validated.
		* @param {boolean} [allowComments=false] - Whether comments should be
		* considered valid.
		*
		* @returns {boolean}
		*
		* @example
		* jsonc.isJSON('{"x":1}'); // true
		* jsonc.isJSON('true'); // false
		* jsonc.isJSON('[1, false, null]'); // true
		* jsonc.isJSON('string'); // false
		* jsonc.isJSON('null'); // false
		*/
		static isJSON(str: string, allowComments?: boolean): boolean;
		/**
		* Strips comments from the given JSON string.
		*
		* @param {string} str - JSON string.
		* @param {boolean} [whitespace=false] - Whether to replace comments with
		* whitespace instead of stripping them entirely.
		*
		* @returns {string} - Valid JSON string.
		*
		* @example
		* const str = jsonc.stripComments('// comments\n{"key":"value"}');
		* console.log(str); // '\n{"key":"value"}'
		*/
		static stripComments(str: string, whitespace?: boolean): string;
		/**
		* Uglifies the given JSON string.
		*
		* @param {string} str - JSON string to be uglified.
		* @returns {string} - Uglified JSON string.
		*
		* @example
		* const pretty = `
		* {
		* // comments...
		* "key": "value"
		* }
		* `;
		* const ugly = jsonc.uglify(pretty);
		* console.log(ugly); // '{"key":"value"}'
		*/
		static uglify(str: string): string;
		/**
		* Beautifies the given JSON string. Note that this will remove comments,
		* if any.
		*
		* @param {string} str - JSON string to be beautified.
		* @param {string\|number} [space=2] Specifies the indentation of nested
		* structures. If it is omitted, the text will be packed without extra
		* whitespace. If it is a number, it will specify the number of spaces to
		* indent at each level. If it is a string (such as "\t" or " "), it
		* contains the characters used to indent at each level.
		*
		* @returns {string} - Beautified JSON string.
		*
		* @example
		* const ugly = '{"key":"value"}';
		* const pretty = jsonc.beautify(ugly);
		* console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		static beautify(str: string, space?: string \| number): string;
		/**
		* Normalizes the given value by stringifying and parsing it back to a
		* Javascript object.
		*
		* @param {any} value
		* @param {Replacer} [replacer] - Determines how object values are
		* normalized for objects. It can be a function or an array of strings.
		*
		* @returns {any} - Normalized object.
		*
		* @example
		* const c = new SomeClass();
		* console.log(c.constructor.name); // "SomeClass"
		* const normalized = jsonc.normalize(c);
		* console.log(normalized.constructor.name); // "Object"
		*/
		static normalize(value: any, replacer?: Replacer): any;
		/**
		* Asynchronously reads a JSON file, strips UTF-8 BOM and parses the JSON
		* content.
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and its
		* return value is used instead of the original value. If it returns what
		* it received, then the structure is not modified. If it returns undefined
		* then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {Promise<any>} - Promise of the parsed JSON content as a
		* JavaScript object.
		*
		* @example <caption>Using async/await</caption>
		* (async () {
		* try {
		* const obj = await jsonc.read('path/to/file.json');
		* console.log(typeof obj); // "object"
		* } catch (err) {
		* console.log('Failed to read JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* jsonc.read('path/to/file.json')
		* .then(obj => {
		* console.log(typeof obj); // "object"
		* })
		* .catch(err => {
		* console.log('Failed to read JSON file');
		* });
		*/
		static read(filePath: string, options?: IReadOptions): Promise<any>;
		/**
		* Synchronously reads a JSON file, strips UTF-8 BOM and parses the JSON
		* content.
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and its
		* return value is used instead of the original value. If it returns what
		* it received, then the structure is not modified. If it returns undefined
		* then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {any} - Parsed JSON content as a JavaScript object.
		*
		* @example
		* const obj = jsonc.readSync('path/to/file.json');
		* // use try/catch block to handle errors. or better, use the safe version.
		* console.log(typeof obj); // "object"
		*/
		static readSync(filePath: string, options?: IReadOptions): any;
		/**
		* Asynchronously writes a JSON file from the given JavaScript object.
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		* @param {number} [options.mode=438] - FileSystem permission mode to be used when
		* writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to create path
		* directories if they don't exist. This will throw if set to `false` and
		* path does not exist.
		*
		* @returns {Promise<boolean>} - Always resolves with `true`, if no errors occur.
		*
		* @example <caption>Using async/await</caption>
		* (async () {
		* try {
		* await jsonc.write('path/to/file.json', data);
		* console.log('Successfully wrote JSON file');
		* } catch (err) {
		* console.log('Failed to write JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* jsonc.write('path/to/file.json', data)
		* .then(success => {
		* console.log('Successfully wrote JSON file');
		* })
		* .catch(err => {
		* console.log('Failed to write JSON file');
		* });
		*/
		static write(filePath: string, data: any, options?: IWriteOptions): Promise<boolean>;
		/**
		* Synchronously writes a JSON file from the given JavaScript object.
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		* @param {number} [options.mode=438] - FileSystem permission mode to be used when
		* writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to create path
		* directories if they don't exist. This will throw if set to `false` and
		* path does not exist.
		*
		* @returns {boolean} - Always returns `true`, if no errors occur.
		*
		* @example
		* const success = jsonc.writeSync('path/to/file.json');
		* // this will always return true. use try/catch block to handle errors. or better, use the safe version.
		* console.log('Successfully wrote JSON file');
		*/
		static writeSync(filePath: string, data: any, options?: IWriteOptions): boolean;
		}
		/**
		* Class that provides safe versions of `jsonc` methods. Safe methods provide a
		* way to easily handle errors without throwing; so that you don't need to use
		* try/catch blocks.
		*
		* Each method (except a few such as `.isJSON`), will return an array with the
		* first item being the `Error` instance caught. If successful, second item
		* will be the result.
		* @name jsonc.safe
		* @class
		*
		* @example
		* const { safe } = require('jsonc');
		* // or
		* import { safe as jsonc } from 'jsonc';
		*
		* const [err, result] = jsonc.parse('[invalid JSON}');
		* if (err) {
		* console.log(`Failed to parse JSON: ${err.message}`);
		* } else {
		* console.log(result);
		* }
		*/
		class jsoncSafe {
		/**
		* Configures `jsonc` object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.config()`.</blockquote>
		*
		* @name jsonc.safe.config
		* @function
		*
		* @param {IConfig} cfg - Configurations.
		* @param {NodeJS.WriteStream} [stream] - Stream to write logs to. This is
		* used with `.log()` and `.logp()` methods.
		* @param {NodeJS.WriteStream} [streamErr] - Stream to write error logs to.
		* This is used with `.log()` and `.logp()` methods.
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* // Output logs to stdout but logs containing errors to a file.
		* jsonc.config({
		* stream: process.stdout,
		* streamErr: fs.createWriteStream('path/to/log.txt')
		* });
		* jsonc.log({ info: 'this is logged to console' });
		* jsonc.log(new Error('this is logged to file'));
		*/
		static config(cfg: IConfig): void;
		/**
		* Stringifies and logs the given arguments to console. This will
		* automatically handle circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.log()`.</blockquote>
		* @name jsonc.safe.log
		* @function
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		static log(...args: any[]): void;
		/**
		* Pretty version of `log()` method. Stringifies and logs the given
		* arguments to console, with indents. This will automatically handle
		* circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.logp()`.</blockquote>
		* @name jsonc.safe.logp
		* @function
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		static logp(...args: any[]): void;
		/**
		* Safe version of `jsonc.parse()`. Parses the given string into a
		* JavaScript object.
		* @name jsonc.safe.parse
		* @function
		*
		* @param {string} str - JSON string to be parsed.
		* @param {IParseOptions\|Reviver} [options] - Either a parse options
		* object or a reviver function.
		* @param {Reviver} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns `undefined` then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will return the first
		* parameter as an error if this is set to `false` and the string
		* includes comments.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, result] = jsonc.parse('--invalid JSON--');
		* if (err) {
		* console.log('Failed to parse JSON: ' + err.message);
		* } else {
		* console.log(result);
		* }
		*/
		static parse(str: string, options?: IParseOptions \| Reviver): [Error] \| [null, any];
		/**
		* Safe version of `jsonc.stringify()`. Stringifies the given
		* JavaScript object. The input object can have circular references
		* which will return the string `"[Circular]"` for each circular
		* reference, by default. You can use a replacer function to replace or
		* remove circular references instead.
		* @name jsonc.safe.stringify
		* @function
		*
		* @param {*} value - JavaScript value to be stringified.
		* @param {IStringifyOptions\|Replacer} [options] - Stringify options or
		* a replacer.
		* @param {Replacer} [options.replacer] - Determines how object values
		* are stringified for objects. It can be an array of strings or
		* numbers; or a function with the following signature: `(key: string,
		* value: any) => any`.
		* @param {string\|number} [options.space] - Specifies the indentation
		* of nested structures. If it is omitted, the text will be packed
		* without extra whitespace. If it is a number, it will specify the
		* number of spaces to indent at each level. If it is a string (such as
		* `"\t"` or `" "`), it contains the characters used to indent at
		* each level.
		* @param {boolean} [options.handleCircular=true] - Whether to handle
		* circular references (if any) by replacing their values with the
		* string `"[Circular]"`. You can also use a replacer function to
		* replace or remove circular references instead.
		* @param {string\|number} [space] - This takes effect if second
		* argument is the `replacer` or a falsy value. Included for supporting
		* the signature of native `JSON.stringify()` method.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const obj = { key: 'value' };
		* let [err, str] = jsonc.stringify(obj);
		* if (!err) console.log(str); // '{"key":"value"}'
		*
		* // pretty output with indents
		* let [err, pretty] = jsonc.stringify(obj, null, 2);
		* // equivalent to:
		* [err, pretty] = jsonc.stringify(obj, { reviver: null, space: 2 });
		* if (!err) console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		static stringify(value: any, option?: IStringifyOptions): [Error] \| [null, string];
		static stringify(value: any, replacer: Replacer, space?: string \| number): [Error] \| [null, string];
		/**
		* Specifies whether the given string has well-formed JSON structure.
		*
		* Note that, not all JSON-parsable strings are considered well-formed JSON
		* structures. JSON is built on two structures; a collection of name/value
		* pairs (object) or an ordered list of values (array).
		*
		* For example, `JSON.parse('true')` will parse successfully but
		* `jsonc.isJSON('true')` will return `false` since it has no object or
		* array structure.
		*
		* <blockquote>This method is added for convenience. Works the same as
		* `jsonc.isJSON()`.</blockquote>
		* @name jsonc.safe.isJSON
		* @function
		*
		* @param {string} str - String to be validated.
		* @param {boolean} [allowComments=false] - Whether comments should be
		* considered valid.
		*
		* @returns {boolean}
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* jsonc.isJSON('{"x":1}'); // true
		* jsonc.isJSON('true'); // false
		* jsonc.isJSON('[1, false, null]'); // true
		* jsonc.isJSON('string'); // false
		* jsonc.isJSON('null'); // false
		*/
		static isJSON(str: string, allowComments?: boolean): boolean;
		/**
		* Strips comments from the given JSON string.
		* @name jsonc.safe.stripComments
		* @function
		*
		* @param {string} str - JSON string.
		* @param {boolean} [whitespace=false] - Whether to replace comments
		* with whitespace instead of stripping them entirely.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, str] = jsonc.stripComments('// comments\n{"key":"value"}');
		* if (!err) console.log(str); // '\n{"key":"value"}'
		*/
		static stripComments(str: string, whitespace?: boolean): string;
		/**
		* Safe version of `jsonc.uglify()`. Uglifies the given JSON string.
		* @name jsonc.safe.uglify
		* @function
		*
		* @param {string} str - JSON string to be uglified.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const pretty = `
		* {
		* // comments...
		* "key": "value"
		* }
		* `;
		* const [err, ugly] = jsonc.uglify(pretty);
		* if (!err) console.log(ugly); // '{"key":"value"}'
		*/
		static uglify(str: string): [Error] \| [null, string];
		/**
		* Safe version of `jsonc.beautify()`. Beautifies the given JSON
		* string. Note that this will remove comments, if any.
		* @name jsonc.safe.beautify
		* @function
		*
		* @param {string} str - JSON string to be beautified.
		* @param {string\|number} [space=2] Specifies the indentation of nested
		* structures. If it is omitted, the text will be packed without extra
		* whitespace. If it is a number, it will specify the number of spaces
		* to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const ugly = '{"key":"value"}';
		* const [err, pretty] = jsonc.beautify(ugly);
		* if (!err) console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		static beautify(str: string, space?: string \| number): [Error] \| [null, string];
		/**
		* Safe version of `jsonc.normalize()`. Normalizes the given value by
		* stringifying and parsing it back to a Javascript object.
		* @name jsonc.safe.normalize
		* @function
		*
		* @param {any} value
		* @param {Replacer} [replacer] - Determines how object values are
		* normalized for objects. It can be a function or an array of strings.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const c = new SomeClass();
		* console.log(c.constructor.name); // "SomeClass"
		* const [err, normalized] = jsonc.normalize(c);
		* if (err) {
		* console.log('Failed to normalize: ' + err.message);
		* } else {
		* console.log(normalized.constructor.name); // "Object"
		* }
		*/
		static normalize(value: any, replacer?: Replacer): [Error] \| [null, any];
		/**
		* Safe version of `jsonc.read()`. Asynchronously reads a JSON file,
		* strips UTF-8 BOM and parses the JSON content.
		* @name jsonc.safe.read
		* @function
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns undefined then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will fail if this is
		* set to `false` and the string includes comments.
		*
		* @returns {Promise<Array>} - Safe methods return an array with
		* the first item being the `Error` instance caught. If successful,
		* second item will be the result: `Promise<[Error, any]>`
		*
		* @example <caption>Using async/await (recommended)</caption>
		* import { safe as jsonc } from 'jsonc';
		* (async () {
		* const [err, obj] = await jsonc.read('path/to/file.json');
		* if (err) {
		* console.log('Failed to read JSON file');
		* } catch (err) {
		* console.log(typeof obj); // "object"
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* import { safe as jsonc } from 'jsonc';
		* jsonc.read('path/to/file.json')
		* .then([err, obj] => {
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log(typeof obj); // "object"
		* }
		* })
		* // .catch(err => {}); // this is never invoked when safe version is used.
		*/
		static read(filePath: string, options?: IReadOptions): Promise<[Error] \| [null, any]>;
		/**
		* Safe version of `jsonc.readSync()`. Synchronously reads a JSON file,
		* strips UTF-8 BOM and parses the JSON content.
		* @name jsonc.safe.readSync
		* @function
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns undefined then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will fail if this is
		* set to `false` and the string includes comments.
		*
		* @returns {Array} - Safe methods return an array with
		* the first item being the `Error` instance caught. If successful,
		* second item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, obj] = jsonc.readSync('path/to/file.json');
		* if (!err) console.log(typeof obj); // "object"
		*/
		static readSync(filePath: string, options?: IReadOptions): [Error] \| [null, any];
		/**
		* Safe version of `jsonc.write()`. Asynchronously writes a JSON file
		* from the given JavaScript object.
		* @name jsonc.safe.write
		* @function
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values
		* are stringified for objects. It can be a function or an array of
		* strings.
		* @param {string\|number} [options.space] - Specifies the indentation
		* of nested structures. If it is omitted, the text will be packed
		* without extra whitespace. If it is a number, it will specify the
		* number of spaces to indent at each level. If it is a string (such as
		* "\t" or " "), it contains the characters used to indent at each
		* level.
		* @param {number} [options.mode=438] - FileSystem permission mode to
		* be used when writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to
		* create path directories if they don't exist. This will throw if set
		* to `false` and path does not exist.
		*
		* @returns {Promise<Array>} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful,
		* second item will be the result: `Promise<[Error, boolean]>`
		*
		* @example <caption>Using async/await (recommended)</caption>
		* import { safe as jsonc } from 'jsonc';
		* (async () {
		* const [err, success] = await jsonc.write('path/to/file.json', data);
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log('Successfully wrote JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* import { safe as jsonc } from 'jsonc';
		* jsonc.write('path/to/file.json', data)
		* .then([err, obj] => {
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log('Successfully wrote JSON file');
		* }
		* })
		* // .catch(err => {}); // this is never invoked when safe version is used.
		*/
		static write(filePath: string, data: any, options?: IWriteOptions): Promise<[Error] \| [null, boolean]>;
		/**
		* Safe version of `jsonc.writeSync()`. Synchronously writes a JSON
		* file from the given JavaScript object.
		* @name jsonc.safe.writeSync
		* @function
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values
		* are stringified for objects. It can be a function or an array of
		* strings.
		* @param {string\|number} [options.space] - Specifies the indentation
		* of nested structures. If it is omitted, the text will be packed
		* without extra whitespace. If it is a number, it will specify the
		* number of spaces to indent at each level. If it is a string (such as
		* "\t" or " "), it contains the characters used to indent at each
		* level.
		* @param {number} [options.mode=438] - FileSystem permission mode to
		* be used when writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to
		* create path directories if they don't exist. This will throw if set
		* to `false` and path does not exist.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, boolean]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, obj] = jsonc.writeSync('path/to/file.json');
		* if (!err) console.log(typeof obj); // "object"
		*/
		static writeSync(filePath: string, data: any, options?: IWriteOptions): [Error] \| [null, boolean];
		}
		declare namespace jsonc {
		const safe: typeof jsoncSafe;
		}
		export { jsonc };

+21

LICENSE

		The MIT License

		Copyright (c) 2018, Onur Yıldırım <onur@cutepilot.com>. All rights reserved.

		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.

+86

README.md

		# jsonc

		[![build-status](https://img.shields.io/travis/onury/jsonc.svg?branch=master&style=flat-square)](https://travis-ci.org/onury/jsonc)
		[![coverage-status](https://coveralls.io/repos/github/onury/jsonc/badge.svg?branch=master&style=flat-square)](https://coveralls.io/github/onury/jsonc?branch=master)
		[![npm](http://img.shields.io/npm/v/jsonc.svg?style=flat-square)](https://www.npmjs.com/package/jsonc)
		[![release](https://img.shields.io/github/release/onury/jsonc.svg?style=flat-square)](https://github.com/onury/jsonc)
		[![dependencies](https://david-dm.org/onury/jsonc.svg?style=flat-square)](https://david-dm.org/onury/jsonc)
		[![license](http://img.shields.io/npm/l/jsonc.svg?style=flat-square)](https://github.com/onury/jsonc/blob/master/LICENSE)
		[![maintained](https://img.shields.io/maintenance/yes/2018.svg?style=flat-square)](https://github.com/onury/jsonc/graphs/punch-card)

		> © 2018, Onur Yıldırım ([@onury](https://github.com/onury)). MIT License.

		Everything you need in JSON land.

		`npm i jsonc`

		## Features

		- Parse JSON with comments.
		- Stringify objects with circular references.
		- Safely parse / stringify without try/catch blocks.
		- Read and auto-parse JSON files gracefully, sync or async (with promises).
		- Auto-stringify and write JSON files gracefully, sync or async (with promises).
		- Strips UTF-8 BOM.
		- Log objects as JSON (without worrying about errors).
		- Uglify/beautify JSON strings.
		- More helpful JSON errors.
		- Friendly API.
		- TypeScript support.

		## Usage

		See the concise [API reference][docs-api].

		```js
		const jsonc = require('jsonc');
		// or
		import { jsonc } from 'jsonc';
		```

		This is safe for JSON with comments:
		```js
		jsonc.parse('// comment\n{"data": /* comment */ "value"}\n'); // » { data: 'value' }
		```

		And this is safe for circular references:
		```js
		const obj = { x: 1 };
		obj.y = obj; // circular
		jsonc.stringify(obj); // » { x: 1, y: '[Circular]' }
		```

		But this is seriously safe:
		```js
		// safe version of every method
		const jsonc = require('jsonc').safe;
		// or
		import { safe as jsonc } from 'jsonc';

		const [err, result] = jsonc.parse('[invalid JSON}');
		if (err) {
		console.log(`Failed to parse JSON: ${err.message}`);
		} else {
		console.log(result);
		}
		```

		## Documentation

		See the concise [API reference][docs-api].

		## Change Log

		- v1.0.0 (2018-10-18)
		+ Initial release.


		## License
		MIT.


		[docs-api]:https://onury.io/jsonc/api
		[strip-json-comments]:https://github.com/sindresorhus/strip-json-comments
		[json-stringify-safe]:https://github.com/isaacs/json-stringify-safe
		[parse-json]:https://github.com/sindresorhus/parse-json
		[fs-extra]:https://www.npmjs.com/package/fs-extra

+973

-86

lib/jsonc.js

		@@ -1,89 +0,976 @@
		/* @author mayank */

		var _fs = require('fs');

		// I have just added comments in default json files and named it as jsonc
		// this file contains parser for jsonc
		// It uses default JSON parser after removing comments from file
		// this will remove the comments and return jsonc parsed javascript object.
		// as jsonc is basically json (json + comments) so it can parse json string also.
		exports.parse = function parse(jsonc_string) {
		var json_str = this.removeComments(jsonc_string, true); // comments removed
		return JSON.parse(json_str);
		"use strict";
		/* tslint:disable:class-name no-require-imports no-default-export max-line-length interface-name max-classes-per-file max-file-line-count */
		var __assign = (this && this.__assign) \|\| function () {
		__assign = Object.assign \|\| function(t) {
		for (var s, i = 1, n = arguments.length; i < n; i++) {
		s = arguments[i];
		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		t[p] = s[p];
		}
		return t;
		};
		return __assign.apply(this, arguments);
		};

		// remove comments from jsonc file and write file as json
		// TODO: Implement this function
		exports.exportAsJSON = function exportAsJSON(filePath, outputPath) {
		var jsonc_string = _fs.readFileSync(filePath, "utf8");
		var json_str = this.removeComments(jsonc_string, true);
		// try {
		// JSON.parse(json_str);
		// } catch(e) {
		// console.log(e.message);
		// }
		_fs.writeFileSync(outputPath, json_str, "utf8");
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};

		// minify default is false
		exports.removeComments = function removeComments(json, minify) {

		minify = minify \|\| false; // minify output file

		var tokenizer = /"\|(\/\)\|(\\/)\|(\/\/)\|\n\|\r/g,
		in_string = false,
		in_multiline_comment = false,
		in_singleline_comment = false,
		tmp, tmp2, new_str = [], ns = 0, from = 0, lc, rc
		;

		tokenizer.lastIndex = 0;

		while (tmp = tokenizer.exec(json)) {
		lc = RegExp.leftContext;
		rc = RegExp.rightContext;
		if (!in_multiline_comment && !in_singleline_comment) {
		tmp2 = lc.substring(from);
		if (!in_string) {
		tmp2 = tmp2.replace(/(\n\|\r\|\s)*/g,"");
		}
		new_str[ns++] = tmp2;
		}
		from = tokenizer.lastIndex;

		if (tmp[0] == "\"" && !in_multiline_comment && !in_singleline_comment) {
		tmp2 = lc.match(/(\\)*$/);
		if (!in_string \|\| !tmp2 \|\| (tmp2[0].length % 2) == 0) { // start of string with ", or unescaped " character found to end string
		in_string = !in_string;
		}
		from--; // include " character in next catch
		rc = json.substring(from);
		}
		else if (tmp[0] == "/*" && !in_string && !in_multiline_comment && !in_singleline_comment) {
		in_multiline_comment = true;
		}
		else if (tmp[0] == "*/" && !in_string && in_multiline_comment && !in_singleline_comment) {
		in_multiline_comment = false;
		}
		else if (tmp[0] == "//" && !in_string && !in_multiline_comment && !in_singleline_comment) {
		in_singleline_comment = true;
		}
		else if ((tmp[0] == "\n" \|\| tmp[0] == "\r") && !in_string && !in_multiline_comment && in_singleline_comment) {
		in_singleline_comment = false;
		}
		else if (!in_multiline_comment && !in_singleline_comment && !(/\n\|\r\|\s/.test(tmp[0]))) {
		new_str[ns++] = tmp[0];
		}
		}
		new_str[ns++] = rc;

		var json_str_minified = new_str.join(""); // comments removed + minified

		if (!minify) {
		var json_parsed = JSON.parse(json_str_minified);
		var json_str_non_minified = JSON.stringify(json_parsed, null, 4);
		return json_str_non_minified;
		}

		return json_str_minified;
		var __generator = (this && this.__generator) \|\| function (thisArg, body) {
		var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
		return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		function verb(n) { return function (v) { return step([n, v]); }; }
		function step(op) {
		if (f) throw new TypeError("Generator is already executing.");
		while (_) try {
		if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] \|\| ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		if (y = 0, t) op = [op[0] & 2, t.value];
		switch (op[0]) {
		case 0: case 1: t = op; break;
		case 4: _.label++; return { value: op[1], done: false };
		case 5: _.label++; y = op[1]; op = [0]; continue;
		case 7: op = _.ops.pop(); _.trys.pop(); continue;
		default:
		if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 \|\| op[0] === 2)) { _ = 0; continue; }
		if (op[0] === 3 && (!t \|\| (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		if (t[2]) _.ops.pop();
		_.trys.pop(); continue;
		}
		op = body.call(thisArg, _);
		} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		}
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		// core modules
		var path = require("path");
		// dep modules
		var fast_safe_stringify_1 = require("fast-safe-stringify");
		var parseJson = require("parse-json");
		var stripBOM = require("strip-bom");
		var stripJsonComments = require("strip-json-comments");
		// own modules
		var helper_1 = require("./helper");
		// constants, variables
		var fs = helper_1.helper.fs, mkdirp = helper_1.helper.mkdirp, promise = helper_1.helper.promise, safeSync = helper_1.helper.safeSync, safeAsync = helper_1.helper.safeAsync;
		var logger;
		var prettyLogger;
		/**
		* JSON utility class that can handle comments and circular references; and
		* other extra functionality.
		* @class
		* @author Onur Yıldırım <onur@cutepilot.com>
		* @license MIT
		* @see {@link https://github.com/onury/jsonc\|GitHub Repo}
		* @see {@link https://github.com/onury/jsonc#related-modules\|Related Modules}
		*
		* @example
		* const jsonc = require('jsonc');
		* // or
		* import { jsonc } from 'jsonc';
		*
		* const result = jsonc.parse('// comments\n{ "key": "value" }');
		* console.log(result); // { key: "value" }
		*/
		var jsonc = /** @class */ (function () {
		function jsonc() {
		}
		/**
		* Configures `jsonc` object.
		*
		* @param {IConfig} cfg - Configurations.
		* @param {NodeJS.WriteStream} [stream] - Stream to write logs to. This is
		* used with `.log()` and `.logp()` methods.
		* @param {NodeJS.WriteStream} [streamErr] - Stream to write error logs to.
		* This is used with `.log()` and `.logp()` methods.
		*
		* @example
		* // Output logs to stdout but logs containing errors to a file.
		* jsonc.config({
		* stream: process.stdout,
		* streamErr: fs.createWriteStream('path/to/log.txt')
		* });
		* jsonc.log({ info: 'this is logged to console' });
		* jsonc.log(new Error('this is logged to file'));
		*/
		jsonc.config = function (cfg) {
		var conf = __assign({ stream: process.stdout, streamErr: process.stderr }, (cfg \|\| {}));
		logger = helper_1.helper.getLogger(conf, false);
		prettyLogger = helper_1.helper.getLogger(conf, true);
		};
		/**
		* Stringifies and logs the given arguments to console. This will
		* automatically handle circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		jsonc.log = function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		logger.apply(void 0, args);
		};
		/**
		* Pretty version of `log()` method. Stringifies and logs the given
		* arguments to console, with indents. This will automatically handle
		* circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		jsonc.logp = function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		prettyLogger.apply(void 0, args);
		};
		/**
		* Parses the given JSON string into a JavaScript object. The input string
		* can include comments.
		*
		* @param {string} str - JSON string to be parsed.
		* @param {IParseOptions\|Reviver} [options] - Either a parse options
		* object or a reviver function.
		* @param {Reviver} [options.reviver] - A function that can filter
		* and transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it returns
		* what it received, then the structure is not modified. If it returns
		* `undefined` then the member is deleted.
		* @param {Boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {any} - Parsed value.
		*
		* @throws {JSONError} - If JSON string is not valid. Note that any
		* comments within JSON are removed by default; so this will not throw for
		* comments unless you explicitly set `stripComments` to `false`.
		*
		* @example
		* const parsed = jsonc.parse('// comments\n{"success":true}\n');
		* console.log(parsed); // { success: true }
		*/
		jsonc.parse = function (str, options) {
		var opts = typeof options === 'function'
		? { reviver: options }
		: (options \|\| {});
		if (opts.stripComments !== false)
		str = stripJsonComments(str, { whitespace: false });
		return parseJson(str, opts.reviver);
		};
		/**
		* Outputs a JSON string from the given JavaScript object.
		*
		* @param {*} value - JavaScript value to be stringified.
		* @param {IStringifyOptions\|Replacer} [options] - Stringify options or a
		* replacer.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings or
		* numbers.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as `"\t"` or
		* `" "`), it contains the characters used to indent at each level.
		* @param {string\|number} [space] - This takes effect if second argument is
		* the `replacer` or a falsy value. This is for supporting the signature of
		* native `JSON.stringify()` method.
		* @param {boolean} [options.handleCircular=true] - Whether to handle
		* circular references (if any) by replacing their values with the string
		* `"[Circular]"`. You can also use a replacer function to replace or
		* remove circular references instead.
		*
		* @returns {string} - JSON string.
		*
		* @throws {Error} - If there are any circular references within the
		* original input. In this case, use `jsonc.safe.stringify()` method
		* instead.
		*
		* @example
		* const obj = { key: 'value' };
		* console.log(jsonc.stringify(obj)); // '{"key":"value"}'
		*
		* // pretty output with indents
		* let pretty = jsonc.stringify(obj, null, 2);
		* // equivalent to:
		* pretty = jsonc.stringify(obj, { reviver: null, space: 2 });
		* if (!err) console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		jsonc.stringify = function (value, optionsOrReplacer, space) {
		var opts = helper_1.helper.getStringifyOptions(optionsOrReplacer, space);
		return opts.handleCircular
		? fast_safe_stringify_1.default(value, opts.replacer, opts.space)
		: JSON.stringify(value, opts.replacer, opts.space);
		};
		/**
		* Specifies whether the given string has well-formed JSON structure.
		*
		* Note that, not all JSON-parsable strings are considered well-formed JSON
		* structures. JSON is built on two structures; a collection of name/value
		* pairs (object) or an ordered list of values (array).
		*
		* For example, `JSON.parse('true')` will parse successfully but
		* `jsonc.isJSON('true')` will return `false` since it has no object or
		* array structure.
		*
		* @param {string} str - String to be validated.
		* @param {boolean} [allowComments=false] - Whether comments should be
		* considered valid.
		*
		* @returns {boolean}
		*
		* @example
		* jsonc.isJSON('{"x":1}'); // true
		* jsonc.isJSON('true'); // false
		* jsonc.isJSON('[1, false, null]'); // true
		* jsonc.isJSON('string'); // false
		* jsonc.isJSON('null'); // false
		*/
		jsonc.isJSON = function (str, allowComments) {
		if (allowComments === void 0) { allowComments = false; }
		if (typeof str !== 'string')
		return false;
		var _a = jsonc.safe.parse(str, { stripComments: allowComments }), err = _a[0], result = _a[1];
		return !err && (helper_1.helper.isObject(result) \|\| Array.isArray(result));
		};
		/**
		* Strips comments from the given JSON string.
		*
		* @param {string} str - JSON string.
		* @param {boolean} [whitespace=false] - Whether to replace comments with
		* whitespace instead of stripping them entirely.
		*
		* @returns {string} - Valid JSON string.
		*
		* @example
		* const str = jsonc.stripComments('// comments\n{"key":"value"}');
		* console.log(str); // '\n{"key":"value"}'
		*/
		jsonc.stripComments = function (str, whitespace) {
		if (whitespace === void 0) { whitespace = false; }
		return stripJsonComments(str, { whitespace: whitespace });
		};
		/**
		* Uglifies the given JSON string.
		*
		* @param {string} str - JSON string to be uglified.
		* @returns {string} - Uglified JSON string.
		*
		* @example
		* const pretty = `
		* {
		* // comments...
		* "key": "value"
		* }
		* `;
		* const ugly = jsonc.uglify(pretty);
		* console.log(ugly); // '{"key":"value"}'
		*/
		jsonc.uglify = function (str) {
		return jsonc.stringify(jsonc.parse(str, { stripComments: true }));
		};
		/**
		* Beautifies the given JSON string. Note that this will remove comments,
		* if any.
		*
		* @param {string} str - JSON string to be beautified.
		* @param {string\|number} [space=2] Specifies the indentation of nested
		* structures. If it is omitted, the text will be packed without extra
		* whitespace. If it is a number, it will specify the number of spaces to
		* indent at each level. If it is a string (such as "\t" or " "), it
		* contains the characters used to indent at each level.
		*
		* @returns {string} - Beautified JSON string.
		*
		* @example
		* const ugly = '{"key":"value"}';
		* const pretty = jsonc.beautify(ugly);
		* console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		jsonc.beautify = function (str, space) {
		if (space === void 0) { space = 2; }
		if (!space)
		space = 2;
		return jsonc.stringify(jsonc.parse(str), { space: space });
		};
		/**
		* Normalizes the given value by stringifying and parsing it back to a
		* Javascript object.
		*
		* @param {any} value
		* @param {Replacer} [replacer] - Determines how object values are
		* normalized for objects. It can be a function or an array of strings.
		*
		* @returns {any} - Normalized object.
		*
		* @example
		* const c = new SomeClass();
		* console.log(c.constructor.name); // "SomeClass"
		* const normalized = jsonc.normalize(c);
		* console.log(normalized.constructor.name); // "Object"
		*/
		jsonc.normalize = function (value, replacer) {
		return jsonc.parse(jsonc.stringify(value, { replacer: replacer }));
		};
		/**
		* Asynchronously reads a JSON file, strips UTF-8 BOM and parses the JSON
		* content.
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and its
		* return value is used instead of the original value. If it returns what
		* it received, then the structure is not modified. If it returns undefined
		* then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {Promise<any>} - Promise of the parsed JSON content as a
		* JavaScript object.
		*
		* @example <caption>Using async/await</caption>
		* (async () {
		* try {
		* const obj = await jsonc.read('path/to/file.json');
		* console.log(typeof obj); // "object"
		* } catch (err) {
		* console.log('Failed to read JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* jsonc.read('path/to/file.json')
		* .then(obj => {
		* console.log(typeof obj); // "object"
		* })
		* .catch(err => {
		* console.log('Failed to read JSON file');
		* });
		*/
		jsonc.read = function (filePath, options) {
		return __awaiter(this, void 0, void 0, function () {
		var opts, data;
		return __generator(this, function (_a) {
		switch (_a.label) {
		case 0:
		opts = __assign({ reviver: null, stripComments: true }, (options \|\| {}));
		return [4 /yield/, promise.readFile(filePath, 'utf8')];
		case 1:
		data = _a.sent();
		if (opts.stripComments !== false)
		data = stripJsonComments(data);
		return [2 /return/, parseJson(stripBOM(data), opts.reviver, filePath)];
		}
		});
		});
		};
		/**
		* Synchronously reads a JSON file, strips UTF-8 BOM and parses the JSON
		* content.
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and its
		* return value is used instead of the original value. If it returns what
		* it received, then the structure is not modified. If it returns undefined
		* then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will throw if this is set to
		* `false` and the string includes comments.
		*
		* @returns {any} - Parsed JSON content as a JavaScript object.
		*
		* @example
		* const obj = jsonc.readSync('path/to/file.json');
		* // use try/catch block to handle errors. or better, use the safe version.
		* console.log(typeof obj); // "object"
		*/
		jsonc.readSync = function (filePath, options) {
		var opts = __assign({ reviver: null, stripComments: true }, (options \|\| {}));
		var data = fs.readFileSync(filePath, 'utf8');
		if (opts.stripComments !== false)
		data = stripJsonComments(data);
		return parseJson(stripBOM(data), opts.reviver, filePath);
		};
		/**
		* Asynchronously writes a JSON file from the given JavaScript object.
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		* @param {number} [options.mode=438] - FileSystem permission mode to be used when
		* writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to create path
		* directories if they don't exist. This will throw if set to `false` and
		* path does not exist.
		*
		* @returns {Promise<boolean>} - Always resolves with `true`, if no errors occur.
		*
		* @example <caption>Using async/await</caption>
		* (async () {
		* try {
		* await jsonc.write('path/to/file.json', data);
		* console.log('Successfully wrote JSON file');
		* } catch (err) {
		* console.log('Failed to write JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* jsonc.write('path/to/file.json', data)
		* .then(success => {
		* console.log('Successfully wrote JSON file');
		* })
		* .catch(err => {
		* console.log('Failed to write JSON file');
		* });
		*/
		jsonc.write = function (filePath, data, options) {
		return __awaiter(this, void 0, void 0, function () {
		var opts, content;
		return __generator(this, function (_a) {
		switch (_a.label) {
		case 0:
		opts = __assign({ replacer: null, space: 0, mode: 438, autoPath: true }, (options \|\| {}));
		if (!opts.autoPath) return [3 /break/, 2];
		return [4 /yield/, promise.mkdirp(path.dirname(filePath), { fs: fs })];
		case 1:
		_a.sent();
		_a.label = 2;
		case 2:
		content = JSON.stringify(data, opts.replacer, opts.space);
		return [4 /yield/, promise.writeFile(filePath, content + "\n", {
		mode: opts.mode,
		encoding: 'utf8'
		})];
		case 3:
		_a.sent();
		return [2 /return/, true];
		}
		});
		});
		};
		/**
		* Synchronously writes a JSON file from the given JavaScript object.
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values are
		* stringified for objects. It can be a function or an array of strings.
		* @param {string\|number} [options.space] - Specifies the indentation of
		* nested structures. If it is omitted, the text will be packed without
		* extra whitespace. If it is a number, it will specify the number of
		* spaces to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		* @param {number} [options.mode=438] - FileSystem permission mode to be used when
		* writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to create path
		* directories if they don't exist. This will throw if set to `false` and
		* path does not exist.
		*
		* @returns {boolean} - Always returns `true`, if no errors occur.
		*
		* @example
		* const success = jsonc.writeSync('path/to/file.json');
		* // this will always return true. use try/catch block to handle errors. or better, use the safe version.
		* console.log('Successfully wrote JSON file');
		*/
		jsonc.writeSync = function (filePath, data, options) {
		var opts = __assign({ replacer: null, space: 0, mode: 438, autoPath: true }, (options \|\| {}));
		if (opts.autoPath)
		mkdirp.sync(path.dirname(filePath), { fs: fs });
		var content = JSON.stringify(data, opts.replacer, opts.space);
		fs.writeFileSync(filePath, content + "\n", {
		mode: opts.mode,
		encoding: 'utf8'
		});
		return true;
		};
		return jsonc;
		}());
		exports.jsonc = jsonc;
		/**
		* Class that provides safe versions of `jsonc` methods. Safe methods provide a
		* way to easily handle errors without throwing; so that you don't need to use
		* try/catch blocks.
		*
		* Each method (except a few such as `.isJSON`), will return an array with the
		* first item being the `Error` instance caught. If successful, second item
		* will be the result.
		* @name jsonc.safe
		* @class
		*
		* @example
		* const { safe } = require('jsonc');
		* // or
		* import { safe as jsonc } from 'jsonc';
		*
		* const [err, result] = jsonc.parse('[invalid JSON}');
		* if (err) {
		* console.log(`Failed to parse JSON: ${err.message}`);
		* } else {
		* console.log(result);
		* }
		*/
		var jsoncSafe = /** @class */ (function () {
		function jsoncSafe() {
		}
		/**
		* Configures `jsonc` object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.config()`.</blockquote>
		*
		* @name jsonc.safe.config
		* @function
		*
		* @param {IConfig} cfg - Configurations.
		* @param {NodeJS.WriteStream} [stream] - Stream to write logs to. This is
		* used with `.log()` and `.logp()` methods.
		* @param {NodeJS.WriteStream} [streamErr] - Stream to write error logs to.
		* This is used with `.log()` and `.logp()` methods.
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* // Output logs to stdout but logs containing errors to a file.
		* jsonc.config({
		* stream: process.stdout,
		* streamErr: fs.createWriteStream('path/to/log.txt')
		* });
		* jsonc.log({ info: 'this is logged to console' });
		* jsonc.log(new Error('this is logged to file'));
		*/
		jsoncSafe.config = function (cfg) {
		jsonc.config(cfg);
		};
		/**
		* Stringifies and logs the given arguments to console. This will
		* automatically handle circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.log()`.</blockquote>
		* @name jsonc.safe.log
		* @function
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		jsoncSafe.log = function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		logger.apply(void 0, args);
		};
		/**
		* Pretty version of `log()` method. Stringifies and logs the given
		* arguments to console, with indents. This will automatically handle
		* circular references; so it won't throw.
		*
		* If an `Error` instance is passed, it will log the `.stack` property on
		* the instance, without stringifying the object.
		*
		* <blockquote>This method is added for convenience. Works the same as `jsonc.logp()`.</blockquote>
		* @name jsonc.safe.logp
		* @function
		*
		* @param {...any[]} [args] - Arguments to be logged.
		* @returns {void}
		*/
		jsoncSafe.logp = function () {
		var args = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		args[_i] = arguments[_i];
		}
		prettyLogger.apply(void 0, args);
		};
		/**
		* Safe version of `jsonc.parse()`. Parses the given string into a
		* JavaScript object.
		* @name jsonc.safe.parse
		* @function
		*
		* @param {string} str - JSON string to be parsed.
		* @param {IParseOptions\|Reviver} [options] - Either a parse options
		* object or a reviver function.
		* @param {Reviver} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns `undefined` then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will return the first
		* parameter as an error if this is set to `false` and the string
		* includes comments.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, result] = jsonc.parse('--invalid JSON--');
		* if (err) {
		* console.log('Failed to parse JSON: ' + err.message);
		* } else {
		* console.log(result);
		* }
		*/
		jsoncSafe.parse = function (str, options) {
		return safeSync(jsonc.parse)(str, options);
		};
		jsoncSafe.stringify = function (value, optionsOrReplacer, space) {
		var opts = helper_1.helper.getStringifyOptions(optionsOrReplacer, space);
		try {
		return [null, fast_safe_stringify_1.default(value, opts.replacer, opts.space)];
		}
		catch (err) {
		return [err];
		}
		};
		/**
		* Specifies whether the given string has well-formed JSON structure.
		*
		* Note that, not all JSON-parsable strings are considered well-formed JSON
		* structures. JSON is built on two structures; a collection of name/value
		* pairs (object) or an ordered list of values (array).
		*
		* For example, `JSON.parse('true')` will parse successfully but
		* `jsonc.isJSON('true')` will return `false` since it has no object or
		* array structure.
		*
		* <blockquote>This method is added for convenience. Works the same as
		* `jsonc.isJSON()`.</blockquote>
		* @name jsonc.safe.isJSON
		* @function
		*
		* @param {string} str - String to be validated.
		* @param {boolean} [allowComments=false] - Whether comments should be
		* considered valid.
		*
		* @returns {boolean}
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* jsonc.isJSON('{"x":1}'); // true
		* jsonc.isJSON('true'); // false
		* jsonc.isJSON('[1, false, null]'); // true
		* jsonc.isJSON('string'); // false
		* jsonc.isJSON('null'); // false
		*/
		jsoncSafe.isJSON = function (str, allowComments) {
		if (allowComments === void 0) { allowComments = false; }
		return jsonc.isJSON(str, allowComments);
		};
		/**
		* Strips comments from the given JSON string.
		* @name jsonc.safe.stripComments
		* @function
		*
		* @param {string} str - JSON string.
		* @param {boolean} [whitespace=false] - Whether to replace comments
		* with whitespace instead of stripping them entirely.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, str] = jsonc.stripComments('// comments\n{"key":"value"}');
		* if (!err) console.log(str); // '\n{"key":"value"}'
		*/
		jsoncSafe.stripComments = function (str, whitespace) {
		if (whitespace === void 0) { whitespace = false; }
		return safeSync(stripJsonComments)(str, { whitespace: whitespace });
		};
		/**
		* Safe version of `jsonc.uglify()`. Uglifies the given JSON string.
		* @name jsonc.safe.uglify
		* @function
		*
		* @param {string} str - JSON string to be uglified.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const pretty = `
		* {
		* // comments...
		* "key": "value"
		* }
		* `;
		* const [err, ugly] = jsonc.uglify(pretty);
		* if (!err) console.log(ugly); // '{"key":"value"}'
		*/
		jsoncSafe.uglify = function (str) {
		return safeSync(jsonc.uglify)(str);
		};
		/**
		* Safe version of `jsonc.beautify()`. Beautifies the given JSON
		* string. Note that this will remove comments, if any.
		* @name jsonc.safe.beautify
		* @function
		*
		* @param {string} str - JSON string to be beautified.
		* @param {string\|number} [space=2] Specifies the indentation of nested
		* structures. If it is omitted, the text will be packed without extra
		* whitespace. If it is a number, it will specify the number of spaces
		* to indent at each level. If it is a string (such as "\t" or
		* " "), it contains the characters used to indent at each level.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, string]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const ugly = '{"key":"value"}';
		* const [err, pretty] = jsonc.beautify(ugly);
		* if (!err) console.log(pretty);
		* // {
		* // "key": "value"
		* // }
		*/
		jsoncSafe.beautify = function (str, space) {
		if (space === void 0) { space = 2; }
		return safeSync(jsonc.beautify)(str, space);
		};
		/**
		* Safe version of `jsonc.normalize()`. Normalizes the given value by
		* stringifying and parsing it back to a Javascript object.
		* @name jsonc.safe.normalize
		* @function
		*
		* @param {any} value
		* @param {Replacer} [replacer] - Determines how object values are
		* normalized for objects. It can be a function or an array of strings.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const c = new SomeClass();
		* console.log(c.constructor.name); // "SomeClass"
		* const [err, normalized] = jsonc.normalize(c);
		* if (err) {
		* console.log('Failed to normalize: ' + err.message);
		* } else {
		* console.log(normalized.constructor.name); // "Object"
		* }
		*/
		jsoncSafe.normalize = function (value, replacer) {
		return safeSync(jsonc.normalize)(value, replacer);
		};
		/**
		* Safe version of `jsonc.read()`. Asynchronously reads a JSON file,
		* strips UTF-8 BOM and parses the JSON content.
		* @name jsonc.safe.read
		* @function
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns undefined then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will fail if this is
		* set to `false` and the string includes comments.
		*
		* @returns {Promise<Array>} - Safe methods return an array with
		* the first item being the `Error` instance caught. If successful,
		* second item will be the result: `Promise<[Error, any]>`
		*
		* @example <caption>Using async/await (recommended)</caption>
		* import { safe as jsonc } from 'jsonc';
		* (async () {
		* const [err, obj] = await jsonc.read('path/to/file.json');
		* if (err) {
		* console.log('Failed to read JSON file');
		* } catch (err) {
		* console.log(typeof obj); // "object"
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* import { safe as jsonc } from 'jsonc';
		* jsonc.read('path/to/file.json')
		* .then([err, obj] => {
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log(typeof obj); // "object"
		* }
		* })
		* // .catch(err => {}); // this is never invoked when safe version is used.
		*/
		jsoncSafe.read = function (filePath, options) {
		return safeAsync(jsonc.read(filePath, options));
		};
		/**
		* Safe version of `jsonc.readSync()`. Synchronously reads a JSON file,
		* strips UTF-8 BOM and parses the JSON content.
		* @name jsonc.safe.readSync
		* @function
		*
		* @param {string} filePath - Path to JSON file.
		* @param {Function\|IReadOptions} [options] - Read options.
		* @param {Function} [options.reviver] - A function that can filter and
		* transform the results. It receives each of the keys and values, and
		* its return value is used instead of the original value. If it
		* returns what it received, then the structure is not modified. If it
		* returns undefined then the member is deleted.
		* @param {boolean} [options.stripComments=true] - Whether to strip
		* comments from the JSON string. Note that it will fail if this is
		* set to `false` and the string includes comments.
		*
		* @returns {Array} - Safe methods return an array with
		* the first item being the `Error` instance caught. If successful,
		* second item will be the result: `[Error, any]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, obj] = jsonc.readSync('path/to/file.json');
		* if (!err) console.log(typeof obj); // "object"
		*/
		jsoncSafe.readSync = function (filePath, options) {
		return safeSync(jsonc.readSync)(filePath, options);
		};
		/**
		* Safe version of `jsonc.write()`. Asynchronously writes a JSON file
		* from the given JavaScript object.
		* @name jsonc.safe.write
		* @function
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values
		* are stringified for objects. It can be a function or an array of
		* strings.
		* @param {string\|number} [options.space] - Specifies the indentation
		* of nested structures. If it is omitted, the text will be packed
		* without extra whitespace. If it is a number, it will specify the
		* number of spaces to indent at each level. If it is a string (such as
		* "\t" or " "), it contains the characters used to indent at each
		* level.
		* @param {number} [options.mode=438] - FileSystem permission mode to
		* be used when writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to
		* create path directories if they don't exist. This will throw if set
		* to `false` and path does not exist.
		*
		* @returns {Promise<Array>} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful,
		* second item will be the result: `Promise<[Error, boolean]>`
		*
		* @example <caption>Using async/await (recommended)</caption>
		* import { safe as jsonc } from 'jsonc';
		* (async () {
		* const [err, success] = await jsonc.write('path/to/file.json', data);
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log('Successfully wrote JSON file');
		* }
		* })();
		*
		* @example <caption>Using promises</caption>
		* import { safe as jsonc } from 'jsonc';
		* jsonc.write('path/to/file.json', data)
		* .then([err, obj] => {
		* if (err) {
		* console.log('Failed to read JSON file');
		* } else {
		* console.log('Successfully wrote JSON file');
		* }
		* })
		* // .catch(err => {}); // this is never invoked when safe version is used.
		*/
		jsoncSafe.write = function (filePath, data, options) {
		return safeAsync(jsonc.write(filePath, data, options));
		};
		/**
		* Safe version of `jsonc.writeSync()`. Synchronously writes a JSON
		* file from the given JavaScript object.
		* @name jsonc.safe.writeSync
		* @function
		*
		* @param {string} filePath - Path to JSON file to be written.
		* @param {any} data - Data to be stringified into JSON.
		* @param {IWriteOptions} [options] - Write options.
		* @param {Replacer} [options.replacer] - Determines how object values
		* are stringified for objects. It can be a function or an array of
		* strings.
		* @param {string\|number} [options.space] - Specifies the indentation
		* of nested structures. If it is omitted, the text will be packed
		* without extra whitespace. If it is a number, it will specify the
		* number of spaces to indent at each level. If it is a string (such as
		* "\t" or " "), it contains the characters used to indent at each
		* level.
		* @param {number} [options.mode=438] - FileSystem permission mode to
		* be used when writing the file. Default is `438` (`0666` in octal).
		* @param {boolean} [options.autoPath=true] - Specifies whether to
		* create path directories if they don't exist. This will throw if set
		* to `false` and path does not exist.
		*
		* @returns {Array} - Safe methods return an array with the
		* first item being the `Error` instance caught. If successful, second
		* item will be the result: `[Error, boolean]`
		*
		* @example
		* import { safe as jsonc } from 'jsonc';
		* const [err, obj] = jsonc.writeSync('path/to/file.json');
		* if (!err) console.log(typeof obj); // "object"
		*/
		jsoncSafe.writeSync = function (filePath, data, options) {
		return safeSync(jsonc.writeSync)(filePath, data, options);
		};
		return jsoncSafe;
		}());
		// default configuration
		jsonc.config(null);
		/* istanbul ignore next */
		(function (jsonc) {
		jsonc.safe = jsoncSafe;
		})(jsonc \|\| (jsonc = {}));
		exports.jsonc = jsonc;

+88

-17

package.json

		{
		"name": "jsonc",
		"version": "0.1.0",
		"description": "json + comments",
		"main": "./lib/jsonc.js",
		"version": "1.0.0",
		"description": "Everything you need in JSON land. Parse JSON with comments, stringify objects with circular references, etc...",
		"author": "Onur Yıldırım <onur@cutepilot.com>",
		"license": "MIT",
		"repository": "onury/jsonc",
		"main": "index.js",
		"files": [
		"lib",
		"index.js",
		"LICENSE"
		],
		"types": "./lib/jsonc.d.ts",
		"scripts": {
		"test": "echo \"Error: no test specified\" && exit 1"
		"clean": "rimraf ./lib",
		"build": "npm run clean && npm run cover && mkdirp ./lib && tsc",
		"test": "jest --verbose --no-cache",
		"cover": "jest --coverage --verbose --no-cache",
		"coveralls": "cat ./test/coverage/lcov.info \| ./node_modules/coveralls/bin/coveralls.js -v",
		"report": "open ./test/coverage/lcov-report/index.html",
		"docs": "docma -c ./docma.config.json"
		},
		"jest": {
		"testEnvironment": "node",
		"globals": {
		"ts-jest": {
		"diagnostics": false
		}
		},
		"roots": [
		"<rootDir>/src",
		"<rootDir>/lib",
		"<rootDir>/test"
		],
		"transform": {
		"^.+\\.tsx?$": "ts-jest"
		},
		"testRegex": "(/test/.*\|(\\.\|/)(test\|spec))\\.tsx?$",
		"moduleFileExtensions": [
		"ts",
		"tsx",
		"js",
		"json"
		],
		"testPathIgnorePatterns": [
		"/backup/",
		"/helpers/",
		"/coverage/"
		],
		"collectCoverageFrom": [
		"src/*/.ts",
		"!src/interfaces.ts"
		],
		"coverageDirectory": "./test/coverage"
		},
		"keywords": [
		"json",
		"with",
		"object",
		"notation",
		"safe",
		"stringify",
		"parse",
		"read-file",
		"write-file",
		"comments",
		"jsonc",
		"json",
		"comments"
		"circular",
		"cyclic",
		"console",
		"log",
		"uglify",
		"beautify",
		"typescript"
		],
		"author": {
		"name": "mayank"
		"dependencies": {
		"fast-safe-stringify": "^2.0.6",
		"graceful-fs": "^4.1.11",
		"mkdirp": "^0.5.1",
		"parse-json": "^4.0.0",
		"strip-bom": "^3.0.0",
		"strip-json-comments": "^2.0.1"
		},
		"license": "BSD",
		"_id": "jsonc@0.0.0",
		"readme": "ERROR: No README.md file found!",
		"dist": {
		"shasum": "39d5ae95d47de300bd7560d94a1be046081ec925"
		},
		"_from": "jsonc"
		"devDependencies": {
		"@types/jest": "^23.3.5",
		"@types/mkdirp": "^0.5.2",
		"@types/node": "^10.12.0",
		"@types/parse-json": "^4.0.0",
		"@types/strip-bom": "^3.0.0",
		"@types/strip-json-comments": "0.0.30",
		"coveralls": "^3.0.2",
		"docma": "^2.1.0",
		"jest": "^23.6.0",
		"jest-cli": "^23.6.0",
		"rimraf": "^2.6.2",
		"ts-jest": "^23.10.4",
		"typescript": "^3.1.3"
		}
		}

jsonc - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes