2020-06-17 18:59:00

34 files changed, 1202 insertions, 313 deletions

diff --git a/context/data/scite/context/lexers/data/scite-context-data-context.lua b/context/data/scite/context/lexers/data/scite-context-data-context.lua
index bec15067d..3e243b290 100644
--- a/context/data/scite/context/lexers/data/scite-context-data-context.lua
+++ b/context/data/scite/context/lexers/data/scite-context-data-context.lua
@@ -1,4 +1,4 @@
 return {
- ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" },
+ ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" },
  ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifelsesetups", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "copysetups", "resetsetups", "doifelsecommandhandler", "doifcommandhandlerelse", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "globalsetmode", "globalresetmode", "globalsetsystemmode", "globalresetsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "autorule", "strippedcsname", "checkedstrippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthargumenttrue", "sixthargumentfalse", "sixthargumenttrue", "seventhargumentfalse", "seventhargumenttrue", "vkern", "hkern", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "foundtrue", "foundfalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "startpickupmath", "stoppickupmath", "reqno", "mathortext", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilll", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "normalhfilllneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilll", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "normalvfilllneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhpack", "ruledvpack", "ruledtpack", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "privatescratchcounter", "scratchdimen", "globalscratchdimen", "privatescratchdimen", "scratchskip", "globalscratchskip", "privatescratchskip", "scratchmuskip", "globalscratchmuskip", "privatescratchmuskip", "scratchtoks", "globalscratchtoks", "privatescratchtoks", "scratchbox", "globalscratchbox", "privatescratchbox", "globalscratchcounterone", "globalscratchcountertwo", "globalscratchcounterthree", "groupedcommand", "groupedcommandcs", "triggergroupedcommand", "triggergroupedcommandcs", "simplegroupedcommand", "pickupgroupedcommand", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "next", "nexttoken", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "flushnextbox", "boxisempty", "givenwidth", "givenheight", "givendepth", "scangivendimensions", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchtotal", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchcounterfour", "scratchcounterfive", "scratchcountersix", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchdimenfour", "scratchdimenfive", "scratchdimensix", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchskipfour", "scratchskipfive", "scratchskipsix", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchmuskipfour", "scratchmuskipfive", "scratchmuskipsix", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchtoksfour", "scratchtoksfive", "scratchtokssix", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchboxfour", "scratchboxfive", "scratchboxsix", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchmin", "scratchmax", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "firstinset", "doifinset", "doifnotinset", "doifelseinset", "doifinsetelse", "doifelsenextchar", "doifnextcharelse", "doifelsenextcharcs", "doifnextcharcselse", "doifelsenextoptional", "doifnextoptionalelse", "doifelsenextoptionalcs", "doifnextoptionalcselse", "doifelsefastoptionalcheck", "doiffastoptionalcheckelse", "doifelsefastoptionalcheckcs", "doiffastoptionalcheckcselse", "doifelsenextbgroup", "doifnextbgroupelse", "doifelsenextbgroupcs", "doifnextbgroupcselse", "doifelsenextparenthesis", "doifnextparenthesiselse", "doifelseundefined", "doifundefinedelse", "doifelsedefined", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifnothingelse", "doifelsesomething", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifvaluenothingelse", "doifelsedimension", "doifdimensionelse", "doifelsenumber", "doifnumberelse", "doifnumber", "doifnotnumber", "doifelsecommon", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifelseinstring", "doifinstringelse", "doifelseassignment", "doifassignmentelse", "docheckassignment", "doifelseassignmentcs", "doifassignmentelsecs", "validassignment", "novalidassignment", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "quitcondition", "truecondition", "falsecondition", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "emspace", "charspace", "nbsp", "crlf", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "removepunctuation", "ignoreparskip", "forcestrutdepth", "onlynonbreakablespace", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "directmeasure", "setquantity", "setequantity", "setgquantity", "setxquantity", "definequantity", "freezequantity", "quantity", "quantitied", "directquantity", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "setexpandeddummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "fastloopindex", "fastloopfinal", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "onlypdfobjectcompression", "nopdfobjectcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doifelsefirstchar", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "halflinestrut", "noheightstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "strutgap", "begstrut", "endstrut", "lineheight", "leftboundary", "rightboundary", "signalcharacter", "shiftbox", "vpackbox", "hpackbox", "vpackedbox", "hpackedbox", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "normalsuperscript", "normalsubscript", "normalnosuperscript", "normalnosubscript", "superscript", "subscript", "nosuperscript", "nosubscript", "superprescript", "subprescript", "nosuperprescript", "nosubsprecript", "uncramped", "cramped", "mathstyletrigger", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expelsedoif", "expdoif", "expdoifnot", "expdoifelsecommon", "expdoifcommonelse", "expdoifelseinset", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "installctxfunction", "installprotectedctxfunction", "installprotectedctxscanner", "installctxscanner", "resetctxscanner", "cldprocessfile", "cldloadfile", "cldloadviafile", "cldcontext", "cldcommand", "carryoverpar", "lastlinewidth", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "leftorrighthbox", "leftorrightvbox", "leftorrightvtop", "lefttoright", "righttoleft", "checkedlefttoright", "checkedrighttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "dirlre", "dirrle", "dirlro", "dirrlo", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath", "break", "nobreak", "allowbreak", "goodbreak", "nospace", "nospacing", "dospacing", "naturalhbox", "naturalvbox", "naturalvtop", "naturalhpack", "naturalvpack", "naturaltpack", "reversehbox", "reversevbox", "reversevtop", "reversehpack", "reversevpack", "reversetpack", "frule", "compoundhyphenpenalty", "start", "stop", "unsupportedcs" },
 }
\ No newline at end of file
diff --git a/context/data/scite/context/scite-context-data-context.properties b/context/data/scite/context/scite-context-data-context.properties
index ca68597f6..5bebca808 100644
--- a/context/data/scite/context/scite-context-data-context.properties
+++ b/context/data/scite/context/scite-context-data-context.properties
@@ -44,8 +44,7 @@ trueifcode falseifcode caseifcode definedifcode csnameifcode \
 fontcharifcode fontslantperpoint fontinterwordspace fontinterwordstretch fontinterwordshrink \
 fontexheight fontemwidth fontextraspace slantperpoint mathexheight \
 mathemwidth interwordspace interwordstretch interwordshrink exheight \
-emwidth extraspace mathsupdisplay mathsupnormal mathsupcramped \
-mathsubnormal mathsubcombined mathaxisheight muquad startmode \
+emwidth extraspace mathaxisheight muquad startmode \
 stopmode startnotmode stopnotmode startmodeset stopmodeset \
 doifmode doifelsemode doifmodeelse doifnotmode startmodeset \
 stopmodeset startallmodes stopallmodes startnotallmodes stopnotallmodes \
