jsonc-effect 0.2.0 → 0.3.0

package/index.js

@@ -1,1454 +1,11 @@
-import { Chunk, Data, Effect, Function, Option, ParseResult, Schema, Stream } from "effect";
-const findNode = Function.dual(2, (root, path)=>Effect.sync(()=>findNodeImpl(root, path)));
-const findNodeAtOffset = Function.dual(2, (root, offset)=>Effect.sync(()=>findNodeAtOffsetImpl(root, offset)));
-const getNodePath = Function.dual(2, (root, targetOffset)=>Effect.sync(()=>buildPath(root, targetOffset, [])));
-const getNodeValue = (node)=>Effect.sync(()=>evaluateNode(node));
-function findNodeImpl(root, path) {
-    let current = root;
-    for (const segment of path){
-        if (!current?.children) return Option.none();
-        if ("string" == typeof segment) {
-            if ("object" !== current.type) return Option.none();
-            const property = current.children.find((child)=>"property" === child.type && void 0 !== child.children && child.children[0]?.value === segment);
-            current = property?.children?.[1];
-        } else {
-            if ("array" !== current.type) return Option.none();
-            current = current.children[segment];
-        }
-    }
-    return current ? Option.some(current) : Option.none();
-}
-function findNodeAtOffsetImpl(root, offset) {
-    if (offset < root.offset || offset >= root.offset + root.length) return Option.none();
-    if (!root.children) return Option.some(root);
-    for (const child of root.children)if (offset >= child.offset && offset < child.offset + child.length) return findNodeAtOffsetImpl(child, offset);
-    return Option.some(root);
-}
-function buildPath(node, targetOffset, currentPath) {
-    if (targetOffset < node.offset || targetOffset >= node.offset + node.length) return Option.none();
-    if (!node.children) return Option.some(currentPath);
-    if ("object" === node.type) {
-        for (const prop of node.children)if ("property" === prop.type && void 0 !== prop.children && targetOffset >= prop.offset && targetOffset < prop.offset + prop.length) {
-            const key = prop.children[0]?.value;
-            const valuePath = [
-                ...currentPath,
-                key
-            ];
-            const valueChild = prop.children[1];
-            if (valueChild && targetOffset >= valueChild.offset && targetOffset < valueChild.offset + valueChild.length) return buildPath(valueChild, targetOffset, valuePath);
-            return Option.some(valuePath);
-        }
-    } else if ("array" === node.type) for(let i = 0; i < node.children.length; i++){
-        const child = node.children[i];
-        if (targetOffset >= child.offset && targetOffset < child.offset + child.length) return buildPath(child, targetOffset, [
-            ...currentPath,
-            i
-        ]);
-    }
-    return Option.some(currentPath);
-}
-function evaluateNode(node) {
-    switch(node.type){
-        case "object":
-            {
-                const obj = {};
-                if (node.children) {
-                    for (const prop of node.children)if ("property" === prop.type && void 0 !== prop.children && 2 === prop.children.length) {
-                        const key = prop.children[0].value;
-                        obj[key] = evaluateNode(prop.children[1]);
-                    }
-                }
-                return obj;
-            }
-        case "array":
-            return (node.children ?? []).map(evaluateNode);
-        case "property":
-            return node.children?.[1] ? evaluateNode(node.children[1]) : void 0;
-        case "string":
-        case "number":
-        case "boolean":
-        case "null":
-            return node.value;
-    }
-}
-const JsoncParseErrorCode = Schema.Literal("InvalidSymbol", "InvalidNumberFormat", "PropertyNameExpected", "ValueExpected", "ColonExpected", "CommaExpected", "CloseBraceExpected", "CloseBracketExpected", "EndOfFileExpected", "InvalidCommentToken", "UnexpectedEndOfComment", "UnexpectedEndOfString", "UnexpectedEndOfNumber", "InvalidUnicode", "InvalidEscapeCharacter", "InvalidCharacter");
-class JsoncParseErrorDetail extends Schema.Class("JsoncParseErrorDetail")({
-    code: JsoncParseErrorCode,
-    message: Schema.String,
-    offset: Schema.Number,
-    length: Schema.Number,
-    startLine: Schema.Number,
-    startCharacter: Schema.Number
-}) {
-}
-const JsoncParseErrorBase = Data.TaggedError("JsoncParseError");
-class JsoncParseError extends JsoncParseErrorBase {
-    get message() {
-        const count = this.errors.length;
-        return `JSONC parse failed with ${count} error${1 !== count ? "s" : ""}: ${this.errors.map((e)=>e.message).join("; ")}`;
-    }
-}
-const JsoncNodeNotFoundErrorBase = Data.TaggedError("JsoncNodeNotFoundError");
-class JsoncNodeNotFoundError extends JsoncNodeNotFoundErrorBase {
-    get message() {
-        return `Node not found at path [${this.path.join(", ")}] in ${this.rootNodeType} node`;
-    }
-}
-const JsoncModificationErrorBase = Data.TaggedError("JsoncModificationError");
-class JsoncModificationError extends JsoncModificationErrorBase {
-    get message() {
-        return `Modification failed at path [${this.path.join(", ")}]: ${this.reason}`;
-    }
-}
-const isWhitespace = (ch)=>0x20 === ch || 0x09 === ch || 0x0b === ch || 0x0c === ch || 0xa0 === ch || 0xfeff === ch;
-const isLineBreak = (ch)=>0x0a === ch || 0x0d === ch || 0x2028 === ch || 0x2029 === ch;
-const isDigit = (ch)=>ch >= 0x30 && ch <= 0x39;
-const createScanner = (text, ignoreTrivia = false)=>{
-    const len = text.length;
-    let pos = 0;
-    let tokenOffset = 0;
-    let token = "Unknown";
-    let tokenValue = "";
-    let tokenError = "None";
-    let lineNumber = 0;
-    let lineStartOffset = 0;
-    let tokenStartLine = 0;
-    let tokenStartCharacter = 0;
-    const scanHexDigits = (count)=>{
-        let value = 0;
-        for(let i = 0; i < count; i++){
-            if (pos >= len) return -1;
-            const ch = text.charCodeAt(pos);
-            if (ch >= 0x30 && ch <= 0x39) value = 16 * value + (ch - 0x30);
-            else if (ch >= 0x41 && ch <= 0x46) value = 16 * value + (ch - 0x41 + 10);
-            else {
-                if (!(ch >= 0x61) || !(ch <= 0x66)) return -1;
-                value = 16 * value + (ch - 0x61 + 10);
-            }
-            pos++;
-        }
-        return value;
-    };
-    const scanString = ()=>{
-        let result = "";
-        pos++;
-        let start = pos;
-        while(pos < len){
-            const ch = text.charCodeAt(pos);
-            if (0x22 === ch) {
-                result += text.substring(start, pos);
-                pos++;
-                return result;
-            }
-            if (0x5c === ch) {
-                result += text.substring(start, pos);
-                pos++;
-                if (pos >= len) {
-                    tokenError = "UnexpectedEndOfString";
-                    return result;
-                }
-                const escaped = text.charCodeAt(pos);
-                pos++;
-                switch(escaped){
-                    case 0x22:
-                        result += '"';
-                        break;
-                    case 0x5c:
-                        result += "\\";
-                        break;
-                    case 0x2f:
-                        result += "/";
-                        break;
-                    case 0x62:
-                        result += "\b";
-                        break;
-                    case 0x66:
-                        result += "\f";
-                        break;
-                    case 0x6e:
-                        result += "\n";
-                        break;
-                    case 0x72:
-                        result += "\r";
-                        break;
-                    case 0x74:
-                        result += "\t";
-                        break;
-                    case 0x75:
-                        {
-                            const value = scanHexDigits(4);
-                            if (value >= 0) result += String.fromCharCode(value);
-                            else tokenError = "InvalidUnicode";
-                            break;
-                        }
-                    default:
-                        tokenError = "InvalidEscapeCharacter";
-                        break;
-                }
-                start = pos;
-            } else if (isLineBreak(ch)) {
-                tokenError = "UnexpectedEndOfString";
-                return result + text.substring(start, pos);
-            } else pos++;
-        }
-        tokenError = "UnexpectedEndOfString";
-        return result + text.substring(start, pos);
-    };
-    const scanNumber = ()=>{
-        const start = pos;
-        if (0x2d === text.charCodeAt(pos)) pos++;
-        if (0x30 === text.charCodeAt(pos)) pos++;
-        else {
-            if (!isDigit(text.charCodeAt(pos))) {
-                tokenError = "UnexpectedEndOfNumber";
-                return text.substring(start, pos);
-            }
-            pos++;
-            while(pos < len && isDigit(text.charCodeAt(pos)))pos++;
-        }
-        if (pos < len && 0x2e === text.charCodeAt(pos)) {
-            pos++;
-            if (!isDigit(text.charCodeAt(pos))) {
-                tokenError = "UnexpectedEndOfNumber";
-                return text.substring(start, pos);
-            }
-            pos++;
-            while(pos < len && isDigit(text.charCodeAt(pos)))pos++;
-        }
-        if (pos < len && (0x45 === text.charCodeAt(pos) || 0x65 === text.charCodeAt(pos))) {
-            pos++;
-            if (pos < len && (0x2b === text.charCodeAt(pos) || 0x2d === text.charCodeAt(pos))) pos++;
-            if (!isDigit(text.charCodeAt(pos))) {
-                tokenError = "UnexpectedEndOfNumber";
-                return text.substring(start, pos);
-            }
-            pos++;
-            while(pos < len && isDigit(text.charCodeAt(pos)))pos++;
-        }
-        return text.substring(start, pos);
-    };
-    const scan = ()=>{
-        tokenValue = "";
-        tokenError = "None";
-        if (pos >= len) {
-            tokenOffset = len;
-            tokenStartLine = lineNumber;
-            tokenStartCharacter = pos - lineStartOffset;
-            token = "EOF";
-            return token;
-        }
-        let ch = text.charCodeAt(pos);
-        if (isWhitespace(ch)) {
-            tokenOffset = pos;
-            tokenStartLine = lineNumber;
-            tokenStartCharacter = pos - lineStartOffset;
-            do {
-                pos++;
-                ch = pos < len ? text.charCodeAt(pos) : 0;
-            }while (isWhitespace(ch));
-            tokenValue = text.substring(tokenOffset, pos);
-            if (ignoreTrivia) return scan();
-            token = "Trivia";
-            return token;
-        }
-        if (isLineBreak(ch)) {
-            tokenOffset = pos;
-            tokenStartLine = lineNumber;
-            tokenStartCharacter = pos - lineStartOffset;
-            pos++;
-            if (0x0d === ch && pos < len && 0x0a === text.charCodeAt(pos)) pos++;
-            lineNumber++;
-            lineStartOffset = pos;
-            tokenValue = text.substring(tokenOffset, pos);
-            if (ignoreTrivia) return scan();
-            token = "LineBreak";
-            return token;
-        }
-        tokenOffset = pos;
-        tokenStartLine = lineNumber;
-        tokenStartCharacter = pos - lineStartOffset;
-        switch(ch){
-            case 0x7b:
-                pos++;
-                tokenValue = "{";
-                token = "OpenBrace";
-                return token;
-            case 0x7d:
-                pos++;
-                tokenValue = "}";
-                token = "CloseBrace";
-                return token;
-            case 0x5b:
-                pos++;
-                tokenValue = "[";
-                token = "OpenBracket";
-                return token;
-            case 0x5d:
-                pos++;
-                tokenValue = "]";
-                token = "CloseBracket";
-                return token;
-            case 0x3a:
-                pos++;
-                tokenValue = ":";
-                token = "Colon";
-                return token;
-            case 0x2c:
-                pos++;
-                tokenValue = ",";
-                token = "Comma";
-                return token;
-            case 0x22:
-                tokenValue = scanString();
-                token = "String";
-                return token;
-            case 0x2f:
-                {
-                    const nextCh = pos + 1 < len ? text.charCodeAt(pos + 1) : 0;
-                    if (0x2f === nextCh) {
-                        pos += 2;
-                        while(pos < len && !isLineBreak(text.charCodeAt(pos)))pos++;
-                        tokenValue = text.substring(tokenOffset, pos);
-                        if (ignoreTrivia) return scan();
-                        token = "LineComment";
-                        return token;
-                    }
-                    if (0x2a === nextCh) {
-                        pos += 2;
-                        const safeLen = len - 1;
-                        let commentClosed = false;
-                        while(pos < safeLen){
-                            const cch = text.charCodeAt(pos);
-                            if (isLineBreak(cch)) {
-                                if (0x0d === cch && pos + 1 < len && 0x0a === text.charCodeAt(pos + 1)) pos++;
-                                pos++;
-                                lineNumber++;
-                                lineStartOffset = pos;
-                            } else if (0x2a === cch && 0x2f === text.charCodeAt(pos + 1)) {
-                                pos += 2;
-                                commentClosed = true;
-                                break;
-                            } else pos++;
-                        }
-                        if (!commentClosed) {
-                            pos = len;
-                            tokenError = "UnexpectedEndOfComment";
-                        }
-                        tokenValue = text.substring(tokenOffset, pos);
-                        if (ignoreTrivia) return scan();
-                        token = "BlockComment";
-                        return token;
-                    }
-                    pos++;
-                    tokenValue = text.substring(tokenOffset, pos);
-                    token = "Unknown";
-                    tokenError = "InvalidCharacter";
-                    return token;
-                }
-            case 0x2d:
-                if (pos + 1 < len && isDigit(text.charCodeAt(pos + 1))) {
-                    tokenValue = scanNumber();
-                    token = "Number";
-                    return token;
-                }
-                pos++;
-                tokenValue = "-";
-                token = "Unknown";
-                tokenError = "InvalidSymbol";
-                return token;
-            default:
-                if (isDigit(ch)) {
-                    tokenValue = scanNumber();
-                    token = "Number";
-                    return token;
-                }
-                if (ch >= 0x61 && ch <= 0x7a) {
-                    const start = pos;
-                    pos++;
-                    while(pos < len){
-                        const kch = text.charCodeAt(pos);
-                        if (kch >= 0x61 && kch <= 0x7a) pos++;
-                        else break;
-                    }
-                    tokenValue = text.substring(start, pos);
-                    switch(tokenValue){
-                        case "true":
-                            token = "True";
-                            return token;
-                        case "false":
-                            token = "False";
-                            return token;
-                        case "null":
-                            token = "Null";
-                            return token;
-                        default:
-                            token = "Unknown";
-                            tokenError = "InvalidSymbol";
-                            return token;
-                    }
-                }
-                pos++;
-                tokenValue = text.substring(tokenOffset, pos);
-                token = "Unknown";
-                tokenError = "InvalidCharacter";
-                return token;
-        }
-    };
-    return {
-        scan,
-        getToken: ()=>token,
-        getTokenValue: ()=>tokenValue,
-        getTokenOffset: ()=>tokenOffset,
-        getTokenLength: ()=>pos - tokenOffset,
-        getTokenStartLine: ()=>tokenStartLine,
-        getTokenStartCharacter: ()=>tokenStartCharacter,
-        getTokenError: ()=>tokenError,
-        getPosition: ()=>pos,
-        setPosition: (newPos)=>{
-            pos = newPos;
-            tokenValue = "";
-            token = "Unknown";
-            tokenError = "None";
-        }
-    };
-};
-const parse = (text, options)=>Effect.sync(()=>parseInternal(text, options ?? {}, false)).pipe(Effect.flatMap(({ value, errors })=>{
-        if (errors.length > 0) return Effect.fail(new JsoncParseError({
-            errors,
-            text,
-            ...void 0 !== options ? {
-                options
-            } : {}
-        }));
-        return Effect.succeed(value);
-    }));
-const parseTree = (text, options)=>Effect.sync(()=>parseInternal(text, options ?? {}, true)).pipe(Effect.flatMap(({ root, errors })=>{
-        if (errors.length > 0) return Effect.fail(new JsoncParseError({
-            errors,
-            text,
-            ...void 0 !== options ? {
-                options
-            } : {}
-        }));
-        return Effect.succeed(root ? Option.some(root) : Option.none());
-    }));
-const stripComments = (text, replaceCh)=>Effect.sync(()=>{
-        const scanner = createScanner(text);
-        const parts = [];
-        let lastOffset = 0;
-        let kind;
-        do {
-            kind = scanner.scan();
-            const offset = scanner.getTokenOffset();
-            const length = scanner.getTokenLength();
-            if ("LineComment" === kind || "BlockComment" === kind) {
-                if (lastOffset < offset) parts.push(text.substring(lastOffset, offset));
-                if (void 0 !== replaceCh) for(let i = 0; i < length; i++){
-                    const ch = text.charCodeAt(offset + i);
-                    parts.push(0x0a === ch || 0x0d === ch ? text[offset + i] : replaceCh);
-                }
-                lastOffset = offset + length;
-            }
-        }while ("EOF" !== kind);
-        if (lastOffset < text.length) parts.push(text.substring(lastOffset));
-        return parts.join("");
-    });
-function parseInternal(text, options, buildTree) {
-    const scanner = createScanner(text, false);
-    const errors = [];
-    const disallowComments = options.disallowComments ?? false;
-    const allowTrailingComma = options.allowTrailingComma ?? true;
-    const allowEmptyContent = options.allowEmptyContent ?? false;
-    let currentToken = "Unknown";
-    function token() {
-        return currentToken;
-    }
-    function scanNext() {
-        for(;;){
-            currentToken = scanner.scan();
-            switch(scanner.getTokenError()){
-                case "InvalidUnicode":
-                    handleError("InvalidUnicode");
-                    break;
-                case "InvalidEscapeCharacter":
-                    handleError("InvalidEscapeCharacter");
-                    break;
-                case "UnexpectedEndOfNumber":
-                    handleError("InvalidNumberFormat");
-                    break;
-                case "UnexpectedEndOfComment":
-                    handleError("UnexpectedEndOfComment");
-                    break;
-                case "UnexpectedEndOfString":
-                    handleError("UnexpectedEndOfString");
-                    break;
-                case "InvalidCharacter":
-                    handleError("InvalidCharacter");
-                    break;
-            }
-            switch(currentToken){
-                case "LineComment":
-                case "BlockComment":
-                    if (disallowComments) handleError("InvalidCommentToken");
-                    break;
-                case "Trivia":
-                case "LineBreak":
-                    break;
-                default:
-                    return currentToken;
-            }
-        }
-    }
-    function handleError(code, skipUntilAfter = [], skipUntil = []) {
-        errors.push(new JsoncParseErrorDetail({
-            code,
-            message: formatError(code, scanner.getTokenOffset()),
-            offset: scanner.getTokenOffset(),
-            length: scanner.getTokenLength(),
-            startLine: scanner.getTokenStartLine(),
-            startCharacter: scanner.getTokenStartCharacter()
-        }));
-        if (skipUntilAfter.length > 0 || skipUntil.length > 0) {
-            let t = token();
-            while("EOF" !== t){
-                if (skipUntilAfter.includes(t)) {
-                    scanNext();
-                    break;
-                }
-                if (skipUntil.includes(t)) break;
-                t = scanNext();
-            }
-        }
-    }
-    function parseValue() {
-        switch(token()){
-            case "OpenBracket":
-                return parseArray();
-            case "OpenBrace":
-                return parseObject();
-            case "String":
-                return parseString();
-            case "Number":
-                return parseNumber();
-            case "True":
-                scanNext();
-                return true;
-            case "False":
-                scanNext();
-                return false;
-            case "Null":
-                scanNext();
-                return null;
-            default:
-                return;
-        }
-    }
-    function parseString() {
-        const value = scanner.getTokenValue();
-        scanNext();
-        return value;
-    }
-    function parseNumber() {
-        const value = Number.parseFloat(scanner.getTokenValue());
-        scanNext();
-        return value;
-    }
-    function parseArray() {
-        scanNext();
-        const arr = [];
-        let needsComma = false;
-        while("CloseBracket" !== token() && "EOF" !== token()){
-            if ("Comma" === token()) {
-                if (!needsComma) handleError("ValueExpected");
-                scanNext();
-                if ("CloseBracket" === token() && allowTrailingComma) break;
-            } else if (needsComma) handleError("CommaExpected");
-            const value = parseValue();
-            if (void 0 === value) handleError("ValueExpected", [], [
-                "CloseBracket",
-                "Comma"
-            ]);
-            else arr.push(value);
-            needsComma = true;
-        }
-        if ("CloseBracket" !== token()) handleError("CloseBracketExpected");
-        else scanNext();
-        return arr;
-    }
-    function parseObject() {
-        scanNext();
-        const obj = {};
-        let needsComma = false;
-        while("CloseBrace" !== token() && "EOF" !== token()){
-            if ("Comma" === token()) {
-                if (!needsComma) handleError("PropertyNameExpected");
-                scanNext();
-                if ("CloseBrace" === token() && allowTrailingComma) break;
-            } else if (needsComma) handleError("CommaExpected");
-            if ("String" !== token()) {
-                handleError("PropertyNameExpected", [], [
-                    "CloseBrace",
-                    "Comma"
-                ]);
-                continue;
-            }
-            const key = scanner.getTokenValue();
-            scanNext();
-            if ("Colon" !== token()) {
-                handleError("ColonExpected", [], [
-                    "CloseBrace",
-                    "Comma"
-                ]);
-                continue;
-            }
-            scanNext();
-            const value = parseValue();
-            if (void 0 === value) handleError("ValueExpected", [], [
-                "CloseBrace",
-                "Comma"
-            ]);
-            else obj[key] = value;
-            needsComma = true;
-        }
-        if ("CloseBrace" !== token()) handleError("CloseBraceExpected");
-        else scanNext();
-        return obj;
-    }
-    function parseValueTree() {
-        switch(token()){
-            case "OpenBracket":
-                return parseArrayTree();
-            case "OpenBrace":
-                return parseObjectTree();
-            case "String":
-                {
-                    const node = {
-                        type: "string",
-                        offset: scanner.getTokenOffset(),
-                        length: 0,
-                        value: scanner.getTokenValue()
-                    };
-                    scanNext();
-                    node.length = scanner.getTokenOffset() - node.offset;
-                    return node;
-                }
-            case "Number":
-                {
-                    const node = {
-                        type: "number",
-                        offset: scanner.getTokenOffset(),
-                        length: 0,
-                        value: Number.parseFloat(scanner.getTokenValue())
-                    };
-                    scanNext();
-                    node.length = scanner.getTokenOffset() - node.offset;
-                    return node;
-                }
-            case "True":
-                {
-                    const node = {
-                        type: "boolean",
-                        offset: scanner.getTokenOffset(),
-                        length: 0,
-                        value: true
-                    };
-                    scanNext();
-                    node.length = scanner.getTokenOffset() - node.offset;
-                    return node;
-                }
-            case "False":
-                {
-                    const node = {
-                        type: "boolean",
-                        offset: scanner.getTokenOffset(),
-                        length: 0,
-                        value: false
-                    };
-                    scanNext();
-                    node.length = scanner.getTokenOffset() - node.offset;
-                    return node;
-                }
-            case "Null":
-                {
-                    const node = {
-                        type: "null",
-                        offset: scanner.getTokenOffset(),
-                        length: 0,
-                        value: null
-                    };
-                    scanNext();
-                    node.length = scanner.getTokenOffset() - node.offset;
-                    return node;
-                }
-            default:
-                return;
-        }
-    }
-    function parseArrayTree() {
-        const node = {
-            type: "array",
-            offset: scanner.getTokenOffset(),
-            length: 0,
-            children: []
-        };
-        scanNext();
-        let needsComma = false;
-        while("CloseBracket" !== token() && "EOF" !== token()){
-            if ("Comma" === token()) {
-                if (!needsComma) handleError("ValueExpected");
-                scanNext();
-                if ("CloseBracket" === token() && allowTrailingComma) break;
-            } else if (needsComma) handleError("CommaExpected");
-            const child = parseValueTree();
-            if (child) node.children.push(child);
-            else handleError("ValueExpected", [], [
-                "CloseBracket",
-                "Comma"
-            ]);
-            needsComma = true;
-        }
-        if ("CloseBracket" !== token()) handleError("CloseBracketExpected");
-        else scanNext();
-        node.length = scanner.getTokenOffset() - node.offset;
-        return node;
-    }
-    function parseObjectTree() {
-        const node = {
-            type: "object",
-            offset: scanner.getTokenOffset(),
-            length: 0,
-            children: []
-        };
-        scanNext();
-        let needsComma = false;
-        while("CloseBrace" !== token() && "EOF" !== token()){
-            if ("Comma" === token()) {
-                if (!needsComma) handleError("PropertyNameExpected");
-                scanNext();
-                if ("CloseBrace" === token() && allowTrailingComma) break;
-            } else if (needsComma) handleError("CommaExpected");
-            if ("String" !== token()) {
-                handleError("PropertyNameExpected", [], [
-                    "CloseBrace",
-                    "Comma"
-                ]);
-                continue;
-            }
-            const property = {
-                type: "property",
-                offset: scanner.getTokenOffset(),
-                length: 0,
-                children: []
-            };
-            const keyNode = {
-                type: "string",
-                offset: scanner.getTokenOffset(),
-                length: 0,
-                value: scanner.getTokenValue()
-            };
-            scanNext();
-            keyNode.length = scanner.getTokenOffset() - keyNode.offset;
-            property.children.push(keyNode);
-            if ("Colon" !== token()) {
-                handleError("ColonExpected", [], [
-                    "CloseBrace",
-                    "Comma"
-                ]);
-                property.length = scanner.getTokenOffset() - property.offset;
-                node.children.push(property);
-                continue;
-            }
-            property.colonOffset = scanner.getTokenOffset();
-            scanNext();
-            const valueNode = parseValueTree();
-            if (valueNode) property.children.push(valueNode);
-            else handleError("ValueExpected", [], [
-                "CloseBrace",
-                "Comma"
-            ]);
-            property.length = scanner.getTokenOffset() - property.offset;
-            node.children.push(property);
-            needsComma = true;
-        }
-        if ("CloseBrace" !== token()) handleError("CloseBraceExpected");
-        else scanNext();
-        node.length = scanner.getTokenOffset() - node.offset;
-        return node;
-    }
-    scanNext();
-    if (buildTree) {
-        const root = parseValueTree();
-        if ("EOF" !== token()) handleError("EndOfFileExpected");
-        if (!root && !allowEmptyContent) handleError("ValueExpected");
-        return {
-            value: void 0,
-            root,
-            errors
-        };
-    }
-    const value = parseValue();
-    if ("EOF" !== token()) handleError("EndOfFileExpected");
-    if (void 0 === value && !allowEmptyContent) handleError("ValueExpected");
-    return {
-        value,
-        root: void 0,
-        errors
-    };
-}
-function formatError(code, offset) {
-    switch(code){
-        case "InvalidSymbol":
-            return `Invalid symbol at offset ${offset}`;
-        case "InvalidNumberFormat":
-            return `Invalid number format at offset ${offset}`;
-        case "PropertyNameExpected":
-            return `Property name expected at offset ${offset}`;
-        case "ValueExpected":
-            return `Value expected at offset ${offset}`;
-        case "ColonExpected":
-            return `Colon expected at offset ${offset}`;
-        case "CommaExpected":
-            return `Comma expected at offset ${offset}`;
-        case "CloseBraceExpected":
-            return `Close brace expected at offset ${offset}`;
-        case "CloseBracketExpected":
-            return `Close bracket expected at offset ${offset}`;
-        case "EndOfFileExpected":
-            return `End of file expected at offset ${offset}`;
-        case "InvalidCommentToken":
-            return `Comments not allowed at offset ${offset}`;
-        case "UnexpectedEndOfComment":
-            return `Unexpected end of comment at offset ${offset}`;
-        case "UnexpectedEndOfString":
-            return `Unexpected end of string at offset ${offset}`;
-        case "UnexpectedEndOfNumber":
-            return `Unexpected end of number at offset ${offset}`;
-        case "InvalidUnicode":
-            return `Invalid unicode escape at offset ${offset}`;
-        case "InvalidEscapeCharacter":
-            return `Invalid escape character at offset ${offset}`;
-        case "InvalidCharacter":
-            return `Invalid character at offset ${offset}`;
-        default:
-            return `Parse error at offset ${offset}`;
-    }
-}
-function deepEqual(a, b) {
-    if (a === b) return true;
-    if (null === a || null === b) return false;
-    if (typeof a !== typeof b) return false;
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b)) return false;
-        if (a.length !== b.length) return false;
-        for(let i = 0; i < a.length; i++)if (!deepEqual(a[i], b[i])) return false;
-        return true;
-    }
-    if (Array.isArray(b)) return false;
-    if ("object" == typeof a && "object" == typeof b) {
-        const aObj = a;
-        const bObj = b;
-        const aKeys = Object.keys(aObj);
-        const bKeys = Object.keys(bObj);
-        if (aKeys.length !== bKeys.length) return false;
-        for (const key of aKeys){
-            if (!Object.hasOwn(bObj, key)) return false;
-            if (!deepEqual(aObj[key], bObj[key])) return false;
-        }
-        return true;
-    }
-    return false;
-}
-const equals = Function.dual(2, (self, that)=>Effect.map(Effect.all([
-        parse(self),
-        parse(that)
-    ]), ([a, b])=>deepEqual(a, b)));
-const equalsValue = Function.dual(2, (self, value)=>Effect.map(parse(self), (parsed)=>deepEqual(parsed, value)));
-const format = (text, range, options)=>Effect.sync(()=>formatImpl(text, range, options));
-const applyEdits = Function.dual(2, (text, edits)=>Effect.sync(()=>{
-        const sorted = [
-            ...edits
-        ].sort((a, b)=>b.offset - a.offset);
-        let result = text;
-        for (const edit of sorted)result = result.substring(0, edit.offset) + edit.content + result.substring(edit.offset + edit.length);
-        return result;
-    }));
-const formatAndApply = (text, range, options)=>format(text, range, options).pipe(Effect.flatMap((edits)=>applyEdits(text, edits)));
-const modify = Function.dual((args)=>"string" == typeof args[0] && Array.isArray(args[1]), (text, path, value, options)=>Effect["try"]({
-        try: ()=>modifyImpl(text, path, value, options?.formattingOptions),
-        catch: (e)=>new JsoncModificationError({
-                path,
-                reason: String(e)
-            })
-    }));
-function formatImpl(text, range, options) {
-    const opts = {
-        tabSize: options?.tabSize ?? 2,
-        insertSpaces: options?.insertSpaces ?? true,
-        eol: options?.eol ?? "\n",
-        insertFinalNewline: options?.insertFinalNewline ?? false,
-        keepLines: options?.keepLines ?? false
-    };
-    const indentUnit = opts.insertSpaces ? " ".repeat(opts.tabSize) : "\t";
-    const edits = [];
-    const scanner = createScanner(text, false);
-    const rangeStart = range?.offset ?? 0;
-    const rangeEnd = range ? range.offset + range.length : text.length;
-    let depth = 0;
-    let prevTokenEnd = -1;
-    let prevToken = "Unknown";
-    let firstToken = true;
-    function makeIndent(d) {
-        return indentUnit.repeat(d);
-    }
-    function addEdit(offset, length, content) {
-        if (offset >= rangeStart && offset + length <= rangeEnd) {
-            if (text.substring(offset, offset + length) !== content) edits.push({
-                offset,
-                length,
-                content
-            });
-        }
-    }
-    let kind = scanner.scan();
-    while("EOF" !== kind){
-        const tokenOffset = scanner.getTokenOffset();
-        const tokenLength = scanner.getTokenLength();
-        if ("Trivia" !== kind && "LineBreak" !== kind) {
-            if (!firstToken && prevTokenEnd >= 0) {
-                const gap = text.substring(prevTokenEnd, tokenOffset);
-                let expectedGap;
-                if ("CloseBrace" === kind || "CloseBracket" === kind) {
-                    depth--;
-                    expectedGap = opts.eol + makeIndent(depth);
-                } else expectedGap = "OpenBrace" === prevToken || "OpenBracket" === prevToken ? opts.eol + makeIndent(depth) : "Comma" === prevToken ? opts.eol + makeIndent(depth) : "Colon" === prevToken ? " " : "LineComment" === kind || "BlockComment" === kind ? gap.includes("\n") ? opts.eol + makeIndent(depth) : " " : "LineComment" === prevToken ? opts.eol + makeIndent(depth) : "BlockComment" === prevToken ? gap.includes("\n") ? opts.eol + makeIndent(depth) : " " : gap;
-                if (opts.keepLines && gap.includes("\n")) expectedGap = gap;
-                addEdit(prevTokenEnd, tokenOffset - prevTokenEnd, expectedGap);
-            }
-            if ("OpenBrace" === kind || "OpenBracket" === kind) depth++;
-            prevToken = kind;
-            prevTokenEnd = tokenOffset + tokenLength;
-            firstToken = false;
-        }
-        kind = scanner.scan();
-    }
-    if (opts.insertFinalNewline && prevTokenEnd >= 0) {
-        const trailing = text.substring(prevTokenEnd);
-        if (!trailing.endsWith(opts.eol)) edits.push({
-            offset: prevTokenEnd,
-            length: trailing.length,
-            content: opts.eol
-        });
-    }
-    return edits;
-}
-function modifyImpl(text, path, value, formattingOptions) {
-    const opts = {
-        tabSize: formattingOptions?.tabSize ?? 2,
-        insertSpaces: formattingOptions?.insertSpaces ?? true,
-        eol: formattingOptions?.eol ?? "\n"
-    };
-    const indentUnit = opts.insertSpaces ? " ".repeat(opts.tabSize) : "\t";
-    if (0 === path.length) {
-        const content = void 0 === value ? "" : JSON.stringify(value, null, opts.tabSize);
-        return [
-            {
-                offset: 0,
-                length: text.length,
-                content
-            }
-        ];
-    }
-    const scanner = createScanner(text, true);
-    let currentToken = scanner.scan();
-    function skipValue() {
-        switch(currentToken){
-            case "OpenBrace":
-                {
-                    currentToken = scanner.scan();
-                    let first = true;
-                    while("CloseBrace" !== currentToken && "EOF" !== currentToken){
-                        if (!first && "Comma" === currentToken) currentToken = scanner.scan();
-                        if ("String" === currentToken) {
-                            currentToken = scanner.scan();
-                            if ("Colon" === currentToken) {
-                                currentToken = scanner.scan();
-                                skipValue();
-                            }
-                        } else currentToken = scanner.scan();
-                        first = false;
-                    }
-                    if ("CloseBrace" === currentToken) currentToken = scanner.scan();
-                    break;
-                }
-            case "OpenBracket":
-                {
-                    currentToken = scanner.scan();
-                    let first = true;
-                    while("CloseBracket" !== currentToken && "EOF" !== currentToken){
-                        if (!first && "Comma" === currentToken) currentToken = scanner.scan();
-                        skipValue();
-                        first = false;
-                    }
-                    if ("CloseBracket" === currentToken) currentToken = scanner.scan();
-                    break;
-                }
-            default:
-                currentToken = scanner.scan();
-                break;
-        }
-    }
-    let depth = 0;
-    for (const segment of path){
-        depth++;
-        if ("string" == typeof segment) {
-            if ("OpenBrace" !== currentToken) throw new Error(`Expected object at depth ${depth}`);
-            currentToken = scanner.scan();
-            let found = false;
-            let lastValueEnd = scanner.getTokenOffset();
-            let isFirst = true;
-            while("CloseBrace" !== currentToken && "EOF" !== currentToken){
-                if (!isFirst && "Comma" === currentToken) currentToken = scanner.scan();
-                if ("String" === currentToken) {
-                    const key = scanner.getTokenValue();
-                    currentToken = scanner.scan();
-                    if ("Colon" === currentToken) currentToken = scanner.scan();
-                    if (key === segment) {
-                        found = true;
-                        if (depth === path.length) {
-                            const valueStart = scanner.getTokenOffset();
-                            const prevEnd = valueStart;
-                            skipValue();
-                            const valueEnd = scanner.getTokenOffset();
-                            if (void 0 === value) {
-                                let removeStart = valueStart;
-                                let removeEnd = valueEnd;
-                                const keySearchArea = text.substring(0, valueStart);
-                                const keyStart = keySearchArea.lastIndexOf(`"${segment}"`);
-                                if (keyStart >= 0) removeStart = keyStart;
-                                const beforeKey = text.substring(0, removeStart).trimEnd();
-                                const commaPosBefore = beforeKey.lastIndexOf(",");
-                                if (commaPosBefore >= 0) removeStart = commaPosBefore;
-                                else {
-                                    const afterValue = text.substring(removeEnd);
-                                    const trimmedAfter = afterValue.match(/^(\s*,)/);
-                                    if (trimmedAfter) removeEnd += trimmedAfter[1].length;
-                                }
-                                return [
-                                    {
-                                        offset: removeStart,
-                                        length: removeEnd - removeStart,
-                                        content: ""
-                                    }
-                                ];
-                            }
-                            const serialized = JSON.stringify(value, null, opts.tabSize);
-                            return [
-                                {
-                                    offset: prevEnd,
-                                    length: valueEnd - prevEnd,
-                                    content: serialized
-                                }
-                            ];
-                        }
-                        break;
-                    }
-                    skipValue();
-                } else currentToken = scanner.scan();
-                lastValueEnd = scanner.getTokenOffset();
-                isFirst = false;
-            }
-            if (!found && depth === path.length && void 0 !== value) {
-                const indent = indentUnit.repeat(depth);
-                const serialized = JSON.stringify(value, null, opts.tabSize);
-                const insertText = isFirst ? `${opts.eol}${indent}"${segment}": ${serialized}${opts.eol}${indentUnit.repeat(depth - 1)}` : `,${opts.eol}${indent}"${segment}": ${serialized}`;
-                return [
-                    {
-                        offset: lastValueEnd,
-                        length: 0,
-                        content: insertText
-                    }
-                ];
-            }
-        } else {
-            if ("OpenBracket" !== currentToken) throw new Error(`Expected array at depth ${depth}`);
-            currentToken = scanner.scan();
-            let idx = 0;
-            let lastEnd = scanner.getTokenOffset();
-            while("CloseBracket" !== currentToken && "EOF" !== currentToken){
-                if (idx > 0 && "Comma" === currentToken) currentToken = scanner.scan();
-                if (idx === segment) {
-                    if (depth === path.length) {
-                        const valueStart = scanner.getTokenOffset();
-                        skipValue();
-                        const valueEnd = scanner.getTokenOffset();
-                        if (void 0 === value) {
-                            let removeEnd = valueEnd;
-                            const after = text.substring(removeEnd).trimStart();
-                            if (after.startsWith(",")) removeEnd = text.indexOf(",", removeEnd) + 1;
-                            return [
-                                {
-                                    offset: valueStart,
-                                    length: removeEnd - valueStart,
-                                    content: ""
-                                }
-                            ];
-                        }
-                        const serialized = JSON.stringify(value, null, opts.tabSize);
-                        return [
-                            {
-                                offset: valueStart,
-                                length: valueEnd - valueStart,
-                                content: serialized
-                            }
-                        ];
-                    }
-                    break;
-                }
-                skipValue();
-                lastEnd = scanner.getTokenOffset();
-                idx++;
-            }
-            if (idx <= segment && depth === path.length && void 0 !== value) {
-                const indent = indentUnit.repeat(depth);
-                const serialized = JSON.stringify(value, null, opts.tabSize);
-                const insertText = 0 === idx ? `${opts.eol}${indent}${serialized}${opts.eol}${indentUnit.repeat(depth - 1)}` : `,${opts.eol}${indent}${serialized}`;
-                return [
-                    {
-                        offset: lastEnd,
-                        length: 0,
-                        content: insertText
-                    }
-                ];
-            }
-        }
-    }
-    return [];
-}
-const JsoncFromString = makeJsoncFromString();
-function makeJsoncFromString(options) {
-    return Schema.transformOrFail(Schema.String, Schema.Unknown, {
-        strict: true,
-        decode: (input, _options, ast)=>{
-            const program = options ? parse(input, options) : parse(input);
-            return Effect.mapError(program, (parseError)=>new ParseResult.Type(ast, input, parseError.message));
-        },
-        encode: (value)=>ParseResult.succeed(JSON.stringify(value, null, 2))
-    }).annotations({
-        title: "JsoncFromString",
-        description: "Parse a JSONC string into an unknown JavaScript value"
-    });
-}
-const makeJsoncSchema = (targetSchema, options)=>Schema.compose(makeJsoncFromString(options), targetSchema);
-const JsoncSyntaxKind = Schema.Literal("OpenBrace", "CloseBrace", "OpenBracket", "CloseBracket", "Comma", "Colon", "Null", "True", "False", "String", "Number", "LineComment", "BlockComment", "LineBreak", "Trivia", "Unknown", "EOF");
-const JsoncScanError = Schema.Literal("None", "UnexpectedEndOfComment", "UnexpectedEndOfString", "UnexpectedEndOfNumber", "InvalidUnicode", "InvalidEscapeCharacter", "InvalidCharacter", "InvalidSymbol");
-class JsoncToken extends Schema.Class("JsoncToken")({
-    kind: JsoncSyntaxKind,
-    value: Schema.String,
-    offset: Schema.Number,
-    length: Schema.Number,
-    startLine: Schema.Number,
-    startCharacter: Schema.Number,
-    error: JsoncScanError
-}) {
-}
-const JsoncNodeType = Schema.Literal("object", "array", "property", "string", "number", "boolean", "null");
-class JsoncNode extends Schema.Class("JsoncNode")({
-    type: JsoncNodeType,
-    value: Schema.optional(Schema.Unknown),
-    offset: Schema.Number,
-    length: Schema.Number,
-    colonOffset: Schema.optional(Schema.Number),
-    children: Schema.optional(Schema.Array(Schema.suspend(()=>JsoncNode)))
-}) {
-}
-const JsoncSegment = Schema.Union(Schema.String, Schema.Number);
-Schema.Array(JsoncSegment);
-class JsoncEdit extends Schema.Class("JsoncEdit")({
-    offset: Schema.Number,
-    length: Schema.Number,
-    content: Schema.String
-}) {
-}
-class JsoncRange extends Schema.Class("JsoncRange")({
-    offset: Schema.Number,
-    length: Schema.Number
-}) {
-}
-class JsoncParseOptions extends Schema.Class("JsoncParseOptions")({
-    disallowComments: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>false
-    }),
-    allowTrailingComma: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    }),
-    allowEmptyContent: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>false
-    })
-}) {
-}
-class JsoncFormattingOptions extends Schema.Class("JsoncFormattingOptions")({
-    tabSize: Schema.optionalWith(Schema.Number, {
-        default: ()=>2
-    }),
-    insertSpaces: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>true
-    }),
-    eol: Schema.optionalWith(Schema.String, {
-        default: ()=>"\n"
-    }),
-    insertFinalNewline: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>false
-    }),
-    keepLines: Schema.optionalWith(Schema.Boolean, {
-        default: ()=>false
-    })
-}) {
-}
-const visit = (text, options)=>Stream.fromIterable(visitGen(text, options));
-const visitCollect = (text, predicate, options)=>visit(text, options).pipe(Stream.filter(predicate), Stream.runCollect, Effect.map(Chunk.toReadonlyArray));
-function* visitGen(text, options) {
-    const scanner = createScanner(text, false);
-    const disallowComments = options?.disallowComments ?? false;
-    const path = [];
-    function* scanNext() {
-        for(;;){
-            const t = scanner.scan();
-            const scanError = scanner.getTokenError();
-            if ("None" !== scanError) {
-                let code;
-                switch(scanError){
-                    case "InvalidUnicode":
-                        code = "InvalidUnicode";
-                        break;
-                    case "InvalidEscapeCharacter":
-                        code = "InvalidEscapeCharacter";
-                        break;
-                    case "UnexpectedEndOfNumber":
-                        code = "InvalidNumberFormat";
-                        break;
-                    case "UnexpectedEndOfComment":
-                        code = "UnexpectedEndOfComment";
-                        break;
-                    case "UnexpectedEndOfString":
-                        code = "UnexpectedEndOfString";
-                        break;
-                    case "InvalidCharacter":
-                        code = "InvalidCharacter";
-                        break;
-                    default:
-                        code = "InvalidSymbol";
-                }
-                yield {
-                    _tag: "Error",
-                    code,
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-            }
-            switch(t){
-                case "LineComment":
-                case "BlockComment":
-                    if (disallowComments) yield {
-                        _tag: "Error",
-                        code: "InvalidCommentToken",
-                        offset: scanner.getTokenOffset(),
-                        length: scanner.getTokenLength()
-                    };
-                    else yield {
-                        _tag: "Comment",
-                        offset: scanner.getTokenOffset(),
-                        length: scanner.getTokenLength()
-                    };
-                    break;
-                case "Trivia":
-                case "LineBreak":
-                    break;
-                default:
-                    return t;
-            }
-        }
-    }
-    function getLiteralValue(kind, tokenValue) {
-        switch(kind){
-            case "String":
-                return tokenValue;
-            case "Number":
-                return Number.parseFloat(tokenValue);
-            case "True":
-                return true;
-            case "False":
-                return false;
-            case "Null":
-                return null;
-            default:
-                return;
-        }
-    }
-    function* visitValue() {
-        const t = scanner.getToken();
-        switch(t){
-            case "OpenBrace":
-                return yield* visitObject();
-            case "OpenBracket":
-                return yield* visitArray();
-            case "String":
-            case "Number":
-            case "True":
-            case "False":
-            case "Null":
-                yield {
-                    _tag: "LiteralValue",
-                    value: getLiteralValue(t, scanner.getTokenValue()),
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength(),
-                    path: [
-                        ...path
-                    ]
-                };
-                yield* scanNext();
-                return true;
-            default:
-                yield {
-                    _tag: "Error",
-                    code: "ValueExpected",
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-                return false;
-        }
-    }
-    function* visitObject() {
-        yield {
-            _tag: "ObjectBegin",
-            offset: scanner.getTokenOffset(),
-            length: scanner.getTokenLength(),
-            path: [
-                ...path
-            ]
-        };
-        yield* scanNext();
-        let needsComma = false;
-        while("CloseBrace" !== scanner.getToken() && "EOF" !== scanner.getToken()){
-            if ("Comma" === scanner.getToken()) {
-                yield {
-                    _tag: "Separator",
-                    character: ",",
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-                yield* scanNext();
-                if ("CloseBrace" === scanner.getToken()) break;
-            } else if (needsComma) yield {
-                _tag: "Error",
-                code: "CommaExpected",
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength()
-            };
-            if ("String" !== scanner.getToken()) {
-                yield {
-                    _tag: "Error",
-                    code: "PropertyNameExpected",
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-                yield* scanNext();
-                continue;
-            }
-            const key = scanner.getTokenValue();
-            yield {
-                _tag: "ObjectProperty",
-                property: key,
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength(),
-                path: [
-                    ...path
-                ]
-            };
-            path.push(key);
-            yield* scanNext();
-            if ("Colon" === scanner.getToken()) {
-                yield {
-                    _tag: "Separator",
-                    character: ":",
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-                yield* scanNext();
-            } else yield {
-                _tag: "Error",
-                code: "ColonExpected",
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength()
-            };
-            yield* visitValue();
-            path.pop();
-            needsComma = true;
-        }
-        if ("CloseBrace" === scanner.getToken()) {
-            yield {
-                _tag: "ObjectEnd",
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength()
-            };
-            yield* scanNext();
-        } else yield {
-            _tag: "Error",
-            code: "CloseBraceExpected",
-            offset: scanner.getTokenOffset(),
-            length: scanner.getTokenLength()
-        };
-        return true;
-    }
-    function* visitArray() {
-        yield {
-            _tag: "ArrayBegin",
-            offset: scanner.getTokenOffset(),
-            length: scanner.getTokenLength(),
-            path: [
-                ...path
-            ]
-        };
-        yield* scanNext();
-        let index = 0;
-        let needsComma = false;
-        while("CloseBracket" !== scanner.getToken() && "EOF" !== scanner.getToken()){
-            if ("Comma" === scanner.getToken()) {
-                yield {
-                    _tag: "Separator",
-                    character: ",",
-                    offset: scanner.getTokenOffset(),
-                    length: scanner.getTokenLength()
-                };
-                yield* scanNext();
-                if ("CloseBracket" === scanner.getToken()) break;
-            } else if (needsComma) yield {
-                _tag: "Error",
-                code: "CommaExpected",
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength()
-            };
-            path.push(index);
-            yield* visitValue();
-            path.pop();
-            index++;
-            needsComma = true;
-        }
-        if ("CloseBracket" === scanner.getToken()) {
-            yield {
-                _tag: "ArrayEnd",
-                offset: scanner.getTokenOffset(),
-                length: scanner.getTokenLength()
-            };
-            yield* scanNext();
-        } else yield {
-            _tag: "Error",
-            code: "CloseBracketExpected",
-            offset: scanner.getTokenOffset(),
-            length: scanner.getTokenLength()
-        };
-        return true;
-    }
-    yield* scanNext();
-    if ("EOF" !== scanner.getToken()) yield* visitValue();
-}
-export { JsoncEdit, JsoncFormattingOptions, JsoncFromString, JsoncModificationError, JsoncModificationErrorBase, JsoncNode, JsoncNodeNotFoundError, JsoncNodeNotFoundErrorBase, JsoncParseError, JsoncParseErrorBase, JsoncParseErrorDetail, JsoncParseOptions, JsoncRange, JsoncToken, applyEdits, createScanner, equals, equalsValue, findNode, findNodeAtOffset, format, formatAndApply, getNodePath, getNodeValue, makeJsoncFromString, makeJsoncSchema, modify, parse, parseTree, stripComments, visit, visitCollect };
+import { findNode, findNodeAtOffset, getNodePath, getNodeValue } from "./ast.js";
+import { JsoncModificationError, JsoncModificationErrorBase, JsoncNodeNotFoundError, JsoncNodeNotFoundErrorBase, JsoncParseError, JsoncParseErrorBase, JsoncParseErrorDetail } from "./errors.js";
+import { createScanner } from "./scanner.js";
+import { parse, parseTree, stripComments } from "./parse.js";
+import { equals, equalsValue } from "./equality.js";
+import { applyEdits, format, formatAndApply, modify } from "./format.js";
+import { JsoncFromString, makeJsoncFromString, makeJsoncSchema } from "./schema-integration.js";
+import { JsoncEdit, JsoncFormattingOptions, JsoncNode, JsoncParseOptions, JsoncRange, JsoncToken } from "./schemas.js";
+import { visit, visitCollect } from "./visitor.js";
+
+export { JsoncEdit, JsoncFormattingOptions, JsoncFromString, JsoncModificationError, JsoncModificationErrorBase, JsoncNode, JsoncNodeNotFoundError, JsoncNodeNotFoundErrorBase, JsoncParseError, JsoncParseErrorBase, JsoncParseErrorDetail, JsoncParseOptions, JsoncRange, JsoncToken, applyEdits, createScanner, equals, equalsValue, findNode, findNodeAtOffset, format, formatAndApply, getNodePath, getNodeValue, makeJsoncFromString, makeJsoncSchema, modify, parse, parseTree, stripComments, visit, visitCollect };