2021-11-13 20:35:00

43 files changed, 1628 insertions, 1054 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 cad31703e..88613d1db 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", "pluseleven", "plustwelve", "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", "prerollrun", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "statuswrite", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "rlncatcodes", "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", "percentasciicode", "leftbracketasciicode", "rightbracketasciicode", "hsizefrozenparcode", "skipfrozenparcode", "hangfrozenparcode", "indentfrozenparcode", "parfillfrozenparcode", "adjustfrozenparcode", "protrudefrozenparcode", "tolerancefrozenparcode", "stretchfrozenparcode", "loosenessfrozenparcode", "lastlinefrozenparcode", "linepenaltyfrozenparcode", "clubpenaltyfrozenparcode", "widowpenaltyfrozenparcode", "displaypenaltyfrozenparcode", "brokenpenaltyfrozenparcode", "demeritsfrozenparcode", "shapefrozenparcode", "linefrozenparcode", "hyphenationfrozenparcode", "shapingpenaltiesfrozenparcode", "orphanpenaltyfrozenparcode", "allfrozenparcode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vadjustgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "alsosimplegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "localboxgroupcode", "splitoffgroupcode", "splitkeepgroupcode", "preamblegroupcode", "alignsetgroupcode", "finrowgroupcode", "discretionarygroupcode", "markautomigrationcode", "insertautomigrationcode", "adjustautomigrationcode", "preautomigrationcode", "postautomigrationcode", "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", "overrulemathcontrolcode", "underrulemathcontrolcode", "radicalrulemathcontrolcode", "fractionrulemathcontrolcode", "accentskewhalfmathcontrolcode", "accentskewapplymathcontrolcode", "accentitalickernmathcontrolcode", "delimiteritalickernmathcontrolcode", "noorditalickernmathcontrolcode", "charitalicwidthmathcontrolcode", "charitalicnoreboxmathcontrolcode", "boxednoitalickernmathcontrolcode", "nostaircasekernmathcontrolcode", "textitalickernmathcontrolcode", "noscriptitalickernmathcontrolcode", "noligaturingglyphoptioncode", "nokerningglyphoptioncode", "noexpansionglyphoptioncode", "noprotrusionglyphoptioncode", "noleftkerningglyphoptioncode", "noleftligaturingglyphoptioncode", "norightkerningglyphoptioncode", "norightligaturingglyphoptioncode", "noitaliccorrectionglyphoptioncode", "normalparcontextcode", "vmodeparcontextcode", "vboxparcontextcode", "vtopparcontextcode", "vcenterparcontextcode", "vadjustparcontextcode", "insertparcontextcode", "outputparcontextcode", "alignparcontextcode", "noalignparcontextcode", "spanparcontextcode", "resetparcontextcode", "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", "normalhyphenationcode", "automatichyphenationcode", "explicithyphenationcode", "syllablehyphenationcode", "uppercasehyphenationcode", "collapsehyphenationcode", "compoundhyphenationcode", "strictstarthyphenationcode", "strictendhyphenationcode", "automaticpenaltyhyphenationcode", "explicitpenaltyhyphenationcode", "permitgluehyphenationcode", "permitallhyphenationcode", "permitmathreplacehyphenationcode", "forcecheckhyphenationcode", "lazyligatureshyphenationcode", "forcehandlerhyphenationcode", "feedbackcompoundhyphenationcode", "ignoreboundshyphenationcode", "partialhyphenationcode", "completehyphenationcode", "normalizelinenormalizecode", "parindentskipnormalizecode", "swaphangindentnormalizecode", "swapparsshapenormalizecode", "breakafterdirnormalizecode", "removemarginkernsnormalizecode", "clipwidthnormalizecode", "flattendiscretionariesnormalizecode", "discardzerotabskipsnormalizecode", "noligaturingglyphoptioncode", "nokerningglyphoptioncode", "noleftligatureglyphoptioncode", "noleftkernglyphoptioncode", "norightligatureglyphoptioncode", "norightkernglyphoptioncode", "noexpansionglyphoptioncode", "noprotrusionglyphoptioncode", "noitaliccorrectionglyphoptioncode", "nokerningcode", "noligaturingcode", "frozenflagcode", "tolerantflagcode", "protectedflagcode", "primitiveflagcode", "permanentflagcode", "noalignedflagcode", "immutableflagcode", "mutableflagcode", "globalflagcode", "overloadedflagcode", "immediateflagcode", "conditionalflagcode", "valueflagcode", "instanceflagcode", "ordmathflattencode", "binmathflattencode", "relmathflattencode", "punctmathflattencode", "innermathflattencode", "normalworddiscoptioncode", "preworddiscoptioncode", "postworddiscoptioncode", "continuewhenlmtxmode" },
+ ["constants"]={ "zerocount", "minusone", "minustwo", "plusone", "plustwo", "plusthree", "plusfour", "plusfive", "plussix", "plusseven", "pluseight", "plusnine", "plusten", "pluseleven", "plustwelve", "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", "prerollrun", "voidbox", "emptybox", "emptyvbox", "emptyhbox", "bigskipamount", "medskipamount", "smallskipamount", "fmtname", "fmtversion", "texengine", "texenginename", "texengineversion", "texenginefunctionality", "luatexengine", "pdftexengine", "xetexengine", "unknownengine", "contextformat", "contextversion", "contextlmtxmode", "contextmark", "mksuffix", "activecatcode", "bgroup", "egroup", "endline", "conditionaltrue", "conditionalfalse", "attributeunsetvalue", "statuswrite", "uprotationangle", "rightrotationangle", "downrotationangle", "leftrotationangle", "inicatcodes", "ctxcatcodes", "texcatcodes", "notcatcodes", "txtcatcodes", "vrbcatcodes", "prtcatcodes", "nilcatcodes", "luacatcodes", "tpacatcodes", "tpbcatcodes", "xmlcatcodes", "ctdcatcodes", "rlncatcodes", "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", "percentasciicode", "leftbracketasciicode", "rightbracketasciicode", "hsizefrozenparcode", "skipfrozenparcode", "hangfrozenparcode", "indentfrozenparcode", "parfillfrozenparcode", "adjustfrozenparcode", "protrudefrozenparcode", "tolerancefrozenparcode", "stretchfrozenparcode", "loosenessfrozenparcode", "lastlinefrozenparcode", "linepenaltyfrozenparcode", "clubpenaltyfrozenparcode", "widowpenaltyfrozenparcode", "displaypenaltyfrozenparcode", "brokenpenaltyfrozenparcode", "demeritsfrozenparcode", "shapefrozenparcode", "linefrozenparcode", "hyphenationfrozenparcode", "shapingpenaltiesfrozenparcode", "orphanpenaltyfrozenparcode", "allfrozenparcode", "activemathcharcode", "activetabtoken", "activeformfeedtoken", "activeendoflinetoken", "batchmodecode", "nonstopmodecode", "scrollmodecode", "errorstopmodecode", "bottomlevelgroupcode", "simplegroupcode", "hboxgroupcode", "adjustedhboxgroupcode", "vboxgroupcode", "vtopgroupcode", "aligngroupcode", "noaligngroupcode", "outputgroupcode", "mathgroupcode", "discretionarygroupcode", "insertgroupcode", "vadjustgroupcode", "vcentergroupcode", "mathabovegroupcode", "mathchoicegroupcode", "alsosimplegroupcode", "semisimplegroupcode", "mathshiftgroupcode", "mathleftgroupcode", "localboxgroupcode", "splitoffgroupcode", "splitkeepgroupcode", "preamblegroupcode", "alignsetgroupcode", "finrowgroupcode", "discretionarygroupcode", "markautomigrationcode", "insertautomigrationcode", "adjustautomigrationcode", "preautomigrationcode", "postautomigrationcode", "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", "overrulemathcontrolcode", "underrulemathcontrolcode", "radicalrulemathcontrolcode", "fractionrulemathcontrolcode", "accentskewhalfmathcontrolcode", "accentskewapplymathcontrolcode", "accentitalickernmathcontrolcode", "delimiteritalickernmathcontrolcode", "noorditalickernmathcontrolcode", "charitalicwidthmathcontrolcode", "charitalicnoreboxmathcontrolcode", "boxednoitalickernmathcontrolcode", "nostaircasekernmathcontrolcode", "textitalickernmathcontrolcode", "noscriptitalickernmathcontrolcode", "italicshapekernmathcontrolcode", "noligaturingglyphoptioncode", "nokerningglyphoptioncode", "noexpansionglyphoptioncode", "noprotrusionglyphoptioncode", "noleftkerningglyphoptioncode", "noleftligaturingglyphoptioncode", "norightkerningglyphoptioncode", "norightligaturingglyphoptioncode", "noitaliccorrectionglyphoptioncode", "normalparcontextcode", "vmodeparcontextcode", "vboxparcontextcode", "vtopparcontextcode", "vcenterparcontextcode", "vadjustparcontextcode", "insertparcontextcode", "outputparcontextcode", "alignparcontextcode", "noalignparcontextcode", "spanparcontextcode", "resetparcontextcode", "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", "normalhyphenationcode", "automatichyphenationcode", "explicithyphenationcode", "syllablehyphenationcode", "uppercasehyphenationcode", "collapsehyphenationcode", "compoundhyphenationcode", "strictstarthyphenationcode", "strictendhyphenationcode", "automaticpenaltyhyphenationcode", "explicitpenaltyhyphenationcode", "permitgluehyphenationcode", "permitallhyphenationcode", "permitmathreplacehyphenationcode", "forcecheckhyphenationcode", "lazyligatureshyphenationcode", "forcehandlerhyphenationcode", "feedbackcompoundhyphenationcode", "ignoreboundshyphenationcode", "partialhyphenationcode", "completehyphenationcode", "normalizelinenormalizecode", "parindentskipnormalizecode", "swaphangindentnormalizecode", "swapparsshapenormalizecode", "breakafterdirnormalizecode", "removemarginkernsnormalizecode", "clipwidthnormalizecode", "flattendiscretionariesnormalizecode", "discardzerotabskipsnormalizecode", "noligaturingglyphoptioncode", "nokerningglyphoptioncode", "noleftligatureglyphoptioncode", "noleftkernglyphoptioncode", "norightligatureglyphoptioncode", "norightkernglyphoptioncode", "noexpansionglyphoptioncode", "noprotrusionglyphoptioncode", "noitaliccorrectionglyphoptioncode", "nokerningcode", "noligaturingcode", "frozenflagcode", "tolerantflagcode", "protectedflagcode", "primitiveflagcode", "permanentflagcode", "noalignedflagcode", "immutableflagcode", "mutableflagcode", "globalflagcode", "overloadedflagcode", "immediateflagcode", "conditionalflagcode", "valueflagcode", "instanceflagcode", "ordmathflattencode", "binmathflattencode", "relmathflattencode", "punctmathflattencode", "innermathflattencode", "normalworddiscoptioncode", "preworddiscoptioncode", "postworddiscoptioncode", "continuewhenlmtxmode" },
  ["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", "nofarguments", "firstargumentfalse", "firstargumenttrue", "secondargumentfalse", "secondargumenttrue", "thirdargumentfalse", "thirdargumenttrue", "fourthargumentfalse", "fourthargumenttrue", "fifthargumentfalse", "fifthargumenttrue", "sixthargumentfalse", "sixthargumenttrue", "seventhargumentfalse", "seventhargumenttrue", "vkern", "hkern", "vpenalty", "hpenalty", "doglobal", "dodoglobal", "redoglobal", "resetglobal", "donothing", "untraceddonothing", "dontcomplain", "lessboxtracing", "forgetall", "donetrue", "donefalse", "foundtrue", "foundfalse", "inlineordisplaymath", "indisplaymath", "forcedisplaymath", "startforceddisplaymath", "stopforceddisplaymath", "startpickupmath", "stoppickupmath", "reqno", "mathortext", "thebox", "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", "scratchstring", "scratchstringone", "scratchstringtwo", "tempstring", "scratchcounter", "globalscratchcounter", "privatescratchcounter", "scratchdimen", "globalscratchdimen", "privatescratchdimen", "scratchskip", "globalscratchskip", "privatescratchskip", "scratchmuskip", "globalscratchmuskip", "privatescratchmuskip", "scratchtoks", "globalscratchtoks", "privatescratchtoks", "scratchbox", "globalscratchbox", "privatescratchbox", "scratchmacro", "scratchmacroone", "scratchmacrotwo", "scratchconditiontrue", "scratchconditionfalse", "ifscratchcondition", "scratchconditiononetrue", "scratchconditiononefalse", "ifscratchconditionone", "scratchconditiontwotrue", "scratchconditiontwofalse", "ifscratchconditiontwo", "globalscratchcounterone", "globalscratchcountertwo", "globalscratchcounterthree", "groupedcommand", "groupedcommandcs", "triggergroupedcommand", "triggergroupedcommandcs", "simplegroupedcommand", "simplegroupedcommandcs", "pickupgroupedcommand", "pickupgroupedcommandcs", "usedbaselineskip", "usedlineskip", "usedlineskiplimit", "availablehsize", "localhsize", "setlocalhsize", "distributedhsize", "hsizefraction", "next", "nexttoken", "nextbox", "dowithnextbox", "dowithnextboxcs", "dowithnextboxcontent", "dowithnextboxcontentcs", "flushnextbox", "boxisempty", "boxtostring", "contentostring", "prerolltostring", "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", "tracingcatcodes", "showluatokens", "aliasmacro", "removetoks", "appendtoks", "prependtoks", "appendtotoks", "prependtotoks", "to", "endgraf", "endpar", "reseteverypar", "finishpar", "empty", "null", "space", "quad", "enspace", "emspace", "charspace", "nbsp", "crlf", "obeyspaces", "obeylines", "obeytabs", "obeypages", "obeyedspace", "obeyedline", "obeyedtab", "obeyedpage", "normalspace", "naturalspace", "controlspace", "normalspaces", "ignoretabs", "ignorelines", "ignorepages", "ignoreeofs", "setcontrolspaces", "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", "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", "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", "doloopovermatch", "doloopovermatched", "doloopoverlist", "newconstant", "setnewconstant", "setconstant", "setconstantvalue", "newconditional", "settrue", "setfalse", "settruevalue", "setfalsevalue", "setconditional", "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", "aligncontentleft", "aligncontentmiddle", "aligncontentright", "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", "ctxluamatch", "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", "freezeparagraphproperties", "defrostparagraphproperties", "setparagraphfreezing", "forgetparagraphfreezing", "updateparagraphproperties", "updateparagraphpenalties", "updateparagraphdemerits", "updateparagraphshapes", "updateparagraphlines", "lastlinewidth", "assumelongusagecs", "Umathbotaccent", "Umathtopaccent", "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", "dohyphencollapsing", "nohyphencollapsing", "compounddiscretionary", "Ucheckedstartdisplaymath", "Ucheckedstopdisplaymath", "break", "nobreak", "allowbreak", "goodbreak", "nospace", "nospacing", "dospacing", "naturalhbox", "naturalvbox", "naturalvtop", "naturalhpack", "naturalvpack", "naturaltpack", "reversehbox", "reversevbox", "reversevtop", "reversehpack", "reversevpack", "reversetpack", "hcontainer", "vcontainer", "tcontainer", "frule", "compoundhyphenpenalty", "start", "stop", "unsupportedcs", "openout", "closeout", "write", "openin", "closein", "read", "readline", "readfromterminal", "boxlines", "boxline", "setboxline", "copyboxline", "boxlinewd", "boxlineht", "boxlinedp", "boxlinenw", "boxlinenh", "boxlinend", "boxlinels", "boxliners", "boxlinelh", "boxlinerh", "boxlinelp", "boxlinerp", "boxlinein", "boxrangewd", "boxrangeht", "boxrangedp", "bitwiseset", "bitwiseand", "bitwiseor", "bitwisexor", "bitwisenot", "bitwisenil", "ifbitwiseand", "bitwise", "bitwiseshift", "bitwiseflip", "textdir", "linedir", "pardir", "boxdir", "prelistbox", "postlistbox", "prelistcopy", "postlistcopy", "setprelistbox", "setpostlistbox", "noligaturing", "nokerning", "noexpansion", "noprotrusion", "noleftkerning", "noleftligaturing", "norightkerning", "norightligaturing", "noitaliccorrection", "futureletnexttoken", "defbackslashbreak", "letbackslashbreak", "pushoverloadmode", "popoverloadmode", "pushrunstate", "poprunstate", "suggestedalias", "showboxhere", "discoptioncodestring", "flagcodestring", "frozenparcodestring", "glyphoptioncodestring", "groupcodestring", "hyphenationcodestring", "mathcontrolcodestring", "mathflattencodestring", "normalizecodestring", "parcontextcodestring", "newlocalcount", "newlocaldimen", "newlocalskip", "newlocalmuskip", "newlocaltoks", "newlocalbox", "newlocalwrite", "newlocalread", "setnewlocalcount", "setnewlocaldimen", "setnewlocalskip", "setnewlocalmuskip", "setnewlocaltoks", "setnewlocalbox", "ifexpression" },
 }
\ No newline at end of file
diff --git a/context/data/scite/context/lexers/scite-context-lexer.lua b/context/data/scite/context/lexers/scite-context-lexer.lua
index 121bfd249..7eafa1c31 100644
--- a/context/data/scite/context/lexers/scite-context-lexer.lua
+++ b/context/data/scite/context/lexers/scite-context-lexer.lua
@@ -442,6 +442,8 @@ do
         utfchar(0x200B), -- zerowidthspace
         utfchar(0x202F), -- narrownobreakspace
         utfchar(0x205F), -- math thinspace
+        utfchar(0x200C), -- zwnj
+        utfchar(0x200D), -- zwj
     }
 
     -- now we can make:
diff --git a/context/data/scite/context/scite-context-data-context.properties b/context/data/scite/context/scite-context-data-context.properties
index 6655f34ed..40b4ffae8 100644
--- a/context/data/scite/context/scite-context-data-context.properties
+++ b/context/data/scite/context/scite-context-data-context.properties
@@ -52,56 +52,56 @@ vboxifcode xifcode eofifcode trueifcode falseifcode \
 caseifcode definedifcode csnameifcode fontcharifcode overrulemathcontrolcode \
 underrulemathcontrolcode radicalrulemathcontrolcode fractionrulemathcontrolcode accentskewhalfmathcontrolcode accentskewapplymathcontrolcode \
 accentitalickernmathcontrolcode delimiteritalickernmathcontrolcode noorditalickernmathcontrolcode charitalicwidthmathcontrolcode charitalicnoreboxmathcontrolcode \
