WiiDatabase Wiki

Modul:DateTime: Unterschied zwischen den Versionen

Modul Diskussion

Modul:DateTime (Quelltext anzeigen)

Version vom 30. September 2020, 00:38 Uhr

12.245 Bytes hinzugefügt ,  30. September 2020
2020-09-30 - Administratoren-Anfrage: https://de.wikipedia.org/w/index.php?title=Wikipedia:Administratoren/Anfragen&diff=204106510&oldid=204105921
(Die Seite wurde neu angelegt: „local DateTime = { serial = "2018-01-24", suite = "DateTime", item = 20652535 } -- Date and time objects loca…“)
 
(2020-09-30 - Administratoren-Anfrage: https://de.wikipedia.org/w/index.php?title=Wikipedia:Administratoren/Anfragen&diff=204106510&oldid=204105921)
Zeile 1: Zeile 1:
local DateTime  = { serial = "2018-01-24",
local DateTime  = { serial = "2020-09-30",
                     suite  = "DateTime",
                     suite  = "DateTime",
                     item  = 20652535 }   -- Date and time objects
                     item  = 20652535 }
-- Date and time objects
local Failsafe  = DateTime
local GlobalMod  = DateTime
local Calc      = { }
local Calc      = { }
local Meta      = { }
local Meta      = { }
Zeile 13: Zeile 16:
                     months4    = { } }
                     months4    = { } }
local MaxYear    = 2099
local MaxYear    = 2099
local Nbsp      = mw.ustring.char( 160 )
local Tab        = mw.ustring.char( 9 )
local Frame
local Frame
DateTime.char = { nbsp = mw.ustring.char( 160 ),
                  tab  = mw.ustring.char( 9 ) }
World.era = { en = { "BC", "AD" } }
World.era = { en = { "BC", "AD" } }
World.monthsAbbr = {  en = { n = 3 }  }
World.monthsAbbr = {  en = { n = 3 }  }
Zeile 104: Zeile 107:
     HST  = -1000    -- Hawaiian Standard Time
     HST  = -1000    -- Hawaiian Standard Time
}
}
local foreignModule = function ( access, advanced, append, alt, alert )
    -- Fetch global module
    -- Precondition:
    --    access    -- string, with name of base module
    --    advanced  -- true, for require(); else mw.loadData()
    --    append    -- string, with subpage part, if any; or false
    --    alt      -- number, of wikidata item of root; or false
    --    alert    -- true, for throwing error on data problem
    -- Postcondition:
    --    Returns whatever, probably table
    -- 2020-01-01
    local storage = access
    local fun, lucky, r
    if advanced then
        fun = require
    else
        fun = mw.loadData
    end
    if append then
        storage = string.format( "%s/%s", storage, append )
    end
    lucky, r = pcall( fun,  "Module:" .. storage )
    if not lucky then
        local suited
        GlobalMod.globalModules = GlobalMod.globalModules or { }
        suited = GlobalMod.globalModules[ access ]
        if not suited  and
          type( alt ) == "number"  and
          alt > 0 then
            suited = string.format( "Q%d", alt )
            suited = mw.wikibase.getSitelink( suited )
            GlobalMod.globalModules[ access ] = suited or true
        end
        if type( suited ) == "string" then
            storage = suited
            if append then
                storage = string.format( "%s/%s", storage, append )
            end
            lucky, r = pcall( fun, storage )
        end
        if not lucky and alert then
            error( "Missing or invalid page: " .. storage )
        end
    end
    return r
end -- foreignModule()




Zeile 125: Zeile 177:
     -- Returns:
     -- Returns:
     --    string, HTML span
     --    string, HTML span
     return string.format( "<span class=\"error\">%s</span>", a )
     local e = mw.html.create( "span" )
                    :addClass( "error" )
                    :wikitext( a )
    return tostring( e )
end -- fault()
end -- fault()


Zeile 261: Zeile 316:
end -- Meta.fiat()
end -- Meta.fiat()
setmetatable( DateTime, Meta.tableL )
setmetatable( DateTime, Meta.tableL )
DateTime.serial = nil
DateTime.serial   = nil
 




Zeile 328: Zeile 382:
                         n    = min + m
                         n    = min + m
                     else    -- dom
                     else    -- dom
                         if adjust.month and adjust.year and  n > 1 and
                         if adjust.month and adjust.year  and
                           adjust.month >= 1  and
                           adjust.month >= 1  and
                           adjust.month <= 12 and
                           adjust.month <= 12 and
                           adjust.year > 1900 then
                           adjust.year > 1900 then
                             max = Calc.months[ adjust.month ]
                             if n > 0 then
                             if adjust.month == 2  and
                                max = Calc.final( adjust )
                              ( adjust.year % 4 ~= 0  or
                                while n > max do
                                adjust.year % 400 == 0 ) then
                                    n = n - max
                                 max = 28
                                    if adjust.month < 12 then
                                        adjust.month = adjust.month + 1
                                    else
                                        adjust.month = 1
                                        adjust.year  = adjust.year + 1
                                    end
                                    max = Calc.final( adjust )
                                end    -- while n <= max
                             else
                                while n < 1 do
                                    if adjust.month == 1 then
                                        adjust.month = 12
                                        adjust.year = adjust.year - 1
                                    else
                                        adjust.month = adjust.month - 1
                                    end
                                    max = Calc.final( adjust )
                                    n  = n + max
                                 end    -- while n < 1
                             end
                             end
                            if n <= max then
                                max = false
                            end
                        end
                        if max then
                            m    = n % 30
                            move = ( n - m )  /  30
                            n    = 1 + m
                         end
                         end
                     end
                     end
 
                end
                    end
                 adjust[ s ] = n
                 adjust[ s ] = n
             end
             end
Zeile 355: Zeile 418:
     end -- for i
     end -- for i
end -- Calc.fair()
end -- Calc.fair()
Calc.final = function ( adjust )
    -- Retrieve number of days in particular month
    -- Parameter:
    --    adjust  -- table, with date specification
    -- Returns:
    --    number, of days in month
    local r = Calc.months[ adjust.month ]
    if adjust.month == 2  and
      ( adjust.year % 4 ~= 0  or
        adjust.year % 400 == 0 ) then
        r = 28
    end
    return r
end -- Calc.final()




Zeile 445: Zeile 525:
         if amount <= 4 then
         if amount <= 4 then
             r.year = tonumber( analyse )
             r.year = tonumber( analyse )
         elseif n == 14 then
         elseif amount == 14 then
             -- timestamp
             -- timestamp
             r.year  = tonumber( analyse:sub(  1, 4 ) )
             r.year  = tonumber( analyse:sub(  1, 4 ) )
             r.month  = tonumber( analyse:sub(  5, 2 ) )
             r.month  = tonumber( analyse:sub(  5, 6 ) )
             r.dom    = tonumber( analyse:sub(  7, 2 ) )
             r.dom    = tonumber( analyse:sub(  7, 8 ) )
             r.hour  = tonumber( analyse:sub(  9, 2 ) )
             r.hour  = tonumber( analyse:sub(  9, 10 ) )
             r.min    = tonumber( analyse:sub( 11, 2 ) )
             r.min    = tonumber( analyse:sub( 11, 12 ) )
             r.sec    = tonumber( analyse:sub( 13, 2 ) )
             r.sec    = tonumber( analyse:sub( 13, 14 ) )
         else
         else
             r = false
             r = false
Zeile 673: Zeile 753:
             if rS:byte( 1, 1 ) == 45 then
             if rS:byte( 1, 1 ) == 45 then
                 local suffix
                 local suffix
                 s = rS:match( "^%-([012][0-9])" )
                 s = rS:match( "^%-([0-3][0-9])" )
                 if s then
                 if s then
                     n  = tonumber( s )
                     n  = tonumber( s )
