ᱢᱳᱰᱩᱞ:Year in various calendars

ᱮᱴᱟᱜ ᱯᱟᱹᱧᱡᱤ ᱨᱮ ᱒᱐᱒᱔
ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱐᱒᱔; MMXXIV
ᱟᱵᱽ ᱩᱨᱵᱮ ᱠᱳᱱᱰᱤᱛᱟ	᱒᱗᱗᱗
ᱟᱨᱢᱮᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱗᱓; ԹՎ ՌՆՀԳ
ᱮᱥᱤᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱖᱗᱗᱔
ᱵᱟᱦᱟᱭ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱘᱐–᱑᱘᱑
ᱵᱟᱝᱞᱟ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱓᱐–᱑᱔᱓᱑
ᱵᱟᱨᱵᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱙᱗᱔
ᱵᱩᱫᱫᱷᱚ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱕᱖᱘
ᱵᱚᱨᱢᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱓᱘᱖
ᱵᱟᱭᱡᱮᱱᱴᱟᱭᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱗᱕᱓᱒–᱗᱕᱓᱓
ᱪᱟᱭᱱᱤᱡᱽ ᱠᱮᱞᱮᱱᱰᱟᱨ	癸卯年 (ᱫᱟᱜ ᱠᱩᱞᱟᱹᱭ); ᱔᱗᱒᱐ ᱥᱮ ᱔᱖᱖᱐; — ᱠᱷᱚᱱ —; 甲辰年 (ᱠᱟᱴᱷ ᱰᱨᱟᱜᱚᱱ); ᱔᱗᱒᱑ ᱥᱮ ᱔᱖᱖᱑
ᱠᱚᱯᱴᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱗᱔᱐–᱑᱗᱔᱑
ᱰᱤᱥᱠᱳᱨᱰᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱓᱑᱙᱐
ᱤᱛᱷᱤᱭᱳᱯᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱐᱑᱖–᱒᱐᱑᱗
ᱦᱤᱵᱽᱨᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱕᱗᱘᱔–᱕᱗᱘᱕
ᱦᱤᱱᱫᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ
- ᱵᱤᱠᱨᱚᱢ ᱥᱚᱝᱵᱚᱫ	᱒᱐᱘᱐–᱒᱐᱘᱑
- ᱥᱚᱠᱟ ᱥᱚᱝᱵᱚᱫ	᱑᱙᱔᱕–᱑᱙᱔᱖
- ᱠᱚᱞᱤ ᱡᱩᱜᱽ	᱕᱑᱒᱔–᱕᱑᱒᱕
ᱦᱚᱞᱚᱥᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱒᱐᱒᱔
ᱤᱜᱽᱵᱳ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱐᱒᱔–᱑᱐᱒᱕
ᱤᱨᱟᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱐᱒–᱑᱔᱐᱓
ᱤᱥᱞᱟᱢ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱔᱕–᱑᱔᱔᱖
ᱡᱩᱥ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱑᱓
ᱡᱩᱞᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱵᱷᱮᱜᱮᱫ ᱑᱓ ᱢᱟᱦᱟᱸ
ᱠᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱔᱓᱕᱗
ᱢᱤᱝᱜᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ	ᱯᱨᱚ. ᱪᱤᱱ ᱑᱑᱓; 民國᱑᱑᱓年
ᱛᱷᱟᱭ ᱥᱳᱞᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱕᱖᱗
ᱤᱣᱱᱤᱠᱥ ᱚᱠᱛᱚ	᱑᱗᱐᱔᱐᱖᱗᱒᱐᱐ – ᱑᱗᱓᱕᱖᱘᱙᱕᱙᱙
	This box: view; talk; edit;

ᱮᱴᱟᱜ ᱯᱟᱹᱧᱡᱤ ᱨᱮ ᱒᱐᱒᱔
ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱐᱒᱔; MMXXIV
ᱟᱵᱽ ᱩᱨᱵᱮ ᱠᱳᱱᱰᱤᱛᱟ	᱒᱗᱗᱗
ᱟᱨᱢᱮᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱗᱓; ԹՎ ՌՆՀԳ
ᱮᱥᱤᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱖᱗᱗᱔
ᱵᱟᱦᱟᱭ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱘᱐–᱑᱘᱑
ᱵᱟᱝᱞᱟ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱓᱐–᱑᱔᱓᱑
ᱵᱟᱨᱵᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱙᱗᱔
ᱵᱩᱫᱫᱷᱚ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱕᱖᱘
ᱵᱚᱨᱢᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱓᱘᱖
ᱵᱟᱭᱡᱮᱱᱴᱟᱭᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱗᱕᱓᱒–᱗᱕᱓᱓
ᱪᱟᱭᱱᱤᱡᱽ ᱠᱮᱞᱮᱱᱰᱟᱨ	癸卯年 (ᱫᱟᱜ ᱠᱩᱞᱟᱹᱭ); ᱔᱗᱒᱐ ᱥᱮ ᱔᱖᱖᱐; — ᱠᱷᱚᱱ —; 甲辰年 (ᱠᱟᱴᱷ ᱰᱨᱟᱜᱚᱱ); ᱔᱗᱒᱑ ᱥᱮ ᱔᱖᱖᱑
ᱠᱚᱯᱴᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱗᱔᱐–᱑᱗᱔᱑
ᱰᱤᱥᱠᱳᱨᱰᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱓᱑᱙᱐
ᱤᱛᱷᱤᱭᱳᱯᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱐᱑᱖–᱒᱐᱑᱗
ᱦᱤᱵᱽᱨᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱕᱗᱘᱔–᱕᱗᱘᱕
ᱦᱤᱱᱫᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ
- ᱵᱤᱠᱨᱚᱢ ᱥᱚᱝᱵᱚᱫ	᱒᱐᱘᱐–᱒᱐᱘᱑
- ᱥᱚᱠᱟ ᱥᱚᱝᱵᱚᱫ	᱑᱙᱔᱕–᱑᱙᱔᱖
- ᱠᱚᱞᱤ ᱡᱩᱜᱽ	᱕᱑᱒᱔–᱕᱑᱒᱕
ᱦᱚᱞᱚᱥᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱒᱐᱒᱔
ᱤᱜᱽᱵᱳ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱐᱒᱔–᱑᱐᱒᱕
ᱤᱨᱟᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱐᱒–᱑᱔᱐᱓
ᱤᱥᱞᱟᱢ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱔᱔᱕–᱑᱔᱔᱖
ᱡᱩᱥ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱑᱑᱓
ᱡᱩᱞᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱵᱷᱮᱜᱮᱫ ᱑᱓ ᱢᱟᱦᱟᱸ
ᱠᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱔᱓᱕᱗
ᱢᱤᱝᱜᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ	ᱯᱨᱚ. ᱪᱤᱱ ᱑᱑᱓; 民國᱑᱑᱓年
ᱛᱷᱟᱭ ᱥᱳᱞᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ	᱒᱕᱖᱗
ᱤᱣᱱᱤᱠᱥ ᱚᱠᱛᱚ	᱑᱗᱐᱔᱐᱖᱗᱒᱐᱐ – ᱑᱗᱓᱕᱖᱘᱙᱕᱙᱙
	This box: view; talk; edit;

