opencode-navigator 0.27.4 → 0.27.5

package/dist/native-todo-setup.js

@@ -1,3 +1,5 @@
+import {parseTree,findNodeAtLocation,modify,applyEdits
+} from "./chunk-v6qckzat.js";
 import {createComponent as _$createComponent4} from "@opentui/solid"
 import {createSignal} from "solid-js"
 function todoConfig(entries){let owner=-1
@@ -9,833 +11,6 @@ const candidates=owner>=0?[entries[owner]]:entries
 const files=[...new Set(candidates.flatMap((entry)=>entry.path&&/\.jsonc?$/iu.test(entry.path)?[entry.path]:[]))]
 return{enabled,files,signature:JSON.stringify(entries),unavailable:files.length===0?"OpenCode did not expose an editable JSON/JSONC source for its effective experimental settings.":undefined
 }}
-function createScanner(text,ignoreTrivia=false){const len=text.length
-let pos=0,value="",tokenOffset=0,token=16,lineNumber=0,lineStartOffset=0,tokenLineStartOffset=0,prevTokenLineStartOffset=0,scanError=0
-function scanHexDigits(count,exact){let digits=0
-let value=0
-while(digits<count||!exact){let ch=text.charCodeAt(pos)
-if(ch>=48&&ch<=57){value=value*16 + ch-48
-} else if(ch>=65&&ch<=70){value=value*16 + ch-65 + 10
-} else if(ch>=97&&ch<=102){value=value*16 + ch-97 + 10
-} else{break
-}
-pos++
-digits++
-}
-if(digits<count){value=-1
-}
-return value
-}
-function setPosition(newPosition){pos=newPosition
-value=""
-tokenOffset=0
-token=16
-scanError=0
-}
-function scanNumber(){let start=pos
-if(text.charCodeAt(pos)===48){pos++
-} else{pos++
-while(pos<text.length&&isDigit(text.charCodeAt(pos))){pos++
-}}
-if(pos<text.length&&text.charCodeAt(pos)===46){pos++
-if(pos<text.length&&isDigit(text.charCodeAt(pos))){pos++
-while(pos<text.length&&isDigit(text.charCodeAt(pos))){pos++
-}} else{scanError=3
-return text.substring(start,pos)
-}}
-let end=pos
-if(pos<text.length&&(text.charCodeAt(pos)===69||text.charCodeAt(pos)===101)){pos++
-if(pos<text.length&&text.charCodeAt(pos)===43||text.charCodeAt(pos)===45){pos++
-}
-if(pos<text.length&&isDigit(text.charCodeAt(pos))){pos++
-while(pos<text.length&&isDigit(text.charCodeAt(pos))){pos++
-}
-end=pos
-} else{scanError=3
-}}
-return text.substring(start,end)
-}
-function scanString(){let result="",start=pos
-while(true){if(pos>=len){result += text.substring(start,pos)
-scanError=2
-break
-}
-const ch=text.charCodeAt(pos)
-if(ch===34){result += text.substring(start,pos)
-pos++
-break
-}
-if(ch===92){result += text.substring(start,pos)
-pos++
-if(pos>=len){scanError=2
-break
-}
-const ch2=text.charCodeAt(pos++)
-switch(ch2){case 34:result += '"'
-break
-case 92:result += "\\"
-break
-case 47:result += "/"
-break
-case 98:result += "\b"
-break
-case 102:result += "\f"
-break
-case 110:result += `
-`
-break
-case 114:result += "\r"
-break
-case 116:result += "\t"
-break
-case 117:const ch3=scanHexDigits(4,true)
-if(ch3>=0){result += String.fromCharCode(ch3)
-} else{scanError=4
-}
-break
-default:scanError=5
-}
-start=pos
-continue
-}
-if(ch>=0&&ch<=31){if(isLineBreak(ch)){result += text.substring(start,pos)
-scanError=2
-break
-} else{scanError=6
-}}
-pos++
-}
-return result
-}
-function scanNext(){value=""
-scanError=0
-tokenOffset=pos
-lineStartOffset=lineNumber
-prevTokenLineStartOffset=tokenLineStartOffset
-if(pos>=len){tokenOffset=len
-return token=17
-}
-let code=text.charCodeAt(pos)
-if(isWhiteSpace(code)){do{pos++
-value += String.fromCharCode(code)
-code=text.charCodeAt(pos)
-} while(isWhiteSpace(code))
-return token=15
-}
-if(isLineBreak(code)){pos++
-value += String.fromCharCode(code)
-if(code===13&&text.charCodeAt(pos)===10){pos++
-value += `
-`
-}
-lineNumber++
-tokenLineStartOffset=pos
-return token=14
-}
-switch(code){case 123:pos++
-return token=1
-case 125:pos++
-return token=2
-case 91:pos++
-return token=3
-case 93:pos++
-return token=4
-case 58:pos++
-return token=6
-case 44:pos++
-return token=5
-case 34:pos++
-value=scanString()
-return token=10
-case 47:const start=pos-1
-if(text.charCodeAt(pos + 1)===47){pos += 2
-while(pos<len){if(isLineBreak(text.charCodeAt(pos))){break
-}
-pos++
-}
-value=text.substring(start,pos)
-return token=12
-}
-if(text.charCodeAt(pos + 1)===42){pos += 2
-const safeLength=len-1
-let commentClosed=false
-while(pos<safeLength){const ch=text.charCodeAt(pos)
-if(ch===42&&text.charCodeAt(pos + 1)===47){pos += 2
-commentClosed=true
-break
-}
-pos++
-if(isLineBreak(ch)){if(ch===13&&text.charCodeAt(pos)===10){pos++
-}
-lineNumber++
-tokenLineStartOffset=pos
-}}
-if(!commentClosed){pos++
-scanError=1
-}
-value=text.substring(start,pos)
-return token=13
-}
-value += String.fromCharCode(code)
-pos++
-return token=16
-case 45:value += String.fromCharCode(code)
-pos++
-if(pos===len||!isDigit(text.charCodeAt(pos))){return token=16
-}
-case 48:case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:value += scanNumber()
-return token=11
-default:while(pos<len&&isUnknownContentCharacter(code)){pos++
-code=text.charCodeAt(pos)
-}
-if(tokenOffset!==pos){value=text.substring(tokenOffset,pos)
-switch(value){case "true":return token=8
-case "false":return token=9
-case "null":return token=7
-}
-return token=16
-}
-value += String.fromCharCode(code)
-pos++
-return token=16
-}}
-function isUnknownContentCharacter(code){if(isWhiteSpace(code)||isLineBreak(code)){return false
-}
-switch(code){case 125:case 93:case 123:case 91:case 34:case 58:case 44:case 47:return false
-}
-return true
-}
-function scanNextNonTrivia(){let result
-do{result=scanNext()
-} while(result>=12&&result<=15)
-return result
-}
-return{setPosition,getPosition:()=>pos,scan:ignoreTrivia?scanNextNonTrivia:scanNext,getToken:()=>token,getTokenValue:()=>value,getTokenOffset:()=>tokenOffset,getTokenLength:()=>pos-tokenOffset,getTokenStartLine:()=>lineStartOffset,getTokenStartCharacter:()=>tokenOffset-prevTokenLineStartOffset,getTokenError:()=>scanError
-}}
-function isWhiteSpace(ch){return ch===32||ch===9
-}
-function isLineBreak(ch){return ch===10||ch===13
-}
-function isDigit(ch){return ch>=48&&ch<=57
-}
-var CharacterCodes;
-(function(CharacterCodes){CharacterCodes[CharacterCodes["lineFeed"]=10]="lineFeed"
-CharacterCodes[CharacterCodes["carriageReturn"]=13]="carriageReturn"
-CharacterCodes[CharacterCodes["space"]=32]="space"
-CharacterCodes[CharacterCodes["_0"]=48]="_0"
-CharacterCodes[CharacterCodes["_1"]=49]="_1"
-CharacterCodes[CharacterCodes["_2"]=50]="_2"
-CharacterCodes[CharacterCodes["_3"]=51]="_3"
-CharacterCodes[CharacterCodes["_4"]=52]="_4"
-CharacterCodes[CharacterCodes["_5"]=53]="_5"
-CharacterCodes[CharacterCodes["_6"]=54]="_6"
-CharacterCodes[CharacterCodes["_7"]=55]="_7"
-CharacterCodes[CharacterCodes["_8"]=56]="_8"
-CharacterCodes[CharacterCodes["_9"]=57]="_9"
-CharacterCodes[CharacterCodes["a"]=97]="a"
-CharacterCodes[CharacterCodes["b"]=98]="b"
-CharacterCodes[CharacterCodes["c"]=99]="c"
-CharacterCodes[CharacterCodes["d"]=100]="d"
-CharacterCodes[CharacterCodes["e"]=101]="e"
-CharacterCodes[CharacterCodes["f"]=102]="f"
-CharacterCodes[CharacterCodes["g"]=103]="g"
-CharacterCodes[CharacterCodes["h"]=104]="h"
-CharacterCodes[CharacterCodes["i"]=105]="i"
-CharacterCodes[CharacterCodes["j"]=106]="j"
-CharacterCodes[CharacterCodes["k"]=107]="k"
-CharacterCodes[CharacterCodes["l"]=108]="l"
-CharacterCodes[CharacterCodes["m"]=109]="m"
-CharacterCodes[CharacterCodes["n"]=110]="n"
-CharacterCodes[CharacterCodes["o"]=111]="o"
-CharacterCodes[CharacterCodes["p"]=112]="p"
-CharacterCodes[CharacterCodes["q"]=113]="q"
-CharacterCodes[CharacterCodes["r"]=114]="r"
-CharacterCodes[CharacterCodes["s"]=115]="s"
-CharacterCodes[CharacterCodes["t"]=116]="t"
-CharacterCodes[CharacterCodes["u"]=117]="u"
-CharacterCodes[CharacterCodes["v"]=118]="v"
-CharacterCodes[CharacterCodes["w"]=119]="w"
-CharacterCodes[CharacterCodes["x"]=120]="x"
-CharacterCodes[CharacterCodes["y"]=121]="y"
-CharacterCodes[CharacterCodes["z"]=122]="z"
-CharacterCodes[CharacterCodes["A"]=65]="A"
-CharacterCodes[CharacterCodes["B"]=66]="B"
-CharacterCodes[CharacterCodes["C"]=67]="C"
-CharacterCodes[CharacterCodes["D"]=68]="D"
-CharacterCodes[CharacterCodes["E"]=69]="E"
-CharacterCodes[CharacterCodes["F"]=70]="F"
-CharacterCodes[CharacterCodes["G"]=71]="G"
-CharacterCodes[CharacterCodes["H"]=72]="H"
-CharacterCodes[CharacterCodes["I"]=73]="I"
-CharacterCodes[CharacterCodes["J"]=74]="J"
-CharacterCodes[CharacterCodes["K"]=75]="K"
-CharacterCodes[CharacterCodes["L"]=76]="L"
-CharacterCodes[CharacterCodes["M"]=77]="M"
-CharacterCodes[CharacterCodes["N"]=78]="N"
-CharacterCodes[CharacterCodes["O"]=79]="O"
-CharacterCodes[CharacterCodes["P"]=80]="P"
-CharacterCodes[CharacterCodes["Q"]=81]="Q"
-CharacterCodes[CharacterCodes["R"]=82]="R"
-CharacterCodes[CharacterCodes["S"]=83]="S"
-CharacterCodes[CharacterCodes["T"]=84]="T"
-CharacterCodes[CharacterCodes["U"]=85]="U"
-CharacterCodes[CharacterCodes["V"]=86]="V"
-CharacterCodes[CharacterCodes["W"]=87]="W"
-CharacterCodes[CharacterCodes["X"]=88]="X"
-CharacterCodes[CharacterCodes["Y"]=89]="Y"
-CharacterCodes[CharacterCodes["Z"]=90]="Z"
-CharacterCodes[CharacterCodes["asterisk"]=42]="asterisk"
-CharacterCodes[CharacterCodes["backslash"]=92]="backslash"
-CharacterCodes[CharacterCodes["closeBrace"]=125]="closeBrace"
-CharacterCodes[CharacterCodes["closeBracket"]=93]="closeBracket"
-CharacterCodes[CharacterCodes["colon"]=58]="colon"
-CharacterCodes[CharacterCodes["comma"]=44]="comma"
-CharacterCodes[CharacterCodes["dot"]=46]="dot"
-CharacterCodes[CharacterCodes["doubleQuote"]=34]="doubleQuote"
-CharacterCodes[CharacterCodes["minus"]=45]="minus"
-CharacterCodes[CharacterCodes["openBrace"]=123]="openBrace"
-CharacterCodes[CharacterCodes["openBracket"]=91]="openBracket"
-CharacterCodes[CharacterCodes["plus"]=43]="plus"
-CharacterCodes[CharacterCodes["slash"]=47]="slash"
-CharacterCodes[CharacterCodes["formFeed"]=12]="formFeed"
-CharacterCodes[CharacterCodes["tab"]=9]="tab"
-})(CharacterCodes||(CharacterCodes={}));
-var cachedSpaces=new Array(20).fill(0).map((_,index)=>{return " ".repeat(index)
-})
-var maxCachedValues=200
-var cachedBreakLinesWithSpaces={" ":{"\n":new Array(maxCachedValues).fill(0).map((_,index)=>{return `
-` + " ".repeat(index)
-}),"\r":new Array(maxCachedValues).fill(0).map((_,index)=>{return "\r" + " ".repeat(index)
-}),"\r\n":new Array(maxCachedValues).fill(0).map((_,index)=>{return `\r
-` + " ".repeat(index)
-})
-},"\t":{"\n":new Array(maxCachedValues).fill(0).map((_,index)=>{return `
-` + "\t".repeat(index)
-}),"\r":new Array(maxCachedValues).fill(0).map((_,index)=>{return "\r" + "\t".repeat(index)
-}),"\r\n":new Array(maxCachedValues).fill(0).map((_,index)=>{return `\r
-` + "\t".repeat(index)
-})
-}}
-var supportedEols=[`
-`,"\r",`\r
-`];
-function format(documentText,range,options){let initialIndentLevel
-let formatText
-let formatTextStart
-let rangeStart
-let rangeEnd
-if(range){rangeStart=range.offset
-rangeEnd=rangeStart + range.length
-formatTextStart=rangeStart
-while(formatTextStart>0&&!isEOL(documentText,formatTextStart-1)){formatTextStart--
-}
-let endOffset=rangeEnd
-while(endOffset<documentText.length&&!isEOL(documentText,endOffset)){endOffset++
-}
-formatText=documentText.substring(formatTextStart,endOffset)
-initialIndentLevel=computeIndentLevel(formatText,options)
-} else{formatText=documentText
-initialIndentLevel=0
-formatTextStart=0
-rangeStart=0
-rangeEnd=documentText.length
-}
-const eol=getEOL(options,documentText)
-const eolFastPathSupported=supportedEols.includes(eol)
-let numberLineBreaks=0
-let indentLevel=0
-let indentValue
-if(options.insertSpaces){indentValue=cachedSpaces[options.tabSize||4]??repeat(cachedSpaces[1],options.tabSize||4)
-} else{indentValue="\t"
-}
-const indentType=indentValue==="\t"?"\t":" "
-let scanner=createScanner(formatText,false)
-let hasError=false
-function newLinesAndIndent(){if(numberLineBreaks>1){return repeat(eol,numberLineBreaks) + repeat(indentValue,initialIndentLevel + indentLevel)
-}
-const amountOfSpaces=indentValue.length*(initialIndentLevel + indentLevel)
-if(!eolFastPathSupported||amountOfSpaces>cachedBreakLinesWithSpaces[indentType][eol].length){return eol + repeat(indentValue,initialIndentLevel + indentLevel)
-}
-if(amountOfSpaces<=0){return eol
-}
-return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces]
-}
-function scanNext(){let token=scanner.scan()
-numberLineBreaks=0
-while(token===15||token===14){if(token===14&&options.keepLines){numberLineBreaks += 1
-} else if(token===14){numberLineBreaks=1
-}
-token=scanner.scan()
-}
-hasError=token===16||scanner.getTokenError()!==0
-return token
-}
-const editOperations=[]
-function addEdit(text,startOffset,endOffset){if(!hasError&&(!range||startOffset<rangeEnd&&endOffset>rangeStart)&&documentText.substring(startOffset,endOffset)!==text){editOperations.push({offset:startOffset,length:endOffset-startOffset,content:text})
-}}
-let firstToken=scanNext()
-if(options.keepLines&&numberLineBreaks>0){addEdit(repeat(eol,numberLineBreaks),0,0)
-}
-if(firstToken!==17){let firstTokenStart=scanner.getTokenOffset() + formatTextStart
-let initialIndent=indentValue.length*initialIndentLevel<20&&options.insertSpaces?cachedSpaces[indentValue.length*initialIndentLevel]:repeat(indentValue,initialIndentLevel)
-addEdit(initialIndent,formatTextStart,firstTokenStart)
-}
-while(firstToken!==17){let firstTokenEnd=scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart
-let secondToken=scanNext()
-let replaceContent=""
-let needsLineBreak=false
-while(numberLineBreaks===0&&(secondToken===12||secondToken===13)){let commentTokenStart=scanner.getTokenOffset() + formatTextStart
-addEdit(cachedSpaces[1],firstTokenEnd,commentTokenStart)
-firstTokenEnd=scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart
-needsLineBreak=secondToken===12
-replaceContent=needsLineBreak?newLinesAndIndent():""
-secondToken=scanNext()
-}
-if(secondToken===2){if(firstToken!==1){indentLevel--
-}
-if(options.keepLines&&numberLineBreaks>0||!options.keepLines&&firstToken!==1){replaceContent=newLinesAndIndent()
-} else if(options.keepLines){replaceContent=cachedSpaces[1]
-}} else if(secondToken===4){if(firstToken!==3){indentLevel--
-}
-if(options.keepLines&&numberLineBreaks>0||!options.keepLines&&firstToken!==3){replaceContent=newLinesAndIndent()
-} else if(options.keepLines){replaceContent=cachedSpaces[1]
-}} else{switch(firstToken){case 3:case 1:indentLevel++
-if(options.keepLines&&numberLineBreaks>0||!options.keepLines){replaceContent=newLinesAndIndent()
-} else{replaceContent=cachedSpaces[1]
-}
-break
-case 5:if(options.keepLines&&numberLineBreaks>0||!options.keepLines){replaceContent=newLinesAndIndent()
-} else{replaceContent=cachedSpaces[1]
-}
-break
-case 12:replaceContent=newLinesAndIndent()
-break
-case 13:if(numberLineBreaks>0){replaceContent=newLinesAndIndent()
-} else if(!needsLineBreak){replaceContent=cachedSpaces[1]
-}
-break
-case 6:if(options.keepLines&&numberLineBreaks>0){replaceContent=newLinesAndIndent()
-} else if(!needsLineBreak){replaceContent=cachedSpaces[1]
-}
-break
-case 10:if(options.keepLines&&numberLineBreaks>0){replaceContent=newLinesAndIndent()
-} else if(secondToken===6&&!needsLineBreak){replaceContent=""
-}
-break
-case 7:case 8:case 9:case 11:case 2:case 4:if(options.keepLines&&numberLineBreaks>0){replaceContent=newLinesAndIndent()
-} else{if((secondToken===12||secondToken===13)&&!needsLineBreak){replaceContent=cachedSpaces[1]
-} else if(secondToken!==5&&secondToken!==17){hasError=true
-}}
-break
-case 16:hasError=true
-break
-}
-if(numberLineBreaks>0&&(secondToken===12||secondToken===13)){replaceContent=newLinesAndIndent()
-}}
-if(secondToken===17){if(options.keepLines&&numberLineBreaks>0){replaceContent=newLinesAndIndent()
-} else{replaceContent=options.insertFinalNewline?eol:""
-}}
-const secondTokenStart=scanner.getTokenOffset() + formatTextStart
-addEdit(replaceContent,firstTokenEnd,secondTokenStart)
-firstToken=secondToken
-}
-return editOperations
-}
-function repeat(s,count){let result=""
-for(let i=0;i<count; i++){result += s
-}
-return result
-}
-function computeIndentLevel(content,options){let i=0
-let nChars=0
-const tabSize=options.tabSize||4
-while(i<content.length){let ch=content.charAt(i)
-if(ch===cachedSpaces[1]){nChars++
-} else if(ch==="\t"){nChars += tabSize
-} else{break
-}
-i++
-}
-return Math.floor(nChars / tabSize)
-}
-function getEOL(options,text){for(let i=0;i<text.length; i++){const ch=text.charAt(i)
-if(ch==="\r"){if(i + 1<text.length&&text.charAt(i + 1)===`
-`){return `\r
-`
-}
-return "\r"
-} else if(ch===`
-`){return `
-`
-}}
-return options&&options.eol||`
-`
-}
-function isEOL(text,offset){return `\r
-`.indexOf(text.charAt(offset))!==-1
-}
-var ParseOptions;
-(function(ParseOptions){ParseOptions.DEFAULT={allowTrailingComma:false
-}})(ParseOptions||(ParseOptions={}))
-function parseTree(text,errors=[],options=ParseOptions.DEFAULT){let currentParent={type:"array",offset:-1,length:-1,children:[],parent:undefined}
-function ensurePropertyComplete(endOffset){if(currentParent.type==="property"){currentParent.length=endOffset-currentParent.offset
-currentParent=currentParent.parent
-}}
-function onValue(valueNode){currentParent.children.push(valueNode)
-return valueNode
-}
-const visitor={onObjectBegin:(offset)=>{currentParent=onValue({type:"object",offset,length:-1,parent:currentParent,children:[]})
-},onObjectProperty:(name,offset,length)=>{currentParent=onValue({type:"property",offset,length:-1,parent:currentParent,children:[]})
-currentParent.children.push({type:"string",value:name,offset,length,parent:currentParent})
-},onObjectEnd:(offset,length)=>{ensurePropertyComplete(offset + length)
-currentParent.length=offset + length-currentParent.offset
-currentParent=currentParent.parent
-ensurePropertyComplete(offset + length)
-},onArrayBegin:(offset,length)=>{currentParent=onValue({type:"array",offset,length:-1,parent:currentParent,children:[]})
-},onArrayEnd:(offset,length)=>{currentParent.length=offset + length-currentParent.offset
-currentParent=currentParent.parent
-ensurePropertyComplete(offset + length)
-},onLiteralValue:(value,offset,length)=>{onValue({type:getNodeType(value),offset,length,parent:currentParent,value})
-ensurePropertyComplete(offset + length)
-},onSeparator:(sep,offset,length)=>{if(currentParent.type==="property"){if(sep===":"){currentParent.colonOffset=offset
-} else if(sep===","){ensurePropertyComplete(offset)
-}}},onError:(error,offset,length)=>{errors.push({error,offset,length})
-}}
-visit(text,visitor,options)
-const result=currentParent.children[0]
-if(result){delete result.parent
-}
-return result
-}
-function findNodeAtLocation(root,path){if(!root){return
-}
-let node=root
-for(let segment of path){if(typeof segment==="string"){if(node.type!=="object"||!Array.isArray(node.children)){return
-}
-let found=false
-for(const propertyNode of node.children){if(Array.isArray(propertyNode.children)&&propertyNode.children[0].value===segment&&propertyNode.children.length===2){node=propertyNode.children[1]
-found=true
-break
-}}
-if(!found){return
-}} else{const index=segment
-if(node.type!=="array"||index<0||!Array.isArray(node.children)||index>=node.children.length){return
-}
-node=node.children[index]
-}}
-return node
-}
-function visit(text,visitor,options=ParseOptions.DEFAULT){const _scanner=createScanner(text,false)
-const _jsonPath=[]
-let suppressedCallbacks=0
-function toNoArgVisit(visitFunction){return visitFunction?()=>suppressedCallbacks===0&&visitFunction(_scanner.getTokenOffset(),_scanner.getTokenLength(),_scanner.getTokenStartLine(),_scanner.getTokenStartCharacter()):()=>true
-}
-function toOneArgVisit(visitFunction){return visitFunction?(arg)=>suppressedCallbacks===0&&visitFunction(arg,_scanner.getTokenOffset(),_scanner.getTokenLength(),_scanner.getTokenStartLine(),_scanner.getTokenStartCharacter()):()=>true
-}
-function toOneArgVisitWithPath(visitFunction){return visitFunction?(arg)=>suppressedCallbacks===0&&visitFunction(arg,_scanner.getTokenOffset(),_scanner.getTokenLength(),_scanner.getTokenStartLine(),_scanner.getTokenStartCharacter(),()=>_jsonPath.slice()):()=>true
-}
-function toBeginVisit(visitFunction){return visitFunction?()=>{if(suppressedCallbacks>0){suppressedCallbacks++
-} else{let cbReturn=visitFunction(_scanner.getTokenOffset(),_scanner.getTokenLength(),_scanner.getTokenStartLine(),_scanner.getTokenStartCharacter(),()=>_jsonPath.slice())
-if(cbReturn===false){suppressedCallbacks=1
-}}}:()=>true
-}
-function toEndVisit(visitFunction){return visitFunction?()=>{if(suppressedCallbacks>0){suppressedCallbacks--
-}
-if(suppressedCallbacks===0){visitFunction(_scanner.getTokenOffset(),_scanner.getTokenLength(),_scanner.getTokenStartLine(),_scanner.getTokenStartCharacter())
-}}:()=>true
-}
-const onObjectBegin=toBeginVisit(visitor.onObjectBegin),onObjectProperty=toOneArgVisitWithPath(visitor.onObjectProperty),onObjectEnd=toEndVisit(visitor.onObjectEnd),onArrayBegin=toBeginVisit(visitor.onArrayBegin),onArrayEnd=toEndVisit(visitor.onArrayEnd),onLiteralValue=toOneArgVisitWithPath(visitor.onLiteralValue),onSeparator=toOneArgVisit(visitor.onSeparator),onComment=toNoArgVisit(visitor.onComment),onError=toOneArgVisit(visitor.onError)
-const disallowComments=options&&options.disallowComments
-const allowTrailingComma=options&&options.allowTrailingComma
-function scanNext(){while(true){const token=_scanner.scan()
-switch(_scanner.getTokenError()){case 4:handleError(14)
-break
-case 5:handleError(15)
-break
-case 3:handleError(13)
-break
-case 1:if(!disallowComments){handleError(11)
-}
-break
-case 2:handleError(12)
-break
-case 6:handleError(16)
-break
-}
-switch(token){case 12:case 13:if(disallowComments){handleError(10)
-} else{onComment()
-}
-break
-case 16:handleError(1)
-break
-case 15:case 14:break
-default:return token
-}}}
-function handleError(error,skipUntilAfter=[],skipUntil=[]){onError(error)
-if(skipUntilAfter.length + skipUntil.length>0){let token=_scanner.getToken()
-while(token!==17){if(skipUntilAfter.indexOf(token)!==-1){scanNext()
-break
-} else if(skipUntil.indexOf(token)!==-1){break
-}
-token=scanNext()
-}}}
-function parseString(isValue){const value=_scanner.getTokenValue()
-if(isValue){onLiteralValue(value)
-} else{onObjectProperty(value)
-_jsonPath.push(value)
-}
-scanNext()
-return true
-}
-function parseLiteral(){switch(_scanner.getToken()){case 11:const tokenValue=_scanner.getTokenValue()
-let value=Number(tokenValue)
-if(isNaN(value)){handleError(2)
-value=0
-}
-onLiteralValue(value)
-break
-case 7:onLiteralValue(null)
-break
-case 8:onLiteralValue(true)
-break
-case 9:onLiteralValue(false)
-break
-default:return false
-}
-scanNext()
-return true
-}
-function parseProperty(){if(_scanner.getToken()!==10){handleError(3,[],[2,5])
-return false
-}
-parseString(false)
-if(_scanner.getToken()===6){onSeparator(":")
-scanNext()
-if(!parseValue()){handleError(4,[],[2,5])
-}} else{handleError(5,[],[2,5])
-}
-_jsonPath.pop()
-return true
-}
-function parseObject(){onObjectBegin()
-scanNext()
-let needsComma=false
-while(_scanner.getToken()!==2&&_scanner.getToken()!==17){if(_scanner.getToken()===5){if(!needsComma){handleError(4,[],[])
-}
-onSeparator(",")
-scanNext()
-if(_scanner.getToken()===2&&allowTrailingComma){break
-}} else if(needsComma){handleError(6,[],[])
-}
-if(!parseProperty()){handleError(4,[],[2,5])
-}
-needsComma=true
-}
-onObjectEnd()
-if(_scanner.getToken()!==2){handleError(7,[2],[])
-} else{scanNext()
-}
-return true
-}
-function parseArray(){onArrayBegin()
-scanNext()
-let isFirstElement=true
-let needsComma=false
-while(_scanner.getToken()!==4&&_scanner.getToken()!==17){if(_scanner.getToken()===5){if(!needsComma){handleError(4,[],[])
-}
-onSeparator(",")
-scanNext()
-if(_scanner.getToken()===4&&allowTrailingComma){break
-}} else if(needsComma){handleError(6,[],[])
-}
-if(isFirstElement){_jsonPath.push(0)
-isFirstElement=false
-} else{_jsonPath[_jsonPath.length-1]++
-}
-if(!parseValue()){handleError(4,[],[4,5])
-}
-needsComma=true
-}
-onArrayEnd()
-if(!isFirstElement){_jsonPath.pop()
-}
-if(_scanner.getToken()!==4){handleError(8,[4],[])
-} else{scanNext()
-}
-return true
-}
-function parseValue(){switch(_scanner.getToken()){case 3:return parseArray()
-case 1:return parseObject()
-case 10:return parseString(true)
-default:return parseLiteral()
-}}
-scanNext()
-if(_scanner.getToken()===17){if(options.allowEmptyContent){return true
-}
-handleError(4,[],[])
-return false
-}
-if(!parseValue()){handleError(4,[],[])
-return false
-}
-if(_scanner.getToken()!==17){handleError(9,[],[])
-}
-return true
-}
-function getNodeType(value){switch(typeof value){case "boolean":return "boolean"
-case "number":return "number"
-case "string":return "string"
-case "object":{if(!value){return "null"
-} else if(Array.isArray(value)){return "array"
-}
-return "object"
-}
-default:return "null"
-}}
-function setProperty(text,originalPath,value,options){const path=originalPath.slice()
-const errors=[]
-const root=parseTree(text,errors)
-let parent=undefined
-let lastSegment=undefined
-while(path.length>0){lastSegment=path.pop()
-parent=findNodeAtLocation(root,path)
-if(parent===undefined&&value!==undefined){if(typeof lastSegment==="string"){value={[lastSegment]:value}} else{value=[value]
-}} else{break
-}}
-if(!parent){if(value===undefined){throw new Error("Can not delete in empty document")
-}
-return withFormatting(text,{offset:root?root.offset:0,length:root?root.length:0,content:JSON.stringify(value)},options)
-} else if(parent.type==="object"&&typeof lastSegment==="string"&&Array.isArray(parent.children)){const existing=findNodeAtLocation(parent,[lastSegment])
-if(existing!==undefined){if(value===undefined){if(!existing.parent){throw new Error("Malformed AST")
-}
-const propertyIndex=parent.children.indexOf(existing.parent)
-let removeBegin
-let removeEnd=existing.parent.offset + existing.parent.length
-if(propertyIndex>0){let previous=parent.children[propertyIndex-1]
-removeBegin=previous.offset + previous.length
-} else{removeBegin=parent.offset + 1
-if(parent.children.length>1){let next=parent.children[1]
-removeEnd=next.offset
-}}
-return withFormatting(text,{offset:removeBegin,length:removeEnd-removeBegin,content:""},options)
-} else{return withFormatting(text,{offset:existing.offset,length:existing.length,content:JSON.stringify(value)},options)
-}} else{if(value===undefined){return []
-}
-const newProperty=`${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`
-const index=options.getInsertionIndex?options.getInsertionIndex(parent.children.map((p)=>p.children[0].value)):parent.children.length
-let edit
-if(index>0){let previous=parent.children[index-1]
-edit={offset:previous.offset + previous.length,length:0,content:"," + newProperty}} else if(parent.children.length===0){edit={offset:parent.offset + 1,length:0,content:newProperty}} else{edit={offset:parent.offset + 1,length:0,content:newProperty + ","}}
-return withFormatting(text,edit,options)
-}} else if(parent.type==="array"&&typeof lastSegment==="number"&&Array.isArray(parent.children)){const insertIndex=lastSegment
-if(insertIndex===-1){const newProperty=`${JSON.stringify(value)}`
-let edit
-if(parent.children.length===0){edit={offset:parent.offset + 1,length:0,content:newProperty}} else{const previous=parent.children[parent.children.length-1]
-edit={offset:previous.offset + previous.length,length:0,content:"," + newProperty}}
-return withFormatting(text,edit,options)
-} else if(value===undefined&&parent.children.length>=0){const removalIndex=lastSegment
-const toRemove=parent.children[removalIndex]
-let edit
-if(parent.children.length===1){edit={offset:parent.offset + 1,length:parent.length-2,content:""}} else if(parent.children.length-1===removalIndex){let previous=parent.children[removalIndex-1]
-let offset=previous.offset + previous.length
-let parentEndOffset=parent.offset + parent.length
-edit={offset,length:parentEndOffset-2-offset,content:""}} else{edit={offset:toRemove.offset,length:parent.children[removalIndex + 1].offset-toRemove.offset,content:""}}
-return withFormatting(text,edit,options)
-} else if(value!==undefined){let edit
-const newProperty=`${JSON.stringify(value)}`
-if(!options.isArrayInsertion&&parent.children.length>lastSegment){const toModify=parent.children[lastSegment]
-edit={offset:toModify.offset,length:toModify.length,content:newProperty}} else if(parent.children.length===0||lastSegment===0){edit={offset:parent.offset + 1,length:0,content:parent.children.length===0?newProperty:newProperty + ","}} else{const index=lastSegment>parent.children.length?parent.children.length:lastSegment
-const previous=parent.children[index-1]
-edit={offset:previous.offset + previous.length,length:0,content:"," + newProperty}}
-return withFormatting(text,edit,options)
-} else{throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`)
-}} else{throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`)
-}}
-function withFormatting(text,edit,options){if(!options.formattingOptions){return [edit]
-}
-let newText=applyEdit(text,edit)
-let begin=edit.offset
-let end=edit.offset + edit.content.length
-if(edit.length===0||edit.content.length===0){while(begin>0&&!isEOL(newText,begin-1)){begin--
-}
-while(end<newText.length&&!isEOL(newText,end)){end++
-}}
-const edits=format(newText,{offset:begin,length:end-begin},{...options.formattingOptions,keepLines:false})
-for(let i=edits.length-1;i>=0; i--){const edit=edits[i]
-newText=applyEdit(newText,edit)
-begin=Math.min(begin,edit.offset)
-end=Math.max(end,edit.offset + edit.length)
-end += edit.content.length-edit.length
-}
-const editLength=text.length-(newText.length-end)-begin
-return [{offset:begin,length:editLength,content:newText.substring(begin,end)}]
-}
-function applyEdit(text,edit){return text.substring(0,edit.offset) + edit.content + text.substring(edit.offset + edit.length)
-}
-var ScanError;
-(function(ScanError){ScanError[ScanError["None"]=0]="None"
-ScanError[ScanError["UnexpectedEndOfComment"]=1]="UnexpectedEndOfComment"
-ScanError[ScanError["UnexpectedEndOfString"]=2]="UnexpectedEndOfString"
-ScanError[ScanError["UnexpectedEndOfNumber"]=3]="UnexpectedEndOfNumber"
-ScanError[ScanError["InvalidUnicode"]=4]="InvalidUnicode"
-ScanError[ScanError["InvalidEscapeCharacter"]=5]="InvalidEscapeCharacter"
-ScanError[ScanError["InvalidCharacter"]=6]="InvalidCharacter"
-})(ScanError||(ScanError={}))
-var SyntaxKind;
-(function(SyntaxKind){SyntaxKind[SyntaxKind["OpenBraceToken"]=1]="OpenBraceToken"
-SyntaxKind[SyntaxKind["CloseBraceToken"]=2]="CloseBraceToken"
-SyntaxKind[SyntaxKind["OpenBracketToken"]=3]="OpenBracketToken"
-SyntaxKind[SyntaxKind["CloseBracketToken"]=4]="CloseBracketToken"
-SyntaxKind[SyntaxKind["CommaToken"]=5]="CommaToken"
-SyntaxKind[SyntaxKind["ColonToken"]=6]="ColonToken"
-SyntaxKind[SyntaxKind["NullKeyword"]=7]="NullKeyword"
-SyntaxKind[SyntaxKind["TrueKeyword"]=8]="TrueKeyword"
-SyntaxKind[SyntaxKind["FalseKeyword"]=9]="FalseKeyword"
-SyntaxKind[SyntaxKind["StringLiteral"]=10]="StringLiteral"
-SyntaxKind[SyntaxKind["NumericLiteral"]=11]="NumericLiteral"
-SyntaxKind[SyntaxKind["LineCommentTrivia"]=12]="LineCommentTrivia"
-SyntaxKind[SyntaxKind["BlockCommentTrivia"]=13]="BlockCommentTrivia"
-SyntaxKind[SyntaxKind["LineBreakTrivia"]=14]="LineBreakTrivia"
-SyntaxKind[SyntaxKind["Trivia"]=15]="Trivia"
-SyntaxKind[SyntaxKind["Unknown"]=16]="Unknown"
-SyntaxKind[SyntaxKind["EOF"]=17]="EOF"
-})(SyntaxKind||(SyntaxKind={}))
-var parseTree2=parseTree
-var findNodeAtLocation2=findNodeAtLocation
-var ParseErrorCode;
-(function(ParseErrorCode){ParseErrorCode[ParseErrorCode["InvalidSymbol"]=1]="InvalidSymbol"
-ParseErrorCode[ParseErrorCode["InvalidNumberFormat"]=2]="InvalidNumberFormat"
-ParseErrorCode[ParseErrorCode["PropertyNameExpected"]=3]="PropertyNameExpected"
-ParseErrorCode[ParseErrorCode["ValueExpected"]=4]="ValueExpected"
-ParseErrorCode[ParseErrorCode["ColonExpected"]=5]="ColonExpected"
-ParseErrorCode[ParseErrorCode["CommaExpected"]=6]="CommaExpected"
-ParseErrorCode[ParseErrorCode["CloseBraceExpected"]=7]="CloseBraceExpected"
-ParseErrorCode[ParseErrorCode["CloseBracketExpected"]=8]="CloseBracketExpected"
-ParseErrorCode[ParseErrorCode["EndOfFileExpected"]=9]="EndOfFileExpected"
-ParseErrorCode[ParseErrorCode["InvalidCommentToken"]=10]="InvalidCommentToken"
-ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"]=11]="UnexpectedEndOfComment"
-ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"]=12]="UnexpectedEndOfString"
-ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"]=13]="UnexpectedEndOfNumber"
-ParseErrorCode[ParseErrorCode["InvalidUnicode"]=14]="InvalidUnicode"
-ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"]=15]="InvalidEscapeCharacter"
-ParseErrorCode[ParseErrorCode["InvalidCharacter"]=16]="InvalidCharacter"
-})(ParseErrorCode||(ParseErrorCode={}))
-function modify(text,path,value,options){return setProperty(text,path,value,options)
-}
-function applyEdits(text,edits){let sortedEdits=edits.slice(0).sort((a,b)=>{const diff=a.offset-b.offset
-if(diff===0){return a.length-b.length
-}
-return diff
-})
-let lastModifiedOffset=text.length
-for(let i=sortedEdits.length-1;i>=0; i--){let e=sortedEdits[i]
-if(e.offset + e.length<=lastModifiedOffset){text=applyEdit(text,e)
-} else{throw new Error("Overlapping edit")
-}
-lastModifiedOffset=e.offset
-}
-return text
-}
 function unique(node,key){const matches=node.children?.filter((property)=>property.children?.[0].value===key)??[]
 if(matches.length>1)
 throw new Error(`Duplicate ${key} fields; edit this configuration manually.`)
@@ -845,16 +20,16 @@ throw new Error("The configuration is too large to edit safely.")
 const prefix=source.startsWith("\uFEFF")?"\uFEFF":""
 const text=source.slice(prefix.length)
 const errors=[]
-const root=parseTree2(text,errors,{allowTrailingComma:true})
+const root=parseTree(text,errors,{allowTrailingComma:true})
 if(errors.length>0||root?.type!=="object")
 throw new Error("The configuration is not a valid JSON/JSONC object.")
 unique(root,"experimental")
-const experimental=findNodeAtLocation2(root,["experimental"])
+const experimental=findNodeAtLocation(root,["experimental"])
 if(experimental&&experimental.type!=="object")
 throw new Error("experimental must be an object.")
 if(experimental)
 unique(experimental,"todo")
-const todo=findNodeAtLocation2(root,["experimental","todo"])
+const todo=findNodeAtLocation(root,["experimental","todo"])
 if(todo&&todo.type!=="boolean")
 throw new Error("experimental.todo must be a boolean.")
 const edits=modify(text,["experimental","todo"],true,{formattingOptions:{insertSpaces:!/^\t/mu.test(source),tabSize:2,eol:source.includes(`\r