Zeile 747: Zeile 827:
                         n = #s2
                         n = #s2
                         if n <= 2  and  #s3 == 4 then
                         if n <= 2  and  #s3 == 4 then
                             rO.dom  = tonumber( n )
                             rO.dom  = tonumber( s2 )
                             rO.year = tonumber( s3 )
                             rO.year = tonumber( s3 )
                             rO.dom2 = ( n == 2 )
                             rO.dom2 = ( n == 2 )
Zeile 1.162: Zeile 1.242:
     --    analyse  -- string to be interpreted
     --    analyse  -- string to be interpreted
     --    alien    -- string with language code, or nil
     --    alien    -- string with language code, or nil
     --    add      -- string, with interval (PHP strtotime), or nil
     --    add      -- table, with interval, or nil
     -- Returns:
     -- Returns:
     --    table, if parsed
     --    table, if parsed
Zeile 1.169: Zeile 1.249:
     local r
     local r
     if type( analyse ) == "string" then
     if type( analyse ) == "string" then
        local strip = mw.ustring.char( 0x5B, 0x200E, 0x200F, 0x5D )
         r =  analyse:gsub( "&nbsp;", " " )
         r =  analyse:gsub( "&nbsp;", " " )
                     :gsub( "&#160;", " " )
                     :gsub( "&#160;", " " )
                     :gsub( "&#x[aA]0;", " " )
                     :gsub( "&#x[aA]0;", " " )
                     :gsub( "&#32;", " " )
                     :gsub( "&#32;", " " )
                     :gsub( Nbsp, " " )
                     :gsub( DateTime.char.nbsp, " " )
                     :gsub( Tab, " " )
                     :gsub( DateTime.char.tab, " " )
                     :gsub( "  +", " " )
                     :gsub( "  +", " " )
                     :gsub( "%[%[", "" )
                     :gsub( "%[%[", "" )
                     :gsub( "%]%]", "" )
                     :gsub( "%]%]", "" )
                    :gsub( strip, "" )
         r = mw.text.trim( r )
         r = mw.text.trim( r )
         if r == "" then
         if r == "" then
             r = { }
             r = { }
         else
         else
             local slang = ( alien or "" )
             local slang = ( alien or "" )
            local parser = { en  = "GermanEnglish",
                            de  = "GermanEnglish",
                            frr = "GermanEnglish",
                            nds = "GermanEnglish" }
            local suitable
             if slang == "" then
             if slang == "" then
                 slang = "en"
                 slang = "en"
Zeile 1.191: Zeile 1.278:
                 end
                 end
             end
             end
             slang = slang:lower()
             slang   = slang:lower()
             if slang == "en" or slang == "de" then
             suitable = parser[ slang ]
            if suitable then
                 local l
                 local l
                 l, r = pcall( Parser.GermanEnglish, r )
                 l, r = pcall( Parser[ suitable ], r )
                 if l and r then
                 if l and r then
                     if not Prototypes.fair( r ) then
                     if not Prototypes.fair( r ) then
Zeile 1.201: Zeile 1.289:
                         r = Prototypes.future( r, add )
                         r = Prototypes.future( r, add )
                     end
                     end
                else
                    r = "invalid format"
                 end
                 end
             else
             else
                 r = "unknown language"
                 r = "unknown language: " .. slang
             end
             end
         end
         end
Zeile 1.214: Zeile 1.304:




Private.flow = function ( at1, at2 )
Private.field = function ( at, ask, adapt, atleast )
     -- Compare two objects
     -- Format object as string
     -- Parameter:
     -- Parameter:
     --    at1 -- DateTime
     --    at      -- DateTime
     --    at2 -- DateTime
    --    ask      -- string, with format spec, or nil
    --    adapt    -- table, with options, or nil
    --                .lang    -- string, with particular language code
    --                .london -- true: UTC output; default: local
    --                .lonely  -- true: permit lonely hour
     --    atleast -- string, with default value, or nil
     -- Returns:
     -- Returns:
     --    -1, 0, 1 or nil if not comparable
     --    string, or false, if invalid, or number for julian date
     local r = 0
     local r, spec
    if at1.bc or at2.bc  and  at1.bc ~= at2.bc then
    if type( ask ) == "string" then
        if at1.bc then
        if ask:sub( 1, 1 ) == "$" then
             r = -1
            if ask:sub( 1, 11 ) == "$JulianDate" then
                local luxury = ( ask:sub( -2 ) == ",$" )
                if ask:sub( 1, 14 ) == "$JulianDateJul" then
                    at.legacy = true
                elseif ask:sub( 1, 15 ) == "$JulianDateGreg" then
                else
                    at.legacy = Private.former( at )
                end
                r = Private.fixed( at, luxury )
            elseif ask:sub( 1, 11 ) == "$JulianCal$" then
                adapt.legacy = true
                spec = ask:sub( 12 )
            elseif ask:sub( 1, 3 ) == "$\"$" then
                r = ask:sub( 4 )
             else
                spec = ask
            end
         else
         else
             r = 1
             spec = ask
         end
         end
     else
     else
         local life  = false
         spec = false
         local s, v1, v2
    end
        for i = 2, 10 do
    if not r then
            s = Meta.order[ i ]
         r = Private.format( at, spec, adapt )
            v1 = at1[ s ]
    end
            v2 = at2[ s ]
    return r or atleast
            if v1 or v2 then
end -- Private.field()
                if v1 and v2 then
 
                    if v1 < v2 then
 
                        r = -1
 
                    elseif v1 > v2 then
Private.fixed = function ( at, advanced )
                        r = 1
    -- Compute julian date
                    end
    -- Parameter:
                elseif life then
    --    at        -- DateTime
                    if v2 then
    --                  .legacy -- true: at is in Julian calendar
                        r = -1
    --    advanced  -- true: format long number
                    else
    -- Returns:
                        r = 1
    --    number, or string
                    end
    local mM, mMY, mY, nY, r
                else
    if at.year then
                    r = nil
        mY = at.year * 12
                end
    else    -- actually invalid
                if r ~= 0 then
        mY = 0
                    if at1.bc and r then
    end
                        r = r * -1
    if at.month then
                    end
        mMY = at.month
                    break    -- for i
    else
                end
        mMY = 1
                life = true
    end
            end
    mMY = mMY + 57609
        end -- for i
    if at.dom then
        r = at.dom
    else
        r = 1
     end
     end
     return r
     mM = ( mY + mMY )  *  0.08333333333    -- divided by 12 months
end -- Private.flow()
    nY = math.floor( mM - 1 )
 
    r  = math.floor( nY * 365.25 )
 
        + math.floor( ( mMY%12 + 4 )  *  30.6 )
 
        + r
Private.foreign = function ()
        if at.legacy then
     -- Retrieve localization submodule
            r = r - 32205.5
    if not Meta.localized then
        else
        local l, d = pcall( mw.loadData, "Module:DateTime/local" )
            r = r - math.floor( nY * 0.01 )    -- no leap day in century
         if l then
                  + math.floor( nY * 0.0025 )   -- but every 400 years
            local wk
                  - 32167.5
            if d.slang then
         end
                Meta.suite  = string.format( "%s %s",
    if at.hour then   -- divided by 24 hours per day
                                            Meta.suite, d.slang )
        r = r  +  at.hour * 0.0416666666666667
                World.slang = d.slang
    else
            end
        r = r + 0.5
            for k, v in pairs( d ) do
    end
                wk = World[ k ]
    if at.min then    -- divided by 1440 minutes per day
                if wk  and  wk.en then
        r = r  +  at.min * 0.000694444444
                    for subk, subv in pairs( v ) do
    end
                        wk[ subk ] = subv
    if at.sec then   -- divided by 86400 seconds per day
                    end -- for k, v%s %s
        r = r  +  at.min * 0.00001157407407
                else
    end
                    World[ k ] = v
    if at.bc then
                end
        r = 3442406 - r
             end -- for k, v
        if at.legacy then
             r = r + 3
         end
         end
        Meta.localized = true
     end
     end
end -- Private.foreign()
    if advanced then
        local slang = ( at.lang or World.slang )
        local o = mw.language.new( slang )
        r = o:formatNum( r )
    end
    return r
