*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.M.yyyy 'г.'",
longDate: "dd MMMM yyyy 'г.'",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "dd MMMM yyyy \\г. HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy \\г."
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^Ñнуари/i,
feb: /^февруари/i,
mar: /^март/i,
apr: /^април/i,
may: /^май/i,
jun: /^юни/i,
jul: /^юли/i,
aug: /^авгуÑÑ‚/i,
sep: /^Ñептември/i,
oct: /^октомври/i,
nov: /^ноември/i,
dec: /^декември/i,
sun: /^не((делÑ)?)?/i,
mon: /^по((неделник)?)?/i,
tue: /^вторник/i,
wed: /^ÑÑ€Ñда/i,
thu: /^че((твъртък)?)?/i,
fri: /^пе((тък)?)?/i,
sat: /^ÑÑŠ((бота)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/bs-BA.js 0000664 0001750 0001750 00000014770 12242643315 014477 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "bs-Latn-BA",
englishName: "Bosnian (Bosnia and Herzegovina)",
nativeName: "bosanski (Bosna i Hercegovina)",
/* Day Name Strings */
dayNames: ["nedjelja", "ponedjeljak", "utorak", "srijeda", "Äetvrtak", "petak", "subota"],
abbreviatedDayNames: ["ned", "pon", "uto", "sri", "Äet", "pet", "sub"],
shortestDayNames: ["ned", "pon", "uto", "sri", "Äet", "pet", "sub"],
firstLetterDayNames: ["n", "p", "u", "s", "Ä", "p", "s"],
/* Month Name Strings */
monthNames: ["januar", "februar", "mart", "april", "maj", "jun", "jul", "avgust", "septembar", "oktobar", "novembar", "decembar"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "maj", "jun", "jul", "avg", "sep", "okt", "nov", "dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d.M.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "H:mm:ss",
longTime: "H:mm:ss",
fullDateTime: "d. MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "MMMM dd",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^mar(t)?/i,
apr: /^apr(il)?/i,
may: /^maj/i,
jun: /^jun/i,
jul: /^jul/i,
aug: /^avg(ust)?/i,
sep: /^sep(tembar)?/i,
oct: /^okt(obar)?/i,
nov: /^nov(embar)?/i,
dec: /^dec(embar)?/i,
sun: /^nedjelja/i,
mon: /^ponedjeljak/i,
tue: /^utorak/i,
wed: /^srijeda/i,
thu: /^Äetvrtak/i,
fri: /^petak/i,
sat: /^subota/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/ca-ES.js 0000664 0001750 0001750 00000015062 12242643315 014476 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "ca-ES",
englishName: "Catalan (Catalan)",
nativeName: "català (català )",
/* Day Name Strings */
dayNames: ["diumenge", "dilluns", "dimarts", "dimecres", "dijous", "divendres", "dissabte"],
abbreviatedDayNames: ["dg.", "dl.", "dt.", "dc.", "dj.", "dv.", "ds."],
shortestDayNames: ["dg", "dl", "dt", "dc", "dj", "dv", "ds"],
firstLetterDayNames: ["d", "d", "d", "d", "d", "d", "d"],
/* Month Name Strings */
monthNames: ["gener", "febrer", "març", "abril", "maig", "juny", "juliol", "agost", "setembre", "octubre", "novembre", "desembre"],
abbreviatedMonthNames: ["gen", "feb", "març", "abr", "maig", "juny", "jul", "ag", "set", "oct", "nov", "des"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd/MM/yyyy",
longDate: "dddd, d / MMMM / yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "dddd, d / MMMM / yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM / yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^gen(er)?/i,
feb: /^feb(rer)?/i,
mar: /^març/i,
apr: /^abr(il)?/i,
may: /^maig/i,
jun: /^juny/i,
jul: /^jul(iol)?/i,
aug: /^ag(ost)?/i,
sep: /^set(embre)?/i,
oct: /^oct(ubre)?/i,
nov: /^nov(embre)?/i,
dec: /^des(embre)?/i,
sun: /^dg((.(umenge)?)?)?/i,
mon: /^dl((.(lluns)?)?)?/i,
tue: /^dt((.(marts)?)?)?/i,
wed: /^dc((.(mecres)?)?)?/i,
thu: /^dj((.(jous)?)?)?/i,
fri: /^dv((.(vendres)?)?)?/i,
sat: /^ds((.(ssabte)?)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/cs-CZ.js 0000664 0001750 0001750 00000014716 12242643315 014532 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "cs-CZ",
englishName: "Czech (Czech Republic)",
nativeName: "ÄeÅ¡tina (ÄŒeská republika)",
/* Day Name Strings */
dayNames: ["nedÄ›le", "pondÄ›lÃ", "úterý", "stÅ™eda", "Ätvrtek", "pátek", "sobota"],
abbreviatedDayNames: ["ne", "po", "út", "st", "Ät", "pá", "so"],
shortestDayNames: ["ne", "po", "út", "st", "Ät", "pá", "so"],
firstLetterDayNames: ["n", "p", "ú", "s", "Ä", "p", "s"],
/* Month Name Strings */
monthNames: ["leden", "únor", "bÅ™ezen", "duben", "kvÄ›ten", "Äerven", "Äervenec", "srpen", "zářÃ", "Å™Ãjen", "listopad", "prosinec"],
abbreviatedMonthNames: ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"],
/* AM/PM Designators */
amDesignator: "dop.",
pmDesignator: "odp.",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d.M.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d. MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^leden/i,
feb: /^únor/i,
mar: /^březen/i,
apr: /^duben/i,
may: /^květen/i,
jun: /^Äerven/i,
jul: /^Äervenec/i,
aug: /^srpen/i,
sep: /^zářÃ/i,
oct: /^Å™Ãjen/i,
nov: /^listopad/i,
dec: /^prosinec/i,
sun: /^neděle/i,
mon: /^pondÄ›lÃ/i,
tue: /^úterý/i,
wed: /^středa/i,
thu: /^Ätvrtek/i,
fri: /^pátek/i,
sat: /^sobota/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/da-DK.js 0000664 0001750 0001750 00000014714 12242643315 014471 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "da-DK",
englishName: "Danish (Denmark)",
nativeName: "dansk (Danmark)",
/* Day Name Strings */
dayNames: ["søndag", "mandag", "tirsdag", "onsdag", "torsdag", "fredag", "lørdag"],
abbreviatedDayNames: ["sø", "ma", "ti", "on", "to", "fr", "lø"],
shortestDayNames: ["sø", "ma", "ti", "on", "to", "fr", "lø"],
firstLetterDayNames: ["s", "m", "t", "o", "t", "f", "l"],
/* Month Name Strings */
monthNames: ["januar", "februar", "marts", "april", "maj", "juni", "juli", "august", "september", "oktober", "november", "december"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "maj", "jun", "jul", "aug", "sep", "okt", "nov", "dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd-MM-yyyy",
longDate: "d. MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d. MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^mar(ts)?/i,
apr: /^apr(il)?/i,
may: /^maj/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^dec(ember)?/i,
sun: /^søndag/i,
mon: /^mandag/i,
tue: /^tirsdag/i,
wed: /^onsdag/i,
thu: /^torsdag/i,
fri: /^fredag/i,
sat: /^lørdag/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/date.js 0000664 0001750 0001750 00000247101 12242643315 014524 0 ustar jan jan /**
* @version: 1.0 Alpha-1
* @author: Coolite Inc. http://www.coolite.com/
* @date: 2008-04-13
* @copyright: Copyright (c) 2006-2008, Coolite Inc. (http://www.coolite.com/). All rights reserved.
* @license: Licensed under The MIT License. See license.txt and http://www.datejs.com/license/.
* @website: http://www.datejs.com/
*/
(function () {
var $D = Date,
$P = $D.prototype,
$C = $D.CultureInfo,
p = function (s, l) {
if (!l) {
l = 2;
}
return ("000" + s).slice(l * -1);
};
/**
* Resets the time of this Date object to 12:00 AM (00:00), which is the start of the day.
* @param {Boolean} .clone() this date instance before clearing Time
* @return {Date} this
*/
$P.clearTime = function () {
this.setHours(0);
this.setMinutes(0);
this.setSeconds(0);
this.setMilliseconds(0);
return this;
};
/**
* Resets the time of this Date object to the current time ('now').
* @return {Date} this
*/
$P.setTimeToNow = function () {
var n = new Date();
this.setHours(n.getHours());
this.setMinutes(n.getMinutes());
this.setSeconds(n.getSeconds());
this.setMilliseconds(n.getMilliseconds());
return this;
};
/**
* Gets a date that is set to the current date. The time is set to the start of the day (00:00 or 12:00 AM).
* @return {Date} The current date.
*/
$D.today = function () {
return new Date().clearTime();
};
/**
* Compares the first date to the second date and returns an number indication of their relative values.
* @param {Date} First Date object to compare [Required].
* @param {Date} Second Date object to compare to [Required].
* @return {Number} -1 = date1 is lessthan date2. 0 = values are equal. 1 = date1 is greaterthan date2.
*/
$D.compare = function (date1, date2) {
if (isNaN(date1) || isNaN(date2)) {
throw new Error(date1 + " - " + date2);
} else if (date1 instanceof Date && date2 instanceof Date) {
return (date1 < date2) ? -1 : (date1 > date2) ? 1 : 0;
} else {
throw new TypeError(date1 + " - " + date2);
}
};
/**
* Compares the first Date object to the second Date object and returns true if they are equal.
* @param {Date} First Date object to compare [Required]
* @param {Date} Second Date object to compare to [Required]
* @return {Boolean} true if dates are equal. false if they are not equal.
*/
$D.equals = function (date1, date2) {
return (date1.compareTo(date2) === 0);
};
/**
* Gets the day number (0-6) if given a CultureInfo specific string which is a valid dayName, abbreviatedDayName or shortestDayName (two char).
* @param {String} The name of the day (eg. "Monday, "Mon", "tuesday", "tue", "We", "we").
* @return {Number} The day number
*/
$D.getDayNumberFromName = function (name) {
var n = $C.dayNames, m = $C.abbreviatedDayNames, o = $C.shortestDayNames, s = name.toLowerCase();
for (var i = 0; i < n.length; i++) {
if (n[i].toLowerCase() == s || m[i].toLowerCase() == s || o[i].toLowerCase() == s) {
return i;
}
}
return -1;
};
/**
* Gets the month number (0-11) if given a Culture Info specific string which is a valid monthName or abbreviatedMonthName.
* @param {String} The name of the month (eg. "February, "Feb", "october", "oct").
* @return {Number} The day number
*/
$D.getMonthNumberFromName = function (name) {
var n = $C.monthNames, m = $C.abbreviatedMonthNames, s = name.toLowerCase();
for (var i = 0; i < n.length; i++) {
if (n[i].toLowerCase() == s || m[i].toLowerCase() == s) {
return i;
}
}
return -1;
};
/**
* Determines if the current date instance is within a LeapYear.
* @param {Number} The year.
* @return {Boolean} true if date is within a LeapYear, otherwise false.
*/
$D.isLeapYear = function (year) {
return ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0);
};
/**
* Gets the number of days in the month, given a year and month value. Automatically corrects for LeapYear.
* @param {Number} The year.
* @param {Number} The month (0-11).
* @return {Number} The number of days in the month.
*/
$D.getDaysInMonth = function (year, month) {
return [31, ($D.isLeapYear(year) ? 29 : 28), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month];
};
$D.getTimezoneAbbreviation = function (offset) {
var z = $C.timezones, p;
for (var i = 0; i < z.length; i++) {
if (z[i].offset === offset) {
return z[i].name;
}
}
return null;
};
$D.getTimezoneOffset = function (name) {
var z = $C.timezones, p;
for (var i = 0; i < z.length; i++) {
if (z[i].name === name.toUpperCase()) {
return z[i].offset;
}
}
return null;
};
/**
* Returns a new Date object that is an exact date and time copy of the original instance.
* @return {Date} A new Date instance
*/
$P.clone = function () {
return new Date(this.getTime());
};
/**
* Compares this instance to a Date object and returns an number indication of their relative values.
* @param {Date} Date object to compare [Required]
* @return {Number} -1 = this is lessthan date. 0 = values are equal. 1 = this is greaterthan date.
*/
$P.compareTo = function (date) {
return Date.compare(this, date);
};
/**
* Compares this instance to another Date object and returns true if they are equal.
* @param {Date} Date object to compare. If no date to compare, new Date() [now] is used.
* @return {Boolean} true if dates are equal. false if they are not equal.
*/
$P.equals = function (date) {
return Date.equals(this, date || new Date());
};
/**
* Determines if this instance is between a range of two dates or equal to either the start or end dates.
* @param {Date} Start of range [Required]
* @param {Date} End of range [Required]
* @return {Boolean} true is this is between or equal to the start and end dates, else false
*/
$P.between = function (start, end) {
return this.getTime() >= start.getTime() && this.getTime() <= end.getTime();
};
/**
* Determines if this date occurs after the date to compare to.
* @param {Date} Date object to compare. If no date to compare, new Date() ("now") is used.
* @return {Boolean} true if this date instance is greater than the date to compare to (or "now"), otherwise false.
*/
$P.isAfter = function (date) {
return this.compareTo(date || new Date()) === 1;
};
/**
* Determines if this date occurs before the date to compare to.
* @param {Date} Date object to compare. If no date to compare, new Date() ("now") is used.
* @return {Boolean} true if this date instance is less than the date to compare to (or "now").
*/
$P.isBefore = function (date) {
return (this.compareTo(date || new Date()) === -1);
};
/**
* Determines if the current Date instance occurs today.
* @return {Boolean} true if this date instance is 'today', otherwise false.
*/
/**
* Determines if the current Date instance occurs on the same Date as the supplied 'date'.
* If no 'date' to compare to is provided, the current Date instance is compared to 'today'.
* @param {date} Date object to compare. If no date to compare, the current Date ("now") is used.
* @return {Boolean} true if this Date instance occurs on the same Day as the supplied 'date'.
*/
$P.isToday = $P.isSameDay = function (date) {
return this.clone().clearTime().equals((date || new Date()).clone().clearTime());
};
/**
* Adds the specified number of milliseconds to this instance.
* @param {Number} The number of milliseconds to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addMilliseconds = function (value) {
this.setTime(this.getTime() + value * 1);
return this;
};
/**
* Adds the specified number of seconds to this instance.
* @param {Number} The number of seconds to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addSeconds = function (value) {
return this.addMilliseconds(value * 1000);
};
/**
* Adds the specified number of seconds to this instance.
* @param {Number} The number of seconds to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addMinutes = function (value) {
return this.addMilliseconds(value * 60000); /* 60*1000 */
};
/**
* Adds the specified number of hours to this instance.
* @param {Number} The number of hours to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addHours = function (value) {
return this.addMilliseconds(value * 3600000); /* 60*60*1000 */
};
/**
* Adds the specified number of days to this instance.
* @param {Number} The number of days to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addDays = function (value) {
this.setDate(this.getDate() + value * 1);
return this;
};
/**
* Adds the specified number of weeks to this instance.
* @param {Number} The number of weeks to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addWeeks = function (value) {
return this.addDays(value * 7);
};
/**
* Adds the specified number of months to this instance.
* @param {Number} The number of months to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addMonths = function (value) {
var n = this.getDate();
this.setDate(1);
this.setMonth(this.getMonth() + value * 1);
this.setDate(Math.min(n, $D.getDaysInMonth(this.getFullYear(), this.getMonth())));
return this;
};
/**
* Adds the specified number of years to this instance.
* @param {Number} The number of years to add. The number can be positive or negative [Required]
* @return {Date} this
*/
$P.addYears = function (value) {
return this.addMonths(value * 12);
};
/**
* Adds (or subtracts) to the value of the years, months, weeks, days, hours, minutes, seconds, milliseconds of the date instance using given configuration object. Positive and Negative values allowed.
* Example
* @param {Object} Configuration object containing attributes (months, days, etc.)
* @return {Date} this
*/
$P.add = function (config) {
if (typeof config == "number") {
this._orient = config;
return this;
}
var x = config;
if (x.milliseconds) {
this.addMilliseconds(x.milliseconds);
}
if (x.seconds) {
this.addSeconds(x.seconds);
}
if (x.minutes) {
this.addMinutes(x.minutes);
}
if (x.hours) {
this.addHours(x.hours);
}
if (x.weeks) {
this.addWeeks(x.weeks);
}
if (x.months) {
this.addMonths(x.months);
}
if (x.years) {
this.addYears(x.years);
}
if (x.days) {
this.addDays(x.days);
}
return this;
};
var $y, $m, $d;
/**
* Get the week number. Week one (1) is the week which contains the first Thursday of the year. Monday is considered the first day of the week.
* This algorithm is a JavaScript port of the work presented by Claus Tøndering at http://www.tondering.dk/claus/cal/node8.html#SECTION00880000000000000000
* .getWeek() Algorithm Copyright (c) 2008 Claus Tondering.
* The .getWeek() function does NOT convert the date to UTC. The local datetime is used. Please use .getISOWeek() to get the week of the UTC converted date.
* @return {Number} 1 to 53
*/
$P.getWeek = function () {
var a, b, c, d, e, f, g, n, s, w;
$y = (!$y) ? this.getFullYear() : $y;
$m = (!$m) ? this.getMonth() + 1 : $m;
$d = (!$d) ? this.getDate() : $d;
if ($m <= 2) {
a = $y - 1;
b = (a / 4 | 0) - (a / 100 | 0) + (a / 400 | 0);
c = ((a - 1) / 4 | 0) - ((a - 1) / 100 | 0) + ((a - 1) / 400 | 0);
s = b - c;
e = 0;
f = $d - 1 + (31 * ($m - 1));
} else {
a = $y;
b = (a / 4 | 0) - (a / 100 | 0) + (a / 400 | 0);
c = ((a - 1) / 4 | 0) - ((a - 1) / 100 | 0) + ((a - 1) / 400 | 0);
s = b - c;
e = s + 1;
f = $d + ((153 * ($m - 3) + 2) / 5 | 0) + 58 + s;
}
g = (a + b) % 7;
d = (f + g - e) % 7;
n = f + 3 - d;
if (n < 0) {
w = 53 - ((g - s) / 5 | 0);
} else if (n > 364 + s) {
w = 1;
} else {
w = (n / 7 | 0) + 1;
}
$y = $m = $d = null;
return w;
};
/**
* Get the ISO 8601 week number. Week one ("01") is the week which contains the first Thursday of the year. Monday is considered the first day of the week.
* The .getISOWeek() function does convert the date to it's UTC value. Please use .getWeek() to get the week of the local date.
* @return {String} "01" to "53"
*/
$P.getISOWeek = function () {
$y = this.getUTCFullYear();
$m = this.getUTCMonth() + 1;
$d = this.getUTCDate();
return p(this.getWeek());
};
/**
* Moves the date to Monday of the week set. Week one (1) is the week which contains the first Thursday of the year.
* @param {Number} A Number (1 to 53) that represents the week of the year.
* @return {Date} this
*/
$P.setWeek = function (n) {
return this.moveToDayOfWeek(1).addWeeks(n - this.getWeek());
};
// private
var validate = function (n, min, max, name) {
if (typeof n == "undefined") {
return false;
} else if (typeof n != "number") {
throw new TypeError(n + " is not a Number.");
} else if (n < min || n > max) {
throw new RangeError(n + " is not a valid value for " + name + ".");
}
return true;
};
/**
* Validates the number is within an acceptable range for milliseconds [0-999].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateMillisecond = function (value) {
return validate(value, 0, 999, "millisecond");
};
/**
* Validates the number is within an acceptable range for seconds [0-59].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateSecond = function (value) {
return validate(value, 0, 59, "second");
};
/**
* Validates the number is within an acceptable range for minutes [0-59].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateMinute = function (value) {
return validate(value, 0, 59, "minute");
};
/**
* Validates the number is within an acceptable range for hours [0-23].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateHour = function (value) {
return validate(value, 0, 23, "hour");
};
/**
* Validates the number is within an acceptable range for the days in a month [0-MaxDaysInMonth].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateDay = function (value, year, month) {
return validate(value, 1, $D.getDaysInMonth(year, month), "day");
};
/**
* Validates the number is within an acceptable range for months [0-11].
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateMonth = function (value) {
return validate(value, 0, 11, "month");
};
/**
* Validates the number is within an acceptable range for years.
* @param {Number} The number to check if within range.
* @return {Boolean} true if within range, otherwise false.
*/
$D.validateYear = function (value) {
return validate(value, 0, 9999, "year");
};
/**
* Set the value of year, month, day, hour, minute, second, millisecond of date instance using given configuration object.
* Example
*
* @param {Object} Configuration object containing attributes (month, day, etc.)
* @return {Date} this
*/
$P.set = function (config) {
if ($D.validateMillisecond(config.millisecond)) {
this.addMilliseconds(config.millisecond - this.getMilliseconds());
}
if ($D.validateSecond(config.second)) {
this.addSeconds(config.second - this.getSeconds());
}
if ($D.validateMinute(config.minute)) {
this.addMinutes(config.minute - this.getMinutes());
}
if ($D.validateHour(config.hour)) {
this.addHours(config.hour - this.getHours());
}
if ($D.validateMonth(config.month)) {
this.addMonths(config.month - this.getMonth());
}
if ($D.validateYear(config.year)) {
this.addYears(config.year - this.getFullYear());
}
/* day has to go last because you can't validate the day without first knowing the month */
if ($D.validateDay(config.day, this.getFullYear(), this.getMonth())) {
this.addDays(config.day - this.getDate());
}
if (config.timezone) {
this.setTimezone(config.timezone);
}
if (config.timezoneOffset) {
this.setTimezoneOffset(config.timezoneOffset);
}
if (config.week && validate(config.week, 0, 53, "week")) {
this.setWeek(config.week);
}
return this;
};
/**
* Moves the date to the first day of the month.
* @return {Date} this
*/
$P.moveToFirstDayOfMonth = function () {
return this.set({ day: 1 });
};
/**
* Moves the date to the last day of the month.
* @return {Date} this
*/
$P.moveToLastDayOfMonth = function () {
return this.set({ day: $D.getDaysInMonth(this.getFullYear(), this.getMonth())});
};
/**
* Moves the date to the next n'th occurrence of the dayOfWeek starting from the beginning of the month. The number (-1) is a magic number and will return the last occurrence of the dayOfWeek in the month.
* @param {Number} The dayOfWeek to move to
* @param {Number} The n'th occurrence to move to. Use (-1) to return the last occurrence in the month
* @return {Date} this
*/
$P.moveToNthOccurrence = function (dayOfWeek, occurrence) {
var shift = 0;
if (occurrence > 0) {
shift = occurrence - 1;
}
else if (occurrence === -1) {
this.moveToLastDayOfMonth();
if (this.getDay() !== dayOfWeek) {
this.moveToDayOfWeek(dayOfWeek, -1);
}
return this;
}
return this.moveToFirstDayOfMonth().addDays(-1).moveToDayOfWeek(dayOfWeek, +1).addWeeks(shift);
};
/**
* Move to the next or last dayOfWeek based on the orient value.
* @param {Number} The dayOfWeek to move to
* @param {Number} Forward (+1) or Back (-1). Defaults to +1. [Optional]
* @return {Date} this
*/
$P.moveToDayOfWeek = function (dayOfWeek, orient) {
var diff = (dayOfWeek - this.getDay() + 7 * (orient || +1)) % 7;
return this.addDays((diff === 0) ? diff += 7 * (orient || +1) : diff);
};
/**
* Move to the next or last month based on the orient value.
* @param {Number} The month to move to. 0 = January, 11 = December
* @param {Number} Forward (+1) or Back (-1). Defaults to +1. [Optional]
* @return {Date} this
*/
$P.moveToMonth = function (month, orient) {
var diff = (month - this.getMonth() + 12 * (orient || +1)) % 12;
return this.addMonths((diff === 0) ? diff += 12 * (orient || +1) : diff);
};
/**
* Get the Ordinal day (numeric day number) of the year, adjusted for leap year.
* @return {Number} 1 through 365 (366 in leap years)
*/
$P.getOrdinalNumber = function () {
return Math.ceil((this.clone().clearTime() - new Date(this.getFullYear(), 0, 1)) / 86400000) + 1;
};
/**
* Get the time zone abbreviation of the current date.
* @return {String} The abbreviated time zone name (e.g. "EST")
*/
$P.getTimezone = function () {
return $D.getTimezoneAbbreviation(this.getUTCOffset());
};
$P.setTimezoneOffset = function (offset) {
var here = this.getTimezoneOffset(), there = Number(offset) * -6 / 10;
return this.addMinutes(there - here);
};
$P.setTimezone = function (offset) {
return this.setTimezoneOffset($D.getTimezoneOffset(offset));
};
/**
* Indicates whether Daylight Saving Time is observed in the current time zone.
* @return {Boolean} true|false
*/
$P.hasDaylightSavingTime = function () {
return (Date.today().set({month: 0, day: 1}).getTimezoneOffset() !== Date.today().set({month: 6, day: 1}).getTimezoneOffset());
};
/**
* Indicates whether this Date instance is within the Daylight Saving Time range for the current time zone.
* @return {Boolean} true|false
*/
$P.isDaylightSavingTime = function () {
return Date.today().set({month: 0, day: 1}).getTimezoneOffset() != this.getTimezoneOffset();
};
/**
* Get the offset from UTC of the current date.
* @return {String} The 4-character offset string prefixed with + or - (e.g. "-0500")
*/
$P.getUTCOffset = function () {
var n = this.getTimezoneOffset() * -10 / 6, r;
if (n < 0) {
r = (n - 10000).toString();
return r.charAt(0) + r.substr(2);
} else {
r = (n + 10000).toString();
return "+" + r.substr(1);
}
};
/**
* Returns the number of milliseconds between this date and date.
* @param {Date} Defaults to now
* @return {Number} The diff in milliseconds
*/
$P.getElapsed = function (date) {
return (date || new Date()) - this;
};
if (!$P.toISOString) {
/**
* Converts the current date instance into a string with an ISO 8601 format. The date is converted to it's UTC value.
* @return {String} ISO 8601 string of date
*/
$P.toISOString = function () {
// From http://www.json.org/json.js. Public Domain.
function f(n) {
return n < 10 ? '0' + n : n;
}
return '"' + this.getUTCFullYear() + '-' +
f(this.getUTCMonth() + 1) + '-' +
f(this.getUTCDate()) + 'T' +
f(this.getUTCHours()) + ':' +
f(this.getUTCMinutes()) + ':' +
f(this.getUTCSeconds()) + 'Z"';
};
}
// private
$P._toString = $P.toString;
/**
* Converts the value of the current Date object to its equivalent string representation.
* Format Specifiers
CUSTOM DATE AND TIME FORMAT STRINGS
Format Description Example
------ --------------------------------------------------------------------------- -----------------------
s The seconds of the minute between 0-59. "0" to "59"
ss The seconds of the minute with leading zero if required. "00" to "59"
m The minute of the hour between 0-59. "0" or "59"
mm The minute of the hour with leading zero if required. "00" or "59"
h The hour of the day between 1-12. "1" to "12"
hh The hour of the day with leading zero if required. "01" to "12"
H The hour of the day between 0-23. "0" to "23"
HH The hour of the day with leading zero if required. "00" to "23"
d The day of the month between 1 and 31. "1" to "31"
dd The day of the month with leading zero if required. "01" to "31"
ddd Abbreviated day name. $C.abbreviatedDayNames. "Mon" to "Sun"
dddd The full day name. $C.dayNames. "Monday" to "Sunday"
M The month of the year between 1-12. "1" to "12"
MM The month of the year with leading zero if required. "01" to "12"
MMM Abbreviated month name. $C.abbreviatedMonthNames. "Jan" to "Dec"
MMMM The full month name. $C.monthNames. "January" to "December"
yy The year as a two-digit number. "99" or "08"
yyyy The full four digit year. "1999" or "2008"
t Displays the first character of the A.M./P.M. designator. "A" or "P"
$C.amDesignator or $C.pmDesignator
tt Displays the A.M./P.M. designator. "AM" or "PM"
$C.amDesignator or $C.pmDesignator
S The ordinal suffix ("st, "nd", "rd" or "th") of the current day. "st, "nd", "rd" or "th"
|| *Format* || *Description* || *Example* ||
|| d || The CultureInfo shortDate Format Pattern || "M/d/yyyy" ||
|| D || The CultureInfo longDate Format Pattern || "dddd, MMMM dd, yyyy" ||
|| F || The CultureInfo fullDateTime Format Pattern || "dddd, MMMM dd, yyyy h:mm:ss tt" ||
|| m || The CultureInfo monthDay Format Pattern || "MMMM dd" ||
|| r || The CultureInfo rfc1123 Format Pattern || "ddd, dd MMM yyyy HH:mm:ss GMT" ||
|| s || The CultureInfo sortableDateTime Format Pattern || "yyyy-MM-ddTHH:mm:ss" ||
|| t || The CultureInfo shortTime Format Pattern || "h:mm tt" ||
|| T || The CultureInfo longTime Format Pattern || "h:mm:ss tt" ||
|| u || The CultureInfo universalSortableDateTime Format Pattern || "yyyy-MM-dd HH:mm:ssZ" ||
|| y || The CultureInfo yearMonth Format Pattern || "MMMM, yyyy" ||
STANDARD DATE AND TIME FORMAT STRINGS
Format Description Example ("en-US")
------ --------------------------------------------------------------------------- -----------------------
d The CultureInfo shortDate Format Pattern "M/d/yyyy"
D The CultureInfo longDate Format Pattern "dddd, MMMM dd, yyyy"
F The CultureInfo fullDateTime Format Pattern "dddd, MMMM dd, yyyy h:mm:ss tt"
m The CultureInfo monthDay Format Pattern "MMMM dd"
r The CultureInfo rfc1123 Format Pattern "ddd, dd MMM yyyy HH:mm:ss GMT"
s The CultureInfo sortableDateTime Format Pattern "yyyy-MM-ddTHH:mm:ss"
t The CultureInfo shortTime Format Pattern "h:mm tt"
T The CultureInfo longTime Format Pattern "h:mm:ss tt"
u The CultureInfo universalSortableDateTime Format Pattern "yyyy-MM-dd HH:mm:ssZ"
y The CultureInfo yearMonth Format Pattern "MMMM, yyyy"
* @param {String} A format string consisting of one or more format spcifiers [Optional].
* @return {String} A string representation of the current Date object.
*/
$P.toString = function (format) {
var x = this;
// Standard Date and Time Format Strings. Formats pulled from CultureInfo file and
// may vary by culture.
if (format && format.length == 1) {
var c = $C.formatPatterns;
x.t = x.toString;
switch (format) {
case "d":
return x.t(c.shortDate);
case "D":
return x.t(c.longDate);
case "F":
return x.t(c.fullDateTime);
case "m":
return x.t(c.monthDay);
case "r":
return x.t(c.rfc1123);
case "s":
return x.t(c.sortableDateTime);
case "t":
return x.t(c.shortTime);
case "T":
return x.t(c.longTime);
case "u":
return x.t(c.universalSortableDateTime);
case "y":
return x.t(c.yearMonth);
}
}
var ord = function (n) {
switch (n * 1) {
case 1:
case 21:
case 31:
return "st";
case 2:
case 22:
return "nd";
case 3:
case 23:
return "rd";
default:
return "th";
}
};
return format ? format.replace(/(\\)?(dd?d?d?|MM?M?M?|yy?y?y?|hh?|HH?|mm?|ss?|tt?|S)/g,
function (m) {
if (m.charAt(0) === "\\") {
return m.replace("\\", "");
}
x.h = x.getHours;
switch (m) {
case "hh":
return p(x.h() < 13 ? (x.h() === 0 ? 12 : x.h()) : (x.h() - 12));
case "h":
return x.h() < 13 ? (x.h() === 0 ? 12 : x.h()) : (x.h() - 12);
case "HH":
return p(x.h());
case "H":
return x.h();
case "mm":
return p(x.getMinutes());
case "m":
return x.getMinutes();
case "ss":
return p(x.getSeconds());
case "s":
return x.getSeconds();
case "yyyy":
return p(x.getFullYear(), 4);
case "yy":
return p(x.getFullYear());
case "dddd":
return $C.dayNames[x.getDay()];
case "ddd":
return $C.abbreviatedDayNames[x.getDay()];
case "dd":
return p(x.getDate());
case "d":
return x.getDate();
case "MMMM":
return $C.monthNames[x.getMonth()];
case "MMM":
return $C.abbreviatedMonthNames[x.getMonth()];
case "MM":
return p((x.getMonth() + 1));
case "M":
return x.getMonth() + 1;
case "t":
return x.h() < 12 ? $C.amDesignator.substring(0, 1) : $C.pmDesignator.substring(0, 1);
case "tt":
return x.h() < 12 ? $C.amDesignator : $C.pmDesignator;
case "S":
return ord(x.getDate());
default:
return m;
}
}
) : this._toString();
};
}()); /**
* @version: 1.0 Alpha-1
* @author: Coolite Inc. http://www.coolite.com/
* @date: 2008-04-13
* @copyright: Copyright (c) 2006-2008, Coolite Inc. (http://www.coolite.com/). All rights reserved.
* @license: Licensed under The MIT License. See license.txt and http://www.datejs.com/license/.
* @website: http://www.datejs.com/
*/
/**
**************************************************************
** SugarPak - Domain Specific Language - Syntactical Sugar **
**************************************************************
*/
(function () {
var $D = Date, $P = $D.prototype, $C = $D.CultureInfo, $N = Number.prototype;
// private
$P._orient = +1;
// private
$P._nth = null;
// private
$P._is = false;
// private
$P._same = false;
// private
$P._isSecond = false;
// private
$N._dateElement = "day";
/**
* Moves the date to the next instance of a date as specified by the subsequent date element function (eg. .day(), .month()), month name function (eg. .january(), .jan()) or day name function (eg. .friday(), fri()).
* Example
*
* @return {Date} date
*/
$P.next = function () {
this._orient = +1;
return this;
};
/**
* Creates a new Date (Date.today()) and moves the date to the next instance of the date as specified by the subsequent date element function (eg. .day(), .month()), month name function (eg. .january(), .jan()) or day name function (eg. .friday(), fri()).
* Example
*
* @return {Date} date
*/
$D.next = function () {
return $D.today().next();
};
/**
* Moves the date to the previous instance of a date as specified by the subsequent date element function (eg. .day(), .month()), month name function (eg. .january(), .jan()) or day name function (eg. .friday(), fri()).
* Example
*
* @return {Date} date
*/
$P.last = $P.prev = $P.previous = function () {
this._orient = -1;
return this;
};
/**
* Creates a new Date (Date.today()) and moves the date to the previous instance of the date as specified by the subsequent date element function (eg. .day(), .month()), month name function (eg. .january(), .jan()) or day name function (eg. .friday(), fri()).
* Example
*
* @return {Date} date
*/
$D.last = $D.prev = $D.previous = function () {
return $D.today().last();
};
/**
* Performs a equality check when followed by either a month name, day name or .weekday() function.
* Example
*
* @return {Boolean} true|false
*/
$P.is = function () {
this._is = true;
return this;
};
/**
* Determines if two date objects occur on/in exactly the same instance of the subsequent date part function.
* The function .same() must be followed by a date part function (example: .day(), .month(), .year(), etc).
*
* An optional Date can be passed in the date part function. If now date is passed as a parameter, 'Now' is used.
*
* The following example demonstrates how to determine if two dates fall on the exact same day.
*
* Example
var d1 = Date.today(); // today at 00:00
var d2 = new Date(); // exactly now.
// Do they occur on the same day?
d1.same().day(d2); // true
// Do they occur on the same hour?
d1.same().hour(d2); // false, unless d2 hour is '00' (midnight).
// What if it's the same day, but one year apart?
var nextYear = Date.today().add(1).year();
d1.same().day(nextYear); // false, because the dates must occur on the exact same day.
*
* Scenario: Determine if a given date occurs during some week period 2 months from now.
*
* Example
var future = Date.today().add(2).months();
return someDate.same().week(future); // true|false;
*
* @return {Boolean} true|false
*/
$P.same = function () {
this._same = true;
this._isSecond = false;
return this;
};
/**
* Determines if the current date/time occurs during Today. Must be preceded by the .is() function.
* Example
*
* @return {Boolean} true|false
*/
$P.today = function () {
return this.same().day();
};
/**
* Determines if the current date is a weekday. This function must be preceded by the .is() function.
* Example
Date.today().is().weekday(); // true|false
*
* @return {Boolean} true|false
*/
$P.weekday = function () {
if (this._is) {
this._is = false;
return (!this.is().sat() && !this.is().sun());
}
return false;
};
/**
* Sets the Time of the current Date instance. A string "6:15 pm" or config object {hour:18, minute:15} are accepted.
* Example
// Set time to 6:15pm with a String
Date.today().at("6:15pm");
// Set time to 6:15pm with a config object
Date.today().at({hour:18, minute:15});
*
* @return {Date} date
*/
$P.at = function (time) {
return (typeof time === "string") ? $D.parse(this.toString("d") + " " + time) : this.set(time);
};
/**
* Creates a new Date() and adds this (Number) to the date based on the preceding date element function (eg. second|minute|hour|day|month|year).
* Example
// Undeclared Numbers must be wrapped with parentheses. Requirment of JavaScript.
(3).days().fromNow();
(6).months().fromNow();
// Declared Number variables do not require parentheses.
var n = 6;
n.months().fromNow();
*
* @return {Date} A new Date instance
*/
$N.fromNow = $N.after = function (date) {
var c = {};
c[this._dateElement] = this;
return ((!date) ? new Date() : date.clone()).add(c);
};
/**
* Creates a new Date() and subtract this (Number) from the date based on the preceding date element function (eg. second|minute|hour|day|month|year).
* Example
// Undeclared Numbers must be wrapped with parentheses. Requirment of JavaScript.
(3).days().ago();
(6).months().ago();
// Declared Number variables do not require parentheses.
var n = 6;
n.months().ago();
*
* @return {Date} A new Date instance
*/
$N.ago = $N.before = function (date) {
var c = {};
c[this._dateElement] = this * -1;
return ((!date) ? new Date() : date.clone()).add(c);
};
// Do NOT modify the following string tokens. These tokens are used to build dynamic functions.
// All culture-specific strings can be found in the CultureInfo files. See /trunk/src/globalization/.
var dx = ("sunday monday tuesday wednesday thursday friday saturday").split(/\s/),
mx = ("january february march april may june july august september october november december").split(/\s/),
px = ("Millisecond Second Minute Hour Day Week Month Year").split(/\s/),
pxf = ("Milliseconds Seconds Minutes Hours Date Week Month FullYear").split(/\s/),
nth = ("final first second third fourth fifth").split(/\s/),
de;
/**
* Returns an object literal of all the date parts.
* Example
var o = new Date().toObject();
// { year: 2008, month: 4, week: 20, day: 13, hour: 18, minute: 9, second: 32, millisecond: 812 }
// The object properties can be referenced directly from the object.
alert(o.day); // alerts "13"
alert(o.year); // alerts "2008"
*
* @return {Date} An object literal representing the original date object.
*/
$P.toObject = function () {
var o = {};
for (var i = 0; i < px.length; i++) {
o[px[i].toLowerCase()] = this["get" + pxf[i]]();
}
return o;
};
/**
* Returns a date created from an object literal. Ignores the .week property if set in the config.
* Example
var o = new Date().toObject();
return Date.fromObject(o); // will return the same date.
var o2 = {month: 1, day: 20, hour: 18}; // birthday party!
Date.fromObject(o2);
*
* @return {Date} An object literal representing the original date object.
*/
$D.fromObject = function(config) {
config.week = null;
return Date.today().set(config);
};
// Create day name functions and abbreviated day name functions (eg. monday(), friday(), fri()).
var df = function (n) {
return function () {
if (this._is) {
this._is = false;
return this.getDay() == n;
}
if (this._nth !== null) {
// If the .second() function was called earlier, remove the _orient
// from the date, and then continue.
// This is required because 'second' can be used in two different context.
//
// Example
//
// Date.today().add(1).second();
// Date.march().second().monday();
//
// Things get crazy with the following...
// Date.march().add(1).second().second().monday(); // but it works!!
//
if (this._isSecond) {
this.addSeconds(this._orient * -1);
}
// make sure we reset _isSecond
this._isSecond = false;
var ntemp = this._nth;
this._nth = null;
var temp = this.clone().moveToLastDayOfMonth();
this.moveToNthOccurrence(n, ntemp);
if (this > temp) {
throw new RangeError($D.getDayName(n) + " does not occur " + ntemp + " times in the month of " + $D.getMonthName(temp.getMonth()) + " " + temp.getFullYear() + ".");
}
return this;
}
return this.moveToDayOfWeek(n, this._orient);
};
};
var sdf = function (n) {
return function () {
var t = $D.today(), shift = n - t.getDay();
if (n === 0 && $C.firstDayOfWeek === 1 && t.getDay() !== 0) {
shift = shift + 7;
}
return t.addDays(shift);
};
};
for (var i = 0; i < dx.length; i++) {
// Create constant static Day Name variables. Example: Date.MONDAY or Date.MON
$D[dx[i].toUpperCase()] = $D[dx[i].toUpperCase().substring(0, 3)] = i;
// Create Day Name functions. Example: Date.monday() or Date.mon()
$D[dx[i]] = $D[dx[i].substring(0, 3)] = sdf(i);
// Create Day Name instance functions. Example: Date.today().next().monday()
$P[dx[i]] = $P[dx[i].substring(0, 3)] = df(i);
}
// Create month name functions and abbreviated month name functions (eg. january(), march(), mar()).
var mf = function (n) {
return function () {
if (this._is) {
this._is = false;
return this.getMonth() === n;
}
return this.moveToMonth(n, this._orient);
};
};
var smf = function (n) {
return function () {
return $D.today().set({ month: n, day: 1 });
};
};
for (var j = 0; j < mx.length; j++) {
// Create constant static Month Name variables. Example: Date.MARCH or Date.MAR
$D[mx[j].toUpperCase()] = $D[mx[j].toUpperCase().substring(0, 3)] = j;
// Create Month Name functions. Example: Date.march() or Date.mar()
$D[mx[j]] = $D[mx[j].substring(0, 3)] = smf(j);
// Create Month Name instance functions. Example: Date.today().next().march()
$P[mx[j]] = $P[mx[j].substring(0, 3)] = mf(j);
}
// Create date element functions and plural date element functions used with Date (eg. day(), days(), months()).
var ef = function (j) {
return function () {
// if the .second() function was called earlier, the _orient
// has alread been added. Just return this and reset _isSecond.
if (this._isSecond) {
this._isSecond = false;
return this;
}
if (this._same) {
this._same = this._is = false;
var o1 = this.toObject(),
o2 = (arguments[0] || new Date()).toObject(),
v = "",
k = j.toLowerCase();
for (var m = (px.length - 1); m > -1; m--) {
v = px[m].toLowerCase();
if (o1[v] != o2[v]) {
return false;
}
if (k == v) {
break;
}
}
return true;
}
if (j.substring(j.length - 1) != "s") {
j += "s";
}
return this["add" + j](this._orient);
};
};
var nf = function (n) {
return function () {
this._dateElement = n;
return this;
};
};
for (var k = 0; k < px.length; k++) {
de = px[k].toLowerCase();
// Create date element functions and plural date element functions used with Date (eg. day(), days(), months()).
$P[de] = $P[de + "s"] = ef(px[k]);
// Create date element functions and plural date element functions used with Number (eg. day(), days(), months()).
$N[de] = $N[de + "s"] = nf(de);
}
$P._ss = ef("Second");
var nthfn = function (n) {
return function (dayOfWeek) {
if (this._same) {
return this._ss(arguments[0]);
}
if (dayOfWeek || dayOfWeek === 0) {
return this.moveToNthOccurrence(dayOfWeek, n);
}
this._nth = n;
// if the operator is 'second' add the _orient, then deal with it later...
if (n === 2 && (dayOfWeek === undefined || dayOfWeek === null)) {
this._isSecond = true;
return this.addSeconds(this._orient);
}
return this;
};
};
for (var l = 0; l < nth.length; l++) {
$P[nth[l]] = (l === 0) ? nthfn(-1) : nthfn(l);
}
}());/**
* @version: 1.0 Alpha-1
* @author: Coolite Inc. http://www.coolite.com/
* @date: 2008-04-13
* @copyright: Copyright (c) 2006-2008, Coolite Inc. (http://www.coolite.com/). All rights reserved.
* @license: Licensed under The MIT License. See license.txt and http://www.datejs.com/license/.
* @website: http://www.datejs.com/
*/
(function () {
Date.Parsing = {
Exception: function (s) {
this.message = "Parse error at '" + s.substring(0, 10) + " ...'";
}
};
var $P = Date.Parsing;
var _ = $P.Operators = {
//
// Tokenizers
//
rtoken: function (r) { // regex token
return function (s) {
var mx = s.match(r);
if (mx) {
return ([ mx[0], s.substring(mx[0].length) ]);
} else {
throw new $P.Exception(s);
}
};
},
token: function (s) { // whitespace-eating token
return function (s) {
return _.rtoken(new RegExp("^\s*" + s + "\s*"))(s);
// Removed .strip()
// return _.rtoken(new RegExp("^\s*" + s + "\s*"))(s).strip();
};
},
stoken: function (s) { // string token
return _.rtoken(new RegExp("^" + s));
},
//
// Atomic Operators
//
until: function (p) {
return function (s) {
var qx = [], rx = null;
while (s.length) {
try {
rx = p.call(this, s);
} catch (e) {
qx.push(rx[0]);
s = rx[1];
continue;
}
break;
}
return [ qx, s ];
};
},
many: function (p) {
return function (s) {
var rx = [], r = null;
while (s.length) {
try {
r = p.call(this, s);
} catch (e) {
return [ rx, s ];
}
rx.push(r[0]);
s = r[1];
}
return [ rx, s ];
};
},
// generator operators -- see below
optional: function (p) {
return function (s) {
var r = null;
try {
r = p.call(this, s);
} catch (e) {
return [ null, s ];
}
return [ r[0], r[1] ];
};
},
not: function (p) {
return function (s) {
try {
p.call(this, s);
} catch (e) {
return [null, s];
}
throw new $P.Exception(s);
};
},
ignore: function (p) {
return p ?
function (s) {
var r = null;
r = p.call(this, s);
return [null, r[1]];
} : null;
},
product: function () {
var px = arguments[0],
qx = Array.prototype.slice.call(arguments, 1), rx = [];
for (var i = 0 ; i < px.length ; i++) {
rx.push(_.each(px[i], qx));
}
return rx;
},
cache: function (rule) {
var cache = {}, r = null;
return function (s) {
try {
r = cache[s] = (cache[s] || rule.call(this, s));
} catch (e) {
r = cache[s] = e;
}
if (r instanceof $P.Exception) {
throw r;
} else {
return r;
}
};
},
// vector operators -- see below
any: function () {
var px = arguments;
return function (s) {
var r = null;
for (var i = 0; i < px.length; i++) {
if (px[i] == null) {
continue;
}
try {
r = (px[i].call(this, s));
} catch (e) {
r = null;
}
if (r) {
return r;
}
}
throw new $P.Exception(s);
};
},
each: function () {
var px = arguments;
return function (s) {
var rx = [], r = null;
for (var i = 0; i < px.length ; i++) {
if (px[i] == null) {
continue;
}
try {
r = (px[i].call(this, s));
} catch (e) {
throw new $P.Exception(s);
}
rx.push(r[0]);
s = r[1];
}
return [ rx, s];
};
},
all: function () {
var px = arguments, _ = _;
return _.each(_.optional(px));
},
// delimited operators
sequence: function (px, d, c) {
d = d || _.rtoken(/^\s*/);
c = c || null;
if (px.length == 1) {
return px[0];
}
return function (s) {
var r = null, q = null;
var rx = [];
for (var i = 0; i < px.length ; i++) {
try {
r = px[i].call(this, s);
} catch (e) {
break;
}
rx.push(r[0]);
try {
q = d.call(this, r[1]);
} catch (ex) {
q = null;
break;
}
s = q[1];
}
if (!r) {
throw new $P.Exception(s);
}
if (q) {
throw new $P.Exception(q[1]);
}
if (c) {
try {
r = c.call(this, r[1]);
} catch (ey) {
throw new $P.Exception(r[1]);
}
}
return [ rx, (r?r[1]:s) ];
};
},
//
// Composite Operators
//
between: function (d1, p, d2) {
d2 = d2 || d1;
var _fn = _.each(_.ignore(d1), p, _.ignore(d2));
return function (s) {
var rx = _fn.call(this, s);
return [[rx[0][0], r[0][2]], rx[1]];
};
},
list: function (p, d, c) {
d = d || _.rtoken(/^\s*/);
c = c || null;
return (p instanceof Array ?
_.each(_.product(p.slice(0, -1), _.ignore(d)), p.slice(-1), _.ignore(c)) :
_.each(_.many(_.each(p, _.ignore(d))), px, _.ignore(c)));
},
set: function (px, d, c) {
d = d || _.rtoken(/^\s*/);
c = c || null;
return function (s) {
// r is the current match, best the current 'best' match
// which means it parsed the most amount of input
var r = null, p = null, q = null, rx = null, best = [[], s], last = false;
// go through the rules in the given set
for (var i = 0; i < px.length ; i++) {
// last is a flag indicating whether this must be the last element
// if there is only 1 element, then it MUST be the last one
q = null;
p = null;
r = null;
last = (px.length == 1);
// first, we try simply to match the current pattern
// if not, try the next pattern
try {
r = px[i].call(this, s);
} catch (e) {
continue;
}
// since we are matching against a set of elements, the first
// thing to do is to add r[0] to matched elements
rx = [[r[0]], r[1]];
// if we matched and there is still input to parse and
// we don't already know this is the last element,
// we're going to next check for the delimiter ...
// if there's none, or if there's no input left to parse
// than this must be the last element after all ...
if (r[1].length > 0 && ! last) {
try {
q = d.call(this, r[1]);
} catch (ex) {
last = true;
}
} else {
last = true;
}
// if we parsed the delimiter and now there's no more input,
// that means we shouldn't have parsed the delimiter at all
// so don't update r and mark this as the last element ...
if (!last && q[1].length === 0) {
last = true;
}
// so, if this isn't the last element, we're going to see if
// we can get any more matches from the remaining (unmatched)
// elements ...
if (!last) {
// build a list of the remaining rules we can match against,
// i.e., all but the one we just matched against
var qx = [];
for (var j = 0; j < px.length ; j++) {
if (i != j) {
qx.push(px[j]);
}
}
// now invoke recursively set with the remaining input
// note that we don't include the closing delimiter ...
// we'll check for that ourselves at the end
p = _.set(qx, d).call(this, q[1]);
// if we got a non-empty set as a result ...
// (otw rx already contains everything we want to match)
if (p[0].length > 0) {
// update current result, which is stored in rx ...
// basically, pick up the remaining text from p[1]
// and concat the result from p[0] so that we don't
// get endless nesting ...
rx[0] = rx[0].concat(p[0]);
rx[1] = p[1];
}
}
// at this point, rx either contains the last matched element
// or the entire matched set that starts with this element.
// now we just check to see if this variation is better than
// our best so far, in terms of how much of the input is parsed
if (rx[1].length < best[1].length) {
best = rx;
}
// if we've parsed all the input, then we're finished
if (best[1].length === 0) {
break;
}
}
// so now we've either gone through all the patterns trying them
// as the initial match; or we found one that parsed the entire
// input string ...
// if best has no matches, just return empty set ...
if (best[0].length === 0) {
return best;
}
// if a closing delimiter is provided, then we have to check it also
if (c) {
// we try this even if there is no remaining input because the pattern
// may well be optional or match empty input ...
try {
q = c.call(this, best[1]);
} catch (ey) {
throw new $P.Exception(best[1]);
}
// it parsed ... be sure to update the best match remaining input
best[1] = q[1];
}
// if we're here, either there was no closing delimiter or we parsed it
// so now we have the best match; just return it!
return best;
};
},
forward: function (gr, fname) {
return function (s) {
return gr[fname].call(this, s);
};
},
//
// Translation Operators
//
replace: function (rule, repl) {
return function (s) {
var r = rule.call(this, s);
return [repl, r[1]];
};
},
process: function (rule, fn) {
return function (s) {
var r = rule.call(this, s);
return [fn.call(this, r[0]), r[1]];
};
},
min: function (min, rule) {
return function (s) {
var rx = rule.call(this, s);
if (rx[0].length < min) {
throw new $P.Exception(s);
}
return rx;
};
}
};
// Generator Operators And Vector Operators
// Generators are operators that have a signature of F(R) => R,
// taking a given rule and returning another rule, such as
// ignore, which parses a given rule and throws away the result.
// Vector operators are those that have a signature of F(R1,R2,...) => R,
// take a list of rules and returning a new rule, such as each.
// Generator operators are converted (via the following _generator
// function) into functions that can also take a list or array of rules
// and return an array of new rules as though the function had been
// called on each rule in turn (which is what actually happens).
// This allows generators to be used with vector operators more easily.
// Example:
// each(ignore(foo, bar)) instead of each(ignore(foo), ignore(bar))
// This also turns generators into vector operators, which allows
// constructs like:
// not(cache(foo, bar))
var _generator = function (op) {
return function () {
var args = null, rx = [];
if (arguments.length > 1) {
args = Array.prototype.slice.call(arguments);
} else if (arguments[0] instanceof Array) {
args = arguments[0];
}
if (args) {
for (var i = 0, px = args.shift() ; i < px.length ; i++) {
args.unshift(px[i]);
rx.push(op.apply(null, args));
args.shift();
return rx;
}
} else {
return op.apply(null, arguments);
}
};
};
var gx = "optional not ignore cache".split(/\s/);
for (var i = 0 ; i < gx.length ; i++) {
_[gx[i]] = _generator(_[gx[i]]);
}
var _vector = function (op) {
return function () {
if (arguments[0] instanceof Array) {
return op.apply(null, arguments[0]);
} else {
return op.apply(null, arguments);
}
};
};
var vx = "each any all".split(/\s/);
for (var j = 0 ; j < vx.length ; j++) {
_[vx[j]] = _vector(_[vx[j]]);
}
}());
(function () {
var $D = Date, $P = $D.prototype, $C = $D.CultureInfo;
var flattenAndCompact = function (ax) {
var rx = [];
for (var i = 0; i < ax.length; i++) {
if (ax[i] instanceof Array) {
rx = rx.concat(flattenAndCompact(ax[i]));
} else {
if (ax[i]) {
rx.push(ax[i]);
}
}
}
return rx;
};
$D.Grammar = {};
$D.Translator = {
hour: function (s) {
return function () {
this.hour = Number(s);
};
},
minute: function (s) {
return function () {
this.minute = Number(s);
};
},
second: function (s) {
return function () {
this.second = Number(s);
};
},
meridian: function (s) {
return function () {
this.meridian = s.slice(0, 1).toLowerCase();
};
},
timezone: function (s) {
return function () {
var n = s.replace(/[^\d\+\-]/g, "");
if (n.length) {
this.timezoneOffset = Number(n);
} else {
this.timezone = s.toLowerCase();
}
};
},
day: function (x) {
var s = x[0];
return function () {
this.day = Number(s.match(/\d+/)[0]);
};
},
month: function (s) {
return function () {
this.month = (s.length == 3) ? "jan feb mar apr may jun jul aug sep oct nov dec".indexOf(s)/4 : Number(s) - 1;
};
},
year: function (s) {
return function () {
var n = Number(s);
this.year = ((s.length > 2) ? n :
(n + (((n + 2000) < $C.twoDigitYearMax) ? 2000 : 1900)));
};
},
rday: function (s) {
return function () {
switch (s) {
case "yesterday":
this.days = -1;
break;
case "tomorrow":
this.days = 1;
break;
case "today":
this.days = 0;
break;
case "now":
this.days = 0;
this.now = true;
break;
}
};
},
finishExact: function (x) {
x = (x instanceof Array) ? x : [ x ];
for (var i = 0 ; i < x.length ; i++) {
if (x[i]) {
x[i].call(this);
}
}
var now = new Date();
if ((this.hour || this.minute) && (!this.month && !this.year && !this.day)) {
this.day = now.getDate();
}
if (!this.year) {
this.year = now.getFullYear();
}
if (!this.month && this.month !== 0) {
this.month = now.getMonth();
}
if (!this.day) {
this.day = 1;
}
if (!this.hour) {
this.hour = 0;
}
if (!this.minute) {
this.minute = 0;
}
if (!this.second) {
this.second = 0;
}
if (this.meridian && this.hour) {
if (this.meridian == "p" && this.hour < 12) {
this.hour = this.hour + 12;
} else if (this.meridian == "a" && this.hour == 12) {
this.hour = 0;
}
}
if (this.day > $D.getDaysInMonth(this.year, this.month)) {
throw new RangeError(this.day + " is not a valid value for days.");
}
var r = new Date(this.year, this.month, this.day, this.hour, this.minute, this.second);
if (this.timezone) {
r.set({ timezone: this.timezone });
} else if (this.timezoneOffset) {
r.set({ timezoneOffset: this.timezoneOffset });
}
return r;
},
finish: function (x) {
x = (x instanceof Array) ? flattenAndCompact(x) : [ x ];
if (x.length === 0) {
return null;
}
for (var i = 0 ; i < x.length ; i++) {
if (typeof x[i] == "function") {
x[i].call(this);
}
}
var today = $D.today();
if (this.now && !this.unit && !this.operator) {
return new Date();
} else if (this.now) {
today = new Date();
}
var expression = !!(this.days && this.days !== null || this.orient || this.operator);
var gap, mod, orient;
orient = ((this.orient == "past" || this.operator == "subtract") ? -1 : 1);
if(!this.now && "hour minute second".indexOf(this.unit) != -1) {
today.setTimeToNow();
}
if (this.month || this.month === 0) {
if ("year day hour minute second".indexOf(this.unit) != -1) {
this.value = this.month + 1;
this.month = null;
expression = true;
}
}
if (!expression && this.weekday && !this.day && !this.days) {
var temp = Date[this.weekday]();
this.day = temp.getDate();
if (!this.month) {
this.month = temp.getMonth();
}
this.year = temp.getFullYear();
}
if (expression && this.weekday && this.unit != "month") {
this.unit = "day";
gap = ($D.getDayNumberFromName(this.weekday) - today.getDay());
mod = 7;
this.days = gap ? ((gap + (orient * mod)) % mod) : (orient * mod);
}
if (this.month && this.unit == "day" && this.operator) {
this.value = (this.month + 1);
this.month = null;
}
if (this.value != null && this.month != null && this.year != null) {
this.day = this.value * 1;
}
if (this.month && !this.day && this.value) {
today.set({ day: this.value * 1 });
if (!expression) {
this.day = this.value * 1;
}
}
if (!this.month && this.value && this.unit == "month" && !this.now) {
this.month = this.value;
expression = true;
}
if (expression && (this.month || this.month === 0) && this.unit != "year") {
this.unit = "month";
gap = (this.month - today.getMonth());
mod = 12;
this.months = gap ? ((gap + (orient * mod)) % mod) : (orient * mod);
this.month = null;
}
if (!this.unit) {
this.unit = "day";
}
if (!this.value && this.operator && this.operator !== null && this[this.unit + "s"] && this[this.unit + "s"] !== null) {
this[this.unit + "s"] = this[this.unit + "s"] + ((this.operator == "add") ? 1 : -1) + (this.value||0) * orient;
} else if (this[this.unit + "s"] == null || this.operator != null) {
if (!this.value) {
this.value = 1;
}
this[this.unit + "s"] = this.value * orient;
}
if (this.meridian && this.hour) {
if (this.meridian == "p" && this.hour < 12) {
this.hour = this.hour + 12;
} else if (this.meridian == "a" && this.hour == 12) {
this.hour = 0;
}
}
if (this.weekday && !this.day && !this.days) {
var temp = Date[this.weekday]();
this.day = temp.getDate();
if (temp.getMonth() !== today.getMonth()) {
this.month = temp.getMonth();
}
}
if ((this.month || this.month === 0) && !this.day) {
this.day = 1;
}
if (!this.orient && !this.operator && this.unit == "week" && this.value && !this.day && !this.month) {
return Date.today().setWeek(this.value);
}
if (expression && this.timezone && this.day && this.days) {
this.day = this.days;
}
return (expression) ? today.add(this) : today.set(this);
}
};
var _ = $D.Parsing.Operators, g = $D.Grammar, t = $D.Translator, _fn;
g.datePartDelimiter = _.rtoken(/^([\s\-\.\,\/\x27]+)/);
g.timePartDelimiter = _.rtoken(/^([\.:])/);
g.whiteSpace = _.rtoken(/^\s*/);
g.generalDelimiter = _.rtoken(/^(([\s\,]|at|@|on)+)/);
var _C = {};
g.ctoken = function (keys) {
var fn = _C[keys];
if (! fn) {
var c = $C.regexPatterns;
var kx = keys.split(/\s+/), px = [];
for (var i = 0; i < kx.length ; i++) {
px.push(_.replace(_.rtoken(c[kx[i]]), kx[i]));
}
fn = _C[keys] = _.any.apply(null, px);
}
return fn;
};
g.ctoken2 = function (key) {
return _.rtoken($C.regexPatterns[key]);
};
// hour, minute, second, meridian, timezone
g.h = _.cache(_.process(_.rtoken(/^(0[0-9]|1[0-2]|[1-9])/), t.hour));
g.hh = _.cache(_.process(_.rtoken(/^(0[0-9]|1[0-2])/), t.hour));
g.H = _.cache(_.process(_.rtoken(/^([0-1][0-9]|2[0-3]|[0-9])/), t.hour));
g.HH = _.cache(_.process(_.rtoken(/^([0-1][0-9]|2[0-3])/), t.hour));
g.m = _.cache(_.process(_.rtoken(/^([0-5][0-9]|[0-9])/), t.minute));
g.mm = _.cache(_.process(_.rtoken(/^[0-5][0-9]/), t.minute));
g.s = _.cache(_.process(_.rtoken(/^([0-5][0-9]|[0-9])/), t.second));
g.ss = _.cache(_.process(_.rtoken(/^[0-5][0-9]/), t.second));
g.hms = _.cache(_.sequence([g.H, g.m, g.s], g.timePartDelimiter));
// _.min(1, _.set([ g.H, g.m, g.s ], g._t));
g.t = _.cache(_.process(g.ctoken2("shortMeridian"), t.meridian));
g.tt = _.cache(_.process(g.ctoken2("longMeridian"), t.meridian));
g.z = _.cache(_.process(_.rtoken(/^((\+|\-)\s*\d\d\d\d)|((\+|\-)\d\d\:?\d\d)/), t.timezone));
g.zz = _.cache(_.process(_.rtoken(/^((\+|\-)\s*\d\d\d\d)|((\+|\-)\d\d\:?\d\d)/), t.timezone));
g.zzz = _.cache(_.process(g.ctoken2("timezone"), t.timezone));
g.timeSuffix = _.each(_.ignore(g.whiteSpace), _.set([ g.tt, g.zzz ]));
g.time = _.each(_.optional(_.ignore(_.stoken("T"))), g.hms, g.timeSuffix);
// days, months, years
g.d = _.cache(_.process(_.each(_.rtoken(/^([0-2]\d|3[0-1]|\d)/),
_.optional(g.ctoken2("ordinalSuffix"))), t.day));
g.dd = _.cache(_.process(_.each(_.rtoken(/^([0-2]\d|3[0-1])/),
_.optional(g.ctoken2("ordinalSuffix"))), t.day));
g.ddd = g.dddd = _.cache(_.process(g.ctoken("sun mon tue wed thu fri sat"),
function (s) {
return function () {
this.weekday = s;
};
}
));
g.M = _.cache(_.process(_.rtoken(/^(1[0-2]|0\d|\d)/), t.month));
g.MM = _.cache(_.process(_.rtoken(/^(1[0-2]|0\d)/), t.month));
g.MMM = g.MMMM = _.cache(_.process(
g.ctoken("jan feb mar apr may jun jul aug sep oct nov dec"), t.month));
g.y = _.cache(_.process(_.rtoken(/^(\d\d?)/), t.year));
g.yy = _.cache(_.process(_.rtoken(/^(\d\d)/), t.year));
g.yyy = _.cache(_.process(_.rtoken(/^(\d\d?\d?\d?)/), t.year));
g.yyyy = _.cache(_.process(_.rtoken(/^(\d\d\d\d)/), t.year));
// rolling these up into general purpose rules
_fn = function () {
return _.each(_.any.apply(null, arguments), _.not(g.ctoken2("timeContext")));
};
g.day = _fn(g.d, g.dd);
g.month = _fn(g.M, g.MMM);
g.year = _fn(g.yyyy, g.yy);
// relative date / time expressions
g.orientation = _.process(g.ctoken("past future"),
function (s) {
return function () {
this.orient = s;
};
}
);
g.operator = _.process(g.ctoken("add subtract"),
function (s) {
return function () {
this.operator = s;
};
}
);
g.rday = _.process(g.ctoken("yesterday tomorrow today now"), t.rday);
g.unit = _.process(g.ctoken("second minute hour day week month year"),
function (s) {
return function () {
this.unit = s;
};
}
);
g.value = _.process(_.rtoken(/^\d\d?(st|nd|rd|th)?/),
function (s) {
return function () {
this.value = s.replace(/\D/g, "");
};
}
);
g.expression = _.set([ g.rday, g.operator, g.value, g.unit, g.orientation, g.ddd, g.MMM ]);
// pre-loaded rules for different date part order preferences
_fn = function () {
return _.set(arguments, g.datePartDelimiter);
};
g.mdy = _fn(g.ddd, g.month, g.day, g.year);
g.ymd = _fn(g.ddd, g.year, g.month, g.day);
g.dmy = _fn(g.ddd, g.day, g.month, g.year);
g.date = function (s) {
return ((g[$C.dateElementOrder] || g.mdy).call(this, s));
};
// parsing date format specifiers - ex: "h:m:s tt"
// this little guy will generate a custom parser based
// on the format string, ex: g.format("h:m:s tt")
g.format = _.process(_.many(
_.any(
// translate format specifiers into grammar rules
_.process(
_.rtoken(/^(dd?d?d?|MM?M?M?|yy?y?y?|hh?|HH?|mm?|ss?|tt?|zz?z?)/),
function (fmt) {
if (g[fmt]) {
return g[fmt];
} else {
throw $D.Parsing.Exception(fmt);
}
}
),
// translate separator tokens into token rules
_.process(
_.rtoken(/^[^dMyhHmstz]+/), // all legal separators
function (s) {
return _.ignore(_.stoken(s));
}
)
)),
// construct the parser ...
function (rules) {
return _.process(_.each.apply(null, rules), t.finishExact);
}
);
var _F = {
//"M/d/yyyy": function (s) {
// var m = s.match(/^([0-2]\d|3[0-1]|\d)\/(1[0-2]|0\d|\d)\/(\d\d\d\d)/);
// if (m!=null) {
// var r = [ t.month.call(this,m[1]), t.day.call(this,m[2]), t.year.call(this,m[3]) ];
// r = t.finishExact.call(this,r);
// return [ r, "" ];
// } else {
// throw new Date.Parsing.Exception(s);
// }
//}
//"M/d/yyyy": function (s) { return [ new Date(Date._parse(s)), ""]; }
};
var _get = function (f) {
return _F[f] = (_F[f] || g.format(f)[0]);
};
g.formats = function (fx) {
if (fx instanceof Array) {
var rx = [];
for (var i = 0 ; i < fx.length ; i++) {
rx.push(_get(fx[i]));
}
return _.any.apply(null, rx);
} else {
return _get(fx);
}
};
// check for these formats first
g._formats = g.formats([
"\"yyyy-MM-ddTHH:mm:ssZ\"",
"yyyy-MM-ddTHH:mm:ssZ",
"yyyy-MM-ddTHH:mm:ssz",
"yyyy-MM-ddTHH:mm:ss",
"yyyy-MM-ddTHH:mmZ",
"yyyy-MM-ddTHH:mmz",
"yyyy-MM-ddTHH:mm",
"ddd, MMM dd, yyyy H:mm:ss tt",
"ddd MMM d yyyy HH:mm:ss zzz",
"MMddyyyy",
"ddMMyyyy",
"Mddyyyy",
"ddMyyyy",
"Mdyyyy",
"dMyyyy",
"yyyy",
"Mdyy",
"dMyy",
"d"
]);
// starting rule for general purpose grammar
g._start = _.process(_.set([ g.date, g.time, g.expression ],
g.generalDelimiter, g.whiteSpace), t.finish);
// real starting rule: tries selected formats first,
// then general purpose rule
g.start = function (s) {
try {
var r = g._formats.call({}, s);
if (r[1].length === 0) {
return r;
}
} catch (e) {}
return g._start.call({}, s);
};
$D._parse = $D.parse;
/**
* Converts the specified string value into its JavaScript Date equivalent using CultureInfo specific format information.
*
* Example
///////////
// Dates //
///////////
// 15-Oct-2004
var d1 = Date.parse("10/15/2004");
// 15-Oct-2004
var d1 = Date.parse("15-Oct-2004");
// 15-Oct-2004
var d1 = Date.parse("2004.10.15");
//Fri Oct 15, 2004
var d1 = Date.parse("Fri Oct 15, 2004");
///////////
// Times //
///////////
// Today at 10 PM.
var d1 = Date.parse("10 PM");
// Today at 10:30 PM.
var d1 = Date.parse("10:30 P.M.");
// Today at 6 AM.
var d1 = Date.parse("06am");
/////////////////////
// Dates and Times //
/////////////////////
// 8-July-2004 @ 10:30 PM
var d1 = Date.parse("July 8th, 2004, 10:30 PM");
// 1-July-2004 @ 10:30 PM
var d1 = Date.parse("2004-07-01T22:30:00");
////////////////////
// Relative Dates //
////////////////////
// Returns today's date. The string "today" is culture specific.
var d1 = Date.parse("today");
// Returns yesterday's date. The string "yesterday" is culture specific.
var d1 = Date.parse("yesterday");
// Returns the date of the next thursday.
var d1 = Date.parse("Next thursday");
// Returns the date of the most previous monday.
var d1 = Date.parse("last monday");
// Returns today's day + one year.
var d1 = Date.parse("next year");
///////////////
// Date Math //
///////////////
// Today + 2 days
var d1 = Date.parse("t+2");
// Today + 2 days
var d1 = Date.parse("today + 2 days");
// Today + 3 months
var d1 = Date.parse("t+3m");
// Today - 1 year
var d1 = Date.parse("today - 1 year");
// Today - 1 year
var d1 = Date.parse("t-1y");
/////////////////////////////
// Partial Dates and Times //
/////////////////////////////
// July 15th of this year.
var d1 = Date.parse("July 15");
// 15th day of current day and year.
var d1 = Date.parse("15");
// July 1st of current year at 10pm.
var d1 = Date.parse("7/1 10pm");
*
* @param {String} The string value to convert into a Date object [Required]
* @return {Date} A Date object or null if the string cannot be converted into a Date.
*/
$D.parse = function (s) {
var r = null;
if (!s) {
return null;
}
if (s instanceof Date) {
return s;
}
try {
r = $D.Grammar.start.call({}, s.replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1"));
} catch (e) {
return null;
}
return ((r[1].length === 0) ? r[0] : null);
};
$D.getParseFunction = function (fx) {
var fn = $D.Grammar.formats(fx);
return function (s) {
var r = null;
try {
r = fn.call({}, s);
} catch (e) {
return null;
}
return ((r[1].length === 0) ? r[0] : null);
};
};
/**
* Converts the specified string value into its JavaScript Date equivalent using the specified format {String} or formats {Array} and the CultureInfo specific format information.
* The format of the string value must match one of the supplied formats exactly.
*
* Example
// 15-Oct-2004
var d1 = Date.parseExact("10/15/2004", "M/d/yyyy");
// 15-Oct-2004
var d1 = Date.parse("15-Oct-2004", "M-ddd-yyyy");
// 15-Oct-2004
var d1 = Date.parse("2004.10.15", "yyyy.MM.dd");
// Multiple formats
var d1 = Date.parseExact("10/15/2004", ["M/d/yyyy", "MMMM d, yyyy"]);
*
* @param {String} The string value to convert into a Date object [Required].
* @param {Object} The expected format {String} or an array of expected formats {Array} of the date string [Required].
* @return {Date} A Date object or null if the string cannot be converted into a Date.
*/
$D.parseExact = function (s, fx) {
return $D.getParseFunction(fx)(s);
};
}());
Horde_Core-2.11.1/js/date/de-DE.js 0000664 0001750 0001750 00000014751 12242643315 014470 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "de-DE",
englishName: "German (Germany)",
nativeName: "Deutsch (Deutschland)",
/* Day Name Strings */
dayNames: ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"],
abbreviatedDayNames: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
shortestDayNames: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
firstLetterDayNames: ["S", "M", "D", "M", "D", "F", "S"],
/* Month Name Strings */
monthNames: ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"],
abbreviatedMonthNames: ["Jan", "Feb", "Mrz", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "dddd, d. MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "dddd, d. MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^märz/i,
apr: /^apr(il)?/i,
may: /^mai/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^dez(ember)?/i,
sun: /^sonntag/i,
mon: /^montag/i,
tue: /^dienstag/i,
wed: /^mittwoch/i,
thu: /^donnerstag/i,
fri: /^freitag/i,
sat: /^samstag/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/el-GR.js 0000664 0001750 0001750 00000015711 12242643315 014515 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "el-GR",
englishName: "Greek (Greece)",
nativeName: "ελληνικά (Ελλάδα)",
/* Day Name Strings */
dayNames: ["ΚυÏιακή", "ΔευτÎÏα", "ΤÏίτη", "ΤετάÏτη", "Î Îμπτη", "ΠαÏασκευή", "Σάββατο"],
abbreviatedDayNames: ["ΚυÏ", "Δευ", "ΤÏι", "Τετ", "Πεμ", "ΠαÏ", "Σαβ"],
shortestDayNames: ["Κυ", "Δε", "ΤÏ", "Τε", "Πε", "Πα", "Σά"],
firstLetterDayNames: ["Κ", "Δ", "Τ", "Τ", "Π", "Π", "Σ"],
/* Month Name Strings */
monthNames: ["ΙανουάÏιος", "ΦεβÏουάÏιος", "ΜάÏτιος", "ΑπÏίλιος", "Μάιος", "ΙοÏνιος", "ΙοÏλιος", "ΑÏγουστος", "ΣεπτÎμβÏιος", "ΟκτώβÏιος", "ÎοÎμβÏιος", "ΔεκÎμβÏιος"],
abbreviatedMonthNames: ["Ιαν", "Φεβ", "ΜαÏ", "ΑπÏ", "Μαϊ", "Ιουν", "Ιουλ", "Αυγ", "Σεπ", "Οκτ", "Îοε", "Δεκ"],
/* AM/PM Designators */
amDesignator: "πμ",
pmDesignator: "μμ",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d/M/yyyy",
longDate: "dddd, d MMMM yyyy",
shortTime: "h:mm tt",
longTime: "h:mm:ss tt",
fullDateTime: "dddd, d MMMM yyyy h:mm:ss tt",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^ιαν(ουάÏιος)?/i,
feb: /^φεβ(ÏουάÏιος)?/i,
mar: /^μάÏτιος/i,
apr: /^απÏ(ίλιος)?/i,
may: /^μάιος/i,
jun: /^ιοÏνιος/i,
jul: /^ιοÏλιος/i,
aug: /^αÏγουστος/i,
sep: /^σεπ(Ï„ÎμβÏιος)?/i,
oct: /^οκτ(ώβÏιος)?/i,
nov: /^νοÎμβÏιος/i,
dec: /^δεκ(ÎμβÏιος)?/i,
sun: /^κυ(Ï(ιακή)?)?/i,
mon: /^δε(Ï…(Ï„ÎÏα)?)?/i,
tue: /^Ï„Ï(ι(τη)?)?/i,
wed: /^τε(Ï„(άÏτη)?)?/i,
thu: /^πε(μ(πτη)?)?/i,
fri: /^πα(Ï(ασκευή)?)?/i,
sat: /^σά(β(βατο)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/en-US.js 0000664 0001750 0001750 00000015060 12242643315 014533 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "en-US",
englishName: "English (United States)",
nativeName: "English (United States)",
/* Day Name Strings */
dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
abbreviatedDayNames: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
shortestDayNames: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
firstLetterDayNames: ["S", "M", "T", "W", "T", "F", "S"],
/* Month Name Strings */
monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
abbreviatedMonthNames: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d.MM.yyyy",
longDate: "d. MMMM yyyy. a.",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d. MMMM yyyy. a. H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy. a."
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jaan(uar)?/i,
feb: /^veebr(uar)?/i,
mar: /^märts/i,
apr: /^apr(ill)?/i,
may: /^mai/i,
jun: /^juuni/i,
jul: /^juuli/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(oober)?/i,
nov: /^nov(ember)?/i,
dec: /^dets(ember)?/i,
sun: /^pühapäev/i,
mon: /^esmaspäev/i,
tue: /^teisipäev/i,
wed: /^kolmapäev/i,
thu: /^neljapäev/i,
fri: /^reede/i,
sat: /^laupäev/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/eu-ES.js 0000664 0001750 0001750 00000015232 12242643315 014523 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "eu-ES",
englishName: "Basque (Basque)",
nativeName: "euskara (euskara)",
/* Day Name Strings */
dayNames: ["igandea", "astelehena", "asteartea", "asteazkena", "osteguna", "ostirala", "larunbata"],
abbreviatedDayNames: ["ig.", "al.", "as.", "az.", "og.", "or.", "lr."],
shortestDayNames: ["ig", "al", "as", "az", "og", "or", "lr"],
firstLetterDayNames: ["i", "a", "a", "a", "o", "o", "l"],
/* Month Name Strings */
monthNames: ["urtarrila", "otsaila", "martxoa", "apirila", "maiatza", "ekaina", "uztaila", "abuztua", "iraila", "urria", "azaroa", "abendua"],
abbreviatedMonthNames: ["urt.", "ots.", "mar.", "api.", "mai.", "eka.", "uzt.", "abu.", "ira.", "urr.", "aza.", "abe."],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy/MM/dd",
longDate: "dddd, yyyy.eko MMMMk d",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "dddd, yyyy.eko MMMMk d HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "MMMM dd",
yearMonth: "yyyy.eko MMMM"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^urt(.(arrila)?)?/i,
feb: /^ots(.(aila)?)?/i,
mar: /^mar(.(txoa)?)?/i,
apr: /^api(.(rila)?)?/i,
may: /^mai(.(atza)?)?/i,
jun: /^eka(.(ina)?)?/i,
jul: /^uzt(.(aila)?)?/i,
aug: /^abu(.(ztua)?)?/i,
sep: /^ira(.(ila)?)?/i,
oct: /^urr(.(ia)?)?/i,
nov: /^aza(.(roa)?)?/i,
dec: /^abe(.(ndua)?)?/i,
sun: /^ig((.(andea)?)?)?/i,
mon: /^al((.(telehena)?)?)?/i,
tue: /^as((.(teartea)?)?)?/i,
wed: /^az((.(teazkena)?)?)?/i,
thu: /^og((.(teguna)?)?)?/i,
fri: /^or((.(tirala)?)?)?/i,
sat: /^lr((.(runbata)?)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/extras.js 0000664 0001750 0001750 00000041140 12242643315 015110 0 ustar jan jan /**
* @version: 1.0 Alpha-1
* @author: Coolite Inc. http://www.coolite.com/
* @date: 2008-04-13
* @copyright: Copyright (c) 2006-2008, Coolite Inc. (http://www.coolite.com/). All rights reserved.
* @license: Licensed under The MIT License. See license.txt and http://www.datejs.com/license/.
* @website: http://www.datejs.com/
*/
(function () {
var $D = Date,
$P = $D.prototype,
$C = $D.CultureInfo,
$f = [],
p = function (s, l) {
if (!l) {
l = 2;
}
return ("000" + s).slice(l * -1);
};
/**
* Converts a PHP format string to Java/.NET format string.
* A PHP format string can be used with .$format or .format.
* A Java/.NET format string can be used with .toString().
* The .parseExact function will only accept a Java/.NET format string
*
* Example
var f1 = "%m/%d/%y"
var f2 = Date.normalizeFormat(f1); // "MM/dd/yy"
new Date().format(f1); // "04/13/08"
new Date().$format(f1); // "04/13/08"
new Date().toString(f2); // "04/13/08"
var date = Date.parseExact("04/13/08", f2); // Sun Apr 13 2008
* @param {String} A PHP format string consisting of one or more format spcifiers.
* @return {String} The PHP format converted to a Java/.NET format string.
*/
$D.normalizeFormat = function (format) {
$f = [];
var t = new Date().$format(format);
return $f.join("");
};
/**
* Format a local Unix timestamp according to locale settings
*
* Example
Date.strftime("%m/%d/%y", new Date()); // "04/13/08"
Date.strftime("c", "2008-04-13T17:52:03Z"); // "04/13/08"
* @param {String} A format string consisting of one or more format spcifiers [Optional].
* @param {Number} The number representing the number of seconds that have elapsed since January 1, 1970 (local time).
* @return {String} A string representation of the current Date object.
*/
$D.strftime = function (format, time) {
return new Date(time * 1000).$format(format);
};
/**
* Parse any textual datetime description into a Unix timestamp.
* A Unix timestamp is the number of seconds that have elapsed since January 1, 1970 (midnight UTC/GMT).
*
* Example
Format Description Example
------ --------------------------------------------------------------------------- -----------------------
%a abbreviated weekday name according to the current localed "Mon" through "Sun"
%A full weekday name according to the current locale "Sunday" through "Saturday"
%b abbreviated month name according to the current locale "Jan" through "Dec"
%B full month name according to the current locale "January" through "December"
%c preferred date and time representation for the current locale "4/13/2008 12:33 PM"
%C century number (the year divided by 100 and truncated to an integer) "00" to "99"
%d day of the month as a decimal number "01" to "31"
%D same as %m/%d/%y "04/13/08"
%e day of the month as a decimal number, a single digit is preceded by a space "1" to "31"
%g like %G, but without the century "08"
%G The 4-digit year corresponding to the ISO week number (see %V). "2008"
This has the same format and value as %Y, except that if the ISO week number
belongs to the previous or next year, that year is used instead.
%h same as %b "Jan" through "Dec"
%H hour as a decimal number using a 24-hour clock "00" to "23"
%I hour as a decimal number using a 12-hour clock "01" to "12"
%j day of the year as a decimal number "001" to "366"
%m month as a decimal number "01" to "12"
%M minute as a decimal number "00" to "59"
%n newline character "\n"
%p either "am" or "pm" according to the given time value, or the "am" or "pm"
corresponding strings for the current locale
%r time in a.m. and p.m. notation "8:44 PM"
%R time in 24 hour notation "20:44"
%S second as a decimal number "00" to "59"
%t tab character "\t"
%T current time, equal to %H:%M:%S "12:49:11"
%u weekday as a decimal number ["1", "7"], with "1" representing Monday "1" to "7"
%U week number of the current year as a decimal number, starting with the "0" to ("52" or "53")
first Sunday as the first day of the first week
%V The ISO 8601:1988 week number of the current year as a decimal number, "00" to ("52" or "53")
range 01 to 53, where week 1 is the first week that has at least 4 days
in the current year, and with Monday as the first day of the week.
(Use %G or %g for the year component that corresponds to the week number
for the specified timestamp.)
%W week number of the current year as a decimal number, starting with the "00" to ("52" or "53")
first Monday as the first day of the first week
%w day of the week as a decimal, Sunday being "0" "0" to "6"
%x preferred date representation for the current locale without the time "4/13/2008"
%X preferred time representation for the current locale without the date "12:53:05"
%y year as a decimal number without a century "00" "99"
%Y year as a decimal number including the century "2008"
%Z time zone or name or abbreviation "UTC", "EST", "PST"
%z same as %Z
%% a literal "%" character "%"
d Day of the month, 2 digits with leading zeros "01" to "31"
D A textual representation of a day, three letters "Mon" through "Sun"
j Day of the month without leading zeros "1" to "31"
l A full textual representation of the day of the week (lowercase "L") "Sunday" through "Saturday"
N ISO-8601 numeric representation of the day of the week (added in PHP 5.1.0) "1" (for Monday) through "7" (for Sunday)
S English ordinal suffix for the day of the month, 2 characters "st", "nd", "rd" or "th". Works well with j
w Numeric representation of the day of the week "0" (for Sunday) through "6" (for Saturday)
z The day of the year (starting from "0") "0" through "365"
W ISO-8601 week number of year, weeks starting on Monday "00" to ("52" or "53")
F A full textual representation of a month, such as January or March "January" through "December"
m Numeric representation of a month, with leading zeros "01" through "12"
M A short textual representation of a month, three letters "Jan" through "Dec"
n Numeric representation of a month, without leading zeros "1" through "12"
t Number of days in the given month "28" through "31"
L Whether it's a leap year "1" if it is a leap year, "0" otherwise
o ISO-8601 year number. This has the same value as Y, except that if the "2008"
ISO week number (W) belongs to the previous or next year, that year
is used instead.
Y A full numeric representation of a year, 4 digits "2008"
y A two digit representation of a year "08"
a Lowercase Ante meridiem and Post meridiem "am" or "pm"
A Uppercase Ante meridiem and Post meridiem "AM" or "PM"
B Swatch Internet time "000" through "999"
g 12-hour format of an hour without leading zeros "1" through "12"
G 24-hour format of an hour without leading zeros "0" through "23"
h 12-hour format of an hour with leading zeros "01" through "12"
H 24-hour format of an hour with leading zeros "00" through "23"
i Minutes with leading zeros "00" to "59"
s Seconds, with leading zeros "00" through "59"
u Milliseconds "54321"
e Timezone identifier "UTC", "EST", "PST"
I Whether or not the date is in daylight saving time (uppercase i) "1" if Daylight Saving Time, "0" otherwise
O Difference to Greenwich time (GMT) in hours "+0200", "-0600"
P Difference to Greenwich time (GMT) with colon between hours and minutes "+02:00", "-06:00"
T Timezone abbreviation "UTC", "EST", "PST"
Z Timezone offset in seconds. The offset for timezones west of UTC is "-43200" through "50400"
always negative, and for those east of UTC is always positive.
c ISO 8601 date "2004-02-12T15:19:21+00:00"
r RFC 2822 formatted date "Thu, 21 Dec 2000 16:01:07 +0200"
U Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT) "0"
* @param {String} A format string consisting of one or more format spcifiers [Optional].
* @return {String} A string representation of the current Date object.
*/
$P.$format = function (format) {
var x = this,
y,
t = function (v) {
$f.push(v);
return x.toString(v);
};
return format ? format.replace(/(%|\\)?.|%%/g,
function (m) {
if (m.charAt(0) === "\\" || m.substring(0, 2) === "%%") {
return m.replace("\\", "").replace("%%", "%");
}
switch (m) {
case "d":
case "%d":
return t("dd");
case "D":
case "%a":
return t("ddd");
case "j":
case "%e":
return t("d");
case "l":
case "%A":
return t("dddd");
case "N":
case "%u":
return x.getDay() + 1;
case "S":
return t("S");
case "w":
case "%w":
return x.getDay();
case "z":
return x.getOrdinalNumber();
case "%j":
return p(x.getOrdinalNumber(), 3);
case "%U":
var d1 = x.clone().set({month: 0, day: 1}).addDays(-1).moveToDayOfWeek(0),
d2 = x.clone().addDays(1).moveToDayOfWeek(0, -1);
return (d2 < d1) ? "00" : p((d2.getOrdinalNumber() - d1.getOrdinalNumber()) / 7 + 1);
case "W":
case "%V":
return x.getISOWeek();
case "%W":
return p(x.getWeek());
case "F":
case "%B":
return t("MMMM");
case "m":
case "%m":
return t("MM");
case "M":
case "%b":
case "%h":
return t("MMM");
case "n":
return t("M");
case "t":
return $D.getDaysInMonth(x.getFullYear(), x.getMonth());
case "L":
return ($D.isLeapYear(x.getFullYear())) ? 1 : 0;
case "o":
case "%G":
return x.setWeek(x.getISOWeek()).toString("yyyy");
case "%g":
return x.$format("%G").slice(-2);
case "Y":
case "%Y":
return t("yyyy");
case "y":
case "%y":
return t("yy");
case "a":
case "%p":
return t("tt").toLowerCase();
case "A":
return t("tt").toUpperCase();
case "g":
case "%I":
return t("h");
case "G":
return t("H");
case "h":
return t("hh");
case "H":
case "%H":
return t("HH");
case "i":
case "%M":
return t("mm");
case "s":
case "%S":
return t("ss");
case "u":
return p(x.getMilliseconds(), 3);
case "I":
return (x.isDaylightSavingTime()) ? 1 : 0;
case "O":
return x.getUTCOffset();
case "P":
y = x.getUTCOffset();
return y.substring(0, y.length - 2) + ":" + y.substring(y.length - 2);
case "e":
case "T":
case "%z":
case "%Z":
return x.getTimezone();
case "Z":
return x.getTimezoneOffset() * -60;
case "B":
var now = new Date();
return Math.floor(((now.getHours() * 3600) + (now.getMinutes() * 60) + now.getSeconds() + (now.getTimezoneOffset() + 60) * 60) / 86.4);
case "c":
return x.toISOString().replace(/\"/g, "");
case "U":
return $D.strtotime("now");
case "%c":
return t("d") + " " + t("t");
case "%C":
return Math.floor(x.getFullYear() / 100 + 1);
case "%D":
return t("MM/dd/yy");
case "%n":
return "\\n";
case "%t":
return "\\t";
case "%r":
return t("hh:mm tt");
case "%R":
return t("H:mm");
case "%T":
return t("H:mm:ss");
case "%x":
return t("d");
case "%X":
return t("t");
default:
$f.push(m);
return m;
}
}
) : this._toString();
};
if (!$P.format) {
$P.format = $P.$format;
}
}());
Horde_Core-2.11.1/js/date/fa-IR.js 0000664 0001750 0001750 00000015060 12242643315 014502 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "fa-IR",
englishName: "Persian (Iran)",
nativeName: "Ùارسى (ايران)",
/* Day Name Strings */
dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
abbreviatedDayNames: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
shortestDayNames: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
firstLetterDayNames: ["S", "M", "T", "W", "T", "F", "S"],
/* Month Name Strings */
monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
abbreviatedMonthNames: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
/* AM/PM Designators */
amDesignator: "ق.ظ",
pmDesignator: "ب.ظ",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "mdy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "M/d/yyyy",
longDate: "dddd, MMMM dd, yyyy",
shortTime: "hh:mm tt",
longTime: "hh:mm:ss tt",
fullDateTime: "dddd, MMMM dd, yyyy hh:mm:ss tt",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "MMMM dd",
yearMonth: "MMMM, yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uary)?/i,
feb: /^feb(ruary)?/i,
mar: /^mar(ch)?/i,
apr: /^apr(il)?/i,
may: /^may/i,
jun: /^jun(e)?/i,
jul: /^jul(y)?/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^oct(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^dec(ember)?/i,
sun: /^su(n(day)?)?/i,
mon: /^mo(n(day)?)?/i,
tue: /^tu(e(s(day)?)?)?/i,
wed: /^we(d(nesday)?)?/i,
thu: /^th(u(r(s(day)?)?)?)?/i,
fri: /^fr(i(day)?)?/i,
sat: /^sa(t(urday)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/fi-FI.js 0000664 0001750 0001750 00000015057 12242643315 014504 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "fi-FI",
englishName: "Finnish (Finland)",
nativeName: "suomi (Suomi)",
/* Day Name Strings */
dayNames: ["sunnuntai", "maanantai", "tiistai", "keskiviikko", "torstai", "perjantai", "lauantai"],
abbreviatedDayNames: ["su", "ma", "ti", "ke", "to", "pe", "la"],
shortestDayNames: ["su", "ma", "ti", "ke", "to", "pe", "la"],
firstLetterDayNames: ["s", "m", "t", "k", "t", "p", "l"],
/* Month Name Strings */
monthNames: ["tammikuu", "helmikuu", "maaliskuu", "huhtikuu", "toukokuu", "kesäkuu", "heinäkuu", "elokuu", "syyskuu", "lokakuu", "marraskuu", "joulukuu"],
abbreviatedMonthNames: ["tammi", "helmi", "maalis", "huhti", "touko", "kesä", "heinä", "elo", "syys", "loka", "marras", "joulu"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd/MM/yyyy",
longDate: "dd MMMM yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "dd MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uari)?/i,
feb: /^feb(ruari)?/i,
mar: /^mar(et)?/i,
apr: /^apr(il)?/i,
may: /^mei/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^agust(us)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nop(ember)?/i,
dec: /^des(ember)?/i,
sun: /^m(1)?/i,
mon: /^s(en(in)?)?/i,
tue: /^s(el(asa)?)?/i,
wed: /^r(1)?/i,
thu: /^k(1)?/i,
fri: /^j(1)?/i,
sat: /^s(1)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/is-IS.js 0000664 0001750 0001750 00000015270 12242643315 014533 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "is-IS",
englishName: "Icelandic (Iceland)",
nativeName: "Ãslenska (Ãsland)",
/* Day Name Strings */
dayNames: ["sunnudagur", "mánudagur", "þriðjudagur", "miðvikudagur", "fimmtudagur", "föstudagur", "laugardagur"],
abbreviatedDayNames: ["sun.", "mán.", "þri.", "mið.", "fim.", "fös.", "lau."],
shortestDayNames: ["su", "má", "þr", "mi", "fi", "fö", "la"],
firstLetterDayNames: ["s", "m", "þ", "m", "f", "f", "l"],
/* Month Name Strings */
monthNames: ["janúar", "febrúar", "mars", "aprÃl", "maÃ", "júnÃ", "júlÃ", "ágúst", "september", "október", "nóvember", "desember"],
abbreviatedMonthNames: ["jan.", "feb.", "mar.", "apr.", "maÃ", "jún.", "júl.", "ágú.", "sep.", "okt.", "nóv.", "des."],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d.M.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d. MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(.(úar)?)?/i,
feb: /^feb(.(rúar)?)?/i,
mar: /^mar(.(s)?)?/i,
apr: /^apr(.(Ãl)?)?/i,
may: /^maÃ/i,
jun: /^jún(.(Ã)?)?/i,
jul: /^júl(.(Ã)?)?/i,
aug: /^ágú(.(st)?)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(.(óber)?)?/i,
nov: /^nóv(.(ember)?)?/i,
dec: /^des(.(ember)?)?/i,
sun: /^su(n(.(nudagur)?)?)?/i,
mon: /^má(n(.(udagur)?)?)?/i,
tue: /^þr(i(.(ðjudagur)?)?)?/i,
wed: /^mi(ð(.(vikudagur)?)?)?/i,
thu: /^fi(m(.(mtudagur)?)?)?/i,
fri: /^fö(s(.(tudagur)?)?)?/i,
sat: /^la(u(.(gardagur)?)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/it-IT.js 0000664 0001750 0001750 00000015045 12242643315 014535 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "it-IT",
englishName: "Italian (Italy)",
nativeName: "italiano (Italia)",
/* Day Name Strings */
dayNames: ["domenica", "lunedì", "martedì", "mercoledì", "giovedì", "venerdì", "sabato"],
abbreviatedDayNames: ["dom", "lun", "mar", "mer", "gio", "ven", "sab"],
shortestDayNames: ["do", "lu", "ma", "me", "gi", "ve", "sa"],
firstLetterDayNames: ["d", "l", "m", "m", "g", "v", "s"],
/* Month Name Strings */
monthNames: ["gennaio", "febbraio", "marzo", "aprile", "maggio", "giugno", "luglio", "agosto", "settembre", "ottobre", "novembre", "dicembre"],
abbreviatedMonthNames: ["gen", "feb", "mar", "apr", "mag", "giu", "lug", "ago", "set", "ott", "nov", "dic"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd/MM/yyyy",
longDate: "dddd d MMMM yyyy",
shortTime: "H.mm",
longTime: "H.mm.ss",
fullDateTime: "dddd d MMMM yyyy H.mm.ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^gen(naio)?/i,
feb: /^feb(braio)?/i,
mar: /^mar(zo)?/i,
apr: /^apr(ile)?/i,
may: /^mag(gio)?/i,
jun: /^giu(gno)?/i,
jul: /^lug(lio)?/i,
aug: /^ago(sto)?/i,
sep: /^set(tembre)?/i,
oct: /^ott(obre)?/i,
nov: /^nov(embre)?/i,
dec: /^dic(embre)?/i,
sun: /^do(m(enica)?)?/i,
mon: /^lu(n(edì)?)?/i,
tue: /^ma(r(tedì)?)?/i,
wed: /^me(r(coledì)?)?/i,
thu: /^gi(o(vedì)?)?/i,
fri: /^ve(n(erdì)?)?/i,
sat: /^sa(b(ato)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/ja-JP.js 0000664 0001750 0001750 00000014730 12242643315 014510 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "ja-JP",
englishName: "Japanese (Japan)",
nativeName: "日本語 (日本)",
/* Day Name Strings */
dayNames: ["日曜日", "月曜日", "ç«æ›œæ—¥", "水曜日", "木曜日", "金曜日", "土曜日"],
abbreviatedDayNames: ["æ—¥", "月", "ç«", "æ°´", "木", "金", "土"],
shortestDayNames: ["æ—¥", "月", "ç«", "æ°´", "木", "金", "土"],
firstLetterDayNames: ["æ—¥", "月", "ç«", "æ°´", "木", "金", "土"],
/* Month Name Strings */
monthNames: ["1月", "2月", "3月", "4月", "5月", "6月", "7月", "8月", "9月", "10月", "11月", "12月"],
abbreviatedMonthNames: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"],
/* AM/PM Designators */
amDesignator: "åˆå‰",
pmDesignator: "åˆå¾Œ",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy.MM.dd",
longDate: "yyyy \\m. MMMM d \\d.",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "yyyy \\m. MMMM d \\d. HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "MMMM d \\d.",
yearMonth: "yyyy \\m. MMMM"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^sau(sis)?/i,
feb: /^vas(aris)?/i,
mar: /^kov(as)?/i,
apr: /^bal(andis)?/i,
may: /^geg(užė)?/i,
jun: /^bir(želis)?/i,
jul: /^lie(pa)?/i,
aug: /^rugpjūtis/i,
sep: /^rugsÄ—jis/i,
oct: /^spalis/i,
nov: /^lap(kritis)?/i,
dec: /^gruodis/i,
sun: /^s(k(kmadienis)?)?/i,
mon: /^p(r(rmadienis)?)?/i,
tue: /^a(n(tradienis)?)?/i,
wed: /^t(r(eÄiadienis)?)?/i,
thu: /^k(t(tvirtadienis)?)?/i,
fri: /^penktadienis/i,
sat: /^Å¡(t(Å¡tadienis)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/lv-LV.js 0000664 0001750 0001750 00000015374 12242643315 014554 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "lv-LV",
englishName: "Latvian (Latvia)",
nativeName: "latviešu (Latvija)",
/* Day Name Strings */
dayNames: ["svētdiena", "pirmdiena", "otrdiena", "trešdiena", "ceturtdiena", "piektdiena", "sestdiena"],
abbreviatedDayNames: ["Sv", "Pr", "Ot", "Tr", "Ce", "Pk", "Se"],
shortestDayNames: ["Sv", "Pr", "Ot", "Tr", "Ce", "Pk", "Se"],
firstLetterDayNames: ["S", "P", "O", "T", "C", "P", "S"],
/* Month Name Strings */
monthNames: ["janvÄris", "februÄris", "marts", "aprÄ«lis", "maijs", "jÅ«nijs", "jÅ«lijs", "augusts", "septembris", "oktobris", "novembris", "decembris"],
abbreviatedMonthNames: ["Jan", "Feb", "Mar", "Apr", "Mai", "JÅ«n", "JÅ«l", "Aug", "Sep", "Okt", "Nov", "Dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy.MM.dd.",
longDate: "dddd, yyyy. ga\\da d. MMMM",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "dddd, yyyy. ga\\da d. MMMM H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "yyyy. MMMM"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(vÄris)?/i,
feb: /^feb(ruÄris)?/i,
mar: /^mar(ts)?/i,
apr: /^apr(Ä«lis)?/i,
may: /^mai(js)?/i,
jun: /^jūn(ijs)?/i,
jul: /^jūl(ijs)?/i,
aug: /^aug(usts)?/i,
sep: /^sep(tembris)?/i,
oct: /^okt(obris)?/i,
nov: /^nov(embris)?/i,
dec: /^dec(embris)?/i,
sun: /^svēt(dien(a)?)?/i,
mon: /^pirm(dien(a)?)?/i,
tue: /^otr(dien(a)?)?/i,
wed: /^treš(dien(a)?)?/i,
thu: /^ceturt(dien(a)?)?/i,
fri: /^piekt(dien(a)?)?/i,
sat: /^sest(dien(a)?)?/i,
future: /^nÄkoÅ¡(Ä|ais)?/i,
past: /^pagÄj(uÅ¡(Ä|ais)?)?|iepr(iekÅ¡Ä“j(Ä|ais)?)?/i,
add: /^(\+|pēc)/i,
subtract: /^(\-|pirms)/i,
yesterday: /^vakar(dien(a)?)?/i,
today: /^Å¡odien(a)?/i,
tomorrow: /^rīt(dien(a)?)?/i,
now: /^tagad/i,
millisecond: /^ms|milisekunde(s)?/i,
second: /^sec|sekunde(s)?/i,
minute: /^min|minūte(s)?/i,
hour: /^h|stunda(s)?/i,
week: /^w|nedēļa(s)?/i,
month: /^m|mēne(sis|ši)/i,
day: /^d|diena(s)?/i,
year: /^y|gad(s|i)/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about apmēram
* ago pirms
* date datums
* time laiks
* calendar kalendÄrs
* show parÄdÄ«t
* hourly ikstundas
* daily ikdienas
* weekly iknedēļas
* bi-weekly reizi divÄs nedēļÄs
* fortnight divas nedēļas
* monthly ikmēnesi
* bi-monthly reizi divos mēnešos
* quarter ceturksnis
* quarterly ikceturksni
* yearly ikgadu
* annual ikgadējs
* annually ikgadu
* annum gadÄ
* again atkal
* between starp
* after pēc
* from now turpmÄk
* repeat atkÄrtot
* times reizes
* per reizi
* min (abbrev minute) min
* morning rīts
* noon pusdienas
* night nakts
* midnight pusnakts
* mid-night pusnakts
* evening vakars
* final gala
* future nÄkotne
* spring pavasaris
* summer vasara
* fall rudens
* winter ziema
* end of beigas
* end beigas
* long garš
* short Ä«ss
*/
Horde_Core-2.11.1/js/date/mk-MK.js 0000664 0001750 0001750 00000015615 12242643315 014526 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "mk-MK",
englishName: "Macedonian (Former Yugoslav Republic of Macedonia)",
nativeName: "македонÑки јазик (Македонија)",
/* Day Name Strings */
dayNames: ["недела", "понеделник", "вторник", "Ñреда", "четврток", "петок", "Ñабота"],
abbreviatedDayNames: ["нед", "пон", "втр", "Ñрд", "чет", "пет", "Ñаб"],
shortestDayNames: ["не", "по", "вт", "ÑÑ€", "че", "пе", "Ñа"],
firstLetterDayNames: ["н", "п", "в", "Ñ", "ч", "п", "Ñ"],
/* Month Name Strings */
monthNames: ["јануари", "февруари", "март", "април", "мај", "јуни", "јули", "авгуÑÑ‚", "Ñептември", "октомври", "ноември", "декември"],
abbreviatedMonthNames: ["јан", "фев", "мар", "апр", "мај", "јун", "јул", "авг", "Ñеп", "окт", "ное", "дек"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "dddd, dd MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "dddd, dd MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^јан(уари)?/i,
feb: /^фев(руари)?/i,
mar: /^мар(т)?/i,
apr: /^апр(ил)?/i,
may: /^мај/i,
jun: /^јун(и)?/i,
jul: /^јул(и)?/i,
aug: /^авг(уÑÑ‚)?/i,
sep: /^Ñеп(тември)?/i,
oct: /^окт(омври)?/i,
nov: /^ное(мври)?/i,
dec: /^дек(ември)?/i,
sun: /^не(д(ела)?)?/i,
mon: /^по(н(еделник)?)?/i,
tue: /^вт(р(рник)?)?/i,
wed: /^ÑÑ€(д(да)?)?/i,
thu: /^че(т(врток)?)?/i,
fri: /^пе(т(ок)?)?/i,
sat: /^Ñа(б(ота)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/nb-NO.js 0000664 0001750 0001750 00000014734 12242643315 014524 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "nb-NO",
englishName: "Norwegian, Bokmål (Norway)",
nativeName: "norsk, bokmål (Norge)",
/* Day Name Strings */
dayNames: ["søndag", "mandag", "tirsdag", "onsdag", "torsdag", "fredag", "lørdag"],
abbreviatedDayNames: ["sø", "ma", "ti", "on", "to", "fr", "lø"],
shortestDayNames: ["sø", "ma", "ti", "on", "to", "fr", "lø"],
firstLetterDayNames: ["s", "m", "t", "o", "t", "f", "l"],
/* Month Name Strings */
monthNames: ["januar", "februar", "mars", "april", "mai", "juni", "juli", "august", "september", "oktober", "november", "desember"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "mai", "jun", "jul", "aug", "sep", "okt", "nov", "des"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d. MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^mar(s)?/i,
apr: /^apr(il)?/i,
may: /^mai/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^des(ember)?/i,
sun: /^søndag/i,
mon: /^mandag/i,
tue: /^tirsdag/i,
wed: /^onsdag/i,
thu: /^torsdag/i,
fri: /^fredag/i,
sat: /^lørdag/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/nl-NL.js 0000664 0001750 0001750 00000014746 12242643315 014536 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "nl-NL",
englishName: "Dutch (Netherlands)",
nativeName: "Nederlands (Nederland)",
/* Day Name Strings */
dayNames: ["zondag", "maandag", "dinsdag", "woensdag", "donderdag", "vrijdag", "zaterdag"],
abbreviatedDayNames: ["zo", "ma", "di", "wo", "do", "vr", "za"],
shortestDayNames: ["zo", "ma", "di", "wo", "do", "vr", "za"],
firstLetterDayNames: ["z", "m", "d", "w", "d", "v", "z"],
/* Month Name Strings */
monthNames: ["januari", "februari", "maart", "april", "mei", "juni", "juli", "augustus", "september", "oktober", "november", "december"],
abbreviatedMonthNames: ["jan", "feb", "mrt", "apr", "mei", "jun", "jul", "aug", "sep", "okt", "nov", "dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d-M-yyyy",
longDate: "dddd d MMMM yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "dddd d MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uari)?/i,
feb: /^feb(ruari)?/i,
mar: /^maart/i,
apr: /^apr(il)?/i,
may: /^mei/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^aug(ustus)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^dec(ember)?/i,
sun: /^zondag/i,
mon: /^maandag/i,
tue: /^dinsdag/i,
wed: /^woensdag/i,
thu: /^donderdag/i,
fri: /^vrijdag/i,
sat: /^zaterdag/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/nn-NO.js 0000664 0001750 0001750 00000014734 12242643315 014540 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "nn-NO",
englishName: "Norwegian, Nynorsk (Norway)",
nativeName: "norsk, nynorsk (Noreg)",
/* Day Name Strings */
dayNames: ["søndag", "måndag", "tysdag", "onsdag", "torsdag", "fredag", "laurdag"],
abbreviatedDayNames: ["sø", "må", "ty", "on", "to", "fr", "la"],
shortestDayNames: ["sø", "må", "ty", "on", "to", "fr", "la"],
firstLetterDayNames: ["s", "m", "t", "o", "t", "f", "l"],
/* Month Name Strings */
monthNames: ["januar", "februar", "mars", "april", "mai", "juni", "juli", "august", "september", "oktober", "november", "desember"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "mai", "jun", "jul", "aug", "sep", "okt", "nov", "des"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d. MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^mar(s)?/i,
apr: /^apr(il)?/i,
may: /^mai/i,
jun: /^jun(i)?/i,
jul: /^jul(i)?/i,
aug: /^aug(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^des(ember)?/i,
sun: /^søndag/i,
mon: /^måndag/i,
tue: /^tysdag/i,
wed: /^onsdag/i,
thu: /^torsdag/i,
fri: /^fredag/i,
sat: /^laurdag/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/pl-PL.js 0000664 0001750 0001750 00000014773 12242643315 014542 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "pl-PL",
englishName: "Polish (Poland)",
nativeName: "polski (Polska)",
/* Day Name Strings */
dayNames: ["niedziela", "poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota"],
abbreviatedDayNames: ["N", "Pn", "Wt", "Åšr", "Cz", "Pt", "So"],
shortestDayNames: ["N", "Pn", "Wt", "Åšr", "Cz", "Pt", "So"],
firstLetterDayNames: ["N", "P", "W", "Åš", "C", "P", "S"],
/* Month Name Strings */
monthNames: ["styczeń", "luty", "marzec", "kwiecień", "maj", "czerwiec", "lipiec", "sierpień", "wrzesień", "październik", "listopad", "grudzień"],
abbreviatedMonthNames: ["sty", "lut", "mar", "kwi", "maj", "cze", "lip", "sie", "wrz", "paź", "lis", "gru"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy-MM-dd",
longDate: "d MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^sty(czeń)?/i,
feb: /^lut(y)?/i,
mar: /^mar(zec)?/i,
apr: /^kwi(ecień)?/i,
may: /^maj/i,
jun: /^cze(rwiec)?/i,
jul: /^lip(iec)?/i,
aug: /^sie(rpień)?/i,
sep: /^wrz(esień)?/i,
oct: /^paź(dziernik)?/i,
nov: /^lis(topad)?/i,
dec: /^gru(dzień)?/i,
sun: /^niedziela/i,
mon: /^poniedziałek/i,
tue: /^wtorek/i,
wed: /^środa/i,
thu: /^czwartek/i,
fri: /^piÄ…tek/i,
sat: /^sobota/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/pt-BR.js 0000664 0001750 0001750 00000015106 12242643315 014531 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "pt-BR",
englishName: "Portuguese (Brazil)",
nativeName: "Português (Brasil)",
/* Day Name Strings */
dayNames: ["domingo", "segunda-feira", "terça-feira", "quarta-feira", "quinta-feira", "sexta-feira", "sábado"],
abbreviatedDayNames: ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"],
shortestDayNames: ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"],
firstLetterDayNames: ["d", "s", "t", "q", "q", "s", "s"],
/* Month Name Strings */
monthNames: ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"],
abbreviatedMonthNames: ["jan", "fev", "mar", "abr", "mai", "jun", "jul", "ago", "set", "out", "nov", "dez"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d/M/yyyy",
longDate: "dddd, d \\de MMMM \\de yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "dddd, d \\de MMMM \\de yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd \\de MMMM",
yearMonth: "MMMM \\de yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(eiro)?/i,
feb: /^fev(ereiro)?/i,
mar: /^mar(ço)?/i,
apr: /^abr(il)?/i,
may: /^mai(o)?/i,
jun: /^jun(ho)?/i,
jul: /^jul(ho)?/i,
aug: /^ago(sto)?/i,
sep: /^set(embro)?/i,
oct: /^out(ubro)?/i,
nov: /^nov(embro)?/i,
dec: /^dez(embro)?/i,
sun: /^domingo/i,
mon: /^segunda-feira/i,
tue: /^terça-feira/i,
wed: /^quarta-feira/i,
thu: /^quinta-feira/i,
fri: /^sexta-feira/i,
sat: /^sábado/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/pt-PT.js 0000664 0001750 0001750 00000015103 12242643315 014546 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "pt-PT",
englishName: "Portuguese (Portugal)",
nativeName: "português (Portugal)",
/* Day Name Strings */
dayNames: ["domingo", "segunda-feira", "terça-feira", "quarta-feira", "quinta-feira", "sexta-feira", "sábado"],
abbreviatedDayNames: ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"],
shortestDayNames: ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"],
firstLetterDayNames: ["d", "s", "t", "q", "q", "s", "s"],
/* Month Name Strings */
monthNames: ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"],
abbreviatedMonthNames: ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov", "Dez"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd-MM-yyyy",
longDate: "dddd, d \\de MMMM \\de yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "dddd, d \\de MMMM \\de yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d/M",
yearMonth: "MMMM \\de yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(eiro)?/i,
feb: /^fev(ereiro)?/i,
mar: /^mar(ço)?/i,
apr: /^abr(il)?/i,
may: /^mai(o)?/i,
jun: /^jun(ho)?/i,
jul: /^jul(ho)?/i,
aug: /^ago(sto)?/i,
sep: /^set(embro)?/i,
oct: /^out(ubro)?/i,
nov: /^nov(embro)?/i,
dec: /^dez(embro)?/i,
sun: /^domingo/i,
mon: /^segunda-feira/i,
tue: /^terça-feira/i,
wed: /^quarta-feira/i,
thu: /^quinta-feira/i,
fri: /^sexta-feira/i,
sat: /^sábado/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/ro-RO.js 0000664 0001750 0001750 00000015022 12242643315 014540 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "ro-RO",
englishName: "Romanian (Romania)",
nativeName: "română (România)",
/* Day Name Strings */
dayNames: ["duminică", "luni", "marţi", "miercuri", "joi", "vineri", "sâmbătă"],
abbreviatedDayNames: ["D", "L", "Ma", "Mi", "J", "V", "S"],
shortestDayNames: ["D", "L", "Ma", "Mi", "J", "V", "S"],
firstLetterDayNames: ["D", "L", "M", "M", "J", "V", "S"],
/* Month Name Strings */
monthNames: ["ianuarie", "februarie", "martie", "aprilie", "mai", "iunie", "iulie", "august", "septembrie", "octombrie", "noiembrie", "decembrie"],
abbreviatedMonthNames: ["ian.", "feb.", "mar.", "apr.", "mai.", "iun.", "iul.", "aug.", "sep.", "oct.", "nov.", "dec."],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "d MMMM yyyy",
shortTime: "HH:mm",
longTime: "HH:mm:ss",
fullDateTime: "d MMMM yyyy HH:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^ian(.(uarie)?)?/i,
feb: /^feb(.(ruarie)?)?/i,
mar: /^mar(.(tie)?)?/i,
apr: /^apr(.(ilie)?)?/i,
may: /^mai(.()?)?/i,
jun: /^iun(.(ie)?)?/i,
jul: /^iul(.(ie)?)?/i,
aug: /^aug(.(ust)?)?/i,
sep: /^sep(.(tembrie)?)?/i,
oct: /^oct(.(ombrie)?)?/i,
nov: /^noiembrie/i,
dec: /^dec(.(embrie)?)?/i,
sun: /^duminică/i,
mon: /^luni/i,
tue: /^marţi/i,
wed: /^miercuri/i,
thu: /^joi/i,
fri: /^vineri/i,
sat: /^sâmbătă/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/ru-RU.js 0000664 0001750 0001750 00000015447 12242643315 014567 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "ru-RU",
englishName: "Russian (Russia)",
nativeName: "руÑÑкий (РоÑÑиÑ)",
/* Day Name Strings */
dayNames: ["воÑкреÑенье", "понедельник", "вторник", "Ñреда", "четверг", "пÑтница", "Ñуббота"],
abbreviatedDayNames: ["Ð’Ñ", "Пн", "Ð’Ñ‚", "Ср", "Чт", "Пт", "Сб"],
shortestDayNames: ["Ð’Ñ", "Пн", "Ð’Ñ‚", "Ср", "Чт", "Пт", "Сб"],
firstLetterDayNames: ["В", "П", "В", "С", "Ч", "П", "С"],
/* Month Name Strings */
monthNames: ["Январь", "Февраль", "Март", "Ðпрель", "Май", "Июнь", "Июль", "ÐвгуÑÑ‚", "СентÑбрь", "ОктÑбрь", "ÐоÑбрь", "Декабрь"],
abbreviatedMonthNames: ["Ñнв", "фев", "мар", "апр", "май", "июн", "июл", "авг", "Ñен", "окт", "ноÑ", "дек"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "d MMMM yyyy \\г.",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d MMMM yyyy \\г. H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "MMMM dd",
yearMonth: "MMMM yyyy \\г."
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^Ñнв(арь)?/i,
feb: /^фев(раль)?/i,
mar: /^мар(т)?/i,
apr: /^апр(ель)?/i,
may: /^май/i,
jun: /^июн(ь)?/i,
jul: /^июл(ь)?/i,
aug: /^авг(уÑÑ‚)?/i,
sep: /^Ñен(Ñ‚Ñбрь)?/i,
oct: /^окт(Ñбрь)?/i,
nov: /^ноÑ(брь)?/i,
dec: /^дек(абрь)?/i,
sun: /^воÑкреÑенье/i,
mon: /^понедельник/i,
tue: /^вторник/i,
wed: /^Ñреда/i,
thu: /^четверг/i,
fri: /^пÑтница/i,
sat: /^Ñуббота/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/sk-SK.js 0000664 0001750 0001750 00000014700 12242643315 014534 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "sk-SK",
englishName: "Slovak (Slovakia)",
nativeName: "slovenÄina (Slovenská republika)",
/* Day Name Strings */
dayNames: ["nedeľa", "pondelok", "utorok", "streda", "štvrtok", "piatok", "sobota"],
abbreviatedDayNames: ["ne", "po", "ut", "st", "Å¡t", "pi", "so"],
shortestDayNames: ["ne", "po", "ut", "st", "Å¡t", "pi", "so"],
firstLetterDayNames: ["n", "p", "u", "s", "Å¡", "p", "s"],
/* Month Name Strings */
monthNames: ["január", "február", "marec", "aprÃl", "máj", "jún", "júl", "august", "september", "október", "november", "december"],
abbreviatedMonthNames: ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d. M. yyyy",
longDate: "d. MMMM yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d. MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^január/i,
feb: /^február/i,
mar: /^marec/i,
apr: /^aprÃl/i,
may: /^máj/i,
jun: /^jún/i,
jul: /^júl/i,
aug: /^august/i,
sep: /^sep(t(ember)?)?/i,
oct: /^október/i,
nov: /^november/i,
dec: /^december/i,
sun: /^nedeľa/i,
mon: /^pondelok/i,
tue: /^utorok/i,
wed: /^streda/i,
thu: /^Å¡tvrtok/i,
fri: /^piatok/i,
sat: /^sobota/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/sl-SI.js 0000664 0001750 0001750 00000015005 12242643315 014532 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "sl-SI",
englishName: "Slovenian (Slovenia)",
nativeName: "slovenski (Slovenija)",
/* Day Name Strings */
dayNames: ["nedelja", "ponedeljek", "torek", "sreda", "Äetrtek", "petek", "sobota"],
abbreviatedDayNames: ["ned", "pon", "tor", "sre", "Äet", "pet", "sob"],
shortestDayNames: ["ne", "po", "to", "sr", "Äe", "pe", "so"],
firstLetterDayNames: ["n", "p", "t", "s", "Ä", "p", "s"],
/* Month Name Strings */
monthNames: ["januar", "februar", "marec", "april", "maj", "junij", "julij", "avgust", "september", "oktober", "november", "december"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "maj", "jun", "jul", "avg", "sep", "okt", "nov", "dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d.M.yyyy",
longDate: "d. MMMM yyyy",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d. MMMM yyyy H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d. MMMM",
yearMonth: "MMMM yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^jan(uar)?/i,
feb: /^feb(ruar)?/i,
mar: /^mar(ec)?/i,
apr: /^apr(il)?/i,
may: /^maj/i,
jun: /^jun(ij)?/i,
jul: /^jul(ij)?/i,
aug: /^avg(ust)?/i,
sep: /^sep(t(ember)?)?/i,
oct: /^okt(ober)?/i,
nov: /^nov(ember)?/i,
dec: /^dec(ember)?/i,
sun: /^ne(d(elja)?)?/i,
mon: /^po(n(edeljek)?)?/i,
tue: /^to(r(ek)?)?/i,
wed: /^sr(e(da)?)?/i,
thu: /^Äe(t(rtek)?)?/i,
fri: /^pe(t(ek)?)?/i,
sat: /^so(b(ota)?)?/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/sv-SE.js 0000664 0001750 0001750 00000014743 12242643315 014550 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "sv-SE",
englishName: "Swedish (Sweden)",
nativeName: "svenska (Sverige)",
/* Day Name Strings */
dayNames: ["söndag", "måndag", "tisdag", "onsdag", "torsdag", "fredag", "lördag"],
abbreviatedDayNames: ["sö", "må", "ti", "on", "to", "fr", "lö"],
shortestDayNames: ["sö", "må", "ti", "on", "to", "fr", "lö"],
firstLetterDayNames: ["s", "m", "t", "o", "t", "f", "l"],
/* Month Name Strings */
monthNames: ["januari", "februari", "mars", "april", "maj", "juni", "juli", "augusti", "september", "oktober", "november", "december"],
abbreviatedMonthNames: ["jan", "feb", "mar", "apr", "maj", "jun", "jul", "aug", "sep", "okt", "nov", "dec"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*
* NOTE: It is VERY important this value be correct for each Culture.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "d/M/yyyy",
longDate: "dddd, dd, MMMM, yyyy",
shortTime: "h:mm tt",
longTime: "h:mm:ss tt",
fullDateTime: "dddd, dd, MMMM, yyyy h:mm:ss tt",
sortableDateTime: "dd-MM-yyyyTHH:mm:ss",
universalSortableDateTime: "dd-MM-yyyy HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "dd MMMM",
yearMonth: "MMMM, yyyy"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Discussions located at
* http://groups.google.com/group/date-js
*
* Please mark the subject with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^oca(k)?/i,
feb: /^ÅŸub(at)?/i,
mar: /^mar(t)?/i,
apr: /^nis(an)?/i,
may: /^may(ıs)?/i,
jun: /^haz(iran)?/i,
jul: /^tem(muz)?/i,
aug: /^aÄŸu(stos)?/i,
sep: /^eyl(ül)?/i,
oct: /^eki(m)?/i,
nov: /^kas(ım)?/i,
dec: /^ara(lık)?/i,
sun: /^pa(z(ar)?)?/i,
mon: /^pa(z(artesi)?)?/i,
tue: /^sa(l(ı)?)?/i,
wed: /^ça(r(şamba)?)?/i,
thu: /^pe(r(ÅŸ(e(mbe)?)?)?)?/i,
fri: /^cu(m(a)?)?/i,
sat: /^cu(m(artesi)?)?/i,
future: /^ertesi|birdahaki|sonraki|önümüzdeki/i,
past: /^evvelsi|önceki|geçen?/i,
add: /^(\+|sonra|dan)/i,
subtract: /^(\-|önce)/i,
yesterday: /^dün/i,
today: /^bu(gün)?/i,
tomorrow: /^yarın/i,
now: /^ÅŸi(mdi)?/i,
millisecond: /^ms|mili(saniye)?/i,
second: /^san(iye)?/i,
minute: /^dak(ika)?s?/i,
hour: /^s(aa)?t?/i,
week: /^h(af)?ta/i,
month: /^a(y)?/i,
day: /^g(ün)?/i,
year: /^y(ıl)?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt)/i,
ordinalSuffix: /^\s*(inci|ıncı)/i,
timeContext: /^\s*(\:|a|p)/i
},
abbreviatedTimeZoneStandard: { GMT: "+0200", EST: "-0400", CST: "-0500", MST: "-0600", PST: "-0700" },
abbreviatedTimeZoneDST: { GMT: "+0200", EDT: "-0500", CDT: "-0600", MDT: "-0700", PDT: "-0800" }
};
/********************
** Future Strings **
********************
*
* The following list of strings are not currently being used, but
* may be incorporated later. We would appreciate any help translating
* the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Discussions located at
* http://groups.google.com/group/date-js
*
* Please mark the subject with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* English Name Translated
* ------------------ -----------------
* date tarih
* time zaman
* calendar takvim
* show göster
* hourly saatlik
* daily günlük
* weekly haftalık
* bi-weekly iki haftada bir
* monthly aylık
* bi-monthly iki ayda bir
* quarter çeyrek
* quarterly her çeyrekte
* yearly yıllık
* annual yıldönümü
* annually her yıl
* annum yılda
* again tekrar
* between arasında
* after sonra
* from now bundan sonra
* repeat tekrar
* times kere
* per başına
*/
Horde_Core-2.11.1/js/date/uk-UA.js 0000664 0001750 0001750 00000015520 12242643315 014527 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "uk-UA",
englishName: "Ukrainian (Ukraine)",
nativeName: "україньÑка (Україна)",
/* Day Name Strings */
dayNames: ["неділÑ", "понеділок", "вівторок", "Ñереда", "четвер", "п'ÑтницÑ", "Ñубота"],
abbreviatedDayNames: ["Ðд", "Пн", "Ð’Ñ‚", "Ср", "Чт", "Пт", "Сб"],
shortestDayNames: ["Ðд", "Пн", "Ð’Ñ‚", "Ср", "Чт", "Пт", "Сб"],
firstLetterDayNames: ["Ð", "П", "Ð’", "С", "Ч", "П", "С"],
/* Month Name Strings */
monthNames: ["Січень", "Лютий", "Березень", "Квітень", "Травень", "Червень", "Липень", "Серпень", "ВереÑень", "Жовтень", "ЛиÑтопад", "Грудень"],
abbreviatedMonthNames: ["Січ", "Лют", "Бер", "Кві", "Тра", "Чер", "Лип", "Сер", "Вер", "Жов", "ЛиÑ", "Гру"],
/* AM/PM Designators */
amDesignator: "AM",
pmDesignator: "PM",
firstDayOfWeek: 1,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "dmy",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "dd.MM.yyyy",
longDate: "d MMMM yyyy р.",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "d MMMM yyyy р. H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "d MMMM",
yearMonth: "MMMM yyyy р."
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^Ñіч(ень)?/i,
feb: /^лют(ий)?/i,
mar: /^бер(езень)?/i,
apr: /^кві(тень)?/i,
may: /^тра(вень)?/i,
jun: /^чер(вень)?/i,
jul: /^лип(ень)?/i,
aug: /^Ñер(пень)?/i,
sep: /^вер(еÑень)?/i,
oct: /^жов(тень)?/i,
nov: /^лиÑ(топад)?/i,
dec: /^гру(день)?/i,
sun: /^неділÑ/i,
mon: /^понеділок/i,
tue: /^вівторок/i,
wed: /^Ñереда/i,
thu: /^четвер/i,
fri: /^п'ÑтницÑ/i,
sat: /^Ñубота/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/zh-CN.js 0000664 0001750 0001750 00000015106 12242643315 014524 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "zh-CN",
englishName: "Chinese (People's Republic of China)",
nativeName: "ä¸æ–‡(ä¸åŽäººæ°‘共和国)",
/* Day Name Strings */
dayNames: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期å…"],
abbreviatedDayNames: ["æ—¥", "一", "二", "三", "å››", "五", "å…"],
shortestDayNames: ["æ—¥", "一", "二", "三", "å››", "五", "å…"],
firstLetterDayNames: ["æ—¥", "一", "二", "三", "å››", "五", "å…"],
/* Month Name Strings */
monthNames: ["一月", "二月", "三月", "四月", "五月", "å…月", "七月", "八月", "ä¹æœˆ", "å月", "å一月", "å二月"],
abbreviatedMonthNames: ["一月", "二月", "三月", "四月", "五月", "å…月", "七月", "八月", "ä¹æœˆ", "å月", "å一月", "å二月"],
/* AM/PM Designators */
amDesignator: "上åˆ",
pmDesignator: "下åˆ",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy/M/d",
longDate: "yyyy年M月d日",
shortTime: "H:mm",
longTime: "H:mm:ss",
fullDateTime: "yyyy年M月d日 H:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "M月d日",
yearMonth: "yyyy年M月"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^一月/i,
feb: /^二月/i,
mar: /^三月/i,
apr: /^四月/i,
may: /^五月/i,
jun: /^å…月/i,
jul: /^七月/i,
aug: /^八月/i,
sep: /^ä¹æœˆ/i,
oct: /^å月/i,
nov: /^å一月/i,
dec: /^å二月/i,
sun: /^星期日/i,
mon: /^星期一/i,
tue: /^星期二/i,
wed: /^星期三/i,
thu: /^星期四/i,
fri: /^星期五/i,
sat: /^星期å…/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/date/zh-TW.js 0000664 0001750 0001750 00000015131 12242643315 014554 0 ustar jan jan Date.CultureInfo = {
/* Culture Name */
name: "zh-TW",
englishName: "Chinese (Taiwan)",
nativeName: "ä¸æ–‡(å°ç£)",
/* Day Name Strings */
dayNames: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期å…"],
abbreviatedDayNames: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期å…"],
shortestDayNames: ["æ—¥", "一", "二", "三", "å››", "五", "å…"],
firstLetterDayNames: ["æ—¥", "一", "二", "三", "å››", "五", "å…"],
/* Month Name Strings */
monthNames: ["一月", "二月", "三月", "四月", "五月", "å…月", "七月", "八月", "ä¹æœˆ", "å月", "å一月", "å二月"],
abbreviatedMonthNames: ["一月", "二月", "三月", "四月", "五月", "å…月", "七月", "八月", "ä¹æœˆ", "å月", "å一月", "å二月"],
/* AM/PM Designators */
amDesignator: "上åˆ",
pmDesignator: "下åˆ",
firstDayOfWeek: 0,
twoDigitYearMax: 2029,
/**
* The dateElementOrder is based on the order of the
* format specifiers in the formatPatterns.DatePattern.
*
* Example:
*
* The correct dateElementOrder is required by the parser to
* determine the expected order of the date elements in the
* string being parsed.
*/
dateElementOrder: "ymd",
/* Standard date and time format patterns */
formatPatterns: {
shortDate: "yyyy/M/d",
longDate: "yyyy年M月d日",
shortTime: "tt hh:mm",
longTime: "tt hh:mm:ss",
fullDateTime: "yyyy年M月d日 tt hh:mm:ss",
sortableDateTime: "yyyy-MM-ddTHH:mm:ss",
universalSortableDateTime: "yyyy-MM-dd HH:mm:ssZ",
rfc1123: "ddd, dd MMM yyyy HH:mm:ss GMT",
monthDay: "M月d日",
yearMonth: "yyyy年M月"
},
/**
* NOTE: If a string format is not parsing correctly, but
* you would expect it parse, the problem likely lies below.
*
* The following regex patterns control most of the string matching
* within the parser.
*
* The Month name and Day name patterns were automatically generated
* and in general should be (mostly) correct.
*
* Beyond the month and day name patterns are natural language strings.
* Example: "next", "today", "months"
*
* These natural language string may NOT be correct for this culture.
* If they are not correct, please translate and edit this file
* providing the correct regular expression pattern.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)
*
* We will add the modified patterns to the master source files.
*
* As well, please review the list of "Future Strings" section below.
*/
regexPatterns: {
jan: /^一月/i,
feb: /^二月/i,
mar: /^三月/i,
apr: /^四月/i,
may: /^五月/i,
jun: /^å…月/i,
jul: /^七月/i,
aug: /^八月/i,
sep: /^ä¹æœˆ/i,
oct: /^å月/i,
nov: /^å一月/i,
dec: /^å二月/i,
sun: /^星期日/i,
mon: /^星期一/i,
tue: /^星期二/i,
wed: /^星期三/i,
thu: /^星期四/i,
fri: /^星期五/i,
sat: /^星期å…/i,
future: /^next/i,
past: /^last|past|prev(ious)?/i,
add: /^(\+|aft(er)?|from|hence)/i,
subtract: /^(\-|bef(ore)?|ago)/i,
yesterday: /^yes(terday)?/i,
today: /^t(od(ay)?)?/i,
tomorrow: /^tom(orrow)?/i,
now: /^n(ow)?/i,
millisecond: /^ms|milli(second)?s?/i,
second: /^sec(ond)?s?/i,
minute: /^mn|min(ute)?s?/i,
hour: /^h(our)?s?/i,
week: /^w(eek)?s?/i,
month: /^m(onth)?s?/i,
day: /^d(ay)?s?/i,
year: /^y(ear)?s?/i,
shortMeridian: /^(a|p)/i,
longMeridian: /^(a\.?m?\.?|p\.?m?\.?)/i,
timezone: /^((e(s|d)t|c(s|d)t|m(s|d)t|p(s|d)t)|((gmt)?\s*(\+|\-)\s*\d\d\d\d?)|gmt|utc)/i,
ordinalSuffix: /^\s*(st|nd|rd|th)/i,
timeContext: /^\s*(\:|a(?!u|p)|p)/i
},
timezones: [{name:"UTC", offset:"-000"}, {name:"GMT", offset:"-000"}, {name:"EST", offset:"-0500"}, {name:"EDT", offset:"-0400"}, {name:"CST", offset:"-0600"}, {name:"CDT", offset:"-0500"}, {name:"MST", offset:"-0700"}, {name:"MDT", offset:"-0600"}, {name:"PST", offset:"-0800"}, {name:"PDT", offset:"-0700"}]
};
/********************
** Future Strings **
********************
*
* The following list of strings may not be currently being used, but
* may be incorporated into the Datejs library later.
*
* We would appreciate any help translating the strings below.
*
* If you modify this file, please post your revised CultureInfo file
* to the Datejs Forum located at http://www.datejs.com/forums/.
*
* Please mark the subject of the post with [CultureInfo]. Example:
* Subject: [CultureInfo] Translated "da-DK" Danish(Denmark)b
*
* English Name Translated
* ------------------ -----------------
* about about
* ago ago
* date date
* time time
* calendar calendar
* show show
* hourly hourly
* daily daily
* weekly weekly
* bi-weekly bi-weekly
* fortnight fortnight
* monthly monthly
* bi-monthly bi-monthly
* quarter quarter
* quarterly quarterly
* yearly yearly
* annual annual
* annually annually
* annum annum
* again again
* between between
* after after
* from now from now
* repeat repeat
* times times
* per per
* min (abbrev minute) min
* morning morning
* noon noon
* night night
* midnight midnight
* mid-night mid-night
* evening evening
* final final
* future future
* spring spring
* summer summer
* fall fall
* winter winter
* end of end of
* end end
* long long
* short short
*/
Horde_Core-2.11.1/js/excanvas/excanvas.js 0000775 0001750 0001750 00000064645 12242643315 016327 0 ustar jan jan // Copyright 2006 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Known Issues:
//
// * Patterns are not implemented.
// * Radial gradient are not implemented. The VML version of these look very
// different from the canvas one.
// * Clipping paths are not implemented.
// * Coordsize. The width and height attribute have higher priority than the
// width and height style values which isn't correct.
// * Painting mode isn't implemented.
// * Canvas width/height should is using content-box by default. IE in
// Quirks mode will draw the canvas using border-box. Either change your
// doctype to HTML5
// (http://www.whatwg.org/specs/web-apps/current-work/#the-doctype)
// or use Box Sizing Behavior from WebFX
// (http://webfx.eae.net/dhtml/boxsizing/boxsizing.html)
// * Non uniform scaling does not correctly scale strokes.
// * Optimize. There is always room for speed improvements.
// Only add this code if we do not already have a canvas implementation
if (!document.createElement('canvas').getContext) {
(function() {
// alias some functions to make (compiled) code shorter
var m = Math;
var mr = m.round;
var ms = m.sin;
var mc = m.cos;
var abs = m.abs;
var sqrt = m.sqrt;
// this is used for sub pixel precision
var Z = 10;
var Z2 = Z / 2;
/**
* This funtion is assigned to the