User:Psychoslave/babylscript/error messages

From MediaWiki.org
Jump to navigation Jump to search
# Notu : bonvolu helpi pri kungrue verki kun la traduko de mem
# https://docs.google.com/spreadsheets/d/1ZdKCDKyz_6B9Aqbkd3ebCfcVOeX-ojN6li0yUbKpUkg/edit#gid=0
#
# Dum tradukado, bonvolu
# * aldoni la tradukon antaŭ la komentita fontfrazo
# * duobli la diessignon antaŭ la jam komentitaj fontfrazoj
# * uzi "#!" antaŭ komentoj pri la tradukado mem

#! Tiu dokumento celas provizi kongruan vortreto.
#! Tiu do malcelas nek paŭsi la anglajn termojn nek la "tradiciajn" termojn, 
#! kvankam tiu lasta estas ege inkluza en la pripensado.

#! Ofte la programado temas pri referenco, deklari referencon, difini referencon, uzi la referecon
#! aŭ la referecaton, ktp. 
#! Do sube estas la listo de kontekstoj kie la nocio de referenco etas uzita
#! kaj kiel tio dokumento tradukas ilin

#! Laŭ konteksto pri aliriloj de reĝistro, traduku per -lok- vortoj
#!    load     store
#!    elloki     enloki
#!
#! Laŭ konteksto pri aliriloj de ĉefmemoro, traduku per -ej- vortoj
#!
#! Laŭ dosier-mastrum-konteksto, traduku per -ir-
#!    read    write    open        close
#!     eliri    eniri    ekirebligi    irebleksigi (ek-ir-ebl-igi, ir-ebl-eks-igi).
#!
#! Laŭ konteksto pri reto, traduku per -ŝut-
#!    download    upload    
#!     elŝuti        alŝuti
#!
#! Laŭ konteksto pri aliriloj, difinoj, deklaradoj de variablo ktp, traduku per -sign- vortoj
#!        let                        set
#! declare     allocate    define        initialization     assign         denoting    delete
#!*deklari    asigni        difini         iniciato        atribui        denotacio    
#!                                        indiko
#! signigi    alsigni        limsigni    eksigni        ensigni        elsigni        forsigni 
#!
#! Notu ke eks-signi povus esti pli preciza ol forsigni, sed "ekssigni" tro proksimas "eksigni"
#! *tio estas aliaj validaj termoj ke ni ne uzos tie ĉi.
#!
#! Kelkaj detaloj : 
#! (vidu ankaŭ http://stackoverflow.com/questions/23345554/the-differences-between-initialize-define-declare-a-variable )
#! "x estas variablo" kaj "x estas entjero" estas deklaradoj
#! "0<x<42" kaj  "x ∋ {y+1}" aŭ "function increment(x){return x+1;}" estas difinado
#! "x = 3" estas asigno, aŭ signado
#!
#! Laŭ konteksto pri aliriloj de montrilo/referenco (pointers/references)
#! Notu ke oni povas paroli pri 
#! signsigno, kiuj povas egale referi al signsigno, ktp (montrilo, pointers)
#! valorsigno, kiuj povas nur referi al valoro (referenco, reference)
#!
#! some_type foo = 5;        umtipa aĵo iĝu 5        aĵo signas 5
#! some_type bar = 6;        umtipa ajno iĝu 6        ajno signas 6
#! some_type *baz;            umtipa pera zozo        zozo signigu signsigne
#! some_type &qux = foo;        umtipa eja umo iĝu aĵo    umo signas valorsigne aĵon
#! baz = &foo;            zozo iĝu aĵejo            zozo signas aĵejon
#! baz = &bar;            zozo iĝu ajnejo        zozo signas ajnejon
#! *baz = 10;            zozenhavo iĝu 10        alzozo signas 10
#! foo = *baz            aĵo iĝu zozenhavo        aĵo signas elzozon
#!
#!
#! Laŭ konteksto pri trafo ("scope") de signo, traduku per "-vokebl-"
#!    public            private            protected    friend
#!    eksterklasalirebla    memklasalirea        idklasalirebla    elektklasalirebla
#!
#!    extern             static    
#!    eksterblokalirebla    ĉiingalirebla
#!                klaskomuna
#!                transvoka
#!                nurtujvokebla
#!
#! Laŭ konteksto pri elemento de tabelo, traduku per "-er-"
#!    table[3][5]
#!    5a3a-tabelero
#!
#! Laŭ konteksto pri objekto , traduku per -ul-
#!    class    instance    extend    new    delete        interface        abstract
#!    klaso    ano        klasidi    anigi    eksanigi     interfaco
#!
#! Laŭ konteksto pri aliriloj de eco (property), traduku per -ec-
#!     get    set
#!      eleci    aleci
#! Laŭ konteksto pri ŝaltfrazoj (jump declarations), traduku per -ŝalt-
#!    jump        goto        switch*    break        continue    return
#!    (pri)ŝalti    (pri)alŝalti    (pri)enŝalti    eksterŝalti    (cikl)sekvŝalti     (pri)reŝalti**
#!                                                                                 ĉeŝalti
#!
#!    try         catch         throw        finally        case    default    
#!    flankŝaltebli    elflankŝalti    flankŝalti    finflankŝalti    ŝaltejo    ĉefŝaltejo    
#!    prov(ŝalt)i
#!
#!    except
#!     kromŝaltu
#!
#! *Notu ke pri "switch", KompLeks parolas pri "ŝalt·algebr·o"
#! http://joostje.komputilo.org/KompLeks/html/SX.html#SxALTALGEBRO
#!
#! * *Uzu "reŝalt/i" pri la reŝaltaj frazoj (angle "return statement"), sed uzu "liver/o" por tiu ke la 
#! funkcio produktas. Funkcioj jam aliflanke uzas liveraj frazoj (angle "yield statement") kiel
#! elŝaltilo.
#!
#! Laŭ konteksto de krampo, konteksto, kaj simile :
#!     open    close
#!     aperti    malaperti

#! generator -> gener-il/o

#!!!!!!!!!!!!!!!! Nomoj por elementoj de diskursoj
#! statement -> frazo
#! statement (énoncé) -> vortigo
#! statement -> eldiro
#! instruction -> instrukcio
#! clause -> frazparto, (kunordigita) propozicio, 
#! declaration -> deklaro, deklaracio
#! definition -> difino
#! body -> -uj/o
#! block -> -ing/o
#! stream -> fluo
#! content -> enhavo, -tuto


#!!!!!!!!!!!!!!!! Ecoj por elementoj de diskursoj
#! requirement -> postulo
#! assertion -> aserto
#! claim -> pretendo
#! disclaimer -> malpretendo
#! -> ordono
#! instance-> ano, tipano, klasano
#! qualify -> ecigi, kvalifiki, kvalitigi,

