Module:Lang: Difference between revisions

(6 intermediate revisions by 4 users not shown)

Line 1:

--[=[

Lua support for the {{lang}}, {{lang-xx}}, and {{~~transl~~}} templates and replacement of various supporting templates.

Lua support for the {{lang}}, {{langx}}, {{lang-??}}, and {{transliteration}} templates and replacement of various supporting templates.

]=]

require('~~Module:No globals~~');

require('strict');

local getArgs = require ('Module:Arguments').getArgs;

local unicode = require ("Module:Unicode data"); -- for ~~is_latin~~() and is_rtl()

local unicode = require ("Module:Unicode data"); -- for is_Latin() and is_rtl()

local yesno = require ('Module:Yesno');

Line 22:

local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code

local cfg = mw.loadData ('Module:Lang/configuration' .. (mw.getCurrentFrame():getTitle():match ('/sandbox') or '')); -- for internationalization

local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization

Line 33:

Line 35:

local maint_cats = {}; -- maintenance categories go here

local maint_msgs = {}; -- and their messages go here

--[[--------------------------< M A K E _ E R R O R _ S P A N >--------------------------------------------------

]]

local function make_error_span (template, msg)

return table.concat ({'<span style="color:#d33">', cfg.misc_text_t.error, ': ', template, msg, '</span>'})

end

--[[--------------------------< S U B S T I T U T E >----------------------------------------------------------

Substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when

<data_t> not nil; returns <message> else.

]]

local function substitute (message, data_t)

return data_t and mw.message.newRawMessage (message, data_t):plain() or message;

end

--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------

Assembles an error message from template name, message text, help link, and error category.

]]

local function make_error_msg (msg, args_t, template)

local category;

local text; -- handle the oddity that is {{langx}}

if cfg.templates_t.langxx == template then

text = args_t.text or args_t[1]; -- for {{lang-xx}}

else

text = args_t.text or args_t[2]; -- for {{lang}}, {{langx}}, and {{transliteration}}

end

if cfg.templates_t.transliteration == template then

category = cfg.make_error_msg_t.xlit_err_cat;

else

category = cfg.make_error_msg_t.lang_err_cat;

end

local category_link = ((0 == namespace or 10 == namespace) and not args_t.nocat) and substitute ('[[Category:$1]]', {category}) or '';

return substitute ('[$1] <span style="color:#d33">$2: {{$3}}: $4 ([[:Category:$5|$6]])</span>$7',

{

text or cfg.make_error_msg_t.undefined,

cfg.misc_text_t.error,

template,

msg,

category,

cfg.misc_text_t.help,

category_link

})

end

--[[--------------------------< P A R A M E T E R _ V A L I D A T E >------------------------------------------

]]

local function parameter_validate (args_t, template)

local err_msg = cfg.parameter_validate_t.invalid_param;

if cfg.templates_t.lang == template then -- for {{lang}}

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_lang_t[param] and -- unique {{lang}} parameters

not cfg.known_params_t.common_params_all_t[param] then -- common to all

return substitute (err_msg, {param}); -- <param> not found so abandon

end

elseif cfg.templates_t.langx == template then -- for {{langx}}

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_langx_t[param] and -- unique {{langx}} parameters

not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}}

not cfg.known_params_t.common_params_all_t[param] then -- common to all

return substitute (err_msg, {param}); -- <param> not found so abandon

end

elseif cfg.templates_t.langxx == template then -- for {{lang-xx}}

for param, _ in pairs (args_t) do

if not cfg.known_params_t.params_lang_xx_t[param] and -- unique {{lang-xx}} parameters

not cfg.known_params_t.params_x_t[param] and -- common to {{langx}} and {{lang-xx}}

not cfg.known_params_t.common_params_all_t[param] then -- common to all

return substitute (err_msg, {param}); -- <param> not found so abandon

end

--[[--------------------------< I S _ S E T >------------------------------------------------------------------

Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not an empty string.

Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not

an empty string.

]]

local function is_set( var )

local function is_set (var)

return not (var == nil or var == '');

end

Line 94:

Line 187:

--[[--------------------------< V A L I D A T E _ I T A L I C >------------------------------------------------

~~validates~~ |italic= or |italics= assigned values.

Validates |italic= or |italics= assigned values.

When |italic= is set and has an acceptible assigned value, return the matching css font-style property value or,

Line 104:

Line 197:

The return value nil causes the calling lang, lang_xx, or transl function to set args.italic according to the template's

defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on

defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-??}} depending on

the individual template's requirements, 'italic' for {{~~transl~~}}) or to the value appropriate to |script=, if set ({{lang}}

the individual template's requirements, 'italic' for {{transliteration}}) or to the value appropriate to |script=, if set ({{lang}}

and {{lang-xx}} only).

and {{lang-??}} only).

Accepted values and the values that this function returns are are:

Line 119:

Line 212:

local function validate_italic (args)

local properties = {[~~'yes'~~] = 'italic', [~~'no'~~] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil};

local properties = {[cfg.keywords_t.affirmative] = 'italic', [cfg.keywords_t.negative] = 'normal', [cfg.keywords_t.unset] = 'inherit', [cfg.keywords_t.invert] = 'invert', [cfg.keywords_t.default] = nil};

local count = 0

Line 129:

Line 222:

if count > 1 then -- return nil and an error message if more than one is set

return nil, ~~'only one of |italic=, |italics=, or |i= can be specified'~~;

return nil, cfg.validate_italic_t.multi_italic;

end

Line 138:

Line 231:

--[=[--------------------------< V A L I D A T E _ C A T _ A R G S >----------------------------------------------------------

Default behavior of the {{lang}} and {{lang-xx}} templates is to add categorization when the templates are used in mainspace.

Default behavior of the {{lang}} and {{lang-??}} templates is to add categorization when the templates are used in mainspace.

This default functionality may be suppressed by setting |nocat=yes or |cat=no. This function selects one of these two parameters

to control categorization.

Line 170:

Line 263:

--[[--------------------------< I N _ A R R A Y >--------------------------------------------------------------

Whether needle is in haystack

Whether needle is in haystack.

]]

local function in_array ( needle, haystack )

local function in_array (needle, haystack)

if needle == nil then

return false;

end

for n,v in ipairs( haystack ) do

for n,v in ipairs (haystack) do

if v == needle then

return n;

Line 189:

Line 282:

--[[--------------------------< F O R M A T _ I E T F _ T A G >------------------------------------------------

~~prettify~~ ietf tags to use recommended subtag formats:

Prettify ietf tags to use recommended subtag formats:

code: lower case

script: sentence case

Line 225:

Line 318:

--[[--------------------------< G E T _ I E T F _ P A R T S >--------------------------------------------------

~~extracts~~ and returns IETF language tag parts:

Extracts and returns IETF language tag parts:

primary language subtag (required) - 2 or 3 character IANA language code

script subtag - four character IANA script code

Line 239:

Line 332:

lang-x-private

each of lang, script, region, variant, and private, when used, must be valid

each of lang, script, region, variant, and private, when used, must be valid.

Languages with both two- and three-character code synonyms are promoted to the two-character synonym because

Line 245:

Line 338:

the synonymous three-character codes in the lang= attribute.

For {{lang-xx}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}

For {{lang-??}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}

because those parameters are superfluous to the IETF subtags in |code=)

because those parameters are superfluous to the IETF subtags in |code=).

~~returns~~ six values; all lower case. Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid

Returns six values; all lower case. Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid

parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil.

~~see~~ http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1

See http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1.

]]

Line 259:

Line 352:

if not is_set (source) then

return nil, nil, nil, nil, nil, ~~'missing language tag'~~;

return nil, nil, nil, nil, nil, cfg.get_ietf_parts_t.missing_lang_tag;

end

Line 314:

Line 407:

if not code then

return nil, nil, nil, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized language tag: ',~~ source}); -- don't know what we got but it is malformed

return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_tag, {source}); -- don't know what we got but it is malformed

end

Line 320:

Line 413:

if not (override_table[code] or lang_table[code] or synonym_table[code] or lang_dep_table[code]) then

return nil, nil, nil, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized language code: ',~~ code}); -- invalid language code, don't know about the others (don't care?)

return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_code, {code}); -- invalid language code, don't know about the others (don't care?)

end

if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym

table.insert (maint_cats, ~~table~~.~~concat (~~{~~'Lang and lang-xx code promoted to ISO 639-1|',~~ code}));

table.insert (maint_cats, substitute (cfg.get_ietf_parts_t.maint_promo_cat, {code}));

table.insert (maint_msgs, ~~table~~.~~concat (~~{~~'code: ', code, ' promoted to~~ code~~: '~~, synonym_table[code]}));

table.insert (maint_msgs, substitute (cfg.get_ietf_parts_t.maint_promo_msg, {code, synonym_table[code]}));

code = synonym_table[code]; -- use the synonym

end

Line 331:

Line 424:

if is_set (script) then

if is_set (args_script) then

return code, nil, nil, nil, nil, ~~'redundant script tag'~~; -- both code with script and |script= not allowed

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_scr; -- both code with script and |script= not allowed

end

else

Line 340:

Line 433:

script = script:lower(); -- ensure that we use and return lower case version of this

if not script_table[script] then

return code, nil, nil, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized~~ script~~: ', script, ' for code: '~~, code}); -- language code ok, invalid script, don't know about the others (don't care?)

return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_scr_code, {script, code}); -- language code ok, invalid script, don't know about the others (don't care?)

end

if suppressed_table[script] then -- ensure that code-script does not use a suppressed script

if in_array (code, suppressed_table[script]) then

return code, nil, nil, nil, nil, ~~table~~.~~concat (~~{'script~~: ', script, ' not supported for code: '~~, code}); -- language code ok, script is suppressed for this code

return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.script_code, {script, code}); -- language code ok, script is suppressed for this code

end

Line 351:

Line 444:

if is_set (region) then

if is_set (args_region) then

return code, nil, nil, nil, nil, ~~'redundant region tag'~~; -- both code with region and |region= not allowed

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_reg; -- both code with region and |region= not allowed

end

else

Line 360:

Line 453:

region = region:lower(); -- ensure that we use and return lower case version of this

if not region_table[region] then

return code, script, nil, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized~~ region~~: ', region, ' for code: '~~, code});

return code, script, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_reg_code, {region, code});

end

Line 366:

Line 459:

if is_set (variant) then

if is_set (args_variant) then

return code, nil, nil, nil, nil, ~~'redundant variant tag'~~; -- both code with variant and |variant= not allowed

return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_var; -- both code with variant and |variant= not allowed

end

else

Line 375:

Line 468:

variant = variant:lower(); -- ensure that we use and return lower case version of this

if not variant_table[variant] then -- make sure variant is valid

return code, script, region, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized variant: ',~~ variant});

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var, {variant});

end -- does this duplicate/replace tests in lang() and lang_xx()?

if is_set (script) then -- if script set it must be part of the 'prefix'

if not in_array (table.concat ({code, '-', script}), variant_table[variant]['prefixes']) then

return code, script, region, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized~~ variant~~: ', variant, ' for code-script pair: '~~, code~~, '-'~~, script});

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_scr, {variant, code, script});

end

elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound)

if not in_array (code, variant_table[variant]['prefixes']) then -- first see if lang code is all that's required (en-oxendict though en-GB-oxendict is preferred)

if not in_array (table.concat ({code, '-', region}), variant_table[variant]['prefixes']) then -- now try for lang code and region (en-CA-newfound)

return code, script, region, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized~~ variant~~: ', variant, ' for code-region pair: '~~, code~~, '-'~~, region});

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_reg, {variant, code, region});

end

else -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0

if variant_table[variant]['prefixes'][1] and not in_array (code, variant_table[variant]['prefixes']) then

return code, script, region, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized~~ variant~~: ', variant, ' for code: '~~, code});

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code, {variant, code});

end

Line 397:

Line 490:

private = private:lower(); -- ensure that we use and return lower case version of this

if not override_table[table.concat ({code, '-x-', private})] then -- make sure private tag is valid; note that index

return code, script, region, nil, nil, ~~table~~.~~concat (~~{~~'unrecognized private tag: ',~~ private});

return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_pri, {private});

end

Line 403:

Line 496:

end

~~--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------~~

~~assembles an error message from template name, message text, help link, and error category.~~

]]

~~local function make_error_msg (msg, args, template)~~

~~local out = {};~~

~~local category;~~

~~if 'Transl' == template then~~

~~category = 'Transl';~~

~~else~~

~~category = 'Lang and lang-xx'~~

~~end~~

~~table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available~~

~~table.insert (out, table.concat ({'<span style=\"color:#d33\">Error: {{', template, '}}: '}));~~

~~table.insert (out, msg);~~

~~table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));~~

~~table.insert (out, '</span>');~~

~~if (0 == namespace or 10 == namespace) and not args.nocat then -- categorize in article space (and template space to take care of broken usages)~~

~~table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'}));~~

~~end~~

~~return table.concat (out);~~

~~end~~

--[=[-------------------------< M A K E _ W I K I L I N K >----------------------------------------------------

Line 457:

Line 520:

--[[--------------------------< D I V _ M A R K U P _ A D D >--------------------------------------------------

~~adds~~ <i> and </i> tags to list-item text or to implied <p>..</p> text. ~~mixed~~ not supported

Adds <i> and </i> tags to list-item text or to implied <p>..</p> text. Mixed not supported.

]]

local function div_markup_add (text, style)

~~local implied_p = {};~~

if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text

if 'italic' == style then

Line 484:

Line 545:

return text;

end

--[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------

Makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where

<title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in

html markup. This because the lang= attibute applies to the content of its enclosing tag.

<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag.

]]

local function title_wrapper_make (title_text, content_text, tag)

local wrapper_t = {};

table.insert (wrapper_t, table.concat ({'<', tag})); -- open opening wrapper tag

table.insert (wrapper_t, ' title=\"'); -- begin title attribute

table.insert (wrapper_t, title_text); -- add <title_text>

table.insert (wrapper_t, '\">'); -- end title attribute and close opening wrapper tag

table.insert (wrapper_t, content_text); -- add <content_text>

table.insert (wrapper_t, table.concat ({'</', tag, '>'})); -- add closing wrapper tag

return table.concat (wrapper_t); -- make a big string and done

end

Line 491:

Line 576:

Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or

<div> tags for block content

The lang= attribute also applies to the content of the tag where it is placed so this is wrong because 'Spanish

language text' is English:

should be:

or for <div>...</div>:

]]

local function make_text_html (code, text, tag, rtl, style, size, language)

local ~~html~~ = {};

local html_t = {};

local style_added = '';

local wrapper_tag = tag; -- <tag> gets modified so save a copy for use when/if we create a wrapper span or div

if text:match ('^%*') then