end -- Private.fixed()






Private.from = function ( attempt )
Private.flow = function ( at1, at2 )
     -- Create valid raw table from arbitrary table
     -- Compare two objects
     -- Parameter:
     -- Parameter:
     --    attempt -- table, to be evaluated
     --    at1 -- DateTime
    --    at2  -- DateTime
     -- Returns:
     -- Returns:
     --    table, with valid components, or nil
     --    -1, 0, 1 or nil if not comparable
     local data  = { }
     local r = 0
     local r
     if at1.bc or at2.bc  and  at1.bc ~= at2.bc then
    for k, v in pairs( Meta.components ) do
         if at1.bc then
         if v then
             r = -1
             v = ( type( attempt[ k ] )  ==  v )
         else
         else
             v = true
             r = 1
         end
         end
         if v then
    else
             data[ k ] = attempt[ k ]
        local life  = false
        end
        local s, v1, v2
    end -- for k, v
         for i = 2, 10 do
    if Prototypes.fair( data ) then
            s  = Meta.order[ i ]
        r = data
             v1 = at1[ s ]
     end
            v2 = at2[ s ]
     return r
            if v1 or v2 then
end -- Private.from()
                if v1 and v2 then
                    if v1 < v2 then
                        r = -1
                    elseif v1 > v2 then
                        r = 1
                    end
                elseif life then
                    if v2 then
                        r = -1
                    else
                        r = 1
                    end
                else
                    r = nil
                end
                if r ~= 0 then
                    if at1.bc and r then
                        r = r * -1
                    end
                    break    -- for i
                end
                life = true
            end
        end -- for i
     end
     return r
end -- Private.flow()






Private.future = function ( add )
Private.foreign = function ()
     -- Normalize move interval
     -- Retrieve localization submodule
    if not Meta.localized then
        local d = foreignModule( DateTime.suite,
                                false,
                                "local",
                                DateTime.item )
        if type( d ) == "table" then
            local wk
            if d.slang then
                Meta.suite  = string.format( "%s %s",
                                            Meta.suite, d.slang )
                World.slang = d.slang
            end
            for k, v in pairs( d ) do
                wk = World[ k ]
                if wk  and  wk.en then
                    for subk, subv in pairs( v ) do
                        wk[ subk ] = subv
                    end -- for k, v
                else
                    World[ k ] = v
                end
            end -- for k, v
        end
        Meta.localized = true
    end
end -- Private.foreign()
 
 
 
Private.format = function ( at, ask, adapt )
    -- Format object as string
     -- Parameter:
     -- Parameter:
     --    add  -- string or number, to be added
     --    at    -- table, with numbers etc.
    --    ask    -- string, format spec, or nil
    --    adapt  -- table, with options, or nil
    --              .lang    -- string, with particular language code
    --              .london  -- true: UTC output; default: local
    --              .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    string, with shift, or false/nil
     --    string, or not
     local r
    local slang = at.lang or "en"
     if add then
     local opts  = { lang = slang }
         local s = type( add )
    local babel, r
         if s == "string"  and  add:match( "^%s*[+-]?%d+%.?%d*%s*$" ) then
     if type( adapt ) == "table" then
            r = tonumber( add )
         if type( adapt.lang ) == "string" then
             s = "number"
            local i = adapt.lang:find( "-", 3, true )
         else
            if i then
             r = add
                slang = adapt.lang:lower()
                opts.lang = slang:sub( 1,  i - 1 )
            else
                opts.lang = adapt.lang:lower()
            end
        end
         opts.london = adapt.london
        opts.lonely = adapt.lonely
    end
    babel = mw.language.new( opts.lang:lower() )
    if babel then
        local shift, show, stamp, suffix, limit4, locally
        if at.month then
            stamp = World.monthsLong.en[ at.month ]
            if at.year then
                stamp = string.format( "%s %04d", stamp, at.year )
            end
            if at.dom then
                stamp = string.format( "%d %s", at.dom, stamp )
            end
            if ask and ask:find( "Mon4", 1, true ) then
                local mon4 = World.months4[ opts.lang:lower() ]
                if mon4  and  mon4[ at.month ] then
                    limit4 = true
                end
             end
         elseif at.year then
             stamp = string.format( "%04d", at.year )
         end
         end
         if s == "number" then
         if at.hour then
            if r == 0 then
            if stamp then
                 r = false
                stamp = stamp .. " "
            else
                stamp = ""
            end
            stamp = string.format( "%s%02d:", stamp, at.hour )
            if at.min then
                stamp = string.format( "%s%02d", stamp, at.min )
                if at.sec then
                    stamp = string.format( "%s:%02d",
                                          stamp, at.sec )
                    if at.msec then
                        stamp = string.format( "%s.%03d",
                                              stamp, at.msec )
                        if at.mysec then
                            stamp = string.format( "%s%03d",
                                                  stamp,
                                                  at.mysec )
                        end
                    end
                 end
             else
             else
                 r = string.format( "%d second", r )
                 stamp = stamp .. "00"
             end
             end
        elseif s ~= "string" then
            if at.zone then
             r = false
                stamp = stamp .. World.zones.formatter( at, "+-" )
            end
        end
        show, suffix = World.templates.formatter( at, ask, opts )
        if limit4 then
             show = show:gsub( "M", "F" )
         end
         end
         if r then
         if type( opts.london ) == "boolean" then
             r = Calc.future( r )
             locally = not opts.london
        else
            locally = true
         end
         end
     end
        r = babel:formatDate( show, stamp, locally )
        r = r:gsub( "&#160;$", "" )
        if at.year and at.year < 1000 then
            r = r:gsub( string.format( "%04d", at.year ),
                        tostring( at.year ) )
        end
        if at.month then
            local bucket, m, suite, x
            if show:find( "F", 1, true ) then
                suite = "monthsLong"
            elseif show:find( "M", 1, true ) then
                suite = "monthsAbbr"
            end
            bucket = World[ suite ]
            if bucket then
                m = bucket[ opts.lang:lower() ]
                if slang then
                    x = bucket[ slang:lower() ]
                end
                if m then
                    local base = m[ at.month ]
                    local ex
                    if x then
                        ex = x[ at.month ]
                    end
                    if suite == "monthsAbbr" then
                        local stop
                        if ex then
                            stop = x.suffix
                            base = ex
                        else
                            stop = m.suffix
                        end
                        if base and stop then
                            local shift, std
                            std  = string.format( "%s%%%s",
                                                  base[ 1 ], stop )
                            shift = string.format( "%s%s",
                                                  base[ 2 ], stop )
                            r = mw.ustring.gsub( r, std, shift )
                        end
                    elseif suite == "monthsLong" then
                        if base and ex then
                            r = mw.ustring.gsub( r, base, ex )
                        end
                    end
                end
            end
        end
        if suffix then
            r = r .. suffix
        end
     end
     return r
     return r
end -- Private.future()
end -- Private.format()






Prototypes.clone = function ( self )
Private.former = function ( at )
     -- Clone object
     -- Analyze whether Julian calendar
     -- Parameter:
     -- Parameter:
     --    self -- table, with object, to be cloned
     --    at -- table, to be evaluated
     -- Returns:
     -- Returns:
     --    table, with object
     --    true, i
     local r = { [ Meta.signature ] = self[ Meta.signature ] }
     local r
    setmetatable( r, Meta.tableI )
    if at.year then
        if at.year < 1582 then
            r = true
        elseif at.year == 1582 then
            if at.month then
                if at.month < 10 then
                    r = true
                elseif at.month == 10 then
                    r = ( at.dom <= 15 )
                end
            end
        end
    end
     return r
     return r
end -- Prototypes.clone()
end -- Private.former()






