json-6 1.1.4 → 1.1.5

package/README.md

@@ -57,10 +57,6 @@ JSON6’s aim is to remain close to JSON and JavaScript.
 The following is the exact list of additions to JSON’s syntax introduced by
 JSON6. **All of these are optional**, and **MOST of these come from ES5/6**.
 
-## Caveats
-
-Does not include stringify, instead falling back to original (internal) JSON.stringify.
-This will cause problems maintaining undefined, Infinity and NaN type values.
 
 ### Summary of Changes from JSON5
 
@@ -73,12 +69,13 @@ JSON6 includes all features of JSON5 plus the following.
   - Arrays - empty members
   - Streaming reader interface
   - (Twice the speed of JSON5; subjective)
+  - Opt-in [`esStrictCompatible`](#options) mode that narrows the grammar to a subset of ECMAScript strict mode (see [Why might you wish to enable ECMAScript compatibility?](#why-might-you-wish-to-enable-ecmascript-compatibility)).
 
 ### Objects
 
-- Object keys can be unquoted if they do not have ':', ']', '[', '{', '}', ',', any quote or whitespace; keywords will be interpreted as strings.
+- Object keys can be unquoted if they do not have ':', ']', '[', '{', '}', ',', any quote or whitespace; keywords will be interpreted as strings.  Under the opt-in [`esStrictCompatible`](#options) mode an unquoted key must additionally be a valid ECMAScript identifier name (or a number), so characters such as `-`, `\`, `&`, `+`, `*` and `|` then require quoting.
 
-- Object keys can be single-quoted, (**JSON6**) or back-tick quoted; any valid string
+- Object keys can be single-quoted, (**JSON6**) or back-tick quoted (the latter is rejected under [`esStrictCompatible`](#options)); any valid string
 
 - Object keys can be double-quoted (original JSON).
 
@@ -103,10 +100,13 @@ JSON6 includes all features of JSON5 plus the following.
 - Strings can be split across multiple lines; just prefix each newline with a
   backslash. [ES5 [§7.8.4](http://es5.github.com/#x7.8.4)]
 
-- (**JSON6**) all strings will continue keeping every character between the start and end, this allows multi-line strings
-  and keep the newlines in the string; if you do not want the newlines they can be escaped as previously mentioned.
+- (**JSON6**) all strings keep every character between the start and end, so single-, double-, and
+  back-tick-quoted strings may all span multiple lines with the newlines preserved.  If you do not want the
+  newlines they can be escaped as previously mentioned.  (Under the opt-in [`esStrictCompatible`](#options)
+  mode a literal, unescaped line terminator is rejected inside `'`/`"` strings — but still allowed inside
+  back-ticks — so those strings stay valid ECMAScript.)
 
-- (**JSON5+?**) Strings can have characters emitted using 1 byte hex, interpreted as a utf8 codepoint `\xNN`, 2 and only 2 hex digits must follow `\x`; they may be 4 byte unicode characters `\uUUUU`, 4 and only 4 hex digits must follow `\u`; higher codepoints can be specified with `\u{HHHHH}`, (where H is a hex digit) This is permissive and may accept a single hex digit between `{` and `}`.  All other standard escape sequeneces are also recognized.  Any character that is not recognized as a valid escape character is emitted without the leading escape slash ( for example, `"\012"` will parse as `"012"`
+- (**JSON5+?**) Strings can have characters emitted using 1 byte hex, interpreted as a utf8 codepoint `\xNN`, 2 and only 2 hex digits must follow `\x`; they may be 4 byte unicode characters `\uUUUU`, 4 and only 4 hex digits must follow `\u`; higher codepoints can be specified with `\u{HHHHH}`, (where H is a hex digit) This is permissive and may accept a single hex digit between `{` and `}`.  All other standard escape sequeneces are also recognized.  Any character that is not recognized as a valid escape character is emitted without the leading escape slash ( for example, `"\012"` will parse as `"\0" + "12"`).  (Under the opt-in [`esStrictCompatible`](#options) mode a legacy octal escape such as `"\012"` or `"\1"` is rejected.)
 
 - (**JSON6**) The interpretation of newline is dynamic treating `\r`, `\n`, and `\r\n` as valid combinations of line ending whitespace.  The `\` will behave approrpriately on those combinations.  Mixed line endings like `\n\r?` or `\n\r\n?` are two line endings; 1 for newline, 1 for the \r(follwed by any character), and 1 for the newline, and 1 for the \r\n pair in the second case.
 
@@ -120,7 +120,7 @@ JSON6 includes all features of JSON5 plus the following.
 
 - (**JSON6**) Numbers can be octal (base 8).  (0o prefix)
 
-- (**JSON6**) Decimal Numbers can have leading zeros.  (0 prefix followed by more numbers, without a decimal)
+- (**JSON6**) Decimal Numbers can have leading zeros.  (0 prefix followed by more numbers, without a decimal)  `0123` is `123`, not octal `83`; see [Leading 0 Octal](#leading-0-octal).  (Rejected under the opt-in [`esStrictCompatible`](#options) mode, where ECMAScript treats it as legacy octal.)
 
 - Numbers can begin or end with a (leading or trailing) decimal point.
 
@@ -128,7 +128,7 @@ JSON6 includes all features of JSON5 plus the following.
 
 - Numbers can begin with an explicit plus sign.
 
-- Numbers can begin with multiple minus signs. For example '----123' === 123.
+- (**JSON6**) Numbers can begin with multiple minus signs (for example `'----123' === 123`).  (Two or more consecutive signs are rejected under the opt-in [`esStrictCompatible`](#options) mode.)
 
 ### Keyword Values
 
@@ -138,7 +138,7 @@ JSON6 includes all features of JSON5 plus the following.
 ### Comments
 
 - Both inline (single-line using '//' (todo:or '#'?) ) and block (multi-line using \/\* \*\/ ) comments are allowed.
-  - `//` comments end at a `\r` or `\n` character; They MAY also end at the end of a document, although a warning is issued at this time.
+  - `//` comments end at a `\r` or `\n` character; They MAY also end at the end of a document (pass `{ warnWithCommentWithoutEOL: true }` to log a warning when that happens).
   - `/*` comments should be closed before the end of a document or stream flush.
   - `/` followed by anything else other than `/` or `*` is an error.
 
@@ -269,15 +269,129 @@ var str = JSON6.stringify(obj); /* uses JSON stringify, so don't have to replace
 
 |JSON6 Methods | parameters | Description |
 |-----|-----|-----|
-|parse| (string [,reviver]) | supports all of the JSON6 features listed above, as well as the native [`reviver` argument][json-parse]. |
-|stringify | ( value ) | converts object to JSON.  [stringify][json-stringify] |
+|parse| (string [,reviver] [,options]) | supports all of the JSON6 features listed above, as well as the native [`reviver` argument][json-parse]. See [Options](#options) for `options`. |
+|stringify | (value [,replacer] [,space] [,options]) | converts object to JSON.  [stringify][json-stringify]. `options.sortKeys` (default `true`) can be set to `false` to keep an object's own key order instead of sorting it. |
 |escape | ( string ) | substitutes ", \, ', and ` with backslashed sequences. (prevent 'JSON injection') |
-|begin| (cb [,reviver] ) | create a JSON6 stream processor.  cb is called with (value) for each value decoded from input given with write().  Optional reviver is called with each object before being passed to callback. |
+|begin| (cb [,reviver] [,options] ) | create a JSON6 stream processor.  cb is called with (value) for each value decoded from input given with write().  Optional reviver is called with each object before being passed to callback. `options` are the same as for `parse` and stay in effect across a bare `reset()`. |
+
+`JSON6.stringifier()` returns a reusable stringifier object whose `sortKeys`
+(default `true`) and `ignoreNonEnumerable` (default `false`) properties can
+also be set directly:
+
+```js
+const stringifier = JSON6.stringifier();
+stringifier.sortKeys = false;
+stringifier.stringify({ z: 1, a: 2 }); // '{z:1,a:2}' -- own key order kept
+```
+
+### Options
 
+`parse`, `begin`, and `reset` take an optional trailing `options` object.
+**Every option is off by default**, so out of the box JSON6 accepts its full
+historical grammar.
+
+| Option | Default | Effect |
+|:---|:---|:---|
+| `esStrictCompatible` | `false` | When `true`, narrow the accepted grammar to a subset of **ECMAScript strict mode**, so anything that parses can be pasted into a module or `eval`'d unchanged (if trusted or using `forbidTemplateSubstitution: true`). Rejects: legacy-octal / leading-zero numbers (`0123`); legacy octal string escapes (`"\012"`, `"\1"`..`"\9"`); literal (unescaped) line terminators inside `'`/`"` strings — back-tick strings still allow them; back-tick-quoted object keys; unquoted object keys that are neither identifiers nor numbers (`{a-b: 1}`); and two or more consecutive unary `+`/`-` signs (`--5`). |
+| `forbidTemplateSubstitution` | `false` | When `true`, reject an unescaped `${` inside a back-tick-quoted string, so a document cannot silently turn into a template-literal substitution if it is later evaluated as JavaScript. Independent of `esStrictCompatible`. |
+| `normalizeNumericKeys` | `false` | When `true`, an unquoted object key that parses as a number is replaced with `String(Number(key))`, so `{1e3: true}` gives the key `"1000"` instead of the source text `"1e3"` — matching what a JavaScript object literal produces. Independent of `esStrictCompatible`. `Number()` parses a leading-zero digit string like `"0123"` as decimal (`123`), while a real (sloppy-mode) JavaScript numeric literal `0123` is legacy octal (`83`); combine with `esStrictCompatible` (which forbids leading-zero numbers outright) to avoid that mismatch. |
+| `warnWithCommentWithoutEOL` | `false` | When `true`, a `//` comment that runs to the end of the document with no terminating line break logs a `console` warning. The input is accepted either way. |
+
+Strict mode is the yardstick because modules, classes, and any `"use strict"`
+code are always strict; constructs that are legal only in "sloppy" mode (the
+legacy octal escape `"\1"`, or `"\9"` which sloppy mode silently reduces to
+`"9"`) are still rejected by `esStrictCompatible`.
+
+A numeric object key keeps its source text rather than JavaScript's normalized
+form, so `{1e3:1}` gives the key `"1e3"` here but `"1000"` in JavaScript (where
+a NumericLiteral key is converted through its numeric value). This applies
+under `esStrictCompatible` too: the "same meaning when pasted" guarantee is
+about what parses, not about the exact key string produced by each parser.
+Turn on `normalizeNumericKeys` to close that specific gap.
+
+```js
+JSON6.parse("{'a-b': 0123}");                                        // { 'a-b': 123 }  (default)
+JSON6.parse("{'a-b': 0123}", null, { esStrictCompatible: true });    // throws
+JSON6.parse("`total: ${x}`");                                        // 'total: ${x}'  (default)
+JSON6.parse("`total: ${x}`", null, { forbidTemplateSubstitution: true }); // throws
+JSON6.parse("{1e3: true}");                                          // { '1e3': true }  (default)
+JSON6.parse("{1e3: true}", null, { normalizeNumericKeys: true });    // { '1000': true }
+```
+
+`begin(cb, reviver, options)` applies the options to the stream; a bare
+`reset()` keeps them, while `reset(options)` replaces them.
 
 [json-parse]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse
 [json-stringify]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
 
+#### Why the default is *not* strict
+
+The extensions exist because they make hand-written data less noisy, and for
+a data format — which is read and edited far more than it is pasted into
+code — that often matters more than JavaScript-parseability:
+
+- **Leading zeros align columns.** `[ 001, 002, 010, 100 ]` or a table of
+  `id: 0042` reads better than ragged values. `Number()` already treats
+  `"0123"` as `123`, so nothing is ambiguous; only a *source-code lexer*
+  would see octal. (See [Leading 0 Octal](#leading-0-octal).)
+- **Literal newlines in ordinary strings are the obvious behavior.** Most
+  people expect a quote to keep running until the closing quote; requiring a
+  trailing `\` on every line, or switching to back-ticks, is friction with no
+  payoff when the file is never going to be executed.
+- **Punctuation in unquoted keys.** `content-type`, `x-api-key`,
+  `feature.flag` and the like are extremely common config keys; quoting every
+  one of them is the exact verbosity JSON6 set out to remove.
+- **`--5`, `+8`, stray signs.** Forgiving sign handling means
+  machine-generated output and quick hand edits parse without complaint.
+- **`${...}` as plain text.** In a data file there is no interpolation to
+  worry about, so `` `price: ${amount}` `` is just a string; forbidding it
+  only helps if the file will later be evaluated as code.
+
+If a given file (or project) is meant to double as JavaScript, turn on
+`esStrictCompatible` and the parser will hold it to that stricter bar;
+otherwise the friendlier grammar is the point.
+
+#### Why might you wish to enable ECMAScript compatibility?
+
+JSON6 offers the potential for a `.json6` document to also be a valid
+JavaScript value literal. Turning on `esStrictCompatible` keeps that true
+in every context, and that can buy a lot:
+
+- **Paste-compatibility, both directions.** You can copy a logged object
+  (`console.log(obj)`) straight into a `.json6` file, and paste a `.json6`
+  file into a `.js` module, `eval` it, or rename it to a JS config
+  (`module.exports = { … }`) without edits or `SyntaxError`s. A config
+  authored in JSON6 can "graduate" to a real JS module the day it needs a
+  computed value.
+- **No silent changes of meaning.** The dangerous cases aren't the ones that
+  error — they're the ones that don't. `0123` is `123` in JSON6 but octal
+  `83` in sloppy JS; `` `total: ${x}` `` is a literal string here but a
+  substitution in JS; `--5` is `5` here but decrement-nonsense elsewhere. An
+  ES-compatible subset removes these by construction.
+- **Existing tooling just works.** Editors, syntax highlighters, bracket
+  matchers, Prettier, ESLint, and AST libraries (acorn, Babel, TypeScript)
+  already understand ES. If `.json6` is an ES subset, all of that applies for
+  free, and authors of new tools that touch `.json6` are far less likely to
+  get an edge case subtly wrong.
+- **Familiarity, not a new dialect.** Developers already know the rules;
+  there is no "…but JSON6 also allows backtick keys and `&` in identifiers"
+  to learn, and fewer typos that happen to parse as something unintended.
+- **Interoperability instead of fragmentation.** Other parsers in the
+  ecosystem (e.g. `eslint-plugin-jsonc`, which already reads some JSON6) can
+  be built on an ES grammar; every deviation is a place two implementations
+  can disagree.
+- **Forward compatibility.** TC39 periodically assigns meaning to
+  previously-free syntax. A grammar that stays inside today's ES is less
+  likely to collide with tomorrow's. JSON itself learned this: the
+  U+2028/U+2029 portability bug was fixed in ES2019 by making JSON a
+  syntactic subset of ES.
+- **It's the direction the standards went.** The accepted
+  [tc39 JSON-superset proposal](https://github.com/tc39/proposal-json-superset)
+  made the same argument from the other side.
+- **Cheaper correctness.** The parser can be checked against a reference: if
+  V8/`acorn` accepts the text and produces value *v*, JSON6 should too. A
+  narrower grammar is also less to audit.
+
 ### JSON6 Streaming
 
 A Parser that returns objects as they are encountered in a stream can be created.  `JSON.begin( dataCallback, reviver );`  The callback is called for each complete object in a stream of data that is passed.
@@ -289,7 +403,7 @@ A Parser that returns objects as they are encountered in a stream can be created
 | write | (string) | Parse string passed and as objects are found, invoke the callback passed to `begin()` Objects are passed through optional reviver function passed to `begin()`. |
 | \_write | (string,completeAtEnd) | Low level routine used internally.  This does the work of parsing the passed string. Returns 0 if no object completed, 1 if there is no more data, and an object was completd, returns 2 if there is more data and a parsed object is found.  if completedAtEnd is true, dangling values are returned, for example "1234" isn't known to be completed, more of the number might follow in another buffer; if completeAtEnd is passed, this iwll return as number 1234.  Passing empty arguments steps to the next buffered input value. |
 | value | () | Returns the currently completed object.  Used to get the completed object after calling \_write. |
-| reset | () | If `write()` or `\_write()` throws an exception, no further objects will be parsed becuase internal status is false, this resets the internal status to allow continuing using the existing parser.  ( May require some work to actually work for complex cases) |
+| reset | ( [options] ) | If `write()` or `\_write()` throws an exception, no further objects will be parsed becuase internal status is false, this resets the internal status to allow continuing using the existing parser.  ( May require some work to actually work for complex cases)  With no argument the options passed to `begin()` stay in effect; pass an `options` object to change them. |
 
 
 ```js
@@ -339,6 +453,18 @@ require('./path/to/foo');   // tries foo.json6 after foo.js, foo.json, etc.
 require('./path/to/bar.json6');
 ```
 
+For ES modules, register the loader hooks before your program starts (Node 20.6 or newer):
+
+```sh
+node --import json-6/lib/register.mjs app.mjs
+```
+
+```js
+import config from './path/to/bar.json6';
+```
+
+On older Node versions the same hooks can be applied with `--experimental-loader json-6/lib/import.mjs`.
+
 This module also provides a `json6` executable (requires Node) for converting
 JSON6 files to JSON:
 
@@ -394,6 +520,13 @@ npm test
 As the `package.json6` file states, be sure to run `npm run build` on changes
 to `package.json6`, since npm requires `package.json`.
 
+The parser source is `src/json6.js`; it is the only hand-edited file.  `npm run build`
+generates `lib/json6.js` from it with the package version stamped in
+(`build/src-to-lib.js`), regenerates `package.json`, and then produces `dist/`
+(rollup bundles and TypeScript declarations).  Edits made directly in `lib/` are
+overwritten on the next build.  `lib/json6.js` is committed so that a checkout works
+without a build step; `dist/` is not.
+
 Feel free to [file issues](https://github.com/d3x0r/json6/issues) and submit
 [pull requests](https://github.com/d3x0r/JSON6/pulls) — contributions are
 welcome. If you do submit a pull request, please be sure to add or update the
@@ -408,9 +541,77 @@ switch the test command which is run, the older platforms were removed from test
 The product of this should run on very old platforms also, especially `node_modules/json-6/dist/index.min.js`.
 
 
-## Changelog
+## Leading 0 Octal
 
-- 1.1.5(pre)
+A number with a leading `0` followed by more digits is decimal.  `0123` is `123`.  It is not octal (`83`), and it is not an error.  (The opt-in [`esStrictCompatible`](#options) mode is the exception: it rejects the token, matching ECMAScript strict mode.)
+
+The rationale: JSON6 is a data format, not source code.  The leading-zero-means-octal convention lives in
+*source code lexers* (C, C++, Java, Perl, Ruby, Go, shell, Python 2, sloppy-mode JavaScript).  Every
+*text-to-number conversion* routine, which is what a parser of a data format is, reads a leading zero as
+just another decimal digit: `Number("0123")`, `parseInt("0123", 10)`, `parseFloat("0123")`, Python's
+`int("0123")`, C's `strtol(s, 0, 10)` and `strtod()`, and Java's `Integer.parseInt("0123")` all give `123`.
+None of them have ever produced `83`.
+
+So the rule is simple, and it is the same rule that already governs the other number forms: **a numeric
+token means what `Number()` says it means.**  `Number("0x1F")` is `31`, `Number("0o17")` is `15`,
+`Number("0b101")` is `5`, and `Number("0123")` is `123`.  Legacy octal is the only interpretation
+`Number()` has never accepted.  The only places JSON6 departs from `Number()` are deliberate readability
+extensions: `_` digit separators and a leading or trailing `.`.
+
+The alternatives were considered and rejected:
+
+  - **Octal** silently changes the value, disagrees with `Number()`, and nobody hand-writing a
+    configuration file expects `0123` to be `83`.  Anyone who actually wants octal has `0o123`.
+  - **Rejecting** leading zeros is what JSON, JSON5, strict-mode JavaScript, Python 3, and Rust do.  It
+    loses nothing on the stringify side, since no serializer emits them, but it is strictly less friendly
+    for hand-written files where zero padding is used for alignment, such as `[ 001, 002, 010 ]`.
+
+This is a deliberate divergence from ECMAScript strict mode, where `0123` is a syntax error.  A `.json6`
+document that uses leading zeros is therefore not valid JavaScript source; the same is true of JSON6's
+other extensions.  [JSOX](https://github.com/d3x0r/JSOX) takes the same stance.  Callers who need the
+JavaScript-subset guarantee can turn on [`esStrictCompatible`](#options).
+
+## Changelog
+- 1.1.6(pre)
+    - Error positions are now right: the column no longer starts one too high, numbers no longer count their terminator twice, `_` digit separators are counted, and lines are counted inside comments and strings and for CR, LS and PS as well as LF.
+    - `stringify` emits arrays as arrays; they used to go through the object path and come out as `{"0":..,"1":..}`.  Holes stay holes (`[1,,3]`), `undefined` stays `undefined`, and a trailing hole keeps its comma so it survives a round trip.
+    - `stringify` always quotes string values (#57); only object keys use the bare-identifier rule.
+    - Malformed input that used to be silently accepted now throws:
+        - two values with no separator (`[1 2]` returned `[2]`),
+        - an object field name with no value (`{a}` and `{"a"}` returned `{}`),
+        - an incomplete keyword (`tru` returned `undefined`, `[tru]` returned `[]`); a truncated keyword is still fine as an object key,
+        - a sign with no number after it (`-` returned `undefined`),
+        - a malformed number (`1e`, `.5.`, `0x` returned `NaN`),
+        - a document with no value at all (empty, whitespace, or only comments) from `parse()`; `parse("undefined")` still returns `undefined`.
+    - `begin()` no longer needs a callback; `write()` throws if there is none, since values can only leave it through the callback.
+    - `parse()` restores its nested-parser level when it throws.
+    - Vertical tab (U+000B), form feed (U+000C), line separator (U+2028) and paragraph separator (U+2029) are whitespace between tokens, as in ECMAScript; U+2028/U+2029 also end a `//` comment.
+    - Remove no stringifier cavaet from documentation.
+    - `parse` / `begin` / `reset` now take an `options` argument ([#46](https://github.com/d3x0r/JSON6/issues/46)).
+      All options are off by default, so the historical grammar is unchanged.
+        - `esStrictCompatible` restricts the grammar to a subset of ECMAScript strict mode:
+          it rejects leading-zero / legacy-octal numbers, legacy octal string escapes
+          (`"\1"`..`"\9"`), literal line terminators inside `'`/`"` strings, backtick-quoted
+          object keys, non-identifier unquoted keys, and two or more consecutive `+`/`-` signs.
+        - `forbidTemplateSubstitution` rejects an unescaped `${` inside a backtick string.
+        - `warnWithCommentWithoutEOL` restores the console warning for a `//` comment that
+          ends the document without a line break (now silent by default).
+    - `stringify` gains an opt-out `sortKeys` option (and a matching `sortKeys` property on
+      `JSON6.stringifier()`); default `true` preserves the historical sorted-key output.
+    - `esStrictCompatible` no longer rejects two inputs that are valid ES strict mode:
+      a literal U+2028/U+2029 inside a `'`/`"` string (legal since ES2019), and an
+      unquoted numeric key using a numeric separator (`{1_000:1}`).
+    - `normalizeNumericKeys` normalizes an unquoted numeric object key to
+      `String(Number(key))` (so `{1e3:1}` gives the key `"1000"`, matching
+      JavaScript's object-literal key conversion), closing the "same meaning
+      when pasted" gap `esStrictCompatible` left around numeric keys.
+- 1.1.5
+    - TypeScript declarations are generated from JSDoc during `npm run build` and shipped in `dist/` (#55).
+    - ESM loader for `.json6` moved to the `module.register()` API; `lib/register.mjs` added.
+    - Fix package `exports`: ESM entry pointed at a file that was never built; `lib/require`, `lib/import.mjs`, and `lib/register.mjs` subpaths were unreachable.
+    - `lib/json6.js` can again be loaded directly with a `<script>` tag.
+    - Parser source moved to `src/json6.js`; `lib/json6.js` is generated by `npm run build` with the package version stamped in, so `JSON6.version` can no longer drift from `package.json`.
+    - Document the rationale for leading-zero numbers being decimal.
 - 1.1.4
     - fixes benchmark test for hex number conversion
 - 1.1.3

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../lib/cli.js"],"names":[],"mappings":""}

package/dist/import.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=import.d.mts.map

package/dist/import.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.mts","sourceRoot":"","sources":["../lib/import.mjs"],"names":[],"mappings":""}

package/dist/index-esm.d.mts

@@ -0,0 +1,3 @@
+import json6 from './index.js';
+export default json6;
+//# sourceMappingURL=index-esm.d.mts.map

package/dist/index-esm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-esm.d.mts","sourceRoot":"","sources":["../lib/index-esm.mjs"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAC;eAEhB,KAAK"}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+declare const _exports: {
+    escape: (string: string) => string;
+    begin: (cb?: (value: unknown) => void, reviver?: import("./json6.js").Json6Reviver | undefined, options?: import("./json6.js").Json6ParseOptions) => {
+        finalError(): void;
+        value(): unknown;
+        reset(resetOptions?: import("./json6.js").Json6ParseOptions): void;
+        write(msg?: unknown): void;
+        _write(msg?: string | undefined | null, complete_at_end?: boolean): number;
+    };
+    parse: (msg: unknown, reviver?: import("./json6.js").Json6Reviver, options?: import("./json6.js").Json6ParseOptions) => unknown;
+    stringifierActive: import("./json6.js").Json6Stringifier | null;
+    stringifier: () => {
+        stringify(o?: unknown, r?: import("./json6.js").Json6Replacer, s?: string | number | null, as?: string): string | undefined;
+        setQuote(q: string): void;
+        ignoreNonEnumerable: boolean;
+        sortKeys: boolean;
+    };
+    stringify: (object: unknown, replacer?: import("./json6.js").Json6Replacer, space?: string | number, options?: import("./json6.js").Json6StringifyOptions) => string | undefined;
+    version: string;
+};
+export = _exports;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.js"],"names":[],"mappings":""}