모듈: 다국어

현지의 다국어 = { 스위트   = "다국어",                        시리얼  = "2020-12-10",                        아이템    = 47541920,                        글로벌 = { ISO15924 = 71584769,                                    링크    = 19363224 }                      } --[=[ 다국어 텍스트 및 ISO 639(BCP47) 문제 등에 대한 유틸리티 * fair() * 폴백() * findCode() * fix() * format() * getBase() * getLang() * getName() * i18n() * int() * isLang() * isLangWiki() * is Minusculable() * isRTL() * 메시지() * sitelink() * 탭 데이터() * userLang() * userLangCode() * wikibase() *페일세이프() loadData: 다국어/구성 다국어/이름 ]=] 현지의 페일 세이프   = 다국어 현지의 글로벌 모드  = 다국어 현지의 글로벌 데이터 = 다국어 현지의 사용자       = { 스니퍼 = "show preview" } 다국어.글로벌.다국어 = 다국어.아이템    다국어.이국적인 = { 간단하죠. = 진실의,                         아니요.     = 진실의 } 다국어.선호하다 = { cs = 진실의,                         데 = 진실의,                         en = 진실의,                         es = 진실의,                         프루 = 진실의,                         그것 = 진실의,                         nl = 진실의,                         pt = 진실의,                         루 = 진실의,                         sv = 진실의 }    현지의 외부 모듈 = 기능. ( 접근, 고급., 추가하다, 알트, 경계. )     -- 글로벌 모듈 가져오기     -- 전제 조건:     -- access -- 기본 모듈 이름을 가진 문자열     -- advanced -- true, require()의 경우.그렇지 않으면 mw.loadData()     -- append -- 하위 페이지 부분이 있는 경우 문자열 또는 false     -- alt -- 루트 Wikidata 항목의 번호 또는 false     -- alert -- true, 데이터 문제에 오류를 발생시킵니다.     -- 사후 조건:     -- 무엇이든 반환한다.아마 테이블일 것이다.     -- 2020-01-01     현지의 보관소 = 접근     현지의 보다 세세하게 = 기능. ()                       한다면 추가하다 그리고나서                           보관소 = string.format( %s/%s,                                                    보관소,                                                    추가하다 )                       끝.                   끝.     현지의 재밌어요, 행운의, r, 적합.     한다면 고급. 그리고나서         재밌어요 = 요구하다     또 다른         재밌어요 = 음.로드 데이터     끝.     글로벌 모드.글로벌 모듈 = 글로벌 모드.글로벌 모듈 또는 { }     적합. = 글로벌 모드.글로벌 모듈[ 접근 ]     한다면 것은 아니다. 적합. 그리고나서         보다 세세하게()         행운의, r = pcall( 재밌어요,  "모듈:" .. 보관소 )     끝.     한다면 것은 아니다. 행운의 그리고나서         한다면 것은 아니다. 적합.  그리고.            유형( 알트 ) == "숫자"  그리고.            알트 > 0 그리고나서             적합. = string.format( "Q%d", 알트 )             적합. = 음.키보드.get Sitelink를 취득하다( 적합. )             글로벌 모드.글로벌 모듈[ 접근 ] = 적합. 또는 진실의         끝.         한다면 유형( 적합. ) == "문자열' 그리고나서             보관소 = 적합.             보다 세세하게()             행운의, r = pcall( 재밌어요, 보관소 )         끝.         한다면 것은 아니다. 행운의 그리고. 경계. 그리고나서             에러( "누락되었거나 잘못된 페이지:" .. 보관소 )         끝.     끝.     돌아가다 r 끝. -- foreign Module()    현지의 fetch 데이터 = 기능. ( 접근 )     -- commons에서 번역된 키워드를 가져옵니다.데이터: ***.탭     -- 전제 조건:     -- access -- Commons에서 페이지 ID를 포함하는 문자열     -- 데이터 또는 문자열이 포함된 테이블을 오류 메시지와 함께 반환합니다.     -- 2019-12-05     현지의 보관소 = 접근     현지의 r     한다면 유형( 보관소 ) == "문자열' 그리고나서         현지의 s         보관소 = 음.본문.다듬다( 보관소 )         s = 보관소:더 낮게()         한다면 s:후보선수( 1, 2 ) == "c:" 그리고나서             보관소 = 음.본문.다듬다( 보관소:후보선수( 3 ) )             s       = 보관소:더 낮게()         그렇지 않으면 s:후보선수( 1, 8 ) == "실행:" 그리고나서             보관소 = 음.본문.다듬다( 보관소:후보선수( 9 ) )             s       = 보관소:더 낮게()         끝.         한다면 s:후보선수( 1, 5 ) == "데이터:" 그리고나서             보관소 = 음.본문.다듬다( 보관소:후보선수( 6 ) )             s       = 보관소:더 낮게()         끝.         한다면 s == ""  또는  s == ".탭" 그리고나서             보관소 = 거짓의         그렇지 않으면 s:후보선수( -4 ) == ".탭" 그리고나서             보관소 = 보관소:후보선수( 1, -5 ) .. ".탭"         또 다른             보관소 = 보관소 .. ".탭"         끝.     끝.     한다면 유형( 보관소 ) == "문자열' 그리고나서         현지의 데이터.         한다면 유형( 글로벌 데이터.탭 데이터 ) ~= "테이블" 그리고나서             글로벌 데이터.탭 데이터 = { }         끝.         데이터. = 글로벌 데이터.탭 데이터[ 보관소 ]         한다면 데이터. 그리고나서             r = 데이터.         또 다른             현지의 행운의             행운의, 데이터. = pcall( 음.익스텐트.데이터..얻다, 보관소, "_" )             한다면 유형( 데이터. ) == "테이블" 그리고나서                 데이터. = 데이터..데이터.                 한다면 유형( 데이터. ) == "테이블" 그리고나서                     글로벌 데이터.탭 데이터[ 보관소 ] = 데이터.                 또 다른                     r = string.format( %s [[%s%s],                                        "INVALID Data:*" 탭",                                        "기능:데이터:",                                        보관소 )                 끝.             또 다른                 r = "BAD PAGE 데이터:*. 탭 &#8211; 공통:" .. 보관소             끝.             한다면 r 그리고나서                 글로벌 데이터.탭 데이터[ 보관소 ] = r                 데이터. = 거짓의             또 다른                 r = 데이터.             끝.         끝.     또 다른         r = "BAD PAGE 공통:데이터: *. 탭"     끝.     돌아가다 r 끝. -- fetchData()    현지의 즐겨찾기 = 기능. ()     -- 폴백 코드 제공     -- 사후 조건:     -- 기본 언어 시퀀스가 포함된 테이블을 반환합니다.     -- * 선행 요소     -- * 사용자(아직 액세스 불가)     -- * 페이지 내용 언어(아직 액세스 불가)     -- * 페이지명 서브페이지     -- * 프로젝트     -- * en     현지의 r = 다국어.다중 언어     한다면 것은 아니다. r 그리고나서         현지의 자신 = 음.언어.get Content Language(get Content Language)():get 코드():더 낮게()         현지의 후보선수  = 음.직함.get Current Title(전류 제목)().서브페이지 텍스트         현지의 f    = 기능. ( 더하다 )                          현지의 s = 더하다                          위해서 i = 1, #r 하다                              한다면 r[ i ] == s 그리고나서                                  s = 거짓의                                  브레이크. -- i의 경우                              끝.                          끝. -- i의 경우                          한다면 s 그리고나서                              table.insert( r, s )                          끝.                      끝.         r = { }         한다면 후보선수:발견하다( "/", 2, 진실의 ) 그리고나서             후보선수 = 후보선수:경기( "/(%l%l%l)?$" )             한다면 후보선수 그리고나서                 table.insert( r, 후보선수 )             끝.         그렇지 않으면 후보선수:발견하다( "^%l%l%l?%-?%a?%a?%a?%a?%a?%a?$" )  그리고.                음.언어.is Supported Language(지원 언어)( 후보선수 ) 그리고나서             table.insert( r, 후보선수 )         끝.         f( 자신 )         f( "en" )         다국어.다중 언어 = r     끝.     돌아가다 r 끝. -- 즐겨찾기()    현지의 실현 가능한 = 기능. ( 물어보다, 받아들이다 )     --어플리케이션에서 지원을 요청받았습니까?     -- 전제 조건:     -- ask -- 소문자 코드     -- accept -- 시퀀스테이블(제공된 소문자 코드 포함)     -- 사후 조건:     -- nero 또는 true     현지의 r     위해서 i = 1, #받아들이다 하다         한다면 받아들이다[ i ] == 물어보다 그리고나서             r = 진실의             브레이크. -- i의 경우         끝.     끝. -- i의 경우     돌아가다 r 끝. -- 피지블()    현지의 가지고 오다 = 기능. ( 접근, 추가하다 )     -- 구성 또는 라이브러리 모듈을 연결합니다.     -- 전제 조건:     -- access -- 모듈 제목     -- append -- 이 서브페이지 부분이 포함된 문자열 또는 false     -- 사후 조건:     -- 반환: 테이블, 라이브러리 포함 또는 false     현지의 얻었다, 서명하다     한다면 추가하다 그리고나서         서명하다 = string.format( %s/%s, 접근, 추가하다 )     또 다른         서명하다 = 접근     끝.     한다면 유형( 다국어.익스텐트 ) ~= "테이블" 그리고나서         다국어.익스텐트 = { }     끝.     얻었다 = 다국어.익스텐트[ 서명하다 ]     한다면 것은 아니다. 얻었다  그리고.  얻었다 ~= 거짓의 그리고나서         현지의 세계적인 = 다국어.글로벌[ 접근 ]         현지의 lib    = ( 것은 아니다. 추가하다  또는  추가하다 == "config(config) )         얻었다 = 외부 모듈( 접근, lib, 추가하다, 세계적인 )         한다면 유형( 얻었다 ) == "테이블" 그리고나서             한다면 lib 그리고나서                 현지의 기동 = 얻었다[ 접근 ]                 한다면 유형( 기동 ) == "기능' 그리고나서                     얻었다 = 기동()                 끝.             끝.         또 다른             얻었다 = 거짓의         끝.         다국어.익스텐트[ 서명하다 ] = 얻었다     끝.     돌아가다 얻었다 끝. --fetch()    현지의 페치ISO639 = 기능. ( 접근 )     -- 공통에서 테이블 검색:데이터: ISO639/**** 탭     -- 전제 조건:     -- access -- 서브페이지 ID가 있는 문자열     -- 사후 조건:     -- 빈 테이블이 반환됩니다.     현지의 r     한다면 유형( 다국어.ISO639 ) ~= "테이블" 그리고나서         다국어.ISO639 = { }     끝.     r = 다국어.ISO639[ 접근 ]     한다면 유형( r ) == "실패" 그리고나서         현지의 날것의 = fetch 데이터( "ISO639/" .. 접근 )         한다면 유형( 날것의 ) == "테이블" 그리고나서             현지의 t             r = { }             위해서 i = 1, #날것의 하다                 t = 날것의[ i ]                 한다면 유형( t ) == "테이블"  그리고.                    유형( t[ 1 ] ) == "문자열'  그리고.                    유형( t[ 2 ] ) == "문자열' 그리고나서                     r[ t[ 1 ] ] =  t[ 2 ]                 또 다른                     브레이크. -- i의 경우                 끝.             끝. -- i의 경우         또 다른             r = 거짓의         끝.         다국어.ISO639[ 접근 ] = r     끝.     돌아가다 r 또는 { } 끝. -- 가져오기ISO639()    현지의 채우다 = 기능. ( 접근, 외계인, 틀 )     -- 언어 이름 템플릿을 펼칩니다.     -- 전제 조건:     -- access -- 언어 코드 포함 문자열     -- alien -- 생성되는 언어 코드     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 문자열을 반환합니다.     현지의 템플릿 = 다국어.tmplLang     현지의 r     한다면 유형( 템플릿 ) ~= "테이블" 그리고나서         현지의 cnf = 가지고 오다( "다국어", "config(config) )         한다면 cnf 그리고나서             템플릿 = cnf.tmplLang         끝.     끝.     한다면 유형( 템플릿 ) == "테이블" 그리고나서         현지의 원천 = 템플릿.직함         현지의 f, 행운의, s         다국어.tmplLang = 템플릿         한다면 유형( 원천 ) ~= "문자열'  그리고.            유형( 템플릿.네임팻 ) == "문자열'  그리고.            템플릿.네임팻:발견하다( %s, 1, 진실의 ) 그리고나서             원천 = string.format( 템플릿.네임팻, 접근 )         끝.         한다면 유형( 원천 ) == "문자열' 그리고나서             한다면 것은 아니다. 다국어.틀 그리고나서                 한다면 틀 그리고나서                     다국어.틀 = 틀                 또 다른                     다국어.틀 = 음.get Current Frame(전류 프레임)()                 끝.             끝.             f = 기능. ( a )                     돌아가다 다국어.틀:확장 템플릿{ 직함 = a }                 끝.             행운의, s = pcall( f, 원천 )             한다면 행운의 그리고나서                 r = s             끝.         끝.     끝.     돌아가다 r 끝. --fill()    현지의 발견하다 = 기능. ( 물어보다, 외계인 )     -- 이름에서 언어 코드를 가져옵니다.     -- 전제 조건:     -- ask -- 언어 이름, 다운캐시     -- alien -- 문의 언어 코드     -- 사후 조건:     -- nero 또는     현지의 코드 = 음.언어.fetch Language Names(페치 언어 이름)( 외계인, "모두" )     현지의 r     위해서 k, v 에 쌍들( 코드 ) 하다         한다면 음.스트링.더 낮게( v ) == 물어보다 그리고나서             r = k             브레이크. -- k, v의 경우         끝.     끝. -- k, v의 경우     한다면 것은 아니다. r 그리고나서         r = 다국어.공정한( 물어보다 )     끝.     돌아가다 r 끝. -- find()    현지의 접다 = 기능. ( 틀 )     -- 템플릿과 #invoke arglist를 병합합니다.     -- 전제 조건:     --frame --템플릿 프레임     -- 사후 조건:     -- 테이블, 결합된 arglist가 있는 경우     현지의 r = { }     현지의 f = 기능. ( 적용합니다. )                   한다면 유형( 적용합니다. ) == "테이블"  그리고.                      유형( 적용합니다..args ) == "테이블" 그리고나서                       위해서 k, v 에 쌍들( 적용합니다..args ) 하다                           v = 음.본문.다듬다( v )                           한다면 v ~= "" 그리고나서                               r[ 스트링( k ) ] = v                           끝.                       끝. -- k, v의 경우                   끝.               끝. -- f()     f( 틀:부모 취득() )     f( 틀 )     돌아가다 r 끝. --폴드()    사용자.편애하다 = 기능. ( 받아들이다, 틀 )     -- 사용자 언어 추측     -- 전제 조건:     -- accept -- ISO 639 등의 코드가 있는 시퀀스테이블     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 최상의 코드를 가진 문자열 또는 0을 반환합니다.     한다면 것은 아니다. ( 사용자.자신 또는 사용자.언어 ) 그리고나서         한다면 것은 아니다. 사용자.시련 그리고나서             사용자.말하다 = 음.메세지.신규( 사용자.스니퍼 )             한다면 사용자.말하다:존재한다() 그리고나서                 사용자.시련 = { }                 한다면 것은 아니다. 다국어.틀 그리고나서                     한다면 틀 그리고나서                         다국어.틀 = 틀                     또 다른                         다국어.틀 = 음.get Current Frame(전류 프레임)()                     끝.                 끝.                 사용자.죄 = 다국어.틀:callParser 기능( "int",                                                            사용자.스니퍼 )             또 다른                 사용자.언어 = 진실의             끝.         끝.         한다면 사용자.죄 그리고나서             현지의 주문  = { }             현지의 포스트.   = { }             현지의 세개  = { }             현지의 펼치다 = { }             현지의 s, 죄             위해서 i = 1, #받아들이다 하다                 s = 받아들이다[ i ]                 한다면 것은 아니다. 사용자.시련[ s ] 그리고나서                     한다면 #s > 2 그리고나서                         한다면 s:발견하다( "-", 3, 진실의 ) 그리고나서                             table.insert( 펼치다, s )                         또 다른                             table.insert( 세개, s )                         끝.                     또 다른                         한다면 다국어.선호하다[ s ] 그리고나서                             table.insert( 주문, s )                         또 다른                             table.insert( 포스트., s )                         끝.                     끝.                 끝.             끝. -- i의 경우             위해서 i = 1, #포스트. 하다                 table.insert( 주문, 포스트.[ i ] )             끝. -- i의 경우             위해서 i = 1, #세개 하다                 table.insert( 주문, 세개[ i ] )             끝. -- i의 경우             위해서 i = 1, #펼치다 하다                 table.insert( 주문, 펼치다[ i ] )             끝. -- i의 경우             위해서 i = 1, #주문 하다                 s = 주문[ i ]                 죄 = 사용자.말하다:언어 사용 안 함( s ):평지()                 한다면 죄 == 사용자.죄 그리고나서                     사용자.자신 = s                     브레이크. -- i의 경우                 또 다른                     사용자.시련[ s ] = 진실의                 끝.             끝. -- i의 경우         끝.     끝.     돌아가다 사용자.자신 끝. -- User.favorize()    다국어.공정한 = 기능. ( 물어보다 )     -- RFC 5646 등에 따라 언어 사양을 포맷합니다.     -- 전제 조건:     -- ask -- .getLang()에 의해 작성된 문자열 또는 테이블     -- 사후 조건:     -- 문자열을 반환하거나 false를 반환합니다.     현지의 s = 유형( 물어보다 )     현지의 q, r     한다면 s == "테이블" 그리고나서         q = 물어보다     그렇지 않으면 s == "문자열' 그리고나서         q = 다국어.lang을 취득( 물어보다 )     끝.     한다면 q  그리고.        q.합법적인  그리고.        음.언어.isKnownLanguageTag( q.기초 ) 그리고나서         r = q.기초         한다면 q.n > 1 그리고나서             현지의 주문 = { "확장",                             스크립트,                             "지역",                             "기타",                             "실패" }             위해서 i = 1, #주문 하다                 s = q[ 주문[ i ] ]                 한다면 s 그리고나서                     r =  string.format( %s-%s, r, s )                 끝.             끝. -- i의 경우         끝.     끝.     돌아가다 r 또는 거짓의 끝. -- 다국어.fair()    다국어.폴백 = 기능. ( 할 수 있는, 다른 )     대체어로 다른 언어가 적합합니까?     -- 전제 조건:     -- enable -- 지원되는 언어 버전 지정자     -- 다른 -- 대체 가능한 언어 지정자,     -- 또는 폴백테이블을 취득하지 않습니다.     -- 사후 조건:     -- 폴백 코드가 있는 부울 또는 테이블을 반환합니다.     현지의 r     한다면 유형( 할 수 있는 ) == "문자열'  그리고.  #할 수 있는 > 0 그리고나서         한다면 유형( 다른 ) == "문자열'  그리고.  #다른 > 0 그리고나서             한다면 할 수 있는 == 다른 그리고나서                 r = 진실의             또 다른                 현지의 s = 다국어.getBase( 할 수 있는 )                 한다면 s == 다른 그리고나서                     r = 진실의                 또 다른                     현지의 다른이들 = 음.언어.폴백위해서( s )                     r = 실현 가능한( 다른, 다른이들 )                 끝.             끝.         또 다른             현지의 s = 다국어.getBase( 할 수 있는 )             한다면 s 그리고나서                 r = 음.언어.폴백위해서( s )                 한다면 r[ 1 ] == "en" 그리고나서                     현지의 d = 페치ISO639( 폴백 )                     한다면 유형( d ) == "테이블"  그리고.                        유형( d[ s ] ) == "문자열' 그리고나서                         r = 음.본문.분열되다( d[ s ], " " )                         table.insert( r, "en" )                     끝.                 끝.             끝.         끝.     끝.     돌아가다 r 또는 거짓의 끝. -- 다국어.fallback()    다국어.find 코드 = 기능. ( 물어보다 )     -- 로컬(현재 프로젝트 또는 영어) 언어 이름의 코드를 검색합니다.     -- 전제 조건:     -- ask -- 언어명을 상정하는 문자열     코드 자체도 식별됩니다.     -- 사후 조건:     -- 문자열을 반환하거나 false를 반환합니다.     현지의 추구한다. = 음.본문.다듬다( 물어보다 )     현지의 r = 거짓의     한다면 #추구한다. > 1 그리고나서         한다면 추구한다.:발견하다( "[", 1, 진실의 ) 그리고나서             현지의 링크 = 가지고 오다( "윙크" )             한다면 링크  그리고.                유형( 링크.겟플레인 ) == "기능' 그리고나서                 추구한다. = 링크.겟플레인( 추구한다. )             끝.         끝.         추구한다. = 음.스트링.더 낮게( 추구한다. )         한다면 다국어.랑( 추구한다. ) 그리고나서             r = 다국어.공정한( 추구한다. )         또 다른             현지의 수집 = 즐겨찾기()             위해서 i = 1, #수집 하다                 r = 발견하다( 추구한다., 수집[ i ] )                 한다면 r 그리고나서                     브레이크. -- i의 경우                 끝.             끝. -- i의 경우         끝.     끝.     돌아가다 r 끝. -- 다국어.find Code()    다국어.고치다 = 기능. ( 시도 )     -- 자주 틀리는 언어 코드를 수정합니다.     -- 전제 조건:     -- attempt -- 추정 언어 코드를 포함하는 문자열     -- 사후 조건:     -- 수정한 문자열을 반환하고, 문제가 없는 경우 false를 반환합니다.     현지의 r = 페치ISO639( '수정' )[ 시도:더 낮게() ]     돌아가다 r 또는 거짓의 끝. -- 다국어.fix()    다국어.포맷 = 기능. ( 적용합니다., 외계인, 바꾸다, 활동적인, 경계.,                                  틀, 조립품, 인접한, 앞서. )     -- 하나 이상의 언어를 포맷합니다.     -- 전제 조건:     -- apply -- 언어 목록 또는 항목을 포함하는 문자열     --외계인 --답변 언어     -- -- nero, false, "*" : 네이티브     --"!": 현재 프로젝트     -- -- "#" : 코드, 다운캐시, 공백 구분     -- "-": 코드, 혼합 대소문자, 공백 구분     ----유효한 코드     -- change - "c"의 경우 대문자로, "d"의 경우 모두 소문자로 표시합니다.     -- "f"의 경우 첫 번째 항목만 대문자로 표시합니다.     -- "m"의 경우 첫 번째 단어마다 다운케이스로 구분합니다.     -- active -- true의 경우 항목을 링크합니다.     -- alert - 오류 발생 시 카테고리 제목을 가진 문자열     -- frame -- 사용 가능한 경우     --assembly -- 스플릿 패턴을 가진 문자열(목록이 예상되는 경우)     -- 인접 - 목록 구분 기호가 있는 문자열, 그렇지 않으면 어셈블리     -- ahead -- 첫 번째 요소가 있는 경우 선두에 추가하는 문자열     -- 사후 조건:     -- 문자열을 반환하고, 비어 있으면 false를 반환합니다.     현지의 r = 거짓의     한다면 적용합니다. 그리고나서         현지의 속어.         한다면 조립품 그리고나서             현지의 양동이 = 음.본문.분열되다( 적용합니다., 조립품 )             현지의 교대하다 = 바꾸다             현지의 분리기             한다면 인접한 그리고나서                 분리기 = 인접한             그렇지 않으면 외계인 == "#"  또는  외계인 == "-" 그리고나서                 분리기 = " "             또 다른                 분리기 = 조립품             끝.             위해서 k, v 에 쌍들( 양동이 ) 하다                 속어. = 다국어.포맷( v, 외계인, 교대하다, 활동적인,                                              경계. )                 한다면 속어. 그리고나서                     한다면 r 그리고나서                         r = string.format( %s%s%s,                                            r, 분리기, 속어. )                     또 다른                         r = 속어.                         한다면 교대하다 == "f" 그리고나서                             교대하다 = "d"                         끝.                     끝.                 끝.             끝. -- k, v의 경우             한다면 r 그리고. 앞서. 그리고나서                 r = 앞서. .. r             끝.         또 다른             현지의 싱글 = 음.본문.다듬다( 적용합니다. )             한다면 싱글 == "" 그리고나서                 r = 거짓의             또 다른                 현지의 랩서스, 슬롯                 속어. = 다국어.find 코드( 싱글 )                 한다면 속어. 그리고나서                     한다면 외계인 == "-" 그리고나서                         r = 속어.                     그렇지 않으면 외계인 == "#" 그리고나서                         r = 속어.:더 낮게()                     또 다른                         r = 다국어.getName( 속어., 외계인 )                         한다면 활동적인 그리고나서                             슬롯 = 채우다( 속어., 거짓의, 틀 )                             한다면 슬롯 그리고나서                                 현지의 링크 = 가지고 오다( "윙크" )                                 한다면 링크  그리고.                                    유형( 링크.타겟을 취득하다 )                                                        == "기능' 그리고나서                                     슬롯 = 링크.타겟을 취득하다( 슬롯 )                                 끝.                             또 다른                                 랩서스 = 경계.                             끝.                         끝.                     끝.                 또 다른                     r = 싱글                     한다면 활동적인 그리고나서                         현지의 직함 = 음.직함.make Title(메이크 타이틀)( 0, 싱글 )                         한다면 직함.존재한다 그리고나서                             슬롯 = 싱글                         끝.                     끝.                     랩서스 = 경계.                 끝.                 한다면 것은 아니다. r 그리고나서                     r = 싱글                 그렇지 않으면 바꾸다 == "c" 또는 바꾸다 == "f" 그리고나서                     r = 음.스트링.위쪽의( 음.스트링.후보선수( r, 1, 1 ) )                         .. 음.스트링.후보선수( r, 2 )                 그렇지 않으면 바꾸다 == "d" 그리고나서                     한다면 다국어.미미한( 속어., r ) 그리고나서                         r = 음.스트링.더 낮게( r )                     끝.                 그렇지 않으면 바꾸다 == "m" 그리고나서                     한다면 다국어.미미한( 속어., r ) 그리고나서                         r = 음.스트링.더 낮게( 음.스트링.후보선수( r, 1, 1 ) )                             .. 음.스트링.후보선수( r, 2 )                     끝.                 끝.                 한다면 슬롯 그리고나서                     한다면 r == 슬롯 그리고나서                         r = string.format( "[%s]", r )                     또 다른                         r = string.format( "[%s %s]", 슬롯, r )                     끝.                 끝.                 한다면 랩서스 그리고. 경계. 그리고나서                     r = string.format( %s[[카테고리:%s]", r, 경계. )                 끝.             끝.         끝.     끝.     돌아가다 r 끝. -- 다국어.포맷()    다국어.getBase = 기능. ( 물어보다 )     -- 조합된 ISO 언어 코드에서 기본 언어를 가져옵니다.     -- 전제 조건:     -- ask -- 언어 코드     -- 사후 조건:     -- 문자열을 반환하거나 false를 반환합니다.     현지의 r     한다면 물어보다 그리고나서         현지의 속어. = 물어보다:경기( "^%s*(%a%a?)"-?%a*%s*$" )         한다면 속어. 그리고나서             r = 속어.:더 낮게()         또 다른             r = 거짓의         끝.     또 다른         r = 거짓의     끝.     돌아가다 r 끝. -- 다국어.getBase()    다국어.lang을 취득 = 기능. ( 물어보다 )     -- RFC 5646 언어 코드의 컴포넌트를 가져옵니다.     -- 전제 조건:     -- ask -- 서브태그가 있는 언어 코드     -- 사후 조건:     -- 포맷된 서브태그가 있는 테이블을 반환합니다.     -- .base     -- .지역     -- .script     -- .disclosedisterface.     -- .년     -- .disclosedisterface.     --.기타     -- .n     현지의 태그 = 음.본문.분열되다( 물어보다, "-" )     현지의 s    = 태그[ 1 ]     현지의 r     한다면 s:경기( "^%a%a%a?$" ) 그리고나서         r = { 기초  = s:더 낮게(),               합법적인 = 진실의,               n     = #태그 }         위해서 i = 2, r.n 하다             s = 태그[ i ]             한다면 #s == 2 그리고나서                 한다면 r.지역  또는  것은 아니다. s:경기( %a%a ) 그리고나서                     r.합법적인 = 거짓의                 또 다른                     r.지역 = s:위쪽의()                 끝.             그렇지 않으면 #s == 4 그리고나서                 한다면 s:경기( %a%a%a%a" ) 그리고나서                     r.합법적인 = ( 것은 아니다. r.대본 )                     r.대본 = s:후보선수( 1, 1 ):위쪽의() ..                                s:후보선수( 2 ):더 낮게()                 그렇지 않으면 s:경기( "20%d%d" )  또는                        s:경기( "1%d%d%d" ) 그리고나서                     r.합법적인 = ( 것은 아니다. r.연도 )                     r.연도 = s                 또 다른                     r.합법적인 = 거짓의                 끝.             그렇지 않으면 #s == 3 그리고나서                 한다면 r.익스플랑  또는  것은 아니다. s:경기( %a%a%a" ) 그리고나서                     r.합법적인 = 거짓의                 또 다른                     r.익스플랑 = s:더 낮게()                 끝.             그렇지 않으면 #s == 1 그리고나서                 s = s:더 낮게()                 한다면 s:경기( """ ) 그리고나서                     r.확장 = s                     위해서 k = i + 1, r.n 하다                         s = 태그[ k ]                         한다면 s:경기( "^%w+$" ) 그리고나서                             r.확장 = string.format( %s-%s,                                                          r.확장, s )                         또 다른                             r.합법적인 = 거짓의                         끝.                     끝. -- k의 경우                 또 다른                     r.합법적인 = 거짓의                 끝.                 브레이크. -- i의 경우             또 다른                 r.합법적인 = ( 것은 아니다. r.다른. )  그리고.                           s:경기( %a%a%a" )                 r.다른. = s:더 낮게()             끝.             한다면 것은 아니다. r.합법적인 그리고나서                 브레이크. -- i의 경우             끝.         끝. -- i의 경우         한다면 r.합법적인 그리고나서             r.제안하다 = 다국어.고치다( r.기초 )             한다면 r.제안하다 그리고나서                 r.합법적인 = 거짓의             끝.         끝.     또 다른         r = { 합법적인 = 거짓의 }     끝.     한다면 것은 아니다. r.합법적인 그리고나서         현지의 cnf = 가지고 오다( "다국어", "config(config) )         한다면 cnf  그리고.  유형( cnf.비명을 지르다 ) == "문자열' 그리고나서             r.비명을 지르다 = cnf.비명을 지르다         끝.     끝.     돌아가다 r 끝. -- 다국어.getLang()    다국어.getName = 기능. ( 물어보다, 외계인 )     -- 이 언어 코드에는 어떤 이름이 할당되어 있습니까?     -- 전제 조건:     -- ask -- 언어 코드     --외계인 --답변 언어     -- -- nero, false, "*" : 네이티브     --"!": 현재 프로젝트     ----유효한 코드     -- 사후 조건:     -- 문자열을 반환하거나 false를 반환합니다.     현지의 r     한다면 물어보다 그리고나서         현지의 속어.   = 외계인         현지의 트랑         한다면 속어. 그리고나서             한다면 속어. == "*" 그리고나서                 속어. = 다국어.공정한( 물어보다 )             그렇지 않으면 속어. == "!" 그리고나서                 속어. = 즐겨찾기()[ 1 ]             또 다른                 속어. = 다국어.공정한( 속어. )             끝.         또 다른             속어. = 다국어.공정한( 물어보다 )         끝.         한다면 것은 아니다. 속어. 그리고나서             속어. = 물어보다 또는 "?????"         끝.         속어. = 속어.:더 낮게()         트랑 = 가지고 오다( "다국어", "이름 )         한다면 트랑 그리고나서             트랑 = 트랑[ 속어. ]             한다면 트랑 그리고나서                 r = 트랑[ 물어보다 ]             끝.         끝.         한다면 것은 아니다. r 그리고나서             한다면 것은 아니다. 다국어.익스텐트.tMW 그리고나서                 다국어.익스텐트.tMW = { }             끝.             트랑 = 다국어.익스텐트.tMW[ 속어. ]             한다면 트랑 == 제로 그리고나서                 트랑 = 음.언어.fetch Language Names(페치 언어 이름)( 속어. )                 한다면 트랑 그리고나서                     다국어.익스텐트.tMW[ 속어. ] = 트랑                 또 다른                     다국어.익스텐트.tMW[ 속어. ] = 거짓의                 끝.             끝.             한다면 트랑 그리고나서                 r = 트랑[ 물어보다 ]             끝.         끝.         한다면 것은 아니다. r 그리고나서             r = 음.언어.fetch Language Name(fetch Language Name)( 물어보다:더 낮게(), 속어. )             한다면 r == "" 그리고나서                 r = 거짓의             끝.         끝.     또 다른         r = 거짓의     끝.     돌아가다 r 끝. -- 다국어.getName()    다국어.18n = 기능. ( 이용할 수 있는, 알트, 틀 )     -- 번역 가능한 메시지 선택     -- 전제 조건:     -- 사용 가능 -- 매핑 언어 코드 ./. 텍스트가 있는 테이블     -- alt -- 문자열 0 false, 폴백텍스트 포함     -- frame -- 프레임(사용 가능한 경우)     -- 반환     -- 1. 스트링 제로 false(선택된 메시지 포함)     -- 2. 문자열 0 false, 언어 코드 포함     현지의 r1, r2     한다면 유형( 이용할 수 있는 ) == "테이블" 그리고나서         현지의 코드 = { }         현지의 트러블  = { }         현지의 속어.         위해서 k, v 에 쌍들( 이용할 수 있는 ) 하다             한다면 유형( k ) == "문자열'  그리고.                유형( v ) == "문자열' 그리고나서                 속어. = 음.본문.다듬다( k:더 낮게() )                 table.insert( 코드, 속어. )                 트러블[ 속어. ] = v             끝.         끝. -- k, v의 경우         속어. = 다국어.userLang( 코드, 틀 )         한다면 속어.  그리고.  트러블[ 속어. ] 그리고나서             r1 = 음.본문.다듬다( 트러블[ 속어. ] )             한다면 r1 == "" 그리고나서                 r1 = 거짓의             또 다른                 r2 = 속어.             끝.         끝.     끝.     한다면 것은 아니다. r1  그리고.  유형( 알트 ) == "문자열' 그리고나서         r1 = 음.본문.다듬다( 알트 )         한다면 r1 == "" 그리고나서             r1 = 거짓의         끝.     끝.     돌아가다 r1, r2 끝. -- 다국어.i18n()    다국어.인트 = 기능. ( 접근, 외계인, 적용합니다. )     -- 번역된 시스템 메시지     -- 전제 조건:     -- access -- 메시지 ID     --외계인 --언어 코드     -- apply --null 또는 파라미터 $1, $2, ...의 시퀀스테이블     -- 사후 조건:     -- 문자열을 반환하거나 false를 반환합니다.     현지의 o = 음.메세지.신규( 접근 )     현지의 r     한다면 o:존재한다() 그리고나서         한다면 유형( 외계인 ) == "문자열' 그리고나서             o:언어 사용 안 함( 외계인:더 낮게() )         끝.         한다면 유형( 적용합니다. ) == "테이블" 그리고나서             o:파라미터( 적용합니다. )         끝.         r = o:평지()     끝.     돌아가다 r 또는 거짓의 끝. -- Multilingual.int()    다국어.랑 = 기능. ( 물어보다, 추가의 )     --ISO 언어 코드일 수 있습니까?     -- 전제 조건:     -- ask -- 언어 코드     -- additional -- "simple"과 같은 Wiki 코드가 허용된 경우 true입니다.     -- 사후 조건:     -- 부울을 반환합니다.     현지의 r, s     한다면 추가의 그리고나서         s = 물어보다     또 다른         s = 다국어.getBase( 물어보다 )     끝.     한다면 s 그리고나서         r = 음.언어.isKnownLanguageTag( s )         한다면 r 그리고나서             r = 것은 아니다. 다국어.고치다( s )         그렇지 않으면 추가의 그리고나서             r = 다국어.이국적인[ s ] 또는 거짓의         끝.     또 다른         r = 거짓의     끝.     돌아가다 r 끝. -- 다국어.isLang()    다국어.랑위키 = 기능. ( 물어보다 )     --Wiki 언어 버전일 수 있습니까?     -- 전제 조건:     --ask --언어 버전 지정자     -- 사후 조건:     -- 부울을 반환합니다.     현지의 r     현지의 s = 다국어.getBase( 물어보다 )     한다면 s 그리고나서         r = 음.언어.is Supported Language(지원 언어)( s )  또는             다국어.이국적인[ 물어보다 ]     또 다른         r = 거짓의     끝.     돌아가다 r 끝. -- 다국어.isLangWiki()    다국어.미미한 = 기능. ( 물어보다, 맡겨진 )     --이 언어명이 다운캐시 될 수 있습니까?     -- 전제 조건:     -- ask -- 언어 코드 또는 제로     -- assigned -- 언어 이름 또는 0     -- 사후 조건:     -- 부울을 반환합니다.     현지의 r = 진실의     한다면 물어보다 그리고나서         현지의 cnf = 가지고 오다( "다국어", "config(config) )         한다면 cnf 그리고나서             현지의 s = string.format( " %s ", 물어보다:더 낮게() )             한다면 유형( cnf.정지 최소화 ) == "문자열'                그리고.  cnf.정지 최소화:발견하다( s, 1, 진실의 ) 그리고나서                 r = 거짓의             끝.             한다면 r  그리고.  맡겨진                그리고.  유형( cnf.seek Minusculization(최소화) ) == "문자열'                그리고.  cnf.seek Minusculization(최소화):발견하다( s, 1, 진실의 )                그리고.  유형( cnf.스캔 최소화 ) == "문자열' 그리고나서                 현지의 스캔 = 맡겨진:서브( "[%(%)]", " " ) .. " "                 한다면 것은 아니다. 스캔:발견하다( cnf.스캔 최소화 ) 그리고나서                     r = 거짓의                 끝.             끝.         끝.     끝.     돌아가다 r 끝. -- 다국어.is Minusculable()    다국어.RTL = 기능. ( 물어보다 )     -- 언어가 오른쪽에서 왼쪽으로 쓰여 있는지 확인합니다.     -- 전제 조건:     -- ask -- 언어(또는 스크립트) 코드를 포함한 문자열     -- 오른쪽에서 왼쪽으로의 경우 true를 반환합니다.     현지의 r     다국어.rtl = 다국어.rtl 또는 { }     r = 다국어.rtl[ 물어보다 ]     한다면 유형( r ) ~= "실패" 그리고나서         현지의 턱받이 = 가지고 오다( ISO15924 )         한다면 유형( 턱받이 ) == "테이블"  그리고.            유형( 턱받이.RTL ) == "기능' 그리고나서             r = 턱받이.RTL( 물어보다 )         또 다른             r = 음.언어.신규( 물어보다 ):RTL()         끝.         다국어.rtl[ 물어보다 ] = r     끝.     돌아가다 r 끝. -- 다국어.isRTL()    다국어.메세지 = 기능. ( 리스트, 틀 )     -- 시스템 메시지와 같은 사용자 언어에 가장 적합한 텍스트를 표시합니다.     -- 전제 조건:     -- arglist --템플릿 인수     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 적절한 텍스트가 포함된 문자열을 반환합니다.     현지의 r     한다면 유형( 리스트 ) == "테이블" 그리고나서         현지의 t = { }         현지의 m, p, 절약하다         위해서 k, v 에 쌍들( 리스트 ) 하다             한다면 유형( k ) == "문자열'  그리고.                유형( v ) == "문자열' 그리고나서                 v = 음.본문.다듬다( v )                 한다면 v ~= "" 그리고나서                     한다면 k:경기( "^%l%l" ) 그리고나서                         t[ k ] = v                     그렇지 않으면 k:경기( "^%$%d$" )  그리고.  k ~= "$0" 그리고나서                         p = p 또는 { }                         k = 톤수( k:경기( "^%$(%d)$" ) )                         p[ k ] = v                         한다면 것은 아니다. m  또는  k > m 그리고나서                             m = k                         끝.                     끝.                 끝.             끝.         끝. -- k, v의 경우         한다면 유형( 리스트[ "-" ] ) == "문자열' 그리고나서             절약하다 = 리스트[ 리스트[ "-" ] ]         끝.         r = 다국어.18n( t, 절약하다, 틀 )         한다면 p  그리고.  r  그리고.  r:발견하다( "$", 1, 진실의 ) 그리고나서             t = { }             위해서 i = 1, m 하다                 t[ i ] = p[ i ]  또는  ""             끝. -- i의 경우             r = 음.메세지.new Raw Message( r, t ):평지()         끝.     끝.     돌아가다 r  또는  "" 끝. -- 다국어.message()    다국어.시트링크 = 기능. ( 모든., 틀 )     --최적의 링크 텍스트 번역으로 로컬 사이트 또는 다른 사이트에서 링크를 만듭니다.     -- 전제 조건:     -- all - 문자열 또는 테이블 또는 번호, 항목 ID 또는 엔티티     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 유용한 내부 링크 또는 일반 텍스트가 포함된 문자열을 반환합니다.     현지의 s = 유형( 모든. )     현지의 물건, r     한다면 s == "테이블" 그리고나서         물건 = 모든.     그렇지 않으면 s == "문자열' 그리고나서         물건 = 음.키보드.엔티티( 모든. )     그렇지 않으면 s == "숫자" 그리고나서         물건 = 음.키보드.엔티티( string.format( "Q%d", 모든. ) )     끝.     한다면 유형( 물건 ) == "테이블" 그리고나서         현지의 수집 = 물건.시트링크         현지의 엔트리         s = 거짓의         한다면 유형( 수집 ) == "테이블" 그리고나서             다국어.위치 = 다국어.위치  또는                                 음.키보드.getGlobalSiteId()             엔트리 = 수집[ 다국어.위치 ]             한다면 엔트리 그리고나서                 s = ":" .. 엔트리.직함             그렇지 않으면 수집.enwiki 그리고나서                 s = "w:en:" .. 수집.enwiki.직함             끝.         끝.         r = 다국어.키보드( 물건, "실패", 틀 )         한다면 s 그리고나서             한다면 s == ":" .. r 그리고나서                 r = string.format( "[%s]", s )             또 다른                 r = string.format( "[%s %s]", s, r )             끝.         끝.     끝.     돌아가다 r  또는  "" 끝. -- 다국어.sitelink()    다국어.탭 데이터 = 기능. ( 접근, 에, 알트, 틀 )     -- commons에서 번역된 키워드를 가져옵니다.데이터: ***.탭     -- 전제 조건:     -- access -- Commons에서 페이지 ID를 포함하는 문자열     -- at -- 문자열, 키워드 포함     -- alt -- 문자열 0 false, 폴백텍스트 포함     -- frame -- 프레임(사용 가능한 경우)     -- 반환     -- 1. 스트링 제로 false(선택된 메시지 포함)     -- 2. 언어 코드 또는 "오류"     현지의 데이터. = fetch 데이터( 접근 )     현지의 r1, r2     한다면  유형( 데이터. ) == "테이블" 그리고나서         한다면 유형( 에 ) == "문자열' 그리고나서             현지의 추구한다. = 음.본문.다듬다( 에 )             한다면 추구한다. == "" 그리고나서                 r1 = "EMPLY Multilanguage.Tab 키"             또 다른                 현지의 e, 폴리                 위해서 i = 1, #데이터. 하다                     e = 데이터.[ i ]                     한다면 유형( e ) == "테이블" 그리고나서                         한다면 e[ 1 ] == 추구한다. 그리고나서                             한다면 유형( e[ 2 ] ) == "테이블" 그리고나서                                 폴리 = e[ 2 ]                             또 다른                                 r1 = "잘못된 다국어.탭 데이터 불량 번호"                                                          .. 스트링( i )                             끝.                             브레이크.   -- i의 경우                         끝.                     또 다른                         브레이크.   -- i의 경우                     끝.                 끝.   -- i의 경우                 한다면 폴리 그리고나서                     데이터. = 폴리                 또 다른                     r1 = "알 수 없는 다국어.탭 데이터 키: " .. 추구한다.                 끝.             끝.         또 다른             r1 = "잘못된 다국어.탭 데이터 키"         끝.     또 다른         r1 = 데이터.     끝.     한다면 r1 그리고나서         r2 = "에러"     그렇지 않으면 데이터. 그리고나서         r1, r2 = 다국어.18n( 데이터., 알트, 틀 )         r2 = r2 또는 "에러"     끝.     돌아가다 r1, r2 끝. -- 다국어.탭데이터()    다국어.userLang = 기능. ( 받아들이다, 틀 )     -- 어플리케이션별로 사용자 언어를 지원하려고 합니다.     -- 전제 조건:     -- accept -- 문자열 또는 테이블     -- 사용 가능한 ISO 639 코드 목록을 공백으로 구분합니다.     -- 기본: 프로젝트 언어 또는 영어     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 적절한 코드를 가진 문자열을 반환합니다.     현지의 s = 유형( 받아들이다 )     현지의 코드, r, 속어.     한다면 s == "문자열' 그리고나서         코드 = 음.본문.분열되다( 받아들이다:더 낮게(), %s+ )     그렇지 않으면 s == "테이블" 그리고나서         코드 = { }         위해서 i = 1, #받아들이다 하다             s = 받아들이다[ i ]             한다면 유형( s ) == "문자열'  그리고.                s ~= "" 그리고나서                 table.insert( 코드, s:더 낮게() )             끝.         끝. -- i의 경우     끝.     속어. = 사용자.편애하다( 코드, 틀 )     한다면 속어. 그리고나서         한다면 실현 가능한( 속어., 코드 ) 그리고나서             r = 속어.         그렇지 않으면 속어.:발견하다( "-", 1, 진실의 ) 그리고나서             속어. = 다국어.getBase( 속어. )             한다면 실현 가능한( 속어., 코드 ) 그리고나서                 r = 속어.             끝.         끝.         한다면 것은 아니다. r 그리고나서             현지의 다른이들 = 음.언어.폴백위해서( 속어. )             위해서 i = 1, #다른이들 하다                 속어. = 다른이들[ i ]                 한다면 실현 가능한( 속어., 코드 ) 그리고나서                     r = 속어.                     브레이크. -- i의 경우                 끝.             끝. -- i의 경우         끝.     끝.     한다면 것은 아니다. r 그리고나서         현지의 뒤로 = 즐겨찾기()         위해서 i = 1, #뒤로 하다             속어. = 뒤로[ i ]             한다면 실현 가능한( 속어., 코드 ) 그리고나서                 r = 속어.                 브레이크. -- i의 경우             끝.         끝. -- i의 경우         한다면 것은 아니다. r  그리고.  코드[ 1 ] 그리고나서             r = 코드[ 1 ]         끝.     끝.     돌아가다 r  또는  즐겨찾기()[ 1 ] 끝. -- 다국어.userLang()    다국어.userLangCode(사용자랑코드) = 기능. ()     -- 사용자 언어 코드 추측     -- 사후 조건:     -- 현재 최선의 추측 코드를 반환합니다.     돌아가다 사용자.자신  또는  즐겨찾기()[ 1 ] 끝. -- 다국어.userLangCode()    다국어.키보드 = 기능. ( 모든., 대해서, 시도, 틀 )     -- Wikibase 컴포넌트의 최적의 번역     -- 전제 조건:     -- all -- 문자열 또는 테이블, 오브젝트 ID 또는 엔티티     -- about -- 부울, true "communications" 또는 false "communications"     -- attempt -- 문자열 여부, 우선 언어 코드     -- frame -- 프레임(사용 가능한 경우)     -- 사후 조건:     -- 반환     -- 1. 문자열(선택된 메시지 포함)     -- 2. 문자열, 언어 코드 포함 여부     현지의 s = 유형( 모든. )     현지의 물건, r, r2     한다면 s == "테이블" 그리고나서         물건 = 모든.     그렇지 않으면 s == "문자열' 그리고나서         물건 = 음.키보드.엔티티( 모든. )     끝.     한다면 유형( 물건 ) == "테이블" 그리고나서         한다면 대해서  그리고.  대해서 ~= "실패" 그리고나서             s = 「의견」         또 다른             s = "실패"         끝.         물건 = 물건[ s ]         한다면 유형( 물건 ) == "테이블" 그리고나서             한다면 물건[ 시도 ] 그리고나서                 r  = 물건[ 시도 ].가치                 r2 = 시도             또 다른                 현지의 폴리                 위해서 k, v 에 쌍들( 물건 ) 하다                     폴리 = 폴리 또는 { }                     폴리[ k ] = v.가치                 끝. -- k, v의 경우                 한다면 폴리 그리고나서                     r, r2 = 다국어.18n( 폴리, 제로, 틀 )                 끝.             끝.         끝.     끝.     돌아가다 r  또는  "",   r2 끝. -- 다국어.위키베이스()    페일 세이프.페일 세이프 = 기능. ( 적어도 )     --버전 관리를 취득하여 컴플라이언스를 확인합니다.     -- 전제 조건:     -- 최소 -- 문자열(필요한 버전 포함)     -- 또는 wikidata 항목 ~ @ 또는 false     -- 사후 조건:     --문제의 버전/항목과 함께 문자열을 반환합니다(문제가 있는 경우에도 마찬가지).     -- false -- 적절한 경우     -- 2020-08-17     현지의 부터 = 적어도     현지의 지난    = ( 부터 == "~" )     현지의 링크된  = ( 부터 == "@" )     현지의 링크    = ( 부터 == "항목" )     현지의 r     한다면 지난  또는  링크  또는  링크된  또는  부터 == "카메리다타" 그리고나서         현지의 아이템 = 페일 세이프.아이템         부터 = 거짓의         한다면 유형( 아이템 ) == "숫자"  그리고.  아이템 > 0 그리고나서             현지의 적합. = string.format( "Q%d", 아이템 )             한다면 링크 그리고나서                 r = 적합.             또 다른                 현지의 독립체 = 음.키보드.엔티티( 적합. )                 한다면 유형( 독립체 ) == "테이블" 그리고나서                     현지의 추구한다. = 페일 세이프.serial Property 또는 "P348"                     현지의 vsn  = 독립체:format Property Values( 추구한다. )                     한다면 유형( vsn ) == "테이블"  그리고.                        유형( vsn.가치 ) == "문자열'  그리고.                        vsn.가치 ~= "" 그리고나서                         한다면 지난  그리고.  vsn.가치 == 페일 세이프.시리얼 그리고나서                             r = 거짓의                         그렇지 않으면 링크된 그리고나서                             한다면 음.직함.get Current Title(전류 제목)().프리픽스본문                                ==  음.키보드.get Sitelink를 취득하다( 적합. ) 그리고나서                                 r = 거짓의                             또 다른                                 r = 적합.                             끝.                         또 다른                             r = vsn.가치                         끝.                     끝.                 끝.             끝.         끝.     끝.     한다면 유형( r ) == "실패" 그리고나서         한다면 것은 아니다. 부터  또는  부터 <=> 페일 세이프.시리얼 그리고나서             r = 페일 세이프.시리얼         또 다른             r = 거짓의         끝.     끝.     돌아가다 r 끝. -- Failsafe.failsafe()    -- 내보내기 현지의 p = { }    p.공정한 = 기능. ( 틀 )     -- 언어 코드 포맷     -- 1 -- 언어 코드     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     돌아가다 다국어.공정한( s )  또는  "" 끝. -- p.fair    p.폴백 = 기능. ( 틀 )     대체어로 다른 언어가 적합합니까?     -- 1 -- 지원되는 언어 버전 지정자     -- 2 - 대체 가능한 언어 지정자     현지의 s1 = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     현지의 s2 = 음.본문.다듬다( 틀.args[ 2 ]  또는  "" )     현지의 r  = 다국어.폴백( s1, s2 )     한다면 유형( r ) == "테이블" 그리고나서         r = r[ 1 ]     또 다른         r = r  그리고.  "1"   또는   ""     끝.     돌아가다 r 끝. -- p. 폴백    p.find 코드 = 기능. ( 틀 )     -- 언어 이름에서 언어 코드를 검색합니다.     -- 1 -- 현재 프로젝트 언어로 된 이름     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     돌아가다 다국어.find 코드( s )  또는  "" 끝. -- p.find 코드    p.고치다 = 기능. ( 틀 )     현지의 r = 틀.args[ 1 ]     한다면 r 그리고나서         r = 다국어.고치다( 음.본문.다듬다( r ) )     끝.     돌아가다 r 또는 "" 끝. -- p.fix    p.포맷 = 기능. ( 틀 )     -- 하나 이상의 언어를 포맷합니다.     -- 1 -- 언어 목록 또는 항목     -- slang : 네이티브가 아닌 경우 답변 언어     -- * -- 원어민     --! -- 현재 프로젝트     -- 유효한 코드     --shift -- "c"의 경우 대문자로, "d"의 경우 다운케이스로 지정합니다.     -- "f"의 경우 첫 번째 항목만 대문자로 표시합니다.     -- link -- 1 -- 링크 항목     -- scream -- 오류 발생 시 카테고리 제목     -- split -- 스플릿 패턴(목록이 예상되는 경우)     -- separator -- 목록 구분자, 그렇지 않으면 분할     -- start -- 첫 번째 요소(있는 경우)를 추가합니다.     현지의 r     현지의 링크     한다면 틀.args.링크 == "1" 그리고나서         링크 = 진실의     끝.     r = 다국어.포맷( 틀.args[ 1 ],                              틀.args.속어.,                              틀.args.교대하다,                              링크,                              틀.args.비명을 지르다,                              틀,                              틀.args.분열되다,                              틀.args.분리기,                              틀.args.개시하다 )     돌아가다 r 또는 "" 끝. -- p.format    p.getBase = 기능. ( 틀 )     -- 조합된 ISO 언어 코드에서 기본 언어를 가져옵니다.     -- 1 -- 코드     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     돌아가다 다국어.getBase( s )  또는  "" 끝. -- p.getBase    p.getName = 기능. ( 틀 )     -- ISO 언어 코드에서 언어 이름을 가져옵니다.     -- 1 -- 코드     -- 2 -- 원어민이 아닌 경우 답변에 사용하는 언어     --! -- 현재 프로젝트     -- * -- 원어민     -- 유효한 코드     현지의 s     = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     현지의 속어. = 틀.args[ 2 ]     현지의 r     다국어.틀 = 틀     한다면 속어. 그리고나서         속어. = 음.본문.다듬다( 속어. )     끝.     r = 다국어.getName( s, 속어. )     돌아가다 r 또는 "" 끝. -- p.getName    p.인트 = 기능. ( 틀 )     -- 번역된 시스템 메시지     -- 1 -- 메시지 ID     -- lang -- 언어 코드     -- $1, $2, ... -- 파라미터     현지의 시스템 메시지 = 틀.args[ 1 ]     현지의 r     한다면 시스템 메시지 그리고나서         시스템 메시지 = 음.본문.다듬다( 시스템 메시지 )         한다면 시스템 메시지 ~= "" 그리고나서             현지의 n     = 0             현지의 속어. = 틀.args.언어             현지의 i, 파라미터, s             한다면 속어. == "" 그리고나서                 속어. = 거짓의             끝.             위해서 k, v 에 쌍들( 틀.args ) 하다                 한다면 유형( k ) == "문자열' 그리고나서                     s = k:경기( "^%$(%d+)" )                     한다면 s 그리고나서                         i = 톤수( s )                         한다면 i > n 그리고나서                             n = i                         끝.                     끝.                 끝.             끝. -- k, v의 경우             한다면 n > 0 그리고나서                 현지의 s                 파라미터 = { }                 위해서 i = 1, n 하다                     s = 틀.args[ "$" .. 스트링( i ) ]  또는  ""                     table.insert( 파라미터, s )                 끝. -- i의 경우             끝.             r = 다국어.인트( 시스템 메시지, 속어., 파라미터 )         끝.     끝.     돌아가다 r 또는 "" 끝. -- p.int    p.랑 = 기능. ( 틀 )     --ISO 언어 코드일 수 있습니까?     -- 1 -- 코드     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     현지의 행운의, r = pcall( 다국어.랑, s )     돌아가다 r 그리고. "1" 또는 "" 끝. -- p.isLang    p.랑위키 = 기능. ( 틀 )     --Wiki 언어 버전일 수 있습니까?     -- 1 -- 코드     -- 언어 버전(가능한 경우)이 비어 있지 않은 상태로 반환됩니다.     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     현지의 행운의, r = pcall( 다국어.랑위키, s )     돌아가다 r 그리고. "1" 또는 "" 끝. -- p.isLangWiki    p.RTL = 기능. ( 틀 )     -- 언어가 오른쪽에서 왼쪽으로 쓰여 있는지 확인합니다.     -- 1 -- 언어 코드가 있는 문자열     -- 오른쪽에서 왼쪽으로 빈칸이 아닌 값을 반환합니다.     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     돌아가다 다국어.RTL( s ) 그리고. "1" 또는 "" 끝. -- p.isRTL()    p.메세지 = 기능. ( 틀 )     -- 텍스트 요소의 번역     돌아가다 다국어.메세지( 접다( 틀 ), 틀 ) 끝. -- p.message    p.시트링크 = 기능. ( 틀 )     --최적의 링크 텍스트 번역으로 로컬 사이트 또는 다른 사이트에서 링크를 만듭니다.     -- 1 -- 아이템 ID     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     현지의 r     한다면 s:경기( "^%d+$") 그리고나서         r = 톤수( s )     그렇지 않으면 s:경기( "^Q%d+$") 그리고나서         r = s     끝.     한다면 r 그리고나서         r = 다국어.시트링크( r, 틀 )     끝.     돌아가다 r 또는 s 끝. -- p. sitelink    p.탭 데이터 = 기능. ( 틀 )     -- Commons Data에서 최적의 메시지 텍스트를 가져옵니다.     -- 1 -- Commons 에서의 페이지 식별     -- 2 -- 키워드     -- alt -- 폴백텍스트     현지의 스위트 = 틀.args[ 1 ]     현지의 추구한다.  = 틀.args[ 2 ]     현지의 소금.  = 틀.args.알트     현지의 r     = 다국어.탭 데이터( 스위트, 추구한다., 소금., 틀 )     돌아가다 r 끝. -- p.tabData    p.userLang = 기능. ( 틀 )     --현재 사용자는 어떤 언어를 선호합니까?     -- 1 -- 사용 가능한 ISO 639 코드의 공백 구분 목록     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     돌아가다 다국어.userLang( s, 틀 ) 끝. -- p.userLang    p.키보드 = 기능. ( 틀 )     -- Wikibase 컴포넌트의 최적의 번역     -- 1 -- 오브젝트 ID     -- 2 - "의견"의 경우 1, "의견"의 경우 0.     -- 또는 "의견" 또는 "의견" 중 하나     현지의 r     현지의 s = 음.본문.다듬다( 틀.args[ 1 ]  또는  "" )     한다면 s ~= "" 그리고나서         현지의 s2    = 음.본문.다듬다( 틀.args[ 2 ]  또는  "0" )         현지의 속어. = 음.본문.다듬다( 틀.args.언어  또는  "" )         현지의 큰. = ( s2 ~= ""  그리고.  s2 ~= "0" )         한다면 속어. == "" 그리고나서             속어. = 거짓의         끝.         r = 다국어.키보드( s, 큰., 속어., 틀 )     끝.     돌아가다 r 또는 "" 끝. -- p.c.base    p.페일 세이프 = 기능. ( 틀 )     --버전 관리 인터페이스     현지의 s = 유형( 틀 )     현지의 부터     한다면 s == "테이블" 그리고나서         부터 = 틀.args[ 1 ]     그렇지 않으면 s == "문자열' 그리고나서         부터 = 틀     끝.     한다면 부터 그리고나서         부터 = 음.본문.다듬다( 부터 )         한다면 부터 == "" 그리고나서             부터 = 거짓의         끝.     끝.     돌아가다 페일 세이프.페일 세이프( 부터 )  또는  "" 끝. -- p.failsafe()    p.다국어 = 기능. ()     돌아가다 다국어 끝. -- p. 다국어  돌아가다 p