@datumesh/verify 0.0.0-stage → 0.2.0

package/dist/cjs/errors.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatumeshError = exports.ERROR_CODES = exports.SPEC_VERSION = void 0;
+exports.fail = fail;
+/** The spec revision this library conforms to. */
+exports.SPEC_VERSION = 'spec-0.2.0';
+/** Every error code defined by SPEC.md 10.2, in the order of that table. */
+exports.ERROR_CODES = [
+    'E_PARSE_JSON',
+    'E_PARSE_DUPLICATE_KEY',
+    'E_PARSE_URI',
+    'E_SCHEMA',
+    'E_CANON_NAME',
+    'E_CANON_ARG_NAME',
+    'E_CANON_ARG_DUPLICATE',
+    'E_CANON_ARG_ORDER',
+    'E_CANON_PERCENT',
+    'E_CANON_TYPE',
+    'E_CANON_NUMBER',
+    'E_CANON_UNIT',
+    'E_CANON_DATE',
+    'E_CANON_INSTANT',
+    'E_CANON_STRING',
+    'E_CANON_BLOB',
+    'E_CANON_HEX',
+    'E_CANON_LICENCE',
+    'E_CANON_SET',
+    'E_CANON_LIMIT',
+    'E_SLICE',
+    'E_PUBLISHER_MISMATCH',
+    'E_VALID_MISMATCH',
+    'E_TIME_ORDER',
+    'E_ARG_UNKNOWN',
+    'E_ARG_MISSING',
+    'E_KEY_UNAVAILABLE',
+    'E_KEY_DOC',
+    'E_KEY_UNKNOWN',
+    'E_KEY_NOT_VALID',
+    'E_SIGNATURE',
+    'E_FN_UNAVAILABLE',
+    'E_FN_HASH_MISMATCH',
+    'E_ARG_TYPE',
+    'E_RETURN_TYPE',
+    'E_INPUT_UNAVAILABLE',
+    'E_INPUT_INVALID',
+    'E_INPUT_UNDECLARED',
+    'E_VALUE_MISMATCH',
+    'E_BLOB_MISMATCH',
+    'E_ENVELOPE',
+];
+/** A Datumesh rule was broken. `code` is a SPEC.md 10.2 code; `path` locates the failure. */
+class DatumeshError extends Error {
+    constructor(code, detail, path = null) {
+        super(`${code}${path ? ` at ${path}` : ''}: ${detail}`);
+        this.name = 'DatumeshError';
+        this.code = code;
+        this.path = path;
+        this.detail = detail;
+    }
+}
+exports.DatumeshError = DatumeshError;
+/** Shorthand used throughout: throw a DatumeshError. */
+function fail(code, detail, path = null) {
+    throw new DatumeshError(code, detail, path);
+}

package/dist/cjs/hash.d.ts

@@ -0,0 +1,6 @@
+export declare function toHex(b: Uint8Array): string;
+export declare function fromHex(s: string): Uint8Array;
+/** SHA-256 in lowercase hex. */
+export declare function sha256Hex(b: Uint8Array): string;
+/** SPEC 9.1: first 16 hex digits of SHA-256 over the raw 32-byte public key. */
+export declare function keyIdOf(publicKey: Uint8Array): string;

package/dist/cjs/hash.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHex = toHex;
+exports.fromHex = fromHex;
+exports.sha256Hex = sha256Hex;
+exports.keyIdOf = keyIdOf;
+const sha2_1 = require("@noble/hashes/sha2");
+function toHex(b) {
+    let s = '';
+    for (let i = 0; i < b.length; i++)
+        s += b[i].toString(16).padStart(2, '0');
+    return s;
+}
+function fromHex(s) {
+    const out = new Uint8Array(s.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(s.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}
+/** SHA-256 in lowercase hex. */
+function sha256Hex(b) {
+    return toHex((0, sha2_1.sha256)(b));
+}
+/** SPEC 9.1: first 16 hex digits of SHA-256 over the raw 32-byte public key. */
+function keyIdOf(publicKey) {
+    return sha256Hex(publicKey).slice(0, 16);
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,37 @@
+import { type Kind } from './validate.js';
+export { DatumeshError, ERROR_CODES, SPEC_VERSION, type ErrorCode } from './errors.js';
+export { verify, type VerifyResult, type Recompute } from './verify.js';
+export { checkEnvelope, type EnvelopeResult, type EnvelopeRequest, type Outcome, type Trust } from './envelope.js';
+export { parseUri, formatUri, httpsUrl, type CellRef, type TypedScalar, type Signature, type Unit, type UnitRef } from './uri.js';
+export { keysFromResponse, keysFromDocument, fetchKeys, FETCH_TIMEOUT_MS, type KeysResult, type KeyEntry, type KeyMap, type KeySource } from './keys.js';
+export type { Kind } from './validate.js';
+export type { JsonValue } from './json.js';
+/** Library version. */
+export declare const VERSION = "0.2.0";
+/**
+ * Validate `input` as `kind` and return its RFC 8785 canonical bytes. `input` is JSON text,
+ * UTF-8 bytes, or an already-parsed value. `kind` is "scalar", "cell", "ref", "function" or
+ * "receipt" (inferred from the members when omitted), or "jcs" for plain RFC 8785 with only the
+ * strict-parsing rules of SPEC 6.1. A receipt is returned whole, `sig` included, and is checked
+ * through SPEC 10.1 step 4. Throws DatumeshError.
+ */
+export declare function canonicalize(input: unknown, kind?: Kind | null): Uint8Array;
+/** Cell id (SPEC 4.4): SHA-256 of the cell's canonical bytes, lowercase hex. Throws DatumeshError. */
+export declare function cellHash(cell: unknown): string;
+/** Function hash (SPEC 7): SHA-256 of the descriptor's canonical bytes. Throws DatumeshError. */
+export declare function functionHash(descriptor: unknown): string;
+/** Receipt hash (SPEC 8.3): SHA-256 of the canonical receipt without `sig`. Throws DatumeshError. */
+export declare function receiptHash(receipt: unknown): string;
+/** The signed payload of a receipt (SPEC 8.3): canonical bytes without `sig`. Throws DatumeshError. */
+export declare function receiptPayload(receipt: unknown): Uint8Array;
+/**
+ * The unit of a cell's value (SPEC 7.1, units.md section 3): the descriptor's return unit with
+ * the cell's argument values substituted, e.g. "USD/EUR"; null when the function does not
+ * return a number. `descriptor` must be the cell's function (E_FN_HASH_MISMATCH otherwise).
+ * Both are JSON text, bytes or parsed objects. Throws DatumeshError like canonicalize, and
+ * E_ARG_MISSING / E_SLICE / E_ARG_TYPE / E_CANON_UNIT when a referenced argument cannot give a
+ * unit.
+ */
+export declare function resolvedUnit(descriptor: unknown, cell: unknown): string | null;
+/** Key id of an Ed25519 public key given as 64 lowercase hex digits (SPEC 9.1). Throws DatumeshError. */
+export declare function keyId(publicKeyHex: string): string;

package/dist/cjs/index.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.FETCH_TIMEOUT_MS = exports.fetchKeys = exports.keysFromDocument = exports.keysFromResponse = exports.httpsUrl = exports.formatUri = exports.parseUri = exports.checkEnvelope = exports.verify = exports.SPEC_VERSION = exports.ERROR_CODES = exports.DatumeshError = void 0;
+exports.canonicalize = canonicalize;
+exports.cellHash = cellHash;
+exports.functionHash = functionHash;
+exports.receiptHash = receiptHash;
+exports.receiptPayload = receiptPayload;
+exports.resolvedUnit = resolvedUnit;
+exports.keyId = keyId;
+/**
+ * @datumesh/verify: verify Datumesh receipts (SPEC.md, revision spec-0.2.0).
+ *
+ * Everything here is synchronous and offline except fetchKeys, the only function that uses the
+ * network.
+ */
+const errors_js_1 = require("./errors.js");
+const hash_js_1 = require("./hash.js");
+const json_js_1 = require("./json.js");
+const jcs_js_1 = require("./jcs.js");
+const lexical_js_1 = require("./lexical.js");
+const validate_js_1 = require("./validate.js");
+var errors_js_2 = require("./errors.js");
+Object.defineProperty(exports, "DatumeshError", { enumerable: true, get: function () { return errors_js_2.DatumeshError; } });
+Object.defineProperty(exports, "ERROR_CODES", { enumerable: true, get: function () { return errors_js_2.ERROR_CODES; } });
+Object.defineProperty(exports, "SPEC_VERSION", { enumerable: true, get: function () { return errors_js_2.SPEC_VERSION; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "verify", { enumerable: true, get: function () { return verify_js_1.verify; } });
+var envelope_js_1 = require("./envelope.js");
+Object.defineProperty(exports, "checkEnvelope", { enumerable: true, get: function () { return envelope_js_1.checkEnvelope; } });
+var uri_js_1 = require("./uri.js");
+Object.defineProperty(exports, "parseUri", { enumerable: true, get: function () { return uri_js_1.parseUri; } });
+Object.defineProperty(exports, "formatUri", { enumerable: true, get: function () { return uri_js_1.formatUri; } });
+Object.defineProperty(exports, "httpsUrl", { enumerable: true, get: function () { return uri_js_1.httpsUrl; } });
+var keys_js_1 = require("./keys.js");
+Object.defineProperty(exports, "keysFromResponse", { enumerable: true, get: function () { return keys_js_1.keysFromResponse; } });
+Object.defineProperty(exports, "keysFromDocument", { enumerable: true, get: function () { return keys_js_1.keysFromDocument; } });
+Object.defineProperty(exports, "fetchKeys", { enumerable: true, get: function () { return keys_js_1.fetchKeys; } });
+Object.defineProperty(exports, "FETCH_TIMEOUT_MS", { enumerable: true, get: function () { return keys_js_1.FETCH_TIMEOUT_MS; } });
+/** Library version. */
+exports.VERSION = '0.2.0';
+function parseAndValidate(input, kind) {
+    if (kind !== undefined && kind !== null && !validate_js_1.KINDS.includes(kind))
+        throw new TypeError(`unknown kind ${JSON.stringify(kind)}; expected one of ${validate_js_1.KINDS.join(', ')}`);
+    const value = (0, json_js_1.toJson)(input);
+    const k = kind ?? (0, validate_js_1.inferKind)(value);
+    (0, validate_js_1.validate)(value, k);
+    return { value, kind: k };
+}
+/**
+ * Validate `input` as `kind` and return its RFC 8785 canonical bytes. `input` is JSON text,
+ * UTF-8 bytes, or an already-parsed value. `kind` is "scalar", "cell", "ref", "function" or
+ * "receipt" (inferred from the members when omitted), or "jcs" for plain RFC 8785 with only the
+ * strict-parsing rules of SPEC 6.1. A receipt is returned whole, `sig` included, and is checked
+ * through SPEC 10.1 step 4. Throws DatumeshError.
+ */
+function canonicalize(input, kind) {
+    return (0, jcs_js_1.jcsBytes)(parseAndValidate(input, kind).value);
+}
+/** Cell id (SPEC 4.4): SHA-256 of the cell's canonical bytes, lowercase hex. Throws DatumeshError. */
+function cellHash(cell) {
+    return (0, hash_js_1.sha256Hex)((0, jcs_js_1.jcsBytes)(parseAndValidate(cell, 'cell').value));
+}
+/** Function hash (SPEC 7): SHA-256 of the descriptor's canonical bytes. Throws DatumeshError. */
+function functionHash(descriptor) {
+    return (0, hash_js_1.sha256Hex)((0, jcs_js_1.jcsBytes)(parseAndValidate(descriptor, 'function').value));
+}
+/** Receipt hash (SPEC 8.3): SHA-256 of the canonical receipt without `sig`. Throws DatumeshError. */
+function receiptHash(receipt) {
+    return (0, hash_js_1.sha256Hex)(receiptPayload(receipt));
+}
+/** The signed payload of a receipt (SPEC 8.3): canonical bytes without `sig`. Throws DatumeshError. */
+function receiptPayload(receipt) {
+    const r = parseAndValidate(receipt, 'receipt').value;
+    const o = (0, json_js_1.newObject)();
+    for (const k of Object.keys(r))
+        if (k !== 'sig')
+            o[k] = r[k];
+    return (0, jcs_js_1.jcsBytes)(o);
+}
+/**
+ * The unit of a cell's value (SPEC 7.1, units.md section 3): the descriptor's return unit with
+ * the cell's argument values substituted, e.g. "USD/EUR"; null when the function does not
+ * return a number. `descriptor` must be the cell's function (E_FN_HASH_MISMATCH otherwise).
+ * Both are JSON text, bytes or parsed objects. Throws DatumeshError like canonicalize, and
+ * E_ARG_MISSING / E_SLICE / E_ARG_TYPE / E_CANON_UNIT when a referenced argument cannot give a
+ * unit.
+ */
+function resolvedUnit(descriptor, cell) {
+    if (descriptor === undefined || cell === undefined)
+        throw new TypeError('resolvedUnit(descriptor, cell) needs both arguments');
+    const d = (0, json_js_1.toJson)(descriptor);
+    const c = (0, json_js_1.toJson)(cell);
+    return (0, validate_js_1.cellUnit)(d, c, (x) => (0, hash_js_1.sha256Hex)((0, jcs_js_1.jcsBytes)(x)));
+}
+/** Key id of an Ed25519 public key given as 64 lowercase hex digits (SPEC 9.1). Throws DatumeshError. */
+function keyId(publicKeyHex) {
+    if (typeof publicKeyHex !== 'string' || !(0, lexical_js_1.isHex)(publicKeyHex, 64))
+        (0, errors_js_1.fail)('E_CANON_HEX', 'expected 64 lowercase hex digits', '$');
+    return (0, hash_js_1.keyIdOf)((0, hash_js_1.fromHex)(publicKeyHex));
+}

package/dist/cjs/jcs.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from './json.js';
+/** RFC 8785 canonical text of a JSON value. */
+export declare function jcsText(v: JsonValue): string;
+/** RFC 8785 canonical bytes (UTF-8) of a JSON value. */
+export declare function jcsBytes(v: JsonValue): Uint8Array;

package/dist/cjs/jcs.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jcsText = jcsText;
+exports.jcsBytes = jcsBytes;
+// RFC 8785 JSON Canonicalization Scheme. Serialisation is delegated to the `canonicalize`
+// package (the RFC authors' implementation), which relies on ECMAScript JSON.stringify for
+// strings and numbers and on the default (UTF-16 code unit) sort for member names, exactly as
+// RFC 8785 specifies. It is only ever given values produced by ./json.ts (plain data, finite
+// numbers, well-formed strings), so its toJSON/undefined handling never comes into play.
+const canonicalize_1 = __importDefault(require("canonicalize"));
+const utf8_js_1 = require("./utf8.js");
+/** RFC 8785 canonical text of a JSON value. */
+function jcsText(v) {
+    const s = (0, canonicalize_1.default)(v);
+    if (typeof s !== 'string')
+        throw new Error('canonicalize returned no text');
+    return s;
+}
+/** RFC 8785 canonical bytes (UTF-8) of a JSON value. */
+function jcsBytes(v) {
+    return (0, utf8_js_1.utf8Encode)(jcsText(v));
+}

package/dist/cjs/json.d.ts

@@ -0,0 +1,29 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+/**
+ * Nesting deeper than this is rejected with E_PARSE_JSON. SPEC.md sets no depth limit; this is
+ * an implementation limit (Datumesh objects nest at most five levels) that keeps parsing and
+ * canonicalisation from exhausting the call stack.
+ */
+export declare const MAX_DEPTH = 1000;
+export declare function isObject(v: unknown): v is JsonObject;
+export declare function newObject(): JsonObject;
+export declare function has(o: JsonObject, k: string): boolean;
+/** Member names in JCS order (UTF-16 code units, which is JavaScript's default sort). */
+export declare function sortedKeys(o: JsonObject): string[];
+export declare function memberPath(path: string, name: string): string;
+/** Parse JSON text strictly. */
+export declare function parseJsonText(text: string, numbers?: Map<string, string>): JsonValue;
+/** Parse UTF-8 JSON bytes strictly: no BOM, no invalid UTF-8. */
+export declare function parseJsonBytes(bytes: Uint8Array, numbers?: Map<string, string>): JsonValue;
+/**
+ * Check an already-parsed JavaScript value against the JSON data model and return a private
+ * deep copy (plain data with null-prototype objects), so later checks cannot be affected by
+ * getters, prototypes or mutation. Duplicate members cannot be detected here: pass JSON text
+ * or bytes for that.
+ */
+export declare function normalizeValue(v: unknown, path?: string, depth?: number): JsonValue;
+/** JSON text (string), UTF-8 bytes (Uint8Array) or an already-parsed value. */
+export declare function toJson(input: unknown, numbers?: Map<string, string>): JsonValue;

package/dist/cjs/json.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DEPTH = void 0;
+exports.isObject = isObject;
+exports.newObject = newObject;
+exports.has = has;
+exports.sortedKeys = sortedKeys;
+exports.memberPath = memberPath;
+exports.parseJsonText = parseJsonText;
+exports.parseJsonBytes = parseJsonBytes;
+exports.normalizeValue = normalizeValue;
+exports.toJson = toJson;
+// Strict JSON parsing (SPEC.md 6.1, I-JSON / RFC 7493). JSON.parse is not used: it accepts
+// duplicate members (last wins) and lone surrogates, both of which must be rejected.
+const errors_js_1 = require("./errors.js");
+const unicode_js_1 = require("./unicode.js");
+const utf8_js_1 = require("./utf8.js");
+/**
+ * Nesting deeper than this is rejected with E_PARSE_JSON. SPEC.md sets no depth limit; this is
+ * an implementation limit (Datumesh objects nest at most five levels) that keeps parsing and
+ * canonicalisation from exhausting the call stack.
+ */
+exports.MAX_DEPTH = 1000;
+function isObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function newObject() {
+    return Object.create(null);
+}
+function has(o, k) {
+    return Object.prototype.hasOwnProperty.call(o, k);
+}
+/** Member names in JCS order (UTF-16 code units, which is JavaScript's default sort). */
+function sortedKeys(o) {
+    return Object.keys(o).sort();
+}
+function memberPath(path, name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? `${path}.${name}` : `${path}[${JSON.stringify(name)}]`;
+}
+class Parser {
+    constructor(s, 
+    /** When given, receives the source text of every number, by JSON path. */
+    numbers) {
+        this.s = s;
+        this.numbers = numbers;
+        this.i = 0;
+        /** Path of the first string holding an escaped lone surrogate; reported after parsing. */
+        this.surrogatePath = null;
+    }
+    err(msg) {
+        (0, errors_js_1.fail)('E_PARSE_JSON', `${msg} at offset ${this.i}`, '$');
+    }
+    ws() {
+        const s = this.s;
+        while (this.i < s.length) {
+            const c = s.charCodeAt(this.i);
+            if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d)
+                this.i++;
+            else
+                break;
+        }
+    }
+    parseDocument() {
+        this.ws();
+        const v = this.value('$', 0);
+        this.ws();
+        if (this.i !== this.s.length)
+            this.err('unexpected data after the JSON value');
+        return v;
+    }
+    value(path, depth) {
+        if (depth > exports.MAX_DEPTH)
+            this.err(`nesting deeper than ${exports.MAX_DEPTH} levels (implementation limit)`);
+        const s = this.s;
+        const c = s[this.i];
+        if (c === '{')
+            return this.object(path, depth);
+        if (c === '[')
+            return this.array(path, depth);
+        if (c === '"')
+            return this.string(path);
+        if (c === 't' && s.startsWith('true', this.i)) {
+            this.i += 4;
+            return true;
+        }
+        if (c === 'f' && s.startsWith('false', this.i)) {
+            this.i += 5;
+            return false;
+        }
+        if (c === 'n' && s.startsWith('null', this.i)) {
+            this.i += 4;
+            return null;
+        }
+        if (c === '-' || (c >= '0' && c <= '9'))
+            return this.number(path);
+        if (c === undefined)
+            this.err('unexpected end of input');
+        if (s.startsWith('NaN', this.i) || s.startsWith('Infinity', this.i) || s.startsWith('-Infinity', this.i)) {
+            this.err('NaN and Infinity are not JSON');
+        }
+        this.err(`unexpected character ${JSON.stringify(c)}`);
+    }
+    object(path, depth) {
+        this.i++; // {
+        const o = newObject();
+        let dup = null;
+        this.ws();
+        if (this.s[this.i] === '}') {
+            this.i++;
+            return o;
+        }
+        for (;;) {
+            this.ws();
+            if (this.s[this.i] !== '"')
+                this.err('expected a member name');
+            const k = this.string(path);
+            this.ws();
+            if (this.s[this.i] !== ':')
+                this.err("expected ':'");
+            this.i++;
+            this.ws();
+            const v = this.value(memberPath(path, k), depth + 1);
+            if (has(o, k)) {
+                if (dup === null)
+                    dup = k;
+            }
+            else
+                o[k] = v;
+            this.ws();
+            const c = this.s[this.i];
+            if (c === ',') {
+                this.i++;
+                continue;
+            }
+            if (c === '}') {
+                this.i++;
+                break;
+            }
+            this.err("expected ',' or '}'");
+        }
+        // Like an object-pairs hook, duplicates are reported once the object is complete.
+        if (dup !== null)
+            (0, errors_js_1.fail)('E_PARSE_DUPLICATE_KEY', `duplicate member ${JSON.stringify(dup)}`, path);
+        return o;
+    }
+    array(path, depth) {
+        this.i++; // [
+        const a = [];
+        this.ws();
+        if (this.s[this.i] === ']') {
+            this.i++;
+            return a;
+        }
+        for (;;) {
+            this.ws();
+            a.push(this.value(`${path}[${a.length}]`, depth + 1));
+            this.ws();
+            const c = this.s[this.i];
+            if (c === ',') {
+                this.i++;
+                continue;
+            }
+            if (c === ']') {
+                this.i++;
+                return a;
+            }
+            this.err("expected ',' or ']'");
+        }
+    }
+    string(path) {
+        const s = this.s;
+        this.i++; // opening quote
+        let out = '';
+        let start = this.i;
+        for (;;) {
+            if (this.i >= s.length)
+                this.err('unterminated string');
+            const c = s.charCodeAt(this.i);
+            if (c === 0x22) {
+                out += s.slice(start, this.i);
+                this.i++;
+                break;
+            }
+            if (c < 0x20)
+                this.err('control character in string');
+            if (c === 0x5c) {
+                out += s.slice(start, this.i);
+                const e = s[this.i + 1];
+                let ch;
+                switch (e) {
+                    case '"':
+                        ch = '"';
+                        break;
+                    case '\\':
+                        ch = '\\';
+                        break;
+                    case '/':
+                        ch = '/';
+                        break;
+                    case 'b':
+                        ch = '\b';
+                        break;
+                    case 'f':
+                        ch = '\f';
+                        break;
+                    case 'n':
+                        ch = '\n';
+                        break;
+                    case 'r':
+                        ch = '\r';
+                        break;
+                    case 't':
+                        ch = '\t';
+                        break;
+                    case 'u': {
+                        const h = s.slice(this.i + 2, this.i + 6);
+                        if (!/^[0-9A-Fa-f]{4}$/.test(h))
+                            this.err('bad \\u escape');
+                        ch = String.fromCharCode(parseInt(h, 16));
+                        this.i += 4;
+                        break;
+                    }
+                    default:
+                        this.err('bad escape');
+                }
+                out += ch;
+                this.i += 2;
+                start = this.i;
+                continue;
+            }
+            this.i++;
+        }
+        if (this.surrogatePath === null && (0, unicode_js_1.hasLoneSurrogate)(out))
+            this.surrogatePath = path;
+        return out;
+    }
+    number(path) {
+        const s = this.s;
+        const m = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+        m.lastIndex = this.i;
+        const r = m.exec(s);
+        if (!r || r[0] === '-' || r[0] === '')
+            this.err('bad number');
+        const text = r[0];
+        // A digit right after "0" (e.g. 01) is not JSON.
+        const next = s[this.i + text.length];
+        if (next !== undefined && /[0-9.eE+-]/.test(next))
+            this.err('bad number');
+        this.i += text.length;
+        const n = Number(text);
+        if (!Number.isFinite(n))
+            (0, errors_js_1.fail)('E_PARSE_JSON', `number out of IEEE 754 range: ${text.slice(0, 40)}`, '$');
+        this.numbers?.set(path, text);
+        return n;
+    }
+}
+/** Parse JSON text strictly. */
+function parseJsonText(text, numbers) {
+    if (text.charCodeAt(0) === 0xfeff)
+        (0, errors_js_1.fail)('E_PARSE_JSON', 'byte order mark', '$');
+    if ((0, unicode_js_1.hasLoneSurrogate)(text))
+        (0, errors_js_1.fail)('E_PARSE_JSON', 'lone surrogate in the text', '$');
+    const p = new Parser(text, numbers);
+    const v = p.parseDocument();
+    if (p.surrogatePath !== null)
+        (0, errors_js_1.fail)('E_PARSE_JSON', 'lone surrogate', p.surrogatePath);
+    return v;
+}
+/** Parse UTF-8 JSON bytes strictly: no BOM, no invalid UTF-8. */
+function parseJsonBytes(bytes, numbers) {
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        (0, errors_js_1.fail)('E_PARSE_JSON', 'byte order mark', '$');
+    }
+    const text = (0, utf8_js_1.utf8Decode)(bytes);
+    if (text === null)
+        (0, errors_js_1.fail)('E_PARSE_JSON', 'invalid UTF-8', '$');
+    return parseJsonText(text, numbers);
+}
+/**
+ * Check an already-parsed JavaScript value against the JSON data model and return a private
+ * deep copy (plain data with null-prototype objects), so later checks cannot be affected by
+ * getters, prototypes or mutation. Duplicate members cannot be detected here: pass JSON text
+ * or bytes for that.
+ */
+function normalizeValue(v, path = '$', depth = 0) {
+    if (depth > exports.MAX_DEPTH)
+        (0, errors_js_1.fail)('E_PARSE_JSON', `nesting deeper than ${exports.MAX_DEPTH} levels (or a cycle)`, path);
+    if (v === null || typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            (0, errors_js_1.fail)('E_PARSE_JSON', 'NaN and Infinity are not JSON', path);
+        return v;
+    }
+    if (typeof v === 'string') {
+        if ((0, unicode_js_1.hasLoneSurrogate)(v))
+            (0, errors_js_1.fail)('E_PARSE_JSON', 'lone surrogate', path);
+        return v;
+    }
+    if (Array.isArray(v))
+        return v.map((x, i) => normalizeValue(x, `${path}[${i}]`, depth + 1));
+    if (typeof v === 'object') {
+        const proto = Object.getPrototypeOf(v);
+        if (proto !== Object.prototype && proto !== null)
+            (0, errors_js_1.fail)('E_PARSE_JSON', 'not a plain JSON object', path);
+        const o = newObject();
+        for (const k of Object.keys(v)) {
+            if ((0, unicode_js_1.hasLoneSurrogate)(k))
+                (0, errors_js_1.fail)('E_PARSE_JSON', 'lone surrogate in a member name', path);
+            o[k] = normalizeValue(v[k], memberPath(path, k), depth + 1);
+        }
+        return o;
+    }
+    (0, errors_js_1.fail)('E_PARSE_JSON', `${typeof v} is not a JSON value`, path);
+}
+/** JSON text (string), UTF-8 bytes (Uint8Array) or an already-parsed value. */
+function toJson(input, numbers) {
+    if (typeof input === 'string')
+        return parseJsonText(input, numbers);
+    if (input instanceof Uint8Array)
+        return parseJsonBytes(input, numbers);
+    if (input instanceof ArrayBuffer)
+        return parseJsonBytes(new Uint8Array(input), numbers);
+    return normalizeValue(input);
+}