Este módulo existe principalmente para proporcionar un marcado HTML correcto para textos en idiomas distintos del inglés cuando se utilizan en la Wikipedia en inglés. Tiene un propósito secundario: proporcionar una representación visual correcta de este texto en un idioma distinto del inglés. El módulo se desarrolló para consolidar el procesamiento de , the (most) y templates en una única fuente y para utilizar un conjunto de datos claramente definido extraído de estándares internacionales. Proporciona verificación de errores y generación de informes para garantizar que el HTML representado sea correcto para navegadores y lectores de pantalla.{{Lang}}{{lang-??}}{{Transl}}
Otras plantillas que obtienen soporte para nombres de idiomas de este módulo son:
.svg/1280px-Test_Template_Info-Icon_-_Version_(2).svg.png){kind=icon}
{{Native name}}El conjunto de datos se especifica en Módulo:Lang/data y sus módulos de datos incluidos:
El conjunto de datos también incluye módulos de datos complementarios:
MoS sobre palabras extranjeras:
--[=[ Compatibilidad de Lua con las plantillas {{lang}}, {{langx}}, {{lang-??}} y {{transliteration}} y reemplazo de varias plantillas de soporte. ]=] require ( 'strict' ); local getArgs = require ( 'Module:Arguments' ). getArgs ; local unicode = require ( "Module:Unicode data" ); -- para is_latin() y is_rtl() local yesno = require ( 'Module:Yesno' ); local lang_data = mw . loadData ( 'Module:Lang/data' ); -- tablas de información sobre herramientas de transliteración y anulación de nombres de idiomas local lang_name_table = lang_data . lang_name_table ; -- códigos de idiomas, nombres, regiones, escrituras, escrituras suprimidas local lang_table = lang_data . lang_name_table . lang ; local lang_dep_table = lang_data . lang_name_table . lang_dep ; local script_table = lang_data . lang_name_table . script ; local region_table = lang_data . lang_name_table . region ; local variant_table = lang_data . lang_name_table . variant ; local suppressed_table = lang_data . lang_name_table . suppressed ; local override_table = lang_data . override ; local synonym_table = mw . loadData ( 'Módulo:Lang/Sinónimos ISO 639' ); -- Traducción de código ISO 639-2/639-2T a código 639-1 local namespace = mw . title . getCurrentTitle (). namespace ; -- usado para categorización local content_lang = mw . language . getContentLanguage (); local this_wiki_lang_tag = content_lang . code ; -- obtener la etiqueta de idioma de esta wiki local this_wiki_lang_dir = content_lang : getDir (); -- obtener la dirección de idioma de esta wiki local initial_style_state ; -- establecido por lang_xx_normal() y lang_xx_italic() local maint_cats = {}; -- las categorías de mantenimiento van aquí local maint_msgs = {}; -- y sus mensajes van aquí --[[--------------------------< IS _ SET >------------------------------------------------------------------ Devuelve verdadero si el argumento está establecido; falso en caso contrario. El argumento está 'establecido' cuando existe (no nulo) o cuando no es una cadena vacía. ]] local function is_set ( var ) return not ( var == nil o var == '' ); Esta función intenta invertir el marcado en cursiva de un args.text agregando o quitando el marcado en cursiva inicial o final en args.text. Al igual que |italic=unset, |italic=invert desactiva el marcado en cursiva automático. Los apóstrofos iniciales o finales individuales se convierten en su equivalente de entidad numérica html para que el nuevo marcado en cursiva no se convierta en marcado en negrita inadvertidamente. El marcado wiki inicial y final se extrae de args.text en elementos de tabla separados. La adición, eliminación y reemplazo del marcado wiki se maneja mediante una tabla de reemplazo string.gsub() que opera solo en estos elementos separados. En el patrón de coincidencia string.gsub(), '.*' coincide con una cadena vacía así como con los tres patrones de marcado wiki esperados. Esta función espera que el marcado en args.text esté completo y sea correcto; si no lo está, pueden resultar extraños. ]] función local invert_italics ( fuente ) invert_pattern_table local = { -- marcado inicial/final agregar/eliminar/reemplazar patrones [ "" ] = " \'\' " , -- cadena vacía se convierte en marcado en cursiva [ " \'\' " ] = "" ,-- el marcado en cursiva se convierte en una cadena vacía [ " \'\'\' " ] = " \'\'\'\'\' " , -- negrita se convierte en negrita cursiva [ " \'\'\'\'\' " ] = " \'\'\' " , -- negrita cursiva se convierte en negrita }; local seg = {}; source = source : gsub ( "%f[ \' ] \' %f[^ \' ]" , ''' ); -- proteger las comillas simples para que no se interpreten como marcado en negrita seg [ 1 ] = source : match ( '^( \'\' +%f[^ \' ]).+' ) o '' ; -- obtener el marcado inicial, si lo hay; ignorar las comillas simples seg [ 3 ] = source : match ( '.+(%f[ \' ] \'\' +)$' ) o '' ; -- obtener el marcado final, si lo hay; ignorar comillas simples si '' ~= seg [ 1 ] y '' ~= seg [ 3 ] entonces -- extraer el 'texto' seg [ 2 ] = source : match ( '^ \'\' +%f[^ \' ](.+)%f[ \' ] \'\' +$' ) -- de entre el marcado inicial y final elseif '' ~= seg [ 1 ] entonces seg [ 2 ] = source : match ( '^ \'\' +%f[^ \' ](.+)' ) -- siguiente marcado inicial elseif '' ~= seg [ 3 ] entonces seg [ 2 ] = source : match ( '(.+)%f[ \' ] \'\' +$' ) -- marcado anterior y final else seg [ 2 ] = source -- cuando no hay marcado end seg [ 1 ] = invert_pattern_table [ seg [ 1 ]] o seg [ 1 ]; -- reemplaza el marcado inicial según la tabla de patrones seg [ 3 ] = invert_pattern_table [ seg [ 3 ]] o seg [ 3 ]; -- reemplaza el marcado inicial según la tabla de patrones return table.concat ( seg ); -- vuelve a juntarlo todo y listo end --[[--------------------------< VALIDATE _ ITALIC >------------------------------------------------ valida los valores asignados de |italic= o |italics=. Cuando |italic= está configurado y tiene un valor asignado aceptable, devuelve el valor de la propiedad de estilo de fuente CSS correspondiente o, para el caso especial 'predeterminado', devuelve nil. Cuando |italic= no está configurado, o tiene un valor asignado inaceptable, devuelve nil y un mensaje de error nil. Cuando tanto |italic= como |italics= están configurados, devuelve nil y un mensaje de error 'conflictivo'. El valor de retorno nil hace que la función lang, lang_xx o transl que realiza la llamada establezca args.italic según el valor predeterminado definido en la plantilla ('inherit' para {{lang}}, 'inherit' o 'italic' para {{lang-??}} según los requisitos de la plantilla individual, 'italic' para {{transliteration}}) o según el valor apropiado para |script=, si está establecido ( solo {{lang}} y {{lang-??}}). Los valores aceptados y los valores que esta función devuelve son: nil: cuando |italic= no está establecido o no está establecido; devuelve nil por defecto: para completar, rara vez se debe usar; devuelve nil yes: fuerza que args.text se represente en fuente itálica; devuelve 'italic' no: fuerza que args.text se represente en fuente normal; devuelve 'normal' unset: deshabilita el control de fuente para que el estilo de fuente aplicado al texto esté determinado por el marcado dentro o fuera de la plantilla; devuelve 'invert' invert - deshabilita el control de fuente para que el estilo de fuente aplicado al texto sea determinado por el marcado externo o invertido dentro de la plantilla; devuelve 'invert' ]] función local validar_italic ( args ) propiedades locales = {[ 'yes' ] = 'italic' , [ 'no' ] = 'normal' , [ 'unset' ] = 'inherit' ,[ 'invertir' ] = 'invert' , [ 'default' ] = nil }; recuento local = 0 para _ , arg en pares { 'italic' , 'italics' , 'i' } do if args [ arg ] then count = count + 1 end end if count > 1 then -- devuelve nil y un mensaje de error si se establece más de uno return nil , 'solo se puede especificar uno de |italic=, |italics= o |i=' ; end return properties [ args . italic o args . italics o args . i ], nil ; -- devuelve un valor apropiado y un mensaje de error nil end --[=[---------------------------< VALIDATE _ CAT _ ARGS >---------------------------------------------------------- El comportamiento predeterminado de las plantillas {{lang}} y {{lang-??}} es agregar categorización cuando las plantillas se usan en el espacio principal. Esta funcionalidad predeterminada se puede suprimir estableciendo |nocat=yes o |cat=no. Esta función selecciona uno de estos dos parámetros para controlar la categorización. Debido a que tener dos parámetros con nombres 'opuestos' y valores 'opuestos' es confuso, esta función solo acepta valores afirmativos para |nocat= y solo valores negativos para |cat=; en ambos casos, el 'otro' sentido (y sin sentido) no se acepta y el parámetro se trata como si no estuviera establecido en la plantilla. Establece args.nocat en verdadero si se debe desactivar la categorización; en nulo si se debe aplicar el comportamiento predeterminado. Los valores aceptados para |nocat= son las cadenas de texto: 'yes', 'y', 'true', 't', on, '1' -- [[Module:Yesno]] devuelve verdadero lógico para todos estos; falso o nulo en caso contrario para |cat= 'no', 'n', 'false', 'f', 'off', '0' -- [[Module:Yesno]] devuelve falso lógico para todos estos; verdadero o nulo de lo contrario ]=] función local validar_cat_args ( args ) si no ( args . nocat o args . cat ) entonces -- ambos son nulos,Entonces categorizar devuelve ; fin si es falso == yesno ( args.cat ) o true == yesno ( args.nocat ) entonces args.nocat = true ; -- se establece en true cuando args.nocat es afirmativo; nil en caso contrario (como si el parámetro no estuviera establecido en la plantilla) de lo contrario -- args.nocat es el parámetro realmente utilizado. args.nocat = nil ; fin fin -- [[--------------------------< IN _ ARRAY >-------------------------------------------------------------- Si la aguja está en el pajar ]] función local in_array ( aguja , pajar ) si la aguja == nil entonces devuelve falso ; fin para n , v en ipairs ( haystack ) hacer si v == aguja entonces devuelve n ; fin fin devuelve falso ; fin --[[--------------------------< FORMAT _ IETF _ TAG >------------------------------------------------ embellezca las etiquetas ietf para usar los formatos de subetiqueta recomendados: código: minúscula script: caso de oración región: mayúscula variante: minúscula privada: minúscula con el prefijo -x- ]] función local format_ietf_tag ( código , script , región , variante , privada ) local out = {}; if is_set ( privada ) then return table.concat ({ código : lower (), 'x' , privado : lower ()}, '-' ); -- si es privado, se ignoran todas las demás etiquetas fin tabla.insert ( out , código : lower ()); if is_set ( script ) then script = script : lower (): gsub ( '^%a' , string.upper ); table.insert ( out , script ); end if is_set ( region ) then table.insert ( out , region : upper ()); end if is_set ( variant ) then table.insert ( out , variant : lower ()); end return table.concat ( out , '-' ); end --[[--------------------------< GET _ IETF _ PARTS >-------------------------------------------------- extrae y devuelve partes de la etiqueta de idioma IETF: subetiqueta de idioma principal (obligatoria) - código de idioma IANA de 2 o 3 caracteres subetiqueta de script - código de script IANA de cuatro caracteres subetiqueta de región - código de región IANA de dos letras o tres dígitos subetiqueta de variante - código de variante de cuatro dígitos o 5-8 alnum; solo se admite una subetiqueta de variante subetiqueta privada - x- seguida de un código privado alnum de 1-8; solo se admite con la etiqueta de idioma principal en cualquiera de estas formas lang lang-variant lang-script lang-script-variant lang-region lang-region-variant lang-script-region lang-script-region-variant lang-x-private cada uno de lang, script, region, variant y private, cuando se usan, deben ser válidos Los idiomas con sinónimos de código de dos y tres caracteres se promueven al sinónimo de dos caracteres porque el archivo de registro de IANA omite el código sinónimo de tres caracteres; no podemos depender de que los navegadores entiendan los códigos sinónimos de tres caracteres en el atributo lang=. Para las plantillas {{lang-??}}, se admiten los parámetros |script=, |region= y |variant= (no se admiten en {{lang}} porque esos parámetros son superfluos para las subetiquetas IETF en |code=) devuelve seis valores; todos en minúsculas. Las partes válidas se devuelven como ellas mismas; las partes omitidas se devuelven como cadenas vacías, las partes no válidas se devuelven como nulas; el sexto elemento devuelto es un mensaje de error (si se detecta un error) o nulo. consulte http://www.rfc-editor.org/rfc/bcp/bcp47.txt sección 2.1 ]] función local get_ietf_parts ( source , args_script , args_region , args_variant ) código local , script , región , variante , privado ; -- partes de etiqueta ietf si no es is_set ( fuente ) , entonces devuelve nil , nil , nil , nil , nil , 'etiqueta de idioma faltante' ; fin patrón local = { -- tabla de tablas que contienen patrones de etiqueta ietf aceptables y nombres cortos de la parte ietf capturada por el patrón { '^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%d%d%d%d)$' , 's' , 'r' , 'v' }, -- 1 - ll-Ssss-RR-variant (donde variant tiene 4 dígitos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%d%d%d%d)$' , 's' , 'r' , 'v' }, -- 2 - ll-Ssss-DDD-variant (donde region tiene 3 dígitos; variant tiene 4 dígitos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$' , 's' , 'r' , 'v' }, -- 3 - ll-Ssss-RR-variant (donde variant tiene entre 5 y 8 caracteres numéricos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$' , 's' , 'r' , 'v' }, -- 4 - ll-Ssss-DDD-variant (donde region tiene entre 3 dígitos; variant tiene entre 5 y 8 caracteres numéricos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d%d)$' , 's' , 'v' }, -- 5 - ll-Ssss-variant (donde variant tiene 4 dígitos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%w%w%w%w%w%w?%w?%w?)$' , 's' , 'v' }, -- 6 - ll-Ssss-variant (donde variant tiene 5-8 caracteres alnum) { '^(%a%a%a?)%-(%a%a)%-(%d%d%d%d)$' , 'r' , 'v' }, -- 7 - ll-RR-variant (donde variant tiene 4 dígitos) { '^(%a%a%a?)%-(%d%d%d)%-(%d%d%d%d)$' , 'r' , 'v' }, -- 8 - ll-DDD-variante (donde región tiene 3 dígitos; variante tiene 4 dígitos) { '^(%a%a%a?)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$' , 'r' , 'v' },-- 9 - ll-RR-variant (donde variante tiene entre 5 y 8 caracteres alnum) { '^(%a%a%a?)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$' , 'r' , 'v' }, -- 10 - ll-DDD-variant (donde región tiene 3 dígitos; variante tiene de 5 a 8 caracteres numéricos) { '^(%a%a%a?)%-(%d%d%d%d)$' , 'v' }, -- 11 - ll-variant (donde variante tiene 4 dígitos) { '^(%a%a%a?)%-(%w%w%w%w%w%w?%w?%w?)$' , 'v' }, -- 12 - ll-variant (donde variante tiene de 5 a 8 caracteres numéricos) { '^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)$' , 's' , 'r' }, -- 13 - ll-Ssss-RR { '^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)$' , 's' , 'r' }, -- 14 - ll-Ssss-DDD (la región tiene 3 dígitos) { '^(%a%a%a?)%-(%a%a%a%a)$' , 's' }, -- 15 - ll-Ssss { '^(%a%a%a?)%-(%a%a)$' , 'r' }, -- 16 - ll-RR { '^(%a%a%a?)%-(%d%d%d)$' , 'r' }, -- 17 - ll-DDD (la región tiene 3 dígitos) { '^(%a%a%a?)$' }, -- 18 - ll { '^(%a%a%a?)%-x%-(%w%w?%w?%w?%w?%w?%w?)$' , 'p' }, -- 19 - ll-x-pppppppp (private es de 1 a 8 caracteres alnum) } local t = {}; -- tabla de capturas; sirve como traductor entre las partes de etiqueta ietf capturadas y las variables nombradas para i , v en ipairs ( patrón ) hacer -- recorrer la tabla de patrones buscando una coincidencia local c1 , c2 , c3 , c4 ; -- las capturas en el 'patrón' de la tabla de patrones van aquí c1 , c2 , c3 , c4 = source : match ( patrón [ i ][ 1 ]); -- una o más capturas establecidas si source coincide con pattern[i]) if c1 then -- c1 siempre establecido en match code = c1 ; -- la primera captura siempre es el código t = { [ patrón [ i ][ 2 ] o 'x' ] = c2 ,-- rellenar la tabla de capturas con el resto de capturas [ patrón [ i ][ 3 ] o 'x' ] = c3 , -- toma los nombres de índice de la tabla de patrones y asigna capturas secuenciales [ patrón [ i ][ 4 ] o 'x' ] = c4 , -- el nombre del índice puede ser nulo en la tabla patrón[i] por lo que "o 'x'" falsifica un nombre para este índice en esta tabla }; script = t . s o '' ; -- traduce el contenido de la tabla a variables con nombre; región = t . r o '' ; -- las entradas de tabla ausentes son nulas, por lo que establece las partes ietf con nombre en una cadena vacía para la concatenación variante = t . v o '' ; privado = t . p o '' ; descanso ; -- y listo fin fin si no es código entonces devuelve nil , nil , nil , nil , nil , tabla.concat ({ 'etiqueta de idioma no reconocido: ' , fuente }); -- no sabemos lo que tenemos, pero está mal formado fin código = código : lower (); -- asegúrese de que usamos y devolvemos la versión en minúsculas de esto si no ( override_table [ code ] o lang_table [ code ] o synonym_table [ code ] o lang_dep_table [ code ]) entonces devuelva nil , nil , nil , nil , nil , table.concat ({ 'código de idioma no reconocido: ' , code }); -- código de idioma no válido, no sé sobre los otros (¿no me importa?) fin si synonym_table [ code ] entonces -- si el código 639-2/639-2T tiene un sinónimo 639-1 table.insert ( maint_cats , table.concat ({ 'Código de idioma y lang-xx promocionado a ISO 639-1|' , code })); tabla.insert ( maint_msgs , tabla.concat ({ 'código:' , código , 'promovido a código:' , tabla_de_sinónimos [ código ]})); código = tabla_de_sinónimos [ código ]; -- usar el sinónimo end if is_set ( script ) then if is_set ( args_script ) then return código , nil , nil , nil , nil , 'etiqueta de script redundante' ; -- ambos códigos con script y |script= no están permitidos end else script = args_script o '' ; -- usar args.script si se proporciona end if is_set ( script ) then script = script : lower (); -- asegurarse de que usamos y devolvemos la versión en minúsculas de esto if not script_table [ script ] then return código , nil , nil , nil , nil, nil , tabla.concat ({ 'script no reconocido:' , script , 'para código:' , código }); -- código de idioma correcto, script no válido, no sé sobre los otros (¿no me importa?) end end if suppressed_table [ script ] then -- asegurarse de que code-script no use un script suprimido if in_array ( code , suppressed_table [ script ]) then return code , nil , nil , nil , nil , table.concat ({ 'script: ' , script , ' no compatible con code: ' , code }); -- código de idioma correcto, el script está suprimido para este código end end if is_set ( region ) then if is_set ( args_region ) entonces devuelve código , nil , nil , nil , nil, nil , 'etiqueta de región redundante' ; -- ambos códigos con región y |region= no están permitidos fin de lo contrario región = args_region o '' ; -- usa args.region si se proporciona fin si is_set ( región ) entonces región = región : lower (); -- asegúrate de que usamos y devolvemos la versión en minúsculas de esto si no región_table [ región ] entonces devuelve código , script , nil , nil , nil , nil , tabla.concat ({ 'región no reconocida: ' , región , ' para código: ' , código }); fin fin si is_set ( variante ) entonces si is_set ( args_variant ) entonces devuelve código , nil , nil , nil , nil , nil , 'etiqueta de variante redundante' ; -- ambos códigos con variante y |variant= no están permitidos fin de lo contrario variante = args_variant o '' ; -- use args.variant si se proporciona end if is_set ( variant ) then variant = variant : lower (); -- asegúrese de que usamos y devolvemos la versión en minúsculas de esto if not variant_table [ variant ] then -- asegúrese de que variant sea válido return code , script , region , nil , nil , table.concat ({ 'variante no reconocida: ' , variante }); end -- ¿Esto duplica/reemplaza las pruebas en lang() y lang_xx()? if is_set ( script ) then -- si se establece el script, debe ser parte del 'prefijo' si no está en_array ( table.concat ({ código , '-' , script }), variant_table [ variante ][ 'prefijos' ]) entonces devuelve código , script , región , nulo , nulo , table.concat ({ 'variante no reconocida: ' , variante , ' para el par código-script: ' , código , '-' , script }); end elseif is_set ( region ) then -- si se establece región, hay algunos prefijos que requieren código de idioma y región (en-CA-newfound) if not in_array ( code , variant_table [ variant ][ 'prefixes' ]) then -- primero vea si el código de idioma es todo lo que se requiere (en-oxendict aunque se prefiere en-GB-oxendict) if not in_array ( table.concat ({ code , '-' , region }), variant_table [ variant ][ 'prefixes' ]) then -- ahora intente con el código de idioma y la región (en-CA-newfound) return code , script , region , nil , nil , table.concat ({ 'variante no reconocida: ' , variante , ' para el par código-región: ' , código , '-' , región }); end end else -- forma barata de determinar si hay prefijos; fonipa y otros no tienen prefijos; # El operador siempre devuelve 0 si variant_table [ variant ][ 'prefixes' ][ 1 ] y no in_array ( code , variant_table [ variant ][ 'prefixes' ]) entonces devuelve code , script , region , nil , nil , table.concat ({ 'variante no reconocida: ' , variante , ' para código: ' , código }); fin fin fin si is_set ( private ) entonces privado = privado : lower (); -- asegúrese de que usamos y devolvemos la versión en minúsculas de esto si no override_table [ table.concat ({ code , '-x-' , private })] entonces -- asegúrese de que la etiqueta privada sea válida; note que el índice devuelve código , script , región , nulo , nulo , tabla.concat ({ 'etiqueta privada no reconocida: ' , privada }); fin fin devuelve código , script , región , variante , privado , nulo ; -- devuelve las partes buenas; asegúrese de que msg sea nulo fin --[[--------------------------< SUBSTITUTE >---------------------------------------------------------- sustituye $1, $2, etc en <message> con datos de <data_t>. Devuelve una cadena sustituida en texto sin formato cuando <data_t> no es nulo; devuelve <mensaje> de lo contrario ]] función local replace ( mensaje , data_t ) devuelve data_t y mw . message . newRawMessage ( mensaje , data_t ): plain () o message ; fin --[[--------------------------< MAKE _ ERROR _ MSG >-------------------------------------------------- ensambla un mensaje de error a partir del nombre de la plantilla, el texto del mensaje, el enlace de ayuda y la categoría del error. ]] función local make_error_msg ( msg , args_t , template ) categoría local ; si 'Transliteración' == template entonces categoría = 'Transliteración' ; de lo contrario categoría = 'Idioma y lang-xx' fin local category_link = (( 0 == namespace o 10 == namespace ) y no args_t . nocat ) y table.concat ({ '[[Categoría:' , categoría , ' errores de plantilla]]' }) o '' ; devolver sustituto ( '[$1] <span style="color:#d33">Error: {{$2}}: $3 ([[:Categoría:$4 errores de plantilla|ayuda]])</span>$5' , { args_t . text o 'undefined' , plantilla , msg , categoría , category_link }) fin --[=[--------------------------< MAKE _ WIKILINK >---------------------------------------------------- Crea un wikilink; cuando se proporciona tanto el enlace como el texto para mostrar, devuelve un wikilink en el formato [[L|D]]; si solo se proporciona el enlace, devuelve un wikilink en el formato [[L]]; si no se proporciona ninguno o se omite el enlace, devuelve una cadena vacía. ]=] función local make_wikilink ( enlace , mostrar ) si is_set ( enlace ) entonces si is_set ( mostrar ) entonces devuelve tabla.concat ({ '[[' , enlace , '|' , mostrar , ']]' }); de lo contrario devuelve tabla.concat ({ '[[' , enlace , ']]' }); fin de lo contrario devuelve '' ; fin fin --[[--------------------------< DIV _ MARKUP _ ADD >-------------------------------------------------- agrega etiquetas <i> y </i> al texto del elemento de lista o al texto <p>..</p> implícito. mixto no admitido ]] función local div_markup_add ( texto , estilo ) local implied_p = {}; si texto : buscar ( '^ \n [%*:;#]' ) entonces -- busca el marcado de lista; el marcado de lista debe comenzar al inicio del texto si 'italic' == estilo entonces devuelve el texto : gsub ( '( \n [%*:;#]+)([^ \n ]+)' , '%1<i>%2</i>' ); -- inserta marcado en cursiva en cada elemento de la lista else return text ; end end if text : find ( ' \n +' ) then -- busca cualquier número de \n caracteres en el texto text = text : gsub ( '([^ \n ]) \n ([^ \n ])' , '%1 %2' ); -- reemplaza caracteres de nueva línea con un carácter de espacio que imita a mediawiki if 'italic' == style then text = text : gsub ( '[^ \n ]+' , '<p><i>%1</i></p>' ); -- inserta p y etiquetas de marcado en cursiva en cada p implementada (dos o más secuencias '\n\n' consecutivas) else text = text : gsub ( '[^ \n ]+' , '<p>%1</p>' ); -- inserta marcado p en cada p implementada text = text : gsub ( ' \n ' , '' ); -- quita caracteres de nueva línea end end return text ; end --[[--------------------------< TITLE _ WRAPPER _ MAKE >------------------------------------------ crea un <span title="<title text>"><content_text></span> o <div title="<title text>"><content_text></div> donde <title text> está en la información sobre herramientas en el idioma local de la wiki y <content_text> es texto en un idioma que no es local en el marcado html. Esto se debe a que el atributo lang= se aplica al contenido de la etiqueta que lo contiene. <tag> contiene una cadena 'div' o 'span' que se utiliza para elegir la etiqueta de envoltura correcta ]] función local title_wrapper_make ( title_text , content_text , tag ) local wrapper_t = {}; tabla.insert ( wrapper_t , tabla.concat ({ '<' , etiqueta })); -- abrir la etiqueta contenedora de apertura table.insert ( wrapper_t , ' title= \" ' ); -- comienza el atributo de título table.insert ( wrapper_t , title_text ); -- agrega <title_text> table.insert ( wrapper_t , ' \" >' ); -- finaliza el atributo de título y cierra la etiqueta contenedora de apertura table.insert ( wrapper_t , content_text ); -- agrega <content_text> table.insert ( wrapper_t , table.concat ({ '</' , tag , '>' })); -- agrega la etiqueta contenedora de cierre return table.concat ( wrapper_t ); -- crea una cadena grande y listo -- [[--------------------------< MAKE _ TEXT _ HTML >-------------------------------------------------- Agrega el marcado html al texto según el tipo de contenido que sea: etiquetas <span> o <i> para contenido en línea o etiquetas <div> para contenido en bloque El atributo lang= también aplica al contenido de la etiqueta donde se coloca por lo que esto es incorrecto porque ' Texto en idioma español' es inglés: <i lang="es" title="Texto en idioma español">casa</i> debería ser: <span title="Texto en idioma español"><i lang="es">casa</i></span> o para <div>...</div>: <div title="Texto en idioma español"><div lang="es"><spanish-language-text></div></div> ]] local function make_text_html ( code , text , tag , rtl , style , size , language ) local html_t = {}; local style_added = '' ; local wrapper_tag = tag ; -- <tag> se modifica, por lo que guarda una copia para usarla cuando/si creamos un contenedor span o div if text : match ( '^%*' ) then table.insert ( html_t , '*' ); -- mueve el prefijo de texto del lenguaje proto fuera del marcado en cursiva si lo hay; usa una entidad numérica porque el splat simple confunde a MediaWiki text = text :gsub ( '^%*' , '' ); -- elimina el símbolo del final del texto si 'span' == etiqueta entonces -- etiqueta html predeterminada para contenido en línea si 'italic' == estilo entonces -- pero si la etiqueta italic = 'i' ; -- cambia a etiquetas <i> fin de lo contrario -- debe ser div así que va text = div_markup_add ( text , style ); -- maneja <p> implícito, <p> implícito con <i>, y marcado de lista (*;:#) con <i> fin table.insert ( html_t , table.concat ({ '<' , tag })); -- abre la etiqueta html <i>, <span>, o <div> code = code : gsub ( '%-x%-.*' , '' ); -- quita la subetiqueta de uso privado de la etiqueta code porque no tiene sentido fuera de wikipedia table.insert ( html_t , table.concat ({ ' lang="' , code , ' \" ' })); -- añadir atributo de idioma si ( rtl o unicode . is_rtl ( text )) y ( 'ltr' == this_wiki_lang_dir ) entonces -- el texto se escribe de derecha a izquierda en una wiki de izquierda a derecha table.insert ( html_t , ' dir="rtl"' ); -- añadir atributo de dirección para idiomas de derecha a izquierda elseif no ( rtl o unicode . is_rtl ( text )) y ( 'rtl' == this_wiki_lang_dir ) entonces -- el texto se escribe de izquierda a derecha en una wiki de derecha a izquierda table.insert ( html_t , ' dir="ltr"' ); -- añadir atributo de dirección para idiomas de izquierda a derecha end si 'normal' == style entonces -- cuando |italic=no table.insert ( html_t , ' style= \" font-style: normal;' ); -- anular el marcado externo,si hay algún estilo_agregado = ' \" ' ; -- recuerda que el atributo de estilo se agregó y aún no está cerrado if is_set ( size ) then -- when |size=<something> if is_set ( style_added ) then table.insert ( html_t , table.concat ({ ' font-size: ' , size , ';' })); -- agregar cuando el atributo de estilo ya está insertado else table.insert ( html_t , table.concat ({ ' style= \" font-size: ' , size , ';' })); -- crear atributo de estilo style_added = ' \" ' ; -- recordar que el atributo de estilo se agregó y aún no está cerrado end end table.insert ( html_t , table.concat ({ style_added , '>' })); -- cerrar la etiqueta html de apertura table.insert ( html_t , text ); -- insertar el texto table.insert ( html_t , table.concat ({ '</' , tag , '>' })); -- cierra la etiqueta html 'text' <i>, <span> o <div> si is_set ( language ) entonces -- crea una cadena <title_text> para el atributo title= en un contenedor span o div local title_text ; si 'zxx' == code entonces -- caso especial para esta etiqueta 'sin contenido lingüístico' title_text = table.concat ({ language , ' text' }); -- no es un idioma, por lo que no use 'language' en el texto del título elseif mw . ustring . find ( language , 'languages' , 1 , true ) entonces title_text = table.concat ({ language , ' collective text' }); -- para idiomas colectivos else title_text = table.concat ({ language ,'-texto en idioma' }); -- para idiomas individuales end return title_wrapper_make ( title_text , table.concat ( html_t ), wrapper_tag ); else return table.concat ( html_t ); end end --[=[--------------------------< MAKE _ CATEGORY >---------------------------------------------------- Para idioma individual, <idioma>, devuelve: [[Categoría:Artículos que contienen texto en idioma <idioma>]] para inglés: [[Categoría:Artículos que contienen texto en idioma inglés citado explícitamente]] para idiomas colectivos ISO 639-2 (y para bh 639-1): [[Categoría:Artículos con texto en idiomas <idioma>]] ]=] función local make_category ( código , nombre_idioma , nocat , nombre_get ) gato local = {}; retval local ; si (( 0 ~= espacio_nombre ) o nocat ) y no nombre_get entonces -- solo categoriza en el espacio del artículo devuelve '' ; -- devuelve una cadena vacía para la concatenación fin si mw . ustring . find ( language_name , 'languages' , 1 , true ) entonces devuelve table.concat ({ '[[Categoría:Artículos con texto en ' , language_name , ']]' }); fin table.insert ( cat , '[[Categoría:Artículos que contienen ' ); si esta_etiqueta_idioma_wiki == código entonces table.insert ( cat , 'citado explícitamente ' .. language_name ); -- nombre de categoría único para el idioma local de lo contrario table.insert ( cat , language_name ); fin table.insert ( cat , '-language text]]' ); devuelve table.concat ( cat ); fin --[[--------------------------< MAKE _ TRANSLIT >---------------------------------------------------- devuelve translit <i lang=xx-Latn>...</i> donde xx es el código del idioma; de lo contrario, devuelve una cadena vacía El valor |script= no se usa en {{transliteration}} para este propósito; en su lugar, usa |code. Debido a que los scripts de los idiomas se enumeran en los modificadores {{transliteration}}, se incluyen en las tablas de datos. El parámetro script se introduce en {{Idioma con nombre y transliteración}}. Si se establece |script=, esta función lo usa en preferencia a code. Para evitar confusiones, en este módulo y las plantillas que lo usan, el parámetro script de transliteración se renombra a |translit-script= (en esta función, tscript) Esta función la usan tanto lang_xx() como transl() lang_xx() siempre proporciona code, language_name y translit; puede proporcionar tscript; nunca proporciona estilo transl() siempre proporciona language_name, translit y uno de code o tscript, nunca ambos; siempre proporciona estilo Para {{transliteración}}, el estilo solo se aplica cuando se proporciona un código de idioma ]] función local make_translit ( código , nombre_idioma , translit , std , tscript , estilo , engvar ) título local ; out_t local = {}; título_t local = lang_data . translit_title_table ; -- tabla de estándares de transliteración y los códigos de idioma y escrituras que se aplican a esos estándares título_texto local = '' ; -- texto de información sobre herramientas para título= atributo std = std y std : lower (); -- minúsculas para indexación de tablas si no es is_set ( std ) y no es is_set ( tscript ) entonces -- cuando no se especifica ni el estándar ni la escritura título_texto = nombre_idioma ; -- escribe una información sobre herramientas genérica si no es mw . ustring . find ( language_name , 'languages' , 1 , true ) entonces -- nombres de idiomas colectivos (el plural 'languages' es parte del nombre) title_text = title_text .. '-language' ; -- omitir este texto (solo idiomas individuales y de macro) end title_text = replace ( '$1 $2' , { title_text , lang_data . engvar_t [ engvar ][ 'romanisz_lc' ]}); -- finalizar la información sobre herramientas; usar romanización cuando no se suministra ni el script ni el estándar elseif is_set ( std ) and is_set ( tscript ) then -- cuando se especifican ambos if title_t [ std ] then -- y si el estándar es legítimo if title_t [ std ][ tscript ] then -- y si el script para ese estándar es legítimo if script_table [ tscript ] then title_text = title_text .. table.concat ({ title_t [ std ][ tscript : lower ()], ' (' , script_table [ tscript ], ' script) transliteración' }); -- agrega el texto apropiado a la información sobre herramientas else title_text = title_text .. title_t [ std ][ 'default' ]; -- usa el valor predeterminado si el script no está en la tabla std; TODO: ¿mantenimiento de catálogo? ¿mensaje de error porque no se encontró el script para este estándar? end else title_text = title_text .. title_t [ std ][ 'default' ]; -- usa el valor predeterminado si el script no está en la tabla std; TODO: ¿mantenimiento de catálogo? ¿mensaje de error porque no se encontró el script para este estándar? end else return '' ; -- estándar inválido, configuración para mensaje de error end elseif is_set ( std ) then -- translit-script no configurado, usa código de idioma if not title_t [ std ] then return '' ; end -- estándar inválido, configuración para mensaje de error if title_t [ std ][ code ] then -- si el código de idioma está en la tabla (transl puede no proporcionar un código de idioma) title_text = title_text .. table.concat ({ title_t [ std ][ code : lower ()], ' (' , language_name , ' language) transliteration' }); -- agrega el texto apropiado a la información sobre herramientas de lo contrario -- el código no coincide title_text = title_text .. title_t [ std ][ 'default' ]; -- entonces usa el valor predeterminado del estándar end de lo contrario -- aquí si translit-script está establecido pero translit-std no está establecido si title_t [ 'no_std' ][ tscript ] entonces title_text = title_text .. title_t [ 'no_std' ][ tscript ]; -- usa translit-script si está establecido de lo contrario si title_t [ 'no_std' ][ código ] entonces title_text = title_text .. title_t [ 'no_std' ][ código ]; -- usa el código de idioma else if is_set ( tscript ) then title_text = title_text .. table.concat ({ language_name , '-script transliteration' }); -- escribe una información sobre herramientas de script elseif is_set ( code ) then if not mw . ustring . find ( language_name , 'languages' , 1 , true ) then -- nombres de idioma colectivos (el plural 'languages' es parte del nombre) title_text = title_text .. '-language' ; -- omite este texto (solo idiomas individuales y macro) end title_text = title_text .. ' transliteration' ; -- termina la información sobre herramientas else title_text = title_text ..' transliteración ' ; -- información sobre herramientas genérica (¿llegaremos alguna vez hasta aquí?) fin fin end local close_tag ; if is_set ( code ) then -- cuando se proporciona un código de idioma (siempre con plantillas {{lang-??}}, no siempre con {{transliteration}}) code = code : match ( '^(%a%a%a?)' ); -- elimina todas las subetiquetas dejando solo la subetiqueta de idioma if not style then -- nil para el estilo cursiva predeterminado table.insert ( out_t , "<i lang= \" " ); -- así que usa la etiqueta <i> close_tag = '</i>' ; -- etiqueta a usar al cerrar else table.insert ( out_t , table.concat ({ '<span style= \" font-style: ' , style , ' \" lang= \" ' })); -- estilo no estándar, construye una etiqueta span para él close_tag = '</span>' ; -- etiqueta a usar al cerrar end table.insert ( out_t , code ); table.insert ( out_t , "-Latn \" >" ); -- las transliteraciones siempre están en escritura latina else table.insert ( out_t , "<span>" ); -- cuando no hay código de idioma: sin atributo lang=, no cursiva ({{transliteración}} solamente) close_tag = '</span>' ; end table.insert ( out_t , translit ); -- agrega el texto translit table.insert ( out_t , close_tag ); -- y agrega el </i> o </span> apropiado if '' == title_text then -- cuando no hay necesidad de una información sobre herramientas return table.concat ( out_t ); -- crea una cadena y listo else title_text = 'gb_t' == engvar and title_text : gsub ( '([Rr]omani)z' ,'%1s' ) o title_text ; -- gb eng cuando engvar especifica gb eng; us eng de lo contrario retorna title_wrapper_make ( title_text , table.concat ( out_t ), 'span' ); -- envuelve con una información sobre herramientas span y listo end end --[[---------------------------< VALIDATE _ TEXT >---------------------------------------------------- Esta función comprueba el contenido de args.text y devuelve una cadena vacía si no hay nada incorrecto, de lo contrario devuelve un mensaje de error. Las pruebas son para texto vacío o faltante y para uso incorrecto o no permitido del marcado de apóstrofo. La representación en cursiva está controlada por el parámetro de plantilla |italic= por lo que el marcado en cursiva nunca debe aparecer en args.text ni como ''en sí mismo'' ni como '''''negrita cursiva''''' a menos que |italic=unset o |italic=invert. ]] función local validar_text ( plantilla , args ) si no is_set ( args . text ) entonces devuelve make_error_msg ( 'sin texto' , args , plantilla ); fin si args . texto : find ( "%f[ \' ] \'\'\'\' %f[^ \' ]" ) o args . texto : find ( " \'\'\'\'\' [ \' ]+" ) entonces -- porque estamos buscando, busca 4 apóstrofos o 6+ apóstrofos return make_error_msg ( 'el texto tiene un marcado mal formado' , args , template ); fin local style = args . italic ; si ( 'unset' ~= style ) y ( 'invert' ~= style ) entonces si args . texto : find ( "%f[ \' ] \'\' %f[^ \' ]" ) o args . texto :buscar ( "%f[ \' ] \'\'\'\'\' %f[^ \' ]" ) entonces -- cursiva pero no negrita, o negrita cursiva devolver make_error_msg ( 'el texto tiene marcado en cursiva' , args , plantilla ); fin fin fin --[[--------------------------< RENDER _ MAINT >------------------------------------------------------ renderizar mensajes y categorías de mantenimiento ]] función local render_maint ( nocat ) maint local = {}; si 0 < # maint_msgs entonces -- cuando hay mensajes de mantenimiento table.insert ( maint , table.concat ({ '<span class="lang-comment" style="font-style: normal; display: none; color: #33aa33; margin-left: 0.3em;">' })); -- abrir etiqueta <span> para _ , msg en ipairs ( maint_msgs ) hacer table.insert ( maint , table.concat ({ msg , ' ' })); -- agregar cadenas de mensajes fin table.insert ( maint , '</span>' ); -- cerrar el lapso end if ( 0 < # maint_cats ) and ( 0 == namespace ) and not nocat then -- cuando hay categorías de mantenimiento; solo espacio de nombres de artículo para _ , cat en ipairs ( maint_cats ) do table.insert ( maint , table.concat ({ '[[Category:' , cat , ']]' })); -- formatear y agregar las categorías end end return table.concat ( maint ); end --[[--------------------------< PROTO _ PREFIX >------------------------------------------------------ para los idiomas proto, el texto tiene como prefijo un splat. Lo hacemos aquí como una bandera para make_text_html() para que un splat se represente fuera del marcado en cursiva (si se usa). Si el primer carácter en el texto aquí ya es un splat, no hacemos nada proto_param es booleano o nulo; verdadero agrega el prefijo splat independientemente del nombre del idioma; falso elimina y/o inhibe independientemente del nombre del idioma; nil no hace nada; presupone que el valor en el texto es correcto pero elimina el prefijo splat adicional ]] función local proto_prefix ( texto , nombre_idioma , parámetro_proto ) si falso == proto_param entonces -- cuando es forzado por |proto=no devolver texto : gsub ( '^%**' , '' ); -- devolver texto sin prefijo splat independientemente del nombre del idioma o del prefijo splat existente en el texto si no ( nombre_idioma : buscar ( '^Proto%-' ) o ( verdadero == proto_param )) entonces -- el idioma es un proto o está forzado por |proto=sí devolver texto : gsub ( '^%**' , '*' ); -- prefijo del texto del proto-idioma con un splat; también elimina los splat de prefijo duplicados fin devolver texto : gsub ( '^%*+' , '*' ); -- devuelve el texto intacto excepto los múltiples splats reducidos a un splat fin --[[--------------------------< HAS _ POEM _ TAG >------------------------------------------------------ busca un marcador de tira de poema en el texto; devuelve verdadero cuando lo encuentra; falso de lo contrario, la detección automática de cursiva está deshabilitada cuando el texto tiene un marcador de tira de poema porque no es posible que este código conozca el contenido que reemplazará al marcador de tira. ]] función local has_poem_tag ( text ) devuelve text : find ( ' \127 [^ \127 ]*UNIQ%-%-poem%-[%a%d]+%-QINU[^ \127 ]* \127 ' ) y verdadero o falso ; fin --[[--------------------------< HTML _ TAG _ SELECT >------------------------------------------------ Inspecciona el contenido y recorta selectivamente el texto. Devuelve texto y el nombre de una etiqueta html apropiada para el texto. Si el texto contiene: \n\n el texto tiene etiquetas <p>..</p> implícitas: elimine los espacios iniciales y finales y devuelva Si el texto comienza con marcado de lista: \n* desordenado \n; definición \n: definición \n# ordenado recortar todos los espacios iniciales excepto \n y recortar todos los espacios finales Si el texto contiene el marcador de franja <poem>...</poem>, devolver el texto sin modificar y elegir las etiquetas <div>..</div> porque el marcador de franja se reemplaza con texto envuelto en etiquetas <div>..</div>. Si el texto contiene alguna etiqueta <div>...</div> real, entonces se devuelve nuevamente sin modificar y se usan etiquetas <div>...</div> para envolverlo, para evitar la inversión div/span. ]] función local html_tag_select ( text ) etiqueta local ; si tienes_poem_tag ( text ) entonces -- contiene el marcador de franja del poema (no podemos saber el contenido de ese) etiqueta = 'div' ; -- el reemplazo del poema está en las etiquetas div, por lo que lang debe usar etiquetas div elseif texto : buscar ( '<div' ) entonces -- reductivo; si el texto contiene una etiqueta div, debemos usar etiquetas div etiqueta = 'div' ; elseif mw . texto . trim ( text ): find ( ' \n\n +' ) entonces -- contiene etiquetas p implícitas text = mw . text . trim ( text ); -- recorta los espacios en blanco iniciales y finales tag = 'div' ; -- debe ser div porque span puede no contener etiquetas p (agregado más tarde por MediaWiki); el reemplazo del poema está en las etiquetas div elseif text : find ( ' \n [%*:;%#]' ) entonces -- si text tiene marcado de lista text = text : gsub ( '^[ \t\r\f ]*' , '' ): gsub ( '%s*$' , '' ); -- recorta todos los espacios en blanco excepto el carácter de nueva línea inicial '\n' tag = 'div' ; -- debe ser div porque span puede no contener etiquetas ul, dd, dl, ol (agregado más tarde por MediaWiki) else text = mw . text .trim ( texto ); -- texto sin formato etiqueta = 'span' ; -- entonces span está bien end return text , etiqueta ; fin --[[--------------------------< VALIDATE _ PROTO >-------------------------------------------------- valida el valor asignado a |proto=; los valores permitidos son sí y no; sí devuelve como verdadero, no devuelve como falso, cadena vacía (o parámetro omitido) devuelve como nulo; cualquier otro valor devuelve como nulo con un segundo valor de retorno de verdadero que indica que se ha asignado otro valor a |proto= ]] función local validar_proto ( proto_param ) si 'sí' == proto_param entonces devuelve verdadero ; de lo contrario , si 'no' == proto_param entonces devuelve falso ; de lo contrario, si is_set ( proto_param ) entonces devuelve nulo , verdadero ; -- |proto= algo distinto de 'sí' o 'no' de lo contrario devuelve nulo ; -- faltante o fin vacío fin --[[--------------------------< IDIOMA _ NOMBRE _ GET >-------------------------------------------- función común para devolver el nombre del idioma del conjunto de datos según IETF etiqueta devuelve el nombre del idioma si se encuentra en las tablas de datos; nulo de lo contrario ]] función local language_name_get ( ietf , code , cat ) ietf = ietf : lower (); -- ietf:lower() porque format_ietf_tag() devuelve el nombre local con mayúsculas y minúsculas ; -- permanece nulo si no se encuentra if override_table [ ietf ] then -- busca la etiqueta IETF completa en la tabla de anulación name = override_table [ ietf ]; elseif override_table [ code ] then -- no está ahí, así que intenta con la etiqueta de idioma básica name = override_table [ code ]; elseif lang_table [ code ] then -- cambia a la tabla de etiquetas/nombres activa de iana name = lang_table [ code ]; elseif lang_dep_table [ código ] entonces -- prueba la etiqueta/nombre obsoleto de iana nombre de tabla = lang_dep_table [ código ]; fin si lang_dep_table [ código ] y cat entonces -- porque el código obsoleto puede haber sido reemplazado por el nombre preferido de en.wiki table.insert ( maint_cats , table.concat ({ 'Lang y lang-xx usan códigos ISO 639 obsoletos|' , código })); table.insert ( maint_msgs , table.concat ({ 'código: ' , código , ' está obsoleto' })); fin devolver nombre ; -- nombre de las tablas de datos o fin nulo --[[---------------------------< _ LANG >-------------------------------------------------------------------- punto de entrada para {{lang}} no debería haber ninguna razón para establecer parámetros en {{lang}} {{#invoke:}} <includeonly>{{#invoke:lang|lang}}</includeonly> los parámetros se reciben desde el marco de la plantilla (marco padre) ]] función local _lang ( args ) local out = {}; local language_name ; -- se usa para hacer que los nombres de categorías sean locales category_name ; -- igual que language_name excepto que conserva cualquier desambiguador entre paréntesis (si hay alguno) del conjunto de datos local subtags = {}; -- subetiquetas IETF script, región, variante y código local privado ; -- el código de idioma local msg ; -- para mensajes de error local tag = 'span' ; -- valor inicial para make_text_html() local template = args . template o 'Lang' ; maint_cats = {}; -- inicializar porque cuando este módulo requiere otro módulo, estos solo se declaran una vez, por lo que solo se inicializan una vez maint_msgs = {}; validar_cat_args ( args ); -- determinar si se debe suprimir la categorización si args [ 1 ] y args . código , entonces devuelve make_error_msg ( 'conflicting: {{{1}}} and |code=' , args , template ); else args . code = args [ 1 ] o args . code ; -- prefer args. code end if args [ 2 ] and args . text then return make_error_msg ( 'conflicting: {{{2}}} and |text=' , args , template ); else args . text = args [ 2 ] o args . text ; -- prefer args. text end msg = validation_text ( template , args ); -- se asegura de que |text= esté establecido if is_set ( msg ) then -- msg es un mensaje de error ya formateado return msg ; end args . text , tag = html_tag_select ( args . text ); -- inspecciona text; devuelve la etiqueta html apropiada con el texto recortado en consecuencia args . rtl = args . rtl == 'yes' ; -- convertir a booleano: 'sí' -> verdadero, otros valores -> falso args . proto , msg = validation_proto ( args . proto ); -- devolver booleano, o nulo, o nulo y un indicador de mensaje de error si msg entonces devolver make_error_msg ( table. concat ({ 'invalid |proto=: ' , args . proto }), args , plantilla ); fin código , subetiquetas . script , subetiquetas . región , subetiquetas . variante , subetiquetas . privado , msg = get_ietf_parts ( args . código ); -- |script=, |region=, |variant= no son compatibles porque deberían ser parte de args.code ({{{1}}} en {{lang}}) si msg entonces devuelve make_error_msg ( msg , args , template ); fin args . italic , msg = validation_italic ( args ); si msg entonces devuelve make_error_msg ( msg , args , template ); fin si nil == args . italic entonces -- nil cuando |italic= está ausente o no está configurado o |italic=predeterminado; args.italic controla si ( 'latn' == subtags . script ) o -- el script es latn ( this_wiki_lang_tag ~= code y no is_set ( subtags . script ) y no has_poem_tag ( args . text ) y unicode . is_Latin ( args . text )) entonces -- el texto no es el idioma de esta wiki, no se especificó ningún script y no está en el marcado del poema, pero es completamente script latino (cursiva automática) args . italic = 'italic' ; -- POR DEFECTO para las plantillas {{lang}} es vertical; pero si el script latino está configurado para font-style:italic de lo contrario args . italic = 'inherit' ; -- italic no está configurado; el script no es latn; heredar el estilo actual fin fin si is_set ( subtags . script ) entonces -- si script está configurado, anular la configuración rtl si in_array ( subtags . script , lang_data . rtl_scripts ) entonces args . rtl = true ; -- script es un script rtl de lo contrario args . rtl = false ; -- script no es un script rtl fin fin args . code = format_ietf_tag ( code , subetiquetas . script , subetiquetas . región , subetiquetas . variante , subetiquetas . privado ); -- formato a los estilos de subetiqueta recomendados language_name = language_name_get ( args . code , code , true ); -- obtener el nombre del idioma; probar primero la etiqueta ietf, luego el código sin variante luego el código con variante si 'invert' == args . italic y 'span' == etiqueta entonces -- invertir solo se admite para contenido en línea args . text = invert_italics ( args . text ) fin args . text = proto_prefix ( args . text , language_name , args . proto ); -- prefijo del texto del proto-lenguaje con un splat 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 ) ) ; -- mensajes de mantenimiento y categorías return table.concat ( out ); -- juntarlo todo y listo end -- [[--------------------------< LANG >---------------------------------------------------------------------- punto de entrada para {{lang}} no debería haber ninguna razón para establecer parámetros en {{lang}} {{#invoke:}} <includeonly> {{#invoke:lang|lang}}</includeonly> los parámetros se reciben desde el marco de la plantilla (marco padre) ]] función local lang ( frame ) local args = getArgs ( frame , { -- este código para que podamos detectar y manejar el marcado de la lista wiki en el texto valueFunc = function ( key , value ) if 2 == key or 'text' == key then -- el parámetro 'text'; no recortar los espacios en blanco return value ; -- devuelve 'text' sin recortar elseif value then -- todos los demás valores: si el valor no es nulo value = mw.text.trim ( value ); -- recortar los espacios en blanco if ' ' ~= value then -- cadena vacía cuando el valor era solo un espacio en blanco return value ; end end return nil ; -- el valor estaba vacío o contenía solo espacios en blanco end -- fin de valueFunc }); return _lang ( args ); end --[[--------------------------< TRANSLATION _ MAKE >---------------------------------------------- función independiente para crear una traducción literal del texto principal También se usa en {{lang-x2}} ]] función local translation_make ( args_t ) traducción_t local = { ', ' }; -- inicializa la salida si 'none' ~= args_t . label entonces -- si queremos una etiqueta table.insert ( traducción_t , '<small>' ); -- abre la etiqueta html <small> si 'no' == args_t . link entonces table.insert ( traducción_t , '<abbr title="traducción literal">lit.</abbr>' ); -- formulario sin vínculo else table.insert ( traducción_t , make_wikilink ( 'Traducción literal' , 'lit.' )); -- formulario vinculado end table.insert ( traducción_t ," </small>" ); -- cierra la etiqueta html <small> table.insert ( traduction_t , table.concat ({ ''' , args_t.traduction , ''' })); -- usa entidades html para evitar confusiones con el marcado wiki return table.concat ( traduction_t ); -- crea una cadena grande y listo end -- [[--------------------------< _ LANG _ XX >---------------------------------------------------------- Para las plantillas {{lang-??}}, el único parámetro que se requiere configurar en la plantilla es el código de idioma. Todos los demás parámetros pueden, generalmente deberían, escribirse en la llamada de plantilla. Para las plantillas {{lang-??}} para idiomas que pueden tener múltiples sistemas de escritura, puede ser apropiado configurar |script= también. Para cada plantilla {{lang-??}} elija la función de punto de entrada apropiada para que esta función conozca el estilo predeterminado que se debe aplicar al texto. Para el estilo normal y vertical: <includeonly>{{#invoke:lang|lang_xx_inherit|code=xx}}</includeonly> Para el estilo cursiva: <includeonly>{{#invoke:lang|lang_xx_italic|code=xx}}</includeonly> Todos los demás parámetros se deben recibir desde el marco de la plantilla (marco principal). Los parámetros admitidos son: |code = (obligatorio) el código de idioma de la IANA |script = código de script de la IANA; especialmente para usar con idiomas que usan múltiples sistemas de escritura |region = código de región de la IANA |variant = código de variante de la IANA |text = (obligatorio) el texto mostrado en el idioma especificado por el código |link = booleano falso ('no') no vincula el nombre del idioma especificado por el código al artículo del idioma asociado |rtl = booleano verdadero ('sí') identifica el idioma especificado por el código como un idioma de derecha a izquierda |nocat = booleano verdadero ('sí') inhibe la categorización normal; las categorías de error no se ven afectadas |cat = booleano falso ('no') forma opuesta de |nocat= |italic = booleano verdadero ('sí') muestra el texto mostrado en letra cursiva; booleano falso ('no') muestra el texto mostrado en letra normal; no establecido muestra de acuerdo con initial_style_state |lit = texto que es una traducción literal de texto |label = 'none' para suprimir todo etiquetado (nombre del idioma, 'translit.', 'lit.') cualquier otro texto reemplaza la etiqueta del nombre del idioma - wikilinking automático deshabilitado para aquellas plantillas {{lang-??}} que admiten transliteración (aquellas plantillas donde |text= no es completamente escritura latina):|translit = texto que es una transliteración del texto |translit-std = el estándar que se aplica a la transliteración |translit-script = nombre de script ISO 15924; recurre al código Para {{lang-??}}, los parámetros posicionales son: {{{1}}} texto {{{2}}} texto transliterado {{{3}}} texto de traducción literal no se permiten otros parámetros posicionales ]] función local _lang_xx ( args , base_template ) -- base_template será 'Langx' o 'Lang-xx' local out = {}; nombre_idioma local ; -- se usa para hacer que el texto de visualización y los enlaces a artículos sean locales category_name ; -- igual que language_name excepto que conserva cualquier desambiguador entre paréntesis (si hay alguno) del conjunto de datos subetiquetas locales = {}; -- subetiquetas IETF script, región y variante código local ; -- el código de idioma translit_script_name local ; -- nombre asociado con el código de script de IANA (ISO 15924) translit local ; translit_title local ; msg local ; -- para mensajes de error etiqueta local = 'span' ; -- valor inicial para make_text_html() plantilla local = args . template o base_template ; maint_cats = {}; -- inicializar porque cuando este módulo se requiere en otro módulo, estos solo se declaran una vez, por lo que solo se inicializan una vez maint_msgs = {}; text_idx local = ( 'Langx' == base_template ) y 2 o 1 ; -- para {{langx}} el parámetro posicional 'text' es '2' translit_idx local = ( 'Langx' == base_template ) y 3 o 2 ; xlate_idx local = ( 'Langx' == base_template ) y 4 o 3 ; si args [ text_idx ] y args . text entonces devuelve make_error_msg ( 'conflicting: {{{' .. text_idx .. '}}} y |text=' , args , template ); de lo contrario args . text = args [ text_idx ] o args . text ; -- prefiere el parámetro posicional 'texto' fin msg = validation_text ( template , args ); -- se asegura de que |text= esté establecido, no contenga marcado en cursiva y esté protegido contra negrita inapropiada si is_set ( msg ) entonces devuelve msg ; fin args . text , tag = html_tag_select ( args . text ); -- inspecciona el texto; devuelve la etiqueta html apropiada con el texto recortado en consecuencia si args [ translit_idx ] y args . translit entonces devuelve make_error_msg ( 'conflicting: {{{' .. translit_idx .. '}}} y |translit=' , args , template ); de lo contrario args . translit = args [ translit_idx ] o args . translit -- prefiere el parámetro posicional 'translit' fin args . engvar = lang_data . engvar_sel_t [ args . engvar ] o 'us_t' ; -- ya sea 'gb_t' o 'us_t' cuando |engvar= es válido; 'us_t' de lo contrario si args [ xlate_idx ] y ( args . translation o args . lit ) entonces devuelve make_error_msg ( 'conflicto: {{{' .. xlate_idx .. '}}} y |lit= o |translation=' , args , template ); de lo contrariosi args . translation y args . lit entonces devuelve make_error_msg ( 'conflicto: |lit= y |translation=' , args , template ); de lo contrario args . traducción = args [ xlate_idx ] o args . traducción o args . lit ; -- prefiere el parámetro posicional 'traducción' fin si args . links y args . link entonces devuelve make_error_msg ( 'conflicto: |links= y |link=' , args , plantilla ); de lo contrario args . link = args . link o args . links ; -- prefiere args. link fin de validar_cat_args ( args ); -- determina si se debe suprimir la categorización args . rtl = args . rtl == 'yes' ; -- convierte a booleano: 'yes' -> verdadero, otros valores -> falso código , subetiquetas . script , subetiquetas . región , subetiquetas . variante , subetiquetas . private , msg = get_ietf_parts ( args . code , args . script , args . region , args . variant ); -- private omitido porque private if msg then -- si se detecta un error, entonces hay un mensaje de error return make_error_msg ( msg , args , template ); fin args . italic , msg = validation_italic ( args ); if msg then return make_error_msg ( msg , args , template ); fin -- TODO: esto parece funcionar, por lo que en el futuro podríamos prescindir de heritage_t en Module:Lang/langx -- conservar el sistema existente hasta que {{langx}} haya reemplazado a {{lang-??}} -- if nil == args.italic then -- nil cuando |italic= ausente o no configurado o |italic=predeterminado; args.italic controla -- si ('latn' == subtags.script) o -- el script es latn -- (this_wiki_lang_tag ~= código y no is_set (subtags.script) y unicode.is_Latin (args.text)) entonces -- el texto no es el idioma de este wiki, no se especificó ningún script y es completamente script latn (cursiva automática) -- args.italic = 'italic'; -- establecer font-style:italic -- de lo contrario -- args.italic = 'inherit'; -- italic no establecido; script no latn; heredar el estilo actual -- fin -- fin -- TODO: mantener este sistema hasta que {{langx}} haya reemplazado a {{lang-??}} si nil == args . italic entonces -- args.italic controla si is_set ( subtags . script ) entonces si 'latn' == subtags . script entonces args . italic = 'italic' ; -- |script=Latn; establecido para font-style:italic de lo contrario args . italic = initial_style_state ; -- italic no establecido; el script no es latn; establecido para font-style:<initial_style_state> fin de lo contrario args . italic = initial_style_state ; -- aquí cuando |italic= y |script= no establecidos; establecido para font-style:<initial_style_state> fin fin si is_set ( subtags . script ) entonces -- si script establecido anula la configuración rtl si in_array ( subtags . script , lang_data . rtl_scripts ) entonces args . rtl = true ; -- script es un script rtl de lo contrario args . rtl = false ; -- script no es un script rtl fin fin args . proto , msg = validation_proto ( args . proto ); -- devuelve un valor booleano, o nulo, o nulo y un indicador de mensaje de error si es msg entonces devuelve make_error_msg ( table.concat ({ 'invalid |proto=: ' , args . proto }), args , template ); fin de args . code = format_ietf_tag ( code , subtags.script , subtags.region , subtags.variant , subtags.private ); -- formatear según los estilos de subetiqueta recomendados language_name = language_name_get ( args.code , code , true ); -- obtener el nombre del idioma; probar primero la etiqueta ietf , luego el código sin variante y luego el código con variante category_name = language_name ; -- los nombres de categorías conservan los diambiguadores entre paréntesis de IANA (si los hay) language_name = language_name : gsub ( '%s+%b()' , ' ' ); -- eliminar los desambiguadores o calificadores entre paréntesis de IANA de los nombres que los tienen if args.label then if 'none' ~ = args.label then table.insert ( out , table.concat ({ args.label , ' : ' })); -- etiqueta personalizada end else if 'no' == args . enlace entonces tabla.insert ( out , language_name ); -- nombre del idioma sin wikilink else if mw.ustring.find ( language_name , 'languages' , 1 , true ) then tabla.insert ( out , make_wikilink ( language_name ) ) ; -- el nombre del idioma colectivo usa wikilink simple elseif lang_data.article_name [ args.code : lower ( ) ] then -- ¿ se anula la etiqueta ietf en el nombre del artículo? tabla.insert ( out , make_wikilink ( lang_data.article_name [ args.code : lower ( )] , language_name ) ) ; -- nombre del idioma con wikilink de datos de reemplazo elseif lang_data.article_name [ código ] then -- es la etiqueta de idioma en la tabla de reemplazo del artículo.insert ( out , make_wikilink ( lang_data.article_name [ código ], language_name )); -- nombre del idioma con wikilink de datos de reemplazo else table.insert ( out , make_wikilink ( language_name .. ' language' , language_name ) ); -- nombre del idioma con wikilink end end table.insert ( out , ' : ' ) ; -- separador end if ' invert ' == args.italic then args.text = invert_italics ( args.text ) end args.text = proto_prefix ( args.text , language_name , args.proto ) ; -- prefijo del texto del proto-idioma con un splat table.insert (out, make_text_html(args.code, args.text, tag , args.rtl , args.italic , args.size , ( ' none ' == args.label ) y language_name o nil ) ) si is_set( args.translit ) y no unicode.is_Latin ( args.text ) entonces -- transliteración ( no compatible con { { lang } } ) ; no compatible cuando args.text es texto completamente latn ( esta es una prueba imperfecta) table.insert ( out , ',' ); -- coma para separar el texto de translit si ' none' ~ = args.label entonces tabla.insert ( salida , '<small>' ); si script_table [ args [ 'translit-script' ]] entonces -- cuando se establece |translit-script=, intenta usar el nombre del script translit_script_name = script_table [ args [ 'translit-script' ]]; de lo contrario translit_script_name = language_name ; -- vuelve al nombre del idioma fin translit_title = mw.title.makeTitle ( 0 , tabla.concat ( { 'Romanización de' , translit_script_name })); -- crea un objeto de título; sin engvar, los títulos de los artículos usan la ortografía de EE. UU . si translit_title . existe y ( 'no' ~= args . link ) entonces tabla. insert ( out , make_wikilink ( 'Romanización de ' .. translit_script_name o language_name , substitute ( '$1' , { lang_data . engvar_t [ args . engvar ][ 'romanisz_pt' ]})) .. ':' ); -- crea un wikilink si hay un artículo al que enlazar; engvar el texto para mostrar de lo contrario tabla. insert ( out , substitute ( '$1:' , { lang_data . engvar_t [ args . engvar ][ 'romanisz_pt' ]})); -- de lo contrario texto sin formato por engvar fin tabla. insert ( out , ' </small>' ); -- cierra la etiqueta pequeña fin translit = make_translit ( args . code , language_name , args . translit , args [ 'translit-std' ], args [ 'translit-script' ], nil , args .engvar ) si está establecido ( translit ) entonces tabla.insert ( out , translit ); de lo contrario devolver make_error_msg ( tabla.concat ({ 'invalid translit-std: \' ' , args [ 'translit-std' ] o '[missing]' }), args , plantilla ); fin fin si is_set ( args . traducción ) entonces -- traducción (no compatible con {{lang}}) tabla.insert ( out , traducción_make ( args )); fin tabla.insert ( out , make_category ( code , category_name , args . nocat )); tabla.insert ( out , render_maint ( args . nocat )); -- mensajes de mantenimiento y categorías devolver tabla.concat ( out ); -- junta todo y listo fin --[[--------------------------< LANG _ XX _ ARGS _ GET >---------------------------------------------- función común para obtener la tabla de argumentos de las plantillas {{lang-??}} devuelve la tabla de argumentos los parámetros posicionales de texto no se recortan aquí pero se recortan selectivamente en html_tag_select() ]] función local lang_xx_args_get ( frame , base_template ) local args_t = getArgs ( frame , { parentFirst = true , -- los parámetros en la plantilla anulan los parámetros establecidos en {{#invoke:}} valueFunc = function ( key , value ) if (( 'Langx' == base_template ) and 2 or 1 ) == key then -- el parámetro posicional 'text'; 1 para {{lang-??}}, 2 para {{langx}}; no recortar el espacio en blanco valor de retorno ; -- devuelve el parámetro posicional 'text' sin recortar elseif valor then -- todos los demás valores: si el valor no es nulo value = mw . text . trim ( value ); -- recortar espacios en blanco si '' ~= value then -- cadena vacía cuando value era solo un espacio en blanco return value ; end end return nil ; -- el valor estaba vacío o contenía solo espacios en blanco end -- fin de valueFunc }); return args_t ; end --[[--------------------------< LANG _ XX _ ITALIC >-------------------------------------------------- Punto de entrada para aquellas plantillas {{lang-??}} que llaman a lang_xx_italic(). Establece el estado de estilo inicial en cursiva. ]] función local lang_xx_italic ( frame ) args local = lang_xx_args_get ( frame , 'lang-xx' ); initial_style_state = 'italic' ; return _lang_xx ( args , 'Lang-xx' ) .. '[[Categoría:Páginas que usan plantillas Lang-xx]]' ; -- categoría temporal fin --[[--------------------------< _ LANG _ XX _ ITALIC >------------------------------------------------ Punto de entrada desde otro módulo. Establece el estado de estilo inicial en cursiva. ]] función local _lang_xx_italic ( args ) initial_style_state = 'italic' ; return _lang_xx ( args , 'Lang-xx' ); fin --[[--------------------------< LANG _ XX _ INHERIT >------------------------------------------------ Punto de entrada para aquellas plantillas {{lang-??}} que llaman a lang_xx_inherit(). Establece el estado de estilo inicial en heredar. ]] función local lang_xx_inherit ( frame ) local args = lang_xx_args_get ( frame , 'lang-xx' ); initial_style_state = 'inherit' ; return _lang_xx ( args , 'Lang-xx' ) .. '[[Categoría:Páginas que usan plantillas Lang-xx]]' ; -- temporary categoryend--[[--------------------------< _ 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.]]local function _lang_xx_inherit (args)initial_style_state = 'inherit';return _lang_xx (args, 'Lang-xx');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 inherit_t = langx_data.inherit_t;-- get list of language tags extracted from {{lang-??}} template names for languages that are rendered in upright fontlocal rtl_t = langx_data.rtl_t;-- get list of language tags for languages that are rendered right-to-leftlocal script_t = langx_data.script_t;-- get list of language tags for {{lang-??}} templates that set |script=<something>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>args_t.code = args_t[1] or args_t.code;-- get the language tag; must be {{{1}}} or |code=if not args_t.code thenreturn make_error_msg ('missing language tag', args_t, 'Langx');endargs_t.rtl = args_t.rtl or (rtl_t[args_t.code] and 'yes');-- prefer |rtl= in template call, use rtl_t elseargs_t.script = args_t.script or script_t[args_t.code];-- prefer |script= in template call, use script_t elseargs_t.link = args_t.link or link_t[args_t.code];-- prefer |link= in template call, use link_t felseargs_t.size = args_t.size or size_t[args_t.code];-- prefer |size= in template call, use size_t elseargs_t[1] = nil;-- unset to mimic {{lang-??}} templates which set |code=xxlocal lang_subtag = args_t.code;-- use only the base language subtag for unsupported tag test; some args_t.code are modified by |script= etcinitial_style_state = inherit_t[args_t.code:lower()] and 'inherit' or 'italic';-- if listed in inherit_t, set as 'inherit'; 'italic' elsereturn _lang_xx (args_t, 'Langx') .. ((langx_data.unsupported_t[lang_subtag:lower()] and '[[Category:Langx uses unsupported language tag|'.. lang_subtag .. ']]') or '');-- temporary category for unsupported language tags-- return _lang_xx (args_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 paramtersbut {{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 properpositional parameters.{{lang-??}} depends on the calling template to select 'inherit' or 'italic' as the default renderer.{{langx}} can't do that so, intead, relies on the list of tags scraped from the {{lang-??}} templates that calllang_xx_inherit(). ]]local function langx (frame)local args_t = lang_xx_args_get (frame, 'Langx');-- get the arguments; 'Langx' is the <base_template> used to decide which positional param is 'text', 'translit', 'lit'return _langx (args_t);end--[[--------------------------< _ I S _ I E T F _ T A G >------------------------------------------------------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-??}} templates are supported by this function.Module entry point from another module]]local function _is_ietf_tag (tag)-- entry point when this module is require()d into anotherlocal c, s, r, v, p, err;-- code, script, region, variant, private, error messagec, s, r, v, p, err = get_ietf_parts (tag);-- disassemble tag into constituent part and validatereturn ((c and not err) and true) or nil;-- return true when code portion has a value without error message; nil elseend--[[--------------------------< I S _ I E T F _ T A G >--------------------------------------------------------Module entry point from an {{#invoke:}}]]local function is_ietf_tag (frame)return _is_ietf_tag (getArgs (frame)[1]);-- args[1] is the ietf language tag to be tested; also get parent frameend--[[--------------------------< I S _ I E T F _ T A G _ F R A M E >--------------------------------------------Module entry point from an {{#invoke:}}; same as is_ietf_tag() except does not get parameters from the parent(template) frame. This function not useful when called by {{lang|fn=is_ietf_tag_frame|<tag>}} because <tag>is in the parent frame.]]local function is_ietf_tag_frame (frame)return _is_ietf_tag (getArgs (frame, {frameOnly = true,})[1]);-- args[1] is the ietf language tag to be tested; do not get parent frameend--[[--------------------------< _ N A M E _ F R O M _ T A G >--------------------------------------------------Returns language name associated with IETF language tag if valid; error message else.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]]local function _name_from_tag (args)local subtags = {};-- IETF subtags script, region, variant, and privatelocal raw_code = args[1];-- save a copy of the input IETF subtaglocal link = 'yes' == args['link'];-- make a booleanlocal label = args.label;local code;-- the language codelocal msg;-- gets an error message if IETF language tag is malformed or invalidlocal language_name = '';code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code);if msg thenlocal 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>'});endraw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private);-- format to recommended subtag styles; private omitted because privatelanguage_name = language_name_get (raw_code, code);-- get language name; try ietf tag first, then code w/o variant then code w/ variantlanguage_name = language_name:gsub ('%s+%b()', '');-- remove IANA parenthetical disambiguators or qualifiers from names that have themif link then-- when |link=yes, wikilink the language nameif mw.ustring.find (language_name, 'languages', 1, true) thenlanguage_name = make_wikilink (language_name, label);-- collective language name uses simple wikilinkelseif 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 dataelseif 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 dataelselanguage_name = make_wikilink (language_name .. ' language', label or language_name);-- language name with wikilinkendendreturn language_name;end--[[--------------------------< N A M E _ F R O M _ T A G >----------------------------------------------------Module entry point from an {{#invoke:}}]]local function name_from_tag (frame)-- entry point from an {{#invoke:Lang|name_from_tag|<ietf tag>|link=<yes>|template=<template name>}}return _name_from_tag (getArgs(frame))-- pass-on the args table, nothing else; getArgs() so we also get parent frameend--[[--------------------------< _ T A G _ F R O M _ N A M E >--------------------------------------------------Returns the ietf language tag associated with the language name. Spelling of language name must be correctaccording to the spelling in the source tables. When a standard language name has a parenthetical disambiguator,that disambiguator must be omitted (they are not present in the data name-to-tag tables).Module entry point from another module]]local function _tag_from_name (args)-- entry point from another modulelocal msg;if args[1] and '' ~= args[1] thenlocal data = mw.loadData ('Module:Lang/tag from name');-- get the reversed data tables TODO: change when going livelocal lang = args[1]:lower();-- allow any-case for the language name (speeling must till be correct)local tag = data.rev_override_table[lang] or data.rev_lang_table[lang] or data.rev_lang_dep_table[lang];-- get the code; look first in the override then in the standardif tag thenreturn tag, true;-- language name found so return tag and done; second return used by is_lang_name()elsemsg = 'language: ' .. args[1] .. ' not found'-- language name not found, error messageendelsemsg = 'missing language name'-- language name not provided, error messageendlocal template = '';if args.template and '' ~= args.template thentemplate = table.concat ({'{{', args['template'], '}}: '});-- make template name (if provided by the template)endreturn table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'});end--[[--------------------------< T A G _ F R O M _ N A M E >----------------------------------------------------Module entry point from an {{#invoke:}}]]local function tag_from_name (frame)-- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}}local result, _ = _tag_from_name (getArgs(frame))-- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by is_lang_name()return result;end--[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------Module entry point from an {{#invoke:}}]]local function is_lang_name (frame)local _, result = _tag_from_name (getArgs(frame))-- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by tag_from_name()return result and true or nil;end--[[--------------------------< _ T R A N S L >----------------------------------------------------------------Module entry point from another module]]local function _transl (args)local title_table = lang_data.translit_title_table;-- table of transliteration standards and the language codes and scripts that apply to those standardslocal language_name;-- language name that matches language code; used for tool tiplocal translit;-- transliterated text to displaylocal script;-- IANA scriptlocal msg;-- for when called functions return an error messagemaint_cats = {};-- initialize because when this module required into another module, these only declared once so only initialzed oncemaint_msgs = {};if is_set (args[3]) then-- [3] set when {{transliteration|code|standard|text}}args.text = args[3];-- get the transliterated textargs.translit_std = args[2] and args[2]:lower();-- get the standard; lower case for table indexingif not title_table[args.translit_std] thenreturn make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transliteration');endelseif is_set (args[2]) then-- [2] set when {{transliteration|code|text}}args.text = args[2];-- get the transliterated textelseif 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?args[1]:match ('^%a%a%a?%-x%-')) then-- or is args[1] a private-use tagreturn make_error_msg ('no text', args, 'Transliteration');-- args[1] is a code so we're missing textelseargs.text = args[1];-- args[1] is not a code so we're missing that; assign args.text for error messagereturn make_error_msg ('missing language / script code', args, 'Transliteration');endendendif is_set (args[1]) then-- IANA language code used for html lang= attribute; or ISO 15924 script codeif 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) or private-use; lower case because table indexes are lower caseelsereturn make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transliteration');-- invalid language / script codeendelsereturn make_error_msg ('missing language / script code', args, 'Transliteration');-- missing language / script code so quitendargs.italic, msg = validate_italic (args);if msg thenreturn make_error_msg (msg, args, 'Transliteration');endif 'italic' == args.italic then-- 'italic' when |italic=yes; because that is same as absent or not set and |italic=defaultargs.italic = nil;-- set to nil; endargs.engvar = lang_data.engvar_sel_t[args.engvar] or 'us_t';-- either 'gb_t' or 'us_t' when |engvar= valid; 'us_t' elseif 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 subtagelseif lang_table[args.code] then-- is code a language code defined in the standard language code tables?language_name = lang_table[args.code];elseif lang_dep_table[args.code] then-- is code a language code defined in the deprecated language code tables?language_name = lang_dep_table[args.code];elseif script_table[args.code] then-- if here, code is not a language code; is it a script code?language_name = script_table[args.code];script = args.code;-- code was an ISO 15924 script so use that insteadargs.code = '';-- unset because not a language codeelsereturn make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transliteration');-- invalid language / script codeend-- here only when all parameters passed to make_translit() are validreturn make_translit (args.code, language_name, args.text, args.translit_std, script, args.italic, args.engvar);end--[[--------------------------< T R A N S L >------------------------------------------------------------------Module entry point from an {{#invoke:}}]]local function transl (frame)return _transl (getArgs(frame));end--[[--------------------------< 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 elseAll code combinations supported by {{lang}} and the {{lang-??}} templates are supported by this function.Module entry point from another module]]local function _category_from_tag (args_t)local subtags = {};-- IETF subtags script, region, variant, and privatelocal raw_code = args_t[1];-- save a copy of the input IETF subtaglocal link = 'yes' == args_t.link;-- make a booleanlocal label = args_t.label;local code;-- the language codelocal msg;-- gets an error message if IETF language tag is malformed or invalidlocal category_name = '';code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code);if msg thenlocal 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>'});endraw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private);-- format to recommended subtag styles; private omitted because privatecategory_name = language_name_get (raw_code, code);-- get language name; try ietf tag first, then code w/o variant then code w/ variantcategory_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', '');if link thenreturn table.concat ({'[[:', category_name, ']]'});elsereturn category_name;endend--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------Module entry point from an {{#invoke:}}]]local function category_from_tag (frame)-- entry point from an {{#invoke:Lang|category_from_tag|<ietf tag>|template=<template name>}}return _category_from_tag (getArgs (frame));-- pass-on the args table, nothing else; getArgs() so we also get parent frameend--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------]]return {category_from_tag = category_from_tag , lang = lang , -- punto de entrada para {{lang}} langx = langx , -- punto de entrada para {{langx}} lang_xx_inherit = lang_xx_inherit , -- puntos de entrada para {{lang-??}} lang_xx_italic = lang_xx_italic , is_ietf_tag = is_ietf_tag , is_ietf_tag_frame = is_ietf_tag_frame , is_lang_name = is_lang_name , tag_from_name = tag_from_name , -- devuelve la etiqueta ietf asociada con el nombre del idioma name_from_tag = name_from_tag , -- se usa para la documentación de la plantilla; posible uso en el nombre ISO 639 de las plantillas de código transl = transl , -- punto de entrada para {{transliteración}} _category_from_tag = _category_from_tag , -- puntos de entrada cuando este módulo se requiere() en otros módulos _lang = _lang , _langx = _langx , _lang_xx_inherit = _lang_xx_inherit , _lang_xx_italic = _lang_xx_italic , _is_ietf_tag = _is_ietf_tag , get_ietf_parts = get_ietf_parts , _tag_from_name = _tag_from_name , _name_from_tag = _name_from_tag , _transl = _transl , _translation_make = translation_make , };