table.insert (~~html~~, '*'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki

table.insert (html_t, '*'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki

text = text:gsub ('^%*', ''); -- remove the splat from the text

end

Line 511:

Line 605:

end

table.insert (~~html~~, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag

table.insert (html_t, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag

code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia

table.insert (~~html~~, table.concat ({' lang="', code, '\"'})); -- add language attribute

table.insert (html_t, table.concat ({' lang="', code, '\"'})); -- add language attribute

if (rtl or unicode.is_rtl(text)) and ('ltr' == this_wiki_lang_dir) then -- text is right-to-left on a left-to-right wiki

table.insert (~~html~~, ' dir="rtl"'); -- add direction attribute for right-to-left languages

table.insert (html_t, ' dir="rtl"'); -- add direction attribute for right-to-left languages

elseif not (rtl or unicode.is_rtl(text)) and ('rtl' == this_wiki_lang_dir) then -- text is left-to-right on a right-to-left wiki

table.insert (~~html~~, ' dir="ltr"'); -- add direction attribute for left-to-right languages

table.insert (html_t, ' dir="ltr"'); -- add direction attribute for left-to-right languages

end

if 'normal' == style then -- when |italic=no

table.insert (~~html~~, ' style=\"font-style: normal;'); -- override external markup, if any

table.insert (html_t, ' style=\"font-style: normal;'); -- override external markup, if any

style_added = '\"'; -- remember that style attribute added and is not yet closed

end

Line 528:

Line 622:

if is_set (size) then -- when |size=<something>

if is_set (style_added) then

table.insert (~~html~~, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted

table.insert (html_t, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted

else

table.insert (~~html~~, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute

table.insert (html_t, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute

style_added = '\"'; -- remember that style attribute added and is not yet closed

end

~~if is_set~~ (~~language~~) ~~then~~

table.insert (html_t, table.concat ({style_added, '>'})); -- close the opening html tag

table.insert (~~html~~, table.concat ({~~style_added~~, ' ~~title=\"~~'~~, language~~})); -- ~~start~~ the title ~~text~~

table.insert (html_t, text); -- insert the text

if 'zxx' == code then -- special case for this tag

~~table.insert~~ (~~html,~~ ' ~~text~~'); -- not a language so don't use 'language' in title text

table.insert (html_t, table.concat ({'</', tag, '>'})); -- close the 'text' <i>, <span>, or <div> html tag

elseif mw.ustring.find (language, 'languages', 1, true) then

~~table.insert~~ (~~html~~, ' collective ~~text'~~); -- for collective languages

if is_set (language) then -- create a <title_text> string for the title= attribute in a wrapper span or div

else

local title_text;

~~table.insert~~ (~~html,~~ '-language ~~text'~~); -- for individual languages

if 'zxx' == code then -- special case for this tag 'no linguistic content'

end

title_text = substitute ('$1 $2', {language, cfg.make_text_html_t.zxx}); -- not a language so don't use 'language' in title text

table.~~insert~~ (~~html~~, ~~'\">'~~); ~~-- close the opening html tag~~

elseif mw.ustring.find (language, 'languages', 1, true) then

title_text = substitute ('$1 $2', {language, cfg.make_text_html_t.collective}); -- for collective languages

else

title_text = substitute ('$1-$2', {language, cfg.make_text_html_t.individual}); -- for individual languages

end

return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag);

else

~~table.insert (html,~~ table.concat (~~{style_added, '>'})~~); ~~-- close the style attribute and close opening html tag~~

return table.concat (html_t);

end

~~table.insert (html, text); -- insert the text~~

~~table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag~~

~~return table.concat (html); -- put it all together and done~~

end

Line 561:

Line 656:

[[Category:Articles containing <language>-language text]]

~~for~~ English:

For English:

[[Category:Articles containing explicitly cited English-language text]]

~~for~~ ISO 639-2 collective languages (and for 639-1 bh):

For ISO 639-2 collective languages (and for 639-1 bh):

[[Category:Articles with text in <language> languages]]

Line 570:

Line 665:

local function make_category (code, language_name, nocat, name_get)

~~local cat = {};~~

~~local retval;~~

if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space

return ''; -- return empty string for concatenation

Line 578:

Line 670:

if mw.ustring.find (language_name, 'languages', 1, true) then

return ~~table.concat~~ ({'[[~~Category:Articles with text in~~ ', language_name~~, ']]'~~});

return substitute ('[[$1 $2]]', {cfg.make_category_t.collective_cat, language_name});

end

~~table.insert (cat, '[[Category:Articles containing ');~~

if this_wiki_lang_tag == code then

return substitute ('[[$1 $2 $3-$4]]', { -- unique category name for the local language

if ~~'en'~~ == code then

cfg.make_category_t.cat_prefix,

~~table.insert~~ (~~cat,~~ '~~explicitly cited~~ ' .. language_name); ~~-- falls back to English if regional name not available~~

cfg.make_category_t.explicit_cat,

language_name,

cfg.make_category_t.cat_postfix,

});

else

~~table~~.~~insert (cat~~, language_name);

return substitute ('[[$1 $2-$3]]', { -- category for individual languages

cfg.make_category_t.cat_prefix,

language_name,

cfg.make_category_t.cat_postfix,

});

end

~~table.insert (cat, '-language text]]');~~

~~return table.concat (cat);~~

end

Line 597:

Line 692:

--[[--------------------------< M A K E _ T R A N S L I T >----------------------------------------------------

~~return~~ translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string

Return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string.

The value |script= is not used in {{~~transl~~}} for this purpose; instead it uses |code. Because language scripts

The value |script= is not used in {{transliteration}} for this purpose; instead it uses |code. Because language scripts

are listed in the {{~~transl~~}} switches they are included in the data tables. The script parameter is introduced

are listed in the {{transliteration}} switches they are included in the data tables. The script parameter is introduced

at {{Language with name and transliteration}}. If |script= is set, this function uses it in preference to code.

To avoid confusion, in this module and the templates that use it, the transliteration script parameter is renamed

to be |translit-script= (in this function, tscript)

to be |translit-script= (in this function, tscript).

This function is used by both lang_xx() and transl()

Line 610:

Line 705:

transl() always provides language_name, translit, and one of code or tscript, never both; always provides style

For {{~~transl~~}}, style only applies when a language code is provided

For {{transliteration}}, style only applies when a language code is provided.

]]

local function make_translit (code, language_name, translit, std, tscript, style)

local function make_translit (code, language_name, translit, std, tscript, style, engvar)

local ~~title;~~

local title_t = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards

~~local tout = {};~~

local title_text = ''; -- tool tip text for title= attribute

~~local title_table~~ = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards

~~if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})~~

~~if not style then -- nil for the default italic style~~

~~table.insert (tout, "<i lang~~=~~\""); -- so use <i> tag~~

~~else~~

~~table.insert (tout, table.concat ({~~'~~<span style=\"font-style:~~ '~~, style, '\" lang=\"'}))~~; -- ~~non-standard style, construct a span tag~~ for it

~~end~~

~~table.insert (tout, code);~~

~~table.insert (tout, "-Latn\"~~ title~~=\""); -- transliterations are always Latin script~~

~~else~~

~~table.insert (tout, "<span title=\""); -- when no language code: no lang~~= attribute~~, not italic ({{transl}} only)~~

~~end~~

std = std and std:lower(); -- lower case for table indexing

if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified

~~table.insert (tout,~~ language_name); -- write a generic tool tip

title_text = language_name; -- write a generic tool tip

if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)

~~table.insert~~ (~~tout,~~ '-language') -- skip this text (individual and macro languages only)

title_text = substitute ('$1-$2', {title_text, cfg.misc_text_t.language}); -- skip this text (individual and macro languages only)

end

~~table~~.~~insert~~ (~~tout,~~ ' ~~romanization~~'); -- finish the tool tip; use romanization when neither script nor standard supplied

title_text = substitute ('$1 $2', {title_text, mw.ustring.lower (cfg.engvar_t[engvar]['romanisz_lc'])}); -- finish the tool tip; use romanization when neither script nor standard supplied

elseif is_set (std) and is_set (tscript) then -- when both are specified

if ~~title_table~~[std] then -- and if standard is legitimate

if title_t[std] then -- and if standard is legitimate

if ~~title_table~~[std][tscript] then -- and if script for that standard is legitimate

if title_t[std][tscript] then -- and if script for that standard is legitimate

if script_table[tscript] then

~~table.insert~~ (~~tout~~, ~~table.concat (~~{~~title_table~~[std][tscript:lower()], ~~' (',~~ script_table[tscript], ' script) transliteration'})); ~~-- add the appropriate text to the tool tip~~

title_text = substitute ('$1$2 ($3 $4) $5', { -- add the appropriate text to the tool tip

title_text,

title_t[std][tscript:lower()],

script_table[tscript],

cfg.make_translit_t.script,

cfg.make_translit_t.transliteration,

});

else

~~table~~.~~insert (tout, title_table~~[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

end

else

~~table~~.~~insert (tout, title_table~~[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?

end

else

Line 654:

Line 744:

elseif is_set (std) then -- translit-script not set, use language code

if not ~~title_table~~[std] then return ''; end -- invalid standard, setup for error message

if not title_t[std] then return ''; end -- invalid standard, setup for error message

if ~~title_table~~[std][code] then -- if language code is in the table (transl may not provide a language code)

if title_t[std][code] then -- if language code is in the table (transl may not provide a language code)

~~table.insert~~ (~~tout~~, ~~table.concat (~~{~~title_table~~[std][code:lower()], ~~' (',~~ language_name, ' language) transliteration'})); ~~-- add the appropriate text to the tool tip~~

title_text = substitute ('$1$2 ($3 $4) $5', { -- add the appropriate text to the tool tip

title_text,

title_t[std][code:lower()],

language_name,

cfg.misc_text_t.language,

cfg.make_translit_t.transliteration,

});

else -- code doesn't match

~~table~~.~~insert (tout, title_table~~[std]['default']); -- so use the standard's default

title_text = title_text .. title_t[std]['default']; -- so use the standard's default

end

else -- here if translit-script set but translit-std not set

if ~~title_table~~['no_std'][tscript] then

if title_t['no_std'][tscript] then

~~table~~.~~insert (tout, title_table~~['no_std'][tscript]); -- use translit-script if set

title_text = title_text .. title_t['no_std'][tscript]; -- use translit-script if set

elseif ~~title_table~~['no_std'][code] then

elseif title_t['no_std'][code] then

~~table~~.~~insert (tout, title_table~~['no_std'][code]); -- use language code

title_text = title_text .. title_t['no_std'][code]; -- use language code

else

if is_set (tscript) then

~~table.insert (tout, table.concat~~ (~~{language_name,~~ '-~~script transliteration~~'~~}));~~ -- write a script tool tip

title_text = substitute ('$1$2-$3 $4', { -- write a script tool tip

title_text,

language_name,

cfg.make_translit_t.script,

cfg.make_translit_t.transliteration,

});

elseif is_set (code) then

if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name)

~~table.insert~~ (~~tout,~~ '-~~language~~') -- skip this text (individual and macro languages only)

title_text = substitute ('$1-$2', { -- skip this text (individual and macro languages only)

title_text,

cfg.misc_text_t.language,

});

end

~~table.insert~~ (~~tout,~~ ' ~~transliteration~~'); -- finish the tool tip

title_text = substitute ('$1 $2', { -- finish the tool tip

title_text,

cfg.make_translit_t.transliteration,

});

else

~~table.insert~~ (~~tout,~~ ' ~~transliteration~~'); -- generic tool tip (can we ever get here?)

title_text = substitute ('$1 $2', { -- generic tool tip (can we ever get here?)

title_text,

cfg.make_translit_t.transliteration,

});

end

~~table.insert (tout, '">');~~

local tag

~~table.insert (tout, translit);~~

if is_set (code) then -- when a language code is provided (always with {{lang-??}} templates, not always with {{transliteration}})

if is_set (code) ~~and not style~~ then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{~~transl~~}})

code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag

~~table.insert~~ (~~tout,~~ "</i>"); -- ~~close the italic~~ tag

if not style then -- nil for the default italic style

tag = '<i lang="%s-Latn">%s</i>'

else

tag = '<span style="font-style: %s" lang="%s-Latn">%s</span>' -- non-standard style, construct a span tag for it

tag = string.format(tag, style, "%s", "%s")

end

tag = string.format(tag, code, "%s")

else

~~table.insert (tout, "~~</span>~~");~~ -- no language code ~~so close~~ the span ~~tag~~

tag = '<span>%s</span>' -- when no language code: no lang= attribute, not italic ({{transliteration}} only)

end

tag = string.format(tag, translit) -- add the translit text

if '' == title_text then -- when there is no need for a tool-tip

return tag; -- done

else

title_text = cfg.engvar_sel_t.gb == engvar and title_text:gsub ('([Rr]omani)z', '%1s') or title_text; -- gb eng when engvar specifies gb eng; us eng else

return title_wrapper_make (title_text, tag, 'span'); -- wrap with a tool-tip span and done

end

~~return table.concat (tout);~~

end

Line 694:

Line 819:

This function checks the content of args.text and returns empty string if nothing is amiss else it returns an

error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.

Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text

Line 703:

Line 828:

local function validate_text (template, args)

if not is_set (args.text) then

return make_error_msg (~~'no text'~~, args, template);

return make_error_msg (cfg.validate_text_t.no_text, args, template);

end

if args.text:find ("%f[\']\'\'\'\'%f[^\']") or args.text:find ("\'\'\'\'\'[\']+") then -- because we're looking, look for 4 appostrophes or 6+ appostrophes

return make_error_msg (~~'text has malformed markup'~~, args, template);

return make_error_msg (cfg.validate_text_t.malformed_markup, args, template);

end

local style = args.italic;

if ('unset' ~= style) and ('invert' ~=style) then

if (cfg.keywords_t.unset ~= style) and (cfg.keywords_t.invert ~=style) then

if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then -- italic but not bold, or bold italic

return make_error_msg (~~'text has italic markup'~~, args, template);

return make_error_msg (cfg.validate_text_t.italic_markup, args, template);

end

Line 722:

Line 847:

--[[--------------------------< R E N D E R _ M A I N T >------------------------------------------------------

~~render~~ mainenance messages and categories

Render mainenance messages and categories.

]]

local function render_maint(nocat)

local function render_maint (nocat)

local maint = {};

Line 749:

Line 874:

--[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------

~~for~~ proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat

For proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat

will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we

do nothing

do nothing.

proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and ~~/ or~~ inhibits

proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and inhibits

regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac

regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac.

]]

Line 771:

Line 896:

--[[--------------------------< H A S _ P O E M _ T A G >------------------------------------------------------

~~looks~~ for a poem strip marker in text; returns true when found; false else

Looks for a poem strip marker in text; returns true when found; false else.

~~auto~~-italic detection disabled when text has poem stripmarker because it is not possible for this code to know

Auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know

the content that will replace the stripmarker.

Line 798:

Line 923:

If text contains <poem>...</poem> stripmarker, return text unmodified and choose <div>..</div> tags because

the stripmarker is replaced with text wrapped in <div>..</div> tags.

If the text contains any actual <div>...</div> tags, then it's again returned unmodified and <div>...</div>

tags are used to wrap it, to prevent div/span inversion.

]]

Line 806:

Line 934:

if has_poem_tag (text) then -- contains poem stripmarker (we can't know the content of that)

tag = 'div'; -- poem replacement is in div tags so lang must use div tags

elseif text:find ('<div') then -- reductive; if the text contains a div tag, we must use div tags

tag = 'div';

elseif mw.text.trim (text):find ('\n\n+') then -- contains implied p tags

text = mw.text.trim (text); -- trim leading and trailing whitespace characters

Line 823:

Line 953:

--[[--------------------------< V A L I D A T E _ P R O T O >--------------------------------------------------

~~validates~~ value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,

Validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,

empty string (or parameter omitted) returns as nil; any other value returns as nil with a second return value of

empty string (or parameter omitted) returns as nil; any other value returns nil with <proto_param> as second

~~true indicating that some other value has been assigned to |proto=~~

return value for use in error message.

]]

local function validate_proto (proto_param)

if ~~'yes'~~ == proto_param then

if cfg.keywords_t.affirmative == proto_param then

return true;

elseif ~~'no'~~ == proto_param then

elseif cfg.keywords_t.negative == proto_param then

return false;

elseif is_set (proto_param) then

return nil, ~~true~~; -- |proto= something other than 'yes' or 'no'

return nil, proto_param; -- |proto= something other than 'yes' or 'no'

else

return nil; -- missing or empty

Line 844:

Line 974:

--[[--------------------------< L A N G U A G E _ N A M E _ G E T >--------------------------------------------

~~common~~ function to return language name from the data set according to IETF tag

Common function to return language name from the data set according to IETF tag.

~~returns~~ language name if found in data tables; nil else

Returns language name if found in data tables; nil else.

]]

Line 866:

Line 996:

if lang_dep_table[code] and cat then -- because deprecated code may have been overridden to en.wiki preferred name

table.insert (maint_cats, ~~table~~.~~concat (~~{~~'Lang and lang-xx using deprecated ISO 639 codes|',~~ code}));

table.insert (maint_cats, substitute (cfg.language_name_get_t.deprecated_cat, {code}));

table.insert (maint_msgs, ~~table~~.~~concat (~~{'code~~: ', code, ' is deprecated'~~}));

table.insert (maint_msgs, substitute (cfg.language_name_get_t.deprecated_msg, {code}));

end

return name; -- name from data tables or nil

end

--[[--------------------------< T E X T _ S C R I P T _ M A T C H _ T E S T >----------------------------------

IETF script subtag should match the script of the <text>. This module does not attempt to know all scripts and

what they look like. It does know what Latn script looks like so when <text> is written using other than the Latn

script, the IETF script subtag, if present, should not be Latn.

Conversely, when <text> is written using the Latn script, the IETF script subtag, if present, should be Latn.

For the purposes of this test, Latf (Fraktur) and Latg (Gaelic) are considered to be equivalent to Latn because

unicode treats these two scripts as font-specific variants of Latn.

Returns an error message when mismatch detected; nil else.

]]

local function text_script_match_test (script, is_latn_text, pos)

local scripts_t = {['latf'] = true, ['latg'] = true, ['latn'] = true}; -- unicode 'latn' scripts; 'latf' and 'latg' are font variants so there are no Fraktur or Gaelic codepoints

if is_set (script) then -- don't bother with the rest of this if <script> is nil or empty string

script = script:lower(); -- lower case to index into <scripts_t>

if is_latn_text then -- when text is wholly Latn script

if not scripts_t[script] then -- but a non-Latn script is specified

return cfg.text_script_match_test_t.latn_txt_mismatch; -- emit an error message

end

else -- when text is not wholly Latn script

if scripts_t[script] then -- but a Latn script is specified

return substitute (cfg.text_script_match_test_t.latn_scr_mismatch, {pos}); -- emit an error message with position of first offending character

end

--[[--------------------------< I S _ L A T I N >--------------------------------------------------------------

Created because unicode does not have Latin theta 'θ' character. The Greek 'θ' is, apparently, commonly used

in certain romanizations. This function attempts to discover if <text> script is Latn with Greek 'θ' or some

other script with Greek 'θ'.

when <text> is or has Greek 'θ':

for {{lang}}, {{langx}}, and {{lang-??}}, returns boolean true when <text>:

has theta and all other characters are Latn

has theta as the only character, <script> is Latn

for {{transliteration}}, returns boolean true when <text>:

has theta and all other characters are Latn

has theta as the only character

]]

local function is_latin (text, script, transl)

if mw.ustring.find (text, 'θ', 1, true) then -- does <text> contain 'θ'?

text = text:gsub ('θ', ''); -- remove theta from <text>

if 0 == text:len() then -- will be zero if theta was the only character in <text>

if transl then -- not nil for {{transliteration}}; assume Latin theta because this is 'transliteration' template

return true;

end

return (script and ('latn' == script:lower())) or false; -- {{lang}}, {{langx}}, and {{lang-??}}; true when script is Latn; false else

end

return unicode.is_Latin (text); -- return true when all characters in modified <text> are Latn script; false else

end

return unicode.is_Latin (text); -- return true when all characters in <text> are Latn script; false else

end

Line 876:

Line 1,071:

--[[--------------------------< _ L A N G >--------------------------------------------------------------------

~~entry~~ point for {{lang}}

Entry point for {{lang}}.

~~there~~ should be no reason to set parameters in the {{lang}} {{#invoke:}}

There should be no reason to set parameters in the {{lang}} {{#invoke:}}

<includeonly>{{#invoke:lang|lang}}</includeonly>

~~parameters~~ are received from the template's frame (parent frame)

Parameters are received from the template's frame (parent frame).

]]

Line 893:

Line 1,088:

local msg; -- for error messages

local tag = 'span'; -- initial value for make_text_html()

local template = args.template or ~~'Lang'~~;

local template = args.template or cfg.templates_t.lang;

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

maint_msgs = {};

validate_cat_args (args); -- determine if categorization should be suppressed

if args[1] and args.code then

return make_error_msg ('~~conflicting: {{{~~1}~~}} and |code='~~, args, template);

return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'1', cfg.lang_t.conflict_n_param_types.code}), args, template);

else

args.code = args[1] or args.code; -- prefer args.code

Line 904:

Line 1,102:

if args[2] and args.text then

return make_error_msg ('~~conflicting: {{{~~2}~~}} and |text='~~, args, template);

return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'2', cfg.lang_t.conflict_n_param_types.text}), args, template);

else

args.text = args[2] or args.text; -- prefer args.text

end

msg = validate_text (template, args); -- ensure that |text= is set

if is_set (msg) then -- msg is an already-formatted error message

Line 916:

Line 1,114:

args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly

args.rtl = args.rtl == ~~'yes'~~; -- convert to boolean: 'yes' -> true, other values -> false

args.rtl = args.rtl == cfg.keywords_t.affirmative; -- convert to boolean: 'yes' -> true, other values -> false

args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag

if msg then

return make_error_msg (~~table~~.~~concat (~~{~~'invalid |proto=: ', args.proto~~}), args, template);

return make_error_msg (substitute (cfg.lang_t.invalid_proto, {msg}), args, template);

end

Line 926:

Line 1,124:

if msg then

return make_error_msg ( msg, args, template);

return make_error_msg (msg, args, template);

end

local is_latn_text, pos = is_latin (args.text, subtags.script); -- make a boolean

msg = text_script_match_test (subtags.script, is_latn_text, pos)

if msg then -- if an error detected then there is an error message

return make_error_msg (msg, args, template);

end

Line 936:

Line 1,141:

if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls

if ('latn' == subtags.script) or -- script is latn

(this_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and ~~unicode.is_Latin (args.text)~~) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)

(this_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and is_latn_text) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)

args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic

else

Line 954:

Line 1,159:

language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant

if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content

if cfg.keywords_t.invert == args.italic and 'span' == tag then -- invert only supported for in-line content

args.text = invert_italics (args.text)

end

Line 962:

Line 1,167:

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, language_name));

table.insert (out, make_category (code, language_name, args.nocat));

table.insert (out, render_maint(args.nocat)); -- maintenance messages and categories

table.insert (out, render_maint (args.nocat)); -- maintenance messages and categories

return table.concat (out); -- put it all together and done

Line 970:

Line 1,175:

--[[--------------------------< L A N G >----------------------------------------------------------------------

~~entry~~ point for {{lang}}

Entry point for {{lang}}.

~~there~~ should be no reason to set parameters in the {{lang}} {{#invoke:}}

There should be no reason to set parameters in the {{lang}} {{#invoke:}}

<includeonly>{{#invoke:lang|lang}}</includeonly>

~~parameters~~ are received from the template's frame (parent frame)

Parameters are received from the template's frame (parent frame).

]]

local function lang (frame)

local ~~args~~ = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text

local args_t = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text

valueFunc = function (key, value)

if 2 == key or 'text' == key then -- the 'text' parameter; do not trim wite space

Line 994:

Line 1,199:

});

return _lang (~~args~~);

args_t.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang|...}}

local msg = parameter_validate (args_t, cfg.templates_t.lang); -- verify that all supplied parameters are supported by {{lang-??}}

if msg then

return make_error_msg (msg, args_t, cfg.templates_t.lang); -- when template has unsupported params, abandon with error message

end

return _lang (args_t);

end

--[[--------------------------< T R A N S L A T I O N _ M A K E >----------------------------------------------

Stand-alone function to create literal translation of main text.

Also used by {{lang-x2}}.

]]

local function translation_make (args_t)

local translation_t = {', '}; -- initialize output

if 'none' ~= args_t.label then -- if we want a label

table.insert (translation_t, '<small>'); -- open the <small> html tag

if cfg.keywords_t.negative == args_t.link then

table.insert (translation_t, substitute ('<abbr title="$1">$2</abbr>', {cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr})); -- unlinked form

else

table.insert (translation_t, make_wikilink (cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr)); -- linked form

end

table.insert (translation_t, " </small>"); -- close the <small> html tag

end

table.insert (translation_t, table.concat ({''', args_t.translation, '''})); -- use html entities to avoid wiki markup confusion

return table.concat (translation_t); -- make a big string and done

end

--[[--------------------------< L A N G _ X X >----------------------------------------------------------------

--[[--------------------------< _ L A N G _ X X >--------------------------------------------------------------

For the {{lang-xx}} templates, the only parameter required to be set in the template is the language code. All

For the {{lang-??}} templates, the only parameter required to be set in the template is the language code. All

other parameters can, usually should, be written in the template call. For {{lang-xx}} templates for languages

other parameters can, usually should, be written in the template call. For {{lang-??}} templates for languages

that can have multiple writing systems, it may be appropriate to set |script= as well.

For each {{lang-xx}} template choose the appropriate entry-point function so that this function knows the default

For each {{lang-??}} template choose the appropriate entry-point function so that this function knows the default

styling that should be applied to text.

Line 1,029:

Line 1,266:

any other text replaces language-name label - automatic wikilinking disabled

for those {{lang-xx}} templates that support transliteration (those templates where |text= is not entirely latn script):

for those {{lang-??}} templates that support transliteration (those templates where |text= is not entirely latn script):

|translit = text that is a transliteration of text

|translit-std = the standard that applies to the transliteration

|translit-script = ISO 15924 script name; falls back to code

For {{lang-xx}}, the positional parameters are:

For {{lang-??}}, the positional parameters are:

{{{1}}} text

{{{2}}} transliterated text

Line 1,042:

Line 1,279:

]]

local function _lang_xx (args)

local function _lang_xx (args, base_template) -- base_template will be either of 'Langx' or 'Lang-xx'

local out = {};

local language_name; -- used to make display text, article links

Line 1,051:

Line 1,288:

local translit_script_name; -- name associated with IANA (ISO 15924) script code

local translit;

~~local translit_title;~~

local msg; -- for error messages

local tag = 'span'; -- initial value for make_text_html()

local template = args.template or ~~'Lang-xx'~~;

local template = args.template or base_template;

if args[1] and args.text then

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

return make_error_msg (~~'conflicting:~~ {~~{{1}}~~} ~~and |text='~~, args, template);

maint_msgs = {};

local text_idx = (cfg.templates_t.langx == base_template) and 2 or 1; -- for {{langx}} 'text' positional parameter is '2'

local translit_idx = (cfg.templates_t.langx == base_template) and 3 or 2;

local xlate_idx = (cfg.templates_t.langx == base_template) and 4 or 3;

if args[text_idx] and args.text then

return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.text}), args, template);

else

args.text = args[1] or args.text; -- prefer ~~args.~~text

args.text = args[text_idx] or args.text; -- prefer positional 'text' parameter

end

msg = validate_text (template, args); -- ensure that |text= is set, does not contain italic markup and is protected from improper bolding

if is_set (msg) then

Line 1,069:

Line 1,312:

args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly

if args[2] and args.translit then

if args[translit_idx] and args.translit then

return make_error_msg (~~'conflicting:~~ {~~{{2~~}~~}} and |translit='~~, args, template);

return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.translit}), args, template);