This module is rated as beta, and is ready for widespread use. It is still new and should be used with some caution to ensure the results are as expected.

This module produces the sidebar opposite displaying a given Gregorian year in various different calendars.

Syntax

Simple

{{ᱪᱷᱟᱸᱪ:Hashinvoke:Year in various calendars|main}}

All parameters

{{ᱪᱷᱟᱸᱪ:Hashinvoke:Year in various calendars|main |year=(n) |footnotes=(footnotes) |gregcal=(article name)}}

Parameters

year: Number specifying the year to be displayed. This can be negative and also can be in the format "n BC" to display BC dates or "AD n" as an alternative to a positive number. If not specified, the current year is used.
footnotes: Any footnotes to be placed at the bottom of the sidebar.
gregcal: Name of an article to be displayed for Gregorian and Julian years (e.g. "2000 BC"). Do not include square brackets.

Microformat

ᱪᱷᱟᱸᱪ:UF-hcal-auto

Adding new calendars

The module is set up to allow for easy addition of new calendars. Just scroll down to the "Build the box" section of the module code, and add your calendar as follows:

To display one year:

    local myCalendar = calendar:new()
    myCalendar:setLink( 'My calendar article' ) -- The name of the calendar's Wikipedia article.
    myCalendar:setYear( year + 10 ) -- Lua code linking the Gregorian calendar year to your calendar's year.
    box:addCalendar( myCalendar )

To display a year range:

    local myCalendar = calendar:new()
    myCalendar:setLink( 'My calendar article' ) -- The name of the calendar's Wikipedia article.
    myCalendar:setYearRange( year + 10, year + 11 ) -- Lua code outputting the start year and the end year of the year range.
    box:addCalendar( myCalendar )

More complicated calendars can be passed as a string to calendar:setYear().

Technical details

The module defines three classes which do the work of setting up the sidebar and displaying the data provided by the calendar functions. These are the calendarBox class, which defines the sidebar; the calendar class, which holds the data for one calendar; and the calendarGroup object, which defines a group of calendar objects with a heading.

To load these classes from another module, use the following:

local yearInOtherCalendars = require( 'Module:Year in various calendars' )
local calendarBox = yearInOtherCalendars.calendarBox
local calendarGroup = yearInOtherCalendars.calendarGroup
local calendar = yearInOtherCalendars.calendar

calendarBox class

A calendarBox object is initiated with:

local myCalendarBox = calendarBox:new{ year = yyyy, footnotes = footnotes, navbar = page name }

year - sets the Gregorian year to base calendar calculations on. If not specified, the current year is used.
footnotes - sets text to be displayed in a footnotes section at the bottom of the sidebar.
navbar - sets the page name to be used by the navbar.

Calendar box objects have the following properties:

calendarBox.year - the Gregorian year number. This is negative for BC years; for example, for the year 100 BC the value of calendarBox.year is -99. (BC years are calculated by "1 - n" rather than "0 - n", as there is no year zero.)
calendarBox.yearText - the Gregorian year text. This is a string value of the format "n" for AD years and "n BC" for BC years.
calendarBox.caption - the text of the box caption (the bold text that appears directly above the box). The default caption is the value of calendarBox.yearText.
calendarBox.footnotes - the text of the box footnotes.
calendarBox.navbar - the page name used by the navbar.

Calendar box objects have the following methods:

calendarBox:setCaption( caption ) - sets the box caption (the bold text that appears directly above the box). The default caption is the value of calendarBox.yearText.
calendarBox:addCalendar( obj ) - adds a calendar object or a calendar group object to the calendar box.
calendarBox:addCalendarGroup( obj ) - an alias for myCalendarBox:addCalendar().
calendarBox:export() - converts the calendar box object to wikicode. This calls calendar:export() and calendarGroup:export() to export calendar objects and calendar group objects.

calendar class

A calendar object is initiated with:

local myCalendar = calendar:new()

Calendar objects have the following properties:

calendar.link - the link name.
calendar.year - the year value. This is always a string value.

Calendar objects have the following methods:

calendar:setLink( link, display ) - sets the link name for the calendar object. link is the name of Wikipedia's article about the calendar, and display is an optional display name for the article link.
calendar:setRawLink( wikitext ) - sets the calendar link as raw wikitext.
calendar:getLink() - gets the link value.
calendar:setYear( year ) - sets the year value for the calendar. year can be a number or a string.
calendar:setYearRange( startYear, endYear ) - sets the year value for the calendar as a year range. Both startYear and endYear must be number values.
calendar:export() - exports the calendar to wikitext. If no link value was found, this returns nil. If a link was found but no year value was found, the calendar is output with a value of N/A for the year.

calendarGroup class

A calendarGroup object is initiated with:

local myCalendarGroup = calendarGroup:new{ heading = heading }

heading - the wikitext heading for the calendar group (e.g. [[Hindu calendar]]s).

Calendar group objects have one property:

calendarGroup.heading - the calendar group heading text.

Calendar group objects have the following methods:

calendarGroup:addCalendar( obj ) - adds a calendar object to the calendar group.
calendarGroup:export() - converts a calendar group to wikitext. Calls calendar:export() to export individual calendar objects.

-- Load dependencies.
local getArgs = require('Module:Arguments').getArgs
local SongkhaRupantor = require( 'Module:Numeral converter' ).convert
local numToRoman = require( 'Module:Roman' ).main
-- local getOlympiad = require( 'Module:Ancient Olympiads' )._main
-- local getDynasty = require( 'Module:Ancient Egypt era' )._main
-- local getPharaoh = require( 'Module:Ancient Egypt kings' )._main
local numToArmenian = require( 'Module:Armenian' ).main
-- local getRegnal = require( 'Module:British regnal year' ).main
-- local japaneseEra = require( 'Module:Japanese calendar' ).era()

-- Define constants.
local lang = mw.getLanguage('en')
local currentYear = tonumber( lang:formatDate( 'Y' ) )

--------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------

local function isInteger( num )
	-- Checks if a value is an integer. If so, returns the value converted to a number.
	-- If not, returns false.
	num = tonumber( num )
	if num and math.floor( num ) == num and num ~= math.huge then
		return num
	else
		return false
	end
end

local function BCToNum( s )
	-- Converts strings of the format "n BC" to their corresponding
	-- numerical values.
	if type( s ) ~= 'string' then
		return nil
	end
	s = s:match('^([1-9]%d*)%s*[Bb][Cc]$') or s:match('^ᱵᱤ.ᱥᱤ%s*([1-9]%d*)$')
	if not s then
		return nil
	end
	local num = tonumber( s )
	num = ( num - 1 ) * -1
	return num
end

local function numToBC( num )
	-- For BC years, returns a string with the year name appended with " BC".
	-- Otherwise returns nil.
	num = isInteger( num )
	if not num then return end
	if num <= 0 then
		return 'ᱵᱤ.ᱥᱤ ' .. (1 - num)
	end
end

local function formatNegative(s)
	-- Replaces hyphens in a string with minus signs if the hyphen comes before a number.
	s = mw.ustring.gsub( s, '%-(%d)', '−%1' )
	return s
end

--------------------------------------------------------------------
-- Calendar box class definition
--------------------------------------------------------------------

local calendarBox = {}
calendarBox.__index = calendarBox

function calendarBox:new( init )
	init = type( init ) == 'table' and init or {}
	local obj = {}
	local pagename = mw.ustring.gsub(SongkhaRupantor('en', mw.title.getCurrentTitle().text), '[^%d]+', '')

	-- Set the year. If the year is specified as an argument, use that.
	-- Otherwise, use the page name if it is valid. If the pagename isn't
	-- valid, use the current year.
	local yearNum = isInteger( SongkhaRupantor('en', init.year) )
	if yearNum then -- First, see if the year parameter is a number.
		self.year = yearNum
	else
		local yearBC = BCToNum( SongkhaRupantor('en', init.year) )
		if yearBC then -- Second, see if the year parameter is a "yyyy BC" string.
			self.year = yearBC
		else
			local pageNum = isInteger( pagename )
			if pageNum then -- Third, see if the pagename is an integer.
				self.year = pageNum
			else
				local pageBC = BCToNum( pagename )
				if pageBC then -- Fourth, see if the pagename is a "yyyy BC" string.
					self.year = pageBC
				else
					self.year = currentYear -- If none of the above apply, use the current year.
				end
			end
		end
	end

	-- Set year text values.
	self.BCYearName = numToBC( self.year )
	if self.BCYearName then
		self.yearText = self.BCYearName
	else
		self.yearText = tostring( self.year )
	end

	-- Set other fields.
	self.caption = self.yearText
	self.footnotes = init.footnotes
	self.navbar = init.navbar

	return setmetatable( obj, {
			__index = self
		})
end

function calendarBox:setCaption( s )
	-- Sets the calendar box caption.
	if type( s ) ~= 'string' or s == '' then return end
	self.caption = s
end

function calendarBox:addCalendar( obj )
	-- Adds a calendar or a calendar group.
	if type( obj ) ~= 'table' and type( obj.new ) ~= 'function' then return end -- Exit if the object is invalid.
	self.calendars = self.calendars or {}
	table.insert( self.calendars, obj )
end

-- Add an alias for adding calendar groups. The function is the same, but it might be confusing for users
-- to have to use the name "addCalendar" for a calendar group.
calendarBox.addCalendarGroup = calendarBox.addCalendar

function calendarBox:export()
	-- Outputs the calendar box wikitext.
	local root = mw.html.create( 'table' )
	-- Export the calendar box headers.
	root
	:addClass( 'infobox vevent' )
	:css( 'width', '22em' )
	:tag( 'caption' )
	:css( 'font-size', '125%' )
	:tag( 'span' )
	:addClass( 'summary dtstart' )
	:wikitext( self.caption )

	-- Export the calendars and calendar groups. "calendar:export()" works for both kinds
	-- of objects. Some export functions can return nil, so we need to check for that.
	if type( self.calendars ) == 'table' then
		for _, calendar in ipairs( self.calendars ) do
			local calendarText = calendar:export()
			if type( calendarText ) == 'string' then
				root:wikitext( calendarText )
			end
		end
	end

	-- Add footnotes.
	if type( self.footnotes ) == 'string' and self.footnotes ~= '' then
		root
		:tag( 'tr' )
		:tag( 'td' )
		:attr( 'colspan', '2' )
		:wikitext( string.format( '<small>%s</small>', self.footnotes ) )
	end

	-- Add navbar.
	if type( self.navbar ) == 'string' and self.navbar ~= '' then
		root
		:tag( 'tr' )
		:tag( 'td' )
		:attr( 'colspan', '2' )
		:css( 'text-align', 'center' )
		:wikitext( require('Module:Navbar')._navbar{ self.navbar } )
	end

	return tostring( root )
end

--------------------------------------------------------------------
-- Calendar group class definition
--------------------------------------------------------------------

--  Calendar groups are used to group different calendars together. 
--  Previously, the template did this by including a table row with
--  no year value. By using objects we can do the same thing more
--  semantically.

local calendarGroup = {}
calendarGroup.__index = calendarGroup

function calendarGroup:new( init )
	init = type( init ) == 'table' and init or {}
	local obj = {}

	-- Get the heading and throw an error if it is invalid.
	obj.heading = init.heading
	if type( obj.heading ) ~= 'string' then
		error( 'calendarGroup: ᱚᱠᱟ ᱢᱩᱬᱩᱛ ᱧᱩᱛᱩᱢ ᱦᱚᱸ ᱵᱟᱝ ᱪᱤᱱᱦᱟᱹᱯ ᱟᱠᱟᱱᱟ' )
	end

	-- Set the metatable and return the object.
	self.__index = self
	return setmetatable( obj, {
			__index = self
		})
end

function calendarGroup:addCalendar( calendar )
	-- Adds a calendar object to the calendar group.
	self.calendars = self.calendars or {}
	if type( calendar ) == 'table' and type( calendar.getLink ) == 'function' then
		table.insert( self.calendars, calendar )
	end
end

function calendarGroup:export()
	-- Exports the calendar group's wikitext.
	-- Indent and italicise each calendar's link if it exists.
	for i, calendar in ipairs( self.calendars ) do
		local link = calendar:getLink()
		if type( link ) == 'string' then
			self.calendars[ i ]:setRawLink( string.format( "&nbsp;- ''%s''", link ) )
		end
	end
	-- Create the heading row html and export the calendar objects.
	local ret = mw.html.create()
	ret
	:tag( 'tr' )
	:tag( 'td' )
	:wikitext( self.heading )
	:done()
	:tag( 'td' ) -- Use a blank tag to make the html look nice.
	:allDone()
	for _, calendar in ipairs( self.calendars ) do
		ret:wikitext( calendar:export() )
	end
	return tostring( ret )
end

--------------------------------------------------------------------
-- Calendar class definition
--------------------------------------------------------------------

local calendar = {}
calendar.__index = calendar
calendar.type = 'calendar'

function calendar:new()
	local obj = {}
	return setmetatable( obj, {
			__index = self
		})
end

function calendar:setLink( link, display )
	-- Sets the calendar's wikilink, with optional display text and italics.
	if type( link ) ~= 'string' or link == '' then return end
	display = type( display ) == 'string' and display ~= '' and display
	if display then
		self.link = string.format( '[[%s|%s]]', link, display )
	else
		self.link = string.format( '[[%s]]', link )
	end
end

function calendar:setRawLink( s )
	-- Sets the calendar's wikilink as raw wikitext.
	if type( s ) ~= 'string' or s == '' then return end
	self.link = s
end

function calendar:getLink()
	-- Returns the calendar's link value.
	return self.link
end

function calendar:setYear( year )
	-- Sets a single year. Can be passed either a string or a number.
	-- If passed as a number, it is formatted with minus signs instead of hyphens.
	-- If passed as a string, no minus-sign formatting occurs; this should be done in the individual calendar definitions.
	if type( year ) == 'number' then
		year = tostring( year )
		self.year = formatNegative( year )
	elseif type( year ) == 'string' then
		self.year = year
	end
end

function calendar:setYearRange( year1, year2 )
	-- Sets a year range. Must be passed two numbers.
	if type( year1 ) == 'number' and type( year2 ) == 'number' then
		local year
		if year1 < 0 or year2 < 0 then -- Leave a gap for negative years to avoid having a minus sign and a dash right next to each other.
			year = string.format( '%d – %d', year1, year2 )
			year = formatNegative( year )
		else
			year = string.format( '%d–%d', year1, year2 )
		end
		self.year = year
	end
end

function calendar:setYearCouple( year1, year2 )
	-- Same as setYearRange, only with a slash (/) in the middle. Must be passed two numbers. 
	-- Additional text possible, must be defined as follows: addtext = string.format( 'additional text or link')
	-- See example in Seleucid era calendar
	if type( year1 ) == 'number' and type( year2 ) == 'number' then
		local year
		if year1 < 0 or year2 < 0 then -- Leave no gap for negative years.
			year = string.format( '%d/%d %s', year1, year2, addtext )
			year = formatNegative( year )
		else
			year = string.format( '%d/%d %s', year1, year2, addtext )
		end
		self.year = year
	end
end

function calendar:export()
	-- Outputs the calendar wikitext.
	-- Exit if no link has been specified.
	local link = self.link
	if type( link ) ~= 'string' or link == '' then return end

	-- If no year has been specified, set the year value to N/A.
	local year = self.year
	if type( year ) ~= 'string' or year == '' then
		year = "''ᱵᱟᱝ ᱟᱹᱢᱟᱹᱞᱮᱛ''" -- N/A
	end

	-- Build the table row.
	local ret = mw.html.create()
	ret
	:tag( 'tr' )
	:tag( 'td' )
	:wikitext( link )
	:done()
	:tag( 'td' )
	:wikitext( SongkhaRupantor('bn', year) )
	:allDone()
	return tostring( ret )
end

--------------------------------------------------------------------
-- Build the box
--------------------------------------------------------------------

local function makeCalendarBox( args )
	-- Initiate the box and get the year values.
	local init = args
	init.navbar = 'ᱮᱴᱟᱜ ᱯᱟᱹᱧᱡᱤ ᱨᱮᱭᱟᱜ ᱥᱮᱨᱢᱟ'
	local box = calendarBox:new( init )
	local year = box.year
	local yearText = box.yearText

	-- Set the caption.
	box:setCaption( 'ᱮᱴᱟᱜ ᱯᱟᱹᱧᱡᱤ ᱨᱮ ' .. SongkhaRupantor('bn', box.caption))

	----------------------------------------------------------------------
	-- ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local gregorian = calendar:new()
	gregorian:setLink( 'ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	-- Get the year link.
	local gregcal = args.gregcal
	if type( gregcal ) == 'string' and gregcal ~= '' then
		gregorian.yearLink = string.format( '[[%s|%s]]', gregcal, yearText )
	else
		gregorian.yearLink = yearText
	end
	-- Set the year.
	gregorian.romanYear = (year < 0 and 'ᱵᱤ.ᱥᱤ ' or '') .. numToRoman{ math.abs(year) }
	if gregorian.romanYear then
		gregorian:setYear( string.format(
				[[%s<br /><span style="font-family: serif;">''%s''</span>]],
				gregorian.yearLink, gregorian.romanYear
				) )
	else
		gregorian:setYear( gregorian.yearLink )
	end
	box:addCalendar( gregorian ) 
	
		----------------------------------------------------------------------
	-- ᱯᱷᱨᱮᱸᱪ ᱯᱨᱚᱡᱟᱛᱟᱱᱛᱨᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ
	-- displays only in years 1793 - 1805 and 1871
	-- This calendar was in use and had defined years only for the short period on display.
	-- Its importance during these few years is also the reason why it should stay out of the alphabetic order.
	-- See discussion on talk page.
	----------------------------------------------------------------------
	
	if year >= 1793 and year < 1806 or year == 1871 then
		local republican = calendar:new()
		republican:setLink('ᱯᱷᱨᱮᱸᱪ ᱯᱨᱚᱡᱟᱛᱟᱱᱛᱨᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ')
		if year <= 1870 then
			republican:setYearRange( year - 1792, year - 1791 )
		elseif year == 1871 then
			republican:setYear( year - 1792 ) -- Paris Commune, May
		end
		box:addCalendar( republican )
	end
	
	----------------------------------------------------------------------
	-- ᱟᱵᱽ ᱩᱨᱵᱮ ᱠᱳᱱᱰᱤᱛᱟ
	-- Varro's correlation, from 1 AUC
	----------------------------------------------------------------------
	if year >= -752 then
		local abUrbe = calendar:new()
		abUrbe:setLink( 'ᱟᱵᱽ ᱩᱨᱵᱮ ᱠᱳᱱᱰᱤᱛᱟ' )
		abUrbe:setYear( year + 753 )
		box:addCalendar( abUrbe )
	end
	
	----------------------------------------------------------------------
	-- ᱢᱟᱨᱮ ᱢᱤᱥᱚᱨ ᱡᱩᱜᱽ
	-- Displays dynasty between 1549 BC and 30 BC
	-- Displays pharaoh or king between 752 BC and 30 BC
	----------------------------------------------------------------------
--	if year > -1549 and year <= -29 then
--	local ancEgypt = calendar:new()
--	ancEgypt:setLink(
--			'Egyptian chronology',
--			'Ancient Egypt era'
--		)
--	ancEgypt:setYear( getDynasty( year ) )
--	box:addCalendar( ancEgypt )
--	end
--	if year > - 752 and year <= -29 then
--	local ancPharaoh = calendar:new()
--	ancPharaoh:setLink(
--			'List of pharaohs',
--			'<i>- Pharaoh</i>'
--		)
--	ancPharaoh:setYear( getPharaoh( year ) )
--	box:addCalendar( ancPharaoh )
--	end

	----------------------------------------------------------------------
	-- ᱢᱟᱨᱮ ᱚᱞᱤᱢᱯᱤᱭᱟᱰ 
	-- Currently only the first 194 Olympiads
	-- May be expanded until 394 AD when data available
	----------------------------------------------------------------------
--	if year >= -1300 and year < 1 then
--	local ancOlympiads = calendar:new()
--	ancOlympiads:setLink(
--			'Ancient Greek calendar',
--			'Ancient Greek era'
--		)
--	ancOlympiads:setYear( getOlympiad( year ) )
--	box:addCalendar( ancOlympiads )
--	end

	----------------------------------------------------------------------
	-- ᱟᱨᱢᱮᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	if year > 551 then
	local armenian = calendar:new()
	armenian:setLink( 'ᱟᱨᱢᱮᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
		local armenianYear = year - 551
		armenian:setYear( string.format( '%s<br />ԹՎ %s', armenianYear, numToArmenian( armenianYear ) ) )
	box:addCalendar( armenian )
	end

	----------------------------------------------------------------------
	-- ᱮᱥᱤᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local assyrian = calendar:new()
	assyrian:setLink( 'ᱮᱥᱤᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	assyrian:setYear( year + 4750 )
	box:addCalendar( assyrian )

	----------------------------------------------------------------------
	-- ᱵᱟᱦᱟᱭ ᱠᱮᱞᱮᱱᱰᱟᱨ
	-- displays only after 1843
	----------------------------------------------------------------------
	
	if year >= 1844 then
		local bahai = calendar:new()
		bahai:setLink( "ᱵᱟᱦᱟᱭ ᱠᱮᱞᱮᱱᱰᱟᱨ" )
		bahai:setYearRange( year - 1844, year - 1843 )
		box:addCalendar( bahai )
	end

	----------------------------------------------------------------------
	-- ᱵᱟᱝᱞᱟ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local bengali = calendar:new()
	bengali:setLink( 'ᱵᱚᱝᱜᱟᱵᱽᱫᱚ', 'ᱵᱟᱝᱞᱟ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	bengali:setYearRange( year - 594, year - 593 )
	box:addCalendar( bengali )

	----------------------------------------------------------------------
	-- ᱵᱟᱨᱵᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local berber = calendar:new()
	berber:setLink( 'ᱵᱟᱨᱵᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	berber:setYear( year + 950 )
	box:addCalendar( berber )

	----------------------------------------------------------------------
	-- ᱨᱮᱡᱽᱱᱟᱞ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

--	if year >= 1000 then
--		local regnal = calendar:new()
--		local regnalName
--		if year > 1706 then
--			regnalName = 'British'
--		else
--			regnalName = 'English'
--		end
--		regnal:setLink( 'Regnal years of English monarchs', regnalName .. ' Regnal year' )
--		regnal:setYear( getRegnal( year ) )
--		box:addCalendar( regnal )
--	end

	----------------------------------------------------------------------
	-- ᱵᱩᱫᱫᱷᱚ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local buddhist = calendar:new()
	buddhist:setLink( 'ᱵᱩᱫᱫᱷᱟᱵᱽᱫᱚ', 'ᱵᱩᱫᱫᱷᱚ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	buddhist:setYear( year + 544 )
	box:addCalendar( buddhist )

	----------------------------------------------------------------------
	-- ᱵᱚᱨᱢᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local burmese = calendar:new()
	burmese:setLink( 'ᱵᱚᱨᱢᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	burmese:setYear( year - 638 )
	box:addCalendar( burmese )

	----------------------------------------------------------------------
	-- ᱵᱟᱭᱡᱮᱱᱴᱟᱭᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local byzantine = calendar:new()
	byzantine:setLink( 'ᱵᱟᱭᱡᱮᱱᱴᱟᱭᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	byzantine:setYearRange( year + 5508, year + 5509 )
	box:addCalendar( byzantine )

	----------------------------------------------------------------------
	-- ᱪᱟᱭᱱᱤᱡᱽ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local chinese = calendar:new()
	chinese:setLink( 'ᱪᱟᱭᱱᱤᱡᱽ ᱠᱮᱞᱮᱱᱰᱟᱨ' )

	-- Define the information for the "heavenly stems" and "earthly branches" year cycles.
	-- See [[Chinese calendar#Cycle of years]] for information.

	local heavenlyStems = {
		{ '甲', 'ᱠᱟᱴᱷ' },   -- 1
		{ '乙', 'ᱠᱟᱴᱷ' },   -- 2
		{ '丙', 'ᱥᱮᱸᱜᱮᱞ' },   -- 3
		{ '丁', 'ᱥᱮᱸᱜᱮᱞ' },   -- 4
		{ '戊', 'ᱫᱷᱟᱹᱨᱛᱤ' },  -- 5
		{ '己', 'ᱫᱷᱟᱹᱛᱨᱤ' },  -- 6
		{ '庚', 'ᱫᱷᱟᱹᱛᱩ' },  -- 7
		{ '辛', 'ᱫᱷᱟᱹᱛᱩ' },  -- 8
		{ '壬', 'ᱫᱟᱜ' },  -- 9
		{ '癸', 'ᱫᱟᱜ' }   -- 10
	}

	local earthlyBranches = {
		{ '子', '[[Rat (zodiac)|ᱜᱩᱰᱩ]]' },           -- 1
		{ '丑', '[[Ox (zodiac)|ᱥᱟᱨ ᱰᱟᱝᱨᱟ]]' },             -- 2
		{ '寅', '[[Tiger (zodiac)|ᱛᱟᱹᱨᱩᱵ]]' },       -- 3
		{ '卯', '[[Rabbit (zodiac)|ᱠᱩᱞᱟᱹᱭ]]' },     -- 4
		{ '辰', '[[Dragon (zodiac)|ᱰᱨᱟᱜᱚᱱ]]' },     -- 5
		{ '巳', '[[Snake (zodiac)|ᱵᱤᱝ]]' },       -- 6
		{ '午', '[[Horse (zodiac)|ᱥᱟᱫᱚᱢ]]' },       -- 7
		{ '未', '[[Goat (zodiac)|ᱢᱮᱨᱚᱢ]]' },         -- 8
		{ '申', '[[Monkey (zodiac)|ᱦᱟᱹᱬᱩ]]' },     -- 9
		{ '酉', '[[Rooster (zodiac)|ᱥᱟᱺᱰᱤ]]' },   -- 10
		{ '戌', '[[Dog (zodiac)|ᱥᱮᱛᱟ]]' },           -- 11
		{ '亥', '[[Pig (zodiac)|ᱠᱩᱸᱲᱤᱫ]]' }            -- 12
	}

	-- Calculate the cycle numbers from the year. The first sexagenary year corresponds to the ''previous'' year's entry
	-- in [[Chinese calendar correspondence table]], as the Chinese New Year doesn't happen until Jan/Feb in
	-- Gregorian years.
	local sexagenaryYear1 = ( year - 4 ) % 60
	local sexagenaryYear2 = ( year - 3 ) % 60
	local heavenlyNum1 = (sexagenaryYear1 - 1) % 10 + 1 -- amod, since lua arrays are 1-indexed
	local heavenlyNum2 = (sexagenaryYear2 - 1) % 10 + 1
	local earthlyNum1 = (sexagenaryYear1 - 1) % 12 + 1
	local earthlyNum2 = (sexagenaryYear2 - 1) % 12 + 1

	-- Get the data tables for each permutation.
	local heavenlyTable1 = heavenlyStems[ heavenlyNum1 ]
	local heavenlyTable2 = heavenlyStems[ heavenlyNum2 ]
	local earthlyTable1 = earthlyBranches[ earthlyNum1 ]
	local earthlyTable2 = earthlyBranches[ earthlyNum2 ]

	-- Work out the continously-numbered year. (See [[Chinese calendar#Continuously numbered years]].)
	local year1 = year + 2696
	local year2 = year + 2697
	local year1Alt = year1 - 60
	local year2Alt = year2 - 60

	-- Format any negative numbers.
	year1 = formatNegative( tostring( year1 ) )
	year2 = formatNegative( tostring( year2 ) )
	year1Alt = formatNegative( tostring( year1Alt ) )
	year2Alt = formatNegative( tostring( year2Alt ) )

	-- Return all of that data in a (hopefully) reader-friendly format.
	chinese:setYear( string.format(
			[=[[[Sexagenary cycle|%s%s]]年 <small>(%s&nbsp;%s)</small><br />%s ᱥᱮ %s<br />&nbsp;&nbsp;&nbsp;&nbsp;''—&nbsp;ᱠᱷᱚᱱ&nbsp;—''<br />%s%s年 <small>(%s&nbsp;%s)</small><br />%s ᱥᱮ %s]=],
			heavenlyTable1[ 1 ],
			earthlyTable1[ 1 ],
			heavenlyTable1[ 2 ],
			earthlyTable1[ 2 ],
			year1,
			year1Alt,
			heavenlyTable2[ 1 ],
			earthlyTable2[ 1 ],
			heavenlyTable2[ 2 ],
			earthlyTable2[ 2 ],
			year2,
			year2Alt
			) )

	box:addCalendar( chinese )

	----------------------------------------------------------------------
	-- ᱠᱚᱯᱴᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local coptic = calendar:new()
	coptic:setLink( 'ᱠᱚᱯᱴᱤᱠ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	coptic:setYearRange( year - 284, year - 283 )
	box:addCalendar( coptic )

	----------------------------------------------------------------------
	-- ᱰᱤᱥᱠᱳᱨᱰᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local discordian = calendar:new()
	discordian:setLink( 'ᱰᱤᱥᱠᱳᱨᱰᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	discordian:setYear( year + 1166 )
	box:addCalendar( discordian )

	----------------------------------------------------------------------
	-- ᱤᱛᱷᱤᱭᱳᱯᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local ethiopian = calendar:new()
	ethiopian:setLink( 'ᱤᱛᱷᱤᱭᱳᱯᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	ethiopian:setYearRange( year - 8, year - 7 )
	box:addCalendar( ethiopian )

	----------------------------------------------------------------------
	-- ᱦᱤᱵᱽᱨᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local hebrew = calendar:new()
	hebrew:setLink( 'ᱦᱤᱵᱽᱨᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	hebrew:setYearRange( year + 3760, year + 3761 )
	box:addCalendar( hebrew )

	----------------------------------------------------------------------
	-- ᱦᱤᱱᱫᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local hindu = calendarGroup:new{ heading = '[[ᱦᱤᱱᱫᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ]]' }

	-- ᱵᱤᱠᱨᱚᱢ ᱥᱚᱝᱵᱚᱫ

	local vikramSamvat = calendar:new()
	vikramSamvat:setLink( 'ᱵᱤᱠᱨᱚᱢ ᱥᱚᱝᱵᱚᱫ' )
	vikramSamvat:setYearRange( year + 56, year + 57 )
	hindu:addCalendar( vikramSamvat )

	-- ᱥᱚᱡᱟ ᱥᱚᱝᱵᱚᱫ

	local shakaSamvat = calendar:new()
	shakaSamvat:setLink( 'ᱥᱚᱠᱟᱵᱽᱫᱚ', 'ᱥᱚᱠᱟ ᱥᱚᱝᱵᱚᱫ' )
	if year >= 78 then
		shakaSamvat:setYearRange( year - 79, year - 78 )
	end
	hindu:addCalendar( shakaSamvat )

	-- ᱠᱚᱞᱤ ᱡᱩᱜᱽ

	local kaliYuga = calendar:new()
	kaliYuga:setLink( 'ᱠᱚᱞᱤ ᱡᱩᱜᱽ' ) -- use italics
	kaliYuga:setYearRange( year + 3100, year + 3101 )
	hindu:addCalendar( kaliYuga )

	box:addCalendarGroup( hindu )

	----------------------------------------------------------------------
	-- ᱦᱚᱞᱳᱥᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local holocene = calendar:new()
	holocene:setLink( 'ᱦᱚᱞᱚᱥᱤᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	holocene:setYear( year + 10000 )
	box:addCalendar( holocene )

	----------------------------------------------------------------------
	-- ᱤᱜᱽᱵᱳ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	-- In the old template this was a calendar group with just one calendar; intentionally adding this as a single
	-- calendar here, as the previous behaviour looked like a mistake.
	if year >= 1000 then
		local igbo = calendar:new()
		igbo:setLink( 'ᱤᱜᱽᱵᱳ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
		igbo:setYearRange( year - 1000, year - 999 )
		box:addCalendar( igbo )
	end

	----------------------------------------------------------------------
	-- ᱤᱨᱟᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local iranian = calendar:new()
	iranian:setLink( 'ᱤᱨᱟᱱᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	if year - 621 > 0 then
		iranian:setYearRange( year - 622, year - 621 )
	else
		iranian:setYear( string.format( '%d <abbr title="ᱱᱟᱦᱟᱜ ᱢᱟᱨᱟᱝ ᱨᱮ">BP</abbr>&nbsp;– %d <abbr title="ᱱᱟᱦᱟᱜ ᱢᱟᱨᱟᱝ ᱮᱮ">BP</abbr>', 622 - year, 621 - year ) )
	end
	box:addCalendar( iranian )

	----------------------------------------------------------------------
	-- ᱤᱥᱞᱟᱢ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local islamic = calendar:new()
	islamic:setLink( 'ᱤᱥᱞᱟᱢ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	local islamicMult = 1.030684 -- the factor to multiply by
	local islamicSub = 621.5643 -- the factor to subtract by
	if year - 621 > 0 then
		local year1 = math.floor( islamicMult * ( year - islamicSub ) )
		local year2 = math.floor( islamicMult * ( year - islamicSub + 1 ) )
		islamic:setYearRange( year1, year2 )
	else
		local year1 = math.ceil( -islamicMult * ( year - islamicSub ) )
		local year2 = math.ceil( -islamicMult * ( year - islamicSub + 1 ) )
		islamic:setYear( string.format( '%d <abbr title="ᱦᱤᱡᱽᱨᱤ ᱞᱟᱦᱟᱸ">BH</abbr>&nbsp;– %d <abbr title="ᱦᱤᱡᱽᱨᱤ ᱞᱟᱦᱟᱸ">BH</abbr>', year1, year2 ) )
	end
	box:addCalendar( islamic )

	----------------------------------------------------------------------
	-- ᱡᱟᱯᱟᱱᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ
	-- ᱖᱐᱐ ᱠᱷᱚᱱ ᱮᱦᱚᱵ
	----------------------------------------------------------------------
	
--	if year >= 600 then
--	local japanese = calendar:new()
--	japanese:setLink( 'ᱡᱟᱯᱟᱱᱤ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
--
--	japanese.thisEra = japaneseEra:new{ year = year }
--	if japanese.thisEra then
--		local japaneseYearText = {}
--		japanese.oldEra = japanese.thisEra:getOldEra()
--		if japanese.oldEra and japanese.oldEra.eraYear and japanese.thisEra.article ~= japanese.oldEra.article then
--			japanese.oldText = string.format( '%s %d', japanese.oldEra.link, japanese.oldEra.eraYear )
--			table.insert( japaneseYearText, japanese.oldText )
--			table.insert( japaneseYearText, ' / ' )
--		end
--		if japanese.thisEra.eraYear then
--			table.insert( japaneseYearText, string.format( '%s %d', japanese.thisEra.link, japanese.thisEra.eraYear ) )
--		end
--		table.insert( japaneseYearText, string.format( '<br /><small>(%s%s年)</small>', japanese.thisEra.kanji, japanese.thisEra.eraYearKanji ) )
--		japanese:setYear( table.concat( japaneseYearText ) )
--	end
--
--	box:addCalendar( japanese )
--	end

	----------------------------------------------------------------------
	-- ᱡᱩᱥ (Juche) ᱠᱮᱞᱮᱱᱰᱟᱨ
	-- displays only after 1910
	----------------------------------------------------------------------

	if year >= 1910 then
		local juche = calendar:new()
		juche:setLink( 'ᱠᱚᱸᱭᱮ ᱠᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ', 'ᱡᱩᱥ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
		if year > 1911 then
			juche:setYear( year - 1911 )
		end
		box:addCalendar( juche )
	end

	----------------------------------------------------------------------
	-- ᱡᱩᱞᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local julian = calendar:new()
	julian:setLink( 'ᱡᱩᱞᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )

	if year >= -45 and year < 1582 then
		julian:setYear(gregorian.year)
	elseif year >= 1582 then
		local diff = math.floor(year/100-2) - math.floor(year/400)
		if year % 100 == 0 and year % 400 ~= 0 then
			julian:setYear('ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱵᱷᱮᱜᱮᱫ ' .. diff-1 .. ' ᱥᱮ ' .. diff .. ' ᱢᱟᱦᱟᱸ')
		else
			julian:setYear('ᱜᱨᱮᱜᱳᱨᱤᱭᱟᱱ ᱵᱷᱮᱜᱮᱫ ' .. diff .. ' ᱢᱟᱦᱟᱸ')
		end
	end

	box:addCalendar( julian )

	----------------------------------------------------------------------
	-- ᱠᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local korean = calendar:new()
	korean:setLink( 'ᱠᱳᱨᱤᱭᱟᱱ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	korean:setYear( year + 2333 )
	box:addCalendar( korean )

	----------------------------------------------------------------------
	-- ᱢᱤᱝᱜᱩ (Minguo) ᱠᱮᱞᱮᱱᱰᱟᱨ
	----------------------------------------------------------------------

	local minguo = calendar:new()
	minguo:setLink( 'ᱢᱤᱝᱜᱩ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	if year > 1949 then
		local minguoYear = year - 1911
		minguo:setYear( string.format( '[[ᱛᱟᱭᱣᱟᱱ|ᱯᱨᱚ. ᱪᱤᱱ]] %d<br /><small>民國%d年</small>', minguoYear, minguoYear ) )
	elseif year > 1911 then
		local minguoYear = year - 1911
		minguo:setYear( string.format( '[[ᱯᱨᱚᱡᱟᱛᱟᱱᱛᱨᱤ ᱪᱤᱱ (᱑᱙᱑᱒-᱑᱙᱔᱙)|ᱯᱨᱚ.ᱪᱤᱱ]] %d<br /><small>民國%d年</small>', minguoYear, minguoYear ) )
	else
		local minguoYear = 1911 - year + 1
		minguo:setYear( string.format( '[[ᱯᱨᱚᱡᱟᱛᱚᱱᱛᱨᱤ ᱪᱤᱱ (᱑᱙᱑᱒-᱑᱙᱔᱙)|ᱯᱨᱚᱡᱟᱛᱟᱱᱛᱨᱤ ᱪᱤᱱ]] ᱞᱟᱦᱟᱸ ᱛᱮ %d<br /><small>民前%d年</small>', minguoYear, minguoYear ) )
	end
	box:addCalendar( minguo )
	
	----------------------------------------------------------------------
	-- ᱥᱮᱞᱮᱣᱥᱤᱰ ᱡᱩᱜᱽ
	-- displays from 312 BC until 1200 AD
	----------------------------------------------------------------------
	
	if year >= -311 and year < 1200 then
		local seleucid = calendar:new()
			seleucid:setLink( 'ᱥᱮᱞᱮᱣᱥᱤᱰ ᱡᱩᱜᱽ' )
			addtext = string.format( '[[Anno Graecorum|ᱮᱡᱤ]]')
		seleucid:setYearCouple( year + 311, year + 312, addtext )
		box:addCalendar( seleucid )
	end
	
	----------------------------------------------------------------------
	-- ᱛᱷᱟᱭ ᱥᱳᱞᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ 
	----------------------------------------------------------------------

	local thai = calendar:new()
	thai:setLink( 'ᱛᱷᱟᱭ ᱥᱳᱞᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ' )
	if year >= 1941 then
		thai:setYear( year + 543 )
	else -- if year >= 1912 or year <= 1887 -- year started in March/April
		thai:setYearRange( year + 542, year + 543 )
	-- else -- Rattanakosin Era, 1888?-1912
	--			thai:setYear( string.format( '%d &nbsp;– %d <small>([[ᱨᱟᱛᱛᱟᱱᱟᱠᱳᱥᱤᱱ ᱨᱟᱡᱽ|ᱨᱟᱛᱛᱟᱱᱟᱠᱳᱥᱤᱱ ᱡᱩᱜᱽ]])</small>', year - 1782 , year - 1781 ) )
	end
	box:addCalendar( thai )

	----------------------------------------------------------------------
	-- ᱤᱣᱱᱤᱠᱥ ᱚᱠᱛᱚ
	----------------------------------------------------------------------

	local unix = calendar:new()

	local function getUnixTime( year )
		if year < 1970 then return end
		if year > 2039 then return end
		if year == 2039 then
			-- Y2K38 bug
		    return "[[᱒᱐᱓᱘ ᱥᱮᱨᱢᱟ ᱨᱮᱭᱟᱜ ᱮᱴᱠᱮᱴᱚᱬᱮ|-᱒᱑᱑᱗᱔᱙᱒᱘᱙᱗]]"
		end
		local noError, unixTime = pcall( lang.formatDate, lang, 'U', '1 Jan ' .. tostring( year ) )
		if not noError or noError and not unixTime then return end
		unixTime = tonumber( unixTime )
		if unixTime and unixTime >= 0 then
			return unixTime - 1
		end
	end

	unix.thisYear = getUnixTime( year )
	unix.nextYear = getUnixTime( year + 1 )
	if unix.thisYear and unix.nextYear then
		unix:setLink( 'ᱤᱣᱱᱤᱠᱥ ᱚᱠᱛᱚ' )
		unix:setYear( (unix.thisYear + 1) .. " – " .. unix.nextYear )
	end

	box:addCalendar( unix )

	return box:export()
end

--------------------------------------------------------------------
-- Process arguments from #invoke
--------------------------------------------------------------------

local p = {}

function p.main( frame )
	-- Process the arguments and pass them to the box-building function.
	local args = getArgs( frame )
	-- Pass year argument with 'year' parameter or without any name but first argument
	args.year = args.year or args[1]
	return makeCalendarBox( args )
end

return p