diff --git a/context/data/textadept/context/data/scite-context-data-context.lua b/context/data/textadept/context/data/scite-context-data-context.lua
index bec15067d..3e243b290 100644
--- a/context/data/textadept/context/data/scite-context-data-context.lua
+++ b/context/data/textadept/context/data/scite-context-data-context.lua
@@ -1,4 +1,4 @@
 return {
- ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" },
+ ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "plussixteen", "plusfifty", "plushundred", "plusonehundred", "plustwohundred", "plusfivehundred", "plusthousand", "plustenthousand", "plustwentythousand", "medcard", "maxcard", "maxcardminusone", "zeropoint", "onepoint", "halfapoint", "onebasepoint", "maxcount", "maxdimen", "scaledpoint", "thousandpoint", "points", "halfpoint", "zeroskip", "zeromuskip", "onemuskip", "pluscxxvii", "pluscxxviii", "pluscclv", "pluscclvi", "normalpagebox", "directionlefttoright", "directionrighttoleft", "endoflinetoken", "outputnewlinechar", "emptytoks", "empty", "undefined", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextkind", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "escapecatcode", "begingroupcatcode", "endgroupcatcode", "mathshiftcatcode", "alignmentcatcode", "endoflinecatcode", "parametercatcode", "superscriptcatcode", "subscriptcatcode", "ignorecatcode", "spacecatcode", "lettercatcode", "othercatcode", "activecatcode", "commentcatcode", "invalidcatcode", "tabasciicode", "newlineasciicode", "formfeedasciicode", "endoflineasciicode", "endoffileasciicode", "commaasciicode", "spaceasciicode", "periodasciicode", "hashasciicode", "dollarasciicode", "commentasciicode", "ampersandasciicode", "colonasciicode", "backslashasciicode", "circumflexasciicode", "underscoreasciicode", "leftbraceasciicode", "barasciicode", "rightbraceasciicode", "tildeasciicode", "delasciicode", "leftparentasciicode", "rightparentasciicode", "lessthanasciicode", "morethanasciicode", "doublecommentsignal", "atsignasciicode", "exclamationmarkasciicode", "questionmarkasciicode", "doublequoteasciicode", "singlequoteasciicode", "forwardslashasciicode", "primeasciicode", "hyphenasciicode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "vadjustgroupcode", "charnodecode", "hlistnodecode", "vlistnodecode", "rulenodecode", "insertnodecode", "marknodecode", "adjustnodecode", "ligaturenodecode", "discretionarynodecode", "whatsitnodecode", "mathnodecode", "gluenodecode", "kernnodecode", "penaltynodecode", "unsetnodecode", "mathsnodecode", "charifcode", "catifcode", "numifcode", "dimifcode", "oddifcode", "vmodeifcode", "hmodeifcode", "mmodeifcode", "innerifcode", "voidifcode", "hboxifcode", "vboxifcode", "xifcode", "eofifcode", "trueifcode", "falseifcode", "caseifcode", "definedifcode", "csnameifcode", "fontcharifcode", "fontslantperpoint", "fontinterwordspace", "fontinterwordstretch", "fontinterwordshrink", "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint", "mathexheight", "mathemwidth", "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace", "mathaxisheight", "muquad", "startmode", "stopmode", "startnotmode", "stopnotmode", "startmodeset", "stopmodeset", "doifmode", "doifelsemode", "doifmodeelse", "doifnotmode", "startmodeset", "stopmodeset", "startallmodes", "stopallmodes", "startnotallmodes", "stopnotallmodes", "doifallmodes", "doifelseallmodes", "doifallmodeselse", "doifnotallmodes", "startenvironment", "stopenvironment", "environment", "startcomponent", "stopcomponent", "component", "startproduct", "stopproduct", "product", "startproject", "stopproject", "project", "starttext", "stoptext", "startnotext", "stopnotext", "startdocument", "stopdocument", "documentvariable", "unexpandeddocumentvariable", "setupdocument", "presetdocument", "doifelsedocumentvariable", "doifdocumentvariableelse", "doifdocumentvariable", "doifnotdocumentvariable", "startmodule", "stopmodule", "usemodule", "usetexmodule", "useluamodule", "setupmodule", "currentmoduleparameter", "moduleparameter", "everystarttext", "everystoptext", "startTEXpage", "stopTEXpage", "enablemode", "disablemode", "preventmode", "definemode", "globalenablemode", "globaldisablemode", "globalpreventmode", "pushmode", "popmode", "typescriptone", "typescripttwo", "typescriptthree", "mathsizesuffix", "mathordcode", "mathopcode", "mathbincode", "mathrelcode", "mathopencode", "mathclosecode", "mathpunctcode", "mathalphacode", "mathinnercode", "mathnothingcode", "mathlimopcode", "mathnolopcode", "mathboxcode", "mathchoicecode", "mathaccentcode", "mathradicalcode", "constantnumber", "constantnumberargument", "constantdimen", "constantdimenargument", "constantemptyargument", "continueifinputfile", "luastringsep", "!!bs", "!!es", "lefttorightmark", "righttoleftmark", "lrm", "rlm", "bidilre", "bidirle", "bidipop", "bidilro", "bidirlo", "breakablethinspace", "nobreakspace", "nonbreakablespace", "narrownobreakspace", "zerowidthnobreakspace", "ideographicspace", "ideographichalffillspace", "twoperemspace", "threeperemspace", "fourperemspace", "fiveperemspace", "sixperemspace", "figurespace", "punctuationspace", "hairspace", "enquad", "emquad", "zerowidthspace", "zerowidthnonjoiner", "zerowidthjoiner", "zwnj", "zwj", "optionalspace", "asciispacechar", "softhyphen", "Ux", "eUx", "Umathaccents", "parfillleftskip", "parfillrightskip", "startlmtxmode", "stoplmtxmode", "startmkivmode", "stopmkivmode", "wildcardsymbol" },
  ["helpers"]={ "startsetups", "stopsetups", "startxmlsetups", "stopxmlsetups", "startluasetups", "stopluasetups", "starttexsetups", "stoptexsetups", "startrawsetups", "stoprawsetups", "startlocalsetups", "stoplocalsetups", "starttexdefinition", "stoptexdefinition", "starttexcode", "stoptexcode", "startcontextcode", "stopcontextcode", "startcontextdefinitioncode", "stopcontextdefinitioncode", "texdefinition", "doifelsesetups", "doifsetupselse", "doifsetups", "doifnotsetups", "setup", "setups", "texsetup", "xmlsetup", "luasetup", "directsetup", "fastsetup", "copysetups", "resetsetups", "doifelsecommandhandler", "doifcommandhandlerelse", "doifnotcommandhandler", "doifcommandhandler", "newmode", "setmode", "resetmode", "newsystemmode", "setsystemmode", "resetsystemmode", "pushsystemmode", "popsystemmode", "globalsetmode", "globalresetmode", "globalsetsystemmode", "globalresetsystemmode", "booleanmodevalue", "newcount", "newdimen", "newskip", "newmuskip", "newbox", "newtoks", "newread", "newwrite", "newmarks", "newinsert", "newattribute", "newif", "newlanguage", "newfamily", "newfam", "newhelp", "then", "begcsname", "autorule", "strippedcsname", "checkedstrippedcsname", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthargumenttrue", "sixthargumentfalse", "sixthargumenttrue", "seventhargumentfalse", "seventhargumenttrue", "vkern", "hkern", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "dontcomplain", "forgetall", "donetrue", "donefalse", "foundtrue", "foundfalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "startpickupmath", "stoppickupmath", "reqno", "mathortext", "htdp", "unvoidbox", "hfilll", "vfilll", "mathbox", "mathlimop", "mathnolop", "mathnothing", "mathalpha", "currentcatcodetable", "defaultcatcodetable", "catcodetablename", "newcatcodetable", "startcatcodetable", "stopcatcodetable", "startextendcatcodetable", "stopextendcatcodetable", "pushcatcodetable", "popcatcodetable", "restorecatcodes", "setcatcodetable", "letcatcodecommand", "defcatcodecommand", "uedcatcodecommand", "hglue", "vglue", "hfillneg", "vfillneg", "hfilllneg", "vfilllneg", "ruledhss", "ruledhfil", "ruledhfill", "ruledhfilll", "ruledhfilneg", "ruledhfillneg", "normalhfillneg", "normalhfilllneg", "ruledvss", "ruledvfil", "ruledvfill", "ruledvfilll", "ruledvfilneg", "ruledvfillneg", "normalvfillneg", "normalvfilllneg", "ruledhbox", "ruledvbox", "ruledvtop", "ruledvcenter", "ruledmbox", "ruledhpack", "ruledvpack", "ruledtpack", "ruledhskip", "ruledvskip", "ruledkern", "ruledmskip", "ruledmkern", "ruledhglue", "ruledvglue", "normalhglue", "normalvglue", "ruledpenalty", "filledhboxb", "filledhboxr", "filledhboxg", "filledhboxc", "filledhboxm", "filledhboxy", "filledhboxk", "scratchcounter", "globalscratchcounter", "privatescratchcounter", "scratchdimen", "globalscratchdimen", "privatescratchdimen", "scratchskip", "globalscratchskip", "privatescratchskip", "scratchmuskip", "globalscratchmuskip", "privatescratchmuskip", "scratchtoks", "globalscratchtoks", "privatescratchtoks", "scratchbox", "globalscratchbox", "privatescratchbox", "globalscratchcounterone", "globalscratchcountertwo", "globalscratchcounterthree", "groupedcommand", "groupedcommandcs", "triggergroupedcommand", "triggergroupedcommandcs", "simplegroupedcommand", "pickupgroupedcommand", "normalbaselineskip", "normallineskip", "normallineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "next", "nexttoken", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "flushnextbox", "boxisempty", "givenwidth", "givenheight", "givendepth", "scangivendimensions", "scratchwidth", "scratchheight", "scratchdepth", "scratchoffset", "scratchdistance", "scratchtotal", "scratchhsize", "scratchvsize", "scratchxoffset", "scratchyoffset", "scratchhoffset", "scratchvoffset", "scratchxposition", "scratchyposition", "scratchtopoffset", "scratchbottomoffset", "scratchleftoffset", "scratchrightoffset", "scratchcounterone", "scratchcountertwo", "scratchcounterthree", "scratchcounterfour", "scratchcounterfive", "scratchcountersix", "scratchdimenone", "scratchdimentwo", "scratchdimenthree", "scratchdimenfour", "scratchdimenfive", "scratchdimensix", "scratchskipone", "scratchskiptwo", "scratchskipthree", "scratchskipfour", "scratchskipfive", "scratchskipsix", "scratchmuskipone", "scratchmuskiptwo", "scratchmuskipthree", "scratchmuskipfour", "scratchmuskipfive", "scratchmuskipsix", "scratchtoksone", "scratchtokstwo", "scratchtoksthree", "scratchtoksfour", "scratchtoksfive", "scratchtokssix", "scratchboxone", "scratchboxtwo", "scratchboxthree", "scratchboxfour", "scratchboxfive", "scratchboxsix", "scratchnx", "scratchny", "scratchmx", "scratchmy", "scratchunicode", "scratchmin", "scratchmax", "scratchleftskip", "scratchrightskip", "scratchtopskip", "scratchbottomskip", "doif", "doifnot", "doifelse", "firstinset", "doifinset", "doifnotinset", "doifelseinset", "doifinsetelse", "doifelsenextchar", "doifnextcharelse", "doifelsenextcharcs", "doifnextcharcselse", "doifelsenextoptional", "doifnextoptionalelse", "doifelsenextoptionalcs", "doifnextoptionalcselse", "doifelsefastoptionalcheck", "doiffastoptionalcheckelse", "doifelsefastoptionalcheckcs", "doiffastoptionalcheckcselse", "doifelsenextbgroup", "doifnextbgroupelse", "doifelsenextbgroupcs", "doifnextbgroupcselse", "doifelsenextparenthesis", "doifnextparenthesiselse", "doifelseundefined", "doifundefinedelse", "doifelsedefined", "doifdefinedelse", "doifundefined", "doifdefined", "doifelsevalue", "doifvalue", "doifnotvalue", "doifnothing", "doifsomething", "doifelsenothing", "doifnothingelse", "doifelsesomething", "doifsomethingelse", "doifvaluenothing", "doifvaluesomething", "doifelsevaluenothing", "doifvaluenothingelse", "doifelsedimension", "doifdimensionelse", "doifelsenumber", "doifnumberelse", "doifnumber", "doifnotnumber", "doifelsecommon", "doifcommonelse", "doifcommon", "doifnotcommon", "doifinstring", "doifnotinstring", "doifelseinstring", "doifinstringelse", "doifelseassignment", "doifassignmentelse", "docheckassignment", "doifelseassignmentcs", "doifassignmentelsecs", "validassignment", "novalidassignment", "doiftext", "doifelsetext", "doiftextelse", "doifnottext", "quitcondition", "truecondition", "falsecondition", "tracingall", "tracingnone", "loggingall", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "everyendpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "emspace", "charspace", "nbsp", "crlf", "obeyspaces", "obeylines", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "executeifdefined", "singleexpandafter", "doubleexpandafter", "tripleexpandafter", "dontleavehmode", "removelastspace", "removeunwantedspaces", "keepunwantedspaces", "removepunctuation", "ignoreparskip", "forcestrutdepth", "onlynonbreakablespace", "wait", "writestatus", "define", "defineexpandable", "redefine", "setmeasure", "setemeasure", "setgmeasure", "setxmeasure", "definemeasure", "freezemeasure", "measure", "measured", "directmeasure", "setquantity", "setequantity", "setgquantity", "setxquantity", "definequantity", "freezequantity", "quantity", "quantitied", "directquantity", "installcorenamespace", "getvalue", "getuvalue", "setvalue", "setevalue", "setgvalue", "setxvalue", "letvalue", "letgvalue", "resetvalue", "undefinevalue", "ignorevalue", "setuvalue", "setuevalue", "setugvalue", "setuxvalue", "globallet", "glet", "udef", "ugdef", "uedef", "uxdef", "checked", "unique", "getparameters", "geteparameters", "getgparameters", "getxparameters", "forgetparameters", "copyparameters", "getdummyparameters", "dummyparameter", "directdummyparameter", "setdummyparameter", "letdummyparameter", "setexpandeddummyparameter", "usedummystyleandcolor", "usedummystyleparameter", "usedummycolorparameter", "processcommalist", "processcommacommand", "quitcommalist", "quitprevcommalist", "processaction", "processallactions", "processfirstactioninset", "processallactionsinset", "unexpanded", "expanded", "startexpanded", "stopexpanded", "protected", "protect", "unprotect", "firstofoneargument", "firstoftwoarguments", "secondoftwoarguments", "firstofthreearguments", "secondofthreearguments", "thirdofthreearguments", "firstoffourarguments", "secondoffourarguments", "thirdoffourarguments", "fourthoffourarguments", "firstoffivearguments", "secondoffivearguments", "thirdoffivearguments", "fourthoffivearguments", "fifthoffivearguments", "firstofsixarguments", "secondofsixarguments", "thirdofsixarguments", "fourthofsixarguments", "fifthofsixarguments", "sixthofsixarguments", "firstofoneunexpanded", "firstoftwounexpanded", "secondoftwounexpanded", "firstofthreeunexpanded", "secondofthreeunexpanded", "thirdofthreeunexpanded", "gobbleoneargument", "gobbletwoarguments", "gobblethreearguments", "gobblefourarguments", "gobblefivearguments", "gobblesixarguments", "gobblesevenarguments", "gobbleeightarguments", "gobbleninearguments", "gobbletenarguments", "gobbleoneoptional", "gobbletwooptionals", "gobblethreeoptionals", "gobblefouroptionals", "gobblefiveoptionals", "dorecurse", "doloop", "exitloop", "dostepwiserecurse", "recurselevel", "recursedepth", "dofastloopcs", "fastloopindex", "fastloopfinal", "dowith", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "newmacro", "setnewmacro", "newfraction", "newsignal", "dosingleempty", "dodoubleempty", "dotripleempty", "doquadrupleempty", "doquintupleempty", "dosixtupleempty", "doseventupleempty", "dosingleargument", "dodoubleargument", "dotripleargument", "doquadrupleargument", "doquintupleargument", "dosixtupleargument", "doseventupleargument", "dosinglegroupempty", "dodoublegroupempty", "dotriplegroupempty", "doquadruplegroupempty", "doquintuplegroupempty", "permitspacesbetweengroups", "dontpermitspacesbetweengroups", "nopdfcompression", "maximumpdfcompression", "normalpdfcompression", "onlypdfobjectcompression", "nopdfobjectcompression", "modulonumber", "dividenumber", "getfirstcharacter", "doifelsefirstchar", "doiffirstcharelse", "startnointerference", "stopnointerference", "twodigits", "threedigits", "leftorright", "offinterlineskip", "oninterlineskip", "nointerlineskip", "strut", "halfstrut", "quarterstrut", "depthstrut", "halflinestrut", "noheightstrut", "setstrut", "strutbox", "strutht", "strutdp", "strutwd", "struthtdp", "strutgap", "begstrut", "endstrut", "lineheight", "leftboundary", "rightboundary", "signalcharacter", "shiftbox", "vpackbox", "hpackbox", "vpackedbox", "hpackedbox", "ordordspacing", "ordopspacing", "ordbinspacing", "ordrelspacing", "ordopenspacing", "ordclosespacing", "ordpunctspacing", "ordinnerspacing", "opordspacing", "opopspacing", "opbinspacing", "oprelspacing", "opopenspacing", "opclosespacing", "oppunctspacing", "opinnerspacing", "binordspacing", "binopspacing", "binbinspacing", "binrelspacing", "binopenspacing", "binclosespacing", "binpunctspacing", "bininnerspacing", "relordspacing", "relopspacing", "relbinspacing", "relrelspacing", "relopenspacing", "relclosespacing", "relpunctspacing", "relinnerspacing", "openordspacing", "openopspacing", "openbinspacing", "openrelspacing", "openopenspacing", "openclosespacing", "openpunctspacing", "openinnerspacing", "closeordspacing", "closeopspacing", "closebinspacing", "closerelspacing", "closeopenspacing", "closeclosespacing", "closepunctspacing", "closeinnerspacing", "punctordspacing", "punctopspacing", "punctbinspacing", "punctrelspacing", "punctopenspacing", "punctclosespacing", "punctpunctspacing", "punctinnerspacing", "innerordspacing", "inneropspacing", "innerbinspacing", "innerrelspacing", "inneropenspacing", "innerclosespacing", "innerpunctspacing", "innerinnerspacing", "normalreqno", "startimath", "stopimath", "normalstartimath", "normalstopimath", "startdmath", "stopdmath", "normalstartdmath", "normalstopdmath", "normalsuperscript", "normalsubscript", "normalnosuperscript", "normalnosubscript", "superscript", "subscript", "nosuperscript", "nosubscript", "superprescript", "subprescript", "nosuperprescript", "nosubsprecript", "uncramped", "cramped", "mathstyletrigger", "triggermathstyle", "mathstylefont", "mathsmallstylefont", "mathstyleface", "mathsmallstyleface", "mathstylecommand", "mathpalette", "mathstylehbox", "mathstylevbox", "mathstylevcenter", "mathstylevcenteredhbox", "mathstylevcenteredvbox", "mathtext", "setmathsmalltextbox", "setmathtextbox", "pushmathstyle", "popmathstyle", "triggerdisplaystyle", "triggertextstyle", "triggerscriptstyle", "triggerscriptscriptstyle", "triggeruncrampedstyle", "triggercrampedstyle", "triggersmallstyle", "triggeruncrampedsmallstyle", "triggercrampedsmallstyle", "triggerbigstyle", "triggeruncrampedbigstyle", "triggercrampedbigstyle", "luaexpr", "expelsedoif", "expdoif", "expdoifnot", "expdoifelsecommon", "expdoifcommonelse", "expdoifelseinset", "expdoifinsetelse", "ctxdirectlua", "ctxlatelua", "ctxsprint", "ctxwrite", "ctxcommand", "ctxdirectcommand", "ctxlatecommand", "ctxreport", "ctxlua", "luacode", "lateluacode", "directluacode", "registerctxluafile", "ctxloadluafile", "luaversion", "luamajorversion", "luaminorversion", "ctxluacode", "luaconditional", "luaexpanded", "startluaparameterset", "stopluaparameterset", "luaparameterset", "definenamedlua", "obeylualines", "obeyluatokens", "startluacode", "stopluacode", "startlua", "stoplua", "startctxfunction", "stopctxfunction", "ctxfunction", "startctxfunctiondefinition", "stopctxfunctiondefinition", "installctxfunction", "installprotectedctxfunction", "installprotectedctxscanner", "installctxscanner", "resetctxscanner", "cldprocessfile", "cldloadfile", "cldloadviafile", "cldcontext", "cldcommand", "carryoverpar", "lastlinewidth", "assumelongusagecs", "Umathbotaccent", "righttolefthbox", "lefttorighthbox", "righttoleftvbox", "lefttorightvbox", "righttoleftvtop", "lefttorightvtop", "rtlhbox", "ltrhbox", "rtlvbox", "ltrvbox", "rtlvtop", "ltrvtop", "autodirhbox", "autodirvbox", "autodirvtop", "leftorrighthbox", "leftorrightvbox", "leftorrightvtop", "lefttoright", "righttoleft", "checkedlefttoright", "checkedrighttoleft", "synchronizelayoutdirection", "synchronizedisplaydirection", "synchronizeinlinedirection", "dirlre", "dirrle", "dirlro", "dirrlo", "lesshyphens", "morehyphens", "nohyphens", "dohyphens", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath", "break", "nobreak", "allowbreak", "goodbreak", "nospace", "nospacing", "dospacing", "naturalhbox", "naturalvbox", "naturalvtop", "naturalhpack", "naturalvpack", "naturaltpack", "reversehbox", "reversevbox", "reversevtop", "reversehpack", "reversevpack", "reversetpack", "frule", "compoundhyphenpenalty", "start", "stop", "unsupportedcs" },
 }
