diff options
Diffstat (limited to 'Master/texmf-dist/tex/context/base/mkxl/type-ini.mklx')
-rw-r--r-- | Master/texmf-dist/tex/context/base/mkxl/type-ini.mklx | 613 |
1 files changed, 613 insertions, 0 deletions
diff --git a/Master/texmf-dist/tex/context/base/mkxl/type-ini.mklx b/Master/texmf-dist/tex/context/base/mkxl/type-ini.mklx new file mode 100644 index 00000000000..bba2d433b20 --- /dev/null +++ b/Master/texmf-dist/tex/context/base/mkxl/type-ini.mklx @@ -0,0 +1,613 @@ +%D \module +%D [ file=type-ini, +%D version=2001.03.05, +%D title=\CONTEXT\ Typescript Macros, +%D subtitle=Initialization, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA ADE \& \CONTEXT\ Development Team}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See mreadme.pdf for +%C details. + +\writestatus{loading}{ConTeXt Typescript Macros / Initialization} + +\registerctxluafile{type-ini}{autosuffix} + +%D The default fontclass is empty. We could demand always using fontclasses, and +%D then make the calling macros simplier (always assume fontclass) but apart from +%D downward compatibility issues, it would make global, class spanning definitions a +%D pain. Some day we will introduce a default class. +%D +%D The \type {type-ini} and \type {font-ini} modules come as a pair and have mutual +%D dependencies. +%D +%D At some point we will only store in memory so some code can go away. + +\unprotect + +\newcount \c_font_typescripts_n_of_preloaded +\newconditional\c_font_typescripts_quit +\newtoks \c_font_typescripts_document +\newconditional\c_font_typescripts_preload +\newconditional\c_font_typescripts_first_pass \settrue\c_font_typescripts_first_pass + +\newif \iftypescriptfound % will become a mode +\newif \iftracetypescripts + +\newtoks \everybeforedefinetypeface +\newtoks \everyafterdefinetypeface + +\mutable\let\typescriptfiles \empty +\mutable\let\currenttypescripts\empty +\mutable\let\currenttypefile \empty + +\installmacrostack\currenttypefile + +\mutable\let\typescriptone \empty % public, used in typescripts +\mutable\let\typescripttwo \empty % public, used in typescripts +\mutable\let\typescriptthree\empty % public, used in typescripts + +\installmacrostack\typescriptone +\installmacrostack\typescripttwo +\installmacrostack\typescriptthree + +\mutable\let\fontclassstyle \empty + +\installmacrostack\fontclassstyle + +\let\m_font_typescripts_one \empty +\let\m_font_typescripts_two \empty +\let\m_font_typescripts_three\empty +\let\m_font_typescripts_check\empty +\let\m_font_typescripts_match\empty + +\installmacrostack\m_font_typescripts_one +\installmacrostack\m_font_typescripts_two +\installmacrostack\m_font_typescripts_three + +\mutable\let\t_font_typescripts\relax % uses as synonym + +\installcorenamespace{typescriptcache} +\installcorenamespace{typescriptfiles} +\installcorenamespace{typescriptonce} +\installcorenamespace{typescriptsynonyms} +\installcorenamespace{typescriptprefix} +\installcorenamespace{typescriptinheritances} +\installcorenamespace{typescriptdefaultstyles} +\installcorenamespace{typescriptrelatives} + +\definesystemvariable{ts} % TypeScript + +% tricky ... here we push/pop ... so \let + +\mutable\let\typescriptmethod\plusone % 1: empty==all==true 2: empty==false +\mutable\let\typescriptstate \plustwo % 1: process 2: store + +\installmacrostack\typescriptmethod +\installmacrostack\typescriptstate + +%D When these are loaded it is possible to get spaces but the whole idea is to do +%D that loading in vertical mode. Adding \type {\pushendofline} and \type +%D {\popendofline} is an option but not watertight as it can still interfere, for +%D instance work comments and leading spaces. Also, in horizontal mode it is likely +%D that one is also grouped and loading bodyfonts grouped is a real bad idea. +%D Ignoring all spaces is also not a solution. So, our verdict is: no catch. + +\permanent\protected\def\starttypescriptcollection % redefined on the fly + {\dosingleempty\font_typescripts_collection_start} + +\def\font_typescripts_collection_start[#tag]% + {} + +\permanent\let\stoptypescriptcollection\relax + +\permanent\protected\def\usetypescriptfile[#filename]% + {\ifcstok{#filename}\v!reset + \let\typescriptfiles\empty + \else + \splitfilename{#filename}% + \addtocommalist\splitoffbase\typescriptfiles + \fi} + +\installmacrostack\stoptypescript + +% \permanent\protected\def\usetypescript {\dotripleempty\font_typescripts_use_one} +% \permanent\protected\def\usetypescriptexact{\dotripleempty\font_typescripts_use_two} +% +% \def\font_typescripts_use_one{\let\typescriptmethod\plusone\font_typescripts_use} +% \def\font_typescripts_use_two{\let\typescriptmethod\plustwo\font_typescripts_use} +% +% \protected\def\font_typescripts_use[#one][#two][#three]% + +% todo: just pass the method ... also further on then .. first test + +\def\font_typescripts_use_one{\let\typescriptmethod\plusone\font_typescripts_use} +\def\font_typescripts_use_two{\let\typescriptmethod\plustwo\font_typescripts_use} + +\permanent\protected\def\usetypescript {\font_typescripts_use_one} +\permanent\protected\def\usetypescriptexact{\font_typescripts_use_two} + +\tolerant\protected\def\font_typescripts_use[#one]#spacer[#two]#spacer[#three]% + {\push_macro_m_font_typescripts_one + \push_macro_m_font_typescripts_two + \push_macro_m_font_typescripts_three + \edef\m_font_typescripts_one {\truetypescript{#one}}% + \edef\m_font_typescripts_two {\truetypescript{#two}}% + \edef\m_font_typescripts_three{\truetypescript{#three}}% + \push_macro_typescriptone + \push_macro_typescripttwo + \push_macro_typescriptthree + \push_macro_typescriptmethod + \push_macro_typescriptstate + \push_macro_stoptypescript + \typescriptfoundfalse + \let\typescriptstate\plusone % why + \iftracetypescripts + \writestatus\m!fonts{request: [\m_font_typescripts_one] [\m_font_typescripts_two] [\m_font_typescripts_three]}% + \fi + \ifhmode + \font_typescripts_use_inline + \else + \font_typescripts_use_display + \fi + \setfalse\c_font_typescripts_first_pass + \pop_macro_stoptypescript + \pop_macro_typescriptstate + \pop_macro_typescriptmethod + \pop_macro_typescriptthree + \pop_macro_typescripttwo + \pop_macro_typescriptone + \pop_macro_m_font_typescripts_three + \pop_macro_m_font_typescripts_two + \pop_macro_m_font_typescripts_one} + +\def\font_typescripts_use_display + {\processcommacommand[\typescriptfiles]\font_typescripts_load_file + \the\c_font_typescripts_document} + +\let\font_typescripts_use_inline\font_typescripts_use_display + +\permanent\protected\def\preloadtypescripts + {\ifproductionrun\settrue\c_font_typescripts_preload\fi} + +\prependtoks + \preloadtypescripts +\to \everyjob + +\permanent\protected\def\loadtypescriptfile[#1]% + {\push_macro_typescriptstate + \let\typescriptstate\plustwo % assumes 2 at the outer level + \clf_loadtypescriptfile{#1}% + \pop_macro_typescriptstate} + +\permanent\protected\def\loadfoundtypescriptfile#1#2% name foundname / not a user command + {\startreadingfile + \unprotect + \pushendofline + \input{#2}% + \popendofline + \protect + \stopreadingfile} + +\permanent\protected\def\quittypescriptscanning + {\settrue\c_font_typescripts_quit} % public + +\permanent\protected\def\font_typescripts_start_store#definitions\stoptypescript + {\global\advance\c_font_typescripts_n_of_preloaded\plusone + \gdefcsname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname + {\starttypescript#definitions\stoptypescript}% + \gtoksapp\t_font_typescripts\expandafter + {\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}} + +\permanent\protected\def\font_typescripts_collection_start_store#definitions\stoptypescriptcollection + {\global\advance\c_font_typescripts_n_of_preloaded\plusone + \gdefcsname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname + {\starttypescriptcollection#definitions\stoptypescriptcollection}% + \gtoksapp\t_font_typescripts\expandafter + {\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}} + +\def\font_typescripts_load_file#filename% + {\setfalse\c_font_typescripts_quit + \push_macro_currenttypefile + \def\currenttypefile{#filename}% + \ifconditional\c_font_typescripts_preload + \font_typescript_process_typescript_file_and_store + \else + \font_typescript_process_typescript_file + \fi + \pop_macro_currenttypefile + \ifconditional\c_font_typescripts_quit + \quitcommalist + \setfalse\c_font_typescripts_quit + \fi} + +\def\font_typescript_process_typescript_file_and_store + {\expandafter\let\expandafter\t_font_typescripts\csname\??typescriptfiles\currenttypefile\endcsname + \ifrelax\t_font_typescripts + \font_typescript_process_typescript_store_indeed + \fi + \the\t_font_typescripts} + +\def\font_typescript_process_typescript_store_indeed + {\newtoks\t_font_typescripts % is \relaxed elsewhere + \begingroup + \enforced\let\starttypescript \font_typescripts_start_store + \enforced\let\starttypescriptcollection\font_typescripts_collection_start_store + \font_typescript_process_typescript_file + \endgroup + \letcsname\??typescriptfiles\currenttypefile\endcsname\t_font_typescripts} + +\def\font_typescript_process_typescript_file + {\clf_loadtypescriptfile{\currenttypefile}} + +\permanent\tolerant\protected\def\usetypescriptonce[#one]#spacer[#two]#spacer[#three]% + {\ifcsname\??typescriptonce#one:#two:#three\endcsname + \writestatus\m!fonts{once (#one) (#two) (#three)}% + \else + \letcsname\??typescriptonce#one:#two:#three\endcsname\relax + \font_typescripts_use[#one][#two][#three]% + \fi} + +% \definetypescriptsynonym[lbr][cmr] + +\permanent\tolerant\protected\def\definetypescriptsynonym[#name]#spacer[#synonym]% + {\ifarguments\or\or\edefcsname\??typescriptsynonyms#name\endcsname{#synonym}\fi} + +\permanent\def\truetypescript#name% recursive so no \lastnamedcs + {\ifcsname\??typescriptsynonyms#name\endcsname + \expandafter\truetypescript\lastnamedcs + \else + #name% + \fi} + +% script [serif] [default] [size] +% script [serif] [computer-modern] [size] +% script [serif] [computer-modern] [ec] +% script [serif] [computer-modern] [name] +% script [serif] [computer-modern] [special] + +\prependtoks + \settrue\c_font_typescripts_first_pass +\to \everyjob + +\permanent\protected\def\starttypescript + {\ifcase\typescriptstate + % 0 = skip + \expandafter\font_typescripts_start_gobble + \or + % 1 = process + \expandafter\font_typescripts_start_process + \or + % 2 = store + \expandafter\font_typescripts_start_document + \else + % ? = skip + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_start_gobble#ignore\stoptypescript{} + +\def\font_typescripts_start_document#definitions\stoptypescript + {\toksapp\c_font_typescripts_document{\starttypescript#definitions\stoptypescript}} + +\def\font_typescripts_start_process % could be a faster \doifelsenextoptionalif needed + {\let\typescriptone \m_font_typescripts_one + \let\typescripttwo \m_font_typescripts_two + \let\typescriptthree\m_font_typescripts_three + \let\m_font_typescripts_match\empty + \doifelsenextoptionalcs\font_typescripts_start_process_one\font_typescripts_start_process_all} + +\def\font_typescripts_start_process_all % could be a \let + {\ifconditional\c_font_typescripts_first_pass + \expandafter\font_typescripts_start_process_indeed + \else + % skip this since it may do unwanted resets, like + % setting symbolic font names to unknown, especially + % in run time user type scripts + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_show_match + {\writestatus\m!fonts{match:\ifrelax\currenttypefile\space *\fi \m_font_typescripts_match}} + +\def\font_typescripts_start_process_yes + {\ifdone + \typescriptfoundtrue + \iftracetypescripts\font_typescripts_show_match\fi + \expandafter\font_typescripts_start_process_indeed + \else + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_start_process_one + {\font_typescripts_check\m_font_typescripts_one\typescriptone\font_typescripts_start_process_again_one} + +\def\font_typescripts_start_process_two + {\font_typescripts_check\m_font_typescripts_two\typescripttwo\font_typescripts_start_process_again_two} + +\def\font_typescripts_start_process_three + {\font_typescripts_check\m_font_typescripts_three\typescriptthree\font_typescripts_start_process_again_three} + +\def\font_typescripts_start_process_again_one + {\doifelsenextoptionalcs\font_typescripts_start_process_two\font_typescripts_start_process_yes} + +\def\font_typescripts_start_process_again_two + {\doifelsenextoptionalcs\font_typescripts_start_process_three\font_typescripts_start_process_yes} + +\let\font_typescripts_start_process_again_three\font_typescripts_start_process_yes + +\def\font_typescripts_start_process_indeed + {\push_macro_fontclass} + +\permanent\protected\def\stoptypescript + {\pop_macro_fontclass} + +\def\font_typescripts_check#asked#target#followup[#value]% script use value next + {\donefalse + \edef\m_font_typescripts_check{#value}% + \ifempty\m_font_typescripts_check % no longer needed / met + \ifcase\typescriptmethod\or\donetrue\fi + \orelse\ifx#asked\s!all + \donetrue + \orelse\ifx\m_font_typescripts_check\s!all + \donetrue + \orelse\ifx#asked\m_font_typescripts_check % saves 10% trace so probably faster too + \donetrue + \let#target\m_font_typescripts_check + \else + \doifelsecommon\m_font_typescripts_check#asked\donetrue\donefalse + \ifdone + \let#target\commalistelement + \fi + \fi + \ifdone + \iftracetypescripts\extendtypescriptmatch\fi + \expandafter#followup% + \else + \expandafter\font_typescripts_start_gobble + \fi} + +\permanent\protected\def\extendtypescriptmatch + {\edef\m_font_typescripts_match{\m_font_typescripts_match\space[\m_font_typescripts_check]}} + +%D Map files will go away in \LUATEX, but till that happens we use stripped down +%D support for loading them. + +\permanent\tolerant\protected\def\loadmapfile [#filename]{\clf_loadmapfile{#filename}} +\permanent\tolerant\protected\def\loadmapline [#kind]#spacer[#data]{\clf_loadmapline{#kind}{#data}} +\permanent \protected\def\forgetmapfiles {\clf_resetmapfiles} + +% \prependtoks +% \loadmapfile[mkiv-base.map]% can't we preload this one? +% \to \everystarttext + +%D A handy shortcut: + +% \definetypescriptprefix[serif][Serif] +% \definetypescriptprefix[sans] [Sans] +% \definetypescriptprefix[mono] [Mono] +% +% \starttypescript [serif,sans,mono] [handling,hanging,hz] [pure,normal,hz,quality] +% \setupfontsynonym [\typescriptprefix\typescriptone] [handling=\typescriptthree] +% \stoptypescript + +\permanent\tolerant\protected\def\definetypescriptprefix[#name]#spacer[#prefix]% + {\gdefcsname\??typescriptprefix#name\endcsname{#prefix}} % made global + +\permanent\def\typescriptprefix#name% + %{\ifcsname\??typescriptprefix#name\endcsname\csname\??typescriptprefix#name\endcsname\else#name\fi} + {\ifcsname\??typescriptprefix#name\endcsname\lastnamedcs\else#name\fi} + +% defining typefaces: +% +% \definetypeface [joke] [rm] +% \definetypeface [joke] [rm] [settings] +% \definetypeface [joke] [rm] [serif] [lucida] +% \definetypeface [joke] [rm] [serif] [lucida] [size] +% \definetypeface [joke] [rm] [serif] [lucida] [size] [settings] +% \definetypeface [joke] [specification] + +\appendtoks + \font_helpers_reset_fontclass_math_families\fontclass +\to \everybeforedefinetypeface + +%D This hooks into the font switcher: + +\settrue\autotypescripts + +\protected\def\fonts_helpers_try_currentfontclass#typeface% + {\ifconditional\autotypescripts + \usetypescript[#typeface]% + \ifcsname\??fontclassyes#typeface\endcsname + \edef\fontclass{#typeface}% + \else + \iftracetypescripts\writestatus\m!fonts{auto load typescript file 1: [#typeface]}\fi + \usetypescriptfile[#typeface]% + \usetypescript[#typeface]% + \ifcsname\??fontclassyes#typeface\endcsname + \edef\fontclass{#typeface}% + \else + % todo: message + \letcsname\??fontclassnop#typeface\endcsname\empty + \fi + \fi + \else + % todo: message + \letcsname\??fontclassnop#typeface\endcsname\empty + \fi} + +%D Now we define: + +\permanent\tolerant\protected\def\definetypeface[#name]#spacer[#style]#spacer[#fontshape]#spacer[#fontname]#spacer[#fontsize]#spacer[#settings]% + {\ifarguments + \expandafter\font_typefaces_define_e + \or + \expandafter\font_typefaces_define_d + \or + \expandafter\font_typefaces_define_d + \or + \expandafter\font_typefaces_define_c + \or + \expandafter\font_typefaces_define_b + \or + \expandafter\font_typefaces_define_a + \or + \expandafter\font_typefaces_define_a + \fi[#name][#style][#fontshape][#fontname][#fontsize][#settings]} + +\def\font_typefaces_define_e[#name][#style][#fontshape][#fontname][#fontsize][#settings]% + {} + +\def\font_typefaces_define_a[#name][#style][#fontshape][#fontname][#fontsize][#settings]% + {\iftracetypescripts\writestatus\m!fonts{define: [#name] [#style] [#fontshape] [#fontname]}\fi + \font_typefaces_define_indeed[#name][#style]% + \font_typefaces_defining_start{#name}{#style}{#settings}% + \font_typescripts_use_one[#fontshape][#fontname][\s!name]% [\s!name,\s!default]% + \iftypescriptfound + % we're okay + \orelse\ifconditional\autotypescripts + \iftracetypescripts\writestatus\m!fonts{auto load typescript file 2: [#fontname]}\fi + \usetypescriptfile[#fontname]% + \font_typescripts_use_one[#fontshape][#fontname][\s!name]% [\s!name,\s!default]% + \fi + \font_typescripts_use_one[#fontshape][#fontsize][\s!size]% + \font_typefaces_defining_stop} + +\def\font_typefaces_define_b[#name][#style][#fontshape][#fontname][#discard][#discard]% + {\font_typefaces_define_a[#name][#style][#fontshape][#fontname][\s!default][#discard]} + +\def\font_typefaces_define_c[#name][#style][#discard][#discard][#discard][#discard]% + {\font_typefaces_define_indeed[#name][#style]} + +\def\font_typefaces_define_d[#name][#specification][#discard][#discard][#discard][#discard]% use definitions in lfg file + {\clf_definetypeface{#name}{#specification}} + +\def\font_typefaces_define_indeed[#name][#style]% saveguard against redefinition + {\doifsomething{#name} + {\ifcsname\??typescriptdefaultstyles#name\endcsname \else + \registerfontclass{#name}% + \gdefcsname\??typescriptdefaultstyles#name\endcsname{#style}% + \fi + \ifcsname#name\endcsname \else + \protected\frozen\instance\gdefcsname#name\endcsname{\switchtotypeface[#name][#style]}% + \fi}} + +\def\font_typefaces_defining_start#name#style#settings% + {\let\m_ts_rscale \!!plusone % as we push/pop + \let\m_ts_features \empty + \let\m_ts_fallbacks \empty + \let\m_ts_goodies \empty + \let\m_ts_direction \empty + \let\m_ts_designsize\empty + \geteparameters[m_ts_][#settings]% todo raw ... no need for key interpretation + \push_macro_fontclass + \push_macro_fontclassstyle + \setcurrentfontclass{#name}% + \savefontclassparameters{#style}\m_ts_rscale\m_ts_features\m_ts_fallbacks\m_ts_goodies\m_ts_designsize\m_ts_direction + \the\everybeforedefinetypeface} + +\permanent\def\tsvar#key#default% undocumented and unofficial + {\expandafter\ifempty\csname\??ts#key\endcsname + #default% + \else + \csname\??ts#key\endcsname + \fi} + +\def\font_typefaces_defining_stop + {\the\everyafterdefinetypeface + \pop_macro_fontclassstyle + \pop_macro_fontclass} + +\permanent\protected\def\dofastdefinetypeface#name#style#fontshape#fontsize#settings% called from the lua end (via case d) + {\font_typefaces_define_indeed[#name][#style]% + \font_typefaces_defining_start{#name}{#style}{#settings}% + \font_typescripts_use_one[#fontshape][#fontsize][\s!size]% + \font_typefaces_defining_stop} + +\permanent\tolerant\protected\def\setuptypeface[#class]#spacer[#settings]% + {\ifarguments + \or + \setcurrentfontclass{#class}% + \let\globalfontclass\fontclass + \ifempty\fontclass + \setupbodyfont[\s!rm]% + \orelse\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + \expandafter\setupbodyfont\expandafter[\lastnamedcs]% + \else + \setupbodyfont[\s!rm]% + \fi + \or + \setcurrentfontclass{#class}% + \let\globalfontclass\fontclass + \setupbodyfont[#settings]% + \fi + \ifmmode\mr\else\tf\fi} % needed ? + +\permanent\tolerant\protected\def\switchtotypeface[#class]#spacer[#settings]% + {\ifarguments + \or + \setcurrentfontclass{#class}% + \let\globalfontclass\globalfontclass + \ifempty\fontclass + \switchtobodyfont[\s!rm]% + \orelse\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + \expandafter\switchtobodyfont\expandafter[\lastnamedcs]% + \else + \switchtobodyfont[\s!rm]% + \fi + \or + \setcurrentfontclass{#class}% + \let\globalfontclass\globalfontclass + \switchtobodyfont[#settings]% + \fi + \ifmmode\mr\else\tf\fi} % needed ? + +%D For Taco: +%D +%D \starttyping +%D \inherittypeface[palatino][rm][postscript] +%D \inherittypeface[palatino][rm][\fontclass] +%D \inherittypeface[palatino][rm] % == \fontclass +%D \inherittypeface[palatino] % == [rm,ss,tt,mm] +%D \stoptyping + +\permanent\tolerant\protected\def\inherittypeface[#name]#spacer[#styles]#spacer[#parentclass]% + {\iftok{#styles}\emptytoks + \inherittypeface[#name][\s!rm,\s!ss,\s!tt,\s!mm][\fontclass]% + \orelse\iftok{#name}{#parentclass}\else + \glet\font_typescripts_inherit_check\font_typescripts_inherit_check_indeed + \def\font_typescripts_inherit_check_step#style{\edefcsname\??typescriptinheritances#name:#style\endcsname{#parentclass}}% + \processcommalist[#styles]\font_typescripts_inherit_check_step + \fi} + +\let\font_typescripts_inherit_check_step\relax + +%D This hooks into the font mechanism with: + +\def\font_typescripts_inherit_check_indeed#name% called often + {\ifcsname\??typescriptinheritances\fontclass:#name\endcsname + %\expandafter\let\expandafter\fontclass\csname\??typescriptinheritances\fontclass:#name\endcsname + \expandafter\let\expandafter\fontclass\lastnamedcs + \fi} + +\let\font_typescripts_inherit_check\gobbleoneargument + +\def\v_font_string_d % default fontstyle (expands to \s!Serif in font-ini) + {\expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!rm \s!Serif \else % no \orelse ! + \expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!ss \s!Sans \else % no \orelse ! + \expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!tt \s!Mono \else % no \orelse ! + \s!Serif \fi\fi\fi} + +\protected\def\font_helpers_set_fontstyle_of_fontclass + {\ifempty\fontclass + \let\fontstyle\s!rm + \orelse\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + %\edef\fontstyle{\csname\??typescriptdefaultstyles\fontclass\endcsname}% + \edef\fontstyle{\lastnamedcs}% + \else + \let\fontstyle\s!rm + \fi} + +\protect \endinput |