Modul:Wikidata/date

Vikiverilənlərdən doğum və vəfat tarixlərini götürmək üçün istifadə olunan modul.

• p.dateOfBirth ← {{wikidata/p569}}
• p.dateOfDeath ← {{wikidata/p570}}

• p.formatBirthDate ← Module:Wikidata ← p.dateOfBirth ← {{wikidata/p569}}
• p.formatDeathDate ← Module:Wikidata ← p.dateOfDeath ← {{wikidata/p570}}

Sınaqlar

9 testdə xəta baş verdi.

test_formatAsJulian:

	Mətn	Gözlənilən	Aktual
Y	{{#invoke:Wikidata/date | formatAsJulian |-14826758400}}	28 fevral 1500	28 fevral 1500
Y	{{#invoke:Wikidata/date | formatAsJulian |-14826672000}}	29 fevral 1500	29 fevral 1500
N	{{#invoke:Wikidata/date | formatAsJulian |-14826585600}}	1 mart 1500	2 mart 1500
N	{{#invoke:Wikidata/date | formatAsJulian |-11670220800}}	28 fevral (9 mart) 1600	9 (19) mart 1600
N	{{#invoke:Wikidata/date | formatAsJulian |-11670134400}}	29 fevral (10 mart) 1600	10 (20) mart 1600
N	{{#invoke:Wikidata/date | formatAsJulian |-11670048000}}	1 (11) mart 1600	11 (21) mart 1600
N	{{#invoke:Wikidata/date | formatAsJulian | -8514460800}}	28 fevral (10 mart) 1700	10 (21) mart 1700
N	{{#invoke:Wikidata/date | formatAsJulian | -8514374400}}	29 fevral (11 mart) 1700	11 (22) mart 1700
N	{{#invoke:Wikidata/date | formatAsJulian | -8514288000}}	1 (12) mart 1700	12 (23) mart 1700
N	{{#invoke:Wikidata/date | formatAsJulian | -2208988800}}	20 dekabr 1899 (1 yanvar 1900)	1 (13) yanvar 1900
N	{{#invoke:Wikidata/date | formatAsJulian | -1734480000}}	2 (15) yanvar 1915	15 (28) yanvar 1915
Y	{{#invoke:Wikidata/date | formatAsJulian | 946684800}}	yanlış tarix (yuli təqvimi 1918-01-26 tarixindən sonra istifadə olunmur)	yanlış tarix (yuli təqvimi 1918-01-26 tarixindən sonra istifadə olunmur)

---

--settings
local nowLabel = '<abbr class="abbr" title="hal-hazırda">h.&nbsp;h.</abbr>'
local abbrbc = '<abbr class="abbr" title="eradan əvvəl">e.&nbsp;ə.</abbr>'

local moduleDates = require( "Modul:Dates" )
local moduleWikidata = require( "Modul:Wikidata" )
local Ordinal = require( "Modul:Ordinal" )
local moduleRoman = require( "Modul:RomanNumber" )
local dateCat = require("Modul:Infocards/dateCat")

local function deepcopy(orig)
	local orig_type = type(orig)
	local copy
	if orig_type == 'table' then
		copy = {}
		for orig_key, orig_value in next, orig, nil do
			copy[deepcopy(orig_key)] = deepcopy(orig_value)
		end
		setmetatable(copy, deepcopy(getmetatable(orig)))
	else -- number, string, boolean, etc
		copy = orig
	end
	return copy
end

local function ageImpl(bStructure, bPrecision, dStructure, dPrecision)
    if not bStructure or not dStructure or bPrecision < 10 or dPrecision < 10 then
        return nil
    end

    local shift = 0
    if bStructure.year < 0 and dStructure.year > 0 then
        shift = -1
    end

    -- Handle year-only dates
    if bPrecision == 9 or dPrecision == 9 then
        local age = dStructure.year - bStructure.year + shift
        -- Birthday not yet reached this year
        if dStructure.month < bStructure.month or
           (dStructure.month == bStructure.month and dStructure.day < bStructure.day) then
            return age - 1, age -- Return age range
        end
        return age, age -- Return single age
    end

    -- Specific logic for January 1 and December 31
    if bStructure.month == 1 and bStructure.day == 1 then
        return dStructure.year - bStructure.year + shift, dStructure.year - bStructure.year + shift
    elseif bStructure.month == 12 and bStructure.day == 31 then
        return dStructure.year - bStructure.year + shift, dStructure.year - bStructure.year + shift
    end

    -- Handle full dates with month and day
    if bPrecision == 10 or dPrecision == 10 then
        if bStructure.month < dStructure.month then
            return dStructure.year - bStructure.year + shift
        elseif bStructure.month == dStructure.month then
            if bStructure.day <= dStructure.day then
                return dStructure.year - bStructure.year + shift
            else
                return dStructure.year - bStructure.year - 1 + shift
            end
        else
            return dStructure.year - bStructure.year - 1 + shift
        end
    end

    return dStructure.year - bStructure.year + shift
end

-- accepts table of time+precision values
local function age(bTable, dTable)
    local possibleAge = "NYA" -- Not Yet Assigned

    for bKey, bValue in pairs(bTable) do
        if bValue.unknown then
            return nil
        end
        local bStructure = bValue.structure
        local bPrecision = bValue.precision

        for dKey, dValue in pairs(dTable or {{structure=os.date("*t"), precision=11}}) do
            if dValue.unknown then
                return nil
            end
            local dStructure = dValue.structure
            local dPrecision = dValue.precision

            local calculatedAge, maxAge = ageImpl(bStructure, bPrecision, dStructure, dPrecision)

            if possibleAge == "NYA" then
                possibleAge = calculatedAge
                if maxAge then
                    possibleAge = calculatedAge .. "-" .. maxAge -- Range (e.g., 39-40)
                end
            else
                if possibleAge ~= calculatedAge then
                    possibleAge = nil
                end
            end
        end
    end

    return possibleAge
end

-- accepts tables of time+precision values
local function age ( bTable, dTable )
	local possibleAge = "NYA" -- it meansm "Not Yet Assigned", not what you imagined!

	for bKey, bValue in pairs( bTable ) do
		if ( bValue.unknown ) then
			return nil
		end
		local bStructure = bValue.structure
		local bPrecision = bValue.precision

		for dKey, dValue in pairs( dTable ) do
			if ( dValue.unknown ) then
				return nil
			end
			local dStructure = dValue.structure
			local dPrecision = dValue.precision
			if ( bValue.calendar == 'julian' and dValue.calendar == 'gregorian' ) then
				-- to calculate age, need to adjust bStructure to gregorian calendar
				local shift = math.floor(bStructure.year/100-2) - math.floor(bStructure.year/400)
				-- TODO: re-implement this properly
				bStructure.day = bStructure.day + shift
			end

			local calculatedAge = ageImpl ( bStructure, bPrecision, dStructure, dPrecision )
			if ( possibleAge == "NYA" ) then
				possibleAge = calculatedAge
			else
				if ( possibleAge ~= calculatedAge ) then
					possibleAge = nil
				end
			end
		end
	end

	return possibleAge
end

local function ageCurrent(bTable)
    local dTable = {{structure=os.date("*t"), precision=11}} -- Current date with maximum precision
    return age(bTable, dTable)
end

local function parseISO8601Date(str)
	local pattern = "(%-?%d+)%-(%d+)%-(%d+)T"
	local Y, M, D = mw.ustring.match( str, pattern )
	return tonumber(Y), tonumber(M), tonumber(D)
end
 
local function parseISO8601Time(str)
	local pattern = "T(%d+):(%d+):(%d+)%Z"
	local H, M, S = mw.ustring.match( str, pattern)
	return tonumber(H), tonumber(M), tonumber(S)
end
 
local function parseISO8601Offset(str)
	if str:sub(-1)=="Z" then return 0,0 end -- ends with Z, Zulu time
 
	-- matches ±hh:mm, ±hhmm or ±hh; else returns nils 
	local pattern = "([-+])(%d%d):?(%d?%d?)$"
	local sign, oh, om = mw.ustring.match( str, pattern) 
	sign, oh, om = sign or "+", oh or "00", om or "00"
 
	return tonumber(sign .. oh), tonumber(sign .. om)
end

local function parseISO8601(str)
	if 'table' == type(str) then
		if str.args and str.args[1] then
			str = '' .. str.args[1]
		else
			return 'unknown argument type: ' .. type( str ) .. ': ' .. table.tostring( str )
		end
	end

	local Y,M,D = parseISO8601Date(str)
	local h,m,s = parseISO8601Time(str)
	local oh,om = parseISO8601Offset(str)

	if not Y or not M or not D or not h or not m or not s or not oh or not om then
		return nil
	end

	return tonumber(os.time({year=Y, month=M, day=D, hour=(h+oh), min=(m+om), sec=s}))
end

local function parseClaim ( claim )
	if ( claim.mainsnak.snaktype == "value" ) then
		-- The calendar model used for saving the data is always the proleptic Gregorian calendar according to ISO 8601.
		local timeISO8601 = string.gsub( string.gsub( tostring( claim.mainsnak.datavalue.value.time ), '-00%-', '-01-' ), '-00T', '-01T' )
		local unixtime = parseISO8601( timeISO8601 )
		local structure = os.date("*t", unixtime)
		local precision = tonumber( claim.mainsnak.datavalue.value.precision )
		local calendarmodel = 'gregorian'
		if (mw.ustring.find(claim.mainsnak.datavalue.value.calendarmodel, 'Q1985786', 1, true)) then
			calendarmodel = 'julian'
		end
		local item = { structure=structure, precision=precision, calendar = calendarmodel }
		return item
	elseif ( claim.mainsnak.snaktype == "novalue" ) then
		-- novalue
		return { unknown="novalue" }
	else
		--unknown 
		return { unknown="unknown" }
	end
end

-- returns table of time+precision values for specified property
local function parseProperty ( context, options, propertyId )
	if ( not context ) then error( 'context not specified'); end
	if ( not options ) then error( 'options not specified'); end
	if ( not options.entity ) then error( 'options.entity is missing'); end
	if ( not propertyId ) then error( 'propertyId not specified'); end

	local claims = context.selectClaims( options, propertyId )
	if not claims then
		return nil
	end

	local result = {}
	for key, claim in pairs( claims ) do
		table.insert ( result, parseClaim( claim ) )
	end
	return result
end

local function checkDupDates( t )
	if #t > 1 then
		local removed = false
		local j = 1
		while (j <= #t)  do
			local i = 1
			while (i <= #t)  do
				if i ~= j then
					if (os.time(t[j].structure) == os.time(t[i].structure)) then
						if ((t[j].calendarmodel == 'gregorian') and 
							(t[i].calendarmodel == 'julian')) then
							removed = true
							break
						else
							table.remove(t, i)
						end
					else
					  i = i + 1
					end
				else
					i = i + 1
				end
			end
			if removed then
				removed = false
				table.remove(t, j)
			else
				j = j+1
			end
		end
	end
end

-- returns first qualifier of specified propertyId
local function getQualifierWithDataValue( statement, qualifierPropertyId )
	if ( statement.qualifiers
			and statement.qualifiers[qualifierPropertyId] ) then
		local qualifiers = statement.qualifiers[qualifierPropertyId]
		for _, qualifier in ipairs( qualifiers ) do
			if (qualifier.datavalue) then
				return qualifier
			end
		end
	end
	return nil
end

local p = {}

local function formatDecade( time, categoryNamePrefix )
	if ( time.year < 0 ) then
		local year = math.floor( math.abs(time.year) / 10 ) * 10
		if ( categoryNamePrefix ) then
			return '[[e.ə. ' .. inYear(year) .. ' illər|' .. abbrbc .. ' ' .. inYear(year) .. ' illər]][[Kateqoriya:e.ə. ' .. inYear(year) .. ' illərdə ' .. categoryNamePrefix .. ']]'
		else
			return 'e.ə.' .. year .. ''
		end
	else
		local year = math.floor( time.year / 10 ) * 10
		if ( categoryNamePrefix ) then
			return '[[' .. inYear(year) .. ' illər]][[Kateqoriya:' .. inYear(year) .. ' illərdə ' .. categoryNamePrefix .. ']]'
		else
			return '' .. year
		end
	end
end

local function formatCentury( time, categoryNamePrefix )
if ( time.year < 0 ) then
    local century = math.floor( (math.abs( time.year) - 1) / 100 ) + 1;
    local infix = '  ';
    if century == 2 then infix = '  '; end;
    if ( moduleRoman ) then
        century = moduleRoman.toRomanNumber( century )
    end
    if ( categoryNamePrefix ) then
        return '[[e.ə. ' .. century .. ' əsr|' .. abbrbc .. ' ' ..  century .. ' əsr]][[Kateqoriya:e.ə. ' .. century .. ' əsrdə ' .. categoryNamePrefix .. ']]'
    else
        return '[[e.ə. ' .. century .. ' əsr| ' .. century .. ' əsr]]'
    end
else
    local century = math.floor( (time.year - 1) / 100 ) + 1
    local infix = '  '
    if (century == 2) then infix = ' ' end;
    if ( moduleRoman ) then
        century = moduleRoman.toRomanNumber( century )
    end
    if ( categoryNamePrefix ) then
        return '[[' .. century .. ' əsr]][[Kateqoriya:' .. century .. ' əsrdə ' .. categoryNamePrefix .. ']]'
    else
        return '[[' .. century .. ' əsr]]'
		end
	end
end

local function formatMillenium( time, categoryNamePrefix )
	if ( time.year < 0 ) then
		local millenium = math.floor( (math.abs( time.year) - 1) / 1000 ) + 1
        local infix = '  '
        if millenium == 2 then infix = '  '; end
		if ( moduleRoman ) then
			millenium = moduleRoman.toRomanNumber( millenium )
		end
		if ( categoryNamePrefix ) then
			if ( millenium == 2 ) then
				return '[[e.ə. ' .. millenium .. ' minillik|' .. abbrbc .. ' ' ..  millenium .. ' minillik]][[Kateqoriya:e.ə. ' .. millenium .. ' minillikdə ' .. categoryNamePrefix .. ']]'
			else	
				return '[[e.ə. ' .. millenium .. ' minillik|' .. abbrbc .. ' ' ..  millenium .. ' minillik]][[Kateqoriya:e.ə. ' .. millenium .. ' minillikdə ' .. categoryNamePrefix .. ']]'
			end	
		else
			return '[[e.ə. ' .. millenium .. ' minillik|' .. abbrbc .. ' ' ..  millenium .. ' minillik]]'
		end
	else
		local millenium = math.floor( (time.year - 1) / 1000 ) + 1
        local infix = '  ';
        if (millenium == 2) then infix = ' ' end
		if ( moduleRoman ) then
			millenium = moduleRoman.toRomanNumber( millenium )
		end
		if ( categoryNamePrefix ) then
			if ( millenium == 2 ) then
				return '[[' .. millenium .. ' minillik]][[Kateqoriya:' .. millenium .. ' minillikdə ' .. categoryNamePrefix .. ']]'
			else
				return '[[' .. millenium .. ' minillik]][[Kateqoriya:' .. millenium .. ' minillikdə ' .. categoryNamePrefix .. ']]'
			end
		else
			return '[[' .. millenium .. ' minillik]]'
		end
	end
end

local function formatDateImpl( value, options, microformatClass, categoryPrefix, leftBracket, rightBracket, nolinks )
	if ( not value ) then error( 'value not specified'); end
	if ( not options ) then error( 'options not specified'); end

	-- The calendar model used for saving the data is always the proleptic Gregorian calendar according to ISO 8601.
	local timeISO8601 = string.gsub( string.gsub( tostring( value.time ), '-00%-', '-01-' ), '-00T', '-01T' )
	local unixtime = parseISO8601( timeISO8601 )
	
	if not unixtime then
		return ''
	end

	local structure = os.date("*t", unixtime)
	local precision = tonumber( value.precision )
	
	if precision <= 6 then
		return formatMillenium(structure, categoryPrefix)
	end	
	if precision == 7 then
		return formatCentury(structure, categoryPrefix)
	end

	if precision == 8 then
		return formatDecade(structure, categoryPrefix)
	end

	if precision == 9 then
		local tCopy = deepcopy( structure )
		tCopy.day = nil
		tCopy.month = nil
		return moduleDates.formatWikiImpl(tCopy, tCopy, infoclass, categoryPrefix, leftBracket, rightBracket, nolinks )
	end

	-- year and month only
	if precision == 10 then
		local tCopy = deepcopy( structure )
		tCopy.day = nil
		return moduleDates.formatWikiImpl(tCopy, tCopy, infoclass, categoryPrefix, leftBracket, rightBracket, nolinks )
	end

	local calendarmodel = 'gregorian'
	if (mw.ustring.find(value.calendarmodel, 'Q1985786', 1, true)) then
		calendarmodel = 'julian'
	end

	if (calendarmodel == 'gregorian') then
		return moduleDates.formatWikiImpl( structure, structure, microformatClass, categoryPrefix, leftBracket, rightBracket, nolinks )
	else
		return p.formatAsJulian( unixtime, infoclass, categoryPrefix, leftBracket, rightBracket, nolinks )
	end
end

local function formatApproximateDateClaim( context, options, statement, unknownDateCategory )
	if ( not context ) then error( 'context not specified'); end
	if ( not options ) then error( 'options not specified'); end
	if ( not options.entity ) then error( 'options.entity is missing'); end
	if ( not statement ) then error( 'statement not specified'); end
	if options.nocat then unknownDateCategory = "" end
	
	local qNotSoonerThan = getQualifierWithDataValue( statement, 'P1319' )
	local qNotLaterThan = getQualifierWithDataValue( statement, 'P1326' )
	if ( qNotSoonerThan or qNotLaterThan ) then
		local results = {}
		if ( qNotSoonerThan ) then
			local formattedDate = formatDateImpl( qNotSoonerThan.datavalue.value, {}, nil, nil, options.leftBracket, options.rightBracket, options.nolinks )
			local value = 'ən&nbsp;tezi&nbsp;' .. context.wrapSnak( formattedDate, qNotSoonerThan.hash )
			table.insert( results, context.wrapQualifier( value, 'P1319' ) )
		end
		if ( qNotLaterThan ) then
			local formattedDate = formatDateImpl( qNotLaterThan.datavalue.value, {}, nil, nil, options.leftBracket, options.rightBracket, options.nolinks )
			local value = 'ən&nbsp;geci&nbsp;' .. context.wrapSnak( formattedDate, qNotLaterThan.hash )
			table.insert( results, context.wrapQualifier( value, 'P1326' ) )
		end
		return mw.text.listToText( results, ' və ' , ' və ' ) .. unknownDateCategory .. context.formatRefs( options, statement )
	end
	
	return nil
end

	function p.formatDateOfBirthClaim( context, options, statement )
	local value = formatApproximateDateClaim( context, options, statement, dateCat.categoryUnknownBirthDate)
	if value then
		return value
	end

    options['conjunction'] = '&#32;və ya&#32;'
    options['value-module'] = 'Wikidata/date'
    options['value-function'] = 'formatBirthDate'
    options.i18n.somevalue = '\'\'bilinmir\'\'' .. dateCat.categoryUnknownBirthDate
	local result = context.formatStatementDefault( context, options, statement )

	local bTable = { parseClaim( statement ) }
	local dTable = parseProperty ( context, options, 'P570' )

	if ( bTable and not dTable ) then
		local age = ageCurrent( bTable )
		if ( age ) then
			if ( options.suppressAge == nil or options.suppressAge == '' ) then
				result = result .. ' <span style="white-space:nowrap;">(' .. age .. ' ' .. 'yaş' .. ')</span>'
				if ( age >= 100 ) then
					result = result .. dateCat.categoryCentenarians
				end	
			end
			if ( not options.nocat ) then
				if ( age >= 90 and age < 100 ) then
					result = result .. dateCat.categoryBigCurrentAge
				elseif (age >= 0) then
					result = result .. dateCat.categoryBiographiesOfLivingPersons
				else
					result = result .. dateCat.categoryNegativeAge
				end
			end
		end
	end

	return result
end

function p.formatDateOfDeathClaim( context, options, statement )
	local value = formatApproximateDateClaim( context, options, statement, dateCat.categoryUnknownDeathDate )
	if value then
		return value
	end

    options['conjunction'] = '&#32;və ya&#32;';
    options['value-module'] = 'Wikidata/date';
    options['value-function'] = 'formatDeathDate';
    options.i18n.somevalue = '\'\'bilinmir\'\'' .. dateCat.categoryUnknownDeathDate
	local result = context.formatStatementDefault( context, options, statement )

	local bTable = parseProperty ( context, options, 'P569' )
	local dTable = { parseClaim( statement ) };

	if ( bTable and dTable ) then
		local age = age( bTable, dTable )
		if ( age ) then
			if ( options.suppressAge == nil or options.suppressAge == '' ) then
				result = result .. ' <span style="white-space:nowrap;">(' .. age .. ' ' .. 'yaşında' .. ')</span>' .. '[[Kateqoriya:' .. age .. ' yaşında vəfat edənlər]]'
				if ( age >= 100 ) then
					result = result .. dateCat.categoryCentenarians
				end	
			end
			if ( not options.nocat and age < 0) then
				result = result .. dateCat.categoryNegativeAge
			end
		end
		
		-- returns category to recently deceased persons
		local unixAvailable, unixDateOfDeath = pcall(function()
			local r = os.time(dTable[1].structure)
			if ( r ~= os.time() ) then
				return r
			end
			error()
		end)
		if ( unixAvailable and os.time() - unixDateOfDeath < 31536000 and not options.nocat ) then
			result = result .. dateCat.categoryRecentlyDeceased
		end
	end

	return result
end

-- Reentry point for Wikidata Snak formatting
function p.formatBirthDate( context, options, value )
	if ( not context ) then error( 'context not specified'); end
	if ( not options ) then error( 'options not specified'); end
	if ( not value ) then error( 'value not specified'); end
	
	local microformatClass = nil
	if options.microformat ~= '-' then
		microformatClass = options.microformat or 'bday'
	end
	if ( options.nocat ) then
		return formatDateImpl( value, options, microformatClass, nil, options.leftBracket, options.rightBracket, options.nolinks )
	else
		return formatDateImpl( value, options, microformatClass, 'doğulanlar', options.leftBracket, options.rightBracket, options.nolinks )
	end
end

-- Reentry point for Wikidata Snak formatting
function p.formatDeathDate( context, options, value )
	if ( not context ) then error( 'context not specified'); end
	if ( not options ) then error( 'options not specified'); end
	if ( not value ) then error( 'value not specified'); end

	local microformatClass = nil
	if options.microformat ~= '-' then
		microformatClass = options.microformat or 'dday'
	end
	if ( options.nocat and options.nocat ~= '' ) then
		return formatDateImpl( value, options, microformatClass, nil, options.leftBracket, options.rightBracket, options.nolinks )
	else
		return formatDateImpl( value, options, microformatClass, 'vəfat edənlər', options.leftBracket, options.rightBracket, options.nolinks )
	end
end

-- Reentry point for Wikidata Snak formatting -- default one
function p.formatDate( context, options, value )
	if ( not context ) then error( 'context not specified'); end
	if ( not options ) then error( 'options not specified'); end
	if ( not value ) then error( 'value not specified'); end

	local microformatClass = options.microformat or nil
	if ( options.nocat and options.nocat ~= '' ) then
		return formatDateImpl( value, options, microformatClass, nil, options.leftBracket, options.rightBracket, options.nolinks )
	else
		local categoryPrefix = options.categoryPrefix or nil
		return formatDateImpl( value, options, microformatClass, categoryPrefix, options.leftBracket, options.rightBracket, options.nolinks )
	end
end

function p.formatDateIntervalProperty( context, options )
	if ( not context ) then error( 'context not specified' ); end
	if ( not options ) then error( 'options not specified' ); end
	if ( not options.entity ) then error( 'options.entity missing' ); end

	local WDS = require( 'Module:WikidataSelectors' )
	local fromProperty = options.property
	if options.from and options.from ~= '' then
		fromProperty = options.from
	end
	local fromClaims = WDS.filter( options.entity.claims, fromProperty )
	local toClaims = WDS.filter( options.entity.claims, options.to )
	local withinClaims = WDS.filter( options.entity.claims, options.within )

	if fromClaims == nil and toClaims == nil then
		return ''
	end

	local formattedFromClaims = {}
	if fromClaims then
		for i, claim in ipairs( fromClaims ) do
			local formattedStatement = context.formatStatement( options, claim )
			if formattedStatement then
				formattedStatement = '<span class="wikidata-claim" data-wikidata-property-id="' .. string.upper( options.property ) .. '" data-wikidata-claim-id="' .. claim.id .. '">' .. formattedStatement .. '</span>'
				table.insert( formattedFromClaims, formattedStatement )
			end
		end
	end

	local formattedToClaims = {}
	local toOptions = deepcopy( options )
	toOptions.property = options.to
	toOptions.novalue = nowLabel
	if toClaims then
		for i, claim in ipairs( toClaims ) do
			local formattedStatement = context.formatStatement( toOptions, claim )
			if formattedStatement then
				formattedStatement = '<span class="wikidata-claim" data-wikidata-property-id="' .. string.upper( toOptions.property ) .. '" data-wikidata-claim-id="' .. claim.id .. '">' .. formattedStatement .. '</span>'
				table.insert( formattedToClaims, formattedStatement )
			end
		end
	end

	local out = ''
	local fromOut = mw.text.listToText( formattedFromClaims, options.separator, options.conjunction )
	local toOut = mw.text.listToText( formattedToClaims, options.separator, options.conjunction )
	
	if fromOut ~= '' or toOut ~= '' then
		if fromOut ~= '' then
			out = fromOut
		else
			out = '?'
		end

		if toOut ~= '' then
			out = out .. '–' .. toOut
		else
			local withinClaims = nil
			if options.within then
				WDS.filter( options.entity.claims, options.within )
			end
			if withinClaims ~= nil then
				out = '' .. out
			else
				out = out .. '–' .. nowLabel
			end
		end
	end

	if out ~= '' then
		if options.before then
			out = options.before .. out
		end
		if options.after then
			out = out .. options.after
		end
	end

	return out
end

local lowestBoundary = parseISO8601('-900-02-20T00:00:00Z')
local mainBoundary = parseISO8601('1582-10-05T00:00:00Z')
local lastBoundary = parseISO8601('1918-01-31T00:00:00Z')

local boundaries = {
	-- from (G) till next will be diff(G = J + diff), at current
	{ lowestBoundary,                       -9 },
	{ parseISO8601('-700-02-29T00:00:00Z'), -8 },
	{ parseISO8601('-600-02-29T00:00:00Z'), -7 },
	{ parseISO8601('-500-02-29T00:00:00Z'), -6 },
	{ parseISO8601('-300-02-29T00:00:00Z'), -5 },
	{ parseISO8601('-200-02-29T00:00:00Z'), -4 },
	{ parseISO8601('-100-02-29T00:00:00Z'), -3 },
	{ parseISO8601('0000-00-00T00:00:00Z'), -2 },
	{ parseISO8601('0100-02-29T00:00:00Z'), -1 },
	{ parseISO8601('0200-02-29T00:00:00Z'),  0 },
	{ parseISO8601('0300-02-29T00:00:00Z'),  1 },
	{ parseISO8601('0500-02-29T00:00:00Z'),  2 },
	{ parseISO8601('0600-02-29T00:00:00Z'),  3 },
	{ parseISO8601('0700-02-29T00:00:00Z'),  4 },
	{ parseISO8601('0900-02-29T00:00:00Z'),  5 },
	{ parseISO8601('1000-02-29T00:00:00Z'),  6 },
	{ parseISO8601('1100-02-29T00:00:00Z'),  7 },
	{ parseISO8601('1300-02-29T00:00:00Z'),  8 },
	{ parseISO8601('1400-02-29T00:00:00Z'),  9 },
	{ parseISO8601('1500-02-29T00:00:00Z'), 10 },
	{ parseISO8601('1700-02-29T00:00:00Z'), 11 },
	{ parseISO8601('1800-02-29T00:00:00Z'), 12 },
	{ parseISO8601('1900-02-29T00:00:00Z'), 13 },
	{ lastBoundary, '' },
}

function p.formatAsJulian( julTime, infocardClass, categoryNamePrefix, leftBracket, rightBracket, nolinks )
	if 'table' == type( julTime ) then
		if julTime.args and julTime.args[1] then
			julTime = tonumber( julTime.args[1] )
		else
			return 'unknown argument type: ' .. type( julTime ) .. ': ' .. table.tostring( julTime )
		end
	end

	local t = os.date( "*t", julTime )
	if ( julTime <= lowestBoundary ) then
		return "''yanlış tarix (etibarsız dəqiqlik)''"
	end
	if ( julTime >= lastBoundary ) then
		return "''yanlış tarix (yuli təqvimi 1918-01-26 tarixindən sonra istifadə olunmur)''"
	end

	for i=1,#boundaries,1 do
		local b1 = boundaries[i][1]
		local b2 = boundaries[i + 1][1]
		if ( b1 <= julTime and julTime < b2 ) then
			local b1s = os.date( "*t", b1 )
			if ( b1s.year == t.year and b1s.month == t.month and b1s.day == t.day) then
				if ( julTime < mainBoundary ) then
					-- only julian
					return moduleDates.formatWikiImpl( {year=t.year, month=2, day=29}, {year=t.year, month=2, day=29}, infocardClass, categoryNamePrefix, leftBracket, rightBracket, nolinks )
				else
					--julian and grigorian
					return moduleDates.formatWikiImpl( {year=t.year, month=2, day=29}, t, infocardClass, categoryNamePrefix, leftBracket, rightBracket, nolinks )
				end
			else
				local gregTime = os.date( "*t", julTime + boundaries[i][2] * 24 * 60 * 60 )
				if ( julTime < mainBoundary ) then
					-- only julian
					return moduleDates.formatWikiImpl( t, t, infocardClass, categoryNamePrefix, leftBracket, rightBracket, nolinks )
				else
					--julian and grigorian
					return moduleDates.formatWikiImpl( t, gregTime, infocardClass, categoryNamePrefix, leftBracket, rightBracket, nolinks )
				end
			end
		end
	end

	if ( julTime >= lastBoundary ) then
		return "''Modul:Wikidata/date daxilində xəta (təqvim çevirməsi olunmadı)''"
	end
end

return p