else

args.translit = args[2] or args.translit -- prefer args.translit

args.translit = args[translit_idx] or args.translit -- prefer positional 'translit' parameter

end

if args.translit then

local latn, pos = is_latin (args.translit, nil, true);

if not latn then

return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template);

end

if args[3] and (args.translation or args.lit) then

args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar; -- |engvar= when valid; cfg.default_engvar else

return make_error_msg (~~'conflicting: {{~~{3}~~}} and |lit= or |translation='~~, args, template);

if args[xlate_idx] and (args.translation or args.lit) then

return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_lit, {translit_idx}), args, template);

elseif args.translation and args.lit then

return make_error_msg (~~'conflicting: |lit= and |translation='~~, args, template);

return make_error_msg (cfg.lang_xx_t.conflict_lit, args, template);

else

args.translation = args[3] or args.translation or args.lit; -- prefer ~~args.~~translation

args.translation = args[xlate_idx] or args.translation or args.lit; -- prefer positional 'translation' parameter

end

if args.links and args.link then

return make_error_msg (~~'conflicting: |links= and |link='~~, args, template);

return make_error_msg (cfg.lang_xx_t.conflict_link, args, template);

else

args.link = args.link or args.links; -- prefer args.link

Line 1,091:

Line 1,344:

validate_cat_args (args); -- determine if categorization should be suppressed

args.rtl = args.rtl == ~~'yes'~~; -- convert to boolean: 'yes' -> true, other values -> false

args.rtl = args.rtl == cfg.keywords_t.affirmative; -- convert to boolean: 'yes' -> true, other values -> false

code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code, args.script, args.region, args.variant); -- private omitted because private

Line 1,099:

Line 1,352:

end

local is_latn_text, pos = is_latin (args.text, subtags.script); -- make a boolean

msg = text_script_match_test (subtags.script, is_latn_text, pos)

if msg then -- if an error detected then there is an error message

return make_error_msg (msg, args, template);

end

args.italic, msg = validate_italic (args);

if msg then

return make_error_msg (msg, args, template);

end

if nil == args.italic then -- args.italic controls

if cfg.templates_t.langx == base_template then -- auto-italics for {{langx}} templates; adapted from {{lang}} (no support for poem tag)

if is_set (subtags.script) then

if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls

if 'latn' == subtags.script then

if ('latn' == subtags.script) or -- script is latn

args.italic = 'italic'; -- |script=Latn; set for font-style:italic

(this_wiki_lang_tag ~= code and not is_set (subtags.script) and is_latn_text) then -- text is not this wiki's language, no script specified and is wholly latn script (auto-italics)

args.italic = 'italic'; -- set font-style:italic

else

args.italic = 'inherit'; -- italic not set; script not latn; inherit current style

end

else -- {{lang-xx}} does not do auto italics; retained for those wikis that don't support {{langx}}

if nil == args.italic then -- args.italic controls

if is_set (subtags.script) then

if 'latn' == subtags.script then

args.italic = 'italic'; -- |script=Latn; set for font-style:italic

else

args.italic = initial_style_state; -- italic not set; script is not latn; set for font-style:<initial_style_state>

end

else

args.italic = initial_style_state; -- italic not set~~; script is not latn~~; set for font-style:<initial_style_state>

args.italic = initial_style_state; -- here when |italic= and |script= not set; set for font-style:<initial_style_state>

end

~~else~~

~~args.italic = initial_style_state; -- here when |italic= and |script= not set; set for font-style:<initial_style_state>~~

end

Line 1,126:

Line 1,398:

args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag

if msg then

return make_error_msg (~~table~~.~~concat (~~{~~'invalid |proto=: ',~~ args.proto}), args, template);

return make_error_msg (substitute (cfg.lang_t.invalid_proto, {args.proto}), args, template);

end

Line 1,140:

Line 1,412:

end

else

if ~~'no'~~ == args.link then

if cfg.keywords_t.negative == args.link then

table.insert (out, language_name); -- language name without wikilink

else

if mw.ustring.find (language_name, 'languages', 1, true) then

table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink

elseif lang_data.article_name[code] then

elseif lang_data.article_name[args.code:lower()] then -- is ietf tag in article name over ride?

table.insert (out, make_wikilink (lang_data.article_name[args.code:lower()], language_name)); -- language name with wikilink from override data

elseif lang_data.article_name[code] then -- is language tag in article override

table.insert (out, make_wikilink (lang_data.article_name[code], language_name)); -- language name with wikilink from override data

else

table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink

table.insert (out, make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), language_name)); -- language name with wikilink

end

Line 1,154:

Line 1,428:

end

if 'invert' == args.italic then

if cfg.keywords_t.invert == args.italic then

args.text = invert_italics (args.text)

end

Line 1,162:

Line 1,436:

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, ('none' == args.label) and language_name or nil))

if is_set (args.translit) and not ~~unicode.is_Latin (args.text)~~ then -- transliteration ~~(not supported in {{lang}})~~; not supported when args.text is wholly latn text (this is an imperfect test)

if is_set (args.translit) and not is_latn_text then -- transliteration; not supported when args.text is wholly latn text (this is an imperfect test)

table.insert (out, ', '); -- comma to separate text from translit

if 'none' ~= args.label then

Line 1,171:

Line 1,445:

translit_script_name = language_name; -- fall back on language name

end

~~translit_title~~ = mw.title.makeTitle (0, ~~table.concat~~ ({'~~Romanization of~~ ', translit_script_name})); -- make a title object

if ~~translit_title~~.exists and (~~'no'~~ ~= args.link) then

local translit_title_obj = mw.title.makeTitle (0, substitute ('$1 $2',{cfg.lang_xx_t.romanization, translit_script_name})); -- make a title object; no engvar, article titles use US spelling

table.insert (out, make_wikilink ('~~Romanization of~~ ' .. translit_script_name or language_name, '~~romanized~~') .. ':'); -- make a wikilink if there is an article to link to

if translit_title_obj.exists and (cfg.keywords_t.negative ~= args.link) then

table.insert (out, make_wikilink (substitute ('$1 $2', {cfg.lang_xx_t.romanization, translit_script_name or language_name}),

substitute ('$1', {cfg.engvar_t[args.engvar]['romanisz_pt']})) .. ':'); -- make a wikilink if there is an article to link to; engvar the display text

else

table.insert (out, '~~romanized~~:'); -- else plain text

table.insert (out, substitute ('$1:', {cfg.engvar_t[args.engvar]['romanisz_pt']})); -- else plain text per engvar

end

table.insert (out, ' </small>'); -- close the small tag

end

translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script'])

translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script'], nil, args.engvar)

if is_set (translit) then

table.insert (out, translit);

else

return make_error_msg (~~table.concat~~ ({'~~invalid translit-std~~: \'', args['translit-std'] or '[missing]'}), args, template);

return make_error_msg (substitute ('$1: $2', {cfg.lang_xx_t.invalid_xlit_std, args['translit-std'] or '[missing]'}), args, template);

end

elseif is_set (args.translit) and is_latn_text then -- when creating a transliteration of Latn script <text>

return make_error_msg (cfg.lang_xx_t.xlit_of_latn, args, template); -- emit error message and abandon

end

if is_set (args.translation) then -- translation (not supported in {{lang}})

table.insert (out, ~~', ');~~

table.insert (out, translation_make (args));

~~if 'none' ~= args.label then~~

~~table.insert (out, '<small>');~~

~~if 'no' == args.link then~~

~~table.insert (out, '<abbr title="literal translation">lit.</abbr>');~~

~~else~~

~~table.insert (out, make_wikilink ('Literal translation', 'lit.'));~~

~~end~~

~~table.insert~~ (~~out, " </small>");~~

~~end~~

~~table.insert (out, table.concat ({''',~~ args~~.translation, '''}~~)); ~~-- use html entities to avoid wiki markup confusion~~

end

Line 1,211:

Line 1,482:

--[[--------------------------< L A N G _ X X _ A R G S _ G E T >----------------------------------------------

~~common~~ function to get args table from {{lang-??}} templates

Common function to get args table from {{lang-??}} templates.

Returns table of args.

~~returns table of args~~

Text positional parameters are not trimmed here but are selectively trimmed at html_tag_select().

]]

local function lang_xx_args_get (frame)

local function lang_xx_args_get (frame, base_template)

local ~~args~~ = getArgs(frame,

local args_t = getArgs(frame,

{

parentFirst= true, -- parameters in the template override parameters set in the {{#invoke:}}

valueFunc = function (key, value)

if 1 == key then -- the 'text' parameter; do not trim wite space

if ((cfg.templates_t.langx == base_template) and 2 or 1) == key then -- the 'text' positional parameter; 1 for {{lang-??}}, 2 for {{langx}}; do not trim wite space

return value; -- return untrimmed 'text'

return value; -- return untrimmed 'text' positional parameter

elseif value then -- all other values: if the value is not nil

value = mw.text.trim (value); -- trim whitespace

Line 1,234:

Line 1,507:

});

return ~~args~~;

return args_t;

end

Line 1,240:

Line 1,513:

--[[--------------------------< L A N G _ X X _ I T A L I C >--------------------------------------------------

Entry point for those {{lang-xx}} templates that call lang_xx_italic(). Sets the initial style state to italic.

Entry point for those {{lang-??}} templates that call lang_xx_italic(). Sets the initial style state to italic.

]]

local function lang_xx_italic (frame)

local args = lang_xx_args_get (frame);

local args = lang_xx_args_get (frame, cfg.templates_t.langxx);

args.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang_xx_italic|...}}

local msg = parameter_validate (args, cfg.templates_t.langxx); -- verify that all supplied parameters are supported by {{lang-??}}

if msg then

return make_error_msg (msg, args, cfg.templates_t.langxx); -- when template has unsupported params, abandon with error message

end

initial_style_state = 'italic';

return _lang_xx (args);

return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category

end

Line 1,254:

Line 1,533:

--[[--------------------------< _ L A N G _ X X _ I T A L I C >------------------------------------------------

Entry point ~~ffrom~~ another module. Sets the initial style state to italic.

Entry point from another module. Sets the initial style state to italic.

]]

Line 1,260:

Line 1,539:

local function _lang_xx_italic (args)

initial_style_state = 'italic';

return _lang_xx (args);

return _lang_xx (args, cfg.templates_t.langxx);

end

Line 1,266:

Line 1,545:

--[[--------------------------< L A N G _ X X _ I N H E R I T >------------------------------------------------

Entry point for those {{lang-xx}} templates that call lang_xx_inherit(). Sets the initial style state to inherit.

Entry point for those {{lang-??}} templates that call lang_xx_inherit(). Sets the initial style state to inherit.

]]

local function lang_xx_inherit (frame)

local args = lang_xx_args_get (frame);

local args = lang_xx_args_get (frame, cfg.templates_t.langxx);

args.fn = nil; -- unset because not supported but this function might have been called by {{lang|fn=lang_xx_inherit|...}}

local msg = parameter_validate (args, cfg.templates_t.langxx); -- verify that all supplied parameters are supported by {{lang-??}}

if msg then

return make_error_msg (msg, args, cfg.templates_t.langxx); -- when template has unsupported params, abandon with error message

end

initial_style_state = 'inherit';

return _lang_xx (args);

return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]'; -- temporary category

end

Line 1,280:

Line 1,565:

--[[--------------------------< _ L A N G _ X X _ I N H E R I T >----------------------------------------------

Entry point from another module. Sets the initial style state to inherit.

]]

Line 1,286:

Line 1,571:

local function _lang_xx_inherit (args)

initial_style_state = 'inherit';

return _lang_xx (args);

return _lang_xx (args, cfg.templates_t.langxx);

end

--[[--------------------------< _ L A N G X >------------------------------------------------------------------

Entry point from another module.

]]

local function _langx (args_t)

local langx_data = mw.loadData ('Module:Lang/langx'); -- get necessary data

local rtl_t = langx_data.rtl_t; -- get list of language tags for languages that are rendered right-to-left

local link_t = langx_data.link_t; -- get list of language tags for {{lang-??}} templates that set |link=<something>

local size_t = langx_data.size_t; -- get list of language tags for {{lang-??}} templates that set |size=<something>

local msg = parameter_validate (args_t, cfg.templates_t.langx);

if msg then

return make_error_msg (msg, args_t, cfg.templates_t.langx);

end

args_t.code = args_t[1] or args_t.code; -- get the language tag; must be {{{1}}} or |code=

if not args_t.code then

return make_error_msg (cfg.get_ietf_parts_t.missing_lang_tag, args_t, cfg.templates_t.langx);

end

args_t.rtl = args_t.rtl or (rtl_t[args_t.code] and cfg.keywords_t.affirmative); -- prefer |rtl= in template call, use rtl_t else

args_t.link = args_t.link or link_t[args_t.code]; -- prefer |link= in template call, use link_t felse

args_t.size = args_t.size or size_t[args_t.code]; -- prefer |size= in template call, use size_t else

args_t[1] = nil; -- unset to mimic {{lang-??}} templates which set |code=xx

local lang_subtag = args_t.code; -- use only the base language subtag for unsupported tag test; some args_t.code are modified by |script= etc

return _lang_xx (args_t, cfg.templates_t.langx);

end

--[[--------------------------< L A N G X >--------------------------------------------------------------------

Entry point for {{langx}}.

this function calls _lang_xx() to render non-English text. The {{lang-??}} templates have three positional paramters

but {{langx}} has four:

| 1 | 2 | 3 | 4

The calls to lang_xx_args_get() and _lang_xx() use 'Langx' as a flag for those functions to select the proper

positional parameters.

{{lang-??}} depends on the calling template to select 'inherit' or 'italic' to establish the default rendering.

{{langx}} can't do that. The initial version of {{langx}} relied on a list of language tags (inherit_t in ~/langx)

scraped from those {{lang-??}} templates that call lang_xx_inherit() to render text in upright font. Langx now

uses auto-italics code adapted from {{lang}} (doesn't support poem tags).

]]

local function langx (frame)

local args_t = lang_xx_args_get (frame, cfg.templates_t.langx); -- get the arguments; 'Langx' is the <base_template> used to decide which positional param is 'text', 'translit', 'lit'

return _langx (args_t);

end

Line 1,294:

Line 1,641:

Returns true when a language name associated with IETF language tag exists; nil else. IETF language tag must be valid.

All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.

All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.

Module entry point from another module

Module entry point from another module.

]]

Line 1,310:

Line 1,657:

--[[--------------------------< I S _ I E T F _ T A G >--------------------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,336:

Line 1,683:

Returns language name associated with IETF language tag if valid; error message else.

All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.

All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.

Set invoke's |link= parameter to yes to get wikilinked version of the language name.

Module entry point from another module

Module entry point from another module.

]]

Line 1,347:

Line 1,694:

local subtags = {}; -- IETF subtags script, region, variant, and private

local raw_code = args[1]; -- save a copy of the input IETF subtag

local link = ~~'yes'~~ == args['link']; -- make a boolean

local link = cfg.keywords_t.affirmative == args['link']; -- make a boolean

local label = args.label;

local code; -- the language code

Line 1,356:

Line 1,703:

if msg then

local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)

return ~~table.concat~~ (~~{'<span style=\"color:#d33\">Error: ',~~ template, msg~~, '</span>'}~~);

return make_error_span (template, msg);

end

Line 1,367:

Line 1,714:

if mw.ustring.find (language_name, 'languages', 1, true) then

language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink

elseif lang_data.article_name[code] then

elseif lang_data.article_name[raw_code:lower()] then -- is ietf tag in article name override?

language_name = make_wikilink (lang_data.article_name[raw_code:lower()], label or language_name); -- language name with wikilink from override data

elseif lang_data.article_name[code] then -- is language tag in article name override?

language_name = make_wikilink (lang_data.article_name[code], label or language_name); -- language name with wikilink from override data

else

language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink

language_name = make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), label or language_name); -- language name with wikilink

end

Line 1,380:

Line 1,729:

--[[--------------------------< N A M E _ F R O M _ T A G >----------------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,395:

Line 1,744:

that disambiguator must be omitted (they are not present in the data name-to-tag tables).

Module entry point from another module

Module entry point from another module.

]]

Line 1,410:

Line 1,759:

return tag, true; -- language name found so return tag and done; second return used by is_lang_name()

else

msg = ~~'language: '~~ .. args[1] ~~.. ' not found'~~ -- language name not found, error message

msg = substitute (cfg.tag_from_name_t.lang_not_found, {args[1]}); -- language name not found, error message

end

else

msg = ~~'missing language name'~~ -- language name not ~~provided~~, error message

msg = cfg.tag_from_name_t.missing_lang_name; -- language name not found, error message

end

Line 1,420:

Line 1,769:

template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template)

end

return ~~table.concat~~ (~~{'<span style=\"color:#d33\">Error: ',~~ template, msg~~, '</span>'}~~);

return make_error_span (template, msg);

end

Line 1,426:

Line 1,776:

--[[--------------------------< T A G _ F R O M _ N A M E >----------------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,438:

Line 1,788:

--[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,450:

Line 1,800:

--[[--------------------------< _ T R A N S L >----------------------------------------------------------------

Module entry point from another module

Module entry point from another module.

]]

Line 1,460:

Line 1,810:

local script; -- IANA script

local msg; -- for when called functions return an error message

local template = args.template or cfg.templates_t.transliteration;

if is_set (args[3]) then -- [3] set when {{~~transl~~|code|standard|text}}

maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once

maint_msgs = {};

if is_set (args[3]) then -- [3] set when {{transliteration|code|standard|text}}

args.text = args[3]; -- get the transliterated text

args.translit_std = args[2] and args[2]:lower(); -- get the standard; lower case for table indexing

if not title_table[args.translit_std] then

return make_error_msg (~~table~~.~~concat (~~{~~'unrecognized transliteration standard: ',~~ args.translit_std}), args, ~~'Transl'~~);

return make_error_msg (substitute (cfg.transl_t.unrecog_xlit_std, {args.translit_std}), args, template);

end

else

if is_set (args[2]) then -- [2] set when {{~~transl~~|code|text}}

if is_set (args[2]) then -- [2] set when {{transliteration|code|text}}

args.text = args[2]; -- get the transliterated text

else

if args[1] and args[1]:match ('^%a%a%a?%a?$') ~~then~~ -- args[2] missing; is args[1] a ~~code~~ or is it the transliterated text?

if args[1] and (args[1]:match ('^%a%a%a?%a?$') or -- args[2] missing; is args[1] a language or script tag or is it the transliterated text?

return make_error_msg (~~'no text'~~, args, ~~'Transl'~~); -- args[1] is a code so we're missing text

args[1]:match ('^%a%a%a?%-x%-')) then -- or is args[1] a private-use tag

return make_error_msg (cfg.transl_t.no_text, args, template); -- args[1] is a code so we're missing text

else

args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message

return make_error_msg (~~'missing language / script code'~~, args, ~~'Transl'~~);

return make_error_msg (cfg.transl_t.missing_lang_scr, args, template);

end

Line 1,482:

Line 1,837:

if is_set (args[1]) then -- IANA language code used for html lang= attribute; or ISO 15924 script code

if args[1]:match ('^%a%a%a?%a?$') then -- args[1] has correct form?

if args[1]:match ('^%a%a%a?%a?$') or args[1]:match ('^%a%a%a?%-x%-') then -- args[1] has correct form?

args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case

args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters) or private-use; lower case because table indexes are lower case

else

return make_error_msg (~~table~~.~~concat (~~{~~'unrecognized language / script code: ',~~ args[1]}), args, ~~'Transl'~~); -- invalid language / script code

return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args[1]}), args, template); -- invalid language / script code

end

else

return make_error_msg (~~'missing language / script code'~~, args, ~~'Transl'~~); -- missing language / script code so quit

return make_error_msg (cfg.transl_t.missing_lang_scr, args, template); -- missing language / script code so quit

end

local latn, pos = is_latin (args.text, nil, true);

if not latn then -- text is not latn

return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template);

end

args.italic, msg = validate_italic (args);

if msg then

return make_error_msg (msg, args, ~~'Transl'~~);

return make_error_msg (msg, args, template);

end

Line 1,499:

Line 1,860:

args.italic = nil; -- set to nil;

end

args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar; -- |engvar= when valid; cfg.default_engvar else

if override_table[args.code] then -- is code a language code defined in the override table?

language_name = override_table[args.code];

args.code = args.code:match ('^%a%a%a?'); -- if private use, strip all but language subtag

elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables?

language_name = lang_table[args.code];

Line 1,511:

Line 1,875:

args.code = ''; -- unset because not a language code

else

return make_error_msg (~~table~~.~~concat (~~{~~'unrecognized language / script code: ',~~ args.code}), args, ~~'Transl'~~); -- invalid language / script code

return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args.code}), args, template); -- invalid language / script code

end

-- here only when all parameters passed to make_translit() are valid

return make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic);

return make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic, args.engvar);

end

Line 1,520:

Line 1,884:

--[[--------------------------< T R A N S L >------------------------------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,531:

Line 1,895:

--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------

Returns category name associated with IETF language tag if valid; error message else

Returns category name associated with IETF language tag if valid; error message else.

All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.

All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.

Module entry point from another module

Module entry point from another module.

]]

Line 1,542:

Line 1,906:

local subtags = {}; -- IETF subtags script, region, variant, and private

local raw_code = args_t[1]; -- save a copy of the input IETF subtag

local link = ~~'yes'~~ == args_t.link; -- make a boolean

local link = cfg.keywords_t.affirmative == args_t.link; -- make a boolean

local label = args_t.label;

local code; -- the language code

Line 1,551:

Line 1,915:

if msg then

local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template)

return ~~table.concat~~ (~~{'<span style=\"color:#d33\">Error: ',~~ template, msg~~, '</span>'}~~);

return make_error_span (template, msg);

end

Line 1,568:

Line 1,932:

--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------

Module entry point from an {{#invoke:}}

Module entry point from an {{#invoke:}}.

]]

Line 1,583:

Line 1,947:

category_from_tag = category_from_tag,

lang = lang, -- entry point for {{lang}}

langx = langx, -- entry point for {{langx}}

lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}}

lang_xx_italic = lang_xx_italic,

Line 1,590:

Line 1,955:

tag_from_name = tag_from_name, -- returns ietf tag associated with language name

name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates

transl = transl, -- entry point for {{~~transl~~}}

transl = transl, -- entry point for {{transliteration}}

_category_from_tag = _category_from_tag, -- entry points when this module is require()d into other modules

_lang = _lang,

_langx = _langx,

_lang_xx_inherit = _lang_xx_inherit,

_lang_xx_italic = _lang_xx_italic,

Line 1,601:

Line 1,967:

_name_from_tag = _name_from_tag,

_transl = _transl,

_translation_make = translation_make,

};

@@ Line 1: / Line 1: @@
 --[=[
-Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates.
+Lua support for the {{lang}}, {{langx}}, {{lang-??}}, and {{transliteration}} templates and replacement of various supporting templates.
 ]=]
-require('Module:No globals');
+require('strict');
 local getArgs = require ('Module:Arguments').getArgs;
-local unicode = require ("Module:Unicode data");								-- for is_latin() and is_rtl()
+local unicode = require ("Module:Unicode data");								-- for is_Latin() and is_rtl()
 local yesno = require ('Module:Yesno');
@@ Line 22: / Line 22: @@
 local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms');				-- ISO 639-2/639-2T code translation to 639-1 code
+local cfg = mw.loadData ('Module:Lang/configuration' .. (mw.getCurrentFrame():getTitle():match ('/sandbox') or ''));	-- for internationalization
 local namespace = mw.title.getCurrentTitle().namespace;							-- used for categorization
@@ Line 33: / Line 35: @@
 local maint_cats = {};															-- maintenance categories go here
 local maint_msgs = {};															-- and their messages go here
+--[[--------------------------< M A K E _ E R R O R _ S P A N >--------------------------------------------------
+]]
+local function make_error_span (template, msg)
+	return table.concat ({'<span style="color:#d33">', cfg.misc_text_t.error, ': ', template, msg, '</span>'})
+end
+--[[--------------------------< S U B S T I T U T E >----------------------------------------------------------
+Substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when
+<data_t> not nil; returns <message> else.
+]]
+local function substitute (message, data_t)
+	return data_t and mw.message.newRawMessage (message, data_t):plain() or message;
+end
+--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------
+Assembles an error message from template name, message text, help link, and error category.
+]]
+local function make_error_msg (msg, args_t, template)
+	local category;
+	local text;																	-- handle the oddity that is {{langx}}
+	if cfg.templates_t.langxx == template then
+		text = args_t.text or args_t[1];										-- for {{lang-xx}}
+	else
+		text = args_t.text or args_t[2];										-- for {{lang}}, {{langx}}, and {{transliteration}}
+	end
+	if cfg.templates_t.transliteration == template then
+		category = cfg.make_error_msg_t.xlit_err_cat;
+	else
+		category = cfg.make_error_msg_t.lang_err_cat;
+	end
+	local category_link = ((0 == namespace or 10 == namespace) and not args_t.nocat) and substitute ('[[Category:$1]]', {category}) or '';
+	return substitute ('[$1] <span style="color:#d33">$2: {{$3}}: $4 ([[:Category:$5|$6]])</span>$7',
+		{
+		text or cfg.make_error_msg_t.undefined,
+		cfg.misc_text_t.error,
+		template,
+		msg,
+		category,
+		cfg.misc_text_t.help,
+		category_link
+		})
+end
+--[[--------------------------< P A R A M E T E R _ V A L I D A T E >------------------------------------------
+]]
+local function parameter_validate (args_t, template)
+	local err_msg = cfg.parameter_validate_t.invalid_param;
+	if cfg.templates_t.lang == template then									-- for {{lang}}
+		for param, _ in pairs (args_t) do
+			if not cfg.known_params_t.params_lang_t[param] and					-- unique {{lang}} parameters
+				 not cfg.known_params_t.common_params_all_t[param] then			-- common to all
+					return substitute (err_msg, {param});						-- <param> not found so abandon
+			end
+		end
+	elseif cfg.templates_t.langx == template then								-- for {{langx}}
+		for param, _ in pairs (args_t) do
+			if not cfg.known_params_t.params_langx_t[param] and					-- unique {{langx}} parameters
+				not cfg.known_params_t.params_x_t[param] and					-- common to {{langx}} and {{lang-xx}}
+				not cfg.known_params_t.common_params_all_t[param] then			-- common to all
+					return substitute (err_msg, {param});						-- <param> not found so abandon
+			end
+		end
+	elseif cfg.templates_t.langxx == template then								-- for {{lang-xx}}
+		for param, _ in pairs (args_t) do
+			if not cfg.known_params_t.params_lang_xx_t[param] and				-- unique {{lang-xx}} parameters
+				not cfg.known_params_t.params_x_t[param] and					-- common to {{langx}} and {{lang-xx}}
+				not cfg.known_params_t.common_params_all_t[param] then			-- common to all
+					return substitute (err_msg, {param});						-- <param> not found so abandon
+			end
+		end
+	end
+end
 --[[--------------------------< I S _ S E T >------------------------------------------------------------------
-Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not an empty string.
+Returns true if argument is set; false otherwise. Argument is 'set' when it exists (not nil) or when it is not
+an empty string.
 ]]
-local function is_set( var )
+local function is_set (var)
 	return not (var == nil or var == '');
 end
@@ Line 94: / Line 187: @@
 --[[--------------------------< V A L I D A T E _ I T A L I C >------------------------------------------------
-validates |italic= or |italics= assigned values.
+Validates |italic= or |italics= assigned values.
 When |italic= is set and has an acceptible assigned value, return the matching css font-style property value or,
@@ Line 104: / Line 197: @@
 The return value nil causes the calling lang, lang_xx, or transl function to set args.italic according to the template's
-defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on
+defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-??}} depending on
-the individual template's requirements, 'italic' for {{transl}}) or to the value appropriate to |script=, if set ({{lang}}
+the individual template's requirements, 'italic' for {{transliteration}}) or to the value appropriate to |script=, if set ({{lang}}
-and {{lang-xx}} only).
+and {{lang-??}} only).
 Accepted values and the values that this function returns are are:
@@ Line 119: / Line 212: @@
 local function validate_italic (args)
-	local properties = {['yes'] = 'italic', ['no'] = 'normal', ['unset'] = 'inherit', ['invert'] = 'invert', ['default'] = nil};
+	local properties = {[cfg.keywords_t.affirmative] = 'italic', [cfg.keywords_t.negative] = 'normal', [cfg.keywords_t.unset] = 'inherit', [cfg.keywords_t.invert] = 'invert', [cfg.keywords_t.default] = nil};
 	local count = 0
@@ Line 129: / Line 222: @@
 	if count > 1 then															-- return nil and an error message if more than one is set
-		return nil, 'only one of |italic=, |italics=, or |i= can be specified';
+		return nil, cfg.validate_italic_t.multi_italic;
 	end
@@ Line 138: / Line 231: @@
 --[=[--------------------------< V A L I D A T E _ C A T _ A R G S >----------------------------------------------------------
-Default behavior of the {{lang}} and {{lang-xx}} templates is to add categorization when the templates are used in mainspace.
+Default behavior of the {{lang}} and {{lang-??}} templates is to add categorization when the templates are used in mainspace.
 This default functionality may be suppressed by setting |nocat=yes or |cat=no.  This function selects one of these two parameters
 to control categorization.
@@ Line 170: / Line 263: @@
 --[[--------------------------< I N _ A R R A Y >--------------------------------------------------------------
-Whether needle is in haystack
+Whether needle is in haystack.
 ]]
-local function in_array ( needle, haystack )
+local function in_array (needle, haystack)
 	if needle == nil then
 		return false;
 	end
-	for n,v in ipairs( haystack ) do
+	for n,v in ipairs (haystack) do
 		if v == needle then
 			return n;
@@ Line 189: / Line 282: @@
 --[[--------------------------< F O R M A T _ I E T F _ T A G >------------------------------------------------
-prettify ietf tags to use recommended subtag formats:
+Prettify ietf tags to use recommended subtag formats:
 	code: lower case
 	script: sentence case
@@ Line 225: / Line 318: @@
 --[[--------------------------< G E T _ I E T F _ P A R T S >--------------------------------------------------
-extracts and returns IETF language tag parts:
+Extracts and returns IETF language tag parts:
 	primary language subtag (required) - 2 or 3 character IANA language code
 	script subtag - four character IANA script code
@@ Line 239: / Line 332: @@
 	lang-x-private
-each of lang, script, region, variant, and private, when used, must be valid
+each of lang, script, region, variant, and private, when used, must be valid.
 Languages with both two- and three-character code synonyms are promoted to the two-character synonym because
@@ Line 245: / Line 338: @@
 the synonymous three-character codes in the lang= attribute.
-For {{lang-xx}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}
+For {{lang-??}} templates, the parameters |script=, |region=, and |variant= are supported (not supported in {{lang}}
-because those parameters are superfluous to the IETF subtags in |code=)
+because those parameters are superfluous to the IETF subtags in |code=).
-returns six  values; all lower case.  Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid
+Returns six  values; all lower case.  Valid parts are returned as themselves; omitted parts are returned as empty strings, invalid
 parts are returned as nil; the sixth returned item is an error message (if an error detected) or nil.
-see http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1
+See http://www.rfc-editor.org/rfc/bcp/bcp47.txt section 2.1.
 ]]
@@ Line 259: / Line 352: @@
 	if not is_set (source) then
-		return nil, nil, nil, nil, nil, 'missing language tag';
+		return nil, nil, nil, nil, nil, cfg.get_ietf_parts_t.missing_lang_tag;
 	end
@@ Line 314: / Line 407: @@
 	if not code then
-		return nil, nil, nil, nil, nil, table.concat ({'unrecognized language tag: ', source});		-- don't know what we got but it is malformed
+		return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_tag, {source});	-- don't know what we got but it is malformed
 	end
@@ Line 320: / Line 413: @@
 	if not (override_table[code] or lang_table[code] or synonym_table[code] or lang_dep_table[code]) then
-		return nil, nil, nil, nil, nil, table.concat ({'unrecognized language code: ', code});		-- invalid language code, don't know about the others (don't care?)
+		return nil, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_code, {code});		-- invalid language code, don't know about the others (don't care?)
 	end
 	if synonym_table[code] then													-- if 639-2/639-2T code has a 639-1 synonym
-		table.insert (maint_cats, table.concat ({'Lang and lang-xx code promoted to ISO 639-1|', code}));
+		table.insert (maint_cats, substitute (cfg.get_ietf_parts_t.maint_promo_cat, {code}));
-		table.insert (maint_msgs, table.concat ({'code: ', code, ' promoted to code: ', synonym_table[code]}));
+		table.insert (maint_msgs, substitute (cfg.get_ietf_parts_t.maint_promo_msg, {code, synonym_table[code]}));
 		code = synonym_table[code];												-- use the synonym
 	end
@@ Line 331: / Line 424: @@
 	if is_set (script) then
 		if is_set (args_script) then
-			return code, nil, nil, nil, nil, 'redundant script tag';			-- both code with script and |script= not allowed
+			return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_scr;	-- both code with script and |script= not allowed
 		end
 	else
@@ Line 340: / Line 433: @@
 		script = script:lower();												-- ensure that we use and return lower case version of this
 		if not script_table[script] then
-			return code, nil, nil, nil, nil, table.concat ({'unrecognized script: ', script, ' for code: ', code});	-- language code ok, invalid script, don't know about the others (don't care?)
+			return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_scr_code, {script, code});	-- language code ok, invalid script, don't know about the others (don't care?)
 		end
 	end
 	if suppressed_table[script] then											-- ensure that code-script does not use a suppressed script
 		if in_array (code, suppressed_table[script]) then
-			return code, nil, nil, nil, nil, table.concat ({'script: ', script, ' not supported for code: ', code});	-- language code ok, script is suppressed for this code
+			return code, nil, nil, nil, nil, substitute (cfg.get_ietf_parts_t.script_code, {script, code});	-- language code ok, script is suppressed for this code
 		end
 	end
@@ Line 351: / Line 444: @@
 	if is_set (region) then
 		if is_set (args_region) then
-			return code, nil, nil, nil, nil, 'redundant region tag';			-- both code with region and |region= not allowed
+			return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_reg;	-- both code with region and |region= not allowed
 		end
 	else
@@ Line 360: / Line 453: @@
 		region = region:lower();												-- ensure that we use and return lower case version of this
 		if not region_table[region] then
-			return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code});
+			return code, script, nil, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_reg_code, {region, code});
 		end
 	end
@@ Line 366: / Line 459: @@
 	if is_set (variant) then
 		if is_set (args_variant) then
-			return code, nil, nil, nil, nil, 'redundant variant tag';			-- both code with variant and |variant= not allowed
+			return code, nil, nil, nil, nil, cfg.get_ietf_parts_t.redundant_var;	-- both code with variant and |variant= not allowed
 		end
 	else
@@ Line 375: / Line 468: @@
 		variant = variant:lower();												-- ensure that we use and return lower case version of this
 		if not variant_table[variant] then										-- make sure variant is valid
-			return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant});
+			return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var, {variant});
 		end																		-- does this duplicate/replace tests in lang() and lang_xx()?
 		if is_set (script) then													-- if script set it must be part of the 'prefix'
 			if not in_array (table.concat ({code, '-', script}), variant_table[variant]['prefixes']) then
-				return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script});
+				return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_scr, {variant, code, script});
 			end
 		elseif is_set (region) then												-- if region set, there are some prefixes that require lang code and region (en-CA-newfound)
 			if not in_array (code, variant_table[variant]['prefixes']) then		-- first see if lang code is all that's required (en-oxendict though en-GB-oxendict is preferred)
 				if not in_array (table.concat ({code, '-', region}), variant_table[variant]['prefixes']) then		-- now try for lang code and region (en-CA-newfound)
-					return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-region pair: ', code, '-', region});
+					return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code_reg, {variant, code, region});
 				end
 			end
 		else																	-- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0
 			if variant_table[variant]['prefixes'][1] and not in_array (code, variant_table[variant]['prefixes']) then
-				return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code});
+				return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_var_code, {variant, code});
 			end
 		end
@@ Line 397: / Line 490: @@
 		private = private:lower();												-- ensure that we use and return lower case version of this
 		if not override_table[table.concat ({code, '-x-', private})] then		-- make sure private tag is valid; note that index
-			return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private});
+			return code, script, region, nil, nil, substitute (cfg.get_ietf_parts_t.unrecog_pri, {private});
 		end
 	end
@@ Line 403: / Line 496: @@
 end
---[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------
-assembles an error message from template name, message text, help link, and error category.
-]]
-local function make_error_msg (msg, args, template)
-	local out = {};
-	local category;
-	if 'Transl' == template then
-		category = 'Transl';
-	else
-		category = 'Lang and lang-xx'
-	end
-	table.insert (out, table.concat ({'[', args.text or 'undefined', '] '}));	-- for error messages output args.text if available
-	table.insert (out, table.concat ({'<span style=\"color:#d33\">Error: {{', template, '}}: '}));
-	table.insert (out, msg);
-	table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));
-	table.insert (out, '</span>');
-	if (0 == namespace or 10 == namespace) and not args.nocat then				-- categorize in article space (and template space to take care of broken usages)
-		table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'}));
-	end
-	return table.concat (out);
-end
 --[=[-------------------------< M A K E _ W I K I L I N K >----------------------------------------------------
@@ Line 457: / Line 520: @@
 --[[--------------------------< D I V _ M A R K U P _ A D D >--------------------------------------------------
-adds <i> and </i> tags to list-item text or to implied <p>..</p> text.  mixed not supported
+Adds <i> and </i> tags to list-item text or to implied <p>..</p> text. Mixed not supported.
 ]]
 local function div_markup_add (text, style)
-local implied_p = {};
 	if text:find ('^\n[%*:;#]') then											-- look for list markup; list markup must begin at start of text
 		if 'italic' == style then
@@ Line 484: / Line 545: @@
 	return text;
+end
+--[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------
+Makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where
+<title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in
+html markup.  This because the lang= attibute applies to the content of its enclosing tag.
+<tag> holds a string 'div' or 'span' used to choose the correct wrapping tag.
+]]
+local function title_wrapper_make (title_text, content_text, tag)
+	local wrapper_t = {};
+	table.insert (wrapper_t, table.concat ({'<', tag}));						-- open opening wrapper tag
+	table.insert (wrapper_t, ' title=\"');										-- begin title attribute
+	table.insert (wrapper_t, title_text);										-- add <title_text>
+	table.insert (wrapper_t, '\">');											-- end title attribute and close opening wrapper tag
+	table.insert (wrapper_t, content_text);										-- add <content_text>
+	table.insert (wrapper_t, table.concat ({'</', tag, '>'}));					-- add closing wrapper tag
+	return table.concat (wrapper_t);											-- make a big string and done
 end
@@ Line 491: / Line 576: @@
 Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or
 <div> tags for block content
+The lang= attribute also applies to the content of the tag where it is placed so this is wrong because 'Spanish
+language text' is English:
+	<i lang="es" title="Spanish language text">casa</i>
+should be:
+	<span title="Spanish language text"><i lang="es">casa</i></span>
+or for <div>...</div>:
+	<div title="Spanish language text"><div lang="es"><spanish-language-text></div></div>
 ]]
 local function make_text_html (code, text, tag, rtl, style, size, language)
-	local html = {};
+	local html_t = {};
 	local style_added = '';
+	local wrapper_tag = tag;													-- <tag> gets modified so save a copy for use when/if we create a wrapper span or div
 	if text:match ('^%*') then
-		table.insert (html, '&#42;');											-- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki
+		table.insert (html_t, '&#42;');											-- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki
 		text = text:gsub ('^%*', '');											-- remove the splat from the text
 	end
@@ Line 511: / Line 605: @@
 	end
-	table.insert (html, table.concat ({'<', tag}));								-- open the <i>, <span>, or <div> html tag
+	table.insert (html_t, table.concat ({'<', tag}));							-- open the <i>, <span>, or <div> html tag
 	code = code:gsub ('%-x%-.*', '');											-- strip private use subtag from code tag because meaningless outside of wikipedia
-	table.insert (html, table.concat ({' lang="', code, '\"'}));				-- add language attribute
+	table.insert (html_t, table.concat ({' lang="', code, '\"'}));				-- add language attribute
 	if (rtl or unicode.is_rtl(text)) and ('ltr' == this_wiki_lang_dir) then		-- text is right-to-left on a left-to-right wiki
-		table.insert (html, ' dir="rtl"');										-- add direction attribute for right-to-left languages
+		table.insert (html_t, ' dir="rtl"');									-- add direction attribute for right-to-left languages
 	elseif not (rtl or unicode.is_rtl(text)) and ('rtl' == this_wiki_lang_dir) then	-- text is left-to-right on a right-to-left wiki
-		table.insert (html, ' dir="ltr"');										-- add direction attribute for left-to-right languages
+		table.insert (html_t, ' dir="ltr"');									-- add direction attribute for left-to-right languages
 	end
 	if 'normal' == style then													-- when |italic=no
-		table.insert (html, ' style=\"font-style: normal;');						-- override external markup, if any
+		table.insert (html_t, ' style=\"font-style: normal;');					-- override external markup, if any
 		style_added = '\"';														-- remember that style attribute added and is not yet closed
 	end
@@ Line 528: / Line 622: @@
 	if is_set (size) then														-- when |size=<something>
 		if is_set (style_added) then
-			table.insert (html, table.concat ({' font-size: ', size, ';'}));		-- add when style attribute already inserted
+			table.insert (html_t, table.concat ({' font-size: ', size, ';'}));	-- add when style attribute already inserted
 		else
-			table.insert (html, table.concat ({' style=\"font-size: ', size, ';'}));	-- create style attribute
+			table.insert (html_t, table.concat ({' style=\"font-size: ', size, ';'}));	-- create style attribute
 			style_added = '\"';													-- remember that style attribute added and is not yet closed
 		end
 	end
-	if is_set (language) then
+	table.insert (html_t, table.concat ({style_added, '>'}));					-- close the opening html tag
-		table.insert (html, table.concat ({style_added, ' title=\"', language}));	-- start the title text
+	table.insert (html_t, text);												-- insert the text
-		if 'zxx' == code then													-- special case for this tag
-			table.insert (html, ' text');										-- not a language so don't use 'language' in title text
+	table.insert (html_t, table.concat ({'</', tag, '>'}));						-- close the 'text' <i>, <span>, or <div> html tag
-		elseif mw.ustring.find (language, 'languages', 1, true) then
-			table.insert (html, ' collective text');							-- for collective languages
+	if is_set (language) then													-- create a <title_text> string for the title= attribute in a wrapper span or div
-		else
+		local title_text;
-			table.insert (html, '-language text');								-- for individual languages
+			if 'zxx' == code then												-- special case for this tag 'no linguistic content'
-		end
+				title_text = substitute ('$1 $2', {language, cfg.make_text_html_t.zxx});	-- not a language so don't use 'language' in title text
-		table.insert (html, '\">');												-- close the opening html tag
+			elseif mw.ustring.find (language, 'languages', 1, true) then
+				title_text = substitute ('$1 $2', {language, cfg.make_text_html_t.collective});	-- for collective languages
+			else
+				title_text = substitute ('$1-$2', {language, cfg.make_text_html_t.individual});	-- for individual languages
+			end
+		return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag);
 	else
-		table.insert (html, table.concat ({style_added, '>'}));					-- close the style attribute and close opening html tag
+		return table.concat (html_t);
 	end
-	table.insert (html, text);													-- insert the text
-	table.insert (html, table.concat ({'</', tag, '>'}));						-- close the <i>, <span>, or <div> html tag
-	return table.concat (html);													-- put it all together and done
 end
@@ Line 561: / Line 656: @@
 	[[Category:Articles containing <language>-language text]]
-for English:
+For English:
 	[[Category:Articles containing explicitly cited English-language text]]
-for ISO 639-2 collective languages (and for 639-1 bh):
+For ISO 639-2 collective languages (and for 639-1 bh):
 	[[Category:Articles with text in <language> languages]]
@@ Line 570: / Line 665: @@
 local function make_category (code, language_name, nocat, name_get)
-	local cat = {};
-	local retval;
 	if ((0 ~= namespace) or nocat) and not name_get then						-- only categorize in article space
 		return '';																-- return empty string for concatenation
@@ Line 578: / Line 670: @@
 	if mw.ustring.find (language_name, 'languages', 1, true) then
-		return table.concat ({'[[Category:Articles with text in ', language_name, ']]'});
+		return substitute ('[[$1 $2]]', {cfg.make_category_t.collective_cat, language_name});
 	end
-	table.insert (cat, '[[Category:Articles containing ');
+	if this_wiki_lang_tag == code then
+		return substitute ('[[$1 $2 $3-$4]]', {									-- unique category name for the local language
-	if 'en' == code then
+			cfg.make_category_t.cat_prefix,
-		table.insert (cat, 'explicitly cited ' .. language_name);				-- falls back to English if regional name not available
+			cfg.make_category_t.explicit_cat,
+			language_name,
+			cfg.make_category_t.cat_postfix,
+			});
 	else
-		table.insert (cat, language_name);
+		return substitute ('[[$1 $2-$3]]', {									-- category for individual languages
+			cfg.make_category_t.cat_prefix,
+			language_name,
+			cfg.make_category_t.cat_postfix,
+			});
 	end
-	table.insert (cat, '-language text]]');
-	return table.concat (cat);
 end
@@ Line 597: / Line 692: @@
 --[[--------------------------< M A K E _ T R A N S L I T >----------------------------------------------------
-return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string
+Return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string.
-The value |script= is not used in {{transl}} for this purpose; instead it uses |code.  Because language scripts
+The value |script= is not used in {{transliteration}} for this purpose; instead it uses |code.  Because language scripts
-are listed in the {{transl}} switches they are included in the data tables.  The script parameter is introduced
+are listed in the {{transliteration}} switches they are included in the data tables.  The script parameter is introduced
 at {{Language with name and transliteration}}.  If |script= is set, this function uses it in preference to code.
 To avoid confusion, in this module and the templates that use it, the transliteration script parameter is renamed
-to be |translit-script= (in this function, tscript)
+to be |translit-script= (in this function, tscript).
 This function is used by both lang_xx() and transl()
@@ Line 610: / Line 705: @@
 	transl() always provides language_name, translit, and one of code or tscript, never both; always provides style
-For {{transl}}, style only applies when a language code is provided
+For {{transliteration}}, style only applies when a language code is provided.
 ]]
-local function make_translit (code, language_name, translit, std, tscript, style)
+local function make_translit (code, language_name, translit, std, tscript, style, engvar)
-	local title;
+	local title_t = lang_data.translit_title_table;								-- table of transliteration standards and the language codes and scripts that apply to those standards
-	local tout = {};
+	local title_text = '';														-- tool tip text for title= attribute
-	local title_table = lang_data.translit_title_table;							-- table of transliteration standards and the language codes and scripts that apply to those standards
-	if is_set (code) then														-- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
-		if not style then														-- nil for the default italic style
-			table.insert (tout, "<i lang=\"");									-- so use <i> tag
-		else
-			table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'}));	-- non-standard style, construct a span tag for it
-		end
-		table.insert (tout, code);
-		table.insert (tout, "-Latn\" title=\"");								-- transliterations are always Latin script
-	else
-		table.insert (tout, "<span title=\"");									-- when no language code: no lang= attribute, not italic ({{transl}} only)
-	end
 	std = std and std:lower();													-- lower case for table indexing
 	if not is_set (std) and not is_set (tscript) then							-- when neither standard nor script specified
-		table.insert (tout, language_name);										-- write a generic tool tip
+		title_text = language_name;												-- write a generic tool tip
 		if not mw.ustring.find (language_name, 'languages', 1, true) then		-- collective language names (plural 'languages' is part of the name)
-			table.insert (tout, '-language')									-- skip this text (individual and macro languages only)
+			title_text = substitute ('$1-$2', {title_text, cfg.misc_text_t.language});	-- skip this text (individual and macro languages only)
 		end
-		table.insert (tout, ' romanization');									-- finish the tool tip; use romanization when neither script nor standard supplied
+		title_text = substitute ('$1 $2', {title_text, mw.ustring.lower (cfg.engvar_t[engvar]['romanisz_lc'])});	-- finish the tool tip; use romanization when neither script nor standard supplied
 	elseif is_set (std) and is_set (tscript) then								-- when both are specified
-		if title_table[std] then												-- and if standard is legitimate
+		if title_t[std] then													-- and if standard is legitimate
-			if title_table[std][tscript] then									-- and if script for that standard is legitimate
+			if title_t[std][tscript] then										-- and if script for that standard is legitimate
 				if script_table[tscript] then
-					table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', script_table[tscript], ' script) transliteration'}));	-- add the appropriate text to the tool tip
+					title_text = substitute ('$1$2 ($3 $4) $5', {				-- add the appropriate text to the tool tip
+						title_text,
+						title_t[std][tscript:lower()],
+						script_table[tscript],
+						cfg.make_translit_t.script,
+						cfg.make_translit_t.transliteration,
+						});
 				else
-					table.insert (tout, title_table[std]['default']);				-- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
+					title_text = title_text .. title_t[std]['default'];			-- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
 				end
 			else
-				table.insert (tout, title_table[std]['default']);				-- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
+				title_text = title_text .. title_t[std]['default'];				-- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
 			end
 		else
@@ Line 654: / Line 744: @@
 	elseif is_set (std) then													-- translit-script not set, use language code
-		if not title_table[std] then return ''; end								-- invalid standard, setup for error message
+		if not title_t[std] then return ''; end									-- invalid standard, setup for error message
-		if title_table[std][code] then											-- if language code is in the table (transl may not provide a language code)
+		if title_t[std][code] then												-- if language code is in the table (transl may not provide a language code)
-			table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', language_name, ' language) transliteration'}));	-- add the appropriate text to the tool tip
+			title_text = substitute ('$1$2 ($3 $4) $5', {						-- add the appropriate text to the tool tip
+				title_text,
+				title_t[std][code:lower()],
+				language_name,
+				cfg.misc_text_t.language,
+				cfg.make_translit_t.transliteration,
+				});
 		else																	-- code doesn't match
-			table.insert (tout, title_table[std]['default']);					-- so use the standard's default
+			title_text = title_text .. title_t[std]['default'];					-- so use the standard's default
 		end
 	else																		-- here if translit-script set but translit-std not set
-		if title_table['no_std'][tscript] then
+		if title_t['no_std'][tscript] then
-			table.insert (tout, title_table['no_std'][tscript]);				-- use translit-script if set
+			title_text = title_text .. title_t['no_std'][tscript];				-- use translit-script if set
-		elseif title_table['no_std'][code] then
+		elseif title_t['no_std'][code] then
-			table.insert (tout, title_table['no_std'][code]);					-- use language code
+			title_text = title_text .. title_t['no_std'][code];					-- use language code
 		else
 			if is_set (tscript) then
-				table.insert (tout, table.concat ({language_name, '-script transliteration'}));	-- write a script tool tip
+				title_text = substitute ('$1$2-$3 $4', {						-- write a script tool tip
+					title_text,
+					language_name,
+					cfg.make_translit_t.script,
+					cfg.make_translit_t.transliteration,
+					});
 			elseif is_set (code) then
 				if not mw.ustring.find (language_name, 'languages', 1, true) then	-- collective language names (plural 'languages' is part of the name)
-					table.insert (tout, '-language')							-- skip this text (individual and macro languages only)
+					title_text = substitute ('$1-$2', {							-- skip this text (individual and macro languages only)
+						title_text,
+						cfg.misc_text_t.language,
+						});
 				end
-				table.insert (tout, ' transliteration');						-- finish the tool tip
+					title_text = substitute ('$1 $2', {							-- finish the tool tip
+						title_text,
+						cfg.make_translit_t.transliteration,
+						});
 			else
-				table.insert (tout, ' transliteration');						-- generic tool tip (can we ever get here?)
+					title_text = substitute ('$1 $2', {							-- generic tool tip (can we ever get here?)
+						title_text,
+						cfg.make_translit_t.transliteration,
+						});
 			end
 		end
 	end
-	table.insert (tout, '">');
+	local tag
-	table.insert (tout, translit);
+	if is_set (code) then														-- when a language code is provided (always with {{lang-??}} templates, not always with {{transliteration}})
-	if is_set (code) and not style then											-- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
+		code = code:match ('^(%a%a%a?)');										-- strip all subtags leaving only the language subtag
-		table.insert (tout, "</i>");											-- close the italic tag
+		if not style then														-- nil for the default italic style
+			tag = '<i lang="%s-Latn">%s</i>'
+		else
+			tag = '<span style="font-style: %s" lang="%s-Latn">%s</span>'		-- non-standard style, construct a span tag for it
+			tag = string.format(tag, style, "%s", "%s")
+		end
+		tag = string.format(tag, code, "%s")
 	else
-		table.insert (tout, "</span>");											-- no language code so close the span tag
+		tag = '<span>%s</span>'													-- when no language code: no lang= attribute, not italic ({{transliteration}} only)
+	end
+	tag = string.format(tag, translit)											-- add the translit text
+	if '' == title_text then													-- when there is no need for a tool-tip
+		return tag;																-- done
+	else
+		title_text = cfg.engvar_sel_t.gb == engvar and title_text:gsub ('([Rr]omani)z', '%1s') or title_text;	-- gb eng when engvar specifies gb eng; us eng else
+		return title_wrapper_make (title_text, tag, 'span');					-- wrap with a tool-tip span and done
 	end
-	return table.concat (tout);
 end
@@ Line 694: / Line 819: @@
 This function checks the content of args.text and returns empty string if nothing is amiss else it returns an
-error message.  The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.
+error message. The tests are for empty or missing text and for improper or disallowed use of apostrophe markup.
 Italic rendering is controlled by the |italic= template parameter so italic markup should never appear in args.text
@@ Line 703: / Line 828: @@
 local function validate_text (template, args)
 	if not is_set (args.text) then
-		return make_error_msg ('no text', args, template);
+		return make_error_msg (cfg.validate_text_t.no_text, args, template);
 	end
 	if args.text:find ("%f[\']\'\'\'\'%f[^\']") or args.text:find ("\'\'\'\'\'[\']+") then	-- because we're looking, look for 4 appostrophes or 6+ appostrophes
-		return make_error_msg ('text has malformed markup', args, template);
+		return make_error_msg (cfg.validate_text_t.malformed_markup, args, template);
 	end
 	local style = args.italic;
-	if ('unset' ~= style) and ('invert' ~=style) then
+	if (cfg.keywords_t.unset ~= style) and (cfg.keywords_t.invert ~=style) then
 		if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then	-- italic but not bold, or bold italic
-			return make_error_msg ('text has italic markup', args, template);
+			return make_error_msg (cfg.validate_text_t.italic_markup, args, template);
 		end
 	end
@@ Line 722: / Line 847: @@
 --[[--------------------------< R E N D E R _ M A I N T >------------------------------------------------------
-render mainenance messages and categories
+Render mainenance messages and categories.
 ]]
-local function render_maint(nocat)
+local function render_maint (nocat)
 	local maint = {};
@@ Line 749: / Line 874: @@
 --[[--------------------------< P R O T O _ P R E F I X >------------------------------------------------------
-for proto languages, text is prefixed with a splat.  We do that here as a flag for make_text_html() so that a splat
+For proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat
-will be rendered outside of italic markup (if used).  If the first character in text here is already a splat, we
+will be rendered outside of italic markup (if used). If the first character in text here is already a splat, we
-do nothing
+do nothing.
-proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and / or inhibits
+proto_param is boolean or nil; true adds splat prefix regardless of language name; false removes and inhibits
-regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac
+regardless of language name; nil does nothing; presumes that the value in text is correct but removes extra splac.
 ]]
@@ Line 771: / Line 896: @@
 --[[--------------------------< H A S _ P O E M _ T A G >------------------------------------------------------
-looks for a poem strip marker in text; returns true when found; false else
+Looks for a poem strip marker in text; returns true when found; false else.
-auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know
+Auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know
 the content that will replace the stripmarker.
@@ Line 798: / Line 923: @@
 If text contains <poem>...</poem> stripmarker, return text unmodified and choose <div>..</div> tags because
 the stripmarker is replaced with text wrapped in <div>..</div> tags.
+If the text contains any actual <div>...</div> tags, then it's again returned unmodified and <div>...</div>
+tags are used to wrap it, to prevent div/span inversion.
 ]]
@@ Line 806: / Line 934: @@
 	if has_poem_tag (text) then													-- contains poem stripmarker (we can't know the content of that)
 		tag = 'div';															-- poem replacement is in div tags so lang must use div tags
+	elseif text:find ('<div') then												-- reductive; if the text contains a div tag, we must use div tags
+		tag = 'div';
 	elseif mw.text.trim (text):find ('\n\n+') then								-- contains implied p tags
 		text = mw.text.trim (text);												-- trim leading and trailing whitespace characters
@@ Line 823: / Line 953: @@
 --[[--------------------------< V A L I D A T E _ P R O T O >--------------------------------------------------
-validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,
+Validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,
-empty string (or parameter omitted) returns as nil; any other value returns as nil with a second return value of
+empty string (or parameter omitted) returns as nil; any other value returns nil with <proto_param> as second
-true indicating that some other value has been assigned to |proto=
+return value for use in error message.
 ]]
 local function validate_proto (proto_param)
-	if 'yes' == proto_param then
+	if cfg.keywords_t.affirmative == proto_param then
 		return true;
-	elseif 'no' == proto_param then
+	elseif cfg.keywords_t.negative == proto_param then
 		return false;
 	elseif is_set (proto_param) then
-		return nil, true;														-- |proto= something other than 'yes' or 'no'
+		return nil, proto_param;												-- |proto= something other than 'yes' or 'no'
 	else
 		return nil;																-- missing or empty
@@ Line 844: / Line 974: @@
 --[[--------------------------< L A N G U A G E _ N A M E _ G E T >--------------------------------------------
-common function to return language name from the data set according to IETF tag
+Common function to return language name from the data set according to IETF tag.
-returns language name if found in data tables; nil else
+Returns language name if found in data tables; nil else.
 ]]
@@ Line 866: / Line 996: @@
 	if lang_dep_table[code] and cat then										-- because deprecated code may have been overridden to en.wiki preferred name
-		table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));
+		table.insert (maint_cats, substitute (cfg.language_name_get_t.deprecated_cat, {code}));
-		table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));
+		table.insert (maint_msgs, substitute (cfg.language_name_get_t.deprecated_msg, {code}));
 	end
 	return name;																-- name from data tables or nil
+end
+--[[--------------------------< T E X T _ S C R I P T _ M A T C H _ T E S T >----------------------------------
+IETF script subtag should match the script of the <text>.  This module does not attempt to know all scripts and
+what they look like.  It does know what Latn script looks like so when <text> is written using other than the Latn
+script, the IETF script subtag, if present, should not be Latn.
+Conversely, when <text> is written using the Latn script, the IETF script subtag, if present, should be Latn.
+For the purposes of this test, Latf (Fraktur) and Latg (Gaelic) are considered to be equivalent to Latn because
+unicode treats these two scripts as font-specific variants of Latn.
+Returns an error message when mismatch detected; nil else.
+]]
+local function text_script_match_test (script, is_latn_text, pos)
+	local scripts_t = {['latf'] = true, ['latg'] = true, ['latn'] = true};		-- unicode 'latn' scripts; 'latf' and 'latg' are font variants so there are no Fraktur or Gaelic codepoints
+	if is_set (script) then														-- don't bother with the rest of this if <script> is nil or empty string
+		script = script:lower();												-- lower case to index into <scripts_t>
+		if is_latn_text then													-- when text is wholly Latn script
+			if not scripts_t[script] then										-- but a non-Latn script is specified
+				return cfg.text_script_match_test_t.latn_txt_mismatch;			-- emit an error message
+			end
+		else																	-- when text is not wholly Latn script
+			if scripts_t[script] then											-- but a Latn script is specified
+				return substitute (cfg.text_script_match_test_t.latn_scr_mismatch, {pos});	-- emit an error message with position of first offending character
+			end
+		end
+	end
+end
+--[[--------------------------< I S _ L A T I N >--------------------------------------------------------------
+Created because unicode does not have Latin theta 'θ' character.  The Greek 'θ' is, apparently, commonly used
+in certain romanizations.  This function attempts to discover if <text> script is Latn with Greek 'θ' or some
+other script with Greek 'θ'.
+when <text> is or has Greek 'θ':
+	for {{lang}}, {{langx}}, and {{lang-??}}, returns boolean true when <text>:
+		has theta and all other characters are Latn
+		has theta as the only character, <script> is Latn
+	for {{transliteration}}, returns boolean true when <text>:
+		has theta and all other characters are Latn
+		has theta as the only character
+]]
+local function is_latin (text, script, transl)
+	if mw.ustring.find (text, 'θ', 1, true) then								-- does <text> contain 'θ'?
+		text = text:gsub ('θ', '');												-- remove theta from <text>
+		if 0 == text:len() then													-- will be zero if theta was the only character in <text>
+			if transl then														-- not nil for {{transliteration}}; assume Latin theta because this is 'transliteration' template
+				return true;
+			end
+			return (script and ('latn' == script:lower())) or false;			-- {{lang}}, {{langx}}, and {{lang-??}}; true when script is Latn; false else
+		end
+		return unicode.is_Latin (text);											-- return true when all characters in modified <text> are Latn script; false else
+	end
+	return unicode.is_Latin (text);												-- return true when all characters in <text> are Latn script; false else
 end
@@ Line 876: / Line 1,071: @@
 --[[--------------------------< _ L A N G >--------------------------------------------------------------------
-entry point for {{lang}}
+Entry point for {{lang}}.
-there should be no reason to set parameters in the {{lang}} {{#invoke:}}
+There should be no reason to set parameters in the {{lang}} {{#invoke:}}
 	<includeonly>{{#invoke:lang|lang}}</includeonly>
-parameters are received from the template's frame (parent frame)
+Parameters are received from the template's frame (parent frame).
 ]]
@@ Line 893: / Line 1,088: @@
 	local msg;																	-- for error messages
 	local tag = 'span';															-- initial value for make_text_html()
-	local template = args.template or 'Lang';
+	local template = args.template or cfg.templates_t.lang;
+	maint_cats = {};															-- initialize because when this module required into another module, these only declared once so only initialzed once
+	maint_msgs = {};
 	validate_cat_args (args);													-- determine if categorization should be suppressed
 	if args[1] and args.code then
-		return make_error_msg ('conflicting: {{{1}}} and |code=', args, template);
+		return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'1', cfg.lang_t.conflict_n_param_types.code}), args, template);
 	else
 		args.code = args[1] or args.code;										-- prefer args.code
@@ Line 904: / Line 1,102: @@
 	if args[2] and args.text then
-		return make_error_msg ('conflicting: {{{2}}} and |text=', args, template);
+		return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {'2', cfg.lang_t.conflict_n_param_types.text}), args, template);
 	else
 		args.text = args[2] or args.text;										-- prefer args.text
 	end
 	msg = validate_text (template, args);										-- ensure that |text= is set
 	if is_set (msg) then														-- msg is an already-formatted error message
@@ Line 916: / Line 1,114: @@
 	args.text, tag = html_tag_select (args.text);								-- inspects text; returns appropriate html tag with text trimmed accordingly
-	args.rtl = args.rtl == 'yes';												-- convert to boolean: 'yes' -> true, other values -> false
+	args.rtl = args.rtl == cfg.keywords_t.affirmative;							-- convert to boolean: 'yes' -> true, other values -> false
 	args.proto, msg = validate_proto (args.proto);								-- return boolean, or nil, or nil and error message flag
 	if msg then
-		return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template);
+		return make_error_msg (substitute (cfg.lang_t.invalid_proto, {msg}), args, template);
 	end
@@ Line 926: / Line 1,124: @@
 	if msg then
-		return make_error_msg ( msg, args, template);
+		return make_error_msg (msg, args, template);
+	end
+	local is_latn_text, pos = is_latin (args.text, subtags.script);				-- make a boolean
+	msg = text_script_match_test (subtags.script, is_latn_text, pos)
+	if msg then																	-- if an error detected then there is an error message
+		return make_error_msg (msg, args, template);
 	end
@@ Line 936: / Line 1,141: @@
 	if nil == args.italic then													-- nil when |italic= absent or not set or |italic=default; args.italic controls
 		if ('latn' == subtags.script) or								 		-- script is latn
-			(this_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)
+			(this_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and is_latn_text) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics)
 				args.italic = 'italic';											-- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic
 		else
@@ Line 954: / Line 1,159: @@
 	language_name = language_name_get (args.code, code, true);					-- get language name; try ietf tag first, then code w/o variant then code w/ variant
-	if 'invert' == args.italic and 'span' == tag then							-- invert only supported for in-line content
+	if cfg.keywords_t.invert == args.italic and 'span' == tag then				-- invert only supported for in-line content
 		args.text = invert_italics (args.text)
 	end
@@ Line 962: / Line 1,167: @@
 	table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, language_name));
 	table.insert (out, make_category (code, language_name, args.nocat));
-	table.insert (out, render_maint(args.nocat));								-- maintenance messages and categories
+	table.insert (out, render_maint (args.nocat));								-- maintenance messages and categories
 	return table.concat (out);													-- put it all together and done
@@ Line 970: / Line 1,175: @@
 --[[--------------------------< L A N G >----------------------------------------------------------------------
-entry point for {{lang}}
+Entry point for {{lang}}.
-there should be no reason to set parameters in the {{lang}} {{#invoke:}}
+There should be no reason to set parameters in the {{lang}} {{#invoke:}}
 	<includeonly>{{#invoke:lang|lang}}</includeonly>
-parameters are received from the template's frame (parent frame)
+Parameters are received from the template's frame (parent frame).
 ]]
 local function lang (frame)
-	local args = getArgs (frame, {												-- this code so that we can detect and handle wiki list markup in text
+	local args_t = getArgs (frame, {											-- this code so that we can detect and handle wiki list markup in text
 		valueFunc = function (key, value)
 			if 2 == key or 'text' == key then									-- the 'text' parameter; do not trim wite space
@@ Line 994: / Line 1,199: @@
 		});
-	return _lang (args);
+	args_t.fn = nil;															-- unset because not supported but this function might have been called by {{lang|fn=lang|...}}
+	local msg = parameter_validate (args_t, cfg.templates_t.lang);				-- verify that all supplied parameters are supported by {{lang-??}}
+	if msg then
+		return make_error_msg (msg, args_t, cfg.templates_t.lang);				-- when template has unsupported params, abandon with error message
+	end
+	return _lang (args_t);
+end
+--[[--------------------------< T R A N S L A T I O N _ M A K E >----------------------------------------------
+Stand-alone function to create literal translation of main text.
+Also used by {{lang-x2}}.
+]]
+local function translation_make (args_t)
+	local translation_t = {', '};												-- initialize output
+	if 'none' ~= args_t.label then												-- if we want a label
+		table.insert (translation_t, '<small>');								-- open the <small> html tag
+		if cfg.keywords_t.negative == args_t.link then
+			table.insert (translation_t, substitute ('<abbr title="$1">$2</abbr>', {cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr}));	-- unlinked form
+		else
+			table.insert (translation_t, make_wikilink (cfg.translation_make_t.lit_xlation, cfg.translation_make_t.lit_abbr));	-- linked form
+		end
+		table.insert (translation_t, "&thinsp;</small>");						-- close the <small> html tag
+	end
+	table.insert (translation_t, table.concat ({'&#39;', args_t.translation, '&#39;'}));	-- use html entities to avoid wiki markup confusion
+	return table.concat (translation_t);										-- make a big string and done
 end
---[[--------------------------< L A N G _ X X >----------------------------------------------------------------
+--[[--------------------------< _ L A N G _ X X >--------------------------------------------------------------
-For the {{lang-xx}} templates, the only parameter required to be set in the template is the language code.  All
+For the {{lang-??}} templates, the only parameter required to be set in the template is the language code.  All
-other parameters can, usually should, be written in the template call.  For {{lang-xx}} templates for languages
+other parameters can, usually should, be written in the template call.  For {{lang-??}} templates for languages
 that can have multiple writing systems, it may be appropriate to set |script= as well.
-For each {{lang-xx}} template choose the appropriate entry-point function so that this function knows the default
+For each {{lang-??}} template choose the appropriate entry-point function so that this function knows the default
 styling that should be applied to text.
@@ Line 1,029: / Line 1,266: @@
 				any other text replaces language-name label - automatic wikilinking disabled
-	for those {{lang-xx}} templates that support transliteration (those templates where |text= is not entirely latn script):
+	for those {{lang-??}} templates that support transliteration (those templates where |text= is not entirely latn script):
 	|translit = text that is a transliteration of text
 	|translit-std = the standard that applies to the transliteration
 	|translit-script = ISO 15924 script name; falls back to code
-For {{lang-xx}}, the positional parameters are:
+For {{lang-??}}, the positional parameters are:
 	{{{1}}}	text
 	{{{2}}}	transliterated text
@@ Line 1,042: / Line 1,279: @@
 ]]
-local function _lang_xx (args)
+local function _lang_xx (args, base_template)									-- base_template will be either of 'Langx' or 'Lang-xx'
 	local out = {};
 	local language_name;														-- used to make display text, article links
@@ Line 1,051: / Line 1,288: @@
 	local translit_script_name;													-- name associated with IANA (ISO 15924) script code
 	local translit;
-	local translit_title;
 	local msg;																	-- for error messages
 	local tag = 'span';															-- initial value for make_text_html()
-	local template = args.template or 'Lang-xx';
+	local template = args.template or base_template;
-	if args[1] and args.text then
+	maint_cats = {};															-- initialize because when this module required into another module, these only declared once so only initialzed once
-		return make_error_msg ('conflicting: {{{1}}} and |text=', args, template);
+	maint_msgs = {};
+	local text_idx = (cfg.templates_t.langx == base_template) and 2 or 1;		-- for {{langx}} 'text' positional parameter is '2'
+	local translit_idx = (cfg.templates_t.langx == base_template) and 3 or 2;
+	local xlate_idx = (cfg.templates_t.langx == base_template) and 4 or 3;
+	if args[text_idx] and args.text then
+		return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.text}), args, template);
 	else
-		args.text = args[1] or args.text;										-- prefer args.text
+		args.text = args[text_idx] or args.text;								-- prefer positional 'text' parameter
 	end
 	msg = validate_text (template, args);										-- ensure that |text= is set, does not contain italic markup and is protected from improper bolding
 	if is_set (msg) then
@@ Line 1,069: / Line 1,312: @@
 	args.text, tag = html_tag_select (args.text);								-- inspects text; returns appropriate html tag with text trimmed accordingly
-	if args[2] and args.translit then
+	if args[translit_idx] and args.translit then
-		return make_error_msg ('conflicting: {{{2}}} and |translit=', args, template);
+		return make_error_msg (substitute (cfg.lang_t.conflict_n_param, {translit_idx, cfg.lang_t.conflict_n_param_types.translit}), args, template);
 	else
-		args.translit = args[2] or args.translit								-- prefer args.translit
+		args.translit = args[translit_idx] or args.translit						-- prefer positional 'translit' parameter
+	end
+	if args.translit then
+		local latn, pos = is_latin (args.translit, nil, true);
+		if not latn then
+			return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template);
+		end
 	end
-	if args[3] and (args.translation or args.lit) then
+	args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar;			-- |engvar= when valid; cfg.default_engvar else
-		return make_error_msg ('conflicting: {{{3}}} and |lit= or |translation=', args, template);
+	if args[xlate_idx] and (args.translation or args.lit) then
+		return make_error_msg (substitute (cfg.lang_xx_t.conflict_n_lit, {translit_idx}), args, template);
 	elseif args.translation and args.lit then
-		return make_error_msg ('conflicting: |lit= and |translation=', args, template);
+		return make_error_msg (cfg.lang_xx_t.conflict_lit, args, template);
 	else
-		args.translation = args[3] or args.translation or args.lit;				-- prefer args.translation
+		args.translation = args[xlate_idx] or args.translation or args.lit;		-- prefer positional 'translation' parameter
 	end
 	if args.links and args.link then
-		return make_error_msg ('conflicting: |links= and |link=', args, template);
+		return make_error_msg (cfg.lang_xx_t.conflict_link, args, template);
 	else
 		args.link = args.link or args.links;									-- prefer args.link
@@ Line 1,091: / Line 1,344: @@
 	validate_cat_args (args);													-- determine if categorization should be suppressed
-	args.rtl = args.rtl == 'yes';												-- convert to boolean: 'yes' -> true, other values -> false
+	args.rtl = args.rtl == cfg.keywords_t.affirmative;							-- convert to boolean: 'yes' -> true, other values -> false
 	code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code, args.script, args.region, args.variant);	-- private omitted because private
@@ Line 1,099: / Line 1,352: @@
 	end
+	local is_latn_text, pos = is_latin (args.text, subtags.script);				-- make a boolean
+	msg = text_script_match_test (subtags.script, is_latn_text, pos)
+	if msg then																	-- if an error detected then there is an error message
+		return make_error_msg (msg, args, template);
+	end
 	args.italic, msg = validate_italic (args);
 	if msg then
 		return make_error_msg (msg, args, template);
 	end
-	if nil == args.italic then													-- args.italic controls
+	if cfg.templates_t.langx == base_template then								-- auto-italics  for {{langx}} templates; adapted from {{lang}} (no support for poem tag)
-		if is_set (subtags.script) then
+		if nil == args.italic then												-- nil when |italic= absent or not set or |italic=default; args.italic controls
-			if 'latn' == subtags.script then
+			if ('latn' == subtags.script) or								 	-- script is latn
-				args.italic = 'italic';											-- |script=Latn; set for font-style:italic
+				(this_wiki_lang_tag ~= code and not is_set (subtags.script) and is_latn_text) then -- text is not this wiki's language, no script specified and is wholly latn script (auto-italics)
+					args.italic = 'italic';										-- set font-style:italic
+			else
+				args.italic = 'inherit';										-- italic not set; script not latn; inherit current style
+			end
+		end
+	else																		-- {{lang-xx}} does not do auto italics; retained for those wikis that don't support {{langx}}
+		if nil == args.italic then												-- args.italic controls
+			if is_set (subtags.script) then
+				if 'latn' == subtags.script then
+					args.italic = 'italic';										-- |script=Latn; set for font-style:italic
+				else
+					args.italic = initial_style_state;							-- italic not set; script is not latn; set for font-style:<initial_style_state>
+				end
 			else
-				args.italic = initial_style_state;								-- italic not set; script is not latn; set for font-style:<initial_style_state>
+				args.italic = initial_style_state;								-- here when |italic= and |script= not set; set for font-style:<initial_style_state>
 			end
-		else
-			args.italic = initial_style_state;									-- here when |italic= and |script= not set; set for font-style:<initial_style_state>
 		end
 	end
@@ Line 1,126: / Line 1,398: @@
 	args.proto, msg = validate_proto (args.proto);								-- return boolean, or nil, or nil and error message flag
 	if msg then
-		return make_error_msg (table.concat ({'invalid |proto=: ', args.proto}), args, template);
+		return make_error_msg (substitute (cfg.lang_t.invalid_proto, {args.proto}), args, template);
 	end
@@ Line 1,140: / Line 1,412: @@
 		end
 	else
-		if 'no' == args.link then
+		if cfg.keywords_t.negative == args.link then
 			table.insert (out, language_name);									-- language name without wikilink
 		else
 			if mw.ustring.find (language_name, 'languages', 1, true) then
 				table.insert (out, make_wikilink (language_name));				-- collective language name uses simple wikilink
-			elseif lang_data.article_name[code] then
+			elseif lang_data.article_name[args.code:lower()] then				-- is ietf tag in article name over ride?
+				table.insert (out, make_wikilink (lang_data.article_name[args.code:lower()], language_name));	-- language name with wikilink from override data
+			elseif lang_data.article_name[code] then							-- is language tag in article override
 				table.insert (out, make_wikilink (lang_data.article_name[code], language_name));	-- language name with wikilink from override data
 			else
-				table.insert (out, make_wikilink (language_name .. ' language', language_name));	-- language name with wikilink
+				table.insert (out, make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), language_name));	-- language name with wikilink
 			end
 		end
@@ Line 1,154: / Line 1,428: @@
 	end
-	if 'invert' == args.italic then
+	if cfg.keywords_t.invert == args.italic then
 		args.text = invert_italics (args.text)
 	end
@@ Line 1,162: / Line 1,436: @@
 	table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, ('none' == args.label) and language_name or nil))
-	if is_set (args.translit) and not unicode.is_Latin (args.text) then			-- transliteration (not supported in {{lang}}); not supported when args.text is wholly latn text (this is an imperfect test)
+	if is_set (args.translit) and not is_latn_text then							-- transliteration; not supported when args.text is wholly latn text (this is an imperfect test)
 		table.insert (out, ', ');												-- comma to separate text from translit
 		if 'none' ~= args.label then
@@ Line 1,171: / Line 1,445: @@
 				translit_script_name = language_name;							-- fall back on language name
 			end
-			translit_title = mw.title.makeTitle (0, table.concat ({'Romanization of ', translit_script_name}));		-- make a title object
-			if translit_title.exists and ('no' ~= args.link) then
+			local translit_title_obj = mw.title.makeTitle (0, substitute ('$1 $2',{cfg.lang_xx_t.romanization, translit_script_name}));		-- make a title object; no engvar, article titles use US spelling
-				table.insert (out, make_wikilink ('Romanization of ' .. translit_script_name or language_name, 'romanized') .. ':');	-- make a wikilink if there is an article to link to
+			if translit_title_obj.exists and (cfg.keywords_t.negative ~= args.link) then
+				table.insert (out, make_wikilink (substitute ('$1 $2', {cfg.lang_xx_t.romanization, translit_script_name or language_name}),
+					substitute ('$1', {cfg.engvar_t[args.engvar]['romanisz_pt']})) .. ':');	-- make a wikilink if there is an article to link to; engvar the display text
 			else
-				table.insert (out, 'romanized:');								-- else plain text
+				table.insert (out, substitute ('$1:', {cfg.engvar_t[args.engvar]['romanisz_pt']}));	-- else plain text per engvar
 			end
 			table.insert (out, '&nbsp;</small>');								-- close the small tag
 		end
-		translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script'])
+		translit = make_translit (args.code, language_name, args.translit, args['translit-std'], args['translit-script'], nil, args.engvar)
 		if is_set (translit) then
 			table.insert (out, translit);
 		else
-			return make_error_msg (table.concat ({'invalid translit-std: \'', args['translit-std'] or '[missing]'}), args, template);
+			return make_error_msg (substitute ('$1: $2', {cfg.lang_xx_t.invalid_xlit_std, args['translit-std'] or '[missing]'}), args, template);
 		end
+	elseif is_set (args.translit) and is_latn_text then							-- when creating a transliteration of Latn script <text>
+		return make_error_msg (cfg.lang_xx_t.xlit_of_latn, args, template);		-- emit error message and abandon
 	end
 	if is_set (args.translation) then											-- translation (not supported in {{lang}})
-		table.insert (out, ', ');
+		table.insert (out, translation_make (args));
-		if 'none' ~= args.label then
-			table.insert (out, '<small>');
-			if 'no' == args.link then
-				table.insert (out, '<abbr title="literal translation">lit.</abbr>');
-			else
-				table.insert (out, make_wikilink ('Literal translation', 'lit.'));
-			end
-			table.insert (out, "&thinsp;</small>");
-		end
-		table.insert (out, table.concat ({'&#39;', args.translation, '&#39;'}));	-- use html entities to avoid wiki markup confusion
 	end
@@ Line 1,211: / Line 1,482: @@
 --[[--------------------------< L A N G _ X X _ A R G S _ G E T >----------------------------------------------
-common function to get args table from {{lang-??}} templates
+Common function to get args table from {{lang-??}} templates.
+Returns table of args.
-returns table of args
+Text positional parameters are not trimmed here but are selectively trimmed at html_tag_select().
 ]]
-local function lang_xx_args_get (frame)
+local function lang_xx_args_get (frame, base_template)
-	local args = getArgs(frame,
+	local args_t = getArgs(frame,
 		{
 		parentFirst= true,														-- parameters in the template override parameters set in the {{#invoke:}}
 		valueFunc = function (key, value)
-			if 1 == key then													-- the 'text' parameter; do not trim wite space
+			if ((cfg.templates_t.langx == base_template) and 2 or 1) == key then	-- the 'text' positional parameter; 1 for {{lang-??}}, 2 for {{langx}}; do not trim wite space
-				return value;													-- return untrimmed 'text'
+				return value;													-- return untrimmed 'text' positional parameter
 			elseif value then													-- all other values: if the value is not nil
 				value = mw.text.trim (value);									-- trim whitespace
@@ Line 1,234: / Line 1,507: @@
 	});
-	return args;
+	return args_t;
 end
@@ Line 1,240: / Line 1,513: @@
 --[[--------------------------< L A N G _ X X _ I T A L I C >--------------------------------------------------
-Entry point for those {{lang-xx}} templates that call lang_xx_italic().  Sets the initial style state to italic.
+Entry point for those {{lang-??}} templates that call lang_xx_italic(). Sets the initial style state to italic.
 ]]
 local function lang_xx_italic (frame)
-	local args = lang_xx_args_get (frame);
+	local args = lang_xx_args_get (frame, cfg.templates_t.langxx);
+	args.fn = nil;																-- unset because not supported but this function might have been called by {{lang|fn=lang_xx_italic|...}}
+	local msg = parameter_validate (args, cfg.templates_t.langxx);				-- verify that all supplied parameters are supported by {{lang-??}}
+	if msg then
+		return make_error_msg (msg, args, cfg.templates_t.langxx);				-- when template has unsupported params, abandon with error message
+	end
 	initial_style_state = 'italic';
-	return _lang_xx (args);
+	return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]';	-- temporary category
 end
@@ Line 1,254: / Line 1,533: @@
 --[[--------------------------< _ L A N G _ X X _ I T A L I C >------------------------------------------------
-Entry point ffrom another module.  Sets the initial style state to italic.
+Entry point from another module. Sets the initial style state to italic.
 ]]
@@ Line 1,260: / Line 1,539: @@
 local function _lang_xx_italic (args)
 	initial_style_state = 'italic';
-	return _lang_xx (args);
+	return _lang_xx (args, cfg.templates_t.langxx);
 end
@@ Line 1,266: / Line 1,545: @@
 --[[--------------------------< L A N G _ X X _ I N H E R I T >------------------------------------------------
-Entry point for those {{lang-xx}} templates that call lang_xx_inherit().  Sets the initial style state to inherit.
+Entry point for those {{lang-??}} templates that call lang_xx_inherit(). Sets the initial style state to inherit.
 ]]
 local function lang_xx_inherit (frame)
-	local args = lang_xx_args_get (frame);
+	local args = lang_xx_args_get (frame, cfg.templates_t.langxx);
+	args.fn = nil;																-- unset because not supported but this function might have been called by {{lang|fn=lang_xx_inherit|...}}
+	local msg = parameter_validate (args, cfg.templates_t.langxx);				-- verify that all supplied parameters are supported by {{lang-??}}
+	if msg then
+		return make_error_msg (msg, args, cfg.templates_t.langxx);				-- when template has unsupported params, abandon with error message
+	end
 	initial_style_state = 'inherit';
-	return _lang_xx (args);
+	return _lang_xx (args, cfg.templates_t.langxx) .. '[[Category:Pages using Lang-xx templates]]';	-- temporary category
 end
@@ Line 1,280: / Line 1,565: @@
 --[[--------------------------< _ L A N G _ X X _ I N H E R I T >----------------------------------------------
-Entry point from another module.  Sets the initial style state to inherit.
+Entry point from another module. Sets the initial style state to inherit.
 ]]
@@ Line 1,286: / Line 1,571: @@
 local function _lang_xx_inherit (args)
 	initial_style_state = 'inherit';
-	return _lang_xx (args);
+	return _lang_xx (args, cfg.templates_t.langxx);
+end
+--[[--------------------------< _ L A N G X >------------------------------------------------------------------
+Entry point from another module.
+]]
+local function _langx (args_t)
+	local langx_data = mw.loadData ('Module:Lang/langx');						-- get necessary data
+	local rtl_t = langx_data.rtl_t;												-- get list of language tags for languages that are rendered right-to-left
+	local link_t = langx_data.link_t;											-- get list of language tags for {{lang-??}} templates that set |link=<something>
+	local size_t = langx_data.size_t;											-- get list of language tags for {{lang-??}} templates that set |size=<something>
+	local msg = parameter_validate (args_t, cfg.templates_t.langx);
+	if msg then
+		return make_error_msg (msg, args_t, cfg.templates_t.langx);
+	end
+	args_t.code = args_t[1] or args_t.code;										-- get the language tag; must be {{{1}}} or |code=
+	if not args_t.code then
+		return make_error_msg (cfg.get_ietf_parts_t.missing_lang_tag, args_t, cfg.templates_t.langx);
+	end
+	args_t.rtl = args_t.rtl or (rtl_t[args_t.code] and cfg.keywords_t.affirmative);	-- prefer |rtl= in template call, use rtl_t else
+	args_t.link = args_t.link or link_t[args_t.code];							-- prefer |link= in template call, use link_t felse
+	args_t.size = args_t.size or size_t[args_t.code];							-- prefer |size= in template call, use size_t else
+	args_t[1] = nil;															-- unset to mimic {{lang-??}} templates which set |code=xx
+	local lang_subtag = args_t.code;											-- use only the base language subtag for unsupported tag test; some args_t.code are modified by |script= etc
+	return _lang_xx (args_t, cfg.templates_t.langx);
+end
+--[[--------------------------< L A N G X >--------------------------------------------------------------------
+Entry point for {{langx}}.
+this function calls _lang_xx() to render non-English text. The {{lang-??}} templates have three positional paramters
+but {{langx}} has four:
+				|  1	|  2		|  3		|  4
+	{{lang-xx	|<text>	|<transl>	|<xlate>			}}
+	{{langx		|<tag>	|<text>		|<transl>	|<xlate>	}}
+The calls to lang_xx_args_get() and _lang_xx() use 'Langx' as a flag for those functions to select the proper
+positional parameters.
+{{lang-??}} depends on the calling template to select 'inherit' or 'italic' to establish the default rendering.
+{{langx}} can't do that.  The initial version of {{langx}} relied on a list of language tags (inherit_t in ~/langx)
+scraped from those {{lang-??}} templates that call lang_xx_inherit() to render text in upright font. Langx now
+uses auto-italics code adapted from {{lang}} (doesn't support poem tags).
+]]
+local function langx (frame)
+	local args_t = lang_xx_args_get (frame, cfg.templates_t.langx);				-- get the arguments; 'Langx' is the <base_template> used to decide which positional param is 'text', 'translit', 'lit'
+	return _langx (args_t);
 end
@@ Line 1,294: / Line 1,641: @@
 Returns true when a language name associated with IETF language tag exists; nil else.  IETF language tag must be valid.
-All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
+All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.
-Module entry point from another module
+Module entry point from another module.
 ]]
@@ Line 1,310: / Line 1,657: @@
 --[[--------------------------< I S _ I E T F _ T A G >--------------------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,336: / Line 1,683: @@
 Returns language name associated with IETF language tag if valid; error message else.
-All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
+All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.
 Set invoke's |link= parameter to yes to get wikilinked version of the language name.
-Module entry point from another module
+Module entry point from another module.
 ]]
@@ Line 1,347: / Line 1,694: @@
 	local subtags = {};															-- IETF subtags script, region, variant, and private
 	local raw_code = args[1];													-- save a copy of the input IETF subtag
-	local link = 'yes' == args['link'];											-- make a boolean
+	local link = cfg.keywords_t.affirmative == args['link'];					-- make a boolean
 	local label = args.label;
 	local code;																	-- the language code
@@ Line 1,356: / Line 1,703: @@
 	if msg then
 		local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or '';	-- make template name (if provided by the template)
-		return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});
+		return make_error_span (template, msg);
 	end
@@ Line 1,367: / Line 1,714: @@
 		if mw.ustring.find (language_name, 'languages', 1, true) then
 			language_name = make_wikilink (language_name, label);				-- collective language name uses simple wikilink
-		elseif lang_data.article_name[code] then
+		elseif lang_data.article_name[raw_code:lower()] then					-- is ietf tag in article name override?
+			language_name = make_wikilink (lang_data.article_name[raw_code:lower()], label or language_name);	-- language name with wikilink from override data
+		elseif lang_data.article_name[code] then								-- is language tag in article name override?
 			language_name = make_wikilink (lang_data.article_name[code], label or language_name);	-- language name with wikilink from override data
 		else
-			language_name = make_wikilink (language_name .. ' language', label or language_name);	-- language name with wikilink
+			language_name = make_wikilink (substitute ('$1 $2', {language_name, cfg.misc_text_t.language}), label or language_name);	-- language name with wikilink
 		end
 	end
@@ Line 1,380: / Line 1,729: @@
 --[[--------------------------< N A M E _ F R O M _ T A G >----------------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,395: / Line 1,744: @@
 that disambiguator must be omitted (they are not present in the data name-to-tag tables).
-Module entry point from another module
+Module entry point from another module.
 ]]
@@ Line 1,410: / Line 1,759: @@
 			return tag, true;													-- language name found so return tag and done; second return used by is_lang_name()
 		else
-			msg = 'language: ' .. args[1] .. ' not found'						-- language name not found, error message
+			msg = substitute (cfg.tag_from_name_t.lang_not_found, {args[1]});	-- language name not found, error message
 		end
 	else
-		msg = 'missing language name'											-- language name not provided, error message
+		msg = cfg.tag_from_name_t.missing_lang_name;							-- language name not found, error message
 	end
@@ Line 1,420: / Line 1,769: @@
 		template = table.concat ({'{{', args['template'], '}}: '});				-- make template name (if provided by the template)
 	end
-	return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});
+	return make_error_span (template, msg);
 end
@@ Line 1,426: / Line 1,776: @@
 --[[--------------------------< T A G _ F R O M _ N A M E >----------------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,438: / Line 1,788: @@
 --[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,450: / Line 1,800: @@
 --[[--------------------------< _ T R A N S L >----------------------------------------------------------------
-Module entry point from another module
+Module entry point from another module.
 ]]
@@ Line 1,460: / Line 1,810: @@
 	local script;																-- IANA script
 	local msg;																	-- for when called functions return an error message
+	local template = args.template or cfg.templates_t.transliteration;
-	if is_set (args[3]) then													-- [3] set when {{transl|code|standard|text}}
+	maint_cats = {};															-- initialize because when this module required into another module, these only declared once so only initialzed once
+	maint_msgs = {};
+	if is_set (args[3]) then													-- [3] set when {{transliteration|code|standard|text}}
 		args.text = args[3];													-- get the transliterated text
 		args.translit_std = args[2] and args[2]:lower();						-- get the standard; lower case for table indexing
 		if not title_table[args.translit_std] then
-			return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transl');
+			return make_error_msg (substitute (cfg.transl_t.unrecog_xlit_std, {args.translit_std}), args, template);
 		end
 	else
-		if is_set (args[2]) then												-- [2] set when {{transl|code|text}}
+		if is_set (args[2]) then												-- [2] set when {{transliteration|code|text}}
 			args.text = args[2];												-- get the transliterated text
 		else
-			if args[1] and args[1]:match ('^%a%a%a?%a?$') then					-- args[2] missing; is args[1] a code or is it the transliterated text?
+			if args[1] and (args[1]:match ('^%a%a%a?%a?$') or					-- args[2] missing; is args[1] a language or script tag or is it the transliterated text?
-				return make_error_msg ('no text', args, 'Transl');				-- args[1] is a code so we're missing text
+				args[1]:match ('^%a%a%a?%-x%-')) then							-- or is args[1] a private-use tag
+					return make_error_msg (cfg.transl_t.no_text, args, template);	-- args[1] is a code so we're missing text
 			else
 				args.text = args[1];											-- args[1] is not a code so we're missing that; assign args.text for error message
-				return make_error_msg ('missing language / script code', args, 'Transl');
+				return make_error_msg (cfg.transl_t.missing_lang_scr, args, template);
 			end
 		end
@@ Line 1,482: / Line 1,837: @@
 	if is_set (args[1]) then													-- IANA language code used for html lang= attribute; or ISO 15924 script code
-		if args[1]:match ('^%a%a%a?%a?$') then									-- args[1] has correct form?
+		if args[1]:match ('^%a%a%a?%a?$') or args[1]:match ('^%a%a%a?%-x%-') then	-- args[1] has correct form?
-			args.code = args[1]:lower();										-- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case
+			args.code = args[1]:lower();										-- use the language/script code; only (2, 3, or 4 alpha characters) or private-use; lower case because table indexes are lower case
 		else
-			return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transl');	-- invalid language / script code
+			return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args[1]}), args, template);	-- invalid language / script code
 		end
 	else
-		return make_error_msg ('missing language / script code', args, 'Transl');	-- missing language / script code so quit
+		return make_error_msg (cfg.transl_t.missing_lang_scr, args, template);	-- missing language / script code so quit
+	end
+	local latn, pos = is_latin (args.text, nil, true);
+	if not latn then									-- text is not latn
+		return make_error_msg (substitute (cfg.lang_xx_t.translit_nonlatn, {pos}), args, template);
 	end
 	args.italic, msg = validate_italic (args);
 	if msg then
-		return make_error_msg (msg, args, 'Transl');
+		return make_error_msg (msg, args, template);
 	end
@@ Line 1,499: / Line 1,860: @@
 		args.italic = nil;														-- set to nil;
 	end
+	args.engvar = cfg.engvar_sel_t[args.engvar] or cfg.default_engvar;			-- |engvar= when valid; cfg.default_engvar else
 	if override_table[args.code] then											-- is code a language code defined in the override table?
 		language_name = override_table[args.code];
+		args.code = args.code:match ('^%a%a%a?');								-- if private use, strip all but language subtag
 	elseif lang_table[args.code] then											-- is code a language code defined in the standard language code tables?
 		language_name = lang_table[args.code];
@@ Line 1,511: / Line 1,875: @@
 		args.code = '';															-- unset because not a language code
 	else
-		return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transl');	-- invalid language / script code
+		return make_error_msg (substitute (cfg.transl_t.unrecog_lang_scr, {args.code}), args, template);	-- invalid language / script code
 	end
 																				-- here only when all parameters passed to make_translit() are valid
-	return make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic);
+	return make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic, args.engvar);
 end
@@ Line 1,520: / Line 1,884: @@
 --[[--------------------------< T R A N S L >------------------------------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,531: / Line 1,895: @@
 --[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------
-Returns category name associated with IETF language tag if valid; error message else
+Returns category name associated with IETF language tag if valid; error message else.
-All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
+All code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.
-Module entry point from another module
+Module entry point from another module.
 ]]
@@ Line 1,542: / Line 1,906: @@
 	local subtags = {};															-- IETF subtags script, region, variant, and private
 	local raw_code = args_t[1];													-- save a copy of the input IETF subtag
-	local link = 'yes' == args_t.link;											-- make a boolean
+	local link = cfg.keywords_t.affirmative == args_t.link;						-- make a boolean
 	local label = args_t.label;
 	local code;																	-- the language code
@@ Line 1,551: / Line 1,915: @@
 	if msg then
 		local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or '';	-- make template name (if provided by the template)
-		return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});
+		return make_error_span (template, msg);
 	end
@@ Line 1,568: / Line 1,932: @@
 --[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------
-Module entry point from an {{#invoke:}}
+Module entry point from an {{#invoke:}}.
 ]]
@@ Line 1,583: / Line 1,947: @@
 	category_from_tag = category_from_tag,
 	lang = lang,																-- entry point for {{lang}}
+	langx = langx,																-- entry point for {{langx}}
 	lang_xx_inherit = lang_xx_inherit,											-- entry points for {{lang-??}}
 	lang_xx_italic = lang_xx_italic,
@@ Line 1,590: / Line 1,955: @@
 	tag_from_name = tag_from_name,												-- returns ietf tag associated with language name
 	name_from_tag = name_from_tag,												-- used for template documentation; possible use in ISO 639 name from code templates
-	transl = transl,															-- entry point for {{transl}}
+	transl = transl,															-- entry point for {{transliteration}}
 	_category_from_tag = _category_from_tag,									-- entry points when this module is require()d into other modules
 	_lang = _lang,
+	_langx = _langx,
 	_lang_xx_inherit = _lang_xx_inherit,
 	_lang_xx_italic = _lang_xx_italic,
@@ Line 1,601: / Line 1,967: @@
 	_name_from_tag = _name_from_tag,
 	_transl = _transl,
+	_translation_make = translation_make,
 	};