@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/stdlib/json.js

@@ -0,0 +1,764 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _JsonLikeParser_instances, _JsonLikeParser_index, _JsonLikeParser_text, _JsonLikeParser_consumeKeyword, _JsonLikeParser_parseArray, _JsonLikeParser_parseNumber, _JsonLikeParser_parseObject, _JsonLikeParser_parseString, _JsonLikeParser_consumeDigits, _JsonLikeParser_skipWhitespace, _JsonLikeParser_isDigit, _JsonLikeParser_error;
+import { Failure } from '@soundscript/soundscript/failures';
+import { isErr, resultOf } from '@soundscript/soundscript/result';
+import { F32, F64, format as formatNumeric, I8, I16, I32, I64, isNumeric, toHostNumber, U8, U16, U32, U64, } from './numerics.js';
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+export class JsonParseFailure extends Failure {
+    constructor(cause) {
+        super('Failed to parse JSON.', { cause });
+    }
+}
+export class JsonStringifyFailure extends Failure {
+    constructor(cause) {
+        super('Failed to stringify JSON.', { cause });
+    }
+}
+export function parseJson(text, options = {}) {
+    return resultOf(() => {
+        const parsed = options.int64 === 'lossless' ? parseLosslessJson(text) : JSON.parse(text);
+        return options.numerics === 'tagged'
+            ? decodeTaggedMachineJsonValue(parsed)
+            : parsed;
+    }, (cause) => new JsonParseFailure(cause));
+}
+export function stringifyJson(value, options = {}) {
+    return resultOf(() => {
+        if (options.numerics) {
+            const normalized = normalizeMachineJsonLikeValue(value, new Set(), options.numerics, 'root');
+            const encoded = stringifyJsonLikeInternal(normalized, new Set(), options.bigint ?? 'reject', 'root');
+            if (encoded === undefined) {
+                throw new TypeError('JSON stringification produced no top-level value.');
+            }
+            return encoded;
+        }
+        if (options.int64 === 'string') {
+            return stringifyJsonWithInt64Mode(value, 'string');
+        }
+        if (options.int64 === 'lossless') {
+            return stringifyJsonWithInt64Mode(value, 'lossless');
+        }
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined) {
+            throw new TypeError('JSON.stringify returned undefined for a JsonValue input.');
+        }
+        return encoded;
+    }, (cause) => new JsonStringifyFailure(cause));
+}
+export function parseAndDecode(text, decoder) {
+    const parsed = parseJson(text);
+    return isErr(parsed) ? parsed : decoder.decode(parsed.value);
+}
+export function encodeAndStringify(value, encoder) {
+    const encoded = encoder.encode(value);
+    return isErr(encoded) ? encoded : stringifyJson(encoded.value);
+}
+export function isJsonValue(value) {
+    return isJsonValueInternal(value, new Set());
+}
+export function parseJsonLike(text) {
+    return resultOf(() => {
+        const parser = new JsonLikeParser(text);
+        const value = parser.parseValue();
+        parser.finish();
+        return value;
+    }, (cause) => new JsonParseFailure(cause));
+}
+export function stringifyJsonLike(value, options = {}) {
+    return resultOf(() => {
+        const encoded = stringifyJsonLikeInternal(value, new Set(), options.bigint ?? 'reject', 'root');
+        if (encoded === undefined) {
+            throw new TypeError('JSON-like stringification produced no top-level value.');
+        }
+        return encoded;
+    }, (cause) => new JsonStringifyFailure(cause));
+}
+export function decodeJson(text, decoder) {
+    const parsed = parseJsonLike(text);
+    return isErr(parsed) ? parsed : decoder.decode(parsed.value);
+}
+export function encodeJson(value, encoder, options = {}) {
+    const encoded = encoder.encode(value);
+    return isErr(encoded) ? encoded : stringifyJsonLike(encoded.value, options);
+}
+export function isJsonLikeValue(value) {
+    return isJsonLikeValueInternal(value, new Set());
+}
+function stringifyJsonWithInt64Mode(value, int64Mode) {
+    return stringifyJsonWithInt64ModeInternal(value, int64Mode, new Set());
+}
+function stringifyJsonWithInt64ModeInternal(value, int64Mode, visited) {
+    switch (typeof value) {
+        case 'string':
+            return JSON.stringify(value);
+        case 'number': {
+            const encoded = JSON.stringify(value);
+            if (encoded === undefined) {
+                throw new TypeError('JSON.stringify returned undefined for a numeric input.');
+            }
+            return encoded;
+        }
+        case 'bigint':
+            return int64Mode === 'string'
+                ? JSON.stringify(value.toString())
+                : value.toString();
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'object':
+            if (value === null) {
+                return 'null';
+            }
+            if (visited.has(value)) {
+                throw new TypeError('Could not stringify cyclic JSON value.');
+            }
+            visited.add(value);
+            try {
+                if (Array.isArray(value)) {
+                    return `[${value.map((entry) => stringifyJsonWithInt64ModeInternal(entry, int64Mode, visited)).join(',')}]`;
+                }
+                const fields = Object.keys(value).map((key) => `${JSON.stringify(key)}:${stringifyJsonWithInt64ModeInternal(value[key], int64Mode, visited)}`);
+                return `{${fields.join(',')}}`;
+            }
+            finally {
+                visited.delete(value);
+            }
+        default:
+            throw new TypeError(`Unsupported JSON value kind: ${typeof value}`);
+    }
+}
+function parseLosslessJson(text) {
+    const parser = new LosslessJsonParser(text);
+    const value = parser.parseValue();
+    parser.skipWhitespace();
+    if (!parser.isAtEnd()) {
+        parser.fail('Unexpected trailing characters.');
+    }
+    return value;
+}
+function isJsonValueInternal(value, visited) {
+    switch (typeof value) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return true;
+        case 'object':
+            if (value === null) {
+                return true;
+            }
+            if (visited.has(value)) {
+                return true;
+            }
+            visited.add(value);
+            try {
+                if (Array.isArray(value)) {
+                    return value.every((entry) => isJsonValueInternal(entry, visited));
+                }
+                for (const key of Object.keys(value)) {
+                    if (!isJsonValueInternal(value[key], visited)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            finally {
+                visited.delete(value);
+            }
+        default:
+            return false;
+    }
+}
+function isJsonLikeValueInternal(value, visited) {
+    switch (typeof value) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+        case 'undefined':
+            return true;
+        case 'object':
+            if (value === null) {
+                return true;
+            }
+            if (visited.has(value)) {
+                return true;
+            }
+            visited.add(value);
+            try {
+                if (Array.isArray(value)) {
+                    return value.every((entry) => isJsonLikeValueInternal(entry, visited));
+                }
+                for (const key of Object.keys(value)) {
+                    if (!isJsonLikeValueInternal(value[key], visited)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            finally {
+                visited.delete(value);
+            }
+        default:
+            return false;
+    }
+}
+function normalizeMachineJsonLikeValue(value, visited, numericMode, position) {
+    if (isNumeric(value)) {
+        return normalizeMachineNumericJsonValue(value, numericMode);
+    }
+    switch (typeof value) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return value;
+        case 'undefined':
+            return position === 'array' ? null : undefined;
+        case 'object':
+            if (value === null) {
+                return null;
+            }
+            if (visited.has(value)) {
+                throw new TypeError('Converting circular structure to machine JSON text.');
+            }
+            visited.add(value);
+            try {
+                if (Array.isArray(value)) {
+                    return value.map((entry) => normalizeMachineJsonLikeValue(entry, visited, numericMode, 'array') ?? null);
+                }
+                const result = {};
+                for (const key of Object.keys(value)) {
+                    const normalized = normalizeMachineJsonLikeValue(value[key], visited, numericMode, 'object');
+                    if (normalized !== undefined) {
+                        result[key] = normalized;
+                    }
+                }
+                return result;
+            }
+            finally {
+                visited.delete(value);
+            }
+        default:
+            throw new TypeError(`Unsupported machine JSON value kind: ${typeof value}`);
+    }
+}
+function normalizeMachineNumericJsonValue(value, numericMode) {
+    switch (numericMode) {
+        case 'tagged':
+            return value.toJSON();
+        case 'decimal-string':
+            return formatNumeric(value);
+        case 'json-number':
+            switch (value.__soundscript_numeric_kind) {
+                case 'i64':
+                case 'u64':
+                    throw new TypeError('json-number machine JSON mode does not support bigint-backed machine numerics.');
+                default:
+                    return toHostNumber(value);
+            }
+    }
+}
+function decodeTaggedMachineJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => decodeTaggedMachineJsonValue(entry));
+    }
+    if (value && typeof value === 'object') {
+        const taggedNumeric = decodeTaggedMachineNumeric(value);
+        if (taggedNumeric) {
+            return taggedNumeric;
+        }
+        const result = {};
+        for (const key of Object.keys(value)) {
+            result[key] = decodeTaggedMachineJsonValue(value[key]);
+        }
+        return result;
+    }
+    return value;
+}
+function decodeTaggedMachineNumeric(value) {
+    const numericKind = value['$numeric'];
+    const numericValue = value['value'];
+    const keys = Object.keys(value);
+    if (typeof numericKind !== 'string' ||
+        typeof numericValue !== 'string' ||
+        keys.length !== 2 ||
+        !keys.includes('$numeric') ||
+        !keys.includes('value')) {
+        return undefined;
+    }
+    switch (numericKind) {
+        case 'f64':
+            return F64.parse(numericValue);
+        case 'f32':
+            return F32.parse(numericValue);
+        case 'i8':
+            return I8.parse(numericValue);
+        case 'i16':
+            return I16.parse(numericValue);
+        case 'i32':
+            return I32.parse(numericValue);
+        case 'i64':
+            return I64.parse(numericValue);
+        case 'u8':
+            return U8.parse(numericValue);
+        case 'u16':
+            return U16.parse(numericValue);
+        case 'u32':
+            return U32.parse(numericValue);
+        case 'u64':
+            return U64.parse(numericValue);
+        default:
+            return undefined;
+    }
+}
+function stringifyJsonLikeInternal(value, visited, bigintMode, position) {
+    switch (typeof value) {
+        case 'string':
+            return JSON.stringify(value);
+        case 'number':
+            return Number.isFinite(value) ? JSON.stringify(value) : 'null';
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'bigint':
+            switch (bigintMode) {
+                case 'string':
+                    return JSON.stringify(value.toString());
+                case 'number':
+                    return value.toString();
+                case 'reject':
+                    throw new TypeError('Encountered bigint while stringifying JSON-like data.');
+            }
+        case 'undefined':
+            return position === 'array' ? 'null' : undefined;
+        case 'object':
+            if (value === null) {
+                return 'null';
+            }
+            if (visited.has(value)) {
+                throw new TypeError('Converting circular structure to JSON-like text.');
+            }
+            visited.add(value);
+            try {
+                if (Array.isArray(value)) {
+                    return `[${value.map((entry) => stringifyJsonLikeInternal(entry, visited, bigintMode, 'array') ?? 'null').join(',')}]`;
+                }
+                const encodedProperties = [];
+                for (const key of Object.keys(value)) {
+                    const encodedValue = stringifyJsonLikeInternal(value[key], visited, bigintMode, 'object');
+                    if (encodedValue === undefined) {
+                        continue;
+                    }
+                    encodedProperties.push(`${JSON.stringify(key)}:${encodedValue}`);
+                }
+                return `{${encodedProperties.join(',')}}`;
+            }
+            finally {
+                visited.delete(value);
+            }
+        default:
+            throw new TypeError('Encountered an unsupported JSON-like value.');
+    }
+}
+class LosslessJsonParser {
+    constructor(text) {
+        this.index = 0;
+        this.text = text;
+    }
+    fail(message) {
+        throw new SyntaxError(`${message} At character ${this.index}.`);
+    }
+    isAtEnd() {
+        return this.index >= this.text.length;
+    }
+    skipWhitespace() {
+        while (!this.isAtEnd() && /\s/u.test(this.text[this.index])) {
+            this.index += 1;
+        }
+    }
+    parseValue() {
+        this.skipWhitespace();
+        if (this.isAtEnd()) {
+            this.fail('Unexpected end of JSON input.');
+        }
+        const current = this.text[this.index];
+        switch (current) {
+            case '"':
+                return this.parseString();
+            case '{':
+                return this.parseObject();
+            case '[':
+                return this.parseArray();
+            case 't':
+                this.consumeKeyword('true');
+                return true;
+            case 'f':
+                this.consumeKeyword('false');
+                return false;
+            case 'n':
+                this.consumeKeyword('null');
+                return null;
+            default:
+                if (current === '-' || isAsciiDigit(current)) {
+                    return this.parseNumber();
+                }
+                this.fail(`Unexpected token ${JSON.stringify(current)}.`);
+        }
+    }
+    consumeKeyword(keyword) {
+        if (!this.text.startsWith(keyword, this.index)) {
+            this.fail(`Expected ${keyword}.`);
+        }
+        this.index += keyword.length;
+    }
+    parseString() {
+        let result = '';
+        this.index += 1;
+        while (!this.isAtEnd()) {
+            const current = this.text[this.index];
+            if (current === '"') {
+                this.index += 1;
+                return result;
+            }
+            if (current === '\\') {
+                this.index += 1;
+                if (this.isAtEnd()) {
+                    this.fail('Unexpected end of escape sequence.');
+                }
+                result += this.parseEscapeSequence();
+                continue;
+            }
+            result += current;
+            this.index += 1;
+        }
+        this.fail('Unterminated string literal.');
+    }
+    parseEscapeSequence() {
+        const current = this.text[this.index];
+        this.index += 1;
+        switch (current) {
+            case '"':
+            case '\\':
+            case '/':
+                return current;
+            case 'b':
+                return '\b';
+            case 'f':
+                return '\f';
+            case 'n':
+                return '\n';
+            case 'r':
+                return '\r';
+            case 't':
+                return '\t';
+            case 'u': {
+                const hex = this.text.slice(this.index, this.index + 4);
+                if (!/^[0-9A-Fa-f]{4}$/u.test(hex)) {
+                    this.fail('Invalid unicode escape.');
+                }
+                this.index += 4;
+                return String.fromCharCode(Number.parseInt(hex, 16));
+            }
+            default:
+                this.fail(`Invalid escape sequence \\${current}.`);
+        }
+    }
+    parseArray() {
+        const result = [];
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.text[this.index] === ']') {
+            this.index += 1;
+            return result;
+        }
+        while (true) {
+            result.push(this.parseValue());
+            this.skipWhitespace();
+            const current = this.text[this.index];
+            if (current === ']') {
+                this.index += 1;
+                return result;
+            }
+            if (current !== ',') {
+                this.fail('Expected , or ] in array literal.');
+            }
+            this.index += 1;
+        }
+    }
+    parseObject() {
+        const result = {};
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.text[this.index] === '}') {
+            this.index += 1;
+            return result;
+        }
+        while (true) {
+            this.skipWhitespace();
+            if (this.text[this.index] !== '"') {
+                this.fail('Expected string key in object literal.');
+            }
+            const key = this.parseString();
+            this.skipWhitespace();
+            if (this.text[this.index] !== ':') {
+                this.fail('Expected : after object key.');
+            }
+            this.index += 1;
+            result[key] = this.parseValue();
+            this.skipWhitespace();
+            const current = this.text[this.index];
+            if (current === '}') {
+                this.index += 1;
+                return result;
+            }
+            if (current !== ',') {
+                this.fail('Expected , or } in object literal.');
+            }
+            this.index += 1;
+        }
+    }
+    parseNumber() {
+        const start = this.index;
+        if (this.text[this.index] === '-') {
+            this.index += 1;
+        }
+        if (this.text[this.index] === '0') {
+            this.index += 1;
+        }
+        else {
+            this.consumeDigits();
+        }
+        let isInteger = true;
+        if (this.text[this.index] === '.') {
+            isInteger = false;
+            this.index += 1;
+            this.consumeDigits();
+        }
+        const exponentMarker = this.text[this.index];
+        if (exponentMarker === 'e' || exponentMarker === 'E') {
+            isInteger = false;
+            this.index += 1;
+            const sign = this.text[this.index];
+            if (sign === '+' || sign === '-') {
+                this.index += 1;
+            }
+            this.consumeDigits();
+        }
+        const token = this.text.slice(start, this.index);
+        if (!isInteger) {
+            return Number(token);
+        }
+        if (token === '-0') {
+            return -0;
+        }
+        const bigintValue = BigInt(token);
+        return bigintValue <= MAX_SAFE_INTEGER_BIGINT && bigintValue >= MIN_SAFE_INTEGER_BIGINT
+            ? Number(token)
+            : bigintValue;
+    }
+    consumeDigits() {
+        const start = this.index;
+        while (!this.isAtEnd() && isAsciiDigit(this.text[this.index])) {
+            this.index += 1;
+        }
+        if (start === this.index) {
+            this.fail('Expected digits.');
+        }
+    }
+}
+class JsonLikeParser {
+    constructor(text) {
+        _JsonLikeParser_instances.add(this);
+        _JsonLikeParser_index.set(this, 0);
+        _JsonLikeParser_text.set(this, void 0);
+        __classPrivateFieldSet(this, _JsonLikeParser_text, text, "f");
+    }
+    finish() {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        if (__classPrivateFieldGet(this, _JsonLikeParser_index, "f") !== __classPrivateFieldGet(this, _JsonLikeParser_text, "f").length) {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Unexpected trailing JSON input');
+        }
+    }
+    parseValue() {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        const current = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+        switch (current) {
+            case '{':
+                return __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_parseObject).call(this);
+            case '[':
+                return __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_parseArray).call(this);
+            case '"':
+                return __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_parseString).call(this);
+            case 't':
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeKeyword).call(this, 'true');
+                return true;
+            case 'f':
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeKeyword).call(this, 'false');
+                return false;
+            case 'n':
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeKeyword).call(this, 'null');
+                return null;
+            default:
+                if (current === '-' || __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_isDigit).call(this, current)) {
+                    return __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_parseNumber).call(this);
+                }
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Unexpected token in JSON input');
+        }
+    }
+}
+_JsonLikeParser_index = new WeakMap(), _JsonLikeParser_text = new WeakMap(), _JsonLikeParser_instances = new WeakSet(), _JsonLikeParser_consumeKeyword = function _JsonLikeParser_consumeKeyword(keyword) {
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f").slice(__classPrivateFieldGet(this, _JsonLikeParser_index, "f"), __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + keyword.length) !== keyword) {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, `Expected ${keyword}`);
+    }
+    __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + keyword.length, "f");
+}, _JsonLikeParser_parseArray = function _JsonLikeParser_parseArray() {
+    const values = [];
+    __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] === ']') {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        return values;
+    }
+    while (true) {
+        values.push(this.parseValue());
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        const current = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+        if (current === ']') {
+            __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+            return values;
+        }
+        if (current !== ',') {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected , or ] in JSON array');
+        }
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+}, _JsonLikeParser_parseNumber = function _JsonLikeParser_parseNumber() {
+    const start = __classPrivateFieldGet(this, _JsonLikeParser_index, "f");
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] === '-') {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] === '0') {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+    else {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeDigits).call(this);
+    }
+    let isInteger = true;
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] === '.') {
+        isInteger = false;
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeDigits).call(this);
+    }
+    const exponent = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+    if (exponent === 'e' || exponent === 'E') {
+        isInteger = false;
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        const sign = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+        if (sign === '+' || sign === '-') {
+            __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        }
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_consumeDigits).call(this);
+    }
+    const token = __classPrivateFieldGet(this, _JsonLikeParser_text, "f").slice(start, __classPrivateFieldGet(this, _JsonLikeParser_index, "f"));
+    if (!isInteger) {
+        return Number(token);
+    }
+    const bigintValue = BigInt(token);
+    const numberValue = Number(token);
+    return Number.isSafeInteger(numberValue) && BigInt(numberValue) === bigintValue
+        ? numberValue
+        : bigintValue;
+}, _JsonLikeParser_parseObject = function _JsonLikeParser_parseObject() {
+    const object = {};
+    __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+    if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] === '}') {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        return object;
+    }
+    while (true) {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] !== '"') {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected string key in JSON object');
+        }
+        const key = __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_parseString).call(this);
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        if (__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] !== ':') {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected : in JSON object');
+        }
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+        object[key] = this.parseValue();
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_skipWhitespace).call(this);
+        const current = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+        if (current === '}') {
+            __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+            return object;
+        }
+        if (current !== ',') {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected , or } in JSON object');
+        }
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+}, _JsonLikeParser_parseString = function _JsonLikeParser_parseString() {
+    const start = __classPrivateFieldGet(this, _JsonLikeParser_index, "f");
+    __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    while (__classPrivateFieldGet(this, _JsonLikeParser_index, "f") < __classPrivateFieldGet(this, _JsonLikeParser_text, "f").length) {
+        const current = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+        if (current === '"') {
+            __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+            const parsed = JSON.parse(__classPrivateFieldGet(this, _JsonLikeParser_text, "f").slice(start, __classPrivateFieldGet(this, _JsonLikeParser_index, "f")));
+            if (typeof parsed !== 'string') {
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected string literal.');
+            }
+            return parsed;
+        }
+        if (current === '\\') {
+            __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+            const escaped = __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")];
+            if (escaped === undefined) {
+                __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Unterminated string escape');
+            }
+            if (escaped === 'u') {
+                for (let index = 0; index < 4; index += 1) {
+                    __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+                    if (!/[0-9A-Fa-f]/u.test(__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] ?? '')) {
+                        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Invalid unicode escape');
+                    }
+                }
+            }
+        }
+        else if (current !== undefined && current <= '\u001F') {
+            __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Invalid control character in string literal');
+        }
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+    __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Unterminated string literal');
+}, _JsonLikeParser_consumeDigits = function _JsonLikeParser_consumeDigits() {
+    const start = __classPrivateFieldGet(this, _JsonLikeParser_index, "f");
+    while (__classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_isDigit).call(this, __classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")])) {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+    if (start === __classPrivateFieldGet(this, _JsonLikeParser_index, "f")) {
+        __classPrivateFieldGet(this, _JsonLikeParser_instances, "m", _JsonLikeParser_error).call(this, 'Expected digit in JSON number');
+    }
+}, _JsonLikeParser_skipWhitespace = function _JsonLikeParser_skipWhitespace() {
+    while (/\s/u.test(__classPrivateFieldGet(this, _JsonLikeParser_text, "f")[__classPrivateFieldGet(this, _JsonLikeParser_index, "f")] ?? '')) {
+        __classPrivateFieldSet(this, _JsonLikeParser_index, __classPrivateFieldGet(this, _JsonLikeParser_index, "f") + 1, "f");
+    }
+}, _JsonLikeParser_isDigit = function _JsonLikeParser_isDigit(value) {
+    return value !== undefined && value >= '0' && value <= '9';
+}, _JsonLikeParser_error = function _JsonLikeParser_error(message) {
+    throw new SyntaxError(`${message} at position ${__classPrivateFieldGet(this, _JsonLikeParser_index, "f")}.`);
+};
+function isAsciiDigit(text) {
+    return text >= '0' && text <= '9';
+}