Prototypes.fair = function ( self, access, assign )
Private.from = function ( attempt )
     -- Check formal validity of table
     -- Create valid raw table from arbitrary table
     -- Parameter:
     -- Parameter:
     --    self    -- table, to be checked
     --    attempt  -- table, to be evaluated
    --    access  -- string or nil, single item to be checked
    --    assign  -- single access value to be checked
     -- Returns:
     -- Returns:
     --    true, if valid; false, if not
     --    table, with valid components, or nil
     local r = ( type( self ) == "table" )
    local data = { }
     if r then
     local r
         local defs = { year  = { max = MaxYear },
    for k, v in pairs( Meta.components ) do
                      month = { min =  1,
        if v then
                                max = 12 },
            v = ( type( attempt[ k ] ) == v )
                      week  = { min =  1,
        else
                                max = 53 },
            v = true
                      dom  = { min =  1,
        end
                                max = 31 },
        if v then
                      hour  = { max = 23 },
            data[ k ] = attempt[ k ]
                      min   = { max = 59 },
        end
                      sec  = { max = 61 },
    end -- for k, v
                      msec  = { max = 999 },
     if Prototypes.fair( data ) then
                      mysec = { max = 999 }
         r = data
        }
    end
         local fNum =
    return r
            function ( k, v )
end -- Private.from()
                local ret = true
 
                local dk = defs[ k ]
 
                if dk then
 
                    if type( dk.max ) == "number" then
Private.future = function ( add )
                        ret = ( type( v ) == "number" )
    -- Normalize move interval
                        if ret then
    -- Parameter:
                            local min
    --    add   -- string or number, to be added
                            if dk.min then
    -- Returns:
                                min = dk.min
    --    table, with shift, or false/nil
                            else
    local r
                                min = 0
    if add then
                            end
         local s = type( add )
                            ret = ( v >= min  and  v <= dk.max
        if s == "string"  and add:match( "^%s*[+-]?%d+%.?%d*%s*$" ) then
                                    and  math.floor( v ) == v )
            r = tonumber( add )
                            if ret and dk.f then
            s = "number"
                                ret = dk.f( v )
        end
                            end
        if s == "number" then
                        end
            if r == 0 then
                    end
                r = false
                end
            else
                return ret
                r = string.format( "%d second",  r or add )
            end -- fNum()
            end
        defs.dom.f =
        elseif s == "string" then
            function ()
            r = add
                local ret
        else
                local d
            r = false
                if access == "dom" then
        end
                    d = assign
        if r then
                else
            r = Calc.future( r )
                    d = self.dom
        end
                end
    end
                if d then
    return r
                    ret = ( d <= 28 )
end -- Private.future()
                    if not ret then
 
                         local m
 
                        if access == "month" then
 
                            m = assign
Prototypes.clone = function ( self )
                        else
    -- Clone object
                            m = self.month
    -- Parameter:
                        end
    --    self  -- table, with object, to be cloned
                        if m then
    -- Returns:
                            ret = ( d <= Calc.months[ m ] )
    --    table, with object
                            if ret then
    local r = { [ Meta.signature ] = self[ Meta.signature ] }
                                local y
    setmetatable( r, Meta.tableI )
                                if access == "year" then
    return r
                                    y = assign
end -- Prototypes.clone()
                                else
 
                                    y = self.year
 
                                end
 
                                if d == 29 and m == 2 and y then
Prototypes.failsafe = function ( self, atleast )
                                    if y % 4 ~= 0  or
    -- Retrieve versioning and check for compliance
                                      ( y % 100 == 0 and
    -- Precondition:
                                        y % 400 ~= 0 ) then
    --    self    -- table, or not, with DateTime object, unused
                                        ret = false
    --    atleast  -- string, with required version
                                    end
    --                         or "wikidata" or "~" or "@" or false
                                 end
    -- Postcondition:
    --    Returns  string  -- with queried version/item, also if problem
    --              false  -- if appropriate
    -- 2020-08-17
    local since = atleast
    local last    = ( since == "~" )
    local linked  = ( since == "@" )
    local link    = ( since == "item" )
    local r
    if last  or  link  or  linked  or  since == "wikidata" then
        local item = Meta.item
        since = false
        if type( item ) == "number"  and  item > 0 then
            local suited = string.format( "Q%d", item )
            if linkedlink then
                r = suited
            else
                local entity = mw.wikibase.getEntity( suited )
                if type( entity ) == "table" then
                    local seek = Failsafe.serialProperty or "P348"
                    local vsn  = entity:formatPropertyValues( seek )
                    if type( vsn ) == "table" and
                      type( vsn.value ) == "string" and
                      vsn.value ~= "" then
                        if last  and
                          vsn.value == ( Meta.serial or
                                          DateTime.serial ) then
                            r = false
                        elseif linked then
                            if mw.title.getCurrentTitle().prefixedText
                              ==  mw.wikibase.getSitelink( suited ) then
                                r = false
                            else
                                 r = suited
                             end
                             end
                        else
                            r = vsn.value
                        end
                        if last then
                            r = false
                        else
                            r = vsn.value
                         end
                         end
                     end
                     end
                else
                    ret = true
                 end
                 end
                return ret
             end
             end -- defs.dom.f()
         end
         defs.sec.f =
    end
            function ()
    if type( r ) == "nil" then
                local ret
        if not since  or  since <= Meta.serial then
                local second
            r = Meta.serial
                if access == "sec" then
        else
                    second = assign
            r = false
                else
        end
                    second = self.sec
    end
                end
    return r
                if second then
end -- Prototypes.failsafe()
                    ret = ( second <= 59 )
 
                    if not ret and self.leap then
 
                        ret = true
 
                    end
Prototypes.fair = function ( self, access, assign )
                end
    -- Check formal validity of table
                return ret
    -- Parameter:
            end -- defs.sec.f()
    --    self    -- table, to be checked
        if access or assign then
    --    access -- string or nil, single item to be checked
            r = ( type( access ) == "string" )
    --    assign -- single access value to be checked
            if r then
    -- Returns:
                 local def = defs[ access ]
    --    true, if valid;  false, if not
                 if def then
    local r = ( type( self ) == "table" )
                     r = fNum( access, assign )
    if r then
                    if r then
        local defs = { year  = { max = MaxYear },
                        if def == "dom"  or
                      month = { min =  1,
                          def == "month" or
                                max = 12 },
                          def == "year" then
                      week  = { min =  1,
                            r = defs.dom.f()
                                max = 53 },
                      dom  = { min =  1,
                                max = 31 },
                      hour  = { max = 23 },
                      min  = { max = 59 },
                      sec  = { max = 61 },
                      msec  = { max = 999 },
                      mysec = { max = 999 }
        }
        local fNum =
            function ( k, v )
                local ret = true
                 local dk  = defs[ k ]
                 if dk then
                     if type( dk.max ) == "number" then
                        ret = ( type( v ) == "number" )
                        if ret then
                            local min
                            if dk.min then
                                min = dk.min
                            else
                                min = 0
                            end
                            ret = ( v >= min  and v <= dk.max
                                    and  math.floor( v ) == v )
                            if ret and dk.f then
                                ret = dk.f( v )
                            end
                         end
                         end
                     end
                     end
                elseif access == "lang" then
                    r = ( type( assign ) == "string" )
                    if r then
                        r = assign:match( "^%l%l%l?-?%a*$" )
                    end
                elseif access == "london" then
                    r = ( type( assign ) == "boolean" )
                 end
                 end
             end
                return ret
        else
             end -- fNum()
            local life  = false
        if self.bc then
            local leak  = false
             defs.year.max = 999999
            local s, v
            for i = 1, 10 do
                s = Meta.order[ i ]
                v = self[ s ]
                if v then
                    if not life and leak then
                        -- gap detected
                        r = false
                        break
                    else
                        if not fNum( s, v ) then
                            r = false
                            break    -- for i
                        end
                        life = true
                        leak = true
                    end
                elseif i == 3 then
                    if not self.week then
                        life = false
                    end
                elseif i ~= 4 then
                    life = false
                end
             end -- for i
            if self.week  and  ( self.month or self.dom ) then
                r = false
            end
         end
         end
    end
        defs.dom.f =
    return r
            function ()