-boxednoitalickernmathcontrolcode nostaircasekernmathcontrolcode textitalickernmathcontrolcode noscriptitalickernmathcontrolcode noligaturingglyphoptioncode \
-nokerningglyphoptioncode noexpansionglyphoptioncode noprotrusionglyphoptioncode noleftkerningglyphoptioncode noleftligaturingglyphoptioncode \
-norightkerningglyphoptioncode norightligaturingglyphoptioncode noitaliccorrectionglyphoptioncode normalparcontextcode vmodeparcontextcode \
-vboxparcontextcode vtopparcontextcode vcenterparcontextcode vadjustparcontextcode insertparcontextcode \
-outputparcontextcode alignparcontextcode noalignparcontextcode spanparcontextcode resetparcontextcode \
-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 normalhyphenationcode automatichyphenationcode \
-explicithyphenationcode syllablehyphenationcode uppercasehyphenationcode collapsehyphenationcode compoundhyphenationcode \
-strictstarthyphenationcode strictendhyphenationcode automaticpenaltyhyphenationcode explicitpenaltyhyphenationcode permitgluehyphenationcode \
-permitallhyphenationcode permitmathreplacehyphenationcode forcecheckhyphenationcode lazyligatureshyphenationcode forcehandlerhyphenationcode \
-feedbackcompoundhyphenationcode ignoreboundshyphenationcode partialhyphenationcode completehyphenationcode normalizelinenormalizecode \
-parindentskipnormalizecode swaphangindentnormalizecode swapparsshapenormalizecode breakafterdirnormalizecode removemarginkernsnormalizecode \
-clipwidthnormalizecode flattendiscretionariesnormalizecode discardzerotabskipsnormalizecode noligaturingglyphoptioncode nokerningglyphoptioncode \
-noleftligatureglyphoptioncode noleftkernglyphoptioncode norightligatureglyphoptioncode norightkernglyphoptioncode noexpansionglyphoptioncode \
-noprotrusionglyphoptioncode noitaliccorrectionglyphoptioncode nokerningcode noligaturingcode frozenflagcode \
-tolerantflagcode protectedflagcode primitiveflagcode permanentflagcode noalignedflagcode \
-immutableflagcode mutableflagcode globalflagcode overloadedflagcode immediateflagcode \
-conditionalflagcode valueflagcode instanceflagcode ordmathflattencode binmathflattencode \
-relmathflattencode punctmathflattencode innermathflattencode normalworddiscoptioncode preworddiscoptioncode \
-postworddiscoptioncode continuewhenlmtxmode 
+boxednoitalickernmathcontrolcode nostaircasekernmathcontrolcode textitalickernmathcontrolcode noscriptitalickernmathcontrolcode italicshapekernmathcontrolcode \
+noligaturingglyphoptioncode nokerningglyphoptioncode noexpansionglyphoptioncode noprotrusionglyphoptioncode noleftkerningglyphoptioncode \
+noleftligaturingglyphoptioncode norightkerningglyphoptioncode norightligaturingglyphoptioncode noitaliccorrectionglyphoptioncode normalparcontextcode \
+vmodeparcontextcode vboxparcontextcode vtopparcontextcode vcenterparcontextcode vadjustparcontextcode \
+insertparcontextcode outputparcontextcode alignparcontextcode noalignparcontextcode spanparcontextcode \
+resetparcontextcode 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 normalhyphenationcode \
+automatichyphenationcode explicithyphenationcode syllablehyphenationcode uppercasehyphenationcode collapsehyphenationcode \
+compoundhyphenationcode strictstarthyphenationcode strictendhyphenationcode automaticpenaltyhyphenationcode explicitpenaltyhyphenationcode \
+permitgluehyphenationcode permitallhyphenationcode permitmathreplacehyphenationcode forcecheckhyphenationcode lazyligatureshyphenationcode \
+forcehandlerhyphenationcode feedbackcompoundhyphenationcode ignoreboundshyphenationcode partialhyphenationcode completehyphenationcode \
+normalizelinenormalizecode parindentskipnormalizecode swaphangindentnormalizecode swapparsshapenormalizecode breakafterdirnormalizecode \
+removemarginkernsnormalizecode clipwidthnormalizecode flattendiscretionariesnormalizecode discardzerotabskipsnormalizecode noligaturingglyphoptioncode \
+nokerningglyphoptioncode noleftligatureglyphoptioncode noleftkernglyphoptioncode norightligatureglyphoptioncode norightkernglyphoptioncode \
+noexpansionglyphoptioncode noprotrusionglyphoptioncode noitaliccorrectionglyphoptioncode nokerningcode noligaturingcode \
+frozenflagcode tolerantflagcode protectedflagcode primitiveflagcode permanentflagcode \
+noalignedflagcode immutableflagcode mutableflagcode globalflagcode overloadedflagcode \
+immediateflagcode conditionalflagcode valueflagcode instanceflagcode ordmathflattencode \
+binmathflattencode relmathflattencode punctmathflattencode innermathflattencode normalworddiscoptioncode \
+preworddiscoptioncode postworddiscoptioncode continuewhenlmtxmode 
 
 keywordclass.context.helpers=\
 startsetups stopsetups startxmlsetups stopxmlsetups \
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 c475101a1..e2a8c0b5c 100644
--- a/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json
+++ b/context/data/vscode/extensions/context/syntaxes/context-syntax-tex.json
@@ -69,7 +69,7 @@
    "name" : "context.comment.comment.tex"
   },
   "constant" : {
-   "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|widowpenaltyfrozenparcode|whatsitnodecode|vtopparcontextcode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeparcontextcode|vmodeifcode|vlistnodecode|vcenterparcontextcode|vcentergroupcode|vboxparcontextcode|vboxifcode|vboxgroupcode|valueflagcode|vadjustparcontextcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|uppercasehyphenationcode|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|underrulemathcontrolcode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tolerantflagcode|tolerancefrozenparcode|tildeasciicode|threeperemspace|thousandpoint|textitalickernmathcontrolcode|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|syllablehyphenationcode|swapparsshapenormalizecode|swaphangindentnormalizecode|superscriptcatcode|subscriptcatcode|strictstarthyphenationcode|strictendhyphenationcode|stretchfrozenparcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|statuswrite|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|splitoffgroupcode|splitkeepgroupcode|spanparcontextcode|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|skipfrozenparcode|sixperemspace|singlequoteasciicode|simplegroupcode|shapingpenaltiesfrozenparcode|shapefrozenparcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlncatcodes|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbracketasciicode|rightbraceasciicode|resetparcontextcode|removemarginkernsnormalizecode|relmathflattencode|radicalrulemathcontrolcode|questionmarkasciicode|pushmode|punctuationspace|punctmathflattencode|prtcatcodes|protrudefrozenparcode|protectedflagcode|project|product|primitiveflagcode|primeasciicode|preworddiscoptioncode|preventmode|presetdocument|prerollrun|preautomigrationcode|preamblegroupcode|postworddiscoptioncode|postautomigrationcode|popmode|points|plustwohundred|plustwo|plustwentythousand|plustwelve|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseleven|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|permitmathreplacehyphenationcode|permitgluehyphenationcode|permitallhyphenationcode|permanentflagcode|periodasciicode|percentasciicode|penaltynodecode|pdftexengine|partialhyphenationcode|parindentskipnormalizecode|parfillrightskip|parfillleftskip|parfillfrozenparcode|parametercatcode|overrulemathcontrolcode|overloadedflagcode|outputparcontextcode|outputnewlinechar|outputgroupcode|othercatcode|orphanpenaltyfrozenparcode|ordmathflattencode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|nostaircasekernmathcontrolcode|noscriptitalickernmathcontrolcode|normalworddiscoptioncode|normalparcontextcode|normalpagebox|normalizelinenormalizecode|normalhyphenationcode|norightligaturingglyphoptioncode|norightligatureglyphoptioncode|norightkerningglyphoptioncode|norightkernglyphoptioncode|noprotrusionglyphoptioncode|noprotrusionglyphoptioncode|noorditalickernmathcontrolcode|nonstopmodecode|nonbreakablespace|noligaturingglyphoptioncode|noligaturingglyphoptioncode|noligaturingcode|noleftligaturingglyphoptioncode|noleftligatureglyphoptioncode|noleftkerningglyphoptioncode|noleftkernglyphoptioncode|nokerningglyphoptioncode|nokerningglyphoptioncode|nokerningcode|noitaliccorrectionglyphoptioncode|noitaliccorrectionglyphoptioncode|noexpansionglyphoptioncode|noexpansionglyphoptioncode|nobreakspace|noalignparcontextcode|noaligngroupcode|noalignedflagcode|nilcatcodes|newlineasciicode|narrownobreakspace|mutableflagcode|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|markautomigrationcode|luatexengine|luastringsep|luacatcodes|lrm|loosenessfrozenparcode|localboxgroupcode|linepenaltyfrozenparcode|linefrozenparcode|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbracketasciicode|leftbraceasciicode|lazyligatureshyphenationcode|lastlinefrozenparcode|kernnodecode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|instanceflagcode|insertparcontextcode|insertnodecode|insertgroupcode|insertautomigrationcode|innermathflattencode|innerifcode|inicatcodes|indentfrozenparcode|immutableflagcode|immediateflagcode|ignorecatcode|ignoreboundshyphenationcode|ideographicspace|ideographichalffillspace|hyphenationfrozenparcode|hyphenasciicode|hsizefrozenparcode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|hangfrozenparcode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalflagcode|globalenablemode|globaldisablemode|frozenflagcode|fractionrulemathcontrolcode|fourperemspace|forwardslashasciicode|formfeedasciicode|forcehandlerhyphenationcode|forcecheckhyphenationcode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|flattendiscretionariesnormalizecode|fiveperemspace|finrowgroupcode|figurespace|feedbackcompoundhyphenationcode|falseifcode|extraspace|explicitpenaltyhyphenationcode|explicithyphenationcode|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|displaypenaltyfrozenparcode|discretionarynodecode|discretionarygroupcode|discretionarygroupcode|discardzerotabskipsnormalizecode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|demeritsfrozenparcode|delimiteritalickernmathcontrolcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continuewhenlmtxmode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalflagcode|conditionalfalse|compoundhyphenationcode|component|completehyphenationcode|commentcatcode|commentasciicode|commaasciicode|colonasciicode|collapsehyphenationcode|clubpenaltyfrozenparcode|clipwidthnormalizecode|circumflexasciicode|charnodecode|charitalicwidthmathcontrolcode|charitalicnoreboxmathcontrolcode|charifcode|catifcode|caseifcode|brokenpenaltyfrozenparcode|breakafterdirnormalizecode|breakablethinspace|boxednoitalickernmathcontrolcode|bottomlevelgroupcode|binmathflattencode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|automaticpenaltyhyphenationcode|automatichyphenationcode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alsosimplegroupcode|allfrozenparcode|alignsetgroupcode|alignparcontextcode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustfrozenparcode|adjustedhboxgroupcode|adjustautomigrationcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|accentskewhalfmathcontrolcode|accentskewapplymathcontrolcode|accentitalickernmathcontrolcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])",
+   "match" : "\u005C\u005C(zwnj|zwj|zerowidthspace|zerowidthnonjoiner|zerowidthnobreakspace|zerowidthjoiner|zeroskip|zeropoint|zeromuskip|zerocount|xmlcatcodes|xifcode|xetexengine|wildcardsymbol|widowpenaltyfrozenparcode|whatsitnodecode|vtopparcontextcode|vtopgroupcode|vrbcatcodes|voidifcode|voidbox|vmodeparcontextcode|vmodeifcode|vlistnodecode|vcenterparcontextcode|vcentergroupcode|vboxparcontextcode|vboxifcode|vboxgroupcode|valueflagcode|vadjustparcontextcode|vadjustgroupcode|usetexmodule|usemodule|useluamodule|uprotationangle|uppercasehyphenationcode|unsetnodecode|unknownengine|unexpandeddocumentvariable|underscoreasciicode|underrulemathcontrolcode|undefined|typescripttwo|typescriptthree|typescriptone|txtcatcodes|twoperemspace|trueifcode|tpbcatcodes|tpacatcodes|tolerantflagcode|tolerancefrozenparcode|tildeasciicode|threeperemspace|thousandpoint|textitalickernmathcontrolcode|texengineversion|texenginename|texenginefunctionality|texengine|texcatcodes|tabasciicode|syllablehyphenationcode|swapparsshapenormalizecode|swaphangindentnormalizecode|superscriptcatcode|subscriptcatcode|strictstarthyphenationcode|strictendhyphenationcode|stretchfrozenparcode|stoptext|stopproject|stopproduct|stopnotmode|stopnotext|stopnotallmodes|stopmodule|stopmodeset|stopmodeset|stopmode|stopmkivmode|stoplmtxmode|stopenvironment|stopdocument|stopcomponent|stopallmodes|stopTEXpage|statuswrite|starttext|startproject|startproduct|startnotmode|startnotext|startnotallmodes|startmodule|startmodeset|startmodeset|startmode|startmkivmode|startlmtxmode|startenvironment|startdocument|startcomponent|startallmodes|startTEXpage|splitoffgroupcode|splitkeepgroupcode|spanparcontextcode|spacecatcode|spaceasciicode|softhyphen|smallskipamount|slantperpoint|skipfrozenparcode|sixperemspace|singlequoteasciicode|simplegroupcode|shapingpenaltiesfrozenparcode|shapefrozenparcode|setupmodule|setupdocument|semisimplegroupcode|scrollmodecode|scaledpoint|rulenodecode|rlncatcodes|rlm|righttoleftmark|rightrotationangle|rightparentasciicode|rightbracketasciicode|rightbraceasciicode|resetparcontextcode|removemarginkernsnormalizecode|relmathflattencode|radicalrulemathcontrolcode|questionmarkasciicode|pushmode|punctuationspace|punctmathflattencode|prtcatcodes|protrudefrozenparcode|protectedflagcode|project|product|primitiveflagcode|primeasciicode|preworddiscoptioncode|preventmode|presetdocument|prerollrun|preautomigrationcode|preamblegroupcode|postworddiscoptioncode|postautomigrationcode|popmode|points|plustwohundred|plustwo|plustwentythousand|plustwelve|plusthree|plusthousand|plustenthousand|plusten|plussixteen|plussix|plusseven|plusonehundred|plusone|plusnine|plushundred|plusfour|plusfivehundred|plusfive|plusfifty|pluseleven|pluseight|pluscxxviii|pluscxxvii|pluscclvi|pluscclv|permitmathreplacehyphenationcode|permitgluehyphenationcode|permitallhyphenationcode|permanentflagcode|periodasciicode|percentasciicode|penaltynodecode|pdftexengine|partialhyphenationcode|parindentskipnormalizecode|parfillrightskip|parfillleftskip|parfillfrozenparcode|parametercatcode|overrulemathcontrolcode|overloadedflagcode|outputparcontextcode|outputnewlinechar|outputgroupcode|othercatcode|orphanpenaltyfrozenparcode|ordmathflattencode|optionalspace|onepoint|onemuskip|onebasepoint|oddifcode|numifcode|notcatcodes|nostaircasekernmathcontrolcode|noscriptitalickernmathcontrolcode|normalworddiscoptioncode|normalparcontextcode|normalpagebox|normalizelinenormalizecode|normalhyphenationcode|norightligaturingglyphoptioncode|norightligatureglyphoptioncode|norightkerningglyphoptioncode|norightkernglyphoptioncode|noprotrusionglyphoptioncode|noprotrusionglyphoptioncode|noorditalickernmathcontrolcode|nonstopmodecode|nonbreakablespace|noligaturingglyphoptioncode|noligaturingglyphoptioncode|noligaturingcode|noleftligaturingglyphoptioncode|noleftligatureglyphoptioncode|noleftkerningglyphoptioncode|noleftkernglyphoptioncode|nokerningglyphoptioncode|nokerningglyphoptioncode|nokerningcode|noitaliccorrectionglyphoptioncode|noitaliccorrectionglyphoptioncode|noexpansionglyphoptioncode|noexpansionglyphoptioncode|nobreakspace|noalignparcontextcode|noaligngroupcode|noalignedflagcode|nilcatcodes|newlineasciicode|narrownobreakspace|mutableflagcode|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|markautomigrationcode|luatexengine|luastringsep|luacatcodes|lrm|loosenessfrozenparcode|localboxgroupcode|linepenaltyfrozenparcode|linefrozenparcode|ligaturenodecode|lettercatcode|lessthanasciicode|lefttorightmark|leftrotationangle|leftparentasciicode|leftbracketasciicode|leftbraceasciicode|lazyligatureshyphenationcode|lastlinefrozenparcode|kernnodecode|italicshapekernmathcontrolcode|invalidcatcode|interwordstretch|interwordspace|interwordshrink|instanceflagcode|insertparcontextcode|insertnodecode|insertgroupcode|insertautomigrationcode|innermathflattencode|innerifcode|inicatcodes|indentfrozenparcode|immutableflagcode|immediateflagcode|ignorecatcode|ignoreboundshyphenationcode|ideographicspace|ideographichalffillspace|hyphenationfrozenparcode|hyphenasciicode|hsizefrozenparcode|hmodeifcode|hlistnodecode|hboxifcode|hboxgroupcode|hashasciicode|hangfrozenparcode|halfpoint|halfapoint|hairspace|gluenodecode|globalpreventmode|globalflagcode|globalenablemode|globaldisablemode|frozenflagcode|fractionrulemathcontrolcode|fourperemspace|forwardslashasciicode|formfeedasciicode|forcehandlerhyphenationcode|forcecheckhyphenationcode|fontslantperpoint|fontinterwordstretch|fontinterwordspace|fontinterwordshrink|fontextraspace|fontexheight|fontemwidth|fontcharifcode|fmtversion|fmtname|flattendiscretionariesnormalizecode|fiveperemspace|finrowgroupcode|figurespace|feedbackcompoundhyphenationcode|falseifcode|extraspace|explicitpenaltyhyphenationcode|explicithyphenationcode|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|displaypenaltyfrozenparcode|discretionarynodecode|discretionarygroupcode|discretionarygroupcode|discardzerotabskipsnormalizecode|disablemode|directionrighttoleft|directionlefttoright|dimifcode|demeritsfrozenparcode|delimiteritalickernmathcontrolcode|delasciicode|definemode|definedifcode|currentmoduleparameter|ctxcatcodes|ctdcatcodes|csnameifcode|continuewhenlmtxmode|continueifinputfile|contextversion|contextmark|contextlmtxmode|contextformat|constantnumberargument|constantnumber|constantemptyargument|constantdimenargument|constantdimen|conditionaltrue|conditionalflagcode|conditionalfalse|compoundhyphenationcode|component|completehyphenationcode|commentcatcode|commentasciicode|commaasciicode|colonasciicode|collapsehyphenationcode|clubpenaltyfrozenparcode|clipwidthnormalizecode|circumflexasciicode|charnodecode|charitalicwidthmathcontrolcode|charitalicnoreboxmathcontrolcode|charifcode|catifcode|caseifcode|brokenpenaltyfrozenparcode|breakafterdirnormalizecode|breakablethinspace|boxednoitalickernmathcontrolcode|bottomlevelgroupcode|binmathflattencode|bigskipamount|bidirlo|bidirle|bidipop|bidilro|bidilre|bgroup|begingroupcatcode|batchmodecode|barasciicode|backslashasciicode|automaticpenaltyhyphenationcode|automatichyphenationcode|attributeunsetvalue|atsignasciicode|asciispacechar|ampersandasciicode|alsosimplegroupcode|allfrozenparcode|alignsetgroupcode|alignparcontextcode|alignmentcatcode|aligngroupcode|adjustnodecode|adjustfrozenparcode|adjustedhboxgroupcode|adjustautomigrationcode|activetabtoken|activemathcharcode|activeformfeedtoken|activeendoflinetoken|activecatcode|activecatcode|accentskewhalfmathcontrolcode|accentskewapplymathcontrolcode|accentitalickernmathcontrolcode|Ux|Umathaccents|!!es|!!bs)(?=[^a-zA-Z])",
    "name" : "context.constant.commands.constant.tex"
   },
   "csname" : {
diff --git a/scripts/context/lua/mtxrun.lua b/scripts/context/lua/mtxrun.lua
index b889e9705..0cd2167ec 100644
--- a/scripts/context/lua/mtxrun.lua
+++ b/scripts/context/lua/mtxrun.lua
@@ -9251,7 +9251,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 24815, stripped down to: 16424
+-- original size: 24844, stripped down to: 16451
 
 if not modules then modules={} end modules ['util-prs']={
  version=1.001,
@@ -9719,7 +9719,7 @@ local function ranger(first,last,n,action)
   action(first)
  end
 end
-local cardinal=lpegpatterns.cardinal/tonumber
+local cardinal=(lpegpatterns.hexadecimal+lpegpatterns.cardinal)/tonumber
 local spacers=lpegpatterns.spacer^0
 local endofstring=lpegpatterns.endofstring
 local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1
@@ -25948,8 +25948,8 @@ end -- of closure
 
 -- used libraries    : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua libs-ini.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 1029781
--- stripped bytes    : 405637
+-- original bytes    : 1029810
+-- stripped bytes    : 405639
 
 -- end library merge
 
diff --git a/scripts/context/stubs/mswin/mtxrun.lua b/scripts/context/stubs/mswin/mtxrun.lua
index b889e9705..0cd2167ec 100644
--- a/scripts/context/stubs/mswin/mtxrun.lua
+++ b/scripts/context/stubs/mswin/mtxrun.lua
@@ -9251,7 +9251,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 24815, stripped down to: 16424
+-- original size: 24844, stripped down to: 16451
 
 if not modules then modules={} end modules ['util-prs']={
  version=1.001,
@@ -9719,7 +9719,7 @@ local function ranger(first,last,n,action)
   action(first)
  end
 end
-local cardinal=lpegpatterns.cardinal/tonumber
+local cardinal=(lpegpatterns.hexadecimal+lpegpatterns.cardinal)/tonumber
 local spacers=lpegpatterns.spacer^0
 local endofstring=lpegpatterns.endofstring
 local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1
@@ -25948,8 +25948,8 @@ end -- of closure
 
 -- used libraries    : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua libs-ini.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 1029781
--- stripped bytes    : 405637
+-- original bytes    : 1029810
+-- stripped bytes    : 405639
 
 -- end library merge
 
diff --git a/scripts/context/stubs/unix/mtxrun b/scripts/context/stubs/unix/mtxrun
index b889e9705..0cd2167ec 100644
--- a/scripts/context/stubs/unix/mtxrun
+++ b/scripts/context/stubs/unix/mtxrun
@@ -9251,7 +9251,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 24815, stripped down to: 16424
+-- original size: 24844, stripped down to: 16451
 
 if not modules then modules={} end modules ['util-prs']={
  version=1.001,
@@ -9719,7 +9719,7 @@ local function ranger(first,last,n,action)
   action(first)
  end
 end
-local cardinal=lpegpatterns.cardinal/tonumber
+local cardinal=(lpegpatterns.hexadecimal+lpegpatterns.cardinal)/tonumber
 local spacers=lpegpatterns.spacer^0
 local endofstring=lpegpatterns.endofstring
 local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1
@@ -25948,8 +25948,8 @@ end -- of closure
 
 -- used libraries    : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua libs-ini.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 1029781
--- stripped bytes    : 405637
+-- original bytes    : 1029810
+-- stripped bytes    : 405639
 
 -- end library merge
 
diff --git a/scripts/context/stubs/win64/mtxrun.lua b/scripts/context/stubs/win64/mtxrun.lua
index b889e9705..0cd2167ec 100644
--- a/scripts/context/stubs/win64/mtxrun.lua
+++ b/scripts/context/stubs/win64/mtxrun.lua
@@ -9251,7 +9251,7 @@ do -- create closure to overcome 200 locals limit
 
 package.loaded["util-prs"] = package.loaded["util-prs"] or true
 
--- original size: 24815, stripped down to: 16424
+-- original size: 24844, stripped down to: 16451
 
 if not modules then modules={} end modules ['util-prs']={
  version=1.001,
@@ -9719,7 +9719,7 @@ local function ranger(first,last,n,action)
   action(first)
  end
 end
-local cardinal=lpegpatterns.cardinal/tonumber
+local cardinal=(lpegpatterns.hexadecimal+lpegpatterns.cardinal)/tonumber
 local spacers=lpegpatterns.spacer^0
 local endofstring=lpegpatterns.endofstring
 local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1
@@ -25948,8 +25948,8 @@ end -- of closure
 
 -- used libraries    : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua libs-ini.lua luat-sta.lua luat-fmt.lua
 -- skipped libraries : -
--- original bytes    : 1029781
--- stripped bytes    : 405637
+-- original bytes    : 1029810
+-- stripped bytes    : 405639
 
 -- end library merge
 
diff --git a/tex/context/base/mkii/cont-new.mkii b/tex/context/base/mkii/cont-new.mkii
index c52d4b787..ca7fb128c 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{2021.11.11 19:18}
+\newcontextversion{2021.11.13 20:33}
 
 %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 ea17f2dc5..1bf322dc6 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{2021.11.11 19:18}
+\edef\contextversion{2021.11.13 20:33}
 
 %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 ce96e7c81..3925a3fce 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{2021.11.11 19:18}
+\newcontextversion{2021.11.13 20:33}
 
 %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 c2178e2b1..cd2f873c5 100644
--- a/tex/context/base/mkiv/context.mkiv
+++ b/tex/context/base/mkiv/context.mkiv
@@ -49,7 +49,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2021.11.11 19:18}
+\edef\contextversion{2021.11.13 20:33}
 
 %D Kind of special:
 
diff --git a/tex/context/base/mkiv/mult-low.lua b/tex/context/base/mkiv/mult-low.lua
index 307cf3c68..b2a3f9b3c 100644
--- a/tex/context/base/mkiv/mult-low.lua
+++ b/tex/context/base/mkiv/mult-low.lua
@@ -105,7 +105,7 @@ return {
         "accentskewhalfmathcontrolcode", "accentskewapplymathcontrolcode", "accentitalickernmathcontrolcode",
         "delimiteritalickernmathcontrolcode", "noorditalickernmathcontrolcode", "charitalicwidthmathcontrolcode",
         "charitalicnoreboxmathcontrolcode", "boxednoitalickernmathcontrolcode", "nostaircasekernmathcontrolcode",
-        "textitalickernmathcontrolcode", "noscriptitalickernmathcontrolcode",
+        "textitalickernmathcontrolcode", "noscriptitalickernmathcontrolcode", "italicshapekernmathcontrolcode",
         --
         "noligaturingglyphoptioncode", "nokerningglyphoptioncode", "noexpansionglyphoptioncode", "noprotrusionglyphoptioncode",
         "noleftkerningglyphoptioncode", "noleftligaturingglyphoptioncode", "norightkerningglyphoptioncode", "norightligaturingglyphoptioncode",
diff --git a/tex/context/base/mkiv/status-files.pdf b/tex/context/base/mkiv/status-files.pdf
index 28cb886a3..5124f23cf 100644
--- a/tex/context/base/mkiv/status-files.pdf
+++ 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
index 19c31285c..896b8856a 100644
--- a/tex/context/base/mkiv/status-lua.pdf
+++ b/tex/context/base/mkiv/status-lua.pdf
diff --git a/tex/context/base/mkiv/strc-syn.lua b/tex/context/base/mkiv/strc-syn.lua
index f8b78b940..8933baea1 100644
--- a/tex/context/base/mkiv/strc-syn.lua
+++ b/tex/context/base/mkiv/strc-syn.lua
@@ -29,6 +29,12 @@ local splitter     = sorters.splitters.utf
 synonyms.collected = collected
 synonyms.tobesaved = tobesaved
 
+local progressions = { } -- false=not_yet_shown  true=shown
+
+local variables    = interfaces.variables
+local v_all        = variables.all
+local v_current    = variables.current
+
 local function initializer()
     collected = synonyms.collected
     tobesaved = synonyms.tobesaved
@@ -86,12 +92,6 @@ function synonyms.register(class,kind,spec)
     local tag        = definition.tag or ""
     data.metadata.kind = kind -- runtime, not saved in format (yet)
     if not hash[tag] then
---         if definition.used == nil then
---             definition.used = false
---         end
---         if definition.shown == nil then
---             definition.shown = false
---         end
         local entries = data.entries
         entries[#entries+1] = spec
         hash[tag] = spec
@@ -130,20 +130,52 @@ function synonyms.isshown(class,tag)
     return okay and okay.definition.shown or false
 end
 
-function synonyms.resetused(class)
+local function resetused(class)
     for tag, data in next, tobesaved[class].hash do
---         data.definition.used = false
         data.definition.used = nil
     end
 end
 
-function synonyms.resetshown(class)
+local function resetshown(class)
     for tag, data in next, tobesaved[class].hash do
---         data.definition.shown = false
         data.definition.shown = nil
     end
 end
 
+local function resetlist(class)
+    for tag, data in next, tobesaved[class].hash do
+        data.definition.list = nil
+    end
+end
+
+local function resetall(class)
+    for tag, data in next, tobesaved[class].hash do
+        local definition = data.definition
+        definition.used  = nil
+        definition.shown = nil
+        definition.list  = nil
+    end
+end
+
+synonyms.resetused  = resetused
+synonyms.resetshown = resetshown
+synonyms.resetlist  = resetlist
+synonyms.resetall   = resetall
+
+function synonyms.reset(class,what)
+    if what == "progress" then
+        progressions = { }
+    elseif what == "used" then
+        resetused(class)
+    elseif what == "shown" then
+        resetshown(class)
+    elseif what == "list" then
+        resetlist(class)
+    else
+        resetall(class)
+    end
+end
+
 function synonyms.synonym(class,tag)
     local data = tobesaved[class]
     local okay = data.hash[tag]
@@ -153,6 +185,9 @@ function synonyms.synonym(class,tag)
         definition.list = true
         context(definition.synonym)
     end
+    if progressions[tag] == nil then
+        progressions[tag] = false -- not yet shown
+    end
 end
 
 function synonyms.meaning(class,tag)
@@ -169,10 +204,10 @@ end
 synonyms.compare = sorters.comparers.basic -- (a,b)
 
 function synonyms.filter(data,options)
-    local result  = { }
-    local entries = data.entries
-    local all     = options and options.criterium == interfaces.variables.all
-    if all then
+    local result    = { }
+    local entries   = data.entries
+    local criterium = options and options.criterium
+    if criterium == v_all then
         for i=1,#entries do
             result[i] = entries[i]
         end
@@ -181,9 +216,17 @@ function synonyms.filter(data,options)
             local entry      = entries[i]
             local definition = entry.definition
             if definition.list then
-                result[#result+1] = entry
+                local tag  = definition.tag
+                local done = progressions[tag]
+                if done == false then
+                    result[#result+1] = entry
+                    progressions[tag] = true
+                end
             end
         end
+        if criterium == v_current then
+            progressions = { }
+        end
     end
     data.result = result
 end
@@ -282,8 +325,10 @@ implement { name = "registerusedsynonym",  actions = synonyms.registerused,  arg
 implement { name = "registershownsynonym", actions = synonyms.registershown, arguments = "2 strings" }
 implement { name = "synonymmeaning",       actions = synonyms.meaning,       arguments = "2 strings" }
 implement { name = "synonymname",          actions = synonyms.synonym,       arguments = "2 strings" }
-implement { name = "resetusedsynonyms",    actions = synonyms.resetused,     arguments = "string" }
-implement { name = "resetshownsynonyms",   actions = synonyms.resetshown,    arguments = "string" }
+--        { name = "resetusedsynonyms",    actions = resetused,              arguments = "string" }
+--        { name = "resetshownsynonyms",   actions = resetshown,             arguments = "string" }
+--        { name = "resetlistsynonyms",    actions = resetlist,              arguments = "string" }
+implement { name = "resetsynonyms",        actions = synonyms.reset,         arguments = "2 strings" }
 
 implement {
     name      = "doifelsesynonymused",
diff --git a/tex/context/base/mkiv/strc-syn.mkiv b/tex/context/base/mkiv/strc-syn.mkiv
index cdede1d0d..e93141bde 100644
--- a/tex/context/base/mkiv/strc-syn.mkiv
+++ b/tex/context/base/mkiv/strc-syn.mkiv
@@ -101,6 +101,31 @@
 %D
 %D The lists are constructions (like descriptions are) and can be set up
 %D likewise.
+%D
+%D You can show the currently accessed entries as follows:
+%D
+%D \starttyping
+%D \startchapter[title=One]
+%D     test \FIRST\ test test \THIRD\ test \blank
+%D     \placelistofsynonyms[myabbreviation]
+%D     \resetsynonymsprogress[myabbreviation] % reset state
+%D \stopchapter
+%D
+%D \startchapter[title=Two]
+%D     test \FIRST\ test test \SECOND\ test \blank
+%D     \placelistofsynonyms[myabbreviation][criterium=current]
+%D     \resetsynonymsprogress[myabbreviation] % reset state
+%D \stopchapter
+%D
+%D \startchapter[title=Three]
+%D     test test test test test test \blank
+%D     \placelistofsynonyms[myabbreviation][criterium=current] % also reset state
+%D \stopchapter
+%D
+%D \startchapter[title=All]
+%D     \placelistofsynonyms[myabbreviation][criterium=all]
+%D \stopchapter
+%D \stoptyping
 
 % todo: add 'define only' option to descriptions, then add sorting (also based on key)
 % and call to definition -> replaces this module
@@ -319,8 +344,11 @@
 \unexpanded\def\currentsynonymmeaning      {\clf_synonymmeaning      {\currentsimplelist}{\currentsynonymtag}}
 \unexpanded\def\doifelsecurrentsynonymused {\clf_doifelsesynonymused {\currentsimplelist}{\currentsynonymtag}}
 \unexpanded\def\doifelsecurrentsynonymshown{\clf_doifelsesynonymshown{\currentsimplelist}{\currentsynonymtag}}
-\unexpanded\def\resetusedsynonyms      [#1]{\clf_resetusedsynonyms   {#1}}
-\unexpanded\def\resetshownsynonyms     [#1]{\clf_resetshownsynonyms  {#1}}
+\unexpanded\def\resetusedsynonyms      [#1]{\clf_resetsynonyms{#1}{used}}
+\unexpanded\def\resetshownsynonyms     [#1]{\clf_resetsynonyms{#1}{shown}}
+\unexpanded\def\resetlistsynonyms      [#1]{\clf_resetsynonyms{#1}{list}}
+\unexpanded\def\resetsynonyms          [#1]{\clf_resetsynonyms{#1}{all}}
+\unexpanded\def\resetsynonymsprogress  [#1]{\clf_resetsynonyms{#1}{progress}}
 
 \let\rawsynonymname   \clf_synonymname
 \let\rawsynonymmeaning\clf_synonymmeaning
diff --git a/tex/context/base/mkiv/util-prs.lua b/tex/context/base/mkiv/util-prs.lua
index f74bc3b12..438fa78bd 100644
--- a/tex/context/base/mkiv/util-prs.lua
+++ b/tex/context/base/mkiv/util-prs.lua
@@ -643,7 +643,7 @@ local function ranger(first,last,n,action)
     end
 end
 
-local cardinal    = lpegpatterns.cardinal / tonumber
+local cardinal    = (lpegpatterns.hexadecimal + lpegpatterns.cardinal) / tonumber
 local spacers     = lpegpatterns.spacer^0
 local endofstring = lpegpatterns.endofstring
 
diff --git a/tex/context/base/mkxl/cont-new.mkxl b/tex/context/base/mkxl/cont-new.mkxl
index 722ac0f09..a3b960aa0 100644
--- a/tex/context/base/mkxl/cont-new.mkxl
+++ b/tex/context/base/mkxl/cont-new.mkxl
@@ -13,7 +13,7 @@
 
 % \normalend % uncomment this to get the real base runtime
 
-\newcontextversion{2021.11.11 19:18}
+\newcontextversion{2021.11.13 20:33}
 
 %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/mkxl/context.mkxl b/tex/context/base/mkxl/context.mkxl
index 8d42981fc..b52808856 100644
--- a/tex/context/base/mkxl/context.mkxl
+++ b/tex/context/base/mkxl/context.mkxl
@@ -29,7 +29,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \immutable\edef\contextformat {\jobname}
-\immutable\edef\contextversion{2021.11.11 19:18}
+\immutable\edef\contextversion{2021.11.13 20:33}
 
 %overloadmode 1 % check frozen / warning
 %overloadmode 2 % check frozen / error
diff --git a/tex/context/base/mkxl/driv-shp.lmt b/tex/context/base/mkxl/driv-shp.lmt
index ace259954..5e3bfd703 100644
--- a/tex/context/base/mkxl/driv-shp.lmt
+++ b/tex/context/base/mkxl/driv-shp.lmt
@@ -165,10 +165,13 @@ local flush_character do
         local saved_r = pos_r
                 pos_r = lefttoright_code
 
-        local data  = fontdata[font] -- hm, so why pass data
-        local fnt   = font
-        local fonts = data.fonts
-        local siz   = (data.parameters.factor or 1)/65536
+        local xoffset = data.xoffset
+        local yoffset = data.yoffset
+
+        local data    = fontdata[font] -- offsets etc
+        local fnt     = font
+        local fonts   = data.fonts
+        local siz     = (data.parameters.factor or 1)/65536
 
         -- An alternative where we (here) locally define handlers like this:
         --
@@ -182,6 +185,16 @@ local flush_character do
         -- work as expected (so we end up in a nesting loop). I remember hitting this somewhat
         -- unexpected feature before.
 
+if xoffset and xoffset ~= 0 then
+    if factor ~= 0 then
+        xoffset = xoffset + xoffset * factor / refactored -- expansion
+    end
+    pos_h = pos_h + xoffset * sx
+end
+if yoffset and yoffset ~= 0 then
+    pos_v = pos_v + yoffset * sy
+end
+
         -- we assume resolved fonts: id mandate but maybe also size
 
         local function flushchar(fnt,chr,f,e) -- can't be moved out of the function due to binding locals
@@ -528,14 +541,6 @@ local flush_character do
         else
             -- kind of messy that we do orientation here and offsets elsewhere .. this might change
             local orientation = data.orientation -- 0 (none), 1, 2, 3 or 4 (none)
---             local x = data.xoffset
---             local y = data.yoffset
---             if x then
---                 pos_h = pos_h + x * sx
---             end
---             if y then
---                 pos_v = pos_v + y * sy
---             end
             if orientation and (orientation == 1 or orientation == 3) then
                 -- we can get weird charactersbox tracing here
                 pushorientation(orientation,pos_h,pos_v)
diff --git a/tex/context/base/mkxl/good-mth.lmt b/tex/context/base/mkxl/good-mth.lmt
index 033b2cb88..0c8311efe 100644
--- a/tex/context/base/mkxl/good-mth.lmt
+++ b/tex/context/base/mkxl/good-mth.lmt
@@ -26,11 +26,9 @@ local trace_defining     = false  trackers.register("math.defining",   function(
 local report_math        = logs.reporter("mathematics","initializing")
 
 local nuts               = nodes.nuts
-
 local setlink            = nuts.setlink
 
 local nodepool           = nuts.pool
-
 local new_kern           = nodepool.kern
 local new_glyph          = nodepool.glyph
 local new_hlist          = nodepool.hlist
@@ -38,174 +36,6 @@ local new_vlist          = nodepool.vlist
 
 local insertnodeafter    = nuts.insertafter
 
-local helpers            = fonts.helpers
-local upcommand          = helpers.commands.up
-local rightcommand       = helpers.commands.right
-local charcommand        = helpers.commands.char
-local prependcommands    = helpers.prependcommands
-
--- experiment, we have to load the definitions immediately as they precede
--- the definition so they need to be initialized in the typescript
-
-local function withscriptcode(tfmdata,unicode,data,action)
-    if type(unicode) == "string" then
-        local p, u = match(unicode,"^(.-):(.-)$")
-        if u then
-            u = tonumber(u)
-            if u then
-                local slots = fonts.helpers.mathscriptslots(tfmdata,u)
-                if slots then
-                    if p == "*" then
-                        action(u,data)
-                        if type(slots) == "number" then
-                            action(slots,data)
-                        else
-                            for i=1,#slots do
-                                action(slots[i],data)
-                            end
-                        end
-                    else
-                        p = tonumber(p)
-                        if p then
-                            if type(slots) == "number" then
-                                action(slots,data)
-                            else
-                                action(slots[p],data)
-                            end
-                        end
-                    end
-                end
-            end
-        end
-    else
-        action(unicode,data)
-    end
-end
-
-local function finalize(tfmdata,feature,value,...)
---     if tfmdata.mathparameters then -- funny, cambria text has this
-    local goodies = tfmdata.goodies
-    if goodies then
-        local virtualized = mathematics.virtualized
-        for i=1,#goodies do
-            local goodie = goodies[i]
-            local mathematics = goodie.mathematics
-            local dimensions  = mathematics and mathematics.dimensions
-            if dimensions then
-                if trace_defining then
-                    report_math("overloading dimensions in %a @ %p",tfmdata.properties.fullname,tfmdata.parameters.size)
-                end
-                local characters   = tfmdata.characters
-                local descriptions = tfmdata.descriptions
-                local parameters   = tfmdata.parameters
-                local factor       = parameters.factor
-                local hfactor      = parameters.hfactor
-                local vfactor      = parameters.vfactor
-                --
-                tfmdata.type                   = "virtual"
-                tfmdata.properties.virtualized = true
-                --
-                local function overloadone(unicode,data)
-                    local character = characters[unicode]
-                    if not character then
-                        local c = virtualized[unicode]
-                        if c then
-                            character = characters[c]
-                        end
-                    end
-                    if character then
-                        local width  = data.width
-                        local height = data.height
-                        local depth  = data.depth
-                        if trace_defining and (width or height or depth) then
-                            report_math("overloading dimensions of %C, width %p, height %p, depth %p",
-                                unicode,width or 0,height or 0,depth or 0)
-                        end
-                        if width  then character.width  = width  * hfactor end
-                        if height then character.height = height * vfactor end
-                        if depth  then character.depth  = depth  * vfactor end
-                        --
-                        local xoffset = data.xoffset
-                        local yoffset = data.yoffset
-                        if xoffset == "llx" then
-                            local d = descriptions[unicode]
-                            if d then
-                                xoffset         = - d.boundingbox[1]
-                                character.width = character.width + xoffset * hfactor
-                                xoffset         = rightcommand[xoffset]
-                            else
-                                xoffset = nil
-                            end
-                        elseif xoffset and xoffset ~= 0 then
-                            xoffset = rightcommand[xoffset * hfactor]
-                        else
-                            xoffset = nil
-                        end
-                        if yoffset and yoffset ~= 0 then
-                            yoffset = upcommand[yoffset * vfactor]
-                        else
-                            yoffset = nil
-                        end
-                        if xoffset or yoffset then
-                            local commands = character.commands
-                            if commands then
-                                prependcommands(commands,yoffset,xoffset)
-                            else
--- character.commands = { { "offset", xoffset or 0, yoffset or 0, unicode } }
-                                local slot = charcommand[unicode]
-                                if xoffset and yoffset then
-                                    character.commands = { xoffset, yoffset, slot }
-                                elseif xoffset then
-                                    character.commands = { xoffset, slot }
-                                else
-                                    character.commands = { yoffset, slot }
-                                end
-                            end
-                        end
-                    elseif trace_defining then
-                        report_math("no overloading dimensions of %C, not in font",unicode)
-                    end
-                end
-                local function overload(dimensions)
-                    for unicode, data in next, dimensions do
-                        withscriptcode(tfmdata,unicode,data,overloadone)
-                    end
-                end
-                if value == nil then
-                    value = { "default" }
-                end
-                if value == "all" or value == true then
-                    for name, value in next, dimensions do
-                        overload(value)
-                    end
-                else
-                    if type(value) == "string" then
-                        value = utilities.parsers.settings_to_array(value)
-                    end
-                    if type(value) == "table" then
-                        for i=1,#value do
-                            local d = dimensions[value[i]]
-                            if d then
-                                overload(d)
-                            end
-                        end
-                    end
-                end
-            end
-        end
-    end
-end
-
-registerotffeature {
-    name         = "mathdimensions",
-    description  = "manipulate math dimensions",
- -- default      = true,
-    manipulators = {
-        base = finalize,
-        node = finalize,
-    }
-}
-
 local function initialize(goodies)
     local mathgoodies = goodies.mathematics
     if mathgoodies then
@@ -233,122 +63,6 @@ end
 
 fontgoodies.register("mathematics", initialize)
 
--- local enabled = false   directives.register("fontgoodies.mathkerning",function(v) enabled = v end)
-
-local function initialize(tfmdata)
---     if enabled and tfmdata.mathparameters then -- funny, cambria text has this
-    if tfmdata.mathparameters then -- funny, cambria text has this
-        local goodies = tfmdata.goodies
-        if goodies then
-            local characters = tfmdata.characters
-            if characters[0x1D44E] then -- 119886
-                -- we have at least an italic a
-                for i=1,#goodies do
-                    local mathgoodies = goodies[i].mathematics
-                    if mathgoodies then
-                        local kerns = mathgoodies.kerns
-                        if kerns then
-                            local function kernone(unicode,data)
-                                local chardata = characters[unicode]
-                                if chardata and (not chardata.mathkerns or data.force) then
-                                    chardata.mathkerns = data
-                                end
-                            end
-                            for unicode, data in next, kerns do
-                                withscriptcode(tfmdata,unicode,data,kernone)
-                            end
-                            return
-                        end
-                    end
-                end
-            else
-                return -- no proper math font anyway
-            end
-        end
-    end
-end
-
-registerotffeature {
-    name         = "mathkerns",
-    description  = "math kerns",
- -- default      = true,
-    initializers = {
-        base = initialize,
-        node = initialize,
-    }
-}
-
--- math italics (not really needed)
---
--- it would be nice to have a \noitalics\font option
-
-local function initialize(tfmdata)
-    local goodies = tfmdata.goodies
-    if goodies then
-        local shared = tfmdata.shared
-        for i=1,#goodies do
-            local mathgoodies = goodies[i].mathematics
-            if mathgoodies then
-                local mathitalics = mathgoodies.italics
-                if mathitalics then
-                    local properties = tfmdata.properties
-                    if properties.setitalics then
-                        mathitalics = mathitalics[file.nameonly(properties.name)] or mathitalics
-                        if mathitalics then
-                            if trace_goodies then
-                                report_goodies("loading mathitalics for font %a",properties.name)
-                            end
-                            local corrections   = mathitalics.corrections
-                            local defaultfactor = mathitalics.defaultfactor
-                         -- properties.mathitalic_defaultfactor = defaultfactor -- we inherit outer one anyway (name will change)
-                            if corrections then
-                                fontgoodies.registerpostprocessor(tfmdata, function(tfmdata) -- this is another tfmdata (a copy)
-                                    -- better make a helper so that we have less code being defined
-                                    local properties = tfmdata.properties
-                                    local parameters = tfmdata.parameters
-                                    local characters = tfmdata.characters
-                                    properties.mathitalic_defaultfactor = defaultfactor
-                                    properties.mathitalic_defaultvalue  = defaultfactor * parameters.quad
-                                    if trace_goodies then
-                                        report_goodies("assigning mathitalics for font %a",properties.name)
-                                    end
-                                    local quad    = parameters.quad
-                                    local hfactor = parameters.hfactor
-                                    for k, v in next, corrections do
-                                        local c = characters[k]
-                                        if c then
-                                            if v > -1 and v < 1 then
-                                                c.italic = v * quad
-                                            else
-                                                c.italic = v * hfactor
-                                            end
-                                        else
-                                            report_goodies("invalid mathitalics entry %U for font %a",k,properties.name)
-                                        end
-                                    end
-                                end)
-                            end
-                            return -- maybe not as these can accumulate
-                        end
-                    end
-                end
-            end
-        end
-    end
-end
-
-registerotffeature {
-    name         = "mathitalics",
-    description  = "additional math italic corrections",
- -- default      = true,
-    initializers = {
-        base = initialize,
-        node = initialize,
-    }
-}
-
--- fontgoodies.register("mathitalics", initialize)
-
 local function mathradicalaction(n,h,v,font,mchar,echar)
     local characters = fontcharacters[font]
     local mchardata  = characters[mchar]
@@ -471,3 +185,284 @@ registerotffeature {
         node = initialize,
     }
 }
+
+-- local helpers            = fonts.helpers
+-- local upcommand          = helpers.commands.up
+-- local rightcommand       = helpers.commands.right
+-- local charcommand        = helpers.commands.char
+-- local prependcommands    = helpers.prependcommands
+--
+-- -- experiment, we have to load the definitions immediately as they precede
+-- -- the definition so they need to be initialized in the typescript
+--
+-- local function withscriptcode(tfmdata,unicode,data,action)
+--     if type(unicode) == "string" then
+--         local p, u = match(unicode,"^(.-):(.-)$")
+--         if u then
+--             u = tonumber(u)
+--             if u then
+--                 local slots = helpers.mathscriptslots(tfmdata,u)
+--                 if slots then
+--                     if p == "*" then
+--                         action(u,data)
+--                         if type(slots) == "number" then
+--                             action(slots,data)
+--                         else
+--                             for i=1,#slots do
+--                                 action(slots[i],data)
+--                             end
+--                         end
+--                     else
+--                         p = tonumber(p)
+--                         if p then
+--                             if type(slots) == "number" then
+--                                 action(slots,data)
+--                             else
+--                                 action(slots[p],data)
+--                             end
+--                         end
+--                     end
+--                 end
+--             end
+--         end
+--     else
+--         action(unicode,data)
+--     end
+-- end
+--
+-- local function finalize(tfmdata,feature,value,...)
+-- --     if tfmdata.mathparameters then -- funny, cambria text has this
+--     local goodies = tfmdata.goodies
+--     if goodies then
+--         local virtualized = mathematics.virtualized
+--         for i=1,#goodies do
+--             local goodie = goodies[i]
+--             local mathematics = goodie.mathematics
+--             local dimensions  = mathematics and mathematics.dimensions
+--             if dimensions then
+--                 if trace_defining then
+--                     report_math("overloading dimensions in %a @ %p",tfmdata.properties.fullname,tfmdata.parameters.size)
+--                 end
+--                 local characters   = tfmdata.characters
+--                 local descriptions = tfmdata.descriptions
+--                 local parameters   = tfmdata.parameters
+--                 local factor       = parameters.factor
+--                 local hfactor      = parameters.hfactor
+--                 local vfactor      = parameters.vfactor
+--                 --
+--                 tfmdata.type                   = "virtual"
+--                 tfmdata.properties.virtualized = true
+--                 --
+--                 local function overloadone(unicode,data)
+--                     local character = characters[unicode]
+--                     if not character then
+--                         local c = virtualized[unicode]
+--                         if c then
+--                             character = characters[c]
+--                         end
+--                     end
+--                     if character then
+--                         local width  = data.width
+--                         local height = data.height
+--                         local depth  = data.depth
+--                         if trace_defining and (width or height or depth) then
+--                             report_math("overloading dimensions of %C, width %p, height %p, depth %p",
+--                                 unicode,width or 0,height or 0,depth or 0)
+--                         end
+--                         if width  then character.width  = width  * hfactor end
+--                         if height then character.height = height * vfactor end
+--                         if depth  then character.depth  = depth  * vfactor end
+--                         --
+--                         local xoffset = data.xoffset
+--                         local yoffset = data.yoffset
+--                         if xoffset == "llx" then
+--                             local d = descriptions[unicode]
+--                             if d then
+--                                 xoffset         = - d.boundingbox[1]
+--                                 character.width = character.width + xoffset * hfactor
+--                                 xoffset         = rightcommand[xoffset]
+--                             else
+--                                 xoffset = nil
+--                             end
+--                         elseif xoffset and xoffset ~= 0 then
+--                             xoffset = rightcommand[xoffset * hfactor]
+--                         else
+--                             xoffset = nil
+--                         end
+--                         if yoffset and yoffset ~= 0 then
+--                             yoffset = upcommand[yoffset * vfactor]
+--                         else
+--                             yoffset = nil
+--                         end
+--                         if xoffset or yoffset then
+--                             local commands = character.commands
+--                             if commands then
+--                                 prependcommands(commands,yoffset,xoffset)
+--                             else
+-- -- character.commands = { { "offset", xoffset or 0, yoffset or 0, unicode } }
+--                                 local slot = charcommand[unicode]
+--                                 if xoffset and yoffset then
+--                                     character.commands = { xoffset, yoffset, slot }
+--                                 elseif xoffset then
+--                                     character.commands = { xoffset, slot }
+--                                 else
+--                                     character.commands = { yoffset, slot }
+--                                 end
+--                             end
+--                         end
+--                     elseif trace_defining then
+--                         report_math("no overloading dimensions of %C, not in font",unicode)
+--                     end
+--                 end
+--                 local function overload(dimensions)
+--                     for unicode, data in next, dimensions do
+--                         withscriptcode(tfmdata,unicode,data,overloadone)
+--                     end
+--                 end
+--                 if value == nil then
+--                     value = { "default" }
+--                 end
+--                 if value == "all" or value == true then
+--                     for name, value in next, dimensions do
+--                         overload(value)
+--                     end
+--                 else
+--                     if type(value) == "string" then
+--                         value = utilities.parsers.settings_to_array(value)
+--                     end
+--                     if type(value) == "table" then
+--                         for i=1,#value do
+--                             local d = dimensions[value[i]]
+--                             if d then
+--                                 overload(d)
+--                             end
+--                         end
+--                     end
+--                 end
+--             end
+--         end
+--     end
+-- end
+--
+-- registerotffeature {
+--     name         = "mathdimensions",
+--     description  = "manipulate math dimensions",
+--  -- default      = true,
+--     manipulators = {
+--         base = finalize,
+--         node = finalize,
+--     }
+-- }
+
+-- local enabled = false   directives.register("fontgoodies.mathkerning",function(v) enabled = v end)
+--
+-- local function initialize(tfmdata)
+--     if tfmdata.mathparameters then -- funny, cambria text has this
+--         local goodies = tfmdata.goodies
+--         if goodies then
+--             local characters = tfmdata.characters
+--             if characters[0x1D44E] then -- 119886
+--                 -- we have at least an italic a
+--                 for i=1,#goodies do
+--                     local mathgoodies = goodies[i].mathematics
+--                     if mathgoodies then
+--                         local kerns = mathgoodies.kerns
+--                         if kerns then
+--                             local function kernone(unicode,data)
+--                                 local chardata = characters[unicode]
+--                                 if chardata and (not chardata.mathkerns or data.force) then
+--                                     chardata.mathkerns = data
+--                                 end
+--                             end
+--                             for unicode, data in next, kerns do
+--                                 withscriptcode(tfmdata,unicode,data,kernone)
+--                             end
+--                             return
+--                         end
+--                     end
+--                 end
+--             else
+--                 return -- no proper math font anyway
+--             end
+--         end
+--     end
+-- end
+--
+-- registerotffeature {
+--     name         = "mathkerns",
+--     description  = "math kerns",
+--  -- default      = true,
+--     initializers = {
+--         base = initialize,
+--         node = initialize,
+--     }
+-- }
+
+-- -- math italics (not really needed)
+--
+-- local function initialize(tfmdata)
+--     local goodies = tfmdata.goodies
+--     if goodies then
+--         local shared = tfmdata.shared
+--         for i=1,#goodies do
+--             local mathgoodies = goodies[i].mathematics
+--             if mathgoodies then
+--                 local mathitalics = mathgoodies.italics
+--                 if mathitalics then
+--                     local properties = tfmdata.properties
+--                     if properties.setitalics then
+--                         mathitalics = mathitalics[file.nameonly(properties.name)] or mathitalics
+--                         if mathitalics then
+--                             if trace_goodies then
+--                                 report_goodies("loading mathitalics for font %a",properties.name)
+--                             end
+--                             local corrections   = mathitalics.corrections
+--                             local defaultfactor = mathitalics.defaultfactor
+--                          -- properties.mathitalic_defaultfactor = defaultfactor -- we inherit outer one anyway (name will change)
+--                             if corrections then
+--                                 fontgoodies.registerpostprocessor(tfmdata, function(tfmdata) -- this is another tfmdata (a copy)
+--                                     -- better make a helper so that we have less code being defined
+--                                     local properties = tfmdata.properties
+--                                     local parameters = tfmdata.parameters
+--                                     local characters = tfmdata.characters
+--                                     properties.mathitalic_defaultfactor = defaultfactor
+--                                     properties.mathitalic_defaultvalue  = defaultfactor * parameters.quad
+--                                     if trace_goodies then
+--                                         report_goodies("assigning mathitalics for font %a",properties.name)
+--                                     end
+--                                     local quad    = parameters.quad
+--                                     local hfactor = parameters.hfactor
+--                                     for k, v in next, corrections do
+--                                         local c = characters[k]
+--                                         if c then
+--                                             if v > -1 and v < 1 then
+--                                                 c.italic = v * quad
+--                                             else
+--                                                 c.italic = v * hfactor
+--                                             end
+--                                         else
+--                                             report_goodies("invalid mathitalics entry %U for font %a",k,properties.name)
+--                                         end
+--                                     end
+--                                 end)
+--                             end
+--                             return -- maybe not as these can accumulate
+--                         end
+--                     end
+--                 end
+--             end
+--         end
+--     end
+-- end
+--
+-- registerotffeature {
+--     name         = "mathitalics",
+--     description  = "additional math italic corrections",
+--  -- default      = true,
+--     initializers = {
+--         base = initialize,
+--         node = initialize,
+--     }
+-- }
+--
+-- -- fontgoodies.register("mathitalics", initialize)
diff --git a/tex/context/base/mkxl/lpdf-lmt.lmt b/tex/context/base/mkxl/lpdf-lmt.lmt
index 463cc8352..6e6812d81 100644
--- a/tex/context/base/mkxl/lpdf-lmt.lmt
+++ b/tex/context/base/mkxl/lpdf-lmt.lmt
@@ -260,7 +260,7 @@ function flushers.updatefontstate(font)
     end
 end
 
--- helpers
+-- helpers (maybe in collapse mode we have to go %.9N)
 
 local f_cm = formatters["%.6N %.6N %.6N %.6N %.6N %.6N cm"]
 local f_tm = formatters["%.6N %.6N %.6N %.6N %.6N %.6N Tm"]
@@ -570,11 +570,15 @@ do
         tj_delta   = 0
         cw         = 0
         --
+        -- print("setup font",where)
+        --
         fs = fontparameters.size * bpfactor
         if collapse then
             local sc = fs / 10
             if f then
-                sc = sc * f
+--                 sc = sc * f
+sx = sx * f
+sy = sy * f
             end
             -- kind of special:
             if format == "opentype" or format == "type1" then
@@ -587,7 +591,9 @@ do
             tmry = tmry * sc
         else
             if f then
-                fs = fs * f
+--                 fs = fs * f
+sx = sx * f
+sy = sy * f
             end
             -- kind of special:
             if format == "opentype" or format == "type1" then
@@ -697,22 +703,18 @@ do
     flushers.character = function(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
         if sx ~= f_x_scale or sy ~= f_y_scale or need_tf or font ~= f_cur or f_pdf ~= f_pdf_cur or fs ~= fs_cur or mode == "page" then
 --         if sx ~= f_x_scale or sy ~= f_y_scale or need_tf or font ~= f_cur or f_pdf ~= f_pdf_cur or fs ~= fs_cur then
--- print("f",1)
             pdf_goto_textmode()
             setup_fontparameters(1,font,factor,f,e,sx,sy) -- too often due to page
             set_font()
 --         elseif mode == "page" then
--- print("f",4)
 --             pdf_goto_textmode()
             set_font()
         elseif cur_f ~= f then -- when ok move up (maybe no longer needed)
--- print("f",2)
             pdf_goto_textmode()
             setup_fontparameters(2,font,factor,f,e,sx,sy)
             set_font()
      -- elseif cur_tmrx ~= tmrx or cur_factor ~= factor or cur_f ~= f or cur_e ~= e then
         elseif cur_tmrx ~= tmrx or cur_factor ~= factor or cur_e ~= e then
--- print("f",3)
             setup_fontparameters(3,font,factor,f,e,sx,sy)
             need_tm = true
         end
diff --git a/tex/context/base/mkxl/math-act.lmt b/tex/context/base/mkxl/math-act.lmt
index 56730f2eb..afaf79593 100644
--- a/tex/context/base/mkxl/math-act.lmt
+++ b/tex/context/base/mkxl/math-act.lmt
@@ -12,11 +12,14 @@ if not modules then modules = { } end modules ['math-act'] = {
 local type, next = type, next
 local fastcopy, insert, remove = table.fastcopy, table.insert, table.remove
 local formatters = string.formatters
+local byte = string.byte
 
 local trace_defining   = false  trackers.register("math.defining",   function(v) trace_defining   = v end)
 local trace_collecting = false  trackers.register("math.collecting", function(v) trace_collecting = v end)
+local trace_tweaking   = false  trackers.register("math.tweaks",     function(v) trace_tweaking   = v end)
 
 local report_math      = logs.reporter("mathematics","initializing")
+local report_mathtweak = logs.reporter("mathematics","tweak")
 
 local context          = context
 local commands         = commands
@@ -46,7 +49,7 @@ appendgroup("mathparameters","before") -- user
 appendgroup("mathparameters","system") -- private
 appendgroup("mathparameters","after" ) -- user
 
-function fonts.constructors.assignmathparameters(original,target)
+function fonts.constructors.assignmathparameters(original,target) -- wrong way around
     local runner = mathfontparameteractions.runner
     if runner then
         runner(original,target)
@@ -186,62 +189,320 @@ end
 local mathtweaks   = { }
 mathematics.tweaks = mathtweaks
 
-local function adapt(targetcharacters,originalcharacters,k,v,compact,n)
-    local character = targetcharacters[k]
-    if character then
-        local width     = character.width
-        local italic    = character.italic
-        local offsetfactor = v[1] or 1
-        local widthfactor  = v[2] or 1
-        local italicfactor = v[3] or 1
-        if width then
-            character.advance = width -- so advance is oldwidth
-            character.xoffset = offsetfactor * width
-            character.width   = widthfactor  * width
-        end
-        if italic then
-            character.italic  = italicfactor * italic
+local function report_tweak(fmt,target,original,...)
+    local metadata   = original.shared.rawdata.metadata
+    local parameters = target.parameters
+    report_mathtweak(
+        "%a, size %p, math size %i, %s",
+        metadata and metadata.fontname or "unknown",
+        parameters.size or 655360,
+        parameters.mathsize or 1,
+        string.formatters[fmt](...)
+    )
+end
+
+do
+
+    local stepper = utilities.parsers.stepper
+
+    local function adapt(target,original,targetcharacters,originalcharacters,k,v,compact,n)
+        local character = targetcharacters[k]
+        if character then
+            local width     = character.width
+            local italic    = character.italic
+            local offsetfactor = v[1] or 1
+            local widthfactor  = v[2] or 1
+            local italicfactor = v[3] or 1
+            if width then
+                character.advance = width -- so advance is oldwidth
+                character.xoffset = offsetfactor * width
+                character.width   = widthfactor  * width
+            end
+            if italic then
+                character.italic  = italicfactor * italic
+            elseif width and italicfactor ~= 1 then
+                character.italic  = italicfactor * width
+            end
+            if trace_tweaking then
+                report_tweak("adapting dimensions of %U ",target,original,k)
+            end
+            local smaller = originalcharacters[k].smaller
+            if compact and smaller and smaller ~= k then
+                adapt(target,original,targetcharacters,originalcharacters,smaller,v,compact,n+1)
+            end
+        else
+            report_math("no character %U",k)
         end
-        local smaller = originalcharacters[k].smaller
-        if compact and smaller and smaller ~= k then
-            adapt(targetcharacters,originalcharacters,smaller,v,compact,n+1)
+    end
+
+    function mathtweaks.dimensions(target,original,parameters)
+        local list = parameters.list
+        if list then
+            local targetcharacters   = target.characters
+            local originalcharacters = original.characters
+            local compact = target.parameters.textscale and true or false
+            for k, v in next, list do
+                local t = type(k)
+                if t == "number" then
+                    adapt(target,original,targetcharacters,originalcharacters,k,v,compact,1)
+                elseif t == "string" then
+                    stepper(k,function(n) adapt(target,original,targetcharacters,originalcharacters,n,v,compact,1) end)
+                end
+            end
         end
-    else
-        report_math("no character %U",k)
     end
+
 end
 
-function mathtweaks.dimensions(target,original,list)
-    local targetcharacters   = target.characters
-    local originalcharacters = original.characters
-    local compact = target.parameters.textscale and true or false
-    for k, v in next, list do
-        adapt(targetcharacters,originalcharacters,k,v,compact,1)
+do
+
+    local list = {
+        { 0x2032, true,            },
+        { 0x2033, true,  0x2032, 2 },
+        { 0x2034, true,  0x2032, 3 },
+        { 0x2057, true,  0x2032, 4 },
+        { 0x2035, false,           },
+        { 0x2036, false, 0x2035, 2 },
+        { 0x2037, false, 0x2035, 3 },
+    }
+
+    local function fix(target,original,characters,factor,scale,newheight,code,mandate)
+        local char  = characters[code]
+        if char then
+            local oldheight = scale * char.height
+            char.yoffset = newheight - oldheight
+            char.height  = newheight
+            if scale ~= 1 then
+                char.width    = scale * char.width
+                char.commands = {
+                    { "slot", 0, code, scale }
+                }
+            end
+            if trace_tweaking then
+                report_tweak("fixing prime %U ",target,original,code)
+            end
+            local small = char.smaller
+            if small then
+                fix(target,original,characters,factor,scale,newheight,small,false)
+            end
+        elseif mandate then
+            report_math("missing %U prime in font %a",code,original.properties.fullname)
+        end
+    end
+
+    function mathtweaks.fixprimes(target,original,parameters)
+        local characters = target.characters
+        local factor     = parameters.factor or 0.85
+        local scale      = parameters.scale  or 1
+        local newheight  = factor * target.mathparameters.AccentBaseHeight
+        for i=1,#list do
+            local entry = list[i]
+            fix(target,original,characters,factor,scale,newheight,entry[1],entry[2])
+        end
+    end
+
+    local function fake(target,original,characters,factor,n,single,multiple)
+        local csingle   = characters[single]
+        local cmultiple = characters[multiple]
+        local width     = csingle.width
+        local hoffset   = factor * width
+        cmultiple.width    = width + (n - 1) * hoffset
+        cmultiple.commands = {
+                      { "offset",           0, 0, single },
+                      { "offset",     hoffset, 0, single },
+            n > 2 and { "offset", 2 * hoffset, 0, single } or nil,
+            n > 3 and { "offset", 3 * hoffset, 0, single } or nil,
+        }
+        if trace_tweaking then
+            report_tweak("faking %U with %i primes",target,original,multiple,n)
+        end
+        local ssingle   = csingle.smaller
+        local smultiple = cmultiple.smaller
+        if ssingle and smultiple then
+            fake(target,original,characters,factor,n,ssingle,smultiple)
+        else
+            --weird font
+        end
+    end
+
+    function mathtweaks.fakeprimes(target,original,parameters)
+        local characters = target.characters
+        local factor     = parameters.factor or .75
+        for i=1,#list do
+            local entry = list[i]
+            local n     = entry[4]
+            if n then
+                fake(target,original,characters,factor,n,entry[3],entry[1])
+            end
+        end
     end
+
 end
 
-function mathtweaks.action(target,original,action,...)
+function mathtweaks.action(target,original,parameters)
+    local action = parameters.action
     if type(action) == "function" then
-        action(target,original,...)
+        action(target,original,parameters)
+    end
+end
+
+do
+
+    local list = {
+        { 0x00A0, "s", 1         }, -- nbsp
+        { 0x2000, "q", 1/2       }, -- enquad
+        { 0x2001, "q", 1         }, -- emquad
+        { 0x2002, "q", 1/2       }, -- enspace
+        { 0x2003, "q", 1         }, -- emspace
+        { 0x2004, "q", 1/3       }, -- threeperemspace
+        { 0x2005, "q", 1/4       }, -- fourperemspace
+        { 0x2006, "q", 1/6       }, -- sixperemspace
+        { 0x2007, "c", byte('0') }, -- figurespace
+        { 0x2008, "c", byte('.') }, -- punctuationspace
+        { 0x2009, "q", 1/8       }, -- breakablethinspace
+        { 0x200A, "q", 1/8       }, -- hairspace
+        { 0x200B, "q", 0         }, -- zerowidthspace
+        { 0x202F, "q", 1/8       }, -- narrownobreakspace
+        { 0x205F, "s", 1/2       }, -- math thinspace
+    }
+
+    function mathtweaks.checkspacing(target,original,parameters)
+        local characters = target.characters
+        local parameters = target.parameters
+        for i=1,#list do
+            local entry   = list[i]
+            local unicode = entry[1]
+            local data    = characters[unicode]
+            if not data then
+                local method   = entry[2]
+                local fraction = entry[3]
+                local width    = 0
+                if how == "c" then
+                    width = characters[fraction].width  -- char
+                elseif how == "s" then
+                    width = fraction * parameters.space -- space
+                else
+                    width = fraction * parameters.quad  -- quad
+                end
+                if trace_tweaking then
+                    report_tweak("setting width of %U to %p",target,original,unicode,width)
+                end
+                characters[unicode] = { width = width }
+            end
+        end
     end
+
 end
 
+do
 
-local reported = { }
+    local list = {
+        0x221A,
+    }
 
-function mathtweaks.version(target,original,expected)
-    local metadata = original.shared.rawdata.metadata
-    if metadata then
-        local version = metadata.version
-        if version then
-            local fontname = metadata.fontname
-         -- version = tonumber(string.match(version,"%d+.%d+"))
-            if not reported[fontname] and version ~= expected then
-                report_math("tweaking %a, version %a found, version %a expected",fontname,version,expected)
-                reported[fontname] = true
+    local function fix(target,original,characters,unicode)
+        local data = characters[unicode]
+        if data then
+            local height = data.height or 0
+            local depth  = data.depth or 0
+            if depth > height then
+                if trace_tweaking then
+                    report_tweak("swapping height and depth of radical %U",target,original,unicode)
+                end
+                data.height  = depth
+                data.depth   = height
+                data.yoffset = depth - height
             end
+            local small = data.smaller
+            if small then
+                fix(target,original,characters,small)
+            end
+        end
+    end
+
+    function mathtweaks.fixradicals(target,original,parameters)
+        local characters = target.characters
+        for i=1,#list do
+            local unicode = list[i]
+            fix(target,original,characters,unicode)
         end
     end
+
+end
+
+do
+
+    -- For Ton, who needs the high minus and plus for calculator signs in Dutch
+    -- school math books.
+
+    local list = {
+        { 0x207A, 0x002B, true  },
+        { 0x207B, 0x2212, true  },
+        { 0x208A, 0x002B, false },
+        { 0x208B, 0x2212, false },
+    }
+
+    local function add(target,original,characters,unicode,template,super,baseheight,scale)
+        if not characters[unicode] then
+            local origdata = characters[template]
+            if origdata then
+                local width  = scale * (origdata.width  or 0)
+                local height = scale * (origdata.height or 0)
+                local depth  = scale * (origdata.depth  or 0)
+                local half   = - (height + depth) / 2
+                local offset = super and baseheight/2 or -baseheight/4
+                characters[unicode] = {
+                    width    = width,
+                    height   = height + offset,
+                    depth    = depth  - offset,
+                    yoffset  = offset,
+                    unicode  = unicode,
+                 -- index    = origdata.index,
+                 -- scale    = scale,
+                    commands = {
+                     -- { "up", yoffset },
+                        { "slot", 0, template, scale }
+                    },
+                }
+                if trace_tweaking then
+                    report_tweak("adding script %U scaled %0.3f",target,original,unicode,scale)
+                end
+                -- no need for smaller
+            end
+        end
+    end
+
+    function mathtweaks.addscripts(target,original,parameters)
+        local characters = target.characters
+        local baseheight = target.mathparameters.AccentBaseHeight
+        local scaledown  = parameters.scale or target.mathparameters.ScriptScriptPercentScaleDown / 100
+        for i=1,#list do
+            local entry = list[i]
+            if entry then
+                add(target,original,characters,entry[1],entry[2],entry[3],baseheight,scaledown)
+            end
+        end
+    end
+
+end
+
+do
+
+    function mathtweaks.version(target,original,parameters)
+        local metadata = original.shared.rawdata.metadata
+        if metadata then
+            local version = metadata.version
+            if version then
+                local expected = parameters.expected
+             -- version = tonumber(string.match(version,"%d+.%d+"))
+                if version ~= expected then
+                    report_tweak("version %a found, version %a expected",target,original,version,expected)
+                    reported[fontname] = true
+                end
+            end
+        end
+    end
+
 end
 
 local function applytweaks(when,target,original)
@@ -260,16 +521,10 @@ local function applytweaks(when,target,original)
                     for i=1,#tweaks do
                         local tweak  = tweaks[i]
                         local tvalue = type(tweak)
-                        if tvalue == "function" then
-                            -- old
-                            tweak(target,original)
-                        elseif tvalue == "table" then
-                            local command = tweak[1]
-                            if type(command) == "string" then
-                                local action = mathtweaks[command]
-                                if action then
-                                    action(target,original,table.unpack(tweak,2))
-                                end
+                        if type(tweak) == "table" then
+                            local action = mathtweaks[tweak.tweak or ""]
+                            if action then
+                                action(target,original,tweak)
                             end
                         end
                     end
diff --git a/tex/context/base/mkxl/math-fbk.lmt b/tex/context/base/mkxl/math-fbk.lmt
index 4c58a2bb6..32ad909f7 100644
--- a/tex/context/base/mkxl/math-fbk.lmt
+++ b/tex/context/base/mkxl/math-fbk.lmt
@@ -7,7 +7,8 @@ if not modules then modules = { } end modules ['math-fbk'] = {
 }
 
 -- This will partly be redone and go via definitions in goodies where we can share
--- some across fonts.
+-- some across fonts. That makes most sense for those patches that might need some
+-- finetuning depending on the font.
 
 local next, type = next, type
 
@@ -169,71 +170,6 @@ end
 
 -- a few examples:
 
-local function reference(index,char)
-    if index then
-        return { "slot", index, char }
-    else
-        return charcommand[char]
-    end
-end
-
-local function raised(data,replacement,down)
-    local character = data.scriptdata.characters[replacement]
-    if character then
-        local size = data.size
-        return {
-            width    = character.width,
-            height   = character.height,
-            depth    = character.depth,
-            commands = {
-                down and downcommand[size/4] or upcommand[size/2],
-                reference(data.scriptindex,replacement)
-            }
-        }
-    end
-end
-
--- virtualcharacters[0x207A] = 0x2212
--- virtualcharacters[0x207B] = 0x002B
--- virtualcharacters[0x208A] = 0x2212
--- virtualcharacters[0x208B] = 0x002B
-
-virtualcharacters[0x207A] = function(data) return raised(data,0x002B)      end
-virtualcharacters[0x207B] = function(data) return raised(data,0x2212)      end
-virtualcharacters[0x208A] = function(data) return raised(data,0x002B,true) end
-virtualcharacters[0x208B] = function(data) return raised(data,0x2212,true) end
-
--- local function repeated(data,char,n,fraction)
---     local character = data.characters[char]
---     if character then
---         local width = character.width
---         local delta = width - character.italic -- width * fraction
---         local c = charcommand[char]
---         local r = rightcommand[right]
---         local commands = { }
---         for i=1,n-1 do
---             width = width + delta
---             commands[#commands+1] = c
---             commands[#commands+1] = -delta
---         end
---         commands[#commands+1] = c
---         return {
---             width    = width,
---             height   = character.height,
---             depth    = character.depth,
---             commands = commands,
---         }
---     end
--- end
-
--- virtualcharacters[0x222C] = function(data)
---     return repeated(data,0x222B,2,1/8)
--- end
-
--- virtualcharacters[0x222D] = function(data)
---     return repeated(data,0x222B,3,1/8)
--- end
-
 local addextra = mathematics.extras.add
 
 addextra(0xFE350) -- MATHEMATICAL DOUBLE ARROW LEFT END
@@ -310,8 +246,6 @@ virtualcharacters[0xFE352] = function(data)
     end
 end
 
--- we could move the defs from math-act here
-
 local function accent_to_extensible(target,newchr,original,oldchr,height,depth,swap,offset,unicode)
     local characters = target.characters
     local olddata = characters[oldchr]
@@ -422,53 +356,6 @@ virtualcharacters[0xFE33F] = function(data)
     return accent_to_extensible(target,0xFE33F,data.original,0x0305,height,depth,nil,nil,0x203E)
 end
 
--- spacing (no need for a cache of widths)
-
-local c_zero   = byte('0')
-local c_period = byte('.')
-
-local function spacefraction(data,fraction)
-    local width = fraction * data.target.parameters.space
-    return {
-        width    = width,
-        commands = { rightcommand[width] }
-    }
-end
-
-local function charfraction(data,char)
-    local width = data.target.characters[char].width
-    return {
-        width    = width,
-        commands = { rightcommand[width] }
-    }
-end
-
-local function quadfraction(data,fraction)
-    local width = fraction * data.target.parameters.quad
-    return {
-        width    = width,
-        commands = { rightcommand[width] }
-    }
-end
-
-virtualcharacters[0x00A0] = function(data) return spacefraction(data,1)        end -- nbsp
-virtualcharacters[0x2000] = function(data) return quadfraction (data,1/2)      end -- enquad
-virtualcharacters[0x2001] = function(data) return quadfraction (data,1)        end -- emquad
-virtualcharacters[0x2002] = function(data) return quadfraction (data,1/2)      end -- enspace
-virtualcharacters[0x2003] = function(data) return quadfraction (data,1)        end -- emspace
-virtualcharacters[0x2004] = function(data) return quadfraction (data,1/3)      end -- threeperemspace
-virtualcharacters[0x2005] = function(data) return quadfraction (data,1/4)      end -- fourperemspace
-virtualcharacters[0x2006] = function(data) return quadfraction (data,1/6)      end -- sixperemspace
-virtualcharacters[0x2007] = function(data) return charfraction (data,c_zero)   end -- figurespace
-virtualcharacters[0x2008] = function(data) return charfraction (data,c_period) end -- punctuationspace
-virtualcharacters[0x2009] = function(data) return quadfraction (data,1/8)      end -- breakablethinspace
-virtualcharacters[0x200A] = function(data) return quadfraction (data,1/8)      end -- hairspace
-virtualcharacters[0x200B] = function(data) return quadfraction (data,0)        end -- zerowidthspace
-virtualcharacters[0x202F] = function(data) return quadfraction (data,1/8)      end -- narrownobreakspace
-virtualcharacters[0x205F] = function(data) return spacefraction(data,1/2)      end -- math thinspace
-
---
-
 local function smashed(data,unicode,swap,private)
     local target   = data.target
     local original = data.original
@@ -514,73 +401,250 @@ end
 virtualcharacters[0xFE302] = function(data) return smashed(data,0x0302,0xFE302) end
 virtualcharacters[0xFE303] = function(data) return smashed(data,0x0303,0xFE303) end
 
--- another crazy hack .. doesn't work as we define scrscr first .. we now have smaller
--- primes so we have smaller primes for the moment, big ones will become an option ..
--- these primes in fonts are a real mess .. kind of a dead end, so don't wonder about
--- the values below
-
-local function smashed(data,unicode,optional)
-    local oldchar = data.characters[unicode]
-    if oldchar then
-        local height  = 0.85 * data.target.mathparameters.AccentBaseHeight
-        local newchar = table.copy(oldchar)
-        newchar.yoffset = height - oldchar.height
-        newchar.height  = height
-        return newchar
-    elseif not optional then
-        report_fallbacks("missing %U prime in font %a",unicode,data.target.properties.fullname)
-    end
-end
+---------------------------------------------------------------------------------
+-- these are moved to math-act.lmt
+---------------------------------------------------------------------------------
 
-addextra(0xFE932) -- SMASHED PRIME 0x02032
-addextra(0xFE933) -- SMASHED PRIME 0x02033
-addextra(0xFE934) -- SMASHED PRIME 0x02034
-addextra(0xFE957) -- SMASHED PRIME 0x02057
-
-addextra(0xFE935) -- SMASHED BACKWARD PRIME 0x02035
-addextra(0xFE936) -- SMASHED BACKWARD PRIME 0x02036
-addextra(0xFE937) -- SMASHED BACKWARD PRIME 0x02037
-
-virtualcharacters[0xFE932] = function(data) return smashed(data,0x02032) end
-virtualcharacters[0xFE933] = function(data) return smashed(data,0x02033) end
-virtualcharacters[0xFE934] = function(data) return smashed(data,0x02034) end
-virtualcharacters[0xFE957] = function(data) return smashed(data,0x02057) end
-
-virtualcharacters[0xFE935] = function(data) return smashed(data,0x02035,true) end
-virtualcharacters[0xFE936] = function(data) return smashed(data,0x02036,true) end
-virtualcharacters[0xFE937] = function(data) return smashed(data,0x02037,true) end
-
-local hack = nil
-
-function mathematics.getridofprime(target,original)
---     local mathsize = specification.mathsize
---     if mathsize == 1 or mathsize == 2 or mathsize == 3) then
-    local mathparameters = original.mathparameters
-    if mathparameters and next(mathparameters) then
-        local changed = original.changed
-        if changed then
-            hack = changed[0x02032]
-            changed[0x02032] = nil
-            changed[0x02033] = nil
-            changed[0x02034] = nil
-            changed[0x02057] = nil
-            changed[0x02035] = nil
-            changed[0x02036] = nil
-            changed[0x02037] = nil
-        end
-    end
-end
+-- local function reference(index,char)
+--     if index then
+--         return { "slot", index, char }
+--     else
+--         return charcommand[char]
+--     end
+-- end
+--
+-- local function raised(data,replacement,down)
+--     local character = data.scriptdata.characters[replacement]
+--     if character then
+--         local size = data.size
+--         return {
+--             width    = character.width,
+--             height   = character.height,
+--             depth    = character.depth,
+--             commands = {
+--                 down and downcommand[size/4] or upcommand[size/2],
+--                 reference(data.scriptindex,replacement)
+--             }
+--         }
+--     end
+-- end
+--
+-- virtualcharacters[0x207A] = function(data) return raised(data,0x002B)      end
+-- virtualcharacters[0x207B] = function(data) return raised(data,0x2212)      end
+-- virtualcharacters[0x208A] = function(data) return raised(data,0x002B,true) end
+-- virtualcharacters[0x208B] = function(data) return raised(data,0x2212,true) end
 
-function mathematics.setridofprime(target,original)
-    local mathparameters = original.mathparameters
-    if mathparameters and next(mathparameters) and original.changed then
-        target.characters[0xFE931] = target.characters[hack or 0x2032]
-        hack = nil
-    end
-end
+---------------------------------------------------------------------------------
+-- these are moved to math-act.lmt
+---------------------------------------------------------------------------------
 
-utilities.sequencers.appendaction("beforecopyingcharacters","system","mathematics.getridofprime")
-utilities.sequencers.appendaction("aftercopyingcharacters", "system","mathematics.setridofprime")
+-- local function repeated(data,char,n,fraction)
+--     local character = data.characters[char]
+--     if character then
+--         local width = character.width
+--         local delta = width - character.italic -- width * fraction
+--         local c = charcommand[char]
+--         local r = rightcommand[right]
+--         local commands = { }
+--         for i=1,n-1 do
+--             width = width + delta
+--             commands[#commands+1] = c
+--             commands[#commands+1] = -delta
+--         end
+--         commands[#commands+1] = c
+--         return {
+--             width    = width,
+--             height   = character.height,
+--             depth    = character.depth,
+--             commands = commands,
+--         }
+--     end
+-- end
+--
+-- virtualcharacters[0x222C] = function(data)
+--     return repeated(data,0x222B,2,1/8)
+-- end
+--
+-- virtualcharacters[0x222D] = function(data)
+--     return repeated(data,0x222B,3,1/8)
+-- end
+
+---------------------------------------------------------------------------------
+-- these are moved to math-act.lmt
+---------------------------------------------------------------------------------
+
+-- -- spacing (no need for a cache of widths)
+--
+-- local c_zero   = byte('0')
+-- local c_period = byte('.')
+--
+-- local function spacefraction(data,fraction)
+--     local width = fraction * data.target.parameters.space
+--     return {
+--         width    = width,
+--      -- commands = { rightcommand[width] }
+--     }
+-- end
+--
+-- local function charfraction(data,char)
+--     local width = data.target.characters[char].width
+--     return {
+--         width    = width,
+--      -- commands = { rightcommand[width] }
+--     }
+-- end
+--
+-- local function quadfraction(data,fraction)
+--     local width = fraction * data.target.parameters.quad
+--     return {
+--         width  = width,
+--      -- commands = { rightcommand[width] }
+--     }
+-- end
+--
+-- virtualcharacters[0x00A0] = function(data) return spacefraction(data,1)        end -- nbsp
+-- virtualcharacters[0x2000] = function(data) return quadfraction (data,1/2)      end -- enquad
+-- virtualcharacters[0x2001] = function(data) return quadfraction (data,1)        end -- emquad
+-- virtualcharacters[0x2002] = function(data) return quadfraction (data,1/2)      end -- enspace
+-- virtualcharacters[0x2003] = function(data) return quadfraction (data,1)        end -- emspace
+-- virtualcharacters[0x2004] = function(data) return quadfraction (data,1/3)      end -- threeperemspace
+-- virtualcharacters[0x2005] = function(data) return quadfraction (data,1/4)      end -- fourperemspace
+-- virtualcharacters[0x2006] = function(data) return quadfraction (data,1/6)      end -- sixperemspace
+-- virtualcharacters[0x2007] = function(data) return charfraction (data,c_zero)   end -- figurespace
+-- virtualcharacters[0x2008] = function(data) return charfraction (data,c_period) end -- punctuationspace
+-- virtualcharacters[0x2009] = function(data) return quadfraction (data,1/8)      end -- breakablethinspace
+-- virtualcharacters[0x200A] = function(data) return quadfraction (data,1/8)      end -- hairspace
+-- virtualcharacters[0x200B] = function(data) return quadfraction (data,0)        end -- zerowidthspace
+-- virtualcharacters[0x202F] = function(data) return quadfraction (data,1/8)      end -- narrownobreakspace
+-- virtualcharacters[0x205F] = function(data) return spacefraction(data,1/2)      end -- math thinspace
+
+-- -- another crazy hack .. doesn't work as we define scrscr first .. we now have smaller
+-- -- primes so we have smaller primes for the moment, big ones will become an option ..
+-- -- these primes in fonts are a real mess .. kind of a dead end, so don't wonder about
+-- -- the values below
+--
+-- local function smashed(data,unicode,optional)
+--     local oldchar = data.characters[unicode]
+--     if oldchar then
+--         local height  = 0.85 * data.target.mathparameters.AccentBaseHeight
+--         local newchar = table.copy(oldchar)
+--         newchar.yoffset = height - oldchar.height
+--         newchar.height  = height
+--         return newchar
+--     elseif not optional then
+--         report_fallbacks("missing %U prime in font %a",unicode,data.target.properties.fullname)
+--     end
+-- end
+--
+-- addextra(0xFE932) -- SMASHED PRIME 0x02032
+-- addextra(0xFE933) -- SMASHED PRIME 0x02033
+-- addextra(0xFE934) -- SMASHED PRIME 0x02034
+-- addextra(0xFE957) -- SMASHED PRIME 0x02057
+--
+-- addextra(0xFE935) -- SMASHED BACKWARD PRIME 0x02035
+-- addextra(0xFE936) -- SMASHED BACKWARD PRIME 0x02036
+-- addextra(0xFE937) -- SMASHED BACKWARD PRIME 0x02037
+--
+-- virtualcharacters[0xFE932] = function(data) return smashed(data,0x02032) end
+-- virtualcharacters[0xFE933] = function(data) return smashed(data,0x02033) end
+-- virtualcharacters[0xFE934] = function(data) return smashed(data,0x02034) end
+-- virtualcharacters[0xFE957] = function(data) return smashed(data,0x02057) end
+--
+-- virtualcharacters[0xFE935] = function(data) return smashed(data,0x02035,true) end
+-- virtualcharacters[0xFE936] = function(data) return smashed(data,0x02036,true) end
+-- virtualcharacters[0xFE937] = function(data) return smashed(data,0x02037,true) end
+--
+-- local hack = nil
+--
+-- function mathematics.getridofprime(target,original)
+--     local mathparameters = original.mathparameters
+--     if mathparameters and next(mathparameters) then
+--         local changed = original.changed
+--         if changed then
+--             hack = changed[0x02032]
+--             changed[0x02032] = nil
+--             changed[0x02033] = nil
+--             changed[0x02034] = nil
+--             changed[0x02057] = nil
+--             changed[0x02035] = nil
+--             changed[0x02036] = nil
+--             changed[0x02037] = nil
+--         end
+--     end
+-- end
+--
+-- function mathematics.setridofprime(target,original)
+--     local mathparameters = original.mathparameters
+--     if mathparameters and next(mathparameters) and original.changed then
+--         target.characters[0xFE931] = target.characters[hack or 0x2032]
+--         hack = nil
+--     end
+-- end
+--
+-- utilities.sequencers.appendaction("beforecopyingcharacters","system","mathematics.getridofprime")
+-- utilities.sequencers.appendaction("aftercopyingcharacters", "system","mathematics.setridofprime")
+
+-- local list = {
+--     { 0x02032, true  },
+--     { 0x02033, true  },
+--     { 0x02034, true  },
+--     { 0x02057, true  },
+--     { 0x02035, false },
+--     { 0x02036, false },
+--     { 0x02037, false },
+-- }
+--
+-- function mathematics.fixprimes(target,original)
+--     local mathparameters = original.mathparameters
+--     if mathparameters and next(mathparameters) then
+--         for i=1,#list do
+--             local entry = list[i]
+--             local char  = original.characters[entry[1]]
+--             if char then
+--                 local height  = 0.85 * orginal.mathparameters.AccentBaseHeight
+--                 char.yoffset = height - char.height
+--                 char.height  = height
+--                 return char
+--             elseif entry[1] then
+--                 report_fallbacks("missing %U prime in font %a",unicode,original.properties.fullname)
+--             end
+--         end
+--     end
+-- end
+--
+-- utilities.sequencers.appendaction("beforecopyingcharacters","system","mathematics.fixprimes")
+
+---------------------------------------------------------------------------------
+-- this one is not used
+---------------------------------------------------------------------------------
+
+-- addextra(0xFE941) -- EXTREMELY IDENTICAL TO
+--
+-- virtualcharacters[0xFE941] = function(data) -- this character is only needed for mathpairs
+--     local characters = data.target.characters
+--     local parameters = data.target.parameters
+--     local basechar   = characters[0x003D]
+--     local width      = basechar.width or 0
+--     local height     = basechar.height or 0
+--     local depth      = basechar.depth or 0
+--     return {
+--         unicode   = 0xFE941,
+--         width     = width,
+--         height    = height,         -- we cheat (no time now)
+--         depth     = depth,          -- we cheat (no time now)
+--         commands  = {
+--             upcommand[height/2], -- sort of works
+--             charcommand[0x003D],
+--             leftcommand[width],
+--             downcommand[height],     -- sort of works
+--             charcommand[0x003D],
+--         },
+--     }
+-- end
+
+---------------------------------------------------------------------------------
+-- these might move to math-act.lmt
+---------------------------------------------------------------------------------
 
 -- actuarian (beware: xits has an ugly one)
 
@@ -638,31 +702,9 @@ virtualcharacters[0x2A75] = function(data) return equals(data,0x2A75,0x003D, 1/5
 virtualcharacters[0x2A76] = function(data) return equals(data,0x2A76,0x003D, 1/5,3) end -- ===
 virtualcharacters[0x2980] = function(data) return equals(data,0x2980,0x007C,-1/8,3) end -- |||
 
--- addextra(0xFE941) -- EXTREMELY IDENTICAL TO
---
--- virtualcharacters[0xFE941] = function(data) -- this character is only needed for mathpairs
---     local characters = data.target.characters
---     local parameters = data.target.parameters
---     local basechar   = characters[0x003D]
---     local width      = basechar.width or 0
---     local height     = basechar.height or 0
---     local depth      = basechar.depth or 0
---     return {
---         unicode   = 0xFE941,
---         width     = width,
---         height    = height,         -- we cheat (no time now)
---         depth     = depth,          -- we cheat (no time now)
---         commands  = {
---             upcommand[height/2], -- sort of works
---             charcommand[0x003D],
---             leftcommand[width],
---             downcommand[height],     -- sort of works
---             charcommand[0x003D],
---         },
---     }
--- end
-
--- lucida needs this
+---------------------------------------------------------------------------------
+-- these might move to math-act.lmt -- lucida needs this
+---------------------------------------------------------------------------------
 
 virtualcharacters[0x305] = function(data)
     local target = data.target
@@ -693,6 +735,10 @@ virtualcharacters[0x305] = function(data)
     }
 end
 
+---------------------------------------------------------------------------------
+-- these might move to math-act.lmt
+---------------------------------------------------------------------------------
+
 local function threedots(data,shift)
     local characters = data.target.characters
     local parameters = data.target.parameters
diff --git a/tex/context/base/mkxl/math-noa.lmt b/tex/context/base/mkxl/math-noa.lmt
index 5ac095fd3..025333699 100644
--- a/tex/context/base/mkxl/math-noa.lmt
+++ b/tex/context/base/mkxl/math-noa.lmt
@@ -1927,20 +1927,32 @@ do
     -- inner under over vcenter
 
     local fixscripts = { }
+--     local movesub    = {
+--         -- primes
+--         [0x2032] = 0xFE932,
+--         [0x2033] = 0xFE933,
+--         [0x2034] = 0xFE934,
+--         [0x2057] = 0xFE957,
+--         -- reverse primes
+--         [0x2035] = 0xFE935,
+--         [0x2036] = 0xFE936,
+--         [0x2037] = 0xFE937,
+--     }
+--
+--     mathematics.virtualize(movesub)
+
     local movesub    = {
         -- primes
-        [0x2032] = 0xFE932,
-        [0x2033] = 0xFE933,
-        [0x2034] = 0xFE934,
-        [0x2057] = 0xFE957,
+        [0x2032] = 0x2032,
+        [0x2033] = 0x2033,
+        [0x2034] = 0x2034,
+        [0x2057] = 0x2057,
         -- reverse primes
-        [0x2035] = 0xFE935,
-        [0x2036] = 0xFE936,
-        [0x2037] = 0xFE937,
+        [0x2035] = 0x2035,
+        [0x2036] = 0x2036,
+        [0x2037] = 0x2037,
     }
 
-    mathematics.virtualize(movesub)
-
     local nosuperscript_code = tex.mathoptioncodes.nosuperscript
 
     local function fixsupscript(parent,current,current_char,new_char)
diff --git a/tex/context/base/mkxl/strc-syn.mkxl b/tex/context/base/mkxl/strc-syn.mkxl
index c6a62e607..e6081d0d9 100644
--- a/tex/context/base/mkxl/strc-syn.mkxl
+++ b/tex/context/base/mkxl/strc-syn.mkxl
@@ -101,6 +101,31 @@
 %D
 %D The lists are constructions (like descriptions are) and can be set up
 %D likewise.
+%D
+%D You can show the currently accessed entries as follows:
+%D
+%D \starttyping
+%D \startchapter[title=One]
+%D     test \FIRST\ test test \THIRD\ test \blank
+%D     \placelistofsynonyms[myabbreviation]
+%D     \resetsynonymsprogress[myabbreviation] % reset state
+%D \stopchapter
+%D
+%D \startchapter[title=Two]
+%D     test \FIRST\ test test \SECOND\ test \blank
+%D     \placelistofsynonyms[myabbreviation][criterium=current]
+%D     \resetsynonymsprogress[myabbreviation] % reset state
+%D \stopchapter
+%D
+%D \startchapter[title=Three]
+%D     test test test test test test \blank
+%D     \placelistofsynonyms[myabbreviation][criterium=current] % also reset state
+%D \stopchapter
+%D
+%D \startchapter[title=All]
+%D     \placelistofsynonyms[myabbreviation][criterium=all]
+%D \stopchapter
+%D \stoptyping
 
 % todo: add 'define only' option to descriptions, then add sorting (also based on key)
 % and call to definition -> replaces this module
@@ -339,8 +364,11 @@
 \permanent         \protected\def\currentsynonymmeaning      {\clf_synonymmeaning{\currentsimplelist}{\currentsynonymtag}}
 \permanent         \protected\def\doifelsecurrentsynonymused {\clf_doifelsesynonymused{\currentsimplelist}{\currentsynonymtag}}
 \permanent         \protected\def\doifelsecurrentsynonymshown{\clf_doifelsesynonymshown{\currentsimplelist}{\currentsynonymtag}}
-\permanent         \protected\def\resetusedsynonyms      [#1]{\clf_resetusedsynonyms{#1}}
-\permanent         \protected\def\resetshownsynonyms     [#1]{\clf_resetshownsynonyms{#1}}
+\permanent         \protected\def\resetusedsynonyms      [#1]{\clf_resetsynonyms{#1}{used}}
+\permanent         \protected\def\resetshownsynonyms     [#1]{\clf_resetsynonyms{#1}{shown}}
+\permanent         \protected\def\resetlistsynonyms      [#1]{\clf_resetsynonyms{#1}{list}}
+\permanent         \protected\def\resetsynonyms          [#1]{\clf_resetsynonyms{#1}{all}}
+\permanent         \protected\def\resetsynonymsprogress  [#1]{\clf_resetsynonyms{#1}{progress}}
 
 \aliased\let\rawsynonymname   \clf_synonymname
 \aliased\let\rawsynonymmeaning\clf_synonymmeaning
diff --git a/tex/context/base/mkxl/trac-vis.lmt b/tex/context/base/mkxl/trac-vis.lmt
index aa599485c..d08f3c282 100644
--- a/tex/context/base/mkxl/trac-vis.lmt
+++ b/tex/context/base/mkxl/trac-vis.lmt
@@ -147,7 +147,7 @@ local modes = {
 visualizers.modes = modes
 
 local usedfont, exheight, emwidth
-local l_penalty, l_glue, l_kern, l_fontkern, l_hbox, l_vbox, l_vtop, l_strut, l_whatsit, l_glyph, l_user, l_math, l_marginkern, l_mathkern, l_italic, l_origin, l_discretionary, l_expansion, l_line, l_space, l_depth,
+local l_penalty, l_glue, l_kern, l_fontkern, l_hbox, l_vbox, l_vtop, l_strut, l_whatsit, l_glyph, l_user, l_math, l_marginkern, l_mathkern, l_mathshape, l_italic, l_origin, l_discretionary, l_expansion, l_line, l_space, l_depth,
     l_dir, l_whatsit, l_mark, l_insert
 
 local enabled = false
@@ -207,6 +207,7 @@ local function initialize()
     l_italic        = layers.italic
     l_marginkern    = layers.marginkern
     l_mathkern      = layers.mathkern
+    l_mathshapekern = layers.mathshapekern
     l_origin        = layers.origin
     l_discretionary = layers.discretionary
     l_expansion     = layers.expansion
@@ -432,6 +433,7 @@ local fontkern, italickern, marginkern, mathkern do
 
     local f_cache = caches["fontkern"]
     local i_cache = caches["italickern"]
+    local s_cache = caches["shapekern"]
     local m_cache = caches["marginkern"]
     local l_cache = caches["mathkern"]
 
@@ -471,6 +473,10 @@ local fontkern, italickern, marginkern, mathkern do
         return somekern(head,current,i_cache,"trace:do",l_italic)
     end
 
+    mathshapekern = function(head,current)
+        return somekern(head,current,s_cache,"trace:do",l_mathshapekern)
+    end
+
     marginkern = function(head,current)
         return somekern(head,current,m_cache,"trace:do",l_marginkern)
     end
@@ -1214,11 +1220,10 @@ local ruledmathkern do
     local h_cache = caches["horizontalmathkern"]
     local v_cache = caches["verticalmathkern"]
 
-    ruledmathkern = function(head,current,subtype)
-        local kern     = getkern(current)
-        local vertical = subtype == verticalmathkern_code
-        local cache    = vertical and v_cache or h_cache
-        local info     = cache[kern]
+    ruledmathkern = function(head,current,vertical)
+        local kern  = getkern(current)
+        local cache = vertical and v_cache or h_cache
+        local info  = cache[kern]
         if not info then
             local amount = formatters["%s:%0.3f"](vertical and "MV" or "MH",kern*pt_factor)
             if kern > 0 then
@@ -1321,6 +1326,7 @@ do
     local italickern_code         = kerncodes.italiccorrection
     local leftmarginkern_code     = kerncodes.leftmarginkern
     local rightmarginkern_code    = kerncodes.rightmarginkern
+    local mathshapekern_code      = kerncodes.mathshapekern
     local horizontalmathkern_code = kerncodes.horizontalmathkern
     local verticalmathkern_code   = kerncodes.verticalmathkern
     ----- userkern_code           = kerncodes.userkern
@@ -1560,13 +1566,19 @@ do
                 end
             elseif subtype == verticalmathkern_code then
                 if trace_mathkern or trace_kern then
-                    head, current = ruledmathkern(head,current,subtype)
+                    head, current = ruledmathkern(head,current,true)
                 end
             elseif subtype == horizontalmathkern_code then
                 if trace_mathkern then
                     head, current = mathkern(head,current)
                 elseif trace_kern then
-                    head, current = ruledmathkern(head,current,subtype)
+                    head, current = ruledmathkern(head,current,false)
+                end
+            elseif subtype == mathshapekern_code then
+                if trace_mathkern or trace_italic then
+                    head, current = mathshapekern(head,current)
+                elseif trace_kern then
+                    head, current = ruledmathkern(head,current,false)
                 end
             else
                 if trace_kern then
diff --git a/tex/context/fonts/mkiv/asana-math.lfg b/tex/context/fonts/mkiv/asana-math.lfg
index 5b47b3ff8..fc83887a0 100644
--- a/tex/context/fonts/mkiv/asana-math.lfg
+++ b/tex/context/fonts/mkiv/asana-math.lfg
@@ -30,7 +30,6 @@ local function more(value,target,original)
     end
 end
 
-
 return {
     name = "asana-math",
     version = "1.00",
@@ -38,6 +37,27 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    }
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 1.05,
+                    scale  = 0.65,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
+        },
         parameters = {
          -- DisplayOperatorMinHeight         = 0, -- more
          -- StackBottomDisplayStyleShiftDown = 0,
diff --git a/tex/context/fonts/mkiv/bonum-math.lfg b/tex/context/fonts/mkiv/bonum-math.lfg
index 51ca2d7f1..8daa047fb 100644
--- a/tex/context/fonts/mkiv/bonum-math.lfg
+++ b/tex/context/fonts/mkiv/bonum-math.lfg
@@ -1,8 +1,21 @@
-local kern_V   = { bottomright = { { kern = -200 } } }
-local kern_W   = { bottomright = { { kern = -100 } } }
-local offset_f = { xoffset = "llx" }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
 
--- Beware of updates in ssty slots!
+    local kern_V   = { bottomright = { { kern = -200 } } }
+    local kern_W   = { bottomright = { { kern = -100 } } }
+    local offset_f = { xoffset = "llx" }
+
+    dimensions = {
+        default = {
+            [0x1D453] = offset_f, -- 𝑓
+        },
+    }
+
+    kerns = {
+        [0x1D449] = kern_V, -- 𝑉
+        [0x1D44A] = kern_W, -- 𝑊
+    }
+
+end
 
 return {
     name = "bonum-math",
@@ -11,26 +24,30 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
-        dimensions = {
-            default = {
-             -- [0x1D453]     = offset_f, -- 𝑓
-             -- ["1:0x1D453"] = offset_f, -- needed for compact
-             -- ["2:0x1D453"] = offset_f, -- needed for compact
-                ["*:0x1D453"] = offset_f, -- 𝑓
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        [0x1D453] = { .40, 1.60, .5 }, -- offset width italic
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "addscripts",
+                },
             },
         },
-        kerns = {
-         -- [0x1D449]     = kern_V, -- 𝑉
-         -- ["1:0x1D449"] = kern_V, -- needed for compact
-         -- ["2:0x1D449"] = kern_V, -- needed for compact
-         -- [0x1D44A]     = kern_W, -- 𝑊
-         -- ["1:0x1D44A"] = kern_W, -- needed for compact
-         -- ["2:0x1D44A"] = kern_W, -- needed for compact
-            ["*:0x1D449"] = kern_V, -- 𝑉
-            ["*:0x1D44A"] = kern_W, -- 𝑊
-        },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/cambria-math.lfg b/tex/context/fonts/mkiv/cambria-math.lfg
index c18854d18..6db382c45 100644
--- a/tex/context/fonts/mkiv/cambria-math.lfg
+++ b/tex/context/fonts/mkiv/cambria-math.lfg
@@ -6,6 +6,32 @@
 -- added to the patch list. No goodies setting is needed with
 -- the filename.
 
+local dimensions, kerns, kernpairs  if CONTEXTLMTXMODE == 0 then
+
+    kernpairs = { -- \setupmathematics[kernpairs=yes]
+        [0x1D44E] = {
+            [0x1D44F] = 1000, -- 𝑎𝑏 demo
+        }
+    }
+
+    kerns = {
+        [0x1D453] = {
+            force = true,
+            topright = {
+                {
+                    kern = 1000,
+                },
+            },
+            bottomright = {
+                {
+                    kern = 1000,
+                },
+            },
+        },
+    }
+
+end
+
 local patches = fonts.handlers.otf.enhancers.patches
 
 local function patch(data,filename,threshold)
@@ -42,28 +68,34 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
+        },
         parameters = {
             DisplayOperatorMinHeight = FixDisplayOperatorMinHeight,
         },
-     -- kernpairs = { -- \setupmathematics[kernpairs=yes]
-     --     [0x1D44E] = {
-     --         [0x1D44F] = 1000, -- 𝑎𝑏 demo
-     --     }
-     -- },
-     -- kerns = {
-     --     [0x1D453] = {
-     --         force = true,
-     --         topright = {
-     --             {
-     --                 kern = 1000,
-     --             },
-     --         },
-     --         bottomright = {
-     --             {
-     --                 kern = 1000,
-     --             },
-     --         },
-     --     },
-     -- },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
+        kernpairs = kernpairs,
     },
 }
diff --git a/tex/context/fonts/mkiv/dejavu-math.lfg b/tex/context/fonts/mkiv/dejavu-math.lfg
index 608b396f8..44b5327de 100644
--- a/tex/context/fonts/mkiv/dejavu-math.lfg
+++ b/tex/context/fonts/mkiv/dejavu-math.lfg
@@ -1,7 +1,14 @@
-local kern_V = { bottomright = { { kern = -250 } } }
-local kern_W = kern_W
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
 
--- Beware of updates in ssty slots!
+    local kern_V = { bottomright = { { kern = -250 } } }
+    local kern_W = kern_W
+
+    kerns = {
+        [0x1D449] = kern_V, -- 𝑉
+        [0x1D44A] = kern_W, -- 𝑊
+    }
+
+end
 
 return {
     name = "dejavu-math",
@@ -10,18 +17,35 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
-        kerns = {
-         -- [0x1D449]     = kern_V, -- 𝑉
-         -- ["1:0x1D449"] = kern_V, -- needed for compact
-         -- ["2:0x1D449"] = kern_V, -- needed for compact
-         -- [0x1D44A]     = kern_W, -- 𝑊
-         -- ["1:0x1D44A"] = kern_W, -- needed for compact
-         -- ["2:0x1D44A"] = kern_W, -- needed for compact
-            ["*:0x1D449"] = kern_V, -- 𝑉
-            ["*:0x1D44A"] = kern_W, -- 𝑊
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                     -- [0x1D449] = { 0, .8, .2 },
+                     -- [0x1D44A] = { 0, .8, .2 },
+                        ["0x1D449:0x1D44A"] = { 0, .8, .2 },
+                    }
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/ebgaramond.lfg b/tex/context/fonts/mkiv/ebgaramond.lfg
index 862e4e85d..7a509893d 100644
--- a/tex/context/fonts/mkiv/ebgaramond.lfg
+++ b/tex/context/fonts/mkiv/ebgaramond.lfg
@@ -5,32 +5,26 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
---         tweaks = {
---             aftercopying = {
---                 function(target,original,...)
---                     local crap = {
---                         [0x1D453] = { .20, 1.20 },
---                         [0x1D454] = { .15, 1.15 },
---                     }
---                     local characters = target.characters
---                     local function adapt(k,v)
---                         local character = characters[k]
---                         local width     = character.width
---                         character.width = v[2]*width
---                      -- character.commands = { { "offset", v[1]*width, 0, k } }
---                         character.xoffset = v[1]*width
---                         local smaller = original.characters[k].smaller
---                         if smaller and smaller ~= k then
---                             adapt(smaller,v)
---                         end
---                     end
---                     for k, v in next, crap do
---                         adapt(k,v)
---                     end
---                 end,
---             },
---         },
-
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        [0x1D453] = { 0, 1, .2 }, -- offset width italic
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
+        },
         alternates = {
             partial        = { feature = 'ss02', value = 1, comment = "Curved partial" },
             semibold       = { feature = 'ss04', value = 1, comment = "Semibold" },
diff --git a/tex/context/fonts/mkiv/libertinus-math.lfg b/tex/context/fonts/mkiv/libertinus-math.lfg
index c02f0506a..a0e9b5c23 100644
--- a/tex/context/fonts/mkiv/libertinus-math.lfg
+++ b/tex/context/fonts/mkiv/libertinus-math.lfg
@@ -13,89 +13,22 @@ return {
     mathematics = {
         tweaks = {
             aftercopying = {
-             -- function(target,original)
-             --     local okay = 983068
-             --     local crap = {
-             --         ["minute"] = "minute.ssty1",
-             --         ["second"] = "second.ssty1",
-             --      -- [8242] = 983068,
-             --      -- [8243] = 983069,
-             --         [8244] = 983070,
-             --         [8245] = 983071,
-             --         [8246] = 983072,
-             --         [8247] = 983073,
-             --     }
-             --     local characters = target.characters
-             --     local unicodes   = original.resources.unicodes
-             --     if unicodes["minute.ssty1"] == okay then
-             --         for old, new in next, crap do
-             --             if type(old) == "string" then
-             --                 old = unicodes[old]
-             --             end
-             --             if type(new) == "string" then
-             --                 new = unicodes[new]
-             --             end
-             --             if old and new and characters[old] then
-             --                 local c = characters[new]
-             --                 if c then
-             --                     characters[old] = c
-             --                     c.commands = { { "up", .06 * c.height }, { "slot", 0, new, .7 } }
-             --                 end
-             --             end
-             --         end
-             --         local four = characters[0x2057]
-             --         if four then
-             --             local one = characters[okay]
-             --             local owd = .75*one.width
-             --             local off = .6*one.height
-             --             four.width = 4*owd
-             --             four.commands = {
-             --                 { "offset",     0, off, okay },
-             --                 { "offset",   owd, off, okay },
-             --                 { "offset", 2*owd, off, okay },
-             --                 { "offset", 3*owd, off, okay },
-             --             }
-             --         else
-             --             -- we don't add (but we could), just patch, and there's no
-             --             -- reverse quad either
-             --         end
-             --     else
-             --         logs.report("fonts","the libertinus tweaks need to be checked")
-             --     end
-             -- end,
-                function(target,original)
-                    local crap = { 0x2032, 0x2033, 0x2034, 0x2036, 0x2037, 0x2038 } -- 0x2057
-                    local characters = target.characters
-                    local originals  = original.characters
-                    local unicodes   = original.resources.unicodes
-                    for i=1,#crap do
-                        local old = crap[i]
-                        local chr = characters[slot]
-                        if chr then
-                            local new = chr.smaller
-                            if new then
-                                local c = characters[new]
-                                if c then
-                                    characters[old] = c
-                                    c.commands = { { "up", .06 * c.height }, { "slot", 0, new, .7 } }
-                                end
-                            end
-                        end
-                    end
-                    local four = characters[0x2057]
-                    if four then
-                        local one = characters[0x2032]
-                        local owd = .75*one.width
-                        local off = .6*one.height
-                        four.width = 4*owd
-                        four.commands = {
-                            { "offset",     0, off, okay },
-                            { "offset",   owd, off, okay },
-                            { "offset", 2*owd, off, okay },
-                            { "offset", 3*owd, off, okay },
-                        }
-                    end
-                end,
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
             },
         },
     },
diff --git a/tex/context/fonts/mkiv/lm.lfg b/tex/context/fonts/mkiv/lm.lfg
index ec37a2975..6039471e3 100644
--- a/tex/context/fonts/mkiv/lm.lfg
+++ b/tex/context/fonts/mkiv/lm.lfg
@@ -1,8 +1,52 @@
 -- In order to be able to use beta math fonts, we use our own file name and
 -- always remap.
 
-local kern_150 = { bottomright = { { kern = -150 } } }
-local kern_200 = { bottomright = { { kern = -200 } } }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
+
+    local kern_150 = { bottomright = { { kern = -150 } } }
+    local kern_200 = { bottomright = { { kern = -200 } } }
+
+    kerns = {
+        [0x1D449] = kern_150, --
+        [0x1D44A] = kern_200, -- 𝑊
+    }
+
+    dimensions = {
+        -- always applied
+     -- default = {
+     -- },
+        -- driven by 'mathdimensions' feature
+        default = {
+            -- the root is quite displaced
+            [0x221A] = {
+                -- 73, -960, 853, 40
+                yoffset = 960 - 40,
+                height  = 960,
+                depth   =  40,
+            },
+        -- [0xFE932] = { xoffset = 50, width = 290 }, -- used prime
+        -- [0x2032]  = { xoffset = 50, width = 290 }, -- prime
+        },
+    -- -- seems ok now --
+    -- signs   = {
+    --  -- [0x00B1] = { -- ±
+    --  --     height = 500, depth = 0,
+    --  -- },
+    --  -- [0x2213] = { -- ∓
+    --  --     height = 500, depth = 0,
+    --  -- },
+    --     -- move in boundingbox
+    --     [0x00B1] = { -- ±
+    --         yoffset =  100,
+    --     },
+    --     [0x2213] = { -- ∓
+    --         yoffset = -100,
+    --     },
+    -- },
+    }
+
+end
+
 
 return {
     name = "latin modern",
@@ -13,58 +57,43 @@ return {
     mathematics = {
         tweaks = {
             aftercopying = {
-                mathematics.tweaks.fixbadprime, -- prime is too low
-            --  mathematics.tweaks.fixoverline,
-            },
-        },
-        kerns = {
-            [0x1D449] = kern_150, --
-            [0x1D44A] = kern_200, -- 𝑊
-        },
-        dimensions = {
-            -- always applied
-         -- default = {
-         -- },
-            -- driven by 'mathdimensions' feature
-            default = {
-                -- the root is quite displaced
-                [0x221A] = {
-                    -- 73, -960, 853, 40
-                    yoffset = 960 - 40,
-                    height  = 960,
-                    depth   =  40,
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
                 },
-            -- [0xFE932] = { xoffset = 50, width = 290 }, -- used prime
-            -- [0x2032]  = { xoffset = 50, width = 290 }, -- prime
-            },
-            signs   = {
-                -- set dimensions
-             -- [0x00B1] = { -- ±
-             --     height = 500, depth = 0,
-             -- },
-             -- [0x2213] = { -- ∓
-             --     height = 500, depth = 0,
-             -- },
-                -- move in boundingbox
-                [0x00B1] = { -- ±
-                    yoffset =  100,
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "fixradicals",
                 },
-                [0x2213] = { -- ∓
-                    yoffset = -100,
+                {
+                    tweak = "addscripts",
                 },
             },
         },
---         parameters = {
---             FractionNumeratorDisplayStyleShiftUp = function(value,target,original)
---                 local o = original.mathparameters.FractionNumeratorDisplayStyleShiftUp
---                 if o > 675 then
---                     o = 600
---                 else
---                     -- probably tuned
---                 end
---                 return o * target.parameters.factor
---             end,
---         }
+        parameters = {
+            FractionNumeratorDisplayStyleShiftUp = function(value,target,original)
+                local o = original.mathparameters.FractionNumeratorDisplayStyleShiftUp
+                if o > 675 then
+                    o = 600
+                else
+                    -- probably tuned
+                end
+                return o * target.parameters.factor
+            end,
+        },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
     filenames = {
         ["latinmodern-math-regular.otf"] = {
diff --git a/tex/context/fonts/mkiv/lucida-opentype-math.lfg b/tex/context/fonts/mkiv/lucida-opentype-math.lfg
index 7596f139a..024284bd2 100644
--- a/tex/context/fonts/mkiv/lucida-opentype-math.lfg
+++ b/tex/context/fonts/mkiv/lucida-opentype-math.lfg
@@ -1,4 +1,29 @@
------ kern_250 = { bottomright = { { kern = -250 } }, force = true }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
+
+ -- local kern_250 = { bottomright = { { kern = -250 } }, force = true }
+
+
+ -- kerns = {
+ --     [0x1D449] = kern_250, --
+ --     [0x1D44A] = kern_250, -- 𝑊
+ -- }
+
+    dimensions = {
+        default = { -- experimental values
+            [0x02044] = { xoffset = 275, width = 600 },
+            -- primes
+            [0xFE932] = { width =  200 },
+            [0xFE933] = { width =  500 },
+            [0xFE934] = { width =  800 },
+            [0xFE935] = { width = 1100 },
+            -- reverse primes
+            [0xFE935] = { width =  200 },
+            [0xFE936] = { width =  500 },
+            [0xFE937] = { width =  800 },
+        },
+    }
+
+end
 
 -- RadicalVerticalGap             =  50
 -- RadicalDisplayStyleVerticalGap = 175
@@ -18,6 +43,30 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak  = "fakeprimes",
+                    factor = 0.75,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
+        },
         parameters = {
             RadicalDisplayStyleVerticalGap = FixRadicalDisplayStyleVerticalGap,
         },
@@ -29,23 +78,10 @@ return {
             zero         = { feature = 'ss05', value = 1, comment = "Mathematical Alternative Zero" },
             partial      = { feature = 'ss20', value = 1, comment = "Mathematical Alternative Upright Partial Differential" },
         },
-     -- kerns = {
-     --     [0x1D449] = kern_250, --
-     --     [0x1D44A] = kern_250, -- 𝑊
-     -- },
-        dimensions = {
-            default = { -- experimental values
-                [0x02044] = { xoffset = 275, width = 600 },
-                -- primes
-                [0xFE932] = { width =  200 },
-                [0xFE933] = { width =  500 },
-                [0xFE934] = { width =  800 },
-                [0xFE935] = { width = 1100 },
-                -- reverse primes
-                [0xFE935] = { width =  200 },
-                [0xFE936] = { width =  500 },
-                [0xFE937] = { width =  800 },
-            },
-        },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/minion-math.lfg b/tex/context/fonts/mkiv/minion-math.lfg
index 863836c1c..13d11edc6 100644
--- a/tex/context/fonts/mkiv/minion-math.lfg
+++ b/tex/context/fonts/mkiv/minion-math.lfg
@@ -1,5 +1,14 @@
-local kern_W = { bottomright = { { kern = -150 } } }
-local kern_V = { bottomright = { { kern = -200 } } }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
+
+    local kern_W = { bottomright = { { kern = -150 } } }
+    local kern_V = { bottomright = { { kern = -200 } } }
+
+    kerns = {
+        [0x1D449] = kern_V, -- 𝑉
+        [0x1D44A] = kern_W, -- 𝑊
+    }
+
+end
 
 return {
     name = "minion-math",
@@ -21,10 +30,28 @@ return {
         },
     },
     mathematics = {
-        kerns = {
-            [0x1D449] = kern_V, -- 𝑉
-            [0x1D44A] = kern_W, -- 𝑊
-            -- todo: ssty 1/2
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = dimensions,
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/pagella-math.lfg b/tex/context/fonts/mkiv/pagella-math.lfg
index e2ed0eb43..3926ae95b 100644
--- a/tex/context/fonts/mkiv/pagella-math.lfg
+++ b/tex/context/fonts/mkiv/pagella-math.lfg
@@ -1,7 +1,31 @@
-local dimensions = {
-    [0x1D453] = { .40, 1.60, .5 }, -- offset width italic
---     [0x1D453] = { .0, 2, 0 }, -- offset width italic
-}
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
+
+    local kern_V   = { bottomright = { { kern = -200 } } }
+    local kern_W   = { bottomright = { { kern = -100 } } }
+
+    dimensions = {
+        default = {
+         -- [0x1D453]     = { xoffset = 162, width = 278 + 162 },-- 𝑓
+         -- [0x1D453]     = offset_f, -- 𝑓
+         -- ["1:0x1D453"] = offset_f, -- needed for compact
+         -- ["2:0x1D453"] = offset_f, -- needed for compact
+--                 ["*:0x1D453"] = offset_f, -- 𝑓
+        },
+    }
+
+    kerns = {
+     -- [0x1D449]     = kern_V, -- 𝑉
+     -- ["1:0x1D449"] = kern_V, -- needed for compact
+     -- ["2:0x1D449"] = kern_V, -- needed for compact
+     -- [0x1D44A]     = kern_W, -- 𝑊
+     -- ["1:0x1D44A"] = kern_W, -- needed for compact
+     -- ["2:0x1D44A"] = kern_W, -- needed for compact
+     -- ["*:0x1D453"] = kern_f,
+        ["*:0x1D449"] = kern_V, -- 𝑉
+        ["*:0x1D44A"] = kern_W, -- 𝑊
+    }
+
+end
 
 return {
     name = "pagella-math",
@@ -12,54 +36,47 @@ return {
     mathematics = {
         tweaks = {
             aftercopying = {
-                { "version",    "Version 1.632" },
-             -- { "action",     function(target,original) mathematics.tweaks.fixdimensions(target, original, fixes) },
-             -- { "action",     mathematics.tweaks.fixdimensions, fixes },
-                { "dimensions", dimensions },
+             -- {
+             --     tweak    = "version",
+             --     expected = "Version 1.632",
+             -- },
+             -- {
+             --     comment = "example"
+             --     tweak   = "action",
+             --     action  = function(target,original,parameters) mathematics.tweaks.fixdimensions(target, original, parameters)
+             --     list    = fixes, -- one of the parameters
+             -- },
+             -- {
+             --     comment = "example"
+             --     tweak   = "action",
+             --     action  = mathematics.tweaks.fixdimensions,
+             --     list    = fixes, -- one of the parameters
+             -- },
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        [0x1D453] = { .40, 1.60, .5 }, -- offset width italic
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
             },
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
-
--- local kern_V   = { bottomright = { { kern = -200 } } }
--- local kern_W   = { bottomright = { { kern = -100 } } }
--- ----- kern_f   = { bottomright = { { kern = -100 } } }
--- -- local offset_f = { xoffset = "llx" }
---
--- -- Beware of updates in ssty slots!
---
--- return {
---     name = "pagella-math",
---     version = "1.00",
---     comment = "Goodies that complement pagella.",
---     author = "Hans Hagen",
---     copyright = "ConTeXt development team",
---     mathematics = {
---         dimensions = {
---             default = {
---              -- [0x1D453]     = { xoffset = 162, width = 278 + 162 },-- 𝑓
---              -- [0x1D453]     = offset_f, -- 𝑓
---              -- ["1:0x1D453"] = offset_f, -- needed for compact
---              -- ["2:0x1D453"] = offset_f, -- needed for compact
--- --                 ["*:0x1D453"] = offset_f, -- 𝑓
---             },
---         },
---         kerns = {
---          -- [0x1D449]     = kern_V, -- 𝑉
---          -- ["1:0x1D449"] = kern_V, -- needed for compact
---          -- ["2:0x1D449"] = kern_V, -- needed for compact
---          -- [0x1D44A]     = kern_W, -- 𝑊
---          -- ["1:0x1D44A"] = kern_W, -- needed for compact
---          -- ["2:0x1D44A"] = kern_W, -- needed for compact
--- --             ["*:0x1D453"] = kern_f,
---             ["*:0x1D449"] = kern_V, -- 𝑉
---             ["*:0x1D44A"] = kern_W, -- 𝑊
---         },
---         alternates = {
---             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
---         },
---     },
--- }
diff --git a/tex/context/fonts/mkiv/schola-math.lfg b/tex/context/fonts/mkiv/schola-math.lfg
index b60bc6d99..0a4d66892 100644
--- a/tex/context/fonts/mkiv/schola-math.lfg
+++ b/tex/context/fonts/mkiv/schola-math.lfg
@@ -1,7 +1,14 @@
-local kern_V = { bottomright = { { kern = -200 } }, topright = { { kern = 50 } } }
-local kern_W = { bottomright = { { kern = -100 } }, topright = { { kern = 50 } } }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
 
--- Beware of updates in ssty slots!
+    local kern_V = { bottomright = { { kern = -200 } }, topright = { { kern = 50 } } }
+    local kern_W = { bottomright = { { kern = -100 } }, topright = { { kern = 50 } } }
+
+    kerns = {
+        [0x1D449] = kern_V, -- 𝑉
+        [0x1D44A] = kern_W, -- 𝑊
+    }
+
+end
 
 return {
     name = "schola-math",
@@ -10,18 +17,33 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
-        kerns = {
-         -- [0x1D449]     = kern_V, -- 𝑉
-         -- ["1:0x1D449"] = kern_V, -- needed for compact
-         -- ["2:0x1D449"] = kern_V, -- needed for compact
-         -- [0x1D44A]     = kern_W, -- 𝑊
-         -- ["1:0x1D44A"] = kern_W, -- needed for compact
-         -- ["2:0x1D44A"] = kern_W, -- needed for compact
-            ["*:0x1D449"] = kern_V, -- 𝑉
-            ["*:0x1D44A"] = kern_W, -- 𝑊
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    }
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/stix-two-math.lfg b/tex/context/fonts/mkiv/stix-two-math.lfg
index 8d9c9c71a..cc09da04b 100644
--- a/tex/context/fonts/mkiv/stix-two-math.lfg
+++ b/tex/context/fonts/mkiv/stix-two-math.lfg
@@ -1,34 +1,3 @@
--- Bah, I really hate these patches especially because one needs to make
--- sure that they are still valid when the font gets updated. So, let's
--- do it runtime (not in the cached copy) and issue a warning every run.
--- As we cannot rely on version numbers (if we have more patches) we
--- check for values instead.
---
--- This font also has inconsistent italics in smaller sizes which we can
--- fix in a more general way but I'm not sure if we want that.
-
-local function fix_italic(target,original,name,value,factor)
-    local m = target.parameters.mathsize
-    if m then
-        local u = type(name) == "number" and name or original.resources.unicodes[name]
-        if u then
-            local c = target.characters[u]
-            if c then
-                local i = c.italic
-                if i then
-                    local d = original.descriptions[u]
-                    if d and d.math.italic == value then
-                        if m then
-                            logs.report("patching font","fixing italic correction of %U at math size %i by %0.3f",u,m,factor)
-                            c.italic = factor * i
-                        end
-                    end
-                end
-            end
-        end
-    end
-end
-
 return {
     name = "stix-two-math",
     version = "1.00",
@@ -36,7 +5,6 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
-        -- these tags are suggestions and can still change
         alternates = {
             calligraphic = { feature = 'ss01', value = 1, comment = "Mathematical Alternative Calligraphic Characters" },
             italic       = { feature = 'ss02', value = 1, comment = "Mathematical Alternative Lowercase Italic" },
@@ -54,10 +22,22 @@ return {
         },
         tweaks = {
             aftercopying = {
-                function(target,original)
-                    fix_italic(target,original,"uni222B.updsp",80,3.5)
-                    fix_italic(target,original,"uni222B.up",   80,2.5)
-                end,
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
             },
         },
     },
diff --git a/tex/context/fonts/mkiv/termes-math.lfg b/tex/context/fonts/mkiv/termes-math.lfg
index da5a13d77..8752f0a3b 100644
--- a/tex/context/fonts/mkiv/termes-math.lfg
+++ b/tex/context/fonts/mkiv/termes-math.lfg
@@ -1,8 +1,22 @@
-local kern_V   = { bottomright = { { kern = -200 } } }
-local kern_W   = { bottomright = { { kern = -100 } } }
--- local offset_f = { xoffset = "llx" }
+local dimensions, kerns  if CONTEXTLMTXMODE == 0 then
+
+ -- local kern_V   = { bottomright = { { kern = -200 } } }
+ -- local kern_W   = { bottomright = { { kern = -100 } } }
+ -- local offset_f = { xoffset = "llx" }
+ --
+ -- dimensions = {
+ --     default = {
+ --         [0x1D453] = offset_f, -- 𝑓
+ --     },
+ -- }
+ --
+ -- kerns = {
+ --     [0x1D449] = kern_V, -- 𝑉
+ --     [0x1D44A] = kern_W, -- 𝑊
+ -- }
+
+end
 
--- Beware of updates in ssty slots!
 
 return {
     name = "termes-math",
@@ -11,26 +25,33 @@ return {
     author = "Hans Hagen",
     copyright = "ConTeXt development team",
     mathematics = {
-        dimensions = {
-            default = {
-             -- [0x1D453]     = offset_f, -- 𝑓
-             -- ["1:0x1D453"] = offset_f, -- needed for compact
-             -- ["2:0x1D453"] = offset_f, -- needed for compact
---                 ["*:0x1D453"] = offset_f, -- 𝑓
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
             },
         },
-        kerns = {
-         -- [0x1D449]     = kern_V, -- 𝑉
-         -- ["1:0x1D449"] = kern_V, -- needed for compact
-         -- ["2:0x1D449"] = kern_V, -- needed for compact
-         -- [0x1D44A]     = kern_W, -- 𝑊
-         -- ["1:0x1D44A"] = kern_W, -- needed for compact
-         -- ["2:0x1D44A"] = kern_W, -- needed for compact
-            ["*:0x1D449"] = kern_V, -- 𝑉
-            ["*:0x1D44A"] = kern_W, -- 𝑊
-        },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
         },
+        --
+        -- experimental fixes for mkiv:
+        --
+        dimensions = dimensions,
+        kerns = kerns,
     },
 }
diff --git a/tex/context/fonts/mkiv/xits-math.lfg b/tex/context/fonts/mkiv/xits-math.lfg
index 88d3a8d45..f166afc80 100644
--- a/tex/context/fonts/mkiv/xits-math.lfg
+++ b/tex/context/fonts/mkiv/xits-math.lfg
@@ -1,23 +1,3 @@
--- \setupbodyfont[xits]
---
--- $ABC$ $\cal ABC$ $\mathalternate{cal}\cal ABC$
---
--- \setupmathematics[italics=1] test $a;b;a; b; f;$ test\par % fontitalics
--- \setupmathematics[italics=2] test $a;b;a; b; f;$ test\par % fontdata
--- \setupmathematics[italics=3] test $a;b;a; b; f;$ test\par % quad based
--- \setupmathematics[italics=4] test $a;b;a; b; f;$ test\par % combination of 1 and 3
-
-local italics = {
-    defaultfactor = 0.025,
-    disableengine = true,
-    corrections   = {
-     -- [0x1D44E] = 0.99,    -- a (fraction of quad)
-     -- [0x1D44F] = 100,     -- b (font points)
-        [0x1D453] = -0.0375, -- f
-        -- todo: ssty 1/2
-    }
-}
-
 return {
     name = "xits-math",
     version = "1.00",
@@ -35,14 +15,26 @@ return {
         },
     },
     mathematics = {
-     -- italics = {
-     --     ["xits-math"] = italics,
-     -- },
-     -- kernpairs = {
-     --     [0x1D44A] = { -- 𝑊
-     --         [0x1D434] = -200, -- 𝐴
-     --     },
-     -- },
+        tweaks = {
+            aftercopying = {
+                {
+                    tweak = "dimensions",
+                    list  = {
+                        -- nothing yet
+                    },
+                },
+                {
+                    tweak  = "fixprimes",
+                    factor = 0.85,
+                },
+                {
+                    tweak = "checkspacing",
+                },
+                {
+                    tweak = "addscripts",
+                },
+            },
+        },
         alternates = {
             calligraphic = { feature = 'ss01', value = 1, comment = "Mathematical Calligraphic Alphabet" },
             greekssup    = { feature = 'ss02', value = 1, comment = "Mathematical Greek Sans Serif Alphabet" },
diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua
index 2a8f5349f..77d72f75b 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  : 2021-11-11 19:18
+-- merge date  : 2021-11-13 20:33
 
 do -- begin closure to overcome local limits and interference