#! statement -> eldiro
#! prescription -> preskribo
#! formula -> formulo
#! formulation -> fomulado
#! caption (légende) ->
#! label (libellé) ->
#! category -> categorio
#! mention -> mencio
#! deklaration -> deklaro
#! -> elparoli
#! -> aliĝilo
#! -> mendo
#! -> mendilo
#!

#!  value-> valoro    sed : intervalo
#! pole    -> poluso    sed : interpoli, ekesterpoli 




# Defaŭltaj mesaĝoj dosiero de Ĝavoskripto.
## Default JavaScript messages file.

#! Tradukdecido :
#! "property" -> "eco"
#! "assembly" -> bind-ilo, bindil-igo, ktp laŭ konteksto
#!
#! Notoj, kaj referencoj
#! ĵar mallongigas "Java ARchive", tio estas "Java-arkivo", aŭ "Java-dosier-formo"
#! http://joostje.komputilo.org/KompLeks/html/AP.html#ASEMBLA-LINGVO
#! http://joostje.komputilo.org/KompLeks/html/B.html#BINDILO

# Jeno estas anstataŭigita dum la Javarkiv-bindiligado el ecĉeno kaj netradukendu
## This is replaced during jar assembly from property string
## and should not be translated
implementation.version = @IMPLEMENTATION.VERSION@

#! "should be accessible" -> al-ir-ebl-end-us

# Por aldoni eraromesaĝojn de JavaScript en aparta lokaĵo,
# kreu novan dosieron “Messages_[lokaĵo].properties“, kie [lokaĵo] estas la
# la Java mallonge ĉeno por tiu lokaĵo. (ISO 639?
# Vidu https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes)
# Ekzemple mesaĝoj je Javascripto por pola lokaĵo lokus en Messages_pl.properties, kaj
# mesaĝoj por svis-itala lokaĵo lokus en Messages_it_CH.properties.
# Mesaĝecdosieroj alireblendus tra la klasirejo (classpath) sub
# org.mozilla.Javascript.resources
#
## To add JavaScript error messages for a particular locale, create a
## new Messages_[locale].properties file, where [locale] is the Java
## string abbreviation for that locale.  For example, JavaScript
## messages for the Polish locale should be located in
## Messages_pl.properties, and messages for the Italian Swiss locale
## should be located in Messages_it_CH.properties.  Message properties
## files should be accessible through the classpath under
## org.mozilla.Javascript.resources
#
# Java.util.ResourceBundle
# Java.text.MessageFormat
#


# iuajnjavklasuziĝinta
## SomeJavaClassWhereUsed

# Kodgeneru
## Codegen
msg.dup.parms =\
    duobligu parametronomo "{0}".
    # Duplicate parameter name "{0}".

#! offset estas "deŝovo" laŭ komputada leksikono
msg.too.big.jump =\
    Programo tro kompleksa: tro granda saltdeŝovo.
    #Program too complex: too big jump offset.

msg.too.big.index =\
    Programo tro kompleksa: interna indekso superas la 64Kan limiton
# Program too complex: internal index exceeds 64K limit.

msg.while.compiling.fn =\
    Trafis kodgeneraderaro dum funkctradukado "{0}": {1}
    #Encountered code generation error while compiling function "{0}": {1}

msg.while.compiling.script =\
    Trafis kodgeneraderaro dum skripttradukado: {0}
    #Encountered code generation error while compiling script: {0}

# Konteksto
## Context
msg.ctor.not.found =\
    Konstruilo por "{0}" maltrovita.
    #Constructor for "{0}" not found.

msg.not.ctor =\
    "{0}" ne estas konstruilo.
    #"{0}" is not a constructor.

# Funkcobjekto
## FunctionObject

msg.varargs.ctor =\
    Metodo aŭ konstruilo "{0}" endas statikan kun signaturo
    “(Konteksta kono, Objekttipaj[] argumentoj, Funkcitpa objektkonstruilo, duvalenta ennovesprimo)\
    por difini konstruilo de variablajn argumentojn.
    #Method or constructor "{0}" must be static with the signature \
    #"(Context cx, Object[] args, Function ctorObj, boolean inNewExpr)" \
    #to define a variable arguments constructor.

msg.varargs.fun =\
    Metodo "{0}" statika signendas kun\(Konteksttipa kono, Skriptebla ĉiaĵo, Objekttipaj[] argumentoj, Funkcitpa funkcaĵo)\
    por difini funkctio de variablajn argumentojn.
    #Method "{0}" must be static with the signature \
    #"(Context cx, Scriptable thisObj, Object[] args, Function funObj)" \
    #to define a variable arguments function.

msg.incompat.call =\
    Metodo "{0}" vokita pro malkongrua objekto\
    #Method "{0}" called on incompatible object.

msg.bad.parms =\
    Nekongrutipa pramatero "{0}" en metodo "{1}".
    #Unsupported parameter type "{0}" in method "{1}".

msg.bad.method.return =\
    Nekongrua reŝalttipa pramatero "{0}" en metodo "{1}".
    #Unsupported return type "{0}" in method "{1}".

msg.bad.ctor.return =\
    Konstruado de objekto per tipo "{0}" estas malkongrua.
    #Construction of objects of type "{0}" is not supported.

msg.no.overload =\
    Metodo "{0}" okazas plurfoje en la klaso "{1}"
    #Method "{0}" occurs multiple times in class "{1}".

msg.method.not.found =\
    Metodo "{0}" maltrovita en "{1}"
    #Method "{0}" not found in "{1}".
#! Kio estas IR???. "factory" tradukas uzino
#! Vidu http://www.docjar.com/html/api/org/mozilla/Javascript/IRFactory.Java.html
## IRFactory



#! Noto pri "left" kaj "right" en sintakspriskribo : tio ne prave signas la fenomenan strukturon, sed unu de ĝiaj apareblaj formoj. Do bone traduki/esprimi tion, necesas kontekste prav-elektatajn termojn. Sed oni povas remaki ke ĝenerale
#! - “left" (liva) esprimas pasivformo relate al plenumiĝo, t.e. termo kiu finas kun -it-, -at-, -ot-
#! - “right" (dekstra) esprimas aktivformo t.e. termo kiu finas kun  "-ant-”
#
#! Tiukaze, la termo parolas pri tiu "statement" (tradukebla kiel frazo, ordono, instrukcio; propozicio laŭ la komputada leksikno) :
#! for (LeftHandSideExpression in objectExpression) {statement}
#! porĉiu([elektit]ero en [iteraciebl]aro) { frazo }
#! ĉiuade(…){…}
#
#! Do "LeftHandSideExpression" estas iteracia frazero, kiu traktas aktualajn erojn de 
#! iteraciebla esprimo.
#! Kaj la sube "left-hand side of" estas "tipo de elektita ero " aŭ mallongige "elektertipo"
msg.bad.for.in.lhs =\
    Malvalida elektertipo en porĉiua frazo.
    #Invalid left-hand side of for..in loop.

msg.mult.index =\
    Sole unu variablon eblas porĉiua frazo.
    #Only one variable allowed in for..in loop.

#! la klasika traduko de "key" estas "ŝlosilo". Sed uzi "vok-" kiel ĉefvorto anstataŭ 
#! semantike plikongrue priskribas. Kaj oni jam parolas pri memvoka funkcio kaj pri voki funkcio.
#! Do sube, ni parolas de "paro de ilo por voki kaj ĝia asociata valoro", aŭ mallongige
#! "vok-il-par-o"
#! key         value        key-value
#! vokantero    vokatero    vokparero
msg.bad.for.in.destruct =\
    Elektero de porĉiufrazo tipendas dueran vicon por vokerpare kongrui.
    #Left hand side of for..in loop must be an array of length 2 to accept \
    #key/value pair.
    
#! ne-trans-tipo-povi
msg.cant.convert =\
    Netranstippovas "{0}".
    #Can''t convert to type "{0}".

msg.bad.assign.left =\
    Malvalida asignato en asignfrazo.
    #Invalid assignment left-hand side.


#! result/factor/operand/operator/operation estas tradukebla kiel:
#! ┌ rezulto/faktoro/operando/operatoro/operacio
#! │ rezulto/faktoro/operaciendo/operatoro/operacio
#! │ rezulto/faktoro/operaciodateno/operatoro/operacio
#! │ rezulto/faktoro/operaciiganto/operatoro/operacio
#! │ rezulto/operacieco/operaciato/operacisimbolo/operacio
#! │ rezulto/operacieco/operaciato/operacileksemo/operacio
#! │ operaciigo/operacieco/operaciato/operaciilo/operacio
#! └ operaciaĵo/operacieco/operaciato/operaciilo/operacio
#!  - liveraĵo/parametro/argumento/funkcinomo/funkcio
#! ┌ bildcelero/bildigeco/bildfontero/bildigilo/bildigo
#! └ bildo/bildeco/bildito/bildilo/bildigo
#
#! "decrement" tradukeblas je "dekrement-",
#! sed "increment" tradukas jene : (al)krementi, plusigi, adicii, aldoni, sinsekvigi
#! do oni povus prefiksi tiujn kun [mal|kontraŭ]
#! ekzemple, radikigi je sekv-, "[antău|post]sinkontraŭsekvilo" povas nomi la "--x" kaj "x--" bildiloj.
#! http://joostje.komputilo.org/KompLeks/html/KR.html#KREMENTI
#! 
#! Kun "sekv-" oni povas konstrui :
#! increment     alkrementi    iteracii        alsekvi
#! decrement     dekrementi    kontrauiteracii    elsekvi     
#! interation     laŭkremento    iteracio        sekvadilo      vicado
#! iterator    laŭkrementilo    iteraciilo     sekveblaĵo     vico
#! iterator    laŭciklilo    ciklilo         sekvciklaĵo     vico
#!
#!         termo mem    
#! while ->    dum
#! for ->     por
#! do ->    
#! 
#! 
msg.bad.decr =\
    Malvalida dekrementa bildanto.
    #Invalid decrement operand.

msg.bad.incr =\
    Malvalida dekrementa bildanto
    #Invalid increment operand.

msg.bad.yield =\
    liverado enfunkciendas.
    #yield must be in a function.

msg.yield.parenthesized =\
    liveresprimo interkrampendas.
    #yield expression must be parenthesized.

#! "Native" estas ofte tradukita kiel "indiĝena"
#! sed depende de konteksto bazo, fondo, fundo, kerno, soklo kaj simile povas esti pli kongrua
#! Ofte tiu temas pri "laŭ-baz-sistem-aĵo", aŭ mallongige "laŭbazâjo".
#! Native (thing) -> laŭbaz(um)o

#! Laŭ konteksto
#! Global -> malloka
#! Global -> gênerala

# laŭbazmallokaĵo
## NativeGlobal
msg.cant.call.indirect =\
    Funkcio "{0}" direktvokendas, tio malpermesas alinomitan funkcvokadon.
    #Function "{0}" must be called directly, and not by way of a \
    #function of another name.

#! primitive tradukas kiel malderivaĵo aŭ primitiva laŭ "Lexique des Termes Scientifique - Français - Espéranto" (LTS)
#! oni povus paroli pri "sen-pra-tipa", ĉar tiu estas pri objekto kies tipo ne havas praaron.
#! "primitive" -> senpratipa
#! intend -> celi
msg.eval.nonstring =\
    Vokado de taksu() kun io ajn alia ke iu senpratipa ĉenvaloro nur liveros la valoron. \
Ĉu ĝi estas tio, kion vi celis?
    #Calling eval() with anything other than a primitive string value will \
    #simply return the value. Is this what you intended?

msg.eval.nonstring.strict =\
    Vokado de taksu() kun io ajn alia ke senpratipa ĉenvaloro malpermitiĝas striktmodon.
    #Calling eval() with anything other than a primitive string value is not \
    #allowed in strict mode.

msg.bad.destruct.op =\
    Malvalida disstruktura asignato bildanto
    #Invalid destructuring assignment operator

# laŭbazvoko
## NativeCall
msg.only.from.new =\
    "{0}" vokendas de novesprimo.
    #"{0}" may only be invoked from a "new" expression.

msg.deprec.ctor =\
    La "{0}" konstruilo estas neplutaŭgonta.
    #The "{0}" constructor is deprecated.

# laŭbazfunkcio
## NativeFunction
msg.no.function.ref.found =\
    Neniu fonto trovita por trakduki fontsigno {0}
    #no source found to decompile function reference {0}

msg.arg.isnt.array =\
    Dua argumento de Funkctipo.prototipo.apliku tipendas aran
    #second argument to Function.prototype.apply must be an array

# laŭbazmallokaĵo
## NativeGlobal
msg.bad.esc.mask =\
    Malvalida eskaposignomasko
    #invalid string escape mask

# laŭbazjavklaso
## NativeJavaClass

#! instance -> klasano/tipano
#! interface estas tradukebla kiel interfaco aŭ konektoloko
msg.cant.instantiate =\
    aĵigeraro ({0}): klaso {1} estas konektoloka aŭ abstrakta
    #error instantiating ({0}): class {1} is interface or abstract

msg.bad.ctor.sig =\
    Trovis konstruilon kun malkongrua signaturo: {0} vokanta {1} kun signaturo {2}
    #Found constructor with wrong signature: \
    #{0} calling {1} with signature {2}

msg.not.Java.obj =\
    klaselsignu() kongruendas Javaobjektan.
    #Expected argument to getClass() to be a Java object.

msg.no.Java.ctor =\
    Javakonstruilo de "{0}" kun argumentoj "{1}" maltrovita.
    #Java constructor for "{0}" with arguments "{1}" not found.

# laŭbazjavmetodo
## NativeJavaMethod
msg.method.ambiguous =\
    Elektado de Java metodo  {0}.{1}, kiu kongruas kun Javasckriptaj argumenttipoj ({2}) \
estas malpreciza; la elekteblaj metodoj estas: {3}
    #The choice of Java method {0}.{1} matching JavaScript argument types ({2}) is ambiguous; \
    #candidate methods are: {3}

msg.constructor.ambiguous =\
    Elektado de Java konstruilo  {0}, kiu kongruas kun Javasckriptaj argumenttipoj ({1}) \
estas malpreciza; la elekteblaj konstruilo estas: {2}
    #The choice of Java constructor {0} matching JavaScript argument types ({1}) is ambiguous; \
    #candidate constructors are: {2}

# laŭbazjavobjekto
## NativeJavaObject
msg.conversion.not.allowed =\
    Transtipado de {0} al {1} ne eblas.
    #Cannot convert {0} to {1}

msg.no.empty.interface.conversion =\
    Transtipado de {0} al konektloka {1} ne eblas sen metodoj.
    #Cannot convert {0} to interface {1} with no methods

#! "signature" ->distingsigno
msg.no.function.interface.conversion =\
    Transtipado de funkcio {0} al konektloko ne eblas ĉar ĝi enhvas \
malsamdistingsignajn metodojn
    #Cannot convert function {0} to interface since it contains methods with \
    #different signatures

# laŭbazjavpako
## NativeJavaPackage
msg.not.classloader =\
    Konstruilo de "pakaĵoj" atendas argumentojn, kiu tipo estas Java.lang.Classloader
    #Constructor for "Packages" expects argument of type Java.lang.Classloader

# laŭbazregulesprimo
## NativeRegExp
msg.bad.quant =\
    Mavalida kvantilo {0}
    #Invalid quantifier {0}

# large: granda
# back reference: retrofontsigno
msg.overlarge.backref =\
    Eksterlimita granda retrofontsigno {0}
    #Overly large back reference {0}

msg.overlarge.min =\
    Eksterlimita minumumo {0}
    #Overly large minimum {0}

msg.overlarge.max =\
    Eksterlimita maksimumo {0}
    #Overly large maximum {0}

msg.zero.quant =\
    Nula kvantilo {0}
    #Zero quantifier {0}

# ĉu "subi" estas la bona termo? aŭ ĉu tio pli kutime alie esprimiĝas?
msg.max.lt.min =\
    Maksimumo {0} subminimumas
    #Maximum {0} less than minimum

msg.unterm.quant =\
    Malfinita kvantilo {0}
    #Unterminated quantifier {0}

# enkrampfrazo
## parenthetical 
msg.unterm.paren =\
    Malfinita krampfrazo {0}
    #Unterminated parenthetical {0}

msg.unterm.class =\
    Malfinita signa klaso {0}
    #Unterminated character class {0}

# "range"-> intervalo
msg.bad.range =\
    Malvalida intervalo en signklaso.
    #Invalid range in character class.

# Laŭ konteksto : 
# Trailing -> fina
# Trailing ->ekstremaĵa
# Trailing ->postsekvanta
msg.trail.backslash =\
    Fina \\ en regula esprimo.
    #Trailing \\ in regular expression.

msg.re.unmatched.right.paren =\
    Malkonguata ) en regula esprimo.
    #unmatched ) in regular expression.

msg.no.regexp =\
    Raciesprimo estas maldisponebla.
    #Regular expressions are not available.

msg.bad.backref =\
    retrofontsigno superas nombron de kaptita kromo.
    #back-reference exceeds number of capturing parentheses.

msg.bad.regexp.compile =\
    Nur unu argumento estas specifiebla kiam la unua argumento de \
    regulesprimo.pratipo.traduku estas regulesprimobjekto.
    #Only one argument may be specified if the first argument to \
    #RegExp.prototype.compile is a RegExp object.

# Parser
# sintaks-analizilo
msg.got.syntax.errors = \
    Tradukado produktis {0} sintakseraroj.
    #Compilation produced {0} syntax errors.

msg.var.redecl =\
    tiperaro: redeklaro de variablo {0}.
    #TypeError: redeclaration of var {0}.

msg.const.redecl =\
    tiperaro: redeklaro de konstato {0}.
    #TypeError: redeclaration of const {0}.
    
msg.let.redecl =\
    tiperaro: redeklaro de variablo {0}.
    #TypeError: redeclaration of variable {0}.

msg.parm.redecl =\
    tiperaro: redeklaro de formala parametro {0}.
    #TypeError: redeclaration of formal parameter {0}.

msg.fn.redecl =\
    tiperaro: redeklaro de funkcio {0}.
    #TypeError: redeclaration of function {0}.

# "let" -> signu
msg.let.decl.not.in.block =\
    sintakseraro: nerektinga "signu"-deklarado
    SyntaxError: let declaration not directly within block

# nodotransformilo
## NodeTransformer

msg.dup.label =\
    duobligita marko
    #duplicated label

msg.undef.label =\
    nedifinita marko
    #undefined label

# break?
msg.bad.break =\
    nemarkita elirejo devas esti en interacio aŭ enŝalto
    #unlabelled break must be inside loop or switch

msg.continue.outside =\
    sekvitiracu devas esti en iteracio
    #continue must be inside loop

msg.continue.nonloop =\
    sekvitiracu nur povas uzi markojn de iteracideklaroj
    continue can only use labeles of iteration statements

#! "keyword" estas tradicie tradukita "ŝlosilvorto", sed tie "ŝloso" ne signas iun ajn
#! konkretan aĵon tie ĉi.
#! Pli kontekste senca traduko parolus pri "vorta elemento kiu aperas en la la gramatika difino de #! la programlingvo".
#! La ĉefaj vortoj de tiu ĉi difino estas certe "gramatika" kaj "elemento". Do "gramatikero" 
#! certe pli bone indikas la priparolantan aĵon ol "ŝlosilvorto".
#! Alia eblo estas paroli pri "ĉefaj/bazaj simbolaj elementoj de la programlingvo", bazlingveroj,
#! bazeroj, bazsimboloj, aŭ bazsigno. Notu ke kutime oni parolas pri "simboltabelo".
#! keyword -> bazsigno

#! Line terminator/end of line marker/EOL etc. -> linifinigilo 
#! File terminator/end of filemarker/EOF etc. -> dosierfinigilo 

msg.bad.throw.eol =\
    linifinigilo estas malpermisita inter "ĵetu" bazsimbolo kaj ĵetesprimo.
    #Line terminator is not allowed between the throw keyword and throw \
    #expression.

msg.no.paren.parms =\
    Mankanta apertanta krampo "(" antaŭ funkciparametroj.
    #missing ( before function parameters.

msg.no.parm =\
    Mankanta formala parametro
    #missing formal parameter

msg.no.paren.after.parms =\
    Mankanta malapertanta krampo ")" post formalaj parametroj.
    #missing ) after formal parameters

# difinujo
## body
msg.no.brace.body =\
    Mankanta apertanta kunigkrampo '{' antaŭ la funkcia difinujo
    #missing '{' before function body

msg.no.brace.after.body =\
    Mankanta kunigkromo "}" post la funkcia difinujo
    #missing } after function body

msg.no.paren.cond =\
    Mankanta apertanta  krampo "(" antaŭ kondiĉo.
    #missing ( before condition

msg.no.paren.after.cond =\
    Mankanta malapertanta kromo ")" post
    #missing ) after condition

msg.no.semi.stmt =\
    Mankanta punktokomo ";" antaŭ frazo
    #missing ; before statement

# tiu operatoro permisas aliri elementojn de objekto, do tiu estas "ilo kiu permisas al-iri ero", aŭ "eralirilo"
msg.no.name.after.dot =\
    mankanta nomo post eralirila operatoro "."
    #missing name after . operator

msg.no.name.after.coloncolon =\
    mankanta nomo post eraligila operatoro "::"
    #missing name after :: operator

msg.no.name.after.dotdot =\
    Mankanta nomo post kunĉeniga operatoro ".."
    #missing name after .. operator

msg.no.name.after.xmlAttr =\
    mankanta nomo post .@
    #missing name after .@

# enŝalti
## switch
msg.no.bracket.index =\
    Mankanta malapertanta rektkrampo ] de indeksesprimo
    #missing ] in index expression

msg.no.paren.switch =\
    Mankanta ( antaŭ enŝaltesprimo
    #missing ( before switch expression

msg.no.paren.after.switch =\
    mankanta ) post enŝaltesprimo
    #missing ) after switch expression

msg.no.brace.switch =\
    mankanta '{' antaŭ enŝultujo
    #missing '{' before switch body

msg.bad.switch =\
    Malvalida enŝaltfrazo
    #invalid switch statement

msg.no.colon.case =\
    mankanta dupunkto ":" post kazesprimo
    #missing : after case expression

msg.double.switch.default =\
    duobla "defaŭlte" marko en la enŝaltfrazo
    #double default label in the switch statement

msg.no.while.do =\
    Mankanta "dum" post la interna parto de finkondiĉa iteraciujo
    #missing while after do-loop body

msg.no.paren.for =\
    Mankanta aperta kromo "(" post "por"
    missing ( after for

# initializer -> ek- -il- -o
msg.no.semi.for =\
    mankanta ";" post por-cickla ekilo
    #missing ; after for-loop initializer

msg.no.semi.for.cond =\
    mankanta ";" post kondiĉo de ĉiuera iteracio 
    #missing ; after for-loop condition
    
msg.in.after.for.name =\
    mankanta "en" post "por"
    #missing in after for
#! control -> stir-
msg.no.paren.for.ctrl =\
    mankanta ")" post stirilo de ĉiuera iteracio 
    #missing ) after for-loop control

msg.no.paren.with =\
    mankanta "(" antaŭ objekto de kun-frazo
    #missing ( before with-statement object

msg.no.paren.after.with =\
    mankanta ")" post objekto de kun-frazo 
    #missing ) after with-statement object

msg.no.paren.after.let =\
    mankanta "(" post "signu"
    #missing ( after let

msg.no.paren.let =\
    mankanta ")" post variablolisto
    #missing ) after variable list

msg.no.curly.let =\
    mankanta "}" post "signu"-frazo
    #missing } after let statement

# return -> (pri)reŝalt/i
msg.bad.return =\
    malvalida reŝalto
    #invalid return

msg.no.brace.block =\
    mankanta "}" en kunmetita frazo
    #missing } in compound statement

msg.bad.label =\
    malvalida marko
    #invalid label

msg.bad.var =\
    mankanta signo de variablo
    missing variable name

msg.bad.var.init =\
    malvalida variablo ekado
    #invalid variable initialization

msg.no.colon.cond =\
    mankanta ":" en kondiĉa esprimo
    #missing : in conditional expression

msg.no.paren.arg =\
    mankanta ")" post argumentlisto
    #missing ) after argument list

msg.no.bracket.arg =\
    mankanta "]" post erlisto
    #missing ] after element list

#! id(entifier) -> identifi -il- -o
#! sam- asocii -il- o : samasociilo
#! kunigi -> samkunigilo
## id
msg.bad.prop =\
    malvalida eca identifilo
    #invalid property id

msg.no.colon.prop =\
    mankanta la dupunkto ":" post eca identifilo
    #missing : after property id
#! Tradukdecido
#! Laŭ konteksto de krampo,  kaj simile :
#! "open/close" -> "aperti/malaperti"
#! 
#! Vidu http://en.lernu.net/komunikado/forumo/temo.php?t=8452&p=4
#! Krome tiu faras plej laŭtempanaliza senco de unue fari kaj poste malfari ol la inversa.
msg.no.brace.prop =\
    Mankanta malapertanta kuniga krampo "}" post eca listo
    #missing } after property list
# enkrampfrazo
## parenthetical -
msg.no.paren =\
    mankanta ")" en kromeco
    #missing ) in parenthetical

msg.reserved.id =\
    identifilo estas rezervita vorto
    #identifier is a reserved word

msg.no.paren.catch =\
    mankanta "(" antaŭ elflankŝaltinga kondicio
    #missing ( before catch-block condition

msg.bad.catchcond =\
    malvalida elflankŝaltinga kondicio
    #invalid catch block condition

msg.catch.unreachable =\
    iu ajn elflankŝalta frazparto, kiu sekvantas maleciga elflankŝalto estas malatingebla
    #any catch clauses following an unqualified catch are unreachable

msg.no.brace.try =\
    mankanta '{' antaŭ flankŝalteblingo
    #missing '{' before try block

msg.no.brace.catchblock =\
    mankanta '{' antaŭ elflankŝaltingujo
    #missing '{' before catch-block body

msg.try.no.catchfinally =\
    flankŝalteblo sen elflankŝalto aŭ finflankŝalto
    #''try'' without ''catch'' or ''finally''

msg.no.return.value =\
    funkcio {0} ne ĉiam prireŝaltu valoron.
#function {0} does not always return a value


#! anonymous -> sennoma
msg.anon.no.return.value =\
  sennoma funkcio ne ĉiam prireŝaltu valoron
  #anonymous function does not always return a value

msg.return.inconsistent =\
  reŝalta frazo malkongruas kun antaŭ uzado
  #return statement is inconsistent with previous usage

msg.generator.returns =\
  tiperaro: generila funkcio {0} prireŝaltu valoron
  #TypeError: generator function {0} returns a value

msg.anon.generator.returns =\
  tiperaro: sennoma generila funkcio liveras valoron.
  #TypeError: anonymous generator function returns a value

msg.syntax =\
    sintakseraro
    #syntax error

msg.unexpected.eof =\
    Malantenta dosierfino
    #Unexpected end of file

#! legal" supozas tro leĝfaka vortprovizo. Lasu leĝojn por leĝaforj.
#! Plej ofe, frazoj temas pri kongrua aŭ malkongrua rilato inter arbitra arta regulo kaj okazaĵo
#! Do, temas pri "regulo" kaj "kongrui", kaj laŭ konteksto:
#! "legal" -> kongrua
#! "legal" -> regula
#! "legal" -> laŭ(um)a 
# ??? ĉu "regulo" tradukas "rule", kiel arbitra gramatika principo
msg.XML.bad.form =\
    malkongrua fomita XMLa sintakso
    #illegally formed XML syntax
#! Runtime :
#! interpretilo         procezilo     rulilo
#! interprettempa    proceztempa    rultempa
#! http://komputeko.net/index_en.php?vorto=runtime
#! http://joostje.komputilo.org/KompLeks/html/RI.html#RULTEMPA 
msg.XML.not.available =\
    XMLa rulilo nehavebla
    #XML runtime not available

#! La jam uzadaj ebloj estas rikuro, rekurso, rikursio, rikuro
#! Sed semantike, tio estas pri "meminga objekto", kaj pli precize ĉi-tie "memvoka funkcio"
#! recursion -> memvokado
#! Vidu ankaŭ https://eo.wikipedia.org/wiki/Rikuro 
msg.too.deep.parser.recursion =\
    Troprofunda memvokado dum sintaksanalizo
    #Too deep recursion while parsing

msg.no.side.effects =\
    Kodo ne havas kromefiko
    #Code has no side effects

msg.extra.trailing.comma =\
    Finkomo malkongruas je ECMA-262a ekilo de objekto. 
    #Trailing comma is not legal in an ECMA-262 object initializer

msg.equal.as.assign =\
    Ĉu okuris mistajpon de asignaĵo (=) anstataŭ testo (==)?
    #Test for equality (==) mistyped as assignment (=)?

msg.var.hides.arg =\
    Variablo {0} kaŝas argumenton
    #Variable {0} hides argument

msg.destruct.assign.no.init =\
    Mankanta egalsigno "=" en disstruckranta deklaro
    #Missing = in destructuring declaration

# skriptrulilo
## ScriptRuntime
msg.no.properties =\
    {0} ne havas ecojn.
    #{0} has no properties.

msg.invalid.iterator =\
    Nevalida ciklilo valoro
    #Invalid iterator value

msg.iterator.primitive =\
    __ciklilo__ liveris senpratipan voloron
    __iterator__ returned a primitive value

msg.assn.create.strict =\
    Asignaĵo al nedeklarita variablo {0}
    #Assignment to undeclared variable {0}

#! Tradukdecido
#! "Reference" tradukeblas per "referenco" kaj "fontindiko".
#! Kaj indiko estas sinonimo de "antaŭsigno".
#! Do ni povus uzi "fontantaŭsigno" se ni volus esti kaj plejpreciza, kaj plejradikekonomia.
#! Ja "signo" estas jam multe uzita en aliaj tradukproponoj por emfazi la rilatojn inter nocioj.
#! Sed ankaŭ la elektaj termoj mallongendu, do la elektita termo estas "fontsigno".
#! "Reference" -> fontsigno
#!
#! Notu ankaŭ ke "fontsigno" kaj "referenco" ambaŭ ennombras 9 literoj.
#! Inverse "difini" (6 literoj) estas mallonga ol "persignigi" (10 literoj) aŭ eĉ "persigni" (8 literoj). 
msg.ref.undefined.prop =\
    Fontsigno al maldifinita eco "{0}"
    #Reference to undefined property "{0}"

msg.prop.not.found =\
    Netrovita eco {0}.
    #Property {0} not found.

#! kiam temas pri ecoj (objektaj atribuoj):
#! "getter/setter" -> "ecelilo/ecalilo"
#! kiam temas pri simpla variablo:
#! "getter/setter" -> "elsignilo/alsignilo"
#! "get/set" -> "elsigno/alsigno", kiel la konteksto estas pri aliro de eco.
#! Kiam la konteksto estas asignfrazo (kiel "a=0"), uzendu je "asigni".
msg.set.prop.no.setter =\
    Nealsignebla eco {0} kiu nur enhavas ecelilon.
    #Cannot set property {0} that has only a getter.

msg.invalid.type =\
    Nevalida Javaskripta valoro por tipo {0}
    #Invalid JavaScript value of type {0}

#! primitive -> senpratipa
msg.primitive.expected =\
    Atendu senpratipan tipon (ricevis {0} anstataŭ)
    #Primitive type expected (had {0} instead)

msg.namespace.expected =\
    Atendu nomspacan objekton live de la regiona operatoro "::" (okazis {0} anstataŭ)
    #Namespace object expected to left of :: (found {0} instead)

#! convert/cast/transtyping -> transtip/i
msg.null.to.object =\
    Nepermisita transtipado de senvalora al objekta.
    #Cannot convert null to an object.

msg.undef.to.object =\
Nepermisita transtipado de nedifinita al objekta.
    #Cannot convert undefined to an object.

msg.cyclic.value =\
    Nepermisita cikla valoro je {0}.
    #Cyclic {0} value not allowed.

msg.is.not.defined =\
    "{0}" estas nedifinita. 
    #"{0}" is not defined.

#! Laŭ dosier-mastrum-konteksto, traduku "read/write/open/close"
#! kiel eliri/eniri/ekirebligi/irebleksig (ek-ir-ebl-igi, ir-ebl-eks-igi).
#! Laŭ konteksto pri aliriloj de eco , traduku "read/write/create/delete
#! kiel elsigni/alsigni/eksigni/forsigni (ek-signi, for-signi)
#! Notu ke eks-signi povus esti pli preciza sed "ekssigni" tro proksimas "eksigni"
msg.undef.prop.read =\
    Malelsignebla eco "{1}" el {0}
    #Cannot read property "{1}" from {0}

msg.undef.prop.write =\
    Malensignebla eco "{1}" el {0} al "{2}"
    #Cannot set property "{1}" of {0} to "{2}"

msg.undef.prop.delete =\
    Malforsignebla eco "{1}" el {0}
    #Cannot delete property "{1}" of {0}

#! Etimologie, "method" kunigas μετά (laŭ-, tra-, trans-) kaj ὁδός (vojo), kaj signifas "peli vojo". 
#! Tiu diris, ĉi-tie metodo nomas funkciajn enhavojn de objektoj, kiel "property" nomas atributajn enhavojn de objektoj. Kaj kiel por la tradukdecido de "property" per "eco", "metodo" estos tradukita, tie kontekste, per "ilo".
#! Tiu kongruas kun la antaŭdecido de traduki "get/set" per "elsignif-il-o/alsignif-il-o"
#! Kaj semantike, tiu kungruas ĉar metodo estas ilo per tiu, kiu oni interagas kun objekto
#! "method" -> ilo

msg.undef.method.call =\
    Malvokebla ilo je "{1}" de {0}
    #Cannot call method "{1}" of {0}

msg.undef.with =\
    Malpermisita uzado de "kun" por {0}
    #Cannot apply "with" to {0}

msg.isnt.function =\
    {0} maltiptaugas funkcion, tiu tipas je {1}
    #{0} is not a function, it is {1}.

msg.isnt.function.in =\
    Malvokebla eco {0} en objeko je {1}. Tiu maltiptaŭgas funkcion, tiu tipas je "{2}".
    #Cannot call property {0} in object {1}. It is not a function, it is "{2}".

msg.function.not.found =\
    Maltrovita funkcio je {0}.
    #Cannot find function {0}.

msg.function.not.found.in =\
    Maltrovebla funkcio {0} en objekto je {1}.
    #Cannot find function {0} in object {1}.

msg.isnt.xml.object =\
    {0} maltiptaŭgas XML-objekton.
    #{0} is not an xml object.

msg.no.ref.to.get =\
    {0} ne estas fontsigno por elsigni fontsignan valoron.
    #{0} is not a reference to read reference value.

msg.no.ref.to.set =\
{0} ne estas fontsigno por alsigni fontsignan valoron al {1}.
    #{0} is not a reference to set reference value to {1}.

msg.no.ref.from.function =\
    Funkcio {0} neuzeblas kiel asignata signo de asignado aŭ kiel operando de inkrementa \
    aŭ dekrementa operatoro. 
    #Function {0} can not be used as the left-hand side of assignment \
    #or as an operand of ++ or -- operator.

msg.bad.default.value =\
    defaŭltvalordonu() metodo de Objekto liveris objekton.
    #Object''s getDefaultValue() method returned an object.

#! instanceof  -> klas-ul-taŭgu
msg.instanceof.not.object = \
    "klasultaŭgu" ne estas uzebla kun neobjektipo. 
    #Can''t use instanceof on a non-object.

msg.instanceof.bad.prototype = \
    "prototipo"-eco de {0} maltiptaŭgas objekton.
    #''prototype'' property of {0} is not an object.

msg.bad.radix = \
    Malkongrua nombra bazo {0}.
    #illegal radix {0}.

# Skripteblobjekto
## ScriptableObject
msg.default.value =\
    Netroveble defaŭlta valoro de objekto.
    #Cannot find default value for object.

msg.zero.arg.ctor =\
    klaso "{0}" ne estas ŝarĝebla, kiu ne havas senparametro kontruilo.
    #Cannot load class "{0}" which has no zero-parameter constructor.

duplicate.defineClass.name =\
    Nevalida metodo "{0}": nomo "{1}" jam estas uzita. 
    #Invalid method "{0}": name "{1}" is already in use.

msg.ctor.multiple.parms =\
    Ne povas difini konstruilo aŭ klaso {0} kiel plej ol unu konstruilo havas plurajn parametrojn.
    #Can''t define constructor or class {0} since more than one \
    #constructor has multiple parameters.

#! extend ->klasidi/tipidi

msg.extend.scriptable =\
    {0} tipidendas "skripteblobjekto" por difini econ je {1}.
    #{0} must extend ScriptableObject in order to define property {1}.

msg.bad.getter.parms =\
    Por difini econ, ecelilo je {0} enhavendas nul parametron aŭ nur unu skripteblobjektan \
parametron.
    #In order to define a property, getter {0} must have zero parameters \
    #or a single ScriptableObject parameter.

msg.obj.getter.parms =\
    Atendas klaskomuna aŭ delega eecilo {0} por preni scripteblobjektan parametron.
    #Expected static or delegated getter {0} to take a ScriptableObject parameter.

msg.getter.static =\
    ecelilo kaj ecalilo devi ambaŭ esti klaskomuna aŭ neklaskomuna.
    #Getter and setter must both be static or neither be static.

msg.setter.return =\
    ecalilo devas enhavi vakan livertipon: {0}
    #Setter must have void return type: {0}

msg.setter2.parms =\
    Duparametra ecalilo devas preni skripteblobjekto kiel unua parametro.
    #Two-parameter setter must take a ScriptableObject as its first parameter.

msg.setter1.parms =\
    Atendis unuopa parametro de ecalilo por {0}
    #Expected single parameter setter for {0}

msg.setter2.expected =\
    Atendis klaskomuna aŭ delega ecalilo {0}, kiu prenas du parametrojn.
    #Expected static or delegated setter {0} to take two parameters.

msg.setter.parms =\
    Atendis aŭ unu parametro aŭ du parametroj por ecalilo.
    #Expected either one or two parameters for setter.

msg.setter.bad.type =\
    Malĝusta parametrotipo "{0}" por ecalilo "{1}".
    #Unsupported parameter type "{0}" in setter "{1}".

#! "to seal" -> sigeli, definitivigi, finitigi nealiebligi [ne-ali-ebl-igi], neŝanĝebligi, neevoluebligi
#! Tradukdecido : finit(ig)-
msg.add.sealed =\
    Malpermisita aldono al finita objekto: {0}.
    #Cannot add a property to a sealed object: {0}.

msg.remove.sealed =\
    Malpermisita forigo de eco el finita objekto: {0}.
    #Cannot remove a property from a sealed object: {0}.

msg.modify.sealed =\
    Malpermisita modifo de eco el finita objekto: {0}.
    #Cannot modify a property of a sealed object: {0}.

msg.modify.readonly =\
    Malpermisita modifo de nurelsignebla eco: {0}
    #Cannot modify readonly property: {0}.

# erfluoj
## TokenStream
msg.missing.exponent =\
    Mankanta eksponento
    #missing exponent

msg.caught.nfe =\
    nombrforma eraro
    #number format error

msg.unterminated.string.lit =\
    nefinita ĉena laŭlitero
    #unterminated string literal

msg.unterminated.comment =\
    nefinita komento
    #unterminated comment

msg.unterminated.re.lit =\
    nefinita regulesprima litero laŭsigno
    #unterminated regular expression literal

msg.invalid.re.flag =\
    malvalida indikilo post regulesprimo
    #invalid flag after regular expression

# kiel traduki input/output ?
msg.no.re.input.for =\
    neniu enigaĵo por {0}
    #no input for {0}

msg.illegal.character =\
    malkongrua signo
    #illegal character

#! escape -> kodŝanĝa signo
msg.invalid.escape =\
    malvalida unikodo kodŝanĝsigna sinsekvo
    #invalid Unicode escape sequence

# frazo
## statement 
msg.bad.namespace =\
    malvalida deklaro de defaŭlta nomspaca frazo. \
    Sintakso estas: defaŭlta xmla nomspaco = ESPRIMO;
    #not a valid default namespace statement. \
    #Syntax is: default xml namespace = EXPRESSION;

#! Laŭ konteksto
#! token -> ero / parto [tokenizer : vorta dis(part)igilo]
#! token -> ĵetono [security token : sekuriga ĵetono] / stafeto [token ring : stafetringo]
#! token -> simbolo
#! http://komputeko.net/index_en.php?vorto=token
#! http://joostje.komputilo.org/KompLeks/html/SI.html#SIMBOLO
#! http://joostje.komputilo.org/KompLeks/html/JX.html#JxETONO

#! Stream -> fluo
#! Warning -> averto

# Avertoj pri erfluoj
## TokensStream warnings

msg.bad.octal.literal =\
    malkongrua okuma  laŭlitera cifero {0}; interpretu ĝin kiel dekuma ĉifro
    #illegal octal literal digit {0}; interpreting it as a decimal digit

msg.reserved.keyword =\
    malregula uzado de estonteca rezervita bazsimbolo {0};
    #illegal usage of future reserved keyword {0}; interpreting it as ordinary identifier

#! LiveConnect temas pri pontoj inter Java kaj Javaskripto, tio estas "trans-ĵav-il-aro"
# transĵaveraroj 
## LiveConnect errors

msg.Java.internal.field.type =\
    Ena eraro: transtipado de {0} por asigni al {1} je {2} malfunkciis.
    #Internal error: type conversion of {0} to assign to {1} on {2} failed.

msg.Java.conversion.implicit_method =\
    Ne povas trovi transtipilan metodon "{0}" je klaso {1}.
    #Can''t find converter method "{0}" on class {1}.

msg.Java.method.assign =\
    Java metodo "{0}" malalsignebla.
    #Java method "{0}" cannot be assigned to.

# memalirebla/idalirebla kampo 
## access private/protected field
msg.Java.internal.private =\
    Ena eraro: provo aliri memalireblan/idalireblan kampon "{0}".
    #Internal error: attempt to access private/protected field "{0}".

msg.Java.no_such_method =\
    Ne povas trovi metodo {0}.
    #Can''t find method {0}.

msg.script.is.not.constructor =\
    Skriptobjektoj ne estas konstruiloj.
    #Script objects are not constructors.

msg.nonJava.method =\
    Java metodo "{0}" elvokita kun {1} kiel "tiu-ĉi" valoro, kiun ne povas esti konverti al Java tipo {2}.
    #Java method "{0}" was invoked with {1} as "this" value that can not be converted to Java type {2}.

#! instance -> klasano
#! instance -> tipano
#! field -> kampo

msg.Java.member.not.found =\
    Java klaso "{0}" ne havas publikan instancan kampon aŭ metodon nomitan "{1}".
    #Java class "{0}" has no public instance field or method named "{1}".

#! array -> vico kiam estas nur unu dimensio 
#! array -> tabelo ĝenerale
msg.Java.array.index.out.of.bounds =\
    Tabelindico {0} eksteriras la intervalo [0..{1}].
    #Array index {0} is out of bounds [0..{1}].

msg.Java.array.member.not.found =\
    Java tabeloj ne havas eksteralirajn klasulajn kampojn aŭ iloj nomitajn "{0}".
    #Java arrays have no public instance fields or methods named "{0}".

msg.pkg.int =\
    Java pakaĝnomoj ne povas esti numbroj.
    #Java package names may not be numbers.

msg.access.prohibited =\
    Aliro al Java klaso "{0}" malpermisita.
    #Access to Java class "{0}" is prohibited.

# importil-supr-nivelo
## ImporterTopLevel
msg.ambig.import =\
    Dubsignifa importo: "{0}" kaj "{1}".
    #Ambiguous import: "{0}" and and "{1}".

msg.not.pkg =\
    Funkcio "pakenportu" vokendas kun pakaĝo; donita "{0}" anstataŭ.  
    #Function importPackage must be called with a package; had "{0}" instead.

msg.not.class =\
    Funkctio "klasenportu" vokendas kun klaso; donita "{0}" anstataŭ.  
    #Function importClass must be called with a class; had "{0}" instead.

msg.not.class.not.pkg =\
    "{0}" estas nek klaso nek pagaĝo.
    #"{0}" is neither a class nor a package.

msg.prop.defined =\
    Ne povas importi "{0}" ĉar eco kun tiu nomo jam estas difinita.
    #Cannot import "{0}" since a property by that name is already defined.

#Javadaptilo
##JavaAdapter
msg.adapter.zero.args =\
    Javadaptilo necesas alemenaŭ unu argumento. 
    #JavaAdapter requires at least one argument.

msg.not.Java.class.arg = \
Argumento {0} ne estas Java klaso: {1}.
#Argument {0} is not Java class: {1}.

#Javadaptilo
##JavaAdapter
msg.only.one.super = \
Nur unu klaso povas esti klaidita per Javadaptilo. Ricevi {0} kaj {1}.
#Only one class may be extended by a JavaAdapter. Had {0} and {1}.

# Tabeloj
## Arrays
msg.arraylength.bad =\
    Malkongrua tabellongo.
    #Inappropriate array length.

# Tabeloj
## Arrays
#! exceed -> superi
#! support -> apog/i
#! unsupported (type, etc.)-> malkungrua (tipo, ktp.)
msg.arraylength.too.big =\
    tabellongo {0} superas limon de apogita kapacito
    #Array length {0} exceeds supported capacity limit.

# URI
## URI
msg.bad.uri =\
    Misformita URI sekvâjo.
    #Malformed URI sequence.

# Nombro
## Number

#! ekster- intervalo iri
msg.bad.precision =\
    Precizo {0} eksterintervaliras.
    #Precision {0} out of range.

#! generate -> generi 
#! send (to function) -> provizi (al funkcio)
#! send (through network) -> alŝuti

# laŭbazgenerilo
## NativeGenerator
msg.send.newborn =\
  Provu provizi valoron al novula generilo
  #Attempt to send value to newborn generator

msg.already.exec.gen =\
    Jam rulanta generilo
    #Already executing generator
    
#! Stop -> halt
#! iterate -> cikli (prefere al "iteracii" aŭ "ripetadi")
#! iteration -> ciklado (prefere al "iteracio", aŭ "ripetado")
#! iterator -> ciklilo (prefere al "iteraciilo")
msg.StopIteration.invalid =\
    haltciklo malŝanĝeblas al arbitra objekto.
    #StopIteration may not be changed to an arbitrary object.

# Interpretilo
## Interpreter
msg.yield.closing =\
  Liverado ekde malapertanta generilo
  #Yield from closing generator

# Nova babilscripta aĵo 
# New Babylscript Stuff
msg.unknown.language.mode =\
  Nelkonata lingva modo
  #Unknown language mode