end -- Prototypes.fair()
                local ret
 
                local d
 
                if access == "dom" then
 
                    d = assign
Prototypes.figure = function ( self, assign )
                else
    -- Assign month by name
                    d = self.dom
    -- Parameter:
                end
    --    self    -- table, to be filled
                if d then
    --    assign  -- string, with month name
                    ret = ( d <= 28 )
    -- Returns:
                    if not ret then
    --    number 1...12, if valid;  false, if not
                        local m
    local r = false
                        if access == "month" then
    if type( self ) == "table"  and  type( assign ) == "string" then
                            m = assign
        r = Parser.monthNumber( assign )
                        else
        if r then
                            m = self.month
            self.month = r
                        end
        end
                        if m then
    end
                            ret = ( d <= Calc.months[ m ] )
    return r
                            if ret then
end -- Prototypes.figure()
                                local y
 
                                if access == "year" then
 
                                    y = assign
 
                                else
Prototypes.first = function ( self )
                                    y = self.year
    -- Retrieve abbreviated month name in current language
                                end
    -- Parameter:
                                if d == 29  and m == 2 and  y then
    --    self -- table, to be evaluated
                                    if y % 4 ~= 0  or
    -- Returns:
                                      ( y % 100 == 0  and
    --    string, if defined; false, if not
                                        y % 400 ~= 0 ) then
    local r
                                        ret = false
    if type( self ) == "table" and  self.month then
                                    end
        local slang = ( self.lang or World.slang )
                                end
        r = World.monthsLong[ slang ]
                            end
        if r then
                        end
            local brief = World.monthsAbbr[ slang ]
                     end
            r = r[ self.month ]
            if brief then
                local ex = brief[ self.month ]
                local s  = brief.suffix
                if ex then
                     r = ex[ 2 ]
                 else
                 else
                     local n = brief.n or 3
                     ret = true
                    r = mw.ustring.sub( r, 1, n )
                 end
                 end
                 if s then
                 return ret
                    r = r .. s
            end -- defs.dom.f()
                 end
        defs.sec.f =
            end
            function ()
        end
                local ret
    else
                 local second
        r = false
                if access == "sec" then
    end
                    second = assign
    return r
                else
end -- Prototypes.first()
                    second = self.sec
 
                end
 
                if second then
 
                    ret = ( second <= 59 )
Prototypes.flow = function ( self, another, assert )
                    if not ret and self.leap then
    -- Compare this object with another timestamp
                        ret = true
    -- Parameter:
                    end
    --    self    -- table, with numbers etc.
                end
    --    another  -- DateTime or string or nil (now)
                return ret
    --    assert  -- nil, or string with operator
            end -- defs.sec.f()
    --                      "lt", "le", "eq", "ne", "ge", "gt",
        if access or assign then
    --                      "<", "<=", "==", "~=", "<>", ">=", "=>", ">"
            r = ( type( access ) == "string" )
    -- Returns:
            if r then
    --    if assert: true or false
                local def = defs[ access ]
    --    else: -1, 0, 1
                if def then
    --    nil if invalid
                    r = fNum( access, assign )
    local base, other, r
                    if r then
    if type( self ) == "table" then
                        if def == "dom"  or
        base = self
                          def == "month"  or
        other = another
                          def == "year" then
    elseif type( another ) == "table" then
                            r = defs.dom.f()
        base = another
                        end
        other = self
                    end
    end
                elseif access == "lang" then
    if base then
                    r = ( type( assign ) == "string" )
        if type( other ) ~= "table" then
                    if r then
            other = Meta.fiat( other )
                        r = assign:match( "^%l%l%l?-?%a*$" )
        end
                    end
        if type( other ) == "table" then
                elseif access == "london" then
            r = Private.flow( base, other )
                    r = ( type( assign ) == "boolean" )
            if r  and  type( assert ) == "string" then
                end
                local trsl = { lt    = "<",
            end
                              ["<"]  = "<",
        else
                              le    = "<=",
            local life  = false
                              ["<="] = "<=",
            local leak  = false
                              eq    = "=",
            local s, v
                              ["=="] = "=",
            for i = 1, 10 do
                              ne    = "<>",
                s = Meta.order[ i ]
                              ["<>"] = "<>",
                 v = self[ s ]
                              ["~="] = "<>",
                 if v then
                              ge    = ">=",
                     if not life and leak then
                              [">="] = ">=",
                        -- gap detected
                              ["=>"] = ">=",
                        r = false
                              gt    = ">",
                        break
                              [">"] = ">" }
                     else
                 local same = trsl[ assert:lower() ]
                        if not fNum( s, v ) then
                 if same then
                            r = false
                     local s = "="
                            break    -- for i
                     if r < 0 then
                        end
                         s = "<"
                        life = true
                     elseif r > 0 then
                         leak = true
                         s = ">"
                     end
                elseif i == 3 then
                    if not self.week then
                         life = false
                     end
                     end
                    r = ( same:find( s, 1, true )  ~= nil )
                elseif i ~= 4 then
                else
                     life = false
                     r = nil
                 end
                 end
            end -- for i
            if self.week  and  ( self.month or self.dom ) then
                r = false
             end
             end
         end
         end
     end
     end
     return r
     return r
end -- Prototypes.flow()
end -- Prototypes.fair()






Prototypes.format = function ( self, ask, adapt )
Prototypes.figure = function ( self, assign )
     -- Format object as string
     -- Assign month by name
     -- Parameter:
     -- Parameter:
     --    self   -- table, with numbers etc.
     --    self   -- table, to be filled
     --    ask    -- string, format spec, or nil
     --    assign -- string, with month name
    --    adapt -- table, with options, or nil
    --              .lang    -- string, with particular language code
    --              .london  -- true: UTC output; default: local
    --              .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    string, or false, if invalid
     --    number 1...12, if valid;  false, if not
     local r = false
     local r = false
     if type( self ) == "table" then
     if type( self ) == "table"  and  type( assign ) == "string" then
        local opts = { lang = self.lang }
        r = Parser.monthNumber( assign )
        local babel, slang
        if r then
        if type( adapt ) == "table" then
             self.month = r
            if type( adapt.lang ) == "string" then
                local i = adapt.lang:find( "-", 3, true )
                if i then
                    slang = adapt.lang:lower()
                    opts.lang = slang:sub( 1,  i - 1 )
                else
                    opts.lang = adapt.lang:lower()
                end
             end
            opts.london = adapt.london
            opts.lonely = adapt.lonely
         end
         end
        babel = mw.language.new( opts.lang )
    end
        if babel then
    return r
            local shift, show, stamp, suffix, limit4, locally
end -- Prototypes.figure()
            if self.month then
 
                stamp = World.monthsLong.en[ self.month ]
 
                if self.year then
 
                    stamp = string.format( "%s %04d", stamp, self.year )