\ No newline at end of file
diff --git a/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json b/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json
index 36a8532e7..4ed46b02b 100644
--- a/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json
+++ b/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json
@@ -68,7 +68,7 @@
    "name" : "context.comment.comment.tex"
   },
   "constant" : {
-   "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|whatsitnodecode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeifcode|vlistnodecode|vcentergroupcode|vboxifcode|vboxgroupcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tildeasciicode|threeperemspace|thousandpoint|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|superscriptcatcode|subscriptcatcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|sixperemspace|singlequoteasciicode|simplegroupcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbraceasciicode|questionmarkasciicode|pushmode|punctuationspace|prtcatcodes|project|product|primeasciicode|preventmode|presetdocument|popmode|points|plustwohundred|plustwo|plustwentythousand|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|periodasciicode|penaltynodecode|pdftexengine|parfillrightskip|parfillleftskip|parametercatcode|outputnewlinechar|outputgroupcode|othercatcode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|normalpagebox|nonstopmodecode|nonbreakablespace|nobreakspace|noaligngroupcode|nilcatcodes|newlineasciicode|narrownobreakspace|muquad|morethanasciicode|moduleparameter|mmodeifcode|mksuffix|minustwo|minusone|medskipamount|medcard|maxdimen|maxcount|maxcardminusone|maxcard|mathsupnormal|mathsupdisplay|mathsupcramped|mathsubnormal|mathsubcombined|mathsnodecode|mathsizesuffix|mathshiftgroupcode|mathshiftcatcode|mathrelcode|mathradicalcode|mathpunctcode|mathordcode|mathopencode|mathopcode|mathnothingcode|mathnolopcode|mathnodecode|mathlimopcode|mathleftgroupcode|mathinnercode|mathgroupcode|mathexheight|mathemwidth|mathclosecode|mathchoicegroupcode|mathchoicecode|mathboxcode|mathbincode|mathaxisheight|mathalphacode|mathaccentcode|mathabovegroupcode|marknodecode|luatexengine|luastringsep|luacatcodes|lrm|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbraceasciicode|kernnodecode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|insertnodecode|insertgroupcode|innerifcode|inicatcodes|ignorecatcode|ideographicspace|ideographichalffillspace|hyphenasciicode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalenablemode|globaldisablemode|fourperemspace|forwardslashasciicode|formfeedasciicode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|fiveperemspace|figurespace|falseifcode|extraspace|exheight|exclamationmarkasciicode|everystoptext|everystarttext|escapecatcode|errorstopmodecode|eofifcode|environment|enquad|endoflinetoken|endoflinecatcode|endoflineasciicode|endoffileasciicode|endline|endgroupcatcode|enablemode|emwidth|emquad|emptyvbox|emptytoks|emptyhbox|emptybox|empty|egroup|eUx|downrotationangle|doublequoteasciicode|doublecommentsignal|dollarasciicode|doifnotmode|doifnotdocumentvariable|doifnotallmodes|doifmodeelse|doifmode|doifelsemode|doifelsedocumentvariable|doifelseallmodes|doifdocumentvariableelse|doifdocumentvariable|doifallmodeselse|doifallmodes|documentvariable|discretionarynodecode|discretionarygroupcode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextkind|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalfalse|component|commentcatcode|commentasciicode|commaasciicode|colonasciicode|circumflexasciicode|charnodecode|charifcode|catifcode|caseifcode|breakablethinspace|bottomlevelgroupcode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustedhboxgroupcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])",
+   "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|whatsitnodecode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeifcode|vlistnodecode|vcentergroupcode|vboxifcode|vboxgroupcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tildeasciicode|threeperemspace|thousandpoint|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|superscriptcatcode|subscriptcatcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|sixperemspace|singlequoteasciicode|simplegroupcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbraceasciicode|questionmarkasciicode|pushmode|punctuationspace|prtcatcodes|project|product|primeasciicode|preventmode|presetdocument|popmode|points|plustwohundred|plustwo|plustwentythousand|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|periodasciicode|penaltynodecode|pdftexengine|parfillrightskip|parfillleftskip|parametercatcode|outputnewlinechar|outputgroupcode|othercatcode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|normalpagebox|nonstopmodecode|nonbreakablespace|nobreakspace|noaligngroupcode|nilcatcodes|newlineasciicode|narrownobreakspace|muquad|morethanasciicode|moduleparameter|mmodeifcode|mksuffix|minustwo|minusone|medskipamount|medcard|maxdimen|maxcount|maxcardminusone|maxcard|mathsnodecode|mathsizesuffix|mathshiftgroupcode|mathshiftcatcode|mathrelcode|mathradicalcode|mathpunctcode|mathordcode|mathopencode|mathopcode|mathnothingcode|mathnolopcode|mathnodecode|mathlimopcode|mathleftgroupcode|mathinnercode|mathgroupcode|mathexheight|mathemwidth|mathclosecode|mathchoicegroupcode|mathchoicecode|mathboxcode|mathbincode|mathaxisheight|mathalphacode|mathaccentcode|mathabovegroupcode|marknodecode|luatexengine|luastringsep|luacatcodes|lrm|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbraceasciicode|kernnodecode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|insertnodecode|insertgroupcode|innerifcode|inicatcodes|ignorecatcode|ideographicspace|ideographichalffillspace|hyphenasciicode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalenablemode|globaldisablemode|fourperemspace|forwardslashasciicode|formfeedasciicode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|fiveperemspace|figurespace|falseifcode|extraspace|exheight|exclamationmarkasciicode|everystoptext|everystarttext|escapecatcode|errorstopmodecode|eofifcode|environment|enquad|endoflinetoken|endoflinecatcode|endoflineasciicode|endoffileasciicode|endline|endgroupcatcode|enablemode|emwidth|emquad|emptyvbox|emptytoks|emptyhbox|emptybox|empty|egroup|eUx|downrotationangle|doublequoteasciicode|doublecommentsignal|dollarasciicode|doifnotmode|doifnotdocumentvariable|doifnotallmodes|doifmodeelse|doifmode|doifelsemode|doifelsedocumentvariable|doifelseallmodes|doifdocumentvariableelse|doifdocumentvariable|doifallmodeselse|doifallmodes|documentvariable|discretionarynodecode|discretionarygroupcode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextkind|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalfalse|component|commentcatcode|commentasciicode|commaasciicode|colonasciicode|circumflexasciicode|charnodecode|charifcode|catifcode|caseifcode|breakablethinspace|bottomlevelgroupcode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustedhboxgroupcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])",
    "name" : "context.constant.commands.constant.tex"
   },
   "csname" : {
diff --git a/doc/context/documents/general/manuals/evenmore.pdf b/doc/context/documents/general/manuals/evenmore.pdf
index 6e5b1105e..0f7da622e 100644
--- a/doc/context/documents/general/manuals/evenmore.pdf
+++ b/doc/context/documents/general/manuals/evenmore.pdf
diff --git a/doc/context/documents/general/manuals/luametatex.pdf b/doc/context/documents/general/manuals/luametatex.pdf
index 93dcc0868..f3a25d6b3 100644
--- a/doc/context/documents/general/manuals/luametatex.pdf
+++ b/doc/context/documents/general/manuals/luametatex.pdf
diff --git a/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex b/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex
new file mode 100644
index 000000000..d0cc29db1
--- /dev/null
+++ b/doc/context/sources/general/manuals/evenmore/evenmore-parsing.tex
@@ -0,0 +1,425 @@
+% language=us
+
+\environment evenmore-style
+
+\startcomponent evenmore-parsing
+
+\startchapter[title=Parsing]
+
+The macro mechanism is \TEX\ is quite powerful and once you understand the
+concept of mixing parameters and delimiters you can do a lot with it. I assume
+that you know what we're talking about, otherwise quit reading. When grabbing
+arguments, there are a few catches.
+
+\startitemize
+\startitem
+    When they are used, delimiters are mandate: \TEX\ will go on reading an
+    argument till the (current) delimiter condition is met. This means that when
+    you forget one you end up with way more in the argument than expected or even
+    run out of input.
+\stopitem
+\startitem
+    Because specified arguments and delimiters are mandate, when you want to
+    parse input, you often need multi|-|step macros that first pick up the to be
+    parsed input, and then piecewise fetch snippets. Bogus delimiters have to be
+    appended to the original in order to catch a run away argument and checking
+    has to be done to get rid of them when all is ok.
+\stopitem
+\stopitemize
+
+The first item can be illustrated as follows:
+
+\starttyping[option=TEX]
+\def\foo[#1]{...}
+\stoptyping
+
+When \type {\foo} gets expanded \TEX\ first looks for a \type{[} and then starts
+collecting tokens for parameter \type {#1}. It stops doing that when aa \type {]}
+is seen. So,
+
+\starttyping[option=TEX]
+\starttext
+    \foo[whatever
+\stoptext
+\stoptyping
+
+will for sure give an error. When collecting tokens, \TEX\ doesn't expand them so
+the \type {\stoptext} is just turned into a token that gets appended.
+
+The second item is harder to explain (or grasp):
+
+\starttyping[option=TEX]
+\def\foo[#1=#2]{(#1/#2)}
+\stoptyping
+
+Here we expect a key and a value, so these will work:
+
+\starttyping[option=TEX]
+\foo[key=value]
+\foo[key=]
+\stoptyping
+
+while these will fail:
+
+\starttyping[option=TEX]
+\foo[key]
+\foo[]
+\stoptyping
+
+unless we have:
+
+\starttyping[option=TEX]
+\foo[key]=]
+\foo[]=]
+\stoptyping
+
+But, when processing the result, we then need to analyze the found arguments and
+correct for them being wrong. For instance, argument \type {#1} can become \type
+{]} or here \type {key]}. When indeed a valid key|/|value combination is given we
+need to get rid of the two \quote {fixup} tokens \type{=]}. Normally we will have
+multiple key|/|value pairs separated by a comma, and in practice we only need to
+catch the missing equal because we can ignore empty cases. There are plenty of
+examples (rather old old code but also more modern variants) in the \CONTEXT\
+code base.
+
+I will now show some new magic that is available in \LUAMETATEX\ as experimental
+code. It will be tested in \LMTX\ for a while and might evolve in the process.
+
+\startbuffer
+\def\foo#1=#2,{(#1/#2)}
+
+\foo 1=2,\ignorearguments
+\foo 1=2\ignorearguments
+\foo 1\ignorearguments
+\foo \ignorearguments
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+Here we pick up a key and value separated by an equal sign. We end the input with
+a special signal command: \type {\ignorearguments}. This tells the parser to quit
+scanning. So, we get this, without any warning with respect to a missing
+delimiter of running away:
+
+\getbuffer
+
+The implementation is actually fairly simple and adds not much overhead.
+Alternatives (and I pondered a few) are just too messy, would remind me too much
+of those awful expression syntaxes, and definitely impact performance of macro
+expansion, therefore: a no|-|go.
+
+Using this new feature, we can implement a key value parser that does a sequence.
+The prototypes used to get here made only use of this one new feature and
+therefore still had to do some testing of the results. But, after looking at the
+code, I decided that a few more helpers could make better looking code. So this
+is what I ended up with:
+
+\startbuffer
+\def\grabparameter#1=#2,%
+  {\ifarguments\or\or
+     % (\whatever/#1/#2)\par%
+     \expandafter\def\csname\namespace#1\endcsname{#2}%
+     \expandafter\grabnextparameter
+   \fi}
+
+\def\grabnextparameter
+  {\expandafterspaces\grabparameter}
+
+\def\grabparameters[#1]#2[#3]%
+  {\def\namespace{#1}%
+   \expandafterspaces\grabparameter#3\ignorearguments\ignorearguments}
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+Now, this one actually does what the \CONTEXT\ \type {\getparameters} command
+does: setting variables in a namespace. Being a parameter driven macro package
+this kind of macros have been part of \CONTEXT\ since the beginning. There are
+some variants and we also need to deal with the multilingual interface. Actually,
+\MKIV\ (and therefore \LMTX) do things a bit different, but the same principles
+apply.
+
+The \type {\ignorearguments} quits the scanning. Here we need two because we
+actually quit twice. The \type {\expandafterspaces} can be implemented in
+traditional \TEX\ macros but I though it is nice to have it this way; the fact
+that I only now added it has more to do with cosmetics. One could use the already
+somewhat older extension \type {\futureexpandis} (which expands the second or
+third token depending seeing the first, in this variant ignoring spaces) or a
+bunch of good old primitives to do the same. The new conditional \type
+{\ifarguments} can be used to act upon the number of arguments given. It reflects
+the most recently expanded macro. There is also a \type {\lastarguments}
+primitive (that provides the number of arguments.
+
+So, what are the benefits? You might think that it is about performance, but in
+practice there are not that many parameter settings going on. When I process the
+\LUAMETATEX\ manual, only some 5000 times one or more parameters are set. And
+even in a way more complex document that I asked my colleague to run I was a bit
+disappointed that only some 30.000 cases were reported. I know of users who have
+documents with hundreds of thousands of cases, but compared to the rest of
+processing this is not where the performance bottleneck is. \footnote {Think of
+thousands of pages of tables with cell settings applied.} This means that a
+change in implementation like the above is not paying off in significantly better
+runtime: all these low level mechanisms in \CONTEXT\ have been very well
+optimized over the years. And faster machines made old bottlenecks go away
+anyway. Take this use case:
+
+\starttyping[option=TEX]
+\grabparameters
+  [foo]
+  [key0=value0,
+   key1=value1,
+   key2=value2,
+   key3=value3]
+\stoptyping
+
+After this, parameters can be accessed with:
+
+\starttyping[option=TEX]
+\def\getvalue#1#2{\csname#1#2\endcsname}
+\stoptyping
+
+used as:
+
+\starttyping[option=TEX]
+\getvalue{foo}{key2}
+\stoptyping
+
+which takes care of characters normally not permitted in macro names, like the
+digits in this example. Of course some namespace protection can be added, like
+adding a colon between the namespace and the key, but let's take just this one.
+
+Some 10.000 expansions of the grabber take on my machine 0.045 seconds while the
+original \type {\getparameters} takes 0.090 so although for this case we're twice
+as fast, the 0.045 difference will not be noticed on a real run. After all, when
+these parameters are set some action will take place. Also, we don't actually use
+this macro for collecting settings with the \type {\setupsomething} commands, so
+the additional overhead that is involved adds a baseline to performance that can
+turn any gain into noise. But some users might notice some gain. Of course this
+observation might change once we apply this trickery in more places than
+parameter parsing, because I have to admit that there might be other places in
+the support macros where we can benefit: less code, double performance, but these
+are all support macros that made sense in \MKII\ and not that much in \MKIV\ or
+\LMTX\ and are kept just for convenience and backward compatibility. Think of
+some list processing macros. So, as a kind of nostalgic trip I decided to rewrite
+some low level macros anyway, if only to see what is no longer used and|/|or to
+make the code base somewhat (c)leaner.
+
+Elsewhere I introduce the \type {#0} argument indicator. That one will just
+gobbles the argument and does not store a token list on the stack. It saves some
+memory access and token recycling when arguments are not used. Another special
+indicator is \type {#+}. That one will flag an argument to be passed as|-|is. The
+\type {#-} variant will simply discard an argument and move on. The following
+examples demonstrate this:
+
+\startbuffer
+\def\foo    [#1]{\detokenize{#1}}
+\def\ofo    [#0]{\detokenize{#1}}
+\def\oof    [#+]{\detokenize{#1}}
+\def\fof[#1#-#2]{\detokenize{#1#2}}
+\def\fff[#1#0#3]{\detokenize{#1#3}}
+
+\meaning\foo\ : <\foo[{123}]> \crlf
+\meaning\ofo\ : <\ofo[{123}]> \crlf
+\meaning\oof\ : <\oof[{123}]> \crlf
+\meaning\fof\ : <\fof[123]>   \crlf
+\meaning\fff\ : <\fof[123]>   \crlf
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+This gives:
+
+{\tttf \getbuffer}
+
+% \getcommalistsize[a,b,c]   \commalistsize\par
+% \getcommalistsize[{a,b,c}] \commalistsize\par
+
+When playing with new features like the one described here, it makes sense to use
+them in existing macros so that they get well tested. Some of the low level
+system files come in different versions: for \MKII, \MKIV\ and \LMTX. The \MKII\
+files often also have the older implementations, so they are also good for
+looking at the history. The \LMTX\ files can be leaner and meaner than the \MKIV\
+files because they use the latest features. \footnote {Some 70 primitives present
+in \LUATEX\ are not in \LUAMETATEX. On the other hand there are also about 70 new
+primitives. Of those gone, most concerned the backend, fonts or no longer
+relevant features from other engines. Of those new, some are really new
+primitives (conditionals, expansion magic), some control previously hardwired
+behaviour, some give access to properties of for instance boxes, and some are
+just variants of existing ones but with options for control.}
+
+When I was rewriting some of these low level \MKIV\ macros using the newer features,
+at some point I wondered why I still had to jump through some hoops. Why not just
+add some more primitives to deal with that? After all, \LUATEX\ and \LUAMETATEX\
+already have more primitives that are helpful in parsing, so a few dozen more lines
+don't hurt. As long as these primitives are generic and not that specific. In this
+particular case we talk about two new conditionals (in addition to the already
+present comparison primitives):
+
+\starttyping[option=TEX]
+\ifhastok    <token>       {<token list>}
+\ifhastoks  {<token list>} {<token list>}
+\ifhasxtoks {<token list>} {<token list>}
+\stoptyping
+
+You can probably guess what they do from their names. The last one is the
+expandable variant of the second one. The first one is the fast one. When playing
+with these I decided to redo the set checker. In \MKII\ that one is done in good
+old \TEX, in \MKIV\ we use \LUA. So, how about going back to \TEX ?
+
+\starttyping[option=TEX]
+\ifhasxtoks {cd} {abcdef}
+\stoptyping
+
+This check is true. But that doesn't work well with a comma separated list, but
+there is a way out:
+
+\starttyping[option=TEX]
+\ifhasxtoks {,cd,} {,ab,cd,ef,}
+\stoptyping
+
+However, when I applied that a user reported that it didn't handle optional
+spaces before commas. So how do we deal with such optional characters tokens?
+
+\startbuffer
+\def\setcontains#1#2{\ifhasxtoks{,#1,}{,#2,}}
+
+\ifcondition\setcontains{cd}{ab,cd,ef}YES \else NO \fi
+\ifcondition\setcontains{cd}{ab, cd, ef}YES \else NO \fi
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+We get:
+
+\getbuffer
+
+The \type {\ifcondition} is an old one. When nested in a condition it will be
+seen as an \type {\if...} by the fast skipping scanner, but when expanded it will
+go on and a following macro has to expand to a proper condition. That said, we
+can take care of the optional space by entering some new territory. Look at this:
+
+\startbuffer
+\def\setcontains#1#2{\ifhasxtoks{,\expandtoken 9 "20 #1,}{,#2,}}
+
+\ifcondition\setcontains{cd}{ab,cd,ef}YES \else NO \fi
+\ifcondition\setcontains{cd}{ab, cd, ef}YES \else NO \fi
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+We get:
+
+\getbuffer
+
+So how does that work? The \type {\expandtoken} injects a space token with
+catcode~9 which means that it is in the to be ignored category. When a to be
+ignored token is seen, and the to be checked token is a character (letter, other,
+space or ignored) then the character code will be compared. When they match, we
+move on, otherwise we just skip over the ignored token (here the space).
+
+In the \CONTEXT\ code base there are already files that are specific for \MKIV\
+and \LMTX. The most visible difference is that we use the \type {\orelse}
+primitive to construct nicer test trees, and we also use some of the additional
+\type {\future...} and \type {\expandafter...} features. The extensions discussed
+here make for the most recent differences (we're talking end May 2020).
+
+After implementing this trick I decided to look at the macro definition mechanism
+one more time and see if I could also use this there. Before I demonstrate
+another next feature, I will again show the argument extensions, this time with
+a fourth variant:
+
+\startbuffer[definitions]
+\def\TestA#1#2#3{{(#1)(#2)(#3)}}
+\def\TestB#1#0#3{(#1)(#2)(#3)}
+\def\TestC#1#+#3{(#1)(#2)(#3)}
+\def\TestD#1#-#2{(#1)(#2)}
+\stopbuffer
+
+\typebuffer[definitions][option=TEX] \getbuffer[definitions]
+
+The last one specifies a to be thrashed argument: \type {#-}. It goes further
+than the second one (\type {#0}) which still keeps a reference. This is why in
+this last case the third argument gets number \type {2}. The meanings of these
+four are:
+
+\startlines \tttf
+\meaning\TestA
+\meaning\TestB
+\meaning\TestC
+\meaning\TestD
+\stoplines
+
+There are some subtle differences between these variants, as you can see from
+the following examples:
+
+\startbuffer[usage]
+\TestA1{\red 2}3
+\TestB1{\red 2}3
+\TestC1{\red 2}3
+\TestD1{\red 2}3
+\stopbuffer
+
+\typebuffer[usage][option=TEX]
+
+Here you also see the side effect of keeping the braces. The zero argument (\type
+{#0}) is ignored, and the thrashed argument (\type {#-}) can't even be accessed.
+
+\startlines \tttf \getbuffer[usage] \stoplines
+
+In the next example we see two delimiters being used, a comma and a space, but
+they have catcode~9 which flags them as ignored. This is a signal for the parser
+that both the comma and the space can be skipped. The zero arguments are still on
+the parameter stack, but the thrashed ones result in a smaller stack, not that
+the later matters much on today's machines.
+
+\startbuffer
+\normalexpanded {
+    \def\noexpand\foo
+    \expandtoken 9 "2C % comma
+    \expandtoken 9 "20 % space
+    #1=#2]%
+}{(#1)(#2)}
+\stopbuffer
+
+\typebuffer[option=TEX] \getbuffer
+
+This means that the next tree expansions won't bark:
+
+\startbuffer
+\foo,key=value]
+\foo, key=value]
+\foo  key=value]
+\stopbuffer
+
+\typebuffer[option=TEX]
+
+or expanded:
+
+\startlines \tttf \getbuffer \stoplines
+
+Now, why didn't I add these primitives long ago already? After all, I already
+added dozens of new primitives over the years. To quote Andrew Cuomo, what
+follows now are opinions, not facts.
+
+Decades ago, when \TEX\ showed up, there was no Internet. I remember that I got
+my first copy on floppy disks. Computers were slow and memory was limited. The
+\TEX book was the main resource and writing macros was a kind of art. One could
+not look up solutions, so trial and error was a valid way to go. Figuring out
+what was efficient in terms of memory consumption and runtime was often needed
+too. I remember meetings where one was not taken serious when not talking in the
+right \quote {token}, \quote {node}, \quote {stomach} and \quote {mouth} speak.
+Suggesting extensions could end up in being told that there was no need because
+all could be done in macros or even arguments of the \quotation {who needs that}.
+I must admit that nowadays I wonder to what extend that was related to extensions
+taking away some of the craftmanship and showing off. In a way it is no surprise
+that (even trivial to implement) extensions never surfaced. Of course then the
+question is: will extensions that once were considered not of importance be used
+today? We'll see.
+
+Let's end by saying that, as with other experiments, I might port some of the new
+features in \LUAMETATEX\ to \LUATEX, but only after they have become stable and
+have been tested in \LMTX\ for quite a while.
+
+\stopchapter
+
+\stopcomponent
diff --git a/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex b/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex
new file mode 100644
index 000000000..d653703a9
--- /dev/null
+++ b/doc/context/sources/general/manuals/evenmore/evenmore-tokens.tex
@@ -0,0 +1,460 @@
+% language=us
+
+% TODO: copy_node_list : return tail
+% TODO: grabnested
+
+\environment evenmore-style
+
+\startcomponent evenmore-tokens
+
+\startchapter[title=Tokens]
+
+\usemodule[article-basic,abbreviations-logos]
+
+\starttext
+
+{\em This is mostly a wrapup of some developments, and definitely not a tutorial.}
+
+Talking deep down \TEX\ is talking about tokens and nodes. Roughly spoken, from
+the perspective of the user, tokens are what goes in and stays in (as macro,
+token list of whatever) and nodes is what get produced and eventually results in
+output. A character in the input becomes one token (before expansion) and a
+control sequence like \type {\foo} also is turned into a token. Tokens can be
+linked into lists. This actually means that in the engine we can talk of tokens
+in two ways: the single item with properties that trigger actions, or as compound
+item with that item and a pointer to the next token (called link). In \LUA\ speak
+token memory can be seen as:
+
+\starttyping
+fixmem = {
+    { info, link },
+    { info, link },
+    { info, link },
+    { info, link },
+    ....
+}
+\stoptyping
+
+Both are 32 bit integers. The \type {info} is a combination of a command code (an
+operator) and a so called chr code (operand) and these determine its behaviour.
+For instance the command code can indicate an integer register and the chr code
+then indicates the number of that register. So, like:
+
+\starttyping
+fixmem = {
+    { { cmd, chr}, index_into_fixmem },
+    { { cmd, chr}, index_into_fixmem },
+    { { cmd, chr}, index_into_fixmem },
+    { { cmd, chr}, index_into_fixmem },
+    ....
+}
+\stoptyping
+
+
+In the following line the characters that make three words are tokens (letters),
+so are the space (spacer), the curly braces (begin- and endgroup token) and the
+bold face switch (which becomes one token which resolves to a token list of
+tokens that trigger actions (in this case switching to a bolder font).
+
+\starttyping
+foo {\bf bar} foo
+\stoptyping
+
+When \TEX\ reads a line of input tokens are expanded immediately but a sequence
+can also become part fo a macro body or token list. Here we have $3_{\type{foo}}
++ 1 + 1_{\type+{+} + 1_{\type{\bf}} + 3_{\type{bar}} + 1_{\type+}+} + 1 +
+3_{\type{foo}} = 14$ tokens.
+
+A control sequence normally starts with a backslash. Some are built in, these are
+called primitives, and others are defined by the macro package or the user. There
+is a lookup table that relates the tokenized control sequence to some action. For
+instance:
+
+\starttyping
+\def\foo{foo}
+\stoptyping
+
+creates an entry that leads (directly or following a hash chain) to the three
+letter token list. Every time the input sees \type {\foo} it gets resolved to
+that list via a hash lookup. However, once internalized and part of a token list,
+it is a direct reference. On the other hand,
+
+\starttyping
+\the\count0
+\stoptyping
+
+triggers the \type {\the} action that relates to this control sequence, which
+then reads a next token and operates on that. That next token itself expects a
+number as follow up. In the end the value of \type {\count0} is found and that
+one is also in the so called equivalent lookup table, in what \TEX\ calls
+specific regions.
+
+\starttyping
+equivalents = {
+    { level, type, value },
+    { level, type, value },
+    { level, type, value },
+    ...
+}
+\stoptyping
+
+The value is in most cases similar to the info (cmd & chr) field in fixmem, but
+one difference is that counters, dimensions etc directly store their value, which
+is why we sometimes need the type separately, for instance in order to reclaim
+memory for glue or node specifications. It sound complicated and it is, but as
+long as you get a rough idea we can continue. Just keep in mind that tokens
+sometimes get expanded on the fly, and sometimes just get stored.
+
+There are a lot of primitives and each has a unique info. The same is true for
+characters (each category has its own command code, so regular letters can be
+distinguished from other tokens, comment signs, math triggers etc). All important
+basic bits are in table of equivalents: macros as well as registers although the
+meaning of a macro and content of token lists lives in the fixmem table and
+the content of boxes in so called node lists (nodes have their own memory).
+
+In traditional \TEX\ the lookup table for primitives, registers and macros is as
+compact as can be: it is an array of so called 32 bit memory words. These can be
+divided into halfs and quarters, so in the source you find terms like \type
+{halfword} and \type {quarterword}. The lookup table is a hybrid:
+
+\starttyping
+[level 8] [type 8] [value 16] | [equivalent 32]
+[level 8] [type 8] [value 16] | [equivalent 32]
+[level 8] [type 8] [value 16] | [equivalent 32]
+...
+\stoptyping
+
+The mentioned counters and such are directly encoded in an equivalent and the
+rest is a combination of level, type and value. The level is used for the
+grouping, and in for instance \PDFTEX\ there can therefore be at most 255 levels.
+In \LUATEX\ we use a wider model. There we have 64 bit memory words which means
+that we have way more levels and don't need to have this dual nature:
+
+\starttyping
+[level 16] [type 16] [value 32]
+[level 16] [type 16] [value 32]
+[level 16] [type 16] [value 32]
+...
+\stoptyping
+
+We already showed a \LUA\ representation. The type in this table is what a
+command code is in an \quote {info} field. In such a token the integer encodes
+the command as well as a value (called chr). In the lookup table the type is the
+command code. When \TEX\ is dealing with a control sequences it looks at the
+type, otherwise it filters the command from the token integer. This means that a
+token cannot store an integer (or dimension), but the lookup table actually can
+do that. However, commands can limit the range, for instance characters are bound
+by what \UNICODE\ permits.
+
+Internally, \LUATEX\ still uses these ranges of fast accessible registers, like
+counters, dimensions and attributes. However, we saw that in \LUATEX\ they don't
+overlap with the level and type. In \LUATEX, at least till version 1.13 we still
+have the shadow array for levels but in \LUAMETATEX\ we just use those in the
+equivalents lookup table. If you look in the \PASCAL\ source you will notice that
+arrays run from \type {[somemin ... somemax]} which in the \CCODE\ source would
+mean using offsets. Actually, the shadow array starts at zero so we waste the
+part that doesn't need shadowing. It is good to remind ourselves that traditional
+\TEX\ is 8 bit character based.
+
+The equivalents lookup table has all kind of special ranges (combined into
+regions of similar nature, in \TEX\ speak), like those for lowercase mapping,
+specific catcode mappings, etc.\ but we're still talking of $n \times 256$
+entries. In \LUATEX\ all these mappings are in dedicated sparse hash tables
+because we need to support the full \UNICODE\ repertoire. This means that, while
+on the one hand \LUATEX\ uses more memory for the lookup table the number of
+slots can be less. But still there was the waste of the shadow level table: I
+didn't calculate the exact saving of ditching that one, but I bet it came close
+to what was available as total memory for programs and data on the first machines
+that I used for running \TEX. But \unknown\ after more than a decade of \LUATEX\
+we now reclaimed that space in \LUAMETATEX. \footnote {Don't expect a gain in
+performance, although using less memory might pay back on a virtual machine or
+when \TEX\ has to share the \CPU\ cache.}
+
+Now, in case you're interested (and actually I just write it down because I don't
+want to forget it myself) the lookup table in \LUAMETATEX\ is layout as follows
+
+\starttabulate
+\NC the hash table                    \NC \NC \NR
+\NC some frozen primitives            \NC \NC \NR
+\NC current and defined fonts         \NC one slot + many pointers \NC \NR
+\NC undefined control sequence        \NC one slot \NC \NR
+\NC internal and register glue        \NC pointer to node \NC \NR
+\NC internal and register muglue      \NC pointer to node \NC \NR
+\NC internal and register toks        \NC pointer to token list \NC \NR
+\NC internal and register boxes       \NC pointer to node list \NC \NR
+\NC internal and register counts      \NC value in token \NC \NR
+\NC internal and register attributes  \NC value in token \NC \NR
+\NC internal and register dimens      \NC value in token \NC \NR
+\NC some special data structures      \NC pointer to node list \NC  \NC \NR
+\NC the (runtime) extended hash table \NC  \NC \NR
+\stoptabulate
+
+Normally a user doesn't need to know anything about these specific properties of
+the engine and it might comfort you to know that for a long time I could stay
+away from these details. One difference with the other engines is that we have
+internal variables and registers split more explicitly. The special data
+structures have their own slots and are not just put somewhere (semi random). The
+initialization is bit more granular in that we properly set the types (cmd codes)
+for registers which in turn is possible because for instance we're able to
+distinguish glue types. This is all part of coming up with a bit more consistent
+interface to tokens from the \LUA\ end. It also permits diagnostics.
+
+Anyway, we now are ready for some more details about tokens. You don't need to
+understand all of it in order to define decent macros. But when you are using
+\LUATEX\ and do want to mess around here is some insight. Assume we have defined
+these macros:
+
+\startluacode
+    local alsoraw = false
+    function documentdata.StartShowTokens(rawtoo)
+        context.starttabulate { "|T|rT|lT|rT|rT|rT|" .. (rawtoo and "rT|" or "") }
+        context.BC()
+        context.BC() context("cmd")
+        context.BC() context("name")
+        context.BC() context("chr")
+        context.BC() context("cs")
+        if rawtoo then
+            context.BC() context("rawchr")
+        end
+        context.BC() context.NR()
+        context.SL()
+        alsoraw = rawtoo
+    end
+    function documentdata.StopShowTokens()
+        context.stoptabulate()
+    end
+    function documentdata.ShowToken(name)
+        local cmd, chr, cs = token.get_cmdchrcs(name)
+        local _,   raw, _  = token.get_cmdchrcs(name,true)
+        context.NC() context("\\string\\"..name)
+        context.NC() context(cmd)
+        context.NC() context(tokens.commands[cmd])
+        context.NC() context(chr)
+        context.NC() context(cs)
+        if alsoraw and chr ~= raw then
+            context.NC() context(raw)
+        end
+        context.NC() context.NR()
+    end
+\stopluacode
+
+\startbuffer
+\def\MacroA{a} \def\MacroB{b}
+\def\macroa{a} \def\macrob{b}
+\def\MACROa{a} \def\MACROb{b}
+\stopbuffer
+
+\typebuffer \getbuffer
+
+How does that end up internally?
+
+\startluacode
+    documentdata.StartShowTokens(true)
+    documentdata.ShowToken("scratchcounterone")
+    documentdata.ShowToken("scratchcountertwo")
+    documentdata.ShowToken("scratchdimen")
+    documentdata.ShowToken("scratchtoks")
+    documentdata.ShowToken("scratchcounter")
+    documentdata.ShowToken("letterpercent")
+    documentdata.ShowToken("everypar")
+    documentdata.ShowToken("%")
+    documentdata.ShowToken("pagegoal")
+    documentdata.ShowToken("pagetotal")
+    documentdata.ShowToken("hangindent")
+    documentdata.ShowToken("hangafter")
+    documentdata.ShowToken("dimdim")
+    documentdata.ShowToken("relax")
+    documentdata.ShowToken("dimen")
+    documentdata.ShowToken("stoptext")
+    documentdata.ShowToken("MacroA")
+    documentdata.ShowToken("MacroB")
+    documentdata.ShowToken("MacroC")
+    documentdata.ShowToken("macroa")
+    documentdata.ShowToken("macrob")
+    documentdata.ShowToken("macroc")
+    documentdata.ShowToken("MACROa")
+    documentdata.ShowToken("MACROb")
+    documentdata.ShowToken("MACROc")
+    documentdata.StopShowTokens()
+\stopluacode
+
+We show the raw chr value but in the \LUA\ interface these are normalized to for
+instance proper register indices. This is because the raw numbers can for
+instance be indices into memory or some \UNICODE\ reference with catcode specific
+bits set. But, while these indices are real and stable, these offsets can
+actually change when the implementation changes. For that reason, in \LUAMETATEX\
+we can better talk of command codes as main indicator and:
+
+\starttabulate
+\NC subcommand       \NC for tokens that have variants, like \type {\ifnum} \NC \NR
+\NC register indices \NC for the 64K register banks, like \type {\count0} \NC \NR
+\NC internal indices \NC for internal variables like \type {\parindent} \NC \NR
+\NC characters       \NC specific \UNICODE\ slots combined with catcode \NC \NR
+\NC pointers         \NC to token lists, macros, \LUA\ functions, nodes \NC \NR
+\stoptabulate
+
+This so called \type {cs} number is a pointer into the table of equivalents. That
+number results comes from the hash table. A macro name, when scanned the first
+time, is still a sequence of bytes. This sequence is used to compute a hash
+number, which is a pointer to a slot in the lower part of the hash (lookup)
+table. That slot points to a string and a next hash entry in the higher end. A
+lookup goes as follows:
+
+\startitemize[n,packed]
+    \startitem
+        compute the index into the hash table from the string
+    \stopitem
+    \startitem
+        goto the slot with that index and compare the \type {string} field
+    \stopitem
+    \startitem
+        when there is no match goto the slot indicated by the \type {next} field
+    \stopitem
+    \startitem
+        compare again and keep following \type {next} fields till there is no
+        follow up
+    \stopitem
+    \startitem
+        optionally create a new entry
+    \stopitem
+    \startitem
+        use the index of that entry as index in the table of equivalents
+    \stopitem
+\stopitemize
+
+So, in \LUA\ speak, we have:
+
+\starttyping
+hashtable = {
+    -- lower part, accessed via the calculated hash number
+    { stringpointer, nextindex },
+    { stringpointer, nextindex },
+    ...
+    -- higher part, accessed by following nextindex
+    { stringpointer, nextindex },
+    { stringpointer, nextindex },
+    ...
+}
+\stoptyping
+
+Eventually, after following a lookup chain in the hash tabl;e, we end up at
+pointer to the equivalents lookup table that we already discussed. From then on
+we're talking tokens. When you're lucky, the list is small and you have a quick
+match. The maximum initial hash index is not that large, around 64K (double that
+in \LUAMETATEX), so in practice there will often be some indirect
+(multi|-|compare) match but increasing the lower end of the hash table might
+result in less string comparisons later on, but also increases the time to
+calculate the initial hash needed for accessing the lower part. Here you can sort
+of see that:
+
+\startbuffer
+\dostepwiserecurse{`a}{`z}{1}{
+    \expandafter\def\csname whatever\Uchar#1\endcsname
+      {}
+}
+\dostepwiserecurse{`a}{`z}{1}{
+    \expandafter\let\csname somemore\Uchar#1\expandafter\endcsname
+        \csname whatever\Uchar#1\endcsname
+}
+\stopbuffer
+
+\typebuffer \getbuffer
+
+\startluacode
+    documentdata.StartShowTokens(true)
+    for i=utf.byte("a"),utf.byte("z") do
+        documentdata.ShowToken("whatever"..utf.char(i))
+        documentdata.ShowToken("somemore"..utf.char(i))
+    end
+    documentdata.StopShowTokens()
+\stopluacode
+
+The command code indicates a macro and the action related to it is an expandable
+call. We have no sub command \footnote {We cheat a little here because chr
+actually is an index into token memory but we don't show them as such.} so that
+column shows zeros. The fifth column is the hash entry which can bring us back to
+the verbose name as needed in reporting while the last column is the index to
+into token memory (watch the duplicates for \type {\let} macros: a ref count is
+kept in order to be able to manage such shared references). When you look a the
+cs column you will notice that some numbers are close which (I think) in this
+case indicates some closeness in the calculated hash name and followed chain.
+
+It will be clear that it is best to not make any assumptions with respect to the
+numbers which is why, in \LUAMETATEX\ we sort of normalize them when accessing
+properties.
+
+\starttabulate
+\NC field      \NC meaning \NC \NR
+\FL
+\NC command    \NC operator \NC \NR
+\NC cmdname    \NC internal name of operator \NC \NR
+\NC index      \NC sanitized operand \NC \NR
+\NC mode       \NC original operand  \NC \NR
+\NC csname     \NC associated name   \NC \NR
+\NC id         \NC the index in token memory (a virtual address) \NC \NR
+\NC tok        \NC the integer representation \NC \NR
+\ML
+\NC active     \NC true when an active character \NC \NR
+\NC expandable \NC true when expandable command \NC \NR
+\NC protected  \NC true when a protected command \NC \NR
+\NC frozen     \NC true when a frozen command \NC \NR
+\NC user       \NC true when a user defined command \NC \NR
+\LL
+\stoptabulate
+
+When a control sequence is an alias to an existing primitive, for instance
+made by \type {\let}, the operand (chr) picked up from its meaning. Take this:
+
+\startbuffer
+\newif\ifmyconditionone
+\newif\ifmyconditiontwo
+
+                    \meaning\ifmyconditionone    \crlf
+                    \meaning\ifmyconditiontwo    \crlf
+                    \meaning\myconditiononetrue  \crlf
+                    \meaning\myconditiontwofalse \crlf
+\myconditiononetrue \meaning\ifmyconditionone    \crlf
+\myconditiontwofalse\meaning\ifmyconditiontwo    \crlf
+\stopbuffer
+
+\typebuffer \getbuffer
+
+Internally this is:
+
+\startluacode
+    documentdata.StartShowTokens(false)
+    documentdata.ShowToken("ifmyconditionone")
+    documentdata.ShowToken("ifmyconditiontwo")
+    documentdata.ShowToken("iftrue")
+    documentdata.ShowToken("iffalse")
+    documentdata.StopShowTokens()
+\stopluacode
+
+The whole list of available commands is given below. Once they are stable the \LUAMETATEX\ manual
+will document the accessors. In this chapter we use:
+
+\starttyping
+kind, min, max, fixedvalue token.get_range("primitive")
+cmd, chr, cs  = token.get_cmdchrcs("primitive")
+\stoptyping
+
+The kind of command is given in the first column, which can have the following values:
+
+\starttabulate[|l|l|p|]
+\NC 0 \NC no        \NC not accessible \NC \NR
+\NC 1 \NC regular   \NC possibly with subcommand \NC \NR
+\NC 2 \NC character \NC the \UNICODE\ slot is encodes in the the token \NC \NR
+\NC 3 \NC register  \NC this is an indexed register (zero upto 64K) \NC \NR
+\NC 4 \NC internal  \NC this is an internal register (range given) \NC \NR
+\NC 5 \NC reference \NC this is a reference to a node, \LUA\ function, etc. \NC \NR
+\NC 6 \NC data      \NC a general data entry (kind of private) \NC \NR
+\NC 7 \NC token     \NC a token reference (that can have a followup) \NC \NR
+\stoptabulate
+
+\usemodule[system-tokens]
+
+\start \switchtobodyfont[7pt] \showsystemtokens \stop
+
+\stopchapter
+
+\stopcomponent
diff --git a/doc/context/sources/general/manuals/evenmore/evenmore.tex b/doc/context/sources/general/manuals/evenmore/evenmore.tex
index b662e5108..c2e4e232b 100644
--- a/doc/context/sources/general/manuals/evenmore/evenmore.tex
+++ b/doc/context/sources/general/manuals/evenmore/evenmore.tex
@@ -22,8 +22,9 @@
         \component evenmore-whattex
         \component evenmore-numbers
       % \component evenmore-parameters
-      % \component evenmore-parsing
-      % \component evenmore-tokens
+        \startchapter[title=Parameters] {\em This will appear first in \TUGBOAT.} \stopchapter
+        \component evenmore-parsing
+        \component evenmore-tokens
     \stopbodymatter
 
 \stopdocument
diff --git a/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex b/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex
index 8aa7408d6..7dfc00313 100644
--- a/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex
+++ b/doc/context/sources/general/manuals/luametatex/luametatex-tex.tex
@@ -653,6 +653,8 @@ tex.currentifbranch
 
 \libindex{scantoks}
 
+\libindex{getmark}
+
 \TEX's attributes (\lpr {attribute}), counters (\prm {count}), dimensions (\prm
 {dimen}), skips (\prm {skip}, \prm {muskip}) and token (\prm {toks}) registers
 can be accessed and written to using two times five virtual sub|-|tables of the
@@ -788,6 +790,12 @@ tex.scantoks("global",0,3,"$\int\limits^1_2$")
 In the function-based interface, it is possible to define values globally by
 using the string \type {global} as the first function argument.
 
+There is a dedicated getter for marks: \type {getmark} that takes two arguments.
+The first argument is one of \type {top}, \type {bottom}, \type {first}, \type
+{splitbottom} or \type {splitfirst}, and the second argument is a marks class
+number. When no arguments are given the current maximum number of classes is
+returned.
+
 \stopsubsection
 
 \startsubsection[title={Character code registers: \type {[get|set]*code[s]}}]
@@ -2087,6 +2095,11 @@ macro, in which case the result will also provide information about what
 arguments are expected and in the result this is separated from the meaning by a
 separator token. The \type {expand} flag determines if the list will be expanded.
 
+The \type {scan_argument} function expands the given argument. When a braced
+argument is scanned, expansion can be prohibited by passing \type {false}
+(default is \type {true}). In case of a control sequence passing \type {false}
+will result in a one|-|level expansion (the meaning of the macro).
+
 The string scanner scans for something between curly braces and expands on the
 way, or when it sees a control sequence it will return its meaning. Otherwise it
 will scan characters with catcode \type {letter} or \type {other}. So, given the
diff --git a/doc/context/sources/general/manuals/luametatex/luametatex.tex b/doc/context/sources/general/manuals/luametatex/luametatex.tex
index 0fd7a31b3..acdffcde3 100644
--- a/doc/context/sources/general/manuals/luametatex/luametatex.tex
+++ b/doc/context/sources/general/manuals/luametatex/luametatex.tex
@@ -9,13 +9,6 @@
 % mswin       2562k  2555k   mswin       2481k  2471k
 % ------------------------   ------------------------
 
-% experiment (if this becomes default we need to check visualizers and disable it when needed):
-
-\startluacode
-nodes.handlers.cleanuppage = nodes.nuts.flatten_discretionaries
-nodes.tasks.prependaction("shipouts", "normalizers", "nodes.handlers.cleanuppage", nil, "nut", "enabled")
-\stopluacode
-
 % 20200509 : 258 pages
 %
 % my 2013 i7 laptop with windows : 11.8 sec mingw64
diff --git a/tex/context/base/mkii/cont-new.mkii b/tex/context/base/mkii/cont-new.mkii
index 7a8184ee4..3f7db0e5d 100644
--- a/tex/context/base/mkii/cont-new.mkii
+++ b/tex/context/base/mkii/cont-new.mkii
@@ -11,7 +11,7 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
-\newcontextversion{2020.06.14 22:04}
+\newcontextversion{2020.06.17 18:56}
 
 %D This file is loaded at runtime, thereby providing an
 %D excellent place for hacks, patches, extensions and new
diff --git a/tex/context/base/mkii/context.mkii b/tex/context/base/mkii/context.mkii
index 8fcff83d3..595650caf 100644
--- a/tex/context/base/mkii/context.mkii
+++ b/tex/context/base/mkii/context.mkii
@@ -20,7 +20,7 @@
 %D your styles an modules.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2020.06.14 22:04}
+\edef\contextversion{2020.06.17 18:56}
 
 %D For those who want to use this:
 
diff --git a/tex/context/base/mkiv/cont-new.mkiv b/tex/context/base/mkiv/cont-new.mkiv
index 58a3ef3e4..397aed038 100644
--- a/tex/context/base/mkiv/cont-new.mkiv
+++ b/tex/context/base/mkiv/cont-new.mkiv
@@ -13,7 +13,7 @@
 
 % \normalend % uncomment this to get the real base runtime
 
-\newcontextversion{2020.06.14 22:04}
+\newcontextversion{2020.06.17 18:56}
 
 %D This file is loaded at runtime, thereby providing an excellent place for hacks,
 %D patches, extensions and new features. There can be local overloads in cont-loc
diff --git a/tex/context/base/mkiv/context.mkiv b/tex/context/base/mkiv/context.mkiv
index fc883aa5e..dec0327ff 100644
--- a/tex/context/base/mkiv/context.mkiv
+++ b/tex/context/base/mkiv/context.mkiv
@@ -45,7 +45,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2020.06.14 22:04}
+\edef\contextversion{2020.06.17 18:56}
 \edef\contextkind   {beta}
 
 %D Kind of special:
diff --git a/tex/context/base/mkiv/context.mkxl b/tex/context/base/mkiv/context.mkxl
index fa498190b..0ca2406ea 100644
--- a/tex/context/base/mkiv/context.mkxl
+++ b/tex/context/base/mkiv/context.mkxl
@@ -29,7 +29,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2020.06.14 22:04}
+\edef\contextversion{2020.06.17 18:56}
 \edef\contextkind   {beta}
 
 %D Kind of special:
diff --git a/tex/context/base/mkiv/driv-shp.lua b/tex/context/base/mkiv/driv-shp.lua
index e7f19aea0..569a1f8dc 100644
--- a/tex/context/base/mkiv/driv-shp.lua
+++ b/tex/context/base/mkiv/driv-shp.lua
@@ -547,7 +547,7 @@ local hlist_out, vlist_out  do
               pos_r = getdirection(this_box)
         local boxwidth,
               boxheight,
-              boxdepth   = getwhd(this_box)
+              boxdepth = getwhd(this_box)
 
         local cur_h = 0
         local cur_v = 0
@@ -675,10 +675,10 @@ local hlist_out, vlist_out  do
                     end
                 end
             elseif id == hlist_code or id == vlist_code then
-                local boxdir = getdirection(current) or lefttoright_code
                 local width, height, depth = getwhd(current)
                 local list = getlist(current)
                 if list then
+                    local boxdir = getdirection(current) or lefttoright_code
                     local shift, orientation = getshift(current)
                     if not orientation then
                         local basepoint_h = boxdir ~= pos_r and width or 0
@@ -896,7 +896,7 @@ local hlist_out, vlist_out  do
 
         local boxwidth,
               boxheight,
-              boxdepth   = getwhd(this_box)
+              boxdepth = getwhd(this_box)
 
         local cur_h    = 0
         local cur_v    = - boxheight
@@ -997,10 +997,10 @@ local hlist_out, vlist_out  do
                     end
                 end
             elseif id == hlist_code or id == vlist_code then
-                local boxdir = getdirection(current) or lefttoright_code
                 local width, height, depth = getwhd(current)
                 local list = getlist(current)
                 if list then
+                    local boxdir = getdirection(current) or lefttoright_code
                     local shift, orientation = getshift(current)
                     if not orientation then
                      -- local basepoint_h = shift
diff --git a/tex/context/base/mkiv/file-ini.mkvi b/tex/context/base/mkiv/file-ini.mkvi
index 225b6b40d..5341cc07b 100644
--- a/tex/context/base/mkiv/file-ini.mkvi
+++ b/tex/context/base/mkiv/file-ini.mkvi
@@ -10,9 +10,8 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
-%D \TEX\ operates on files, so one wouldn't wonder that there
-%D is a separate module for file commands. In \CONTEXT\ files
-%D are used for several purposes:
+%D \TEX\ operates on files, so one wouldn't wonder that there is a separate module
+%D for file commands. In \CONTEXT\ files are used for several purposes:
 %D
 %D \startitemize[packed]
 %D \item  general textual input
@@ -21,10 +20,9 @@
 %D \item  buffering defered textual input
 %D \stopitemize
 %D
-%D When dealing with files we can load them as a whole, using
-%D the \type{\input} primitive or load them on a line||by||line
-%D basis, using \type{\read}. Writing is always done line by
-%D line, using \type{\write}.
+%D When dealing with files we can load them as a whole, using the \type {\input}
+%D primitive or load them on a line||by||line basis, using \type {\read}. Writing is
+%D always done line by line, using \type {\write}.
 
 \writestatus{loading}{ConTeXt File Macros / Helpers}
 
@@ -35,9 +33,9 @@
 %D \macros
 %D   {scratchread, scratchwrite}
 %D
-%D We define a scratch file for reading. Keep in mind that
-%D the number of files is limited to~16, so use this one when
-%D possible. We also define a scratch output file.
+%D We define a scratch file for reading. Keep in mind that the number of files is
+%D limited to~16, so use this one when possible. We also define a scratch output
+%D file. In \MKIV\ and \LMTX\ we never use these file handles.
 
 \ifdefined\scratchread  \else \newread \scratchread  \fi
 \ifdefined\scratchwrite \else \newwrite\scratchwrite \fi
@@ -60,12 +58,10 @@
 %D \macros
 %D   {pushendofline,popendofline}
 %D
-%D When we are loading files in the middle of the typesetting
-%D process, for instance when we load references, we have to be
-%D sure that the reading process does not generate so called
-%D 'spurious spaces'. This can be prevented by assigning the
-%D line ending character the \CATCODE\ comment. This is
-%D accomplished by
+%D When we are loading files in the middle of the typesetting process, for instance
+%D when we load references, we have to be sure that the reading process does not
+%D generate so called 'spurious spaces'. This can be prevented by assigning the line
+%D ending character the \CATCODE\ comment. This is accomplished by
 %D
 %D \starttyping
 %D \pushendofline
@@ -114,11 +110,10 @@
 %D \macros
 %D   {input, normalinput}
 %D
-%D Sometimes we run into troubles when \type {\input} wants to get
-%D expanded, e.g. in a \type {\write} (which happens in the metafun
-%D manual when we permit long MP lines). So, instead of fixing that,
-%D we go for a redefinition of \type {\input}. Of course it's better
-%D to use \type {\readfile} or \type {\processfile}.
+%D Sometimes we run into troubles when \type {\input} wants to get expanded, e.g. in
+%D a \type {\write} (which happens in the metafun manual when we permit long MP
+%D lines). So, instead of fixing that, we go for a redefinition of \type {\input}.
+%D Of course it's better to use \type {\readfile} or \type {\processfile}.
 
 \unexpanded\def\input{\normalinput}
 
@@ -127,8 +122,8 @@
 %D \macros
 %D   {doifelsefile}
 %D
-%D The next alternative only looks if a file is present. No
-%D loading is done. This one obeys the standard \TEX\ lookup.
+%D The next alternative only looks if a file is present. No loading is done. This
+%D one obeys the standard \TEX\ lookup.
 %D
 %D \starttyping
 %D \doiffileelse {filename} {found} {not found}
@@ -155,7 +150,7 @@
 %D \doifparentfileelse{filename}{yes}{no}
 %D \stoptyping
 
-\ifx\outputfilename\undefined \def\outputfilename{\jobname} \fi
+\ifdefined\outputfilename \else \def\outputfilename{\jobname} \fi
 
 \unexpanded\def\doifelseparentfile{\clf_doifelseparentfile}
 
@@ -200,10 +195,9 @@
 %D \macros
 %D   {doonlyonce, doinputonce, doendinputonce}
 %D
-%D Especially macropackages need only be loaded once.
-%D Repetitive loading not only costs time, relocating registers
-%D often leads to abortion of the processing because \TEX's
-%D capacity is limited. One can prevent multiple execution and
+%D Especially macropackages need only be loaded once. Repetitive loading not only
+%D costs time, relocating registers often leads to abortion of the processing
+%D because \TEX's capacity is limited. One can prevent multiple execution and
 %D loading by using one of both:
 %D
 %D \starttyping
@@ -212,8 +206,8 @@
 %D \doendinputonce{filename}
 %D \stoptyping
 %D
-%D This command obeys the standard method for locating files. We could
-%D move this function to the \LUA\ end.
+%D This command obeys the standard method for locating files. We could move this
+%D function to the \LUA\ end.
 
 \installsystemnamespace {fileonce}
 
diff --git a/tex/context/base/mkiv/lxml-ini.lua b/tex/context/base/mkiv/lxml-ini.lua
index 348ecbbe4..f9ba96ece 100644
--- a/tex/context/base/mkiv/lxml-ini.lua
+++ b/tex/context/base/mkiv/lxml-ini.lua
@@ -21,120 +21,122 @@ local implement  = interfaces.implement
 
 -- lxml.id
 
-implement { name = "lxmlid",               actions = lxml.getid,             arguments = "string" }
-
-implement { name = "xmldoif",              actions = lxml.doif,              arguments = "2 strings" }
-implement { name = "xmldoifnot",           actions = lxml.doifnot,           arguments = "2 strings" }
-implement { name = "xmldoifelse",          actions = lxml.doifelse,          arguments = "2 strings" }
-implement { name = "xmldoiftext",          actions = lxml.doiftext,          arguments = "2 strings" }
-implement { name = "xmldoifnottext",       actions = lxml.doifnottext,       arguments = "2 strings" }
-implement { name = "xmldoifelsetext",      actions = lxml.doifelsetext,      arguments = "2 strings" }
-
-implement { name = "xmldoifempty",         actions = lxml.doifempty,         arguments = "2 strings" }
-implement { name = "xmldoifnotempty",      actions = lxml.doifnotempty,      arguments = "2 strings" }
-implement { name = "xmldoifelseempty",     actions = lxml.doifelseempty,     arguments = "2 strings" }
-implement { name = "xmldoifselfempty",     actions = lxml.doifempty,         arguments = "string" } -- second arg is not passed (used)
-implement { name = "xmldoifnotselfempty",  actions = lxml.doifnotempty,      arguments = "string" } -- second arg is not passed (used)
-implement { name = "xmldoifelseselfempty", actions = lxml.doifelseempty,     arguments = "string" } -- second arg is not passed (used)
-
---------- { name = "xmlcontent",           actions = lxml.content,           arguments = "string" }
---------- { name = "xmlflushstripped",     actions = lxml.strip,             arguments = { "string", true } }
-
-implement { name = "xmlall",               actions = lxml.all,               arguments = "2 strings" }
-implement { name = "xmlatt",               actions = lxml.att,               arguments = "2 strings" }
-implement { name = "xmlattdef",            actions = lxml.att,               arguments = "3 strings" }
-implement { name = "xmlattribute",         actions = lxml.attribute,         arguments = "3 strings" }
-implement { name = "xmlattributedef",      actions = lxml.attribute,         arguments = "4 strings" }
-implement { name = "xmlbadinclusions",     actions = lxml.badinclusions,     arguments = "string" }
-implement { name = "xmlchainatt",          actions = lxml.chainattribute,    arguments = { "string", "'/'", "string" } }
-implement { name = "xmlchainattdef",       actions = lxml.chainattribute,    arguments = { "string", "'/'", "string", "string"  } }
-implement { name = "xmlchecknamespace",    actions =  xml.checknamespace,    arguments = { "lxmlid", "string", "string" } }
-implement { name = "xmlcommand",           actions = lxml.command,           arguments = "3 strings" }
-implement { name = "xmlconcat",            actions = lxml.concat,            arguments = "3 strings" }                     --  \detokenize{#3}
-implement { name = "xmlconcatrange",       actions = lxml.concatrange,       arguments = { "string", "string", "string", "string", "string" } } --  \detokenize{#5}
-implement { name = "xmlcontext",           actions = lxml.context,           arguments = "2 strings" }
-implement { name = "xmlcount",             actions = lxml.count,             arguments = "2 strings" }
-implement { name = "xmldelete",            actions = lxml.delete,            arguments = "2 strings" }
-implement { name = "xmldirect",            actions = lxml.direct,            arguments = "string" }
-implement { name = "xmldirectives",        actions = lxml.directives.setup,  arguments = "string" }
-implement { name = "xmldirectivesafter",   actions = lxml.directives.after,  arguments = "string" }
-implement { name = "xmldirectivesbefore",  actions = lxml.directives.before, arguments = "string" }
-implement { name = "xmldisplayverbatim",   actions = lxml.displayverbatim,   arguments = "string" }
-implement { name = "xmlelement",           actions = lxml.element,           arguments = "2 strings" } -- could be integer but now we can alias
-implement { name = "xmlfilter",            actions = lxml.filter,            arguments = "2 strings" }
-implement { name = "xmlfilterlist",        actions = lxml.filterlist,        arguments = "2 strings" }
-implement { name = "xmlfirst",             actions = lxml.first,             arguments = "2 strings" }
-implement { name = "xmlflush",             actions = lxml.flush,             arguments = "string" }
-implement { name = "xmlflushcontext",      actions = lxml.context,           arguments = "string" }
-implement { name = "xmlflushlinewise",     actions = lxml.flushlinewise,     arguments = "string" }
-implement { name = "xmlflushpure",         actions = lxml.pure,              arguments = "string" }
-implement { name = "xmlflushspacewise",    actions = lxml.flushspacewise,    arguments = "string" }
-implement { name = "xmlflushtext",         actions = lxml.text,              arguments = "string" }
-implement { name = "xmlfunction",          actions = lxml.applyfunction,     arguments = "2 strings" }
-implement { name = "xmlinclude",           actions = lxml.include,           arguments = { "string", "string", "string", true } }
-implement { name = "xmlincludeoptions",    actions = lxml.include,           arguments = "4 strings" }
-implement { name = "xmlinclusion",         actions = lxml.inclusion,         arguments = "string" }
-implement { name = "xmlinclusionbase",     actions = lxml.inclusion,         arguments = { "string", false, true } }
-implement { name = "xmlinclusions",        actions = lxml.inclusions,        arguments = "string" }
-implement { name = "xmlindex",             actions = lxml.index,             arguments = "3 strings" } -- can be integer but now we can alias
-implement { name = "xmlinlineverbatim",    actions = lxml.inlineverbatim,    arguments = "string" }
-implement { name = "xmllast",              actions = lxml.last,              arguments = "2 strings" }
-implement { name = "xmllastatt",           actions = lxml.lastatt }
-implement { name = "xmllastmatch",         actions = lxml.lastmatch }
-implement { name = "xmllastpar",           actions = lxml.lastpar }
-implement { name = "xmlloadfile",          actions = lxml.load,              arguments = "3 strings" }
-implement { name = "xmlloadbuffer",        actions = lxml.loadbuffer,        arguments = "3 strings" }
-implement { name = "xmlloaddata",          actions = lxml.loaddata,          arguments = "3 strings" }
-implement { name = "xmlloaddirectives",    actions = lxml.directives.load,   arguments = "string" }
-implement { name = "xmlmain",              actions = lxml.main,              arguments = "string" }
-implement { name = "xmlmatch",             actions = lxml.match,             arguments = "string" }
-implement { name = "xmlname",              actions = lxml.name,              arguments = "string" }
-implement { name = "xmlnamespace",         actions = lxml.namespace,         arguments = "string" }
-implement { name = "xmlnonspace",          actions = lxml.nonspace,          arguments = "2 strings" }
-implement { name = "xmlpar",               actions = lxml.par,               arguments = "2 strings" }
-implement { name = "xmlparam",             actions = lxml.param,             arguments = "3 strings" }
-implement { name = "xmlpath",              actions = lxml.path,              arguments = { "string", "'/'" } }
-implement { name = "xmlpopmatch",          actions = lxml.popmatch }
-implement { name = "xmlpos",               actions = lxml.pos,               arguments = "string" }
-implement { name = "xmlpure",              actions = lxml.pure,              arguments = "2 strings" }
-implement { name = "xmlpushmatch",         actions = lxml.pushmatch }
-implement { name = "xmlraw",               actions = lxml.raw,               arguments = "2 strings" }
-implement { name = "xmlrawtex",            actions = lxml.rawtex,            arguments = "2 strings" }
-implement { name = "xmlrefatt",            actions = lxml.refatt,            arguments = "2 strings" }
-implement { name = "xmlregisterns",        actions =  xml.registerns,        arguments = "2 strings" }
-implement { name = "xmlremapname",         actions =  xml.remapname,         arguments = { "lxmlid", "string","string","string" } }
-implement { name = "xmlremapnamespace",    actions =  xml.renamespace,       arguments = { "lxmlid", "string", "string" } }
-implement { name = "xmlsave",              actions = lxml.save,              arguments = "2 strings" }
-implement { name = "xmlsetatt",            actions = lxml.setatt,            arguments = "3 strings" }
-implement { name = "xmlsetattribute",      actions = lxml.setattribute,      arguments = "4 strings" }
-implement { name = "xmlsetpar",            actions = lxml.setpar,            arguments = "3 strings" }
-implement { name = "xmlsetparam",          actions = lxml.setparam,          arguments = "4 strings" }
-implement { name = "xmlsetsetup",          actions = lxml.setsetup,          arguments = "3 strings" }
-implement { name = "xmlsnippet",           actions = lxml.snippet,           arguments = "2 strings" }
-implement { name = "xmlstrip",             actions = lxml.strip,             arguments = "2 strings" }
-implement { name = "xmlstripanywhere",     actions = lxml.strip,             arguments = { "string", "string", true, true } }
-implement { name = "xmlstripnolines",      actions = lxml.strip,             arguments = { "string", "string", true } }
-implement { name = "xmlstripped",          actions = lxml.stripped,          arguments = "2 strings" }
-implement { name = "xmlstrippednolines",   actions = lxml.stripped,          arguments = { "string", "string", true } }
-implement { name = "xmltag",               actions = lxml.tag,               arguments = "string" }
-implement { name = "xmltext",              actions = lxml.text,              arguments = "2 strings" }
-implement { name = "xmltobuffer",          actions = lxml.tobuffer,          arguments = "3 strings" }
-implement { name = "xmltobuffertextonly",  actions = lxml.tobuffer,          arguments = { "string", "string", "string", false } }
-implement { name = "xmltobufferverbose",   actions = lxml.tobuffer,          arguments = { "string", "string", "string", true, true } }
-implement { name = "xmltofile",            actions = lxml.tofile,            arguments = "3 strings" }
-implement { name = "xmltoparameters",      actions = lxml.toparameters,      arguments = "string" }
-implement { name = "xmlverbatim",          actions = lxml.verbatim,          arguments = "string" }
-
-implement { name = "xmlstartraw",          actions = lxml.startraw }
-implement { name = "xmlstopraw",           actions = lxml.stopraw  }
-
-implement { name = "xmlprependsetup",      actions = lxml.installsetup,      arguments = { 1, "string", "string" } }           -- 2:*
-implement { name = "xmlappendsetup",       actions = lxml.installsetup,      arguments = { 2, "string", "string" } }           -- 2:*
-implement { name = "xmlbeforesetup",       actions = lxml.installsetup,      arguments = { 3, "string", "string", "string" } } -- 2:*
-implement { name = "xmlaftersetup",        actions = lxml.installsetup,      arguments = { 4, "string", "string", "string" } } -- 2:*
-implement { name = "xmlremovesetup",       actions = lxml.removesetup,       arguments = "2 strings" }              -- 1:*
-implement { name = "xmlflushsetups",       actions = lxml.flushsetups,       arguments = "3 strings" }    -- 2:*
-implement { name = "xmlresetsetups",       actions = lxml.resetsetups,       arguments = "string" }
+implement { name = "lxmlid",               public = true, actions = lxml.getid,             arguments = "string" }
+
+implement { name = "xmldoif",              public = true, actions = lxml.doif,              arguments = "2 strings" }
+implement { name = "xmldoifnot",           public = true, actions = lxml.doifnot,           arguments = "2 strings" }
+implement { name = "xmldoifelse",          public = true, actions = lxml.doifelse,          arguments = "2 strings" }
+implement { name = "xmldoiftext",          public = true, actions = lxml.doiftext,          arguments = "2 strings" }
+implement { name = "xmldoifnottext",       public = true, actions = lxml.doifnottext,       arguments = "2 strings" }
+implement { name = "xmldoifelsetext",      public = true, actions = lxml.doifelsetext,      arguments = "2 strings" }
+
+implement { name = "xmldoifempty",         public = true, actions = lxml.doifempty,         arguments = "2 strings" }
+implement { name = "xmldoifnotempty",      public = true, actions = lxml.doifnotempty,      arguments = "2 strings" }
+implement { name = "xmldoifelseempty",     public = true, actions = lxml.doifelseempty,     arguments = "2 strings" }
+implement { name = "xmldoifselfempty",     public = true, actions = lxml.doifempty,         arguments = "string" } -- second arg is not passed (used)
+implement { name = "xmldoifnotselfempty",  public = true, actions = lxml.doifnotempty,      arguments = "string" } -- second arg is not passed (used)
+implement { name = "xmldoifelseselfempty", public = true, actions = lxml.doifelseempty,     arguments = "string" } -- second arg is not passed (used)
+
+--------- { name = "xmlcontent",                          actions = lxml.content,           arguments = "string" }
+--------- { name = "xmlflushstripped",                    actions = lxml.strip,             arguments = { "string", true } }
+
+implement { name = "xmlall",               public = true, actions = lxml.all,               arguments = "2 strings" }
+implement { name = "xmlatt",               public = true, actions = lxml.att,               arguments = "2 strings" }
+implement { name = "xmlattdef",            public = true, actions = lxml.att,               arguments = "3 strings" }
+implement { name = "xmlattribute",         public = true, actions = lxml.attribute,         arguments = "3 strings" }
+implement { name = "xmlattributedef",      public = true, actions = lxml.attribute,         arguments = "4 strings" }
+implement { name = "xmlbadinclusions",     public = true, actions = lxml.badinclusions,     arguments = "string" }
+implement { name = "xmlchainatt",          public = true, actions = lxml.chainattribute,    arguments = { "string", "'/'", "string" } }
+implement { name = "xmlchainattdef",       public = true, actions = lxml.chainattribute,    arguments = { "string", "'/'", "string", "string"  } }
+implement { name = "xmlchecknamespace",    public = true, actions =  xml.checknamespace,    arguments = { "lxmlid", "string", "string" } }
+implement { name = "xmlcommand",           public = true, actions = lxml.command,           arguments = "3 strings" }
+implement { name = "xmlconcat",                           actions = lxml.concat,            arguments = "3 strings" } --  \detokenize{#3}
+implement { name = "xmlconcatrange",                      actions = lxml.concatrange,       arguments = "5 strings" } --  \detokenize{#5}
+--------- { name = "xmlconcat",                           actions = lxml.concat,            arguments = { "string", "string", "verbatim" } }
+--------- { name = "xmlconcatrange",                      actions = lxml.concatrange,       arguments = { "string", "string", "string", "string", "verbatim" } }
+implement { name = "xmlcontext",           public = true, actions = lxml.context,           arguments = "2 strings" }
+implement { name = "xmlcount",             public = true, actions = lxml.count,             arguments = "2 strings" }
+implement { name = "xmldelete",            public = true, actions = lxml.delete,            arguments = "2 strings" }
+implement { name = "xmldirect",            public = true, actions = lxml.direct,            arguments = "string" }
+implement { name = "xmldirectives",        public = true, actions = lxml.directives.setup,  arguments = "string" }
+implement { name = "xmldirectivesafter",   public = true, actions = lxml.directives.after,  arguments = "string" }
+implement { name = "xmldirectivesbefore",  public = true, actions = lxml.directives.before, arguments = "string" }
+implement { name = "xmldisplayverbatim",   public = true, actions = lxml.displayverbatim,   arguments = "string" }
+implement { name = "xmlelement",           public = true, actions = lxml.element,           arguments = "2 strings" } -- could be integer but now we can alias
+implement { name = "xmlfilter",            public = true, actions = lxml.filter,            arguments = "2 strings" }
+implement { name = "xmlfilterlist",        public = true, actions = lxml.filterlist,        arguments = "2 strings" }
+implement { name = "xmlfirst",             public = true, actions = lxml.first,             arguments = "2 strings" }
+implement { name = "xmlflush",             public = true, actions = lxml.flush,             arguments = "string" }
+implement { name = "xmlflushcontext",      public = true, actions = lxml.context,           arguments = "string" }
+implement { name = "xmlflushlinewise",     public = true, actions = lxml.flushlinewise,     arguments = "string" }
+implement { name = "xmlflushpure",         public = true, actions = lxml.pure,              arguments = "string" }
+implement { name = "xmlflushspacewise",    public = true, actions = lxml.flushspacewise,    arguments = "string" }
+implement { name = "xmlflushtext",         public = true, actions = lxml.text,              arguments = "string" }
+implement { name = "xmlfunction",          public = true, actions = lxml.applyfunction,     arguments = "2 strings" }
+implement { name = "xmlinclude",           public = true, actions = lxml.include,           arguments = { "string", "string", "string", true } }
+implement { name = "xmlincludeoptions",    public = true, actions = lxml.include,           arguments = "4 strings" }
+implement { name = "xmlinclusion",         public = true, actions = lxml.inclusion,         arguments = "string" }
+implement { name = "xmlinclusionbase",     public = true, actions = lxml.inclusion,         arguments = { "string", false, true } }
+implement { name = "xmlinclusions",        public = true, actions = lxml.inclusions,        arguments = "string" }
+implement { name = "xmlindex",             public = true, actions = lxml.index,             arguments = "3 strings" } -- can be integer but now we can alias
+implement { name = "xmlinlineverbatim",    public = true, actions = lxml.inlineverbatim,    arguments = "string" }
+implement { name = "xmllast",              public = true, actions = lxml.last,              arguments = "2 strings" }
+implement { name = "xmllastatt",           public = true, actions = lxml.lastatt }
+implement { name = "xmllastmatch",         public = true, actions = lxml.lastmatch }
+implement { name = "xmllastpar",           public = true, actions = lxml.lastpar }
+implement { name = "xmlloadfile",                         actions = lxml.load,              arguments = "3 strings" }
+implement { name = "xmlloadbuffer",                       actions = lxml.loadbuffer,        arguments = "3 strings" }
+implement { name = "xmlloaddata",                         actions = lxml.loaddata,          arguments = "3 strings" }
+implement { name = "xmlloaddirectives",    public = true, actions = lxml.directives.load,   arguments = "string" }
+implement { name = "xmlmain",              public = true, actions = lxml.main,              arguments = "string" }
+implement { name = "xmlmatch",             public = true, actions = lxml.match,             arguments = "string" }
+implement { name = "xmlname",              public = true, actions = lxml.name,              arguments = "string" }
+implement { name = "xmlnamespace",         public = true, actions = lxml.namespace,         arguments = "string" }
+implement { name = "xmlnonspace",          public = true, actions = lxml.nonspace,          arguments = "2 strings" }
+implement { name = "xmlpar",               public = true, actions = lxml.par,               arguments = "2 strings" }
+implement { name = "xmlparam",             public = true, actions = lxml.param,             arguments = "3 strings" }
+implement { name = "xmlpath",              public = true, actions = lxml.path,              arguments = { "string", "'/'" } }
+implement { name = "xmlpopmatch",          public = true, actions = lxml.popmatch }
+implement { name = "xmlpos",               public = true, actions = lxml.pos,               arguments = "string" }
+implement { name = "xmlpure",              public = true, actions = lxml.pure,              arguments = "2 strings" }
+implement { name = "xmlpushmatch",         public = true, actions = lxml.pushmatch }
+implement { name = "xmlraw",               public = true, actions = lxml.raw,               arguments = "2 strings" }
+implement { name = "xmlrawtex",                           actions = lxml.rawtex,            arguments = "2 strings" }
+implement { name = "xmlrefatt",            public = true, actions = lxml.refatt,            arguments = "2 strings" }
+implement { name = "xmlregisterns",        public = true, actions =  xml.registerns,        arguments = "2 strings" }
+implement { name = "xmlremapname",         public = true, actions =  xml.remapname,         arguments = { "lxmlid", "string","string","string" } }
+implement { name = "xmlremapnamespace",    public = true, actions =  xml.renamespace,       arguments = { "lxmlid", "string", "string" } }
+implement { name = "xmlsave",              public = true, actions = lxml.save,              arguments = "2 strings" }
+implement { name = "xmlsetatt",            public = true, actions = lxml.setatt,            arguments = "3 strings" }
+implement { name = "xmlsetattribute",      public = true, actions = lxml.setattribute,      arguments = "4 strings" }
+implement { name = "xmlsetpar",            public = true, actions = lxml.setpar,            arguments = "3 strings" }
+implement { name = "xmlsetparam",          public = true, actions = lxml.setparam,          arguments = "4 strings" }
+implement { name = "xmlsetsetup",          public = true, actions = lxml.setsetup,          arguments = "3 strings" }
+implement { name = "xmlsnippet",           public = true, actions = lxml.snippet,           arguments = "2 strings" }
+implement { name = "xmlstrip",             public = true, actions = lxml.strip,             arguments = "2 strings" }
+implement { name = "xmlstripanywhere",     public = true, actions = lxml.strip,             arguments = { "string", "string", true, true } }
+implement { name = "xmlstripnolines",      public = true, actions = lxml.strip,             arguments = { "string", "string", true } }
+implement { name = "xmlstripped",          public = true, actions = lxml.stripped,          arguments = "2 strings" }
+implement { name = "xmlstrippednolines",   public = true, actions = lxml.stripped,          arguments = { "string", "string", true } }
+implement { name = "xmltag",               public = true, actions = lxml.tag,               arguments = "string" }
+implement { name = "xmltext",              public = true, actions = lxml.text,              arguments = "2 strings" }
+implement { name = "xmltobuffer",          public = true, actions = lxml.tobuffer,          arguments = "3 strings" }
+implement { name = "xmltobuffertextonly",  public = true, actions = lxml.tobuffer,          arguments = { "string", "string", "string", false } }
+implement { name = "xmltobufferverbose",   public = true, actions = lxml.tobuffer,          arguments = { "string", "string", "string", true, true } }
+implement { name = "xmltofile",            public = true, actions = lxml.tofile,            arguments = "3 strings" }
+implement { name = "xmltoparameters",      public = true, actions = lxml.toparameters,      arguments = "string" }
+implement { name = "xmlverbatim",          public = true, actions = lxml.verbatim,          arguments = "string" }
+
+implement { name = "xmlstartraw",                         actions = lxml.startraw }
+implement { name = "xmlstopraw",                          actions = lxml.stopraw  }
+
+implement { name = "xmlprependsetup",                     actions = lxml.installsetup,      arguments = { 1, "string", "string" } }           -- 2:*
+implement { name = "xmlappendsetup",                      actions = lxml.installsetup,      arguments = { 2, "string", "string" } }           -- 2:*
+implement { name = "xmlbeforesetup",                      actions = lxml.installsetup,      arguments = { 3, "string", "string", "string" } } -- 2:*
+implement { name = "xmlaftersetup",                       actions = lxml.installsetup,      arguments = { 4, "string", "string", "string" } } -- 2:*
+implement { name = "xmlremovesetup",                      actions = lxml.removesetup,       arguments = "2 strings" }              -- 1:*
+implement { name = "xmlflushsetups",                      actions = lxml.flushsetups,       arguments = "3 strings" }    -- 2:*
+implement { name = "xmlresetsetups",                      actions = lxml.resetsetups,       arguments = "string" }
 
 implement { name = "xmlgetindex",          actions = lxml.getindex,          arguments = "2 strings" }
 implement { name = "xmlwithindex",         actions = lxml.withindex,         arguments = "3 strings" }
diff --git a/tex/context/base/mkiv/lxml-ini.mkiv b/tex/context/base/mkiv/lxml-ini.mkiv
index 09358e11c..1c7006f57 100644
--- a/tex/context/base/mkiv/lxml-ini.mkiv
+++ b/tex/context/base/mkiv/lxml-ini.mkiv
@@ -34,7 +34,7 @@
 
 \def\ctxlxml                #1{\ctxlua{lxml.#1}}
 
-% for now indirect
+% for now indirect .. this will change when we have updated luatex (scan_argument)
 
 \def\xmlconcat          #1#2#3{\clf_xmlconcat     {#1}{#2}{\detokenize{#3}}}
 \def\xmlconcatrange #1#2#3#4#5{\clf_xmlconcatrange{#1}{#2}{#3}{#4}{\detokenize{#5}}}
@@ -49,85 +49,86 @@
 
 % aliased
 
-\let\xmlall                    \clf_xmlall
-\let\xmlatt                    \clf_xmlatt
-\let\xmlattdef                 \clf_xmlattdef
-\let\xmlattribute              \clf_xmlattribute
-\let\xmlattributedef           \clf_xmlattributedef
-\let\xmlbadinclusions          \clf_xmlbadinclusions
-\let\xmlchainatt               \clf_xmlchainatt
-\let\xmlchainattdef            \clf_xmlchainattdef
-\let\xmlchecknamespace         \clf_xmlchecknamespace
-\let\xmlcommand                \clf_xmlcommand
-\let\xmlcontext                \clf_xmlcontext
-\let\xmlcount                  \clf_xmlcount
-\let\xmldelete                 \clf_xmldelete
-\let\xmldirect                 \clf_xmldirect             % in loops, not dt but root
-\let\xmldirectives             \clf_xmldirectives
-\let\xmldirectivesafter        \clf_xmldirectivesafter
-\let\xmldirectivesbefore       \clf_xmldirectivesbefore
-\let\xmldisplayverbatim        \clf_xmldisplayverbatim
-\let\xmlelement                \clf_xmlelement
-\let\xmlfilter                 \clf_xmlfilter
-\let\xmlfilterlist             \clf_xmlfilterlist
-\let\xmlfirst                  \clf_xmlfirst
-\let\xmlflush                  \clf_xmlflush
-\let\xmlflushcontext           \clf_xmlflushcontext
-\let\xmlflushlinewise          \clf_xmlflushlinewise
-\let\xmlflushpure              \clf_xmlflushpure
-\let\xmlflushspacewise         \clf_xmlflushspacewise
-\let\xmlflushtext              \clf_xmlflushtext
-\let\xmlfunction               \clf_xmlfunction
-\let\xmlinclude                \clf_xmlinclude
-\let\xmlincludeoptions         \clf_xmlincludeoptions
-\let\xmlinclusion              \clf_xmlinclusion
-\let\xmlinclusionbase          \clf_xmlinclusionbase
-\let\xmlinclusions             \clf_xmlinclusions
-\let\xmlindex                  \clf_xmlindex
-\let\xmlinlineverbatim         \clf_xmlinlineverbatim
-\let\xmllast                   \clf_xmllast
-\let\xmllastatt                \clf_xmllastatt
-\let\xmllastmatch              \clf_xmllastmatch
-\let\xmllastpar                \clf_xmllastpar
-\let\xmlloaddirectives         \clf_xmlloaddirectives
-\let\xmlmain                   \clf_xmlmain
-\let\xmlmatch                  \clf_xmlmatch
-\let\xmlname                   \clf_xmlname
-\let\xmlnamespace              \clf_xmlnamespace
-\let\xmlnonspace               \clf_xmlnonspace
-\let\xmlpar                    \clf_xmlpar
-\let\xmlparam                  \clf_xmlparam
-\let\xmlpath                   \clf_xmlpath
-\let\xmlpopmatch               \clf_xmlpopmatch
-\let\xmlpos                    \clf_xmlpos
-\let\xmlposition               \clf_xmlindex
-\let\xmlpure                   \clf_xmlpure
-\let\xmlpushmatch              \clf_xmlpushmatch
-\let\xmlraw                    \clf_xmlraw
-\let\xmlrefatt                 \clf_xmlrefatt
-\let\xmlregisterns             \clf_xmlregisterns         % document
-\let\xmlremapname              \clf_xmlremapname          % element
-\let\xmlremapnamespace         \clf_xmlremapnamespace     % document
-\let\xmlsave                   \clf_xmlsave
-\let\xmlsetatt                 \clf_xmlsetatt
-\let\xmlsetattribute           \clf_xmlsetattribute
-\let\xmlsetpar                 \clf_xmlsetpar
-\let\xmlsetparam               \clf_xmlsetparam
-\let\xmlsetsetup               \clf_xmlsetsetup
-\let\xmlsnippet                \clf_xmlsnippet
-\let\xmlstrip                  \clf_xmlstrip
-\let\xmlstripanywhere          \clf_xmlstripanywhere
-\let\xmlstripnolines           \clf_xmlstripnolines
-\let\xmlstripped               \clf_xmlstripped
-\let\xmlstrippednolines        \clf_xmlstrippednolines
-\let\xmltag                    \clf_xmltag
-\let\xmltext                   \clf_xmltext
-\let\xmltobuffer               \clf_xmltobuffer           % id pattern name
-\let\xmltobuffertextonly       \clf_xmltobuffertextonly   % id pattern name
-\let\xmltobufferverbose        \clf_xmltobufferverbose    % id pattern name
-\let\xmltofile                 \clf_xmltofile             % id pattern filename
-\let\xmltoparameters           \clf_xmltoparameters
-\let\xmlverbatim               \clf_xmlverbatim
+%let\xmlall                    \clf_xmlall
+%let\xmlatt                    \clf_xmlatt
+%let\xmlattdef                 \clf_xmlattdef
+%let\xmlattribute              \clf_xmlattribute
+%let\xmlattributedef           \clf_xmlattributedef
+%let\xmlbadinclusions          \clf_xmlbadinclusions
+%let\xmlchainatt               \clf_xmlchainatt
+%let\xmlchainattdef            \clf_xmlchainattdef
+%let\xmlchecknamespace         \clf_xmlchecknamespace
+%let\xmlcommand                \clf_xmlcommand
+%let\xmlcontext                \clf_xmlcontext
+%let\xmlcount                  \clf_xmlcount
+%let\xmldelete                 \clf_xmldelete
+%let\xmldirect                 \clf_xmldirect             % in loops, not dt but root
+%let\xmldirectives             \clf_xmldirectives
+%let\xmldirectivesafter        \clf_xmldirectivesafter
+%let\xmldirectivesbefore       \clf_xmldirectivesbefore
+%let\xmldisplayverbatim        \clf_xmldisplayverbatim
+%let\xmlelement                \clf_xmlelement
+%let\xmlfilter                 \clf_xmlfilter
+%let\xmlfilterlist             \clf_xmlfilterlist
+%let\xmlfirst                  \clf_xmlfirst
+%let\xmlflush                  \clf_xmlflush
+%let\xmlflushcontext           \clf_xmlflushcontext
+%let\xmlflushlinewise          \clf_xmlflushlinewise
+%let\xmlflushpure              \clf_xmlflushpure
+%let\xmlflushspacewise         \clf_xmlflushspacewise
+%let\xmlflushtext              \clf_xmlflushtext
+%let\xmlfunction               \clf_xmlfunction
+%let\xmlinclude                \clf_xmlinclude
+%let\xmlincludeoptions         \clf_xmlincludeoptions
+%let\xmlinclusion              \clf_xmlinclusion
+%let\xmlinclusionbase          \clf_xmlinclusionbase
+%let\xmlinclusions             \clf_xmlinclusions
+%let\xmlindex                  \clf_xmlindex
+%let\xmlinlineverbatim         \clf_xmlinlineverbatim
+%let\xmllast                   \clf_xmllast
+%let\xmllastatt                \clf_xmllastatt
+%let\xmllastmatch              \clf_xmllastmatch
+%let\xmllastpar                \clf_xmllastpar
+%let\xmlloaddirectives         \clf_xmlloaddirectives
+%let\xmlmain                   \clf_xmlmain
+%let\xmlmatch                  \clf_xmlmatch
+%let\xmlname                   \clf_xmlname
+%let\xmlnamespace              \clf_xmlnamespace
+%let\xmlnonspace               \clf_xmlnonspace
+%let\xmlpar                    \clf_xmlpar
+%let\xmlparam                  \clf_xmlparam
+%let\xmlpath                   \clf_xmlpath
+%let\xmlpopmatch               \clf_xmlpopmatch
+%let\xmlpos                    \clf_xmlpos
+%let\xmlpure                   \clf_xmlpure
+%let\xmlpushmatch              \clf_xmlpushmatch
+%let\xmlraw                    \clf_xmlraw
+%let\xmlrefatt                 \clf_xmlrefatt
+%let\xmlregisterns             \clf_xmlregisterns         % document
+%let\xmlremapname              \clf_xmlremapname          % element
+%let\xmlremapnamespace         \clf_xmlremapnamespace     % document
+%let\xmlsave                   \clf_xmlsave
+%let\xmlsetatt                 \clf_xmlsetatt
+%let\xmlsetattribute           \clf_xmlsetattribute
+%let\xmlsetpar                 \clf_xmlsetpar
+%let\xmlsetparam               \clf_xmlsetparam
+%let\xmlsetsetup               \clf_xmlsetsetup
+%let\xmlsnippet                \clf_xmlsnippet
+%let\xmlstrip                  \clf_xmlstrip
+%let\xmlstripanywhere          \clf_xmlstripanywhere
+%let\xmlstripnolines           \clf_xmlstripnolines
+%let\xmlstripped               \clf_xmlstripped
+%let\xmlstrippednolines        \clf_xmlstrippednolines
+%let\xmltag                    \clf_xmltag
+%let\xmltext                   \clf_xmltext
+%let\xmltobuffer               \clf_xmltobuffer           % id pattern name
+%let\xmltobuffertextonly       \clf_xmltobuffertextonly   % id pattern name
+%let\xmltobufferverbose        \clf_xmltobufferverbose    % id pattern name
+%let\xmltofile                 \clf_xmltofile             % id pattern filename
+%let\xmltoparameters           \clf_xmltoparameters
+%let\xmlverbatim               \clf_xmlverbatim
+
+\let\xmlposition               \xmlindex
 
 \unexpanded\def\xmlinfo#1{\hbox{\ttxx[\clf_xmlname{#1}]}}
 \unexpanded\def\xmlshow#1{\startpacked\ttx\xmlverbatim{#1}\stoppacked}
@@ -135,7 +136,7 @@
 % the next one is handy for mode runs because it enforces a consistent
 % #1 indexing (needed when using \xmltext{main:123}{...} like calls
 
-\let\xmladdindex               \clf_xmladdindex
+%let\xmladdindex               \clf_xmladdindex
 
 % we need to pass the last argument as function, so
 
@@ -185,23 +186,23 @@
 
 % these are expandable! todo: \xmldoifelseattribute
 
-\let\xmldoif              \clf_xmldoif
-\let\xmldoifnot           \clf_xmldoifnot
-\let\xmldoifelse          \clf_xmldoifelse
-\let\xmldoiftext          \clf_xmldoiftext
-\let\xmldoifnottext       \clf_xmldoifnottext
-\let\xmldoifelsetext      \clf_xmldoifelsetext
-
-\let\xmldoifatt           \clf_xmldoifatt
-\let\xmldoifnotatt        \clf_xmldoifnotatt
-\let\xmldoifelseatt       \clf_xmldoifelseatt
-
-\let\xmldoifempty         \clf_xmldoifempty
-\let\xmldoifnotempty      \clf_xmldoifnotempty
-\let\xmldoifelseempty     \clf_xmldoifelseempty
-\let\xmldoifselfempty     \clf_xmldoifselfempty
-\let\xmldoifnotselfempty  \clf_xmldoifnotselfempty
-\let\xmldoifelseselfempty \clf_xmldoifelseselfempty
+%let\xmldoif              \clf_xmldoif
+%let\xmldoifnot           \clf_xmldoifnot
+%let\xmldoifelse          \clf_xmldoifelse
+%let\xmldoiftext          \clf_xmldoiftext
+%let\xmldoifnottext       \clf_xmldoifnottext
+%let\xmldoifelsetext      \clf_xmldoifelsetext
+
+%let\xmldoifatt           \clf_xmldoifatt
+%let\xmldoifnotatt        \clf_xmldoifnotatt
+%let\xmldoifelseatt       \clf_xmldoifelseatt
+
+%let\xmldoifempty         \clf_xmldoifempty
+%let\xmldoifnotempty      \clf_xmldoifnotempty
+%let\xmldoifelseempty     \clf_xmldoifelseempty
+%let\xmldoifselfempty     \clf_xmldoifselfempty
+%let\xmldoifnotselfempty  \clf_xmldoifnotselfempty
+%let\xmldoifelseselfempty \clf_xmldoifelseselfempty
 
 \let\xmldoiftextelse      \xmldoifelsetext
 \let\xmldoifemptyelse     \xmldoifelseempty
diff --git a/tex/context/base/mkiv/lxml-tex.lua b/tex/context/base/mkiv/lxml-tex.lua
index 9ab8cafc6..079ab29da 100644
--- a/tex/context/base/mkiv/lxml-tex.lua
+++ b/tex/context/base/mkiv/lxml-tex.lua
@@ -472,6 +472,7 @@ lxml.addindex = addindex
 implement {
     name      = "xmladdindex",
     arguments = "string",
+    public    = true,
     actions   = addindex,
 }
 
@@ -2070,7 +2071,8 @@ do
     implement {
         name      = "xmldoifatt",
         arguments = "3 strings",
-        actions = function(id,k,v)
+        public    = true,
+        actions   = function(id,k,v)
             local e = getid(id)
             ctx_doif(e and e.at[k] == v or false)
         end
@@ -2079,7 +2081,8 @@ do
     implement {
         name      = "xmldoifnotatt",
         arguments = "3 strings",
-        actions = function(id,k,v)
+        public    = true,
+        actions   = function(id,k,v)
             local e = getid(id)
             ctx_doifnot(e and e.at[k] == v or false)
         end
@@ -2088,7 +2091,8 @@ do
     implement {
         name      = "xmldoifelseatt",
         arguments = "3 strings",
-        actions = function(id,k,v)
+        public    = true,
+        actions   = function(id,k,v)
             local e = getid(id)
             ctx_doifelse(e and e.at[k] == v or false)
         end
diff --git a/tex/context/base/mkiv/math-ali.mkiv b/tex/context/base/mkiv/math-ali.mkiv
index 400326d26..7f210bb41 100644
--- a/tex/context/base/mkiv/math-ali.mkiv
+++ b/tex/context/base/mkiv/math-ali.mkiv
@@ -1012,12 +1012,12 @@
 \let\mathmatrixleft \empty % experimental hook
 \let\mathmatrixright\empty % experimental hook
 
-\setvalue{\??mathmatrixalignlocation\v!top   }{\raise\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\textfont\zerocount\relax}
+\setvalue{\??mathmatrixalignlocation\v!top   }{\raise\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\mathstyle\relax}
 \setvalue{\??mathmatrixalignlocation\v!high  }{\raise\dimexpr(\nextboxdp-\nextboxht)/2\relax}
 \setvalue{\??mathmatrixalignlocation\v!center}{\relax}
 \setvalue{\??mathmatrixalignlocation\v!lohi}  {\relax}
 \setvalue{\??mathmatrixalignlocation\v!normal}{\relax}
-\setvalue{\??mathmatrixalignlocation\v!bottom}{\lower\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\textfont\zerocount\relax}
+\setvalue{\??mathmatrixalignlocation\v!bottom}{\lower\dimexpr(\nextboxdp-\nextboxht)/2 +\mathaxisheight\mathstyle\relax}
 \setvalue{\??mathmatrixalignlocation\v!low   }{\lower\dimexpr(\nextboxdp-\nextboxht)/2\relax}
 
 \def\math_matrix_finish_nextbox
diff --git a/tex/context/base/mkiv/mult-low.lua b/tex/context/base/mkiv/mult-low.lua
index 58202fa1a..16eb3e68b 100644
--- a/tex/context/base/mkiv/mult-low.lua
+++ b/tex/context/base/mkiv/mult-low.lua
@@ -90,7 +90,7 @@ return {
         "fontexheight", "fontemwidth", "fontextraspace", "slantperpoint",
         "mathexheight", "mathemwidth",
         "interwordspace", "interwordstretch", "interwordshrink", "exheight", "emwidth", "extraspace",
-        "mathsupdisplay", "mathsupnormal", "mathsupcramped", "mathsubnormal", "mathsubcombined",  "mathaxisheight",
+        "mathaxisheight",
         "muquad",
         --
         -- maybe a different class
diff --git a/tex/context/base/mkiv/pack-rul.mkxl b/tex/context/base/mkiv/pack-rul.mkxl
index 6268aad3e..97cb82968 100644
--- a/tex/context/base/mkiv/pack-rul.mkxl
+++ b/tex/context/base/mkiv/pack-rul.mkxl
@@ -469,29 +469,6 @@
   {\def\pack_framed_define_overlay_indeed##1{\setvalue{\??overlay##1}{\executedefinedoverlay{##1}{#2}}}%
    \processcommalist[#1]\pack_framed_define_overlay_indeed}
 
-% \unexpanded\def\executedefinedoverlay#1#2% we can share the definitions
-%   {\bgroup % redundant grouping
-%    \setbox\scratchbox\hbox\bgroup
-%      \ifzeropt\d_framed_target_dp
-%        \the\everyoverlay#2% saves wrapping (and lua call)
-%      \else
-%        \lower\d_framed_target_dp
-%        \hbox{\the\everyoverlay#2}%
-%      \fi
-%    \egroup
-%    \setlayoutcomponentattribute{\v!overlay:#1}%
-%    \setbox\scratchbox\hpack \layoutcomponentboxattribute
-%      {\kern -.5\dimexpr\wd\scratchbox-\d_framed_target_wd\relax % was \d_overlay_width
-%       \raise-.5\dimexpr\ht\scratchbox-\d_framed_target_ht\relax % not \d_overlay_height !
-%       \box\scratchbox}%
-%    \wd\scratchbox\d_framed_target_wd
-%    \ht\scratchbox\d_framed_target_ht
-%    \dp\scratchbox\d_framed_target_dp
-%    \box\scratchbox
-%    \egroup}
-
-% 20191231: moved from cont-exp:
-
 \unexpanded\def\executedefinedoverlay#1#2% we can share the definitions
   {\bgroup % redundant grouping
    \setlayoutcomponentattribute{\v!overlay:#1}%
@@ -507,13 +484,6 @@
 %D \macros
 %D   {overlayfakebox}
 
-% \unexpanded\def\overlayfakebox
-%   {\hpack
-%      {\setbox\scratchbox\emptyhbox
-%       \wd\scratchbox\d_overlay_width
-%       \ht\scratchbox\d_overlay_height
-%       \box\scratchbox}}
-
 \unexpanded\def\overlayfakebox
   {\hpack % redundant but needs testing
      {\novrule
diff --git a/tex/context/base/mkiv/spac-flr.mkiv b/tex/context/base/mkiv/spac-flr.mkiv
index 4c3c0c042..a64171247 100644
--- a/tex/context/base/mkiv/spac-flr.mkiv
+++ b/tex/context/base/mkiv/spac-flr.mkiv
@@ -168,6 +168,23 @@
   [\c!alternative=\v!space,
    \c!distance=3\emwidth]
 
+% bonus:
+
+\definefiller
+  [dotfill]
+  [\c!symbol=\textperiod,
+   \c!style=\v!normal,
+   \c!method=\v!middle,
+   \c!width=.5\emwidth,
+   \c!leftmargin=.2\emwidth,
+   \c!rightmargin=.2\emwidth]
+
+\let\mathdotfill\dotfill
+
+\unexpanded\def\textdotfill{\filler[dotfill]}
+
+\unexpanded\def\dotfill{\mathortext\mathdotfill\textdotfill}
+
 % maybe box -> symbol
 
 \protect \endinput
diff --git a/tex/context/base/mkiv/status-files.pdf b/tex/context/base/mkiv/status-files.pdf
new file mode 100644
index 000000000..9ef6ddd19
--- /dev/null
+++ b/tex/context/base/mkiv/status-files.pdf
diff --git a/tex/context/base/mkiv/status-lua.pdf b/tex/context/base/mkiv/status-lua.pdf
new file mode 100644
index 000000000..e967a7798
--- /dev/null
+++ b/tex/context/base/mkiv/status-lua.pdf
diff --git a/tex/context/base/mkiv/syst-aux.mkiv b/tex/context/base/mkiv/syst-aux.mkiv
index d268f2fb6..20716786d 100644
--- a/tex/context/base/mkiv/syst-aux.mkiv
+++ b/tex/context/base/mkiv/syst-aux.mkiv
@@ -4492,7 +4492,9 @@
 
 \unexpanded\def\resetrecurselevel{\let\recurselevel\!!zerocount}
 
-\let\recurselevel\!!zerocount
+\let\recurselevel \!!zerocount
+\let\recurseaction\relax
+\let\recursestring\empty
 
 % \appendtoks \resetrecurselevel \to \everydump
 
diff --git a/tex/context/base/mkiv/syst-aux.mkxl b/tex/context/base/mkiv/syst-aux.mkxl
index 8188577e6..956d43f89 100644
--- a/tex/context/base/mkiv/syst-aux.mkxl
+++ b/tex/context/base/mkiv/syst-aux.mkxl
@@ -2979,6 +2979,9 @@
 \def\recursedepth{\the\outerrecurse}
 \def\recurselevel{0}
 
+\let\recurseaction\relax
+\let\recursestring\empty
+
 \let\syst_helpers_stepwise_next\relax
 
 \unexpanded\def\syst_helpers_stepwise_recurse#1#2#3% from to step
@@ -3088,6 +3091,7 @@
 
 \let\endofloop\donothing % maybe \syst_helpers_loop_end
 
+
 \unexpanded\def\doloop#1%
   {\global\advance\outerrecurse \plusone
    \globalpushmacro\recurselevel
diff --git a/tex/context/base/mkiv/syst-fnt.mkiv b/tex/context/base/mkiv/syst-fnt.mkiv
index cacc5f517..764e486d2 100644
--- a/tex/context/base/mkiv/syst-fnt.mkiv
+++ b/tex/context/base/mkiv/syst-fnt.mkiv
@@ -31,12 +31,7 @@
 \def\emwidth             {\fontdimen\plussix  \font}
 \def\extraspace          {\fontdimen\plusseven\font}
 
-\def\mathsupdisplay      {\fontdimen13 } % to be remapped
-\def\mathsupnormal       {\fontdimen14 } % to be remapped
-\def\mathsupcramped      {\fontdimen15 } % to be remapped
-\def\mathsubnormal       {\fontdimen16 } % to be remapped
-\def\mathsubcombined     {\fontdimen17 } % to be remapped
-\def\mathaxisheight      {\fontdimen22 } % to be remapped
+\def\mathaxisheight      {\Umathaxis} % takes style
 
 \def\currentspaceskip    {\interwordspace\s!plus\interwordstretch\s!minus\interwordshrink\relax}
 
diff --git a/tex/context/base/mkiv/toks-ini.lua b/tex/context/base/mkiv/toks-ini.lua
index da5affa63..8fc60335e 100644
--- a/tex/context/base/mkiv/toks-ini.lua
+++ b/tex/context/base/mkiv/toks-ini.lua
@@ -192,7 +192,7 @@ tokens.scanners = { -- these expand
     string      = scan_string,
     argument    = scan_argument,
     tokenlist   = scan_tokenlist,
-    verbatim    = scan_verbatim,
+    verbatim    = scan_verbatim, -- detokenize
     code        = scan_code,
     tokencode   = scan_token_code,
     word        = scan_word,
diff --git a/tex/context/base/mkiv/trac-vis.lua b/tex/context/base/mkiv/trac-vis.lua
index 760ba8726..f89043547 100644
--- a/tex/context/base/mkiv/trac-vis.lua
+++ b/tex/context/base/mkiv/trac-vis.lua
@@ -874,6 +874,7 @@ local ruledglue do
     local userskip_code       = gluecodes.userskip
     local spaceskip_code      = gluecodes.spaceskip
     local xspaceskip_code     = gluecodes.xspaceskip
+    local zerospaceskip_code  = gluecodes.zerospaceskip or gluecodes.userskip
     local leftskip_code       = gluecodes.leftskip
     local rightskip_code      = gluecodes.rightskip
     local parfillskip_code    = gluecodes.parfillskip
@@ -914,6 +915,7 @@ local ruledglue do
         [rightskip_code]                  = "RS",
         [spaceskip_code]                  = "SP",
         [xspaceskip_code]                 = "XS",
+        [zerospaceskip_code]              = "ZS",
         [parfillskip_code]                = "PF",
         [indentskip_code]                 = "IN",
         [correctionskip_code]             = "CS",
@@ -929,7 +931,7 @@ local ruledglue do
         if info then
             -- print("glue hit")
         else
-            if subtype == spaceskip_code or subtype == xspaceskip_code then
+            if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then
                 info = sometext(amount,l_glue,c_space)
             elseif subtype == leftskip_code or subtype == rightskip_code then
                 info = sometext(amount,l_glue,c_skip_a)
@@ -958,7 +960,7 @@ local ruledglue do
 
  -- ruledspace = function(head,current,parent)
  --     local subtype = getsubtype(current)
- --     if subtype == spaceskip_code or subtype == xspaceskip_code then
+ --     if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then
  --         local width  = effectiveglue(current,parent)
  --         local amount = formatters["%s:%0.3f"](tags[subtype] or "HS",width*pt_factor)
  --         local info   = g_cache_h[amount]
@@ -981,7 +983,7 @@ local ruledglue do
 
     ruledspace = function(head,current,parent)
         local subtype = getsubtype(current)
-        if subtype == spaceskip_code or subtype == xspaceskip_code then -- not yet all space
+        if subtype == spaceskip_code or subtype == xspaceskip_code or subtype == zerospaceskip_code then -- not yet all space
             local width = effectiveglue(current,parent)
             local info
             if subtype == spaceskip_code then
diff --git a/tex/context/base/mkiv/type-ini.mklx b/tex/context/base/mkiv/type-ini.mklx
index c710fbec5..1cb9bc2e5 100644
--- a/tex/context/base/mkiv/type-ini.mklx
+++ b/tex/context/base/mkiv/type-ini.mklx
@@ -90,6 +90,13 @@
 \installmacrostack\typescriptmethod
 \installmacrostack\typescriptstate
 
+%D When these are loaded it is possible to get spaces but the whole idea is to do
+%D that loading in vertical mode. Adding \type {\pushendofline} and \type
+%D {\popendofline} is an option but not watertight as it can still interfere, for
+%D instance work comments and leading spaces. Also, in horizontal mode it is likely
+%D that one is also grouped and loading bodyfonts grouped is a real bad idea.
+%D Ignoring all spaces is also not a solution. So, our verdict is: no catch.
+
 \unexpanded\def\starttypescriptcollection
   {\dosingleempty\font_typescripts_collection_start}
 
diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua
index f2a2b7d9e..a1c027064 100644
--- a/tex/generic/context/luatex/luatex-fonts-merged.lua
+++ b/tex/generic/context/luatex/luatex-fonts-merged.lua
@@ -1,6 +1,6 @@
 -- merged file : c:/data/develop/context/sources/luatex-fonts-merged.lua
 -- parent file : c:/data/develop/context/sources/luatex-fonts.lua
--- merge date  : 2020-06-14 22:04
+-- merge date  : 2020-06-17 18:56
 
 do -- begin closure to overcome local limits and interference