@tabnas/json 0.2.0

package/README.md

@@ -0,0 +1,179 @@
+# @tabnas/json
+
+A standard JSON parser (RFC 8259 / ECMA-404) for TypeScript and
+JavaScript — the standard-JSON **grammar plugin** for the
+[`tabnas`](https://github.com/tabnas/parser) parsing engine.
+
+Available for [TypeScript/JavaScript](#install) and [Go](../go/).
+
+## Install
+
+```bash
+npm install @tabnas/json
+```
+
+`tabnas` (the engine) is a peer/dependency; see [Develop](#develop) for
+the sibling-checkout setup used until it is published.
+
+## Quick example
+
+```ts
+import { parse } from '@tabnas/json'
+
+parse('{"a":1, "b":2}')              // { a: 1, b: 2 }
+parse('[1, 2, 3]')                   // [1, 2, 3]
+parse('{"a": {"b": [true, null]}}')  // { a: { b: [true, null] } }
+```
+
+```js
+const { parse } = require('@tabnas/json')
+parse('"hello"') // => "hello"
+```
+
+`parse` is also the default export.
+
+## Documentation
+
+Full [Diátaxis](https://diataxis.fr) docs:
+
+- [`doc/tutorial.md`](doc/tutorial.md) — learn it step by step.
+- [`doc/guide.md`](doc/guide.md) — task-focused recipes.
+- [`doc/reference.md`](doc/reference.md) — the exact API and CLI surface.
+- [`doc/concepts.md`](doc/concepts.md) — how it works and why.
+
+The Go port has the [equivalent docs](../go/doc/).
+
+## Use it as a plugin
+
+The package is a `tabnas` grammar plugin. Install it on your own engine
+instance and layer further grammar on the shared rules:
+
+```ts
+import { Tabnas } from '@tabnas/parser'
+import { json } from '@tabnas/json'
+
+const tn = new Tabnas({ plugins: [json] })
+tn.parse('{"a":[1,2,3]}')
+```
+
+`registerJsonGrammar(tn)` installs just the `val` / `map` / `list` /
+`pair` / `elem` rules (jsonic's "Plain JSON" core) without the strict
+options, for plugins that want to build on the JSON rule set.
+
+## Reuse and options
+
+`parse` reuses a single lazily-created instance, so you don't pay to
+rebuild the grammar on every call. To customize, build your own instance
+with `make(opts?)` — extra options (e.g. the `info` metadata options) are
+applied on top of the strict JSON config:
+
+```ts
+import { make } from '@tabnas/json'
+
+const p = make({ info: { map: true, list: true } })
+p.parse('{"a":[1,2]}')
+```
+
+`Version` is exported as the package version string.
+
+## What it accepts
+
+Exactly standard JSON:
+
+- objects `{ "key": value, ... }` with double-quoted string keys
+- arrays `[ value, ... ]`
+- double-quoted strings with the JSON escapes
+  (`\" \\ \/ \b \f \n \r \t \uXXXX`, including surrogate pairs)
+- numbers: optional `-`, integer (no leading zeros), optional fraction,
+  optional `e`/`E` exponent
+- `true`, `false`, `null`
+- insignificant whitespace: space, tab, line feed, carriage return
+
+It **rejects** everything outside that grammar — comments, trailing
+commas, unquoted keys, single-quoted or backtick strings, multiline
+strings, implicit objects/arrays, hex/octal/binary numbers, leading
+zeros, a leading `+`, a bare `.5` or trailing `1.`, and empty input.
+This matches the platform `JSON.parse`.
+
+Parsed objects use a **null prototype** (`Object.create(null)`): this is
+deliberate and prototype-pollution-safe — a `"__proto__"` key becomes a
+normal own property rather than mutating the prototype. The only visible
+difference from `JSON.parse` is the missing `Object.prototype` (so e.g.
+`obj.hasOwnProperty` is `undefined`; use `Object.hasOwn(obj, k)`).
+
+## Extending the grammar
+
+Because this is a plain grammar plugin on the shared engine, it is a
+foundation to build other parsers on. Layer options or rules on top of
+the `json` plugin. For example, a JSON-with-comments (JSONC) parser is
+just the JSON grammar with comment lexing re-enabled:
+
+```ts
+import { Tabnas } from '@tabnas/parser'
+import { json } from '@tabnas/json'
+
+const jsonc = new Tabnas({ plugins: [json] })
+jsonc.options({ comment: { lex: true } })
+jsonc.parse('{"a":1} // ok')      // { a: 1 }
+jsonc.parse('{"a":/* ok */1}')    // { a: 1 }
+```
+
+For deeper changes, call `registerJsonGrammar(tn)` to install just the
+rules, then use the engine's rule API (`tn.rule(...)`, and the
+`clearOpen` / `clearClose` / `@<rule>-<phase>/replace` hooks) to replace
+or extend the shared `val` / `map` / `list` / `pair` / `elem` rules
+without re-declaring the JSON core.
+
+## Errors
+
+On invalid input, `parse` throws a `TabnasError` (also exported as
+`JsonError`) carrying `code`, `lineNumber`, and `columnNumber`:
+
+```ts
+import { parse, TabnasError } from '@tabnas/json'
+
+try {
+  parse('{a:1}')
+} catch (err) {
+  if (err instanceof TabnasError) {
+    err.code // 'unexpected'
+  }
+}
+```
+
+## CLI
+
+```bash
+echo '{"a":1}' | npx tabnas-json
+tabnas-json '{"a":1}'
+```
+
+Prints the re-serialized (pretty) JSON, or the error on stderr with exit
+code 1.
+
+## Develop
+
+This package depends on the engine as a sibling checkout:
+
+```bash
+git clone https://github.com/tabnas/parser   # sibling of this repo
+( cd parser/ts && npm install && npm run build )
+npm install      # resolves "@tabnas/parser": "file:../../parser/ts"
+npm test         # tsc build + node --test
+```
+
+See [`AGENTS.md`](AGENTS.md) for layout and conventions.
+
+
+## Grammar diagram
+
+The installed grammar as a railroad/syntax diagram, generated from the live
+grammar with [`@tabnas/railroad`](https://github.com/tabnas/railroad):
+
+![json grammar railroad diagram](doc/grammar.svg)
+
+A vertical ASCII version is in [`doc/grammar.txt`](doc/grammar.txt).
+
+## License
+
+MIT.

package/bin/json

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const { main } = require('../dist/json-cli.js')
+main(
+  process.argv.slice(2),
+  process.stdin,
+  (s) => process.stdout.write(s),
+  (s) => process.stderr.write(s),
+  (code) => process.exit(code),
+)

package/dist/json-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function run(src: string, out: (s: string) => void, errOut: (s: string) => void): number;
+export declare function main(argv: string[], stdin: NodeJS.ReadableStream, out: (s: string) => void, errOut: (s: string) => void, exit: (code: number) => void): void;

package/dist/json-cli.js

@@ -0,0 +1,43 @@
+"use strict";
+/* Copyright (c) 2026 tabnas, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+exports.main = main;
+/* json-cli.ts
+ *
+ * A tiny command-line front end: read JSON from the arguments or from
+ * stdin, parse it, and print the canonical re-serialized form. Exit code
+ * 1 (with the error on stderr) when the input is not valid JSON.
+ *
+ * The logic is split into `run` (pure: source in, exit code out, writes
+ * via injected sinks) and `main` (process wiring), so `run` and `main`
+ * are both testable in-process. `bin/json` calls `main`.
+ */
+const json_1 = require("./json");
+// Parse `src`, writing the pretty-printed value to `out` on success or
+// the error message to `errOut` on failure. Returns the process exit code.
+function run(src, out, errOut) {
+    try {
+        out(JSON.stringify((0, json_1.parse)(src), null, 2) + '\n');
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof json_1.TabnasError) {
+            errOut(err.message + '\n');
+            return 1;
+        }
+        throw err;
+    }
+}
+// Wire `run` to a process-like environment. With arguments, parse them;
+// otherwise read all of stdin. Calls `exit` with the resulting code.
+function main(argv, stdin, out, errOut, exit) {
+    if (argv.length > 0) {
+        exit(run(argv.join(' '), out, errOut));
+        return;
+    }
+    const chunks = [];
+    stdin.on('data', (c) => chunks.push(Buffer.from(c)));
+    stdin.on('end', () => exit(run(Buffer.concat(chunks).toString('utf8'), out, errOut)));
+}
+//# sourceMappingURL=json-cli.js.map

package/dist/json-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-cli.js","sourceRoot":"","sources":["../src/json-cli.ts"],"names":[],"mappings":";AAAA,4CAA4C;;AAiB5C,kBAeC;AAID,oBAcC;AAhDD;;;;;;;;;GASG;AAEH,iCAA2C;AAE3C,uEAAuE;AACvE,2EAA2E;AAC3E,SAAgB,GAAG,CACjB,GAAW,EACX,GAAwB,EACxB,MAA2B;IAE3B,IAAI,CAAC;QACH,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAA,YAAK,EAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;QAC/C,OAAO,CAAC,CAAA;IACV,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,GAAG,YAAY,kBAAW,EAAE,CAAC;YAC/B,MAAM,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;YAC1B,OAAO,CAAC,CAAA;QACV,CAAC;QACD,MAAM,GAAG,CAAA;IACX,CAAC;AACH,CAAC;AAED,wEAAwE;AACxE,qEAAqE;AACrE,SAAgB,IAAI,CAClB,IAAc,EACd,KAA4B,EAC5B,GAAwB,EACxB,MAA2B,EAC3B,IAA4B;IAE5B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;QACtC,OAAM;IACR,CAAC;IACD,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAS,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC5D,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;AACvF,CAAC"}

package/dist/json.d.ts

@@ -0,0 +1,9 @@
+import { Tabnas, TabnasError, type Plugin } from '@tabnas/parser';
+export declare const Version = "1.0.0";
+export declare function registerJsonGrammar(tn: Tabnas): void;
+export declare const json: Plugin;
+export declare function make(opts?: Record<string, any>): Tabnas;
+export declare function parse(src: string): any;
+export { Tabnas, TabnasError };
+export { TabnasError as JsonError };
+export default parse;

package/dist/json.js

@@ -0,0 +1,210 @@
+"use strict";
+/* Copyright (c) 2026 tabnas, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonError = exports.TabnasError = exports.Tabnas = exports.json = exports.Version = void 0;
+exports.registerJsonGrammar = registerJsonGrammar;
+exports.make = make;
+exports.parse = parse;
+/*  json.ts
+ *
+ *  A standard JSON grammar plugin for the `tabnas` parsing engine.
+ *
+ *  The engine ships no grammar of its own; this package supplies the
+ *  strict, standard-JSON one. The rule set (val / map / list / pair /
+ *  elem) is the "Plain JSON" grammar from jsonic's `grammar.ts` — the
+ *  pure-JSON core jsonic defines before extending it for the relaxed
+ *  jsonic format. Here that core is installed on its own, with the lexer
+ *  restricted to strict JSON, and none of jsonic's extended grammar
+ *  (comments, unquoted keys, implicit objects/arrays, trailing commas,
+ *  single/backtick strings, path diving).
+ *
+ *  This plugin is intended to be the foundation other tabnas grammar
+ *  plugins build on: `use` it first, then layer additional rules on the
+ *  shared val / map / list / pair / elem rules.
+ */
+const parser_1 = require("@tabnas/parser");
+Object.defineProperty(exports, "Tabnas", { enumerable: true, get: function () { return parser_1.Tabnas; } });
+Object.defineProperty(exports, "TabnasError", { enumerable: true, get: function () { return parser_1.TabnasError; } });
+Object.defineProperty(exports, "JsonError", { enumerable: true, get: function () { return parser_1.TabnasError; } });
+// Current package version.
+exports.Version = '1.0.0';
+// JSON-only lexer/parser options. Restrictive enough to mirror
+// JSON.parse: double-quoted strings only, plain decimal numbers, quoted
+// keys only, no comments, no trailing-comma map extension, no empty
+// input, and the rule set restricted to the `json`-tagged alternates.
+const JSON_OPTIONS = {
+    text: { lex: false },
+    number: {
+        hex: false,
+        oct: false,
+        bin: false,
+        sep: null,
+        // Reject any token the (lenient) number matcher accepts that is not a
+        // strict JSON number: leading `+`, a bare leading `.` (`.5`), a
+        // trailing `.` (`1.`), and leading zeros (`01`, `00`). The negative
+        // lookahead matches — and so excludes — anything not of the form
+        // -?(0|[1-9][0-9]*)(.[0-9]+)?([eE][+-]?[0-9]+)?.
+        exclude: /^(?!-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$)/,
+    },
+    string: {
+        chars: '"',
+        multiChars: '',
+        // Standard JSON escape handling: allowUnknown:false rejects any
+        // unrecognized escape (\q, \z); escapeStrict disables the engine's
+        // non-standard \xHH and \u{...} structural escapes (plain \uXXXX
+        // stays); and dropping v / ' / ` from the escape map removes the
+        // remaining non-standard built-ins. Result: exactly the JSON.parse
+        // escape set, identical to the Go engine.
+        allowUnknown: false,
+        escapeStrict: true,
+        escape: { v: '', "'": '', '`': '' },
+    },
+    comment: { lex: false },
+    map: { extend: false },
+    lex: { empty: false },
+    rule: { finish: false, include: 'json' },
+    result: { fail: [undefined, NaN] },
+    tokenSet: { KEY: ['#ST', null, null, null] },
+};
+// Install the pure JSON rule set (val / map / list / pair / elem) on the
+// given engine instance. Exposed separately from the options so other
+// grammar plugins can layer their extensions on top without re-declaring
+// the JSON core. This is jsonic's "Plain JSON" grammar.
+function registerJsonGrammar(tn) {
+    tn.grammar({
+        // The schema version of the native-value builtins this grammar binds
+        // to (object/array/reset/key/setval/push/value).
+        v: 2,
+        // The value tree is built ENTIRELY by the engine's native-value
+        // `$`-builtins — referenced by name on the alts below; the engine
+        // merges them in at load. There are NO grammar-local closures: the
+        // builders are info-aware, so when info.map/list/text is enabled they
+        // attach the introspection marker themselves (the json plugin used to
+        // hand-write that as @jsonMapMark/@jsonListMark/@jsonText/@jsonSetval).
+        // Strict JSON containers are always explicit, so @object$/@array$ take
+        // the default implicit:false (no `k` config needed).
+        //
+        // The builtin actions used below, one line each:
+        //   @reset$  — clear the parent-seeded node (so a value doesn't inherit
+        //              the parent container).
+        //   @object$ — allocate an empty object into the node (a MapRef under
+        //              info.map).
+        //   @array$  — allocate an empty array into the node (a ListRef under
+        //              info.list).
+        //   @key$    — capture the matched key token into a scratch slot for the
+        //              pending @setval$.
+        //   @setval$ — assign the just-built child value into the object under
+        //              the captured key.
+        //   @push$   — append the just-built child value to the array.
+        //   @value$  — resolve the rule's value: a built child wins, else the
+        //              scalar token (boxed with quote info under info.text).
+        rule: {
+            val: {
+                // Opening token alternates. @reset$ clears the parent-seeded node
+                // so a scalar doesn't inherit the parent container.
+                open: [
+                    // A map: `{ ...`
+                    { s: '#OB', p: 'map', b: 1, a: '@reset$', g: 'map,json' },
+                    // A list: `[ ...`
+                    { s: '#OS', p: 'list', b: 1, a: '@reset$', g: 'list,json' },
+                    // A plain value: `"x"` `1` `true` ....
+                    { s: '#VAL', a: '@reset$', g: 'val,json' },
+                ],
+                // Closing alternates. @value$ coalesces (child wins, else the
+                // scalar token) and, under info.text, boxes a string with its quote.
+                close: [
+                    // End of input.
+                    { s: '#ZZ', a: '@value$', g: 'end,json' },
+                    // There's more JSON.
+                    { b: 1, a: '@value$', g: 'more,json' },
+                ],
+            },
+            map: {
+                open: [
+                    // An empty map: {}.
+                    { s: '#OB #CB', b: 1, n: { pk: 0 }, a: '@object$', g: 'map,json' },
+                    // Start matching map key-value pairs.
+                    // Reset counter n.pk as new map (for extensions).
+                    { s: '#OB', p: 'pair', n: { pk: 0 }, a: '@object$', g: 'map,json,pair' },
+                ],
+                close: [
+                    // End of map.
+                    { s: '#CB', g: 'end,json' },
+                ],
+            },
+            list: {
+                open: [
+                    // An empty list: [].
+                    { s: '#OS #CS', b: 1, a: '@array$', g: 'list,json' },
+                    // Start matching list elements.
+                    { s: '#OS', p: 'elem', a: '@array$', g: 'list,elem,json' },
+                ],
+                close: [
+                    // End of list.
+                    { s: '#CS', g: 'end,json' },
+                ],
+            },
+            // sets key:val on node
+            pair: {
+                open: [
+                    // Match key-colon start of pair. @key$ captures the key.
+                    {
+                        s: '#KEY #CL',
+                        p: 'val',
+                        u: { pair: true },
+                        a: '@key$',
+                        g: 'map,pair,key,json',
+                    },
+                ],
+                close: [
+                    // Comma means a new pair at same pair-key level. @setval$
+                    // assigns the pair; on every close alt (fan-out).
+                    { s: '#CA', r: 'pair', a: '@setval$', g: 'map,pair,json' },
+                    // End of map.
+                    { s: '#CB', b: 1, a: '@setval$', g: 'map,pair,json' },
+                ],
+            },
+            // push onto node
+            elem: {
+                open: [
+                    // List elements are values.
+                    { p: 'val', g: 'list,elem,val,json' },
+                ],
+                close: [
+                    // Next element. @push$ appends the element.
+                    { s: '#CA', r: 'elem', a: '@push$', g: 'list,elem,json' },
+                    // End of list.
+                    { s: '#CS', b: 1, a: '@push$', g: 'list,elem,json' },
+                ],
+            },
+        },
+    });
+}
+// The standard plugin form: apply the strict JSON options, then register
+// the JSON grammar. `use` this on a bare engine, or pass it to `make`.
+const json = function json(tn, _options) {
+    tn.options(JSON_OPTIONS);
+    registerJsonGrammar(tn);
+};
+exports.json = json;
+// Create a standard-JSON parser instance: a tabnas engine with the json
+// plugin installed. Extra options (e.g. info.map/list/text) are applied
+// after the grammar exists, mirroring the Go `Make`.
+function make(opts) {
+    const tn = new parser_1.Tabnas({ plugins: [exports.json] });
+    if (opts) {
+        tn.options(opts);
+    }
+    return tn;
+}
+// A lazily-created default instance reused by `parse`, so repeated calls
+// don't rebuild the engine and grammar each time. Parsing creates a fresh
+// context per call, so reuse is safe.
+let defaultParser;
+// Parse a JSON source string with a default standard-JSON parser and
+// return the resulting value. Throws a TabnasError on invalid input.
+function parse(src) {
+    return (defaultParser ??= make()).parse(src);
+}
+exports.default = parse;
+//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"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"}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/json-cli.ts","../src/json.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@tabnas/json",
+  "version": "0.2.0",
+  "main": "dist/json.js",
+  "type": "commonjs",
+  "types": "dist/json.d.ts",
+  "description": "A standard JSON parser (RFC 8259).",
+  "keywords": [
+    "json",
+    "parser",
+    "rfc8259",
+    "ecma-404"
+  ],
+  "author": "tabnas",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc --build src",
+    "watch": "tsc --build src -w",
+    "clean": "rm -rf node_modules dist package-lock.json",
+    "test": "npm run build && node --enable-source-maps --test test/**/*.test.js",
+    "coverage": "npm run build && node --test --experimental-test-coverage --test-coverage-include=dist/json.js --test-coverage-include=dist/json-cli.js --test-coverage-lines=0.95 test/**/*.test.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "LICENSE"
+  ],
+  "bin": {
+    "tabnas-json": "bin/json"
+  },
+  "exports": {
+    ".": "./dist/json.js"
+  },
+  "devDependencies": {
+    "@tabnas/debug": "file:../../debug/ts",
+    "@tabnas/parser": "file:../../parser/ts",
+    "@tabnas/railroad": "file:../../railroad/ts",
+    "@types/node": "20.x",
+    "typescript": "5.x"
+  },
+  "peerDependencies": {
+    "@tabnas/parser": "^0.2.0"
+  }
+}