Prototypes.first = function ( self )
                end
    -- Retrieve abbreviated month name in current language
                if self.dom then
    -- Parameter:
                    stamp = string.format( "%d %s", self.dom, stamp )
    --    self -- table, to be evaluated
                end
    -- Returns:
                if ask and ask:find( "Mon4" ) then
    --    string, if defined;  false, if not
                    local mon4 = World.months4[ opts.lang ]
    local r
                    if mon4 then
    if type( self ) == "table"  and  self.month then
                        if mon4[ self.month ] then
        local slang = ( self.lang or World.slang )
                            limit4 = true
        r = World.monthsLong[ slang ]
                        end
        if r then
                    end
            local brief = World.monthsAbbr[ slang ]
                end
            r = r[ self.month ]
             elseif self.year then
             if brief then
                 stamp = string.format( "%04d", self.year )
                 local ex = brief[ self.month ]
            end
                 local s  = brief.suffix
            if self.hour then
                 if ex then
                 stamp = string.format( "%s %02d:", stamp, self.hour )
                     r = ex[ 2 ]
                 if self.min then
                     stamp = string.format( "%s%02d", stamp, self.min )
                    if self.sec then
                        stamp = string.format( "%s:%02d",
                                              stamp, self.sec )
                        if self.msec then
                            stamp = string.format( "%s.%03d",
                                                  stamp, self.msec )
                            if self.mysec then
                                stamp = string.format( "%s%03d",
                                                      stamp,
                                                      self.mysec )
                            end
                        end
                    end
                 else
                 else
                     stamp = stamp .. "00"
                     local n = brief.n or 3
                    r = mw.ustring.sub( r, 1, n )
                 end
                 end
                 if self.zone then
                 if s then
                     stamp = stamp .. World.zones.formatter( self, "+-" )
                     r = r .. s
                 end
                 end
             end
             end
            show, suffix = World.templates.formatter( self, ask, opts )
        end
            if limit4 then
    else
                show = show:gsub( "M", "F" )
        r = false
            end
            if type( opts.london ) == "boolean" then
                locally = not opts.london
            else
                locally = true
            end
            r = babel:formatDate( show, stamp, locally )
            r = r:gsub( "&#160;$", "" )
            if self.year and self.year < 1000 then
                r = r:gsub( string.format( "%04d", self.year ),
                            tostring( self.year ) )
            end
            if self.month then
                local bucket, m, suite, x
                if show:find( "F" ) then
                    suite = "monthsLong"
                elseif show:find( "M" ) then
                    suite = "monthsAbbr"
                end
                bucket = World[ suite ]
                if bucket then
                    m = bucket[ opts.lang ]
                    if slang then
                        x = bucket[ slang ]
                    end
                    if m then
                        local base = m[ self.month ]
                        local ex
                        if x then
                            ex = x[ self.month ]
                        end
                        if suite == "monthsAbbr" then
                            local stop
                            if ex then
                                stop = x.suffix
                                base = ex
                            else
                                stop = m.suffix
                            end
                            if base and stop then
                                local shift, std
                                std  = string.format( "%s%%%s",
                                                      base[ 1 ], stop )
                                shift = string.format( "%s%s",
                                                      base[ 2 ], stop )
                                r = mw.ustring.gsub( r, std, shift )
                            end
                        elseif suite == "monthsLong" then
                            if base and ex then
                                r = mw.ustring.gsub( r, base, ex )
                            end
                        end
                    end
                end
            end
            if suffix then
                r = r .. suffix
            end
        end
     end
     end
     return r
     return r
end -- Prototypes.format()
end -- Prototypes.first()






Prototypes.full = function ( self )
Prototypes.fix = function ( self )
     -- Retrieve month name in current language
     -- Adapt this object to local time if no explicit zone given
     -- Parameter:
     -- Parameter:
     --    self  -- table, to be evaluated
     --    self  -- table, with numbers etc.
    -- Returns:
     if type( self ) == "table"  and
    --    string, if defined;  false, if not
      not self.zone then
    local r
         local seconds = Prototypes.format( self, "Z" )
     if type( self ) == "table"  and self.month then
         Prototypes.future( self,  - tonumber( seconds ) )
         local slang = ( self.lang or World.slang )
     end
         r = World.monthsLong[ slang ]
end -- Prototypes.fix()
        if r then
 
            r = r[ self.month ]
 
        end
 
    else
Prototypes.flow = function ( self, another, assert )
        r = false
     -- Compare this object with another timestamp
     end
    return r
end -- Prototypes.full()
 
 
 
Prototypes.future = function ( self, add, allocate )
     -- Relative move by interval
     -- Parameter:
     -- Parameter:
     --    self     -- table, to be used as base
     --    self     -- table, with numbers etc.
     --    add      -- string or number, to be added
     --    another  -- DateTime or string or nil (now)
     --    allocate  -- true, if a clone shall be returned
    --    assert  -- nil, or string with operator
     --                       "lt", "le", "eq", "ne", "ge", "gt",
     --                       "<", "<=", "==", "~=", "<>", ">=", "=>", ">"
     -- Returns:
     -- Returns:
     --    table, with shift
     --    if assert: true or false
     local r, raw, rel, shift
    --    else: -1, 0, 1
    --    nil if invalid
     local base, other, r
     if type( self ) == "table" then
     if type( self ) == "table" then
         r    = self
         base  = self
         shift = add
         other = another
     elseif type( add ) == "table" then
     elseif type( another ) == "table" then
         r    = add
         base  = another
         shift = self
         other = self
     end
     end
     if r then
     if base then
         raw = r[ Meta.signature ]
         if type( other ) ~= "table" then
         rel = Private.future( shift )
            other = Meta.fiat( other )
     end
        end
     if raw and rel then
         if type( other ) == "table" then
        if allocate then
            r = Private.flow( base, other )
            r   = Prototypes.clone( r )
            if r  and  type( assert ) == "string" then
             raw = r[ Meta.signature ]
                local trsl = { lt    = "<",
                              ["<"]  = "<",
                              le    = "<=",
                              ["<="] = "<=",
                              eq     = "=",
                              ["=="] = "=",
                              ne    = "<>",
                              ["<>"] = "<>",
                              ["~="] = "<>",
                              ge    = ">=",
                              [">="] = ">=",
                              ["=>"] = ">=",
                              gt     = ">",
                              [">"]  = ">" }
                local same = trsl[ assert:lower() ]
                if same then
                    local s = "="
                    if r < 0 then
                        s = "<"
                    elseif r > 0 then
                        s = ">"
                    end
                    r = ( same:find( s, 1, true )  ~=  nil )
                else
                    r = nil
                end
             end
         end
         end
        for k, v in pairs( rel ) do
            raw[ k ] = ( raw[ k ] or 0 )  +  v
        end -- for k, v
        Calc.fair( raw )
        r[ Meta.signature ] = raw
     end
     end
     return r
     return r
end -- Prototypes.future()
end -- Prototypes.flow()






Prototypes.tostring = function ( self )
Prototypes.format = function ( self, ask, adapt )
     -- Stringify yourself
     -- Format object as string
     -- Parameter:
     -- Parameter:
     --    self  -- table, to be stringified
     --    self   -- table, with numbers etc.
    --    ask    -- string, format spec, or nil
    --              table, with multiple formats
    --              string may contain multiple formats joined by "|||"
    --    adapt -- table, with options, or nil
    --              .lang    -- string, with particular language code
    --              .london  -- true: UTC output; default: local
    --              .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    string
     --    string, or false, if invalid, or number for julian date
     local dels = { false, "", "-", "-", "", ":", ":", ".", "", "" }
     local r
    local wids = { false, 4,  2,  2,  2,  2,  2,  2,  3,  3  }
    if type( self ) == "table" then
    local s    = ""
        local s = type( ask )
    local n, r, spec
        local poly
    local f = function ( a )
        if s == "string" and  ask:find( "|||", 1, true ) then
                  n = self[ Meta.order[ a ] ]
            poly = mw.text.split( ask, "|||" )
                  s = s .. dels[ a ]
        elseif s == "table" then
                  if n then
            poly = ask
                      spec = string.format( "%%s%%0%dd", wids[ a ] )
        end
                      s    = string.format( spec, s, n )
        if poly then
                  end
            r = ""
              end -- f()
            for i = 1, #poly do
    for i = 2, 4 do
                r = r .. Private.field( self, poly[ i ], adapt )
        f( i )
            end -- for i
     end -- for i
        else
     r = s
            r = Private.field( self, ask, adapt )
     s = ""
        end
     for i = 5, 10 do
    end
        f( i )
    return r  or  false
     end -- for i
end -- Prototypes.format()
     if s == "::." then
 
         r = r:gsub( "%-+$", "" )
 
 
Prototypes.full = function ( self )
     -- Retrieve month name in current language
     -- Parameter:
     --     self  -- table, to be evaluated
    -- Returns:
     --     string, if defined;  false, if not
    local r
     if type( self ) == "table"  and  self.month then
        local slang = ( self.lang or World.slang )
         r = World.monthsLong[ slang ]
        if r then
            r = r[ self.month ]
        end
     else
     else
         if r == "--" then
         r = false
            r = s
        else
            r = string.format( "%sT%s", r, s )
        end
     end
     end
     return r
     return r
end -- Prototypes.tostring()
end -- Prototypes.full()






Prototypes.valueOf = function ( self )
Prototypes.future = function ( self, add, allocate )
     -- Returns yourselves primitive value (primitive table)
     -- Relative move by interval
     -- Parameter:
     -- Parameter:
     --    self -- table, to be dumped
     --    self     -- table, to be used as base
    --    add      -- string or number, to be added
    --    allocate  -- true, if a clone shall be returned
     -- Returns:
     -- Returns:
     --    table, or false
     --    table, with shift
     local r
     local r, raw, rel, shift
     if type( self ) == "table" then
     if type( self ) == "table" then
         r = self[ Meta.signature ]
         r     = self
        shift = add
    elseif type( add ) == "table" then
        r    = add
        shift = self
    end
    if r then
        if r[ Meta.signature ] then
            raw = r[ Meta.signature ]
        else
            raw = r
        end
        if type( shift ) == "table" then
            rel = shift
        else
            rel = Private.future( shift )
        end
     end
     end
     return r or false
     if raw and rel then
end -- Prototypes.valueOf()
        if allocate then
 
            r   = Prototypes.clone( r )
 
            raw = r[ Meta.signature ]
 
Templates.flow = function ( frame, action )
    -- Comparison invokation
    -- Parameter:
    --    frame  -- object
    -- Returns:
    --    string, either "" or "1"
    local r
    local s1 = frame.args[ 1 ]
    local s2 = frame.args[ 2 ]
    if s1 then
        s1 = mw.text.trim( s1 )
        if s1 == "" then
            s1 = false
         end
         end
        for k, v in pairs( rel ) do
            raw[ k ] = ( raw[ k ] or 0 )  +  v
        end -- for k, v
        Calc.fair( raw )
        r[ Meta.signature ] = raw
     end
     end
    if s2 then
     return r
        s2 = mw.text.trim( s2 )
end -- Prototypes.future()
        if s2 == "" then
 
            s2 = false
 
        end
 
    end
Prototypes.tostring = function ( self )
    if s1 or s2 then
     -- Stringify yourself
        local l
        Frame = frame
        l, r = pcall( Prototypes.flow,
                      Meta.fiat( s1 ), s2, action )
        if r == true then
            r = "1"
        end
    end
     return r or ""
end -- Templates.flow()
 
 
 
World.templates.formatter = function ( assigned, ask, adapt )
     -- Retrieve format specification string
     -- Parameter:
     -- Parameter:
     --    assigned -- table, with numbers etc.
     --    self -- table, to be stringified
    --    ask      -- string, format spec, or nil
    --    adapt    -- table, with options
    --                  .lang    -- string, with particular language code
    --                  .lonely  -- true: permit lonely hour
     -- Returns:
     -- Returns:
     --    1  -- string
    --    string
     --    2  -- string or nil; append suffix (zone)
    local dels = { false, "", "-", "-", "", "", ":", ":", ".", "" }
     local r1, r2
    local wids = { false, 4,  2,  2,  2,  2,  2,  2,  3,  3  }
     if not ask  or  ask == "" then
    local s    = ""
         r1 = "c"
    local n, r, spec
     else
    local f = function ( a )
         local template = World.templates[ ask ]
                  n = self[ Meta.order[ a ] ]
         r1 = ask
                  s = s .. dels[ a ]
         if not template then
                  if n then
             local slang = ( adapt.lang or assigned.lang or World.slang )
                      spec = string.format( "%%s%%0%dd", wids[ a ] )
             local tmp  = World.templates[ slang ]
                      s    = string.format( spec, s, n )
             if tmp then
                  end
                 template = tmp[ ask ]
              end -- f()
             end
    for i = 2, 5 do
         end
        f( i )
         if type( template ) == "table" then
    end -- for i
             local low = ( ask == "ISO" or ask == "ISO-T" )
    r = s
             r1 = template.spec
    s = ""
             if assigned.year then
    for i = 6, 10 do
                 if not assigned.dom then
        f( i )
                     r1 = r1:gsub( "[ .%-]?[dDjlNwz][ .,%-]*", "" )
    end -- for i
                           :gsub( "^&#160;", "" )
    if s == "::." then
                     if not assigned.month then
        r = r:gsub( "%-+$", "" )
                         r1 = r1:gsub( "[ .%-]?[FmMnt][ .%-]*", "" )
    else
        if r == "--" then
            r = s
        else
            r = string.format( "%sT%s", r, s )
        end
    end
    r = r:gsub( "%.$", "" )
    if self.bc then
        if self.year then
            r = "-" .. r
        else
            r = r .. " BC"
        end
    end
    return r
end -- Prototypes.tostring()
 
 
 
Prototypes.valueOf = function ( self )
    -- Returns yourselves primitive value (primitive table)
    -- Parameter:
    --    self  -- table, to be dumped
    -- Returns:
    --    table, or false
    local r
    if type( self ) == "table" then
        r = self[ Meta.signature ]
    end
    return r or false
end -- Prototypes.valueOf()
 
 
 
Templates.flow = function ( frame, action )
    -- Comparison invokation
    -- Parameter:
    --    frame  -- object
    -- Returns:
    --    string, either "" or "1"
    local r
    local s1 = frame.args[ 1 ]
    local s2 = frame.args[ 2 ]
    if s1 then
        s1 = mw.text.trim( s1 )
        if s1 == "" then
            s1 = false
        end
    end
    if s2 then
        s2 = mw.text.trim( s2 )
        if s2 == "" then
            s2 = false
        end
    end
    if s1 or s2 then
        local l
        Frame = frame
        l, r = pcall( Prototypes.flow,
                      Meta.fiat( s1 ), s2, action )
        if r == true then
            r = "1"
        end
    end
    return r or ""
end -- Templates.flow()
 
 
 
World.templates.formatter = function ( assigned, ask, adapt )
    -- Retrieve format specification string
    -- Parameter:
    --    assigned  -- table, with numbers etc.
    --    ask      -- string, format spec, or nil
    --    adapt    -- table, with options
    --                  .lang    -- string, with particular language code
    --                  .lonely  -- true: permit lonely hour
    -- Returns:
     --    1  -- string
     --    2  -- string or nil; append suffix (zone)
     local r1, r2
     if not ask  or  ask == "" then
         r1 = "c"
    elseif ask == "*" then
        if World.present then
            if assigned.hour then
                if assigned.dom or assigned.month or assigned.year then
                    if World.present.both and
                      World.present.date and
                      World.present.time then
                        r1 = World.present.both
                                    :gsub( "$date", World.present.date )
                                    :gsub( "$time", World.present.time )
                    else
                        r1 = World.present.date
                    end
                end
                r1 = r1 or World.present.time
            else
                r1 = World.present.date
            end
        end
        r1 = r1 or "c"
     else
         local template = World.templates[ ask ]
         r1 = ask
         if not template then
             local slang = ( adapt.lang or assigned.lang or World.slang )
             local tmp  = World.templates[ slang ]
             if tmp then
                 template = tmp[ ask ]
            end
            if not template then
                local i = slang:find( "-", 3, true )
                if i then
                    slang = slang:sub( 1,  i - 1 ):lower()
                    tmp  = World.templates[ slang ]
                    if tmp then
                        template = tmp[ ask ]
                    end
                end
             end
         end
         if type( template ) == "table" then
             local low = ( ask == "ISO" or ask == "ISO-T" )
             r1 = template.spec
             if assigned.year then
                 if not assigned.dom then
                     r1 = r1:gsub( "[ .%-]?[dDjlNwz][ .,%-]*", "" )
                           :gsub( "^&#160;", "" )
                     if not assigned.month then
                         r1 = r1:gsub( "[ .%-]?[FmMnt][ .%-]*", "" )
                    end
                end
            else
                r1 = r1:gsub( " ?[yY] ?", "" )
                if not assigned.dom then
                    r1 = r1:gsub( "[ .]?[dDjlNwz][ .,%-]*", "" )
                            :gsub( "^&#160;", "" )
                end
            end
            if template.lift and
              ( assigned.dom or
                not  ( assigned.month or assigned.year or assigned.bc )
              ) then
                local stamp = false
                if assigned.hour then
                    if assigned.min then
                        stamp = "H:i"
                        if assigned.sec then
                            stamp = "H:i:s"
                            if assigned.msec then
                                stamp = string.format( "%s.%03d",
                                                      stamp,
                                                      assigned.msec )
                                if assigned.mysec then
                                    stamp = string.format( "%s.%03d",
                                                          stamp,
                                                        assigned.mysec )
                                end
                            end
                        end
                    elseif adapt.lonely then
                        stamp = "H"
                    end
                end
                if low or ask:find( "hh:mm:ss", 1, true ) then
                    if stamp then
                        r1 = string.format( "%s %s", r1, stamp )
                     end
                     end
                elseif ask:find( "hh:mm", 1, true )  and
                      stamp  and
                      #stamp > 3 then
                    r1 = string.format( "%s H:i", r1 )
                 end
                 end
            else
                 if stamp then
                r1 = r1:gsub( " ?[yY] ?", "" )
                     if low or template.long then
                if not assigned.dom then
                         local scheme
                    r1 = r1:gsub( "[ .]?[dDjlNwz][ .,%-]*", "" )
                         if template.long then
                            :gsub( "^&#160;", "" )
                             scheme = mw.language.getContentLanguage()
                end
            end
            if template.lift and
              (assigned.dom or
                not (assigned.month or assigned.year or assigned.bc)
              ) then
                local stamp = false
                if assigned.hour then
                    if assigned.min then
                        stamp = "H:i"
                        if assigned.sec then
                            stamp = "H:i:s"
                            if assigned.msec then
                                stamp = string.format( "%s.%03d",
                                                      stamp,
                                                      assigned.msec )
                                if assigned.mysec then
                                    stamp = string.format( "%s.%03d",
                                                          stamp,
                                                        assigned.mysec )
                                end
                            end
                        end
                    elseif adapt.lonely then
                        stamp = "H"
                    end
                end
                if low or ask:find( "hh:mm:ss" ) then
                    if stamp then
                        r1 = string.format( "%s %s", r1, stamp )
                    end
                end
                 if stamp then
                     if low or template.long then
                         local scheme
                         if template.long then
                             scheme = mw.language.getContentLanguage()
                             scheme = scheme.code
                             scheme = scheme.code
                         end
                         end
Zeile 2.059: Zeile 2.456:
             if #s == 1 then
             if #s == 1 then
                 -- "YXWVUTSRQPONZABCDEFGHIKLM"
                 -- "YXWVUTSRQPONZABCDEFGHIKLM"
                 move = World.zones[ "!" ]:find( s )
                 move = World.zones[ "!" ]:find( s, 1, true )
                 if move then
                 if move then
                     move          = ( move - 13 ) * 100
                     move          = ( move - 13 ) * 100
Zeile 2.074: Zeile 2.471:
                   if tmp then
                   if tmp then
                       code = tmp[ s ]
                       code = tmp[ s ]
                  end
                  if not code  and
                      slang ~= "en"  and
                      World.zones.en then
                      code = World.zones.en[ s ]
                   end
                   end
                 end
                 end
Zeile 2.128: Zeile 2.530:


-- Export
-- Export
local p = { }
local p = { }
 
 
function p.test( args, alien )
p.test = function ( args, alien )
     local slang = args.lang
     local slang = args.lang or alien
     local obj  = Meta.fiat( args[ 1 ], false, args.shift )
     local obj  = Meta.fiat( args[ 1 ], false, args.shift )
     local r
     local r
     if type( obj ) == "table" then
     if type( obj ) == "table" then
         local spec  = args[ 2 ]
         local spec  = args[ 2 ]
         local opt
         local opt
         if spec then
         if spec then
             spec = mw.text.trim( spec )
             spec = mw.text.trim( spec )
         end
         end
         if slang then
         if slang then
             opt = { lang = mw.text.trim( slang ) }
             opt = { lang = mw.text.trim( slang ) }
         end
         end
         r = obj:format( spec, opt )
         r = obj:format( spec, opt )
     else
     else
         r = ( args.noerror or "0" )
         r = ( args.noerror or "0" )
         if r == "0" then
         if r == "0" then
             r = fault( "Format nicht erkannt" )
             r = fault( "Format invalid" )
         else
         else
             r = ""
             r = ""
        end
        if args.errCat then
            local cats = mw.text.split( args.errCat, "%s*|%s*" )
            for i = 1, #cats do
                r = string.format( "%s[[Category:%s]]",  r,  cats[ i ] )
            end -- for i
         end
         end
     end
     end
Zeile 2.157: Zeile 2.565:




function p.failsafe( frame )
p.failsafe = function ( frame )
     local s = type( frame )
     local s = type( frame )
     local r, since
     local r, since
Zeile 2.168: Zeile 2.576:
         end
         end
     end
     end
     if since == "wikidata" then
     return Prototypes.failsafe( false, since )  or ""
        local item = DateTime.item
        since = false
        if type( item ) == "number" and item > 0 then
            local entity = mw.wikibase.getEntity( string.format( "Q%d",
                                                                item ) )
            if type( entity ) == "table" then
                local vsn = entity:formatPropertyValues( "P348" )
                if type( vsn ) == "table"  and
                  type( vsn.value) == "string" and
                  vsn.value ~= "" then
                    r = vsn.value
                end
            end
        end
    end
    if since then
        if since > Meta.serial then
            r = ""
        else
            r = Meta.serial
        end
    elseif not r then
        r = Meta.serial
    end
    return r
end -- p.failsafe
end -- p.failsafe






function p.format( frame )
p.format = function ( frame )
     --    1      -- stamp
     --    1      -- stamp
     --    2      -- spec
     --    2      -- spec
Zeile 2.208: Zeile 2.591:
                 frame.args[ 2 ],
                 frame.args[ 2 ],
                 shift  = frame.args.shift,
                 shift  = frame.args.shift,
                 noerror = frame.args.noerror }
                 noerror = frame.args.noerror,
                errCat  = frame.args.errCat }
     if not v[ 1 ]  or  v[ 1 ] == "now" then
     if not v[ 1 ]  or  v[ 1 ] == "now" then
         v[ 1 ]  = frame:callParserFunction( "#timel", "c", v.shift )
         v[ 1 ]  = frame:callParserFunction( "#timel", "c", v.shift )
Zeile 2.223: Zeile 2.607:




function p.lt( frame )
p.lt = function ( frame )
     return Templates.flow( frame, "lt" )
     return Templates.flow( frame, "lt" )
end -- p.lt
end -- p.lt
function p.le( frame )
p.le = function ( frame )
     return Templates.flow( frame, "le" )
     return Templates.flow( frame, "le" )
end -- p.le
end -- p.le
function p.eq( frame )
p.eq = function ( frame )
     return Templates.flow( frame, "eq" )
     return Templates.flow( frame, "eq" )
end -- p.eq
end -- p.eq
function p.ne( frame )
p.ne = function ( frame )
     return Templates.flow( frame, "ne" )
     return Templates.flow( frame, "ne" )
end -- p.ne
end -- p.ne
function p.ge( frame )
p.ge = function ( frame )
     return Templates.flow( frame, "ge" )
     return Templates.flow( frame, "ge" )
end -- p.ge
end -- p.ge
function p.gt( frame )
p.gt = function ( frame )
     return Templates.flow( frame, "gt" )
     return Templates.flow( frame, "gt" )
end -- p.gt
end -- p.gt
Anonymer Benutzer
Abgerufen von „https://wiki.wiidatabase.de/wiki/Spezial:Mobiler_Unterschied/10155“