ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱨᱮ ᱚᱞ ᱟᱠᱟᱱ ᱡᱟᱦᱟᱱ ᱞᱮᱠᱟᱱ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱜᱮ ᱚᱠᱛᱚ ᱥᱮ ᱢᱟᱹᱦᱤᱛ ᱥᱟᱶ ᱠᱟᱹᱢᱤ ᱮᱫᱟᱭ ᱾ ᱮᱛᱚᱦᱚᱵ ᱨᱮ, ᱱᱚᱣᱟ ᱫᱚ ᱵᱤᱞᱴ-ᱤᱱ ᱢᱟᱹᱦᱤᱛ ᱮᱯᱤᱟᱭᱤ ᱛᱮ ᱥᱤᱢᱟᱹ ᱛᱟᱦᱮᱸ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ API ᱨᱮ ᱢᱩᱲᱩᱫ ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜᱼᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱣᱟ ᱪᱮᱫ ᱪᱤᱠᱟᱹ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱚᱱᱟ ᱫᱚ ᱟᱹᱰᱤ ᱥᱤᱢᱟᱹ ᱜᱮᱭᱟ᱾ Moment.js ᱞᱮᱠᱟᱱ ᱛᱮᱥᱟᱨ ᱯᱟᱨᱴᱤ ᱞᱟᱭᱵᱨᱮᱨᱤ, ᱟᱨ ᱛᱟᱭᱚᱢ ᱵᱤᱞᱴ-ᱤᱱ API ᱡᱮᱞᱮᱠᱟ Intl APIs ᱟᱨ ᱱᱟᱶᱟ Temporal API, ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱠᱚ ᱥᱟᱶ ᱠᱟᱹᱢᱤ ᱞᱟᱹᱜᱤᱫ ᱟᱹᱰᱤ ᱵᱟᱹᱲᱛᱤ ᱞᱮᱵᱽᱲᱮᱡ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜ-ᱟ᱾ Moment.js ᱨᱮᱭᱟᱜ ᱵᱮᱨᱮᱫ ᱟᱨ ᱧᱩᱨᱦᱟᱹᱜ Moment.js ᱫᱚ ᱢᱤᱫ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱨᱮ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱠᱚ ᱥᱟᱶ ᱠᱟᱹᱢᱤ ᱞᱟᱹᱜᱤᱫ ᱫᱟᱲᱮᱭᱟᱱ ᱵᱮᱵᱷᱟᱨ ᱠᱚ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱱᱚᱣᱟ ᱨᱮ ᱢᱩᱲᱩᱫ ᱢᱟᱹᱦᱤᱛ API ᱠᱷᱚᱱ ᱟᱫ ᱟᱠᱟᱱ ᱜᱩᱱ ᱠᱚ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜᱼᱟ, ᱡᱮᱞᱠᱟ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱦᱮᱨᱟ ᱯᱦᱮᱨ, ᱟᱨ ᱟᱭᱢᱟ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱚᱯᱟᱨᱮᱥᱚᱱ ᱠᱚ ᱟᱞᱜᱟ ᱜᱮᱭᱟ᱾ ᱢᱚᱢᱮᱱᱴ ᱨᱮ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱯᱷᱚᱨᱢᱟᱴᱤᱝ ᱞᱟᱹᱜᱤᱫ ᱯᱷᱟᱱᱠᱥᱚᱱ ᱠᱚ ᱦᱚᱸ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱟᱭᱢᱟ ᱞᱮᱠᱟᱱ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱮ ᱯᱟᱥᱱᱟᱣ ᱞᱮᱠᱟᱛᱮ ᱵᱮᱵᱷᱟᱨᱚᱜ ᱠᱟᱱ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱦᱩᱭᱮᱱᱟ ᱾ ᱢᱮᱱᱠᱷᱟᱱ, ᱢᱚᱢᱮᱱᱴ ᱨᱮᱦᱚᱸ ᱟᱡᱟᱜ ᱦᱟᱹᱴᱤᱧ ᱮᱴᱠᱮᱴᱚᱬᱮ ᱛᱟᱦᱮᱸ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱢᱤᱫ ᱢᱟᱨᱟᱝ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱠᱟᱱᱟ, ᱟᱨ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱮᱭᱟᱜ ᱵᱟᱱᱰᱮᱞ ᱥᱟᱭᱤᱡᱽ ᱨᱮ ᱞᱟᱹᱠᱛᱤᱭᱟᱱ ᱞᱮᱠᱟᱛᱮ ᱥᱮᱞᱮᱫ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱪᱮᱫᱟᱜ ᱥᱮ ᱞᱟᱭᱵᱽᱨᱤ ᱫᱚ ᱫᱟᱨᱮ ᱦᱤᱥᱟᱹᱵ ᱵᱟᱭ ᱥᱟᱯᱚᱨᱴ ᱮᱫᱟ (ᱱᱟᱦᱟᱜ ᱵᱟᱱᱰᱞᱟᱨ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱯᱷᱤᱪᱟᱨ ᱡᱟᱦᱟᱸ ᱫᱚ ᱞᱟᱭᱵᱽᱨᱤ ᱨᱮ ᱵᱟᱝ ᱵᱮᱵᱚᱦᱟᱨ ᱟᱠᱟᱱ ᱦᱟᱹᱴᱤᱧ ᱠᱚ ᱚᱪᱚᱜ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ), ᱟᱢ ᱫᱚ ᱚᱱᱟ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱵᱟᱨ ᱠᱟᱹᱢᱤ ᱵᱮᱵᱚᱦᱟᱨ ᱠᱟᱛᱮ ᱦᱚᱸ ᱜᱚᱴᱟ Moment ᱞᱟᱭᱵᱽᱨᱤ ᱫᱚ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜ-ᱟ᱾ ᱢᱚᱢᱮᱱᱴ ᱥᱟᱶ ᱢᱤᱫ ᱮᱴᱟᱜ ᱮᱴᱠᱮᱴᱚᱬᱮ ᱫᱚ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱱᱚᱣᱟ ᱛᱮ ᱵᱮᱱᱟᱣ ᱟᱠᱟᱱ ᱡᱤᱱᱤᱥ ᱠᱚ ᱫᱚ ᱵᱚᱫᱚᱞᱚᱜ ᱜᱮᱭᱟ ᱾ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱨᱮ ᱠᱤᱪᱷᱩ ᱯᱷᱟᱱᱠᱥᱚᱱ ᱠᱚ ᱦᱚᱦᱚ ᱞᱮᱠᱷᱟᱱ ᱥᱟᱭᱤᱰ ᱤᱯᱷᱮᱠᱴ ᱛᱟᱦᱮᱱᱟ ᱟᱨ ᱚᱱᱟ ᱡᱤᱱᱤᱥ ᱨᱮᱭᱟᱜ ᱜᱚᱱᱚᱝ ᱵᱚᱫᱚᱞᱚᱜᱼᱟ ᱾ ᱱᱚᱣᱟ ᱛᱮ ᱵᱤᱱ ᱟᱥᱟ ᱵᱮᱵᱷᱟᱨ ᱥᱮ ᱛᱤᱡᱩ ᱠᱚ ᱦᱮᱡ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱾ ᱒᱐᱒᱐ ᱨᱮ, ᱢᱚᱢᱮᱱᱴ ᱨᱮᱱ ᱥᱟᱢᱲᱟᱣ ᱠᱚ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱥᱟᱢᱲᱟᱣ ᱢᱚᱰ ᱨᱮ ᱫᱚᱦᱚ ᱨᱮᱭᱟᱜ ᱠᱚ ᱜᱚᱴᱟ ᱠᱮᱫᱟ᱾ ᱪᱮᱫ ᱦᱚᱸ ᱱᱟᱶᱟ ᱯᱷᱤᱪᱟᱨ ᱩᱛᱱᱟᱹᱣ ᱵᱟᱝ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ, ᱟᱨ ᱥᱟᱢᱲᱟᱣ ᱠᱚ ᱱᱟᱶᱟ ᱯᱨᱚᱡᱮᱠᱴ ᱠᱚ ᱞᱟᱹᱜᱤᱫ ᱱᱚᱣᱟ ᱵᱮᱵᱷᱟᱨ ᱵᱤᱨᱩᱫᱷ ᱨᱮ ᱠᱚ ᱢᱮᱛᱟᱜ ᱠᱚᱣᱟ᱾ ᱮᱴᱟᱜ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱰᱮᱴ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱠᱚ ᱢᱮᱱᱟᱜ-ᱟ, ᱡᱮᱞᱮᱠᱟ ᱰᱮᱴ-fns, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱟᱜᱟᱢ ᱨᱮ ᱢᱤᱫ ᱱᱟᱶᱟ ᱠᱷᱮᱞᱚᱱ ᱢᱮᱱᱟᱜ-ᱟ, ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱨᱮ ᱥᱚᱡᱷᱮ ᱵᱮᱱᱟᱣ ᱟᱠᱟᱱ API: Temporal. ᱱᱚᱶᱟ ᱫᱚ ᱱᱟᱶᱟ ᱢᱟᱱᱚᱛ ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱟᱥᱚᱞ ᱢᱟᱹᱦᱤᱛ API ᱨᱮᱭᱟᱜ ᱵᱷᱩᱜᱟᱹᱜ ᱠᱚ ᱯᱮᱨᱮᱡ ᱥᱟᱶ ᱥᱟᱶᱛᱮ ᱢᱚᱢᱮᱱᱴ ᱟᱨ ᱮᱴᱟᱜ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱨᱮ ᱧᱟᱢᱚᱜ ᱠᱟᱱ ᱠᱤᱪᱷᱩ ᱥᱤᱢᱟᱹ ᱠᱚ ᱥᱚᱞᱦᱮᱭᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱪᱮᱫ ᱠᱟᱱᱟ? ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱱᱟᱶᱟ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ API ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ECMAScript ᱥᱴᱮᱱᱰᱟᱨ ᱨᱮ ᱥᱮᱞᱮᱫᱚᱜ ᱠᱟᱱᱟ, ᱚᱠᱟ ᱫᱚ ᱱᱟᱦᱟᱜ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱩᱯᱨᱩᱢ ᱮᱢᱚᱜ ᱠᱟᱱᱟ᱾ 20266 ᱥᱟᱞᱟᱜ ᱢᱟᱨᱪ ᱦᱟᱹᱵᱤᱡ, ᱱᱚᱶᱟ ᱫᱚ TC39 ᱠᱟᱹᱢᱤ (JavaScript ᱯᱟᱹᱨᱥᱤ ᱨᱮ ᱯᱨᱚᱥᱛᱟᱣ ᱟᱨ ᱡᱚᱲᱟᱣ ᱠᱚ ᱧᱮᱞ ᱠᱟᱱ ᱠᱚᱢᱴᱤ) ᱨᱮᱭᱟᱜ 4 ᱫᱷᱟᱯ ᱨᱮ ᱥᱮᱴᱮᱨ ᱟᱠᱟᱱᱟ, ᱟᱨ ECMAScript ᱥᱯᱮᱥᱤᱠᱮᱥᱚᱱ ᱨᱮᱭᱟᱜ ᱫᱚᱥᱟᱨ ᱵᱷᱟᱨᱥᱚᱱ ᱨᱮ ᱥᱮᱞᱮᱫᱚᱜ-ᱟ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱞᱟᱦᱟ ᱠᱷᱚᱱ ᱜᱮ ᱟᱭᱢᱟ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱠᱚᱨᱮ ᱞᱟᱹᱜᱩ ᱟᱠᱟᱱᱟ: ᱠᱨᱚᱢ ᱑᱔᱔+ ᱟᱨ ᱯᱷᱟᱭᱟᱨᱯᱷᱚᱠᱥ ᱑᱓᱙+, ᱥᱟᱯᱟᱨᱤ ᱞᱚᱜᱚᱱ ᱜᱮ ᱯᱟᱧᱡᱟᱭ ᱨᱮᱭᱟᱜ ᱟᱥᱟ ᱢᱮᱱᱟᱜᱼᱟ᱾ ᱵᱟᱝ ᱜᱚᱲᱚ ᱧᱟᱢᱚᱜ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱟᱨ ᱱᱳᱰ.ᱡᱮᱥ ᱞᱟᱹᱜᱤᱫ ᱢᱤᱫ ᱯᱚᱞᱤᱯᱷᱤᱞ ᱦᱚᱸ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ API ᱫᱚ ᱱᱚᱝᱠᱟᱱ ᱡᱤᱱᱤᱥ ᱛᱮᱭᱟᱨ ᱮᱫᱟᱭ ᱚᱠᱟ ᱫᱚ, ᱥᱟᱫᱷᱟᱨᱚᱱ ᱞᱮᱠᱟᱛᱮ, ᱚᱠᱛᱚ ᱨᱮ ᱢᱩᱦᱩᱫ ᱠᱚ ᱩᱫᱩᱜᱟ᱾ ᱱᱚᱶᱟ ᱠᱚ ᱫᱚ ᱢᱤᱫ ᱴᱮᱱ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱨᱮ ᱯᱩᱨᱟᱹ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱟᱢᱯ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, ᱟᱨ ᱵᱟᱝ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱵᱟᱰᱟᱭ ᱵᱟᱝ ᱛᱟᱦᱮᱸ ᱠᱟᱛᱮ “ᱵᱷᱤᱛ ᱜᱷᱚᱰᱤ” ᱚᱠᱛᱚ ᱨᱮᱭᱟᱜ ᱡᱮᱱᱮᱨᱤᱠ ᱫᱟᱹᱭᱠᱟᱹ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱨᱮᱭᱟᱜ ᱠᱤᱪᱷᱩ ᱢᱩᱬ ᱜᱩᱱ ᱠᱚ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜᱼᱟ:
ᱢᱟᱹᱦᱤᱛ ᱥᱟᱶ ᱥᱮ ᱵᱮᱜᱚᱨ ᱚᱠᱛᱚ ᱾ ᱢᱤᱫ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱨᱮ ᱢᱤᱫ ᱚᱠᱛᱚ ᱩᱫᱩᱜ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨ ᱵᱟᱝ ᱢᱟᱹᱦᱤᱛ ᱵᱟᱯᱟᱰᱟᱭ ᱛᱮ ᱢᱤᱫ ᱚᱠᱛᱚ ᱾ ᱢᱤᱫ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱢᱟᱹᱦᱤᱛ, ᱵᱤᱱᱟᱹ ᱚᱠᱛᱚ ᱛᱮ, ᱦᱚᱸ ᱩᱫᱩᱜ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱜᱚᱲᱚ ᱮᱢᱚᱜ ᱠᱟᱱᱟ᱾ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱫᱚ ᱯᱩᱨᱟᱹ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱪᱮᱛᱟᱱ ᱜᱮᱭᱟ ᱟᱨ ᱮᱴᱟᱜ ᱮᱴᱟᱜ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱵᱚᱫᱚᱞ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱢᱚᱢᱮᱱᱴ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱦᱚᱸ ᱥᱟᱯᱚᱨᱴ ᱮᱫᱟᱭ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱣᱟ ᱞᱟᱹᱜᱤᱫ ᱵᱟᱹᱲᱛᱤ ᱢᱚᱢᱮᱱᱴ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ ᱾ ᱵᱟᱝ ᱵᱚᱫᱚᱞᱚᱜ ᱫᱟᱲᱮ ᱾ ᱢᱤᱫ ᱫᱷᱟᱣ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱛᱮᱭᱟᱨ ᱞᱮᱱᱠᱷᱟᱱ, ᱚᱱᱟ ᱵᱟᱝ ᱵᱚᱫᱚᱞ ᱜᱟᱱᱚᱜᱼᱟ ᱾ ᱚᱠᱛᱚ ᱮᱞᱠᱷᱟ ᱥᱮ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱚᱲ ᱫᱚ ᱞᱟᱛᱟᱨ ᱨᱮ ᱢᱮᱱᱟᱜ ᱡᱤᱱᱤᱥ ᱵᱟᱭ ᱥᱚᱫᱚᱨᱟ᱾ ᱱᱚᱣᱟ ᱵᱚᱫᱚᱞ ᱛᱮ, ᱩᱱᱠᱩ ᱢᱤᱫ ᱱᱟᱶᱟ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱠᱚ ᱥᱤᱨᱡᱟᱹᱣ ᱮᱫᱟ᱾ ᱑-ᱟᱫᱷᱟᱨᱚᱱ ᱤᱱᱰᱮᱠᱥᱤᱝ᱾ ᱢᱟᱹᱦᱤᱛ ᱮᱯᱤᱟᱭᱤ ᱥᱟᱶ ᱵᱟᱜᱽ ᱨᱮᱭᱟᱜ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱥᱚᱨᱥ (ᱢᱚᱢᱮᱱᱴ ᱥᱟᱶ ᱥᱟᱶᱛᱮ) ᱫᱚ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱪᱟᱸᱫᱚ ᱠᱚ ᱫᱚ ᱥᱩᱱ-ᱤᱱᱰᱮᱠᱥ ᱜᱮᱭᱟ᱾ ᱱᱚᱣᱟ ᱢᱮᱱᱮᱫ ᱫᱚ ᱡᱟᱱᱩᱣᱟᱨᱤ ᱫᱚ ᱐ ᱪᱟᱸᱫᱚ ᱠᱟᱱᱟ, ᱑ ᱪᱟᱸᱫᱚ ᱵᱚᱫᱚᱞ ᱠᱟᱛᱮ ᱡᱮᱞᱠᱟ ᱟᱵᱚ ᱥᱟᱹᱨᱤ ᱡᱤᱭᱚᱱ ᱨᱮ ᱵᱚᱱ ᱵᱩᱡᱷᱟᱹᱣᱟ᱾ ᱑-ᱟᱫᱷᱟᱨᱚᱱ ᱤᱱᱰᱮᱠᱥᱤᱝ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ ᱚᱠᱛᱚ ᱥᱟᱹᱛ ᱥᱟᱹᱛ ᱟᱠᱟᱱᱟ - ᱡᱟᱱᱩᱣᱟᱨᱤ ᱫᱚ ᱑ ᱪᱟᱸᱫᱚ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮ ᱵᱮᱱᱟᱣ ᱟᱠᱟᱱᱟ ᱾ ᱪᱮᱫᱟᱜ ᱥᱮ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮ ᱢᱤᱫ API ᱠᱟᱱᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱟᱢᱟᱜ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱮᱭᱟᱜ ᱵᱟᱱᱰᱮᱞ ᱥᱟᱭᱤᱡᱽ ᱨᱮ ᱪᱮᱫ ᱦᱚᱸ ᱵᱟᱭ ᱥᱮᱞᱮᱫᱟ᱾
ᱱᱚᱶᱟ ᱦᱚᱸ ᱵᱟᱰᱟᱭ ᱞᱟᱹᱠᱛᱤᱭᱟᱱᱟ ᱡᱮ ᱢᱟᱹᱦᱤᱛ API ᱫᱚ ᱵᱟᱝ ᱪᱟᱞᱟᱜ ᱠᱟᱱᱟ ᱾ ᱡᱚᱠᱷᱚᱱ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱱᱚᱣᱟ API ᱮ ᱯᱷᱮᱨᱟᱣ ᱮᱫᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱵᱟᱝ ᱚᱪᱚᱜ ᱟᱨ ᱵᱟᱝ ᱵᱟᱝ ᱵᱮᱵᱷᱟᱨᱚᱜ ᱠᱟᱱᱟ ᱾ ᱡᱩᱫᱤ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱠᱚ ᱟᱪᱠᱟ ᱰᱮᱴ ᱮᱯᱤᱟᱭ ᱠᱚ ᱚᱪᱚᱜ ᱠᱷᱟᱱ ᱟᱭᱢᱟ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱟᱹᱯᱩᱫᱚᱜᱼᱟ ᱾ ᱢᱮᱱᱠᱷᱟᱱ, ᱱᱚᱣᱟ ᱦᱚᱸ ᱫᱤᱥᱟᱹ ᱫᱚᱦᱚᱭ ᱢᱮ ᱡᱮ ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱱᱤᱛᱚᱜ ᱧᱮᱞ ᱡᱚᱛᱚᱱ ᱢᱚᱰ ᱨᱮ ᱢᱤᱫ ᱞᱮᱜᱮᱥᱤ ᱯᱨᱚᱡᱮᱠᱴ ᱢᱮᱱᱛᱮ ᱵᱩᱡᱷᱟᱹᱣᱚᱜ ᱠᱟᱱᱟ ᱾ ᱢᱩᱪᱟᱹᱫ ᱚᱱᱚᱞ ᱨᱮ, ᱟᱵᱚ ᱫᱚ ᱱᱟᱶᱟ ᱴᱮᱢᱯᱚᱨᱟᱞ API ᱨᱮ Moment-based code ᱢᱟᱭᱜᱽᱨᱮᱴ ᱞᱟᱹᱜᱤᱫ ᱠᱤᱪᱷᱩ “recipes” ᱵᱚᱱ ᱧᱮᱞᱟ᱾ ᱫᱮᱞᱟ ᱨᱤᱯᱷᱮᱠᱴᱚᱨᱤᱝ ᱵᱚᱱ ᱮᱦᱚᱵᱟ! ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱦᱮᱨᱟ ᱯᱷᱮᱨᱟ ᱞᱟᱦᱟᱨᱮ, ᱟᱵᱚ ᱚᱱᱟ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱦᱩᱭᱩᱜ ᱛᱟᱵᱚᱱᱟ᱾ ᱱᱤᱛᱚᱜ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱩᱫᱩᱜ ᱢᱤᱫ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ, ᱢᱚᱢᱮᱱᱴ ᱯᱷᱟᱱᱥᱚᱱ ᱵᱮᱵᱷᱟᱨ ᱢᱮ ᱾ const ᱱᱤᱛᱚᱜ = ᱜᱷᱟᱹᱲᱤ (); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱑᱘ᱴᱤ᱒᱑:᱒᱖:᱒᱙-᱐᱕:᱐᱐>
ᱱᱚᱣᱟ ᱡᱤᱱᱤᱥ ᱫᱚ ᱞᱟᱹᱠᱛᱤ ᱞᱮᱠᱟ ᱯᱷᱚᱨᱢᱮᱴ ᱥᱮ ᱦᱮᱨᱟ ᱯᱷᱮᱨᱟ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾
// UTC ᱨᱮ ᱵᱚᱫᱚᱞ ᱢᱮ //ᱪᱮᱦᱟᱣᱱᱟ: ᱱᱚᱣᱟ ᱫᱚ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱢᱭᱩᱴᱮᱴ ᱟᱨ ᱱᱚᱣᱟ ᱭᱩᱴᱤᱥᱤ ᱢᱚᱰ ᱨᱮ ᱫᱚᱦᱚᱭᱟᱭ! ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱭᱩᱴᱤᱥᱤ()); // ᱢᱩᱦᱩᱛ<᱒᱐᱒᱖-᱐᱒-᱑᱙ᱴᱤ᱐᱒:᱒᱖:᱒᱙ᱡᱮᱰ>
// ᱢᱤᱫ ᱯᱷᱚᱨᱢᱟᱴ ᱥᱴᱨᱤᱝ ᱪᱷᱟᱯᱟ ᱢᱮ - ᱱᱚᱴ ᱢᱮ ᱡᱮ ᱱᱚᱣᱟ ᱫᱚ ᱱᱤᱛᱚᱜ ᱭᱩᱴᱤᱥᱤ ᱚᱠᱛᱚ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟᱭ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱯᱷᱚᱨᱢᱮᱴ('ᱮᱢᱮᱢ/ᱰᱤᱰᱤ/ᱣᱟᱭᱣᱟᱭ ᱦᱦ:ᱢᱮᱢ:ᱮᱥᱮᱥ ᱮ')); // ᱐᱒/᱑᱙/᱒᱐᱒᱖ ᱐᱒:᱒᱗:᱐᱗ ᱥᱮᱛᱟᱜ
ᱢᱚᱢᱮᱱᱴ ᱵᱟᱵᱚᱛ ᱩᱭᱦᱟᱹᱨ ᱞᱟᱹᱠᱛᱤᱭᱟᱱ ᱠᱟᱛᱷᱟ ᱫᱚ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱨᱮ ᱥᱟᱨᱟ ᱜᱷᱟᱹᱲᱤᱡ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱵᱟᱵᱚᱛ ᱵᱟᱯᱟᱰᱟᱭ ᱛᱟᱦᱮᱱᱟ᱾ ᱡᱩᱫᱤ ᱟᱢ ᱫᱚ ᱥᱩᱢᱩᱝ ᱚᱠᱛᱚ ᱵᱟᱰᱟᱭ ᱥᱟᱶ ᱠᱟᱹᱢᱤ ᱞᱟᱹᱠᱛᱤᱭᱟᱢ ᱠᱟᱱᱟ, ᱱᱚᱶᱟ ᱫᱚ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱛᱮ ᱴᱷᱤᱠ ᱜᱮᱭᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱶᱟ ᱫᱚ ᱥᱤᱛᱩᱝ ᱚᱠᱛᱚ ᱥᱮ ᱞᱤᱯ ᱥᱮᱨᱢᱟ ᱞᱮᱠᱟᱱ ᱚᱠᱛᱚ ᱨᱮ ᱵᱟᱝ ᱵᱩᱡᱷᱟᱹᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, ᱚᱠᱟ ᱨᱮ ᱢᱟᱹᱦᱤᱛ ᱫᱚ ᱚᱠᱛᱚ ᱞᱮᱠᱷᱟ ᱨᱮ ᱮᱥᱮᱨ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱟᱹᱰᱤ ᱞᱟᱞᱠᱟᱣ ᱜᱮᱭᱟ ᱾ ᱟᱢ ᱢᱤᱫ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱵᱮᱱᱟᱣ ᱠᱟᱛᱮ ᱱᱤᱛᱚᱜ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ ᱨᱚᱠᱟ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱱᱚᱣᱟ ᱫᱚ “ᱮᱯᱚᱪ” (᱑ ᱡᱟᱱᱩᱣᱟᱨᱤ ᱑᱙᱗᱐ ᱨᱮ ᱛᱟᱞᱟ ᱧᱤᱫᱟᱹ ᱭᱩᱴᱤᱥᱤ) ᱠᱷᱚᱱ ᱚᱠᱛᱚ ᱛᱮ ᱩᱱᱩᱫᱩᱜ ᱚᱠᱛᱚ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱵᱤᱱᱫᱟᱹ ᱩᱫᱩᱜ ᱠᱟᱱᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱱᱮᱱᱚᱥᱮᱠᱮᱱᱰ ᱞᱮᱵᱮᱞ ᱥᱩᱦᱤ ᱥᱟᱶ ᱚᱠᱛᱚ ᱨᱮ ᱱᱚᱣᱟ ᱨᱚᱠᱟ ᱨᱮᱯᱷᱮᱨᱮᱱᱥ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ const ᱱᱤᱛᱚᱜ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ();
// ᱧᱮᱞ ᱢᱮ ᱵᱮᱨᱮᱫ ᱱᱮᱱᱚᱥᱮᱠᱮᱱᱰ ᱠᱷᱚᱱ ᱮᱯᱚᱠ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱮᱯᱚᱪᱱᱟᱱᱚᱥᱮᱠᱮᱱᱰᱥ); // ᱑᱗᱗᱑᱔᱖᱖᱓᱔᱒᱖᱑᱒᱐᱐᱐᱐᱐ᱮᱱ
// ᱭᱩᱴᱤᱥᱤ ᱞᱟᱹᱜᱤᱫ ᱨᱩᱯ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱒᱐᱒᱖-᱐᱒-᱑᱙ᱴᱤ᱐᱑:᱕᱕:᱒᱗.᱘᱔᱔ᱡᱮᱰ
// ᱢᱤᱫ ᱠᱷᱟᱥ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱨᱩᱯ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱩᱥᱴᱨᱤᱝ({ᱚᱠᱛᱚᱴᱚᱬᱮ: 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ'})); // ᱒᱐᱒᱖-᱐᱒-᱑᱘ᱴᱤ᱒᱐:᱕᱖:᱕᱗.᱙᱐᱕-᱐᱕:᱐᱐
ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ ᱤᱱᱥᱴᱟᱱᱴ ᱡᱤᱱᱤᱥ ᱠᱚ ᱦᱚᱸ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱢᱤᱫ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱞᱟᱹᱜᱤᱫ ᱥᱴᱮᱴᱤᱠ ᱯᱚᱛᱷᱤ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ ᱾
ᱠᱚᱱᱥᱴ ᱢᱟᱭᱤᱱᱥᱴᱟᱱᱴ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ᱾ ᱠᱷᱚᱱ ('᱒᱐᱒᱖-᱐᱒-᱑᱘ᱴᱤ᱒᱑:᱑᱐:᱐᱐-᱐᱕:᱐᱐');
// ᱞᱚᱠᱟᱞ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱨᱚᱠᱟ ᱯᱷᱚᱨᱢᱮᱴ ᱢᱮ ᱾ ᱱᱚᱴ ᱢᱮ ᱡᱮ ᱱᱚᱣᱟ ᱫᱚ ᱠᱷᱟᱹᱞᱤ ᱠᱚᱱᱴᱨᱚᱞ ᱮᱫᱟᱭ // ᱯᱷᱚᱨᱢᱟᱴᱤᱝ - ᱱᱚᱣᱟ ᱡᱤᱱᱤᱥ ᱵᱟᱭ ᱢᱭᱩᱴᱮᱴ ᱮᱫᱟ ᱡᱮᱞᱠᱟ moment.utc ᱠᱚᱨᱟᱣᱟ ᱾ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱤᱧᱟᱜ ᱛᱟᱞᱟ.ᱴᱩᱥᱴᱨᱤᱝ({ ᱚᱠᱛᱚᱴᱚᱴᱷᱟ: 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ'})); // ᱒᱐᱒᱖-᱐᱒-᱑᱘ᱴᱤ᱒᱑:᱑᱐:᱐᱐-᱐᱕:᱐᱐
ᱟᱢ ᱮᱴᱟᱜ ᱞᱮᱠᱟᱱ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱦᱚᱸᱢ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱚᱱᱟ ᱥᱟᱶᱛᱮᱺ
ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ ᱯᱞᱮᱱᱰᱮᱴ: ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱡᱟᱦᱟᱸ ᱨᱮ ᱚᱠᱛᱚ ᱵᱟᱯᱟᱰᱟᱭ ᱵᱟᱹᱱᱩᱜᱼᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ ᱯᱞᱮᱱᱴᱟᱭᱤᱢ: ᱢᱤᱫ ᱚᱠᱛᱚ ᱡᱟᱦᱟᱸ ᱨᱮ ᱢᱟᱹᱦᱤᱛ ᱵᱟᱯᱟᱰᱟᱭ ᱵᱟᱹᱱᱩᱜᱼᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱡᱚᱱᱰᱰᱮᱴᱴᱟᱭᱤᱢ: ᱢᱤᱫ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱾
ᱱᱚᱶᱟ ᱠᱚ ᱢᱤᱢᱤᱫ ᱨᱮ ᱢᱤᱫ ᱯᱷᱨᱚᱢ ᱯᱚᱛᱷᱤ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱟᱨ/ᱵᱟᱝᱠᱷᱟᱱ ᱚᱠᱛᱚ ᱩᱫᱩᱜ ᱠᱟᱛᱮ ᱢᱤᱫ ᱡᱤᱱᱤᱥ ᱥᱟᱶᱛᱮ ᱦᱚᱦᱚ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨᱵᱟᱝᱠᱷᱟᱱ ᱯᱟᱨᱥ ᱞᱟᱹᱜᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ᱾ // ᱥᱩᱢᱟᱹᱫᱽ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ const ᱛᱮᱦᱮᱧ = ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱯᱞᱮᱱᱰᱮᱴ.ᱠᱷᱚᱱ({ ᱥᱮᱨᱢᱟ: ᱒᱐᱒᱖, ᱪᱟᱸᱫᱚ: ᱒,// ᱱᱚᱴ ᱟᱞᱮ ᱒ ᱯᱷᱮᱵᱩᱭᱟᱨᱤ ᱞᱟᱹᱜᱤᱫ ᱞᱮ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟ ᱢᱟᱦᱟᱸ: ᱑᱘ }); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱛᱮᱦᱮᱧ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱒᱐᱒᱖-᱐᱒-᱑᱘
// ᱥᱩᱢᱟᱹᱫᱽ ᱢᱤᱫ ᱚᱠᱛᱚ const ᱢᱟᱧᱡᱟᱱ ᱚᱠᱛᱚ = ᱚᱠᱛᱚ .ᱥᱟᱫᱷᱟᱨᱚᱱ ᱚᱠᱛᱚ .ᱠᱷᱚᱱ({ ᱴᱟᱲᱟᱝ: ᱑᱒ }); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱧᱡᱟᱱ ᱚᱠᱛᱚ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱑᱒:᱐᱐:᱐᱐
// ᱟᱢᱮᱨᱤᱠᱟ ᱯᱩᱨᱩᱵ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ const dueAt = ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ᱡᱚᱱᱰᱰᱮᱴᱴᱟᱭᱤᱢ᱾ᱠᱷᱚᱱ({ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ: 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ', ᱥᱮᱨᱢᱟ: ᱒᱐᱒᱖, ᱪᱟᱸᱫᱚ: ᱓, ᱢᱟᱦᱟᱸ: ᱑, ᱴᱟᱲᱟᱝ: ᱑᱒, ᱢᱤᱱᱤᱴ: ᱐, ᱥᱮᱠᱮᱱᱰ: ᱐ }); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱰᱭᱩᱮᱴ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱒᱐᱒᱖-᱐᱓-᱐᱑ᱴᱤ᱑᱒:᱐᱐:᱐᱐-᱐᱕:᱐᱐[ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ]
ᱯᱟᱨᱥᱤᱝ ᱟᱞᱮ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱵᱟᱯᱟᱰᱟᱭ ᱨᱮᱭᱟᱜ ᱯᱨᱚᱜᱽᱨᱟᱢᱮᱴᱤᱠ ᱵᱮᱱᱟᱣ ᱞᱮ ᱠᱚᱵᱷᱟᱨ ᱟᱠᱟᱫᱟ᱾ ᱱᱤᱛ ᱫᱮᱞᱟ ᱯᱟᱨᱥᱤᱝ ᱞᱮ ᱧᱮᱞᱟ᱾ ᱯᱟᱨᱥᱤᱝ ᱫᱚ ᱢᱤᱫ ᱴᱚᱴᱷᱟ ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱨᱮ ᱵᱤᱞᱴ ᱤᱱ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱮᱯᱤᱟᱭ ᱠᱷᱚᱱ ᱢᱚᱢᱮᱱᱴ ᱵᱟᱹᱲᱛᱤ ᱞᱟᱹᱵᱤᱫ ᱜᱮᱭᱟ ᱾ ᱟᱢ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱢᱚᱢᱮᱱᱴ ᱯᱷᱟᱱᱥᱚᱱ ᱨᱮ ᱯᱟᱥ ᱠᱟᱛᱮ ᱯᱟᱨᱥ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ ᱢᱤᱫ ᱟᱨᱜᱩᱴ ᱥᱟᱶᱛᱮ, Moment ᱫᱚ ISO ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱨᱮᱭᱟᱜ ᱟᱥᱚᱜ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱟᱢ ᱫᱚ ᱵᱮᱵᱚᱦᱟᱨ ᱠᱟᱱ ᱢᱟᱹᱦᱤᱛ ᱯᱨᱚᱰᱟᱠᱴ ᱩᱫᱩᱜ ᱠᱟᱛᱮ ᱫᱚᱥᱟᱨ ᱟᱨᱜᱩᱴ ᱮᱢ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾
ᱠᱚᱱᱥᱴ ᱟᱭᱥᱚᱰᱮᱴ = ᱢᱩᱦᱩᱛ ('᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴᱤ᱐᱙:᱐᱐:᱐᱐'); ᱠᱚᱱᱥᱴ ᱯᱷᱚᱨᱢᱮᱴᱰᱮᱴ = ᱢᱩᱦᱩᱛ ('᱒/᱒᱑/᱒᱖ ᱙:᱐᱐:᱐᱐', 'ᱢ/ᱰᱤ/ᱣᱟᱭ ᱮᱪ: ᱢᱤᱢᱤ: ᱮᱥ ᱮᱥ');
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱟᱭᱥᱚᱢᱟᱦᱟᱸ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴ᱐᱙:᱐᱐:᱐᱐-᱐᱕:᱐᱐>
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ (ᱯᱷᱚᱨᱢᱮᱴᱰ ᱢᱟᱹᱦᱤᱛ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴ᱐᱙:᱐᱐:᱐᱐-᱐᱕:᱐᱐>
ᱢᱟᱨᱮ ᱵᱷᱟᱨᱥᱚᱱ ᱠᱚ ᱨᱮ, ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱡᱟᱦᱟᱱ ᱤᱪᱷᱟᱹ ᱞᱮᱠᱟᱛᱮ ᱯᱷᱚᱨᱢᱮᱴ ᱠᱟᱱ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱯᱟᱨᱥ ᱞᱟᱹᱜᱤᱫ ᱥᱚᱨᱚᱥ ᱟᱱᱫᱷᱟᱣ ᱮ ᱛᱮᱭᱟᱨᱟ᱾ ᱱᱚᱣᱟ ᱛᱮ ᱵᱟᱝ ᱵᱟᱰᱟᱭ ᱞᱮᱠᱟᱱ ᱚᱨᱡᱚ ᱧᱟᱢ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ, ᱪᱮᱫ ᱐᱒-᱐᱓-᱒᱐᱒᱖ ᱒ ᱯᱷᱮᱵᱩᱭᱟᱨᱤ ᱥᱮ ᱓ ᱢᱟᱨᱪ ? ᱱᱚᱶᱟ ᱠᱷᱟᱹᱛᱤᱨ ᱛᱮ, Moment ᱨᱮᱭᱟᱜ ᱱᱟᱶᱟ ᱵᱷᱟᱨᱥᱚᱱ ᱫᱚ ISO ᱯᱷᱚᱨᱢᱮᱴ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱵᱮᱜᱚᱨ ᱛᱮ ᱦᱚᱦᱚ ᱠᱟᱱ ᱠᱷᱟᱱ ᱢᱤᱫ ᱥᱮᱬᱟ ᱰᱤᱯᱨᱮᱠᱮᱥᱚᱱ ᱪᱮᱦᱟᱣᱱᱟ ᱩᱫᱩᱜ ᱠᱟᱱᱟ (ᱡᱩᱫᱤ ᱡᱟᱹᱨᱩᱲ ᱯᱷᱚᱨᱢᱮᱴ ᱥᱟᱶ ᱫᱚᱥᱟᱨ ᱟᱨᱜᱩᱴ ᱦᱚᱸ ᱵᱟᱝ ᱮᱢ ᱠᱟᱱᱟ)᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱮᱠᱮᱱ ᱠᱷᱟᱥ ᱠᱟᱭᱛᱮ ᱯᱷᱚᱨᱢᱮᱴ ᱠᱟᱱ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱜᱮ ᱯᱟᱨᱥ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱭ᱾ ᱥᱴᱨᱤᱝ ᱫᱚ ISO 8601 ᱯᱷᱚᱨᱢ ᱥᱮ ᱚᱱᱟ ᱨᱮᱭᱟᱜ ᱮᱠᱥᱴᱮᱱᱥᱚᱱ, RFC 9557 ᱥᱟᱶ ᱯᱟᱹᱛᱤᱭᱟᱹᱣ ᱦᱩᱭᱩᱜ ᱞᱟᱹᱠᱛᱤᱭᱟ᱾
// ᱢᱤᱫ RFC 9557 ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ const myDate = ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱤᱱᱥᱴᱟᱱᱴ.ᱯᱷᱨᱚᱢ('᱒᱐᱒᱖-᱐᱒-᱒᱑T᱐᱙:᱐᱐:᱐᱐-᱐᱕:᱐᱐[ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ]'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱤᱧᱟᱜ ᱢᱟᱹᱦᱤᱛ.ᱴᱩᱥᱴᱨᱤᱝ({ᱚᱠᱛᱚᱴᱚᱬᱮ: 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ'})); // ᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴ᱐᱙:᱐᱐:᱐᱐-᱐᱕:᱐᱐
// ᱢᱤᱫ ᱵᱟᱝ ᱵᱟᱰᱟᱭ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ const ᱮᱴᱟᱜ ᱢᱟᱹᱦᱤᱛ = ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ ᱤᱱᱥᱴᱟᱱᱴ᱾ᱯᱷᱨᱚᱢ ('᱒/᱒᱑/᱒᱖ ᱙:᱐᱐:᱐᱐'); // ᱨᱮᱸᱡᱽ ᱮᱨᱚᱨ: ᱴᱮᱢᱯᱚᱨᱟᱞ ᱮᱨᱚᱨ: ᱥᱮᱨᱢᱟ ᱜᱚᱱᱚᱝ ᱯᱟᱨᱥᱤᱝ ᱚᱠᱛᱚ ᱵᱟᱝ ᱴᱷᱤᱠ ᱪᱤᱠᱤ᱾
ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱨᱮᱭᱟᱜ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱞᱟᱹᱠᱛᱤ ᱠᱚ ᱱᱤᱭᱟᱹ ᱠᱟᱛᱷᱟ ᱨᱮ ᱴᱮᱦᱟᱱᱰ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱮ ᱟᱢ ᱚᱠᱟ ᱞᱮᱠᱟᱱ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱮᱢ ᱵᱮᱱᱟᱣ ᱮᱫᱟ᱾ ᱪᱮᱛᱟᱱ ᱨᱮᱱᱟᱜ ᱫᱟᱹᱭᱠᱟᱹ ᱨᱮ, ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ᱫᱚ ᱢᱤᱫ ᱯᱩᱨᱟᱹ ᱟᱭᱤ ᱮᱥ ᱳ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ8601 ᱟᱨ RFC 9557 ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱫᱚ ᱢᱤᱫ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱚᱯᱷᱥᱮᱴ ᱥᱟᱶᱛᱮ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱩᱫᱩᱜ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱟᱢ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱯᱨᱚᱰᱟᱴ ᱨᱮᱭᱟᱜ ᱥᱩᱢᱩᱝ ᱥᱟᱵᱽᱥᱮᱴ ᱵᱮᱵᱚᱦᱟᱨ ᱠᱟᱛᱮ PlainDate ᱥᱮ PlainTime ᱡᱤᱱᱤᱥ ᱦᱚᱸ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱠᱚᱱᱥᱴ ᱤᱧᱟᱜ ᱢᱟᱹᱦᱤᱛ = ᱚᱠᱛᱚ ᱞᱮᱠᱟᱱ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱾ ᱠᱷᱚᱱ ('᱒᱐᱒᱖-᱐᱒-᱒᱑'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱤᱧᱟᱜ ᱢᱟᱹᱦᱤᱛ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱒᱐᱒᱖-᱐᱒-᱒᱑
const ᱤᱧᱟᱜ ᱚᱠᱛᱚ = ᱚᱠᱛᱚ ᱞᱮᱠᱟᱱ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱚᱠᱛᱚ ᱾ ᱠᱷᱚᱱ ('᱐᱙:᱐᱐:᱐᱐'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱤᱧᱟᱜ ᱚᱠᱛᱚ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱐᱙:᱐᱐:᱐᱐
ᱱᱤᱭᱟᱹ ᱠᱟᱛᱷᱟ ᱫᱚ ᱩᱭᱦᱟᱹᱨ ᱢᱮ ᱡᱮ ᱱᱚᱶᱟ ᱥᱴᱨᱤᱝ ᱠᱚ ᱫᱚ ᱱᱤᱛ ᱦᱚᱸ ᱟᱥᱟ ᱟᱠᱟᱱ ᱯᱨᱚᱨᱩᱢ ᱞᱮᱠᱟ ᱢᱟᱱᱟᱣ ᱞᱟᱹᱠᱛᱤᱭᱟ, ᱵᱟᱝᱠᱷᱟᱱ ᱢᱤᱫ ᱦᱩᱰᱟᱹᱜ ᱪᱟᱯᱟᱫᱚᱜᱼᱟ᱾
// ᱢᱤᱫ ᱵᱟᱝ-ᱢᱟᱱᱟᱣ ᱚᱠᱛᱚ ᱥᱴᱨᱤᱝ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ ᱾ ᱱᱚᱶᱟ ᱠᱚ ᱥᱟᱱᱟᱢ ᱢᱤᱫ ᱨᱮᱸᱡᱽ ᱮᱨᱚᱨ ᱠᱚ ᱪᱟᱯᱟᱫᱟ᱾ ᱚᱠᱛᱚ ᱞᱮᱠᱟᱱ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱚᱠᱛᱚ ᱾ ᱠᱷᱚᱱ ('᱙:᱐᱐'); ᱚᱠᱛᱚ ᱞᱮᱠᱟᱱ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱚᱠᱛᱚ ᱾ ᱠᱷᱚᱱ ('᱙:᱐᱐:᱐᱐ ᱥᱮᱛᱟᱜ');
ᱯᱨᱚ ᱴᱤᱯ: ᱱᱚᱱ-ᱟᱭᱤ ᱮᱥ ᱳ ᱥᱴᱨᱤᱝ ᱦᱮᱱᱰᱞᱤᱝ ᱪᱮᱫᱟᱜ ᱥᱮ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱯᱟᱹᱛᱭᱟᱹᱣᱟᱱ ᱯᱨᱟᱛᱷᱟᱢᱤᱠᱟ ᱮᱢᱟᱭᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱐᱒-᱐᱑-᱒᱐᱒᱖ ᱞᱮᱠᱟᱱ ᱥᱴᱨᱤᱝ ᱨᱮᱭᱟᱜ ᱯᱨᱚᱨᱩᱢ ᱵᱟᱭ ᱟᱴᱠᱟᱨᱟ᱾ ᱡᱩᱫᱤ ᱟᱢᱟᱜ ᱰᱟᱴᱟ ᱥᱚᱨᱥ ᱱᱚᱝᱠᱟᱱ ᱥᱴᱨᱤᱝ ᱵᱮᱵᱚᱦᱟᱨ ᱠᱟᱱᱟ, ᱟᱢ ᱫᱚ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱥᱟᱶ ᱵᱮᱵᱚᱦᱟᱨ ᱨᱮᱭᱟᱜ ᱠᱩᱨᱩᱢᱩᱴᱩ ᱞᱟᱦᱟ ᱨᱮ 2026-02-01 ᱞᱮᱠᱟᱱ ISO ᱥᱴᱨᱤᱝ ᱨᱮ ᱵᱮᱵᱚᱦᱟᱨ ᱞᱟᱹᱜᱤᱫ ᱠᱤᱪᱷᱩ ᱥᱴᱨᱤᱝ ᱦᱮᱨᱟᱣ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ᱾
ᱯᱷᱚᱨᱢᱟᱴᱤᱝ ᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱢ ᱴᱷᱮᱱ ᱢᱚᱢᱮᱱᱴ ᱥᱮ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱛᱟᱦᱮᱱ ᱠᱷᱟᱱ, ᱟᱢ ᱫᱚ ᱚᱱᱟ ᱯᱷᱚᱨᱢᱟᱴ ᱥᱴᱨᱤᱝ ᱨᱮ ᱵᱚᱫᱚᱞ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱢᱤᱫ ᱫᱷᱟᱣ ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱨᱮ ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱱᱟᱥᱮ ᱵᱟᱹᱲᱛᱤ ᱠᱷᱟᱴᱚ ᱜᱮᱭᱟ ᱾ ᱟᱢ ᱡᱤᱱᱤᱥ ᱨᱮᱭᱟᱜ ᱯᱨᱚᱨᱩᱢ ᱯᱚᱛᱷᱤ ᱴᱚᱠᱚᱱ ᱨᱮᱭᱟᱜ ᱥᱴᱨᱤᱝ ᱥᱟᱶᱛᱮ ᱦᱚᱦᱚᱭ ᱢᱮ ᱚᱠᱟ ᱫᱚ ᱡᱟᱹᱨᱩᱲ ᱢᱟᱹᱦᱤᱛ ᱯᱨᱚᱨᱩᱢ ᱵᱚᱨᱱᱚᱱ ᱮᱢᱚᱜ ᱠᱟᱱᱟ᱾ const ᱢᱟᱹᱦᱤᱛ = ᱜᱷᱟᱹᱲᱤ ();
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱨᱩᱯ('ᱮᱢᱮᱢ/ᱰᱤᱰᱤ/ᱣᱟᱭᱣᱟᱭ')); // ᱐᱒/᱒᱒/᱒᱐᱒᱖
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱯᱨᱚᱨᱢᱮᱴ('ᱮᱢᱮᱢᱮᱢ ᱫᱚ ᱣᱟᱭᱣᱟᱭᱣᱟᱭ, ᱮᱪ: ᱮᱢᱮᱢ: ᱮᱥ ᱮᱥ ᱮ')); // ᱯᱷᱮᱵᱩᱭᱟᱨᱤ ᱒᱒ ᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘ᱺ᱑᱘ᱺ᱓᱐
ᱱᱷᱟᱛᱮ, ᱚᱠᱛᱚ ᱞᱟᱹᱜᱤᱫ ᱟᱢ ᱱᱟᱥᱮ ᱵᱟᱹᱲᱛᱤ ᱥᱟᱵᱟᱫᱽ ᱦᱩᱭᱩᱜ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ᱾ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ, ᱡᱮᱞᱮᱠᱟ ᱤᱱᱥᱴᱟᱱᱴ, ᱨᱮ ᱢᱤᱫᱴᱮᱱ toLocaleString ᱯᱚᱛᱷᱟ ᱢᱮᱱᱟᱜ-ᱟ ᱚᱠᱟ ᱫᱚ ᱡᱤᱱᱤᱥ ᱨᱮᱭᱟᱜ ᱜᱩᱱ ᱞᱮᱠᱟ ᱩᱫᱩᱜ ᱟᱠᱟᱱ ᱟᱭᱢᱟ ᱯᱷᱚᱨᱢᱟᱴᱤᱝ ᱚᱯᱥᱚᱱ ᱠᱚ ᱟᱝᱜᱚᱪᱟ᱾
const ᱰᱮᱴ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ();
// ᱵᱤᱱ ᱟᱨᱜᱩᱢᱮᱱᱴ ᱛᱮ, ᱟᱞᱮ ᱱᱤᱛᱚᱜ ᱞᱚᱠᱮᱞ ᱞᱟᱹᱜᱤᱫ ᱰᱤᱯᱷᱚᱞᱴ ᱯᱷᱚᱨᱢᱮᱴ ᱞᱮ ᱧᱟᱢᱟ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱒/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱒᱓:᱓᱖ (ᱮᱱ-ᱭᱩᱮᱥ ᱨᱮᱭᱟᱜ ᱞᱚᱠᱮᱞ ᱢᱚᱱᱮ ᱠᱟᱛᱮ)
// ᱠᱟᱥᱴᱚᱢ ᱯᱷᱚᱨᱢᱮᱴ ᱥᱴᱨᱤᱝ ᱥᱤᱨᱡᱟᱹᱣ ᱞᱟᱹᱜᱤᱫ ᱯᱷᱚᱨᱢᱮᱴᱤᱝ ᱚᱯᱥᱚᱱ ᱠᱚ ᱯᱟᱥ ᱢᱮ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ('ᱮᱱ-ᱭᱩᱮᱥ', { ᱪᱟᱸᱫᱚ: 'ᱡᱮᱞᱮᱝ', ᱫᱤᱱ: 'ᱮᱞᱠᱷᱟ', ᱥᱮᱨᱢᱟ: 'ᱮᱞᱠᱷᱟ', ᱴᱟᱲᱟᱝ: '᱒-ᱰᱤᱡᱤᱴ', ᱢᱤᱱᱤᱴ: '᱒-ᱰᱤᱡᱤᱴ' })); // ᱒᱒ ᱯᱷᱮᱵᱩᱭᱟᱨᱤ, ᱒᱐᱒᱖ ᱟᱹᱭᱩᱵ ᱘ᱺ᱒᱓ ᱨᱮ
// ᱥᱩᱢᱩᱝ ᱚᱱᱟ ᱯᱟᱦᱴᱟ ᱯᱟᱥ ᱢᱮ ᱟᱢ ᱯᱷᱚᱨᱢᱟᱴ ᱥᱴᱨᱤᱝ ᱨᱮ ᱠᱷᱚᱡᱚᱜ ᱠᱟᱱᱟᱢ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ('ᱮᱱ-ᱭᱩᱮᱥ', { ᱪᱟᱸᱫᱚ: 'ᱠᱷᱟᱴᱚ', ᱫᱤᱱ: 'ᱮᱞᱠᱷᱟ' })); // ᱯᱷᱮᱵᱽᱨᱮᱵᱚᱨ ᱒᱒
ᱚᱠᱛᱚ ᱢᱟᱹᱦᱤᱛ ᱯᱷᱚᱨᱢᱟᱴᱤᱝ ᱫᱚ ᱥᱟᱹᱨᱤ ᱛᱮ ᱦᱩᱰ ᱞᱟᱛᱟᱨ ᱨᱮ Intl.DateTimeFormat API (ᱚᱠᱟ ᱫᱚ ᱱᱟᱦᱟᱜ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮ ᱞᱟᱦᱟ ᱠᱷᱚᱱ ᱜᱮ ᱧᱟᱢᱚᱜ ᱠᱟᱱᱟ) ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟᱭ᱾ ᱚᱱᱟ ᱢᱮᱱᱮᱫ ᱫᱚ ᱟᱢ ᱟᱢᱟᱜ ᱠᱟᱥᱴᱚᱢ ᱯᱷᱚᱨᱢᱮᱴ ᱚᱯᱥᱚᱱ ᱠᱚ ᱥᱟᱶᱛᱮ ᱫᱚᱦᱲᱟ ᱵᱮᱵᱷᱟᱨᱚᱜ ᱞᱮᱠᱟᱱ DateTimeFormat ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, ᱚᱱᱟ ᱛᱟᱭᱚᱢ ᱴᱮᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱠᱚ ᱚᱱᱟ ᱨᱮᱭᱟᱜ ᱯᱷᱚᱨᱢᱮᱴ ᱯᱚᱛᱷᱟ ᱨᱮ ᱯᱟᱥ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱱᱚᱣᱟ ᱠᱷᱟᱹᱛᱤᱨ, ᱱᱚᱣᱟ ᱫᱚ ᱢᱚᱢᱮᱱᱴ ᱞᱮᱠᱟ ᱠᱟᱥᱴᱚᱢ ᱰᱮᱴ ᱯᱷᱚᱨᱢᱮᱴ ᱵᱟᱭ ᱥᱟᱯᱚᱨᱴ ᱮᱫᱟ᱾ ᱡᱩᱫᱤ ᱟᱢ 'Q1 2026' ᱥᱮ ᱮᱴᱟᱜ ᱠᱷᱟᱥ ᱯᱷᱚᱨᱢᱮᱴᱤᱝ ᱞᱮᱠᱟᱱ ᱡᱟᱦᱟᱱᱟᱜ ᱞᱟᱹᱠᱛᱤᱭᱟᱢ ᱠᱟᱱᱟ, ᱟᱢ ᱫᱚ ᱠᱟᱥᱴᱚᱢ ᱢᱟᱹᱦᱤᱛ ᱯᱷᱚᱨᱢᱮᱴᱤᱝ ᱠᱚᱰ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ ᱥᱮ ᱛᱮᱥᱟᱨ ᱯᱟᱨᱴᱤ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱨᱮ ᱥᱮᱴᱮᱨᱚᱜ ᱢᱮ᱾ ᱠᱚᱱᱥᱴ ᱯᱷᱚᱨᱢᱮᱴᱟᱨ = ᱱᱟᱶᱟ ᱤᱱᱴᱮᱞ. ᱢᱟᱹᱦᱤᱛ ᱚᱠᱛᱚ ᱯᱷᱚᱨᱢᱮᱴ ('ᱮᱱ-ᱭᱩᱮᱥ', { ᱪᱟᱸᱫᱚ: '᱒-ᱰᱤᱡᱤᱴ', ᱫᱤᱱ: '᱒-ᱰᱤᱡᱤᱴ', ᱥᱮᱨᱢᱟ: 'ᱮᱞᱠᱷᱟ' });
const ᱰᱮᱴ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱤᱱᱥᱴᱟᱱᱴ (); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱯᱷᱚᱨᱢᱮᱴᱟᱨ.ᱯᱷᱚᱨᱢᱮᱴ(ᱢᱟ.ᱦᱤᱛ)); // ᱐᱒/᱒᱒/᱒᱐᱒᱖
ᱢᱚᱢᱮᱱᱴ ᱨᱮᱭᱟᱜ ᱯᱷᱚᱨᱢᱟᱴᱤᱝ ᱴᱚᱠᱮᱱ ᱚᱞ ᱞᱟᱹᱜᱤᱫ ᱟᱞᱜᱟ ᱜᱮᱭᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱚᱱᱟ ᱫᱚ ᱞᱚᱠᱮᱞ ᱜᱟᱛᱮ ᱵᱟᱝ ᱠᱟᱱᱟ᱾ ᱯᱨᱚᱨᱩᱢ ᱥᱴᱨᱤᱝ “ᱦᱟᱨᱰ ᱠᱚᱰ” ᱡᱤᱱᱤᱥ ᱡᱮᱞᱠᱟ ᱪᱟᱸᱫᱚ/ᱢᱟᱦᱟᱸ ᱚᱰᱟᱨ ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱞᱮᱠᱟ ᱠᱚᱱᱯᱷᱤᱜᱟᱨ ᱡᱤᱱᱤᱥ ᱵᱮᱵᱚᱦᱟᱨ ᱨᱮᱭᱟᱜ ᱯᱷᱟᱭᱫᱟ ᱫᱚ ᱱᱚᱶᱟ ᱠᱟᱱᱟ ᱡᱮ ᱱᱚᱶᱟ ᱫᱚ ᱟᱡ ᱛᱮ ᱡᱟᱦᱟᱱ ᱞᱚᱠᱟᱞ ᱨᱮ ᱟᱯᱱᱟᱨ ᱟᱨ ᱴᱷᱤᱠ ᱯᱨᱚᱰᱟᱴ ᱵᱮᱵᱚᱦᱟᱨ ᱠᱟᱱᱟ᱾ const ᱰᱮᱴ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ();
ᱠᱚᱱᱥᱴ ᱯᱷᱚᱨᱢᱟᱴ ᱚᱯᱥᱚᱱᱥ = { ᱪᱟᱸᱫᱚ: 'ᱮᱞᱠᱷᱟ', ᱫᱤᱱ: 'ᱮᱞᱠᱷᱟ', ᱥᱮᱨᱢᱟ: 'ᱮᱞᱠᱷᱟ' };
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ('ᱮᱱ-ᱭᱩᱮᱥ', ᱯᱷᱚᱨᱢᱮᱴ ᱚᱯᱥᱚᱱᱥ)); // ᱒/᱒᱒/᱒᱐᱒᱖
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ('ᱮᱱ-ᱡᱤᱵᱤ', ᱯᱷᱚᱨᱢᱟᱴ ᱚᱯᱥᱚᱱᱥ)); // ᱒᱒/᱐᱒/᱒᱐᱒᱖
ᱢᱟᱹᱦᱤᱛ ᱞᱮᱠᱷᱟ ᱟᱹᱰᱤ ᱜᱟᱱ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱮ, ᱟᱢ ᱫᱚ ᱢᱤᱫ ᱢᱟᱹᱦᱤᱛ ᱨᱮ ᱛᱤᱱᱟᱹᱜ ᱜᱟᱱ ᱞᱮᱠᱷᱟ ᱢᱩᱪᱟᱹᱫ ᱛᱮ ᱦᱩᱭᱟᱢᱟ᱾ ᱟᱢ ᱚᱠᱛᱚ ᱨᱮᱭᱟᱜ ᱭᱩᱱᱤᱴ ᱥᱮᱞᱮᱫ ᱥᱮ ᱚᱪᱚᱜ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ (ᱫᱤᱱ, ᱴᱟᱲᱟᱝ, ᱥᱮᱠᱮᱱᱰ, ᱮᱢᱟᱱ)᱾ ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ, ᱡᱩᱫᱤ ᱟᱢ ᱴᱷᱮᱱ ᱱᱤᱛᱚᱜ ᱢᱟᱹᱦᱤᱛ ᱢᱮᱱᱟᱜᱼᱟ, ᱟᱢ ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱠᱚ ᱱᱤᱛ ᱠᱷᱚᱱ ᱑ ᱦᱟᱴ ᱛᱟᱭᱚᱢ ᱢᱟᱹᱦᱤᱛ ᱩᱫᱩᱜ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ᱾ ᱢᱩᱦᱩᱛ ᱡᱤᱱᱤᱥ ᱨᱮ ᱥᱮᱞᱮᱫ ᱟᱨ ᱜᱷᱚᱴᱟᱣ ᱞᱮᱠᱟᱱ ᱯᱚᱨᱠᱟᱨ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱱᱚᱶᱟ ᱠᱟᱹᱢᱤ ᱠᱚ ᱠᱚᱨᱟᱣᱟ᱾ ᱱᱚᱶᱟ ᱯᱷᱟᱱᱠᱥᱚᱱ ᱠᱚ ᱫᱚ ᱢᱤᱫ ᱜᱚᱱᱚᱝ ᱟᱨ ᱢᱤᱫ ᱭᱩᱱᱤᱴ ᱠᱚ ᱦᱟᱛᱟᱣᱟ, ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ: ᱥᱮᱞᱮᱫ (᱗, 'ᱢᱟᱦᱟᱸ')᱾ Moment ar Temporal ᱨᱮ ᱢᱤᱫ ᱟᱹᱰᱤ ᱡᱟᱹᱨᱩᱲ ᱵᱮᱜᱟᱨ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱶᱟ ᱢᱟᱹᱦᱤᱛ ᱞᱮᱠᱷᱟ ᱠᱚ ᱠᱟᱹᱢᱤ ᱠᱟᱛᱮ ᱞᱟᱛᱟᱨ ᱨᱮ ᱢᱮᱱᱟᱜ ᱡᱤᱱᱤᱥ ᱠᱚ ᱵᱚᱫᱚᱞ ᱠᱟᱱᱟ ᱟᱨ ᱚᱱᱟ ᱨᱮᱭᱟᱜ ᱟᱥᱚᱞ ᱜᱚᱱᱚᱝ ᱠᱚ ᱟᱫ ᱠᱟᱱᱟ᱾ const ᱱᱤᱛᱚᱜ = ᱜᱷᱟᱹᱲᱤ ();
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱔ᱴᱤ᱒᱐:᱐᱘:᱓᱖-᱐᱕:᱐᱐>
const ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ = ᱱᱤᱛᱚᱜ ᱾ ᱥᱮᱞᱮᱫ (᱗, 'ᱢᱟᱦᱟᱸ'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ (ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱓-᱐᱓ᱴᱤ᱒᱐:᱐᱘:᱓᱖-᱐᱕:᱐᱐>
// ᱜᱚᱴᱪᱟ - ᱟᱥᱚᱞ ᱡᱤᱱᱤᱥ ᱢᱭᱩᱴᱮᱴ ᱞᱮᱱᱟ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱓-᱐᱓ᱴᱤ᱒᱐:᱐᱘:᱓᱖-᱐᱕:᱐᱐>
ᱟᱥᱚᱞ ᱢᱟᱹᱦᱤᱛ ᱟᱫ ᱠᱷᱚᱱ ᱥᱟᱦᱟᱜ ᱞᱟᱹᱜᱤᱫ, ᱟᱢ ᱢᱤᱫ ᱱᱚᱠᱚᱞ ᱵᱮᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱨᱮ ᱠᱞᱚᱱ ᱦᱚᱦᱚ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ const ᱱᱤᱛᱚᱜ= ᱜᱷᱟᱹᱲᱤ (); ᱠᱚᱱᱥᱴ ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ = ᱱᱤᱛᱚᱜ ᱾ ᱠᱞᱚᱱ (). ᱥᱮᱞᱮᱫ (᱗, 'ᱢᱟᱦᱟᱸ');
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱔ᱴᱤ᱒᱐:᱑᱒:᱕᱕-᱐᱕:᱐᱐>
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ (ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱓-᱐᱓ᱴᱤ᱒᱐:᱑᱒:᱕᱕-᱐᱕:᱐᱐>
ᱱᱷᱟᱛᱮ, ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱫᱚ ᱵᱟᱝ ᱵᱚᱫᱚᱞᱚᱜᱼᱟ ᱾ ᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱢ ᱫᱚ Instant, PlainDate, ᱟᱨ ᱚᱱᱠᱟᱱ ᱡᱤᱱᱤᱥ ᱵᱮᱱᱟᱣ ᱠᱟᱛᱮ ᱚᱱᱟ ᱡᱤᱱᱤᱥ ᱨᱮᱭᱟᱜ ᱜᱚᱱᱚᱝ ᱫᱚ ᱛᱤᱥ ᱦᱚᱸ ᱵᱟᱝ ᱵᱚᱫᱚᱞᱚᱜᱼᱟ᱾ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱨᱮ ᱦᱚᱸ ᱡᱚᱯᱲᱟᱣ ᱟᱨ ᱚᱪᱚᱜ ᱦᱚᱨᱟ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱚᱠᱛᱚ ᱫᱚ ᱱᱟᱥᱮ ᱵᱟᱪᱷᱟᱣ ᱜᱮᱭᱟ ᱚᱠᱟ ᱚᱠᱛᱚ ᱭᱩᱱᱤᱴ ᱚᱠᱟ ᱡᱤᱱᱤᱥ ᱞᱮᱠᱟᱱ ᱥᱟᱶ ᱥᱮᱞᱮᱫᱚᱜᱼᱟ ᱾ ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ, ᱟᱢ ᱫᱚ ᱨᱚᱠᱟ ᱨᱮ ᱫᱤᱱ ᱵᱟᱢ ᱥᱮᱞᱮᱫ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ:
const ᱱᱤᱛᱚᱜ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱤᱱᱥᱴᱟᱱᱴ (); const ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ = ᱱᱤᱛᱚᱜ ᱾ ᱥᱮᱞᱮᱫ ({ ᱢᱟᱦᱟᱸ: ᱗ }); // ᱯᱟᱥᱱᱟᱣ ᱦᱩᱰᱟᱹᱜ: ᱚᱠᱛᱚ ᱦᱩᱰᱟᱹᱜ: ᱥᱟᱱᱟᱢ ᱠᱷᱚᱱ ᱢᱟᱨᱟᱝ ᱭᱩᱱᱤᱴ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱭᱩᱱᱤᱴ ᱵᱟᱝ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ
ᱱᱚᱣᱟ ᱫᱚ ᱱᱚᱣᱟ ᱠᱷᱟᱹᱛᱤᱨ ᱜᱮ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱡᱮ ᱨᱚᱠᱟ ᱡᱤᱱᱤᱥ ᱠᱚ ᱫᱚ ᱭᱩᱴᱤᱥᱤ ᱨᱮ ᱚᱠᱛᱚ ᱨᱮ ᱢᱤᱫ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱵᱤᱱᱫᱟᱹ ᱩᱫᱩᱜ ᱟᱨ ᱠᱮᱞᱮᱱᱰᱟᱨ-ᱮᱜᱽᱱᱚᱥᱴᱤᱠ ᱠᱟᱱᱟ ᱾ ᱪᱮᱫᱟᱜ ᱥᱮ ᱢᱤᱫ ᱫᱤᱱ ᱨᱮᱭᱟᱜ ᱡᱮᱞᱮᱝ ᱫᱚ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱨᱮᱭᱟᱜ ᱱᱤᱭᱚᱢ ᱞᱮᱠᱟ ᱵᱚᱫᱚᱞ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, ᱱᱚᱶᱟ ᱞᱮᱠᱷᱟ ᱫᱚ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ ᱨᱮ ᱵᱟᱝ ᱧᱟᱢᱚᱜ-ᱟ᱾ ᱟᱢ ᱫᱚ, ᱪᱟᱦᱮ, ᱱᱚᱣᱟ ᱚᱯᱟᱨᱮᱥᱚᱱ ᱮᱴᱟᱜ ᱞᱮᱠᱟᱱ ᱡᱤᱱᱤᱥ ᱠᱚ ᱨᱮᱢ ᱠᱚᱨᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱡᱮᱞᱠᱟ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱚᱠᱛᱚ: const ᱱᱤᱛᱚᱜ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱦᱟᱸ ᱚᱠᱛᱚ ᱟᱭᱤ ᱮᱥ ᱳ (); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱔/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱒᱓:᱕᱙
const ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ = ᱱᱤᱛᱚᱜ ᱾ ᱥᱮᱞᱮᱫ ({ ᱢᱟᱦᱟᱸ: ᱗ });
// ᱱᱚᱴ ᱢᱮ ᱡᱮ ᱟᱥᱚᱞ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱚᱠᱛᱚ ᱵᱟᱝ ᱵᱚᱫᱚᱞ ᱟᱠᱟᱱᱟ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱔/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱒᱓:᱕᱙
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱫᱚᱥᱟᱨ ᱦᱟᱯᱛᱟ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱓/᱓/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱒᱓:᱕᱙
ᱟᱢ ᱦᱚᱸ ᱞᱮᱠᱷᱟ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ ᱵᱟᱨ ᱢᱚᱢᱮᱱᱴ ᱥᱮ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱛᱟᱞᱟ ᱨᱮ ᱛᱤᱱᱟᱹᱜ ᱚᱠᱛᱚ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱢᱚᱢᱮᱱᱴ ᱨᱮᱭᱟᱜ ᱰᱤᱯᱷ ᱯᱷᱟᱱᱥᱚᱱ ᱥᱟᱶᱛᱮ, ᱟᱢ ᱫᱚ ᱜᱽᱨᱟᱱᱩᱞᱟᱨᱤᱴᱤ ᱞᱟᱹᱜᱤᱫ ᱢᱤᱫ ᱭᱩᱱᱤᱴ ᱮᱢ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ, ᱵᱟᱝᱠᱷᱟᱱ ᱱᱚᱣᱟ ᱫᱚ ᱢᱤᱞᱤᱥᱮᱠᱮᱱᱰ ᱨᱮ ᱵᱷᱮᱜᱟᱨ ᱮ ᱨᱩᱣᱟᱹᱲᱟ᱾ ᱠᱚᱱᱥᱴ ᱢᱟᱹᱦᱤᱛ ᱑ = ᱢᱩᱦᱩᱛ ('᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴᱤ᱐᱙:᱐᱐:᱐᱐'); ᱠᱚᱱᱥᱴ ᱢᱟᱹᱦᱤᱛ᱒ = ᱢᱩᱦᱩᱛ ('᱒᱐᱒᱖-᱐᱒-᱒᱒ᱴᱤ᱑᱐:᱓᱐:᱐᱐');
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ᱒.ᱵᱷᱮᱜᱟᱨ(ᱢᱟᱹᱦᱤᱛ᱑)); // ᱙᱑᱘᱐᱐᱐᱐
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱢᱟᱹᱦᱤᱛ᱒.ᱵᱷᱮᱜᱟᱨ(ᱢᱟᱹᱦᱤᱛ᱑, 'ᱢᱟᱦᱟᱸ')); // ᱑
ᱢᱤᱫ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱥᱟᱶ ᱱᱚᱣᱟ ᱠᱚᱨᱟᱣ ᱞᱟᱹᱜᱤᱫ, ᱟᱢ ᱮᱴᱟᱜ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱤᱱᱤᱥ ᱱᱚᱣᱟ ᱦᱟᱹᱵᱤᱡ ᱥᱮ ᱛᱟᱭᱚᱢ ᱯᱚᱫᱷᱚᱱ ᱛᱮᱢ ᱯᱟᱥ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱢᱤᱫ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱨᱩᱣᱟᱹᱲ ᱮᱢᱚᱜ ᱠᱟᱱᱟ᱾ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱡᱟᱦᱟᱸ ᱨᱮ ᱚᱠᱛᱚ ᱵᱮᱜᱟᱨ ᱵᱟᱵᱚᱛ ᱵᱟᱯᱟᱰᱟᱭ ᱛᱟᱦᱮᱱᱟ᱾ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱨᱮ ᱵᱷᱮᱜᱟᱨ ᱨᱮᱭᱟᱜ ᱢᱤᱢᱤᱫ ᱜᱷᱚᱴᱚᱱ ᱞᱟᱹᱜᱤᱫ ᱜᱩᱱ ᱢᱮᱱᱟᱜ-ᱟ, ᱟᱨ ᱚᱠᱛᱚ ᱵᱷᱮᱜᱟᱨ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ISO 8601 ᱚᱠᱛᱚ ᱥᱴᱨᱤᱝ ᱦᱚᱸ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾
const date1 = ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱯᱞᱮᱱᱰᱮᱴᱴᱟᱭᱤᱢ.ᱯᱷᱨᱚᱢ('᱒᱐᱒᱖-᱐᱒-᱒᱑T᱐᱙:᱐᱐:᱐᱐'); const date2 = ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱯᱞᱮᱱᱰᱮᱴᱴᱟᱭᱤᱢ.ᱯᱷᱨᱚᱢ('᱒᱐᱒᱖-᱐᱒-᱒᱒T᱑᱐:᱓᱐:᱐᱐');
// largestUnit ᱫᱚ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ᱚᱠᱛᱚ ᱨᱮᱭᱟᱜ ᱥᱟᱱᱟᱢ ᱠᱷᱚᱱ ᱢᱟᱨᱟᱝ ᱭᱩᱱᱤᱴ ᱩᱫᱩᱜ ᱮᱫᱟᱭ // ᱚᱠᱛᱚ ᱞᱮᱠᱷᱟ ᱨᱮ const diff = ᱢᱟᱹᱦᱤᱛ ᱒. ᱛᱟᱭᱚᱢ ᱠᱷᱚᱱ (ᱢᱟᱹᱦᱤᱛ ᱑, { ᱥᱟᱱᱟᱢ ᱠᱷᱚᱱ ᱢᱟᱨᱟᱝ ᱭᱩᱱᱤᱴ: 'ᱢᱟᱦᱟᱸ' });
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱵᱷᱮᱜᱟᱨ.ᱫᱤᱱ); // ᱑
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱵᱷᱮᱜᱟᱨ.ᱴᱟᱲᱟᱝ); // ᱑
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱵᱷᱮᱜᱟᱨ.ᱢᱤᱱᱤᱴ); // ᱓᱐
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱵᱷᱮᱜᱟᱨ.ᱴᱩᱥᱴᱨᱤᱝ()); // ᱯᱤ᱑ᱰᱤᱴᱤ᱑ᱮᱪ᱓᱐ᱢ // (ᱟᱭᱤ ᱮᱥ ᱳ ᱘᱖᱐᱑ ᱚᱠᱛᱚ ᱥᱴᱨᱤᱝ: ᱑ ᱢᱟᱦᱟᱸ, ᱑ ᱴᱟᱲᱟᱝ, ᱓᱐ ᱴᱤᱯᱤᱡ)
ᱢᱟᱹᱦᱤᱛ ᱠᱚ ᱟᱨ ᱚᱠᱛᱚ ᱠᱚ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ Moment ᱟᱨ Temporal ᱵᱟᱱᱟᱨ ᱜᱮ ᱟᱢ ᱢᱟᱹᱦᱤᱛ ᱟᱨ ᱚᱠᱛᱚ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱮᱢ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ ᱚᱠᱟ ᱫᱚ ᱮᱴᱟᱜ ᱠᱚ ᱞᱟᱦᱟ ᱨᱮ ᱦᱤᱡᱩᱜ-ᱟ, ᱢᱮᱱᱠᱷᱟᱱ API ᱥᱟᱶ ᱵᱷᱮᱜᱟᱨ ᱰᱟᱦᱟᱨ ᱠᱚ ᱦᱟᱛᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱵᱟᱨ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱤᱥᱵᱤᱯᱷᱚᱨ, ᱤᱥᱟᱯᱷᱴᱚᱨ, ᱟᱨ ᱤᱥᱥᱟᱢ ᱞᱮᱠᱟᱱ ᱯᱚᱨᱠᱟᱨ ᱮᱢᱚᱜ ᱠᱟᱱᱟ᱾ ᱠᱚᱱᱥᱴ ᱢᱟᱹᱦᱤᱛ ᱑ = ᱢᱩᱦᱩᱛ ('᱒᱐᱒᱖-᱐᱒-᱒᱑ᱴᱤ᱐᱙:᱐᱐:᱐᱐'); ᱠᱚᱱᱥᱴ ᱢᱟᱹᱦᱤᱛ᱒ = ᱢᱩᱦᱩᱛ ('᱒᱐᱒᱖-᱐᱒-᱒᱒ᱴᱤ᱑᱐:᱓᱐:᱐᱐');
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ (ᱢᱟᱹᱦᱤᱛ ᱑. ᱞᱟᱦᱟ ᱨᱮ (ᱢᱟᱹᱦᱤᱛ ᱒)); // ᱥᱟᱹᱨᱤ
ᱢᱤᱫ ᱞᱮᱠᱟᱱ ᱵᱟᱨ ᱡᱤᱱᱤᱥ ᱛᱟᱞᱟ ᱨᱮ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱥᱴᱮᱴᱤᱠ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱦᱚᱨᱟ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟᱭ ᱾ ᱱᱚᱣᱟ ᱫᱚ -᱑ ᱨᱩᱣᱟᱹᱲᱟ ᱡᱩᱫᱤ ᱯᱩᱭᱞᱩ ᱢᱟᱹᱦᱤᱛ ᱫᱚ ᱫᱚᱥᱟᱨ ᱠᱷᱚᱱ ᱢᱟᱲᱟᱝ ᱨᱮ ᱦᱤᱡᱩᱜ ᱠᱟᱱᱟ, ᱐ ᱡᱩᱫᱤ ᱩᱱᱠᱩ ᱵᱟᱨᱟᱵᱟᱨᱤ ᱠᱚ ᱛᱟᱦᱮᱱᱟ, ᱟᱨ ᱵᱟᱝ ᱑ ᱡᱩᱫᱤ ᱯᱩᱭᱞᱩ ᱢᱟᱹᱦᱤᱛ ᱫᱚ ᱫᱚᱥᱟᱨ ᱛᱟᱭᱚᱢ ᱨᱮ ᱦᱤᱡᱩᱜ ᱠᱟᱱᱟ᱾ ᱞᱟᱛᱟᱨ ᱨᱮ ᱮᱢ ᱟᱠᱟᱱ ᱫᱟᱹᱭᱠᱟᱹ ᱩᱫᱩᱜ ᱮᱫᱟᱭ ᱪᱮᱫ ᱞᱮᱠᱟ ᱵᱟᱨ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱡᱤᱱᱤᱥ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱦᱩᱭᱩᱜᱼᱟ ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱨᱮᱭᱟᱜ ᱵᱟᱱᱟᱨ ᱟᱨᱜᱩᱢᱮᱱᱴ ᱜᱮ ᱯᱞᱮᱱ ᱰᱮᱴ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱯᱞᱮᱱ ᱰᱮᱴ ᱡᱤᱱᱤᱥ ᱦᱩᱭᱩᱜ ᱞᱟᱹᱠᱛᱤᱭᱟ᱾
const date1 = ᱴᱮᱢᱯᱚᱨᱟᱞ. ᱯᱞᱮᱱ ᱰᱮᱴ. ᱠᱷᱚᱱ ({ ᱥᱮᱨᱢᱟ: 2026, ᱪᱟᱸᱫᱚ: 2, ᱢᱟᱦᱟ: 24 }); const date2 = ᱴᱮᱢᱯᱚᱨᱟᱞ. ᱯᱞᱮᱱ ᱰᱮᱴ. ᱠᱷᱚᱱ ({ ᱥᱮᱨᱢᱟ: ᱒᱐᱒᱖, ᱪᱟᱸᱫᱚ: ᱓, ᱢᱟᱦᱟᱸ: ᱒᱔ });
// ᱢᱟᱹᱦᱤᱛ ᱑ ᱢᱟᱹᱦᱤᱛ ᱒ ᱞᱟᱦᱟᱨᱮ ᱦᱤᱡᱩᱜ ᱠᱟᱱᱟ, ᱚᱱᱟᱛᱮ -᱑ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱯᱞᱮᱱᱰᱮᱴ.ᱛᱩᱞᱟᱹ(ᱢᱟᱹᱦᱤᱛ᱑, ᱢᱟᱹᱦᱤᱛ᱒));
// ᱦᱩᱰᱟᱹᱜ ᱡᱩᱫᱤ ᱟᱵᱚ ᱵᱟᱨ ᱞᱮᱠᱟᱱ ᱡᱤᱱᱤᱥ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱨᱮᱭᱟᱜ ᱵᱚᱱ ᱠᱩᱨᱩᱢᱩᱴᱩᱭᱟ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱯᱞᱮᱱᱰᱮᱴ.ᱛᱩᱞᱟᱹ(ᱢᱟᱹᱦᱤᱛ᱑, ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱱᱤᱛᱚᱜ.ᱤᱱᱥᱴᱟᱱᱴ())); // ᱞᱮᱠᱟᱱ ᱦᱩᱰᱟᱹᱜ: ᱚᱠᱛᱚ ᱦᱩᱰᱟᱹᱜ: ᱵᱟᱝ ᱴᱷᱤᱠ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱯᱟᱦᱴᱟ ᱮᱢ ᱟᱠᱟᱱᱟ ᱾
ᱠᱷᱟᱥ ᱠᱟᱛᱮ, ᱱᱚᱣᱟ ᱫᱚ ᱥᱚᱢᱚᱭ ᱡᱤᱱᱤᱥ ᱠᱚ ᱚᱠᱛᱚ ᱞᱮᱠᱟ ᱵᱟᱪᱷᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱟᱞᱜᱟ ᱵᱮᱱᱟᱣ ᱮᱫᱟᱭ ᱾ // ᱴᱮᱢᱯᱚᱨᱟᱞ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱮᱨᱮ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱡᱤᱱᱤᱥ ᱠᱚ ᱠᱚᱱᱥᱴ ᱢᱟᱹᱦᱤᱛ ᱠᱚ = [ ... ];
// ᱴᱮᱢᱯᱚᱨᱟᱞ ᱵᱮᱵᱷᱟᱨ ᱢᱮ ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ ᱾ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱯᱷᱟᱱᱥᱚᱱ ᱞᱮᱠᱟᱛᱮ ᱢᱟᱹᱦᱤᱛ ᱠᱚ᱾ ᱵᱟᱪᱷᱟᱣ (ᱚᱠᱛᱚ᱾ ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱟᱹᱦᱤᱛ᱾ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ);
ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱚᱲ ᱵᱚᱫᱚᱞ ᱠᱚᱨ ᱢᱚᱢᱮᱱᱴ ᱞᱟᱭᱵᱨᱮᱨᱤ ᱫᱚ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱚᱲ ᱵᱟᱭ ᱥᱟᱯᱚᱨᱴ ᱮᱫᱟ᱾ ᱡᱩᱫᱤ ᱟᱢ ᱱᱚᱣᱟ ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱞᱟᱹᱠᱛᱤᱭᱟᱢ ᱠᱟᱱᱟ, ᱟᱢ ᱦᱚᱸ ᱢᱚᱢᱮᱱᱴ-ᱴᱟᱭᱤᱢᱡᱚᱱ ᱯᱮᱠᱮᱡᱽ ᱤᱱᱥᱴᱚᱞ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ᱾ ᱱᱚᱣᱟ ᱯᱮᱠᱮᱡᱽ ᱫᱚ ᱫᱟᱨᱮ ᱞᱮᱠᱟ ᱵᱟᱝ ᱦᱤᱞᱚᱜ ᱜᱮᱭᱟ, ᱟᱨ ᱚᱱᱟ ᱠᱷᱟᱹᱛᱤᱨ ᱟᱢᱟᱜ ᱵᱟᱱᱰᱮᱞ ᱜᱚᱲᱦᱚᱱ ᱨᱮ ᱢᱩᱲᱩᱫ ᱥᱮᱞᱮᱫ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱢ ᱢᱚᱢᱮᱱᱴ-ᱴᱟᱭᱤᱢᱡᱚᱱ ᱤᱱᱥᱴᱚᱞ ᱠᱟᱛᱮ, ᱟᱢ ᱢᱚᱢᱮᱱᱴ ᱡᱤᱱᱤᱥ ᱠᱚ tzz ᱯᱚᱛᱷᱟ ᱛᱮ ᱵᱷᱮᱜᱟᱨ ᱵᱷᱮᱜᱟᱨ ᱴᱟᱭᱤᱢ ᱡᱚᱱ ᱨᱮ ᱵᱚᱫᱚᱞ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ ᱮᱴᱟᱜ ᱢᱚᱢᱮᱱᱴ ᱚᱯᱟᱨᱮᱥᱚᱱ ᱞᱮᱠᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱞᱟᱛᱟᱨ ᱨᱮ ᱢᱮᱱᱟᱜ ᱠᱚ ᱢᱭᱩᱴᱮᱴ ᱮᱫᱟᱭᱡᱤᱱᱤᱥ᱾ // ᱟᱢᱮᱨᱤᱠᱟ ᱯᱩᱨᱩᱵ ᱚᱠᱛᱚ ᱢᱚᱱᱮ ᱠᱟᱛᱮ const ᱱᱤᱛᱚᱜ = ᱜᱷᱟᱹᱲᱤ (); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱘ᱴᱤ᱒᱐:᱐᱘:᱒᱐-᱐᱕:᱐᱐>
// ᱯᱟᱥᱤᱯᱷᱤᱠ ᱚᱠᱛᱚ ᱨᱮ ᱵᱚᱫᱚᱞ ᱢᱮ᱾ // ᱟᱥᱚᱞ ᱯᱩᱨᱩᱵ ᱚᱠᱛᱚ ᱟᱫ ᱮᱱᱟ ᱾ ᱱᱤᱛᱚᱜ.ᱴᱤᱡᱽ('ᱟᱢᱮᱨᱤᱠᱟ/ᱞᱚᱥ_ᱮᱱᱡᱮᱞᱥ'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ); // ᱚᱠᱛᱚ<᱒᱐᱒᱖-᱐᱒-᱒᱘ᱴᱤ᱑᱗:᱐᱘:᱒᱐-᱐᱘:᱐᱐>
ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱫᱚ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱮᱯᱤᱟᱭᱤ ᱨᱮ ᱛᱮᱭᱟᱨ ᱟᱠᱟᱱᱟ ᱚᱠᱛᱚ ᱵᱮᱵᱷᱟᱨ ᱚᱠᱛᱚ ᱚᱠᱛᱚ ᱚᱠᱛᱚ ᱡᱤᱱᱤᱥ ᱾ ᱱᱚᱶᱟ ᱡᱤᱱᱤᱥ ᱠᱚ ᱨᱮ withTimeZone ᱯᱚᱛᱷᱟ ᱢᱮᱱᱟᱜ-ᱟ ᱚᱠᱟ ᱫᱚ ᱚᱠᱛᱚ ᱨᱮ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ᱱᱟᱶᱟ ZonedDateTime ᱨᱩᱣᱟᱹᱲ ᱮᱢᱟᱭᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱨᱮ᱾ // ᱫᱚᱦᱲᱟ, ᱟᱢᱮᱨᱤᱠᱟ ᱯᱩᱨᱩᱵ ᱚᱠᱛᱚ ᱢᱚᱱᱮ ᱠᱟᱛᱮ const ᱱᱤᱛᱚᱜ = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱡᱚᱱᱰᱮᱴ ᱴᱟᱭᱤᱢ ᱟᱭᱤ ᱮᱥ ᱳ (); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱘/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱑᱒:᱐᱒ ᱤ ᱮᱥ ᱴᱤ
// ᱯᱟᱥᱤᱯᱷᱤᱠ ᱚᱠᱛᱚ ᱨᱮ ᱵᱚᱫᱚᱞ ᱢᱮ const nowPacific = ᱱᱤᱛᱚᱜ ᱾ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱥᱟᱶᱛᱮ ('ᱟᱢᱮᱨᱤᱠᱟ/ᱞᱚᱥ_ᱮᱱᱡᱮᱞᱥ'); ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ ᱯᱟᱥᱤᱯᱷᱤᱠ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱘/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱕:᱑᱒:᱐᱒ ᱯᱤ ᱮᱥ ᱴᱤ
// ᱟᱥᱚᱞ ᱡᱤᱱᱤᱥ ᱵᱟᱝ ᱵᱚᱫᱚᱞ ᱟᱠᱟᱱᱟ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱱᱤᱛᱚᱜ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ()); // ᱒/᱒᱘/᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱑᱒:᱐᱒ ᱤ ᱮᱥ ᱴᱤ
ᱱᱚᱴ: ᱴᱚᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ ᱦᱚᱛᱮᱛᱮ ᱨᱩᱣᱟᱹᱲ ᱟᱠᱟᱱ ᱯᱷᱚᱨᱢᱮᱴ ᱵᱷᱮᱞᱭᱩ ᱠᱚ ᱫᱚ, ᱧᱩᱛᱩᱢ ᱞᱮᱠᱟ ᱜᱮ, ᱞᱚᱠᱮᱞ-ᱯᱚᱨᱛᱚᱱ ᱢᱮᱱᱟᱜᱼᱟ᱾ ᱥᱮᱢᱯᱩᱞ ᱠᱚᱰ ᱫᱚ ᱮᱱ-ᱭᱩᱮᱥ ᱞᱚᱠᱮᱞ ᱨᱮ ᱩᱛᱱᱟᱹᱣ ᱞᱮᱱᱟ, ᱚᱱᱟᱛᱮ ᱯᱨᱚᱨᱩᱢ ᱫᱚ ᱱᱚᱝᱠᱟ ᱜᱮᱭᱟ: ᱒/᱒᱘/᱒᱐᱒᱖, ᱕:᱑᱒:᱐᱒ ᱯᱤ ᱮᱢ ᱯᱤ ᱮᱥ ᱴᱤ᱾ ᱮᱴᱟᱜ ᱴᱚᱴᱷᱟ ᱨᱮ, ᱱᱚᱣᱟ ᱫᱚ ᱮᱴᱟᱜ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ, ᱮᱱ-ᱡᱤᱵᱤ ᱞᱚᱠᱮᱞ ᱨᱮ, ᱟᱢ ᱫᱚ ᱒᱘/᱒/᱒᱐᱒᱖, ᱑᱗:᱑᱒:᱐᱒ ᱡᱤ ᱮᱢ ᱴᱤ-᱘ ᱞᱮᱠᱟᱱ ᱡᱟᱦᱟᱱᱟᱜ ᱮᱢ ᱧᱟᱢᱟ᱾ ᱢᱤᱫ ᱥᱟᱹᱨᱤ-ᱫᱷᱟᱹᱨᱛᱤ ᱨᱤᱯᱷᱮᱠᱴᱚᱨᱤᱝ ᱢᱚᱱᱮ ᱢᱮ ᱟᱞᱮ ᱫᱚ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱤᱵᱷᱮᱱᱴ ᱥᱮᱰᱭᱩᱞᱤᱝ ᱞᱟᱹᱜᱤᱫ ᱢᱤᱫᱴᱮᱱ ᱮᱯ ᱞᱮ ᱵᱮᱱᱟᱣ ᱮᱫᱟ᱾ ᱱᱚᱶᱟ ᱮᱯ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱦᱟᱹᱴᱤᱧ ᱫᱚ ᱯᱷᱟᱱᱥᱚᱱ, getEventTimes, ᱡᱟᱦᱟᱸ ᱫᱚ ᱠᱟᱹᱢᱤ ᱨᱮᱭᱟᱜ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱦᱟᱸ, ᱢᱤᱫ ᱞᱚᱠᱟᱞ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ, ᱟᱨ ᱢᱤᱫ ᱴᱟᱨᱴ ᱚᱠᱛᱚ ᱡᱚᱱᱚᱲ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ISO 8601 ᱥᱴᱨᱤᱝ ᱞᱟᱜᱟᱣ ᱠᱟᱱᱟ᱾ ᱯᱷᱟᱱᱥᱚᱱ ᱫᱚ ᱵᱟᱱᱟᱨ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱜᱷᱚᱴᱚᱱ ᱞᱟᱹᱜᱤᱫ ᱯᱷᱚᱨᱢᱮᱴ ᱚᱠᱛᱚ ᱟᱨ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱵᱮᱱᱟᱣ ᱮᱫᱟᱭ ᱾ ᱡᱩᱫᱤ ᱯᱷᱟᱱᱥᱚᱱ ᱫᱚ ᱤᱱᱯᱩᱴ ᱥᱴᱨᱤᱝ ᱮᱢᱚᱜ ᱠᱟᱱᱟ ᱚᱱᱟ ᱫᱚ ᱢᱟᱱᱭᱟ ᱚᱠᱛᱚ/ᱢᱟᱦᱟᱸ ᱥᱴᱨᱤᱝ ᱵᱟᱝ ᱠᱟᱱᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱦᱩᱰᱟᱹᱜ ᱮ ᱪᱟᱯᱟᱫᱟ᱾ ᱱᱚᱸᱰᱮ ᱟᱥᱚᱞ ᱥᱟᱯᱲᱟᱣ ᱢᱮᱱᱟᱜᱼᱟ, ᱢᱚᱢᱮᱱᱴ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ (ᱢᱚᱢᱮᱱᱴ-ᱴᱟᱭᱤᱢᱡᱚᱱ ᱯᱮᱠᱮᱡᱽ ᱨᱮᱭᱟᱜ ᱵᱮᱵᱷᱟᱨ ᱦᱚᱸ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ)᱾
'ᱢᱚᱢᱮᱱᱴ-ᱴᱟᱭᱤᱢᱡᱚᱱ' ᱠᱷᱚᱱ ᱢᱩᱦᱩᱛ ᱟᱹᱜᱩ ᱢᱮ;
ᱯᱷᱟᱱᱥᱚᱱ ᱜᱮᱴ ᱤᱵᱷᱮᱱᱴ ᱴᱟᱭᱤᱢᱥ (ᱤᱱᱯᱩᱴ ᱥᱴᱨᱤᱝ, ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ, ᱴᱟᱨᱜᱮᱴ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ) { ᱠᱚᱱᱥᱴ ᱚᱠᱛᱚ ᱯᱷᱚᱨᱢᱮᱴ = 'ᱮᱢᱮᱢ ᱰᱤ, ᱣᱟᱭᱣᱟᱭ, ᱮᱪ: ᱮᱢᱮᱢ: ᱮᱥ ᱮᱥ ᱮ ᱡᱮᱰ';
// ᱑. ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱠᱚᱣᱟᱜ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱨᱮ ᱮᱛᱚᱦᱚᱵ ᱢᱩᱦᱩᱛ ᱵᱮᱱᱟᱣ ᱢᱮ const ᱤᱵᱷᱮᱱᱴᱴᱟᱭᱤᱢ = ᱢᱚᱢᱮᱱᱴ.ᱴᱤᱡᱽ( ᱤᱱᱯᱩᱴᱥᱴᱨᱤᱝ, ᱢᱚᱢᱮᱱᱴ᱾ ᱟᱭᱤ ᱮᱥ ᱳ_᱘᱖᱐᱑,// ᱢᱤᱫ ᱟᱭᱤ ᱮᱥ ᱳ ᱘᱖᱐᱑ ᱥᱴᱨᱤᱝ ᱨᱮᱭᱟᱜ ᱛᱟᱝᱜᱤ ᱢᱮ ᱥᱟᱹᱨᱤ, // ᱠᱮᱴᱮᱡ ᱯᱟᱨᱥᱤᱝ ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ );
// ᱡᱩᱫᱤ ᱤᱱᱯᱩᱴᱥᱴᱨᱤᱝ ᱢᱟᱱᱭᱟ ᱢᱟᱹᱦᱤᱛ ᱵᱟᱭ ᱩᱫᱩᱜ ᱠᱷᱟᱱ ᱢᱤᱫ ᱦᱩᱰᱟᱹᱜ ᱪᱟᱯᱟᱫ ᱢᱮ ᱡᱩᱫᱤ (! ᱜᱷᱚᱴᱚᱱ ᱚᱠᱛᱚ ᱾ ᱵᱮᱥ ᱜᱮᱭᱟ ()) { ᱱᱟᱶᱟ ᱦᱩᱰᱟᱹᱜ ᱪᱟᱯᱟᱫ ᱢᱮ ('ᱵᱟᱝ ᱴᱷᱤᱠ ᱢᱟᱹᱦᱤᱛ/ᱚᱠᱛᱚ ᱤᱱᱯᱩᱴ'); }
// ᱒. ᱡᱚᱥ ᱚᱠᱛᱚ ᱞᱮᱠᱷᱟᱭ ᱢᱮ // ᱠᱨᱤᱴᱤᱠᱟᱞ: ᱟᱵᱚ ᱫᱚ ᱠᱞᱚᱱ ᱦᱩᱭᱩᱜ ᱛᱟᱵᱚᱱᱟ, ᱵᱟᱝᱠᱷᱟᱱ 'ᱤᱣᱮᱱᱴᱴᱟᱭᱤᱢ' ᱫᱚ ᱞᱮᱛᱟᱲ ᱞᱟᱹᱜᱤᱫ ᱵᱚᱫᱚᱞᱚᱜᱼᱟ! const ᱴᱟᱨᱜᱮᱴᱴᱟᱭᱤᱢ = ᱤᱵᱷᱮᱱᱴᱴᱟᱭᱤᱢ.ᱠᱞᱚᱱ().ᱴᱤᱡᱽ(ᱴᱟᱨᱜᱮᱴᱴᱟᱭᱤᱢᱡᱚᱱ);
ᱨᱩᱣᱟᱹᱲ { ᱞᱚᱠᱟᱞ: ᱤᱵᱷᱮᱱᱴ ᱚᱠᱛᱚ᱾ ᱯᱷᱚᱨᱢᱮᱴ (ᱚᱠᱛᱚ ᱯᱷᱚᱨᱢᱮᱴ), ᱡᱚᱥ: ᱡᱚᱥ ᱚᱠᱛᱚ᱾ ᱯᱷᱚᱨᱢᱮᱴ (ᱚᱠᱛᱚ ᱯᱷᱚᱨᱢᱮᱴ), }; }
const ᱥᱮᱰᱭᱩᱞ = ᱜᱮᱴ ᱤᱵᱷᱮᱱᱴ ᱴᱟᱭᱤᱢᱥ ( '᱒᱐᱒᱖-᱐᱓-᱐᱕ᱴᱤ᱑᱕:᱐᱐-᱐᱕:᱐᱐', 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ', 'ᱭᱳᱨᱳᱯ/ᱞᱚᱱᱰᱚᱱ', );
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱥᱮᱰᱭᱩᱞ.ᱞᱚᱠᱟᱞ); // ᱢᱟᱨᱪ ᱕, ᱒᱐᱒᱖, ᱛᱟᱨᱟᱥᱤᱧ ᱓:᱐᱐:᱐᱐ ᱤ ᱮᱥ ᱴᱤ
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱥᱮᱰᱭᱩᱞ.ᱴᱟᱨᱜᱮᱴ); // ᱢᱟᱨᱪ ᱕, ᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱐᱐:᱐᱐ ᱡᱤ ᱮᱢ ᱴᱤ
ᱱᱚᱣᱟ ᱫᱟᱹᱭᱠᱟᱹ ᱨᱮ, ᱟᱞᱮ ᱫᱚ ISO 8601 ᱨᱮᱭᱟᱜ ᱟᱥᱟ ᱢᱟᱹᱦᱤᱛ ᱯᱨᱚᱨᱩᱢ ᱞᱮ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟ, ᱚᱠᱟ ᱫᱚ ᱢᱚᱢᱮᱱᱴ ᱨᱮ ᱜᱚᱲᱚ ᱞᱮᱠᱟ ᱛᱮ ᱵᱮᱱᱟᱣ ᱟᱠᱟᱱᱟ᱾ ᱟᱞᱮ ᱫᱚ ᱠᱮᱴᱮᱡ ᱯᱟᱨᱥᱤᱝ ᱦᱚᱸ ᱞᱮ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟ, ᱡᱟᱦᱟᱸ ᱨᱮᱭᱟᱜ ᱢᱮᱱᱮᱛ ᱫᱚ ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱥᱟᱶ ᱵᱟᱭ ᱟᱴᱠᱟᱨᱟ ᱚᱠᱟ ᱫᱚ ᱯᱨᱚᱨᱩᱢ ᱥᱟᱶ ᱵᱟᱝ ᱢᱤᱞᱟᱹᱣᱟ᱾ ᱡᱩᱫᱤ ᱢᱤᱫ ᱵᱟᱝ-ISO ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱯᱟᱥ ᱞᱮᱱᱠᱷᱟᱱ, ᱱᱚᱣᱟ ᱨᱮᱭᱟᱜ ᱚᱨᱡᱚ ᱫᱚ ᱵᱟᱝ ᱴᱷᱤᱠ ᱢᱟᱹᱦᱤᱛ ᱡᱤᱱᱤᱥ ᱦᱩᱭᱩᱜᱼᱟ, ᱟᱨ ᱟᱵᱚ ᱫᱚ ᱦᱩᱰᱟᱹᱜ ᱵᱚᱱ ᱪᱟᱯᱟᱫᱟ᱾ ᱚᱠᱛᱚ ᱥᱟᱯᱲᱟᱣ ᱥᱚᱢᱟᱱ ᱧᱮᱞᱚᱜ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱛᱤᱱᱟᱹᱜ ᱜᱟᱱ ᱢᱩᱲᱩᱫ ᱵᱷᱮᱜᱟᱨ ᱢᱮᱱᱟᱜᱼᱟ ᱾
ᱯᱷᱟᱱᱥᱚᱱ ᱜᱮᱴ ᱤᱵᱷᱮᱱᱴ ᱴᱟᱭᱤᱢᱥ (ᱤᱱᱯᱩᱴ ᱥᱴᱨᱤᱝ, ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ, ᱴᱟᱨᱜᱮᱴ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ) { // ᱑. ᱤᱱᱯᱩᱴ ᱥᱚᱡᱷᱮ ᱢᱤᱫ ᱨᱚᱠᱟ ᱨᱮ ᱯᱟᱨᱥ ᱢᱮ, ᱚᱱᱟ ᱛᱟᱭᱚᱢ ᱵᱮᱱᱟᱣ ᱢᱮ // ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱠᱚᱣᱟᱜ ᱡᱚᱱ ᱨᱮ ᱢᱤᱫ ᱡᱚᱱᱰᱰᱮᱴ ᱚᱠᱛᱚ ᱾ const instant = ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱤᱱᱥᱴᱟᱱᱴ ᱾ ᱠᱷᱚᱱ (ᱤᱱᱯᱩᱴᱥᱴᱨᱤᱝ); const eventTime = ᱤᱱᱥᱴᱟᱱᱴ.ᱴᱳᱡᱚᱱᱰᱰᱮᱴᱴᱟᱭᱤᱢISO(ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹᱴᱟᱭᱤᱢᱡᱚᱱ);
// ᱒. ᱡᱚᱥ ᱡᱚᱱ ᱨᱮ ᱵᱚᱫᱚᱞ ᱢᱮ // ᱱᱚᱣᱟ ᱟᱡ ᱛᱮ ᱢᱤᱫ ᱱᱟᱶᱟ ᱡᱤᱱᱤᱥ ᱮ ᱨᱩᱣᱟᱹᱲᱟ; 'ᱤᱵᱷᱮᱱᱴᱴᱟᱭᱤᱢ' ᱫᱚ ᱨᱚᱯᱟ ᱜᱮᱭᱟ ᱾ const ᱴᱟᱨᱜᱮᱴᱴᱟᱭᱤᱢ = ᱤᱵᱷᱮᱱᱴᱴᱟᱭᱤᱢ.ᱣᱤᱛᱷᱴᱟᱭᱤᱢᱡᱚᱱ(ᱴᱟᱨᱜᱮᱴᱴᱟᱭᱤᱢᱡᱚᱱ);
// ᱓. ᱤᱱᱴᱮᱞ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱛᱮ ᱯᱷᱚᱨᱢᱮᱴ (ᱵᱤᱞᱴ-ᱤᱱ) ᱠᱚᱱᱥᱴ ᱚᱯᱥᱚᱱᱥ = { ᱥᱮᱨᱢᱟ: 'ᱮᱞᱠᱷᱟ', ᱪᱟᱸᱫᱚ: 'ᱠᱷᱟᱴᱚ', ᱫᱤᱱ: 'ᱮᱞᱠᱷᱟ', ᱴᱟᱲᱟᱝ: 'ᱮᱞᱠᱷᱟ', ᱢᱤᱱᱤᱴ: '᱒-ᱰᱤᱡᱤᱴ', ᱫᱚᱥᱟᱨ: '᱒-ᱰᱤᱡᱤᱴ', ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱧᱩᱛᱩᱢ: 'ᱠᱷᱟᱴᱚ' };
ᱨᱩᱣᱟᱹᱲ { ᱞᱚᱠᱟᱞ: ᱤᱵᱷᱮᱱᱴᱴᱟᱭᱤᱢ.ᱴᱳᱞᱚᱠᱮᱞᱥᱴᱨᱤᱝ(ᱱᱮᱵᱷᱤᱜᱮᱴᱚᱨ.ᱯᱟᱹᱨᱥᱤ, ᱚᱯᱥᱚᱱᱥ), ᱡᱚᱥ: ᱡᱚᱥ ᱚᱠᱛᱚ᱾ ᱴᱳᱞᱚᱠᱮᱞ ᱥᱴᱨᱤᱝ (ᱱᱮᱵᱷᱤᱜᱮᱴᱚᱨ᱾ ᱯᱟᱹᱨᱥᱤ, ᱣᱤᱠᱟᱞᱯ) }; }
const ᱥᱮᱰᱭᱩᱞ = ᱜᱮᱴ ᱤᱵᱷᱮᱱᱴ ᱴᱟᱭᱤᱢᱥ ( '᱒᱐᱒᱖-᱐᱓-᱐᱕ᱴᱤ᱑᱕:᱐᱐-᱐᱕:᱐᱐', 'ᱟᱢᱮᱨᱤᱠᱟ/ᱱᱭᱩ_ᱭᱚᱨᱠ', 'ᱭᱳᱨᱳᱯ/ᱞᱚᱱᱰᱚᱱ', );
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱥᱮᱰᱭᱩᱞ.ᱞᱚᱠᱟᱞ); // ᱢᱟᱨᱪ ᱕, ᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱓:᱐᱐:᱐᱐ ᱤ ᱮᱥ ᱴᱤ
ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ(ᱥᱮᱰᱭᱩᱞ.ᱴᱟᱨᱜᱮᱴ); // ᱢᱟᱨᱪ ᱕, ᱒᱐᱒᱖, ᱟᱹᱭᱩᱵ ᱘:᱐᱐:᱐᱐ ᱡᱤ ᱮᱢ ᱴᱤ
ᱢᱚᱢᱮᱱᱴ ᱥᱟᱶᱛᱮ, ᱟᱵᱚ ᱫᱚ ᱚᱨᱡᱚ ᱢᱟᱹᱦᱤᱛ ᱥᱴᱨᱤᱝ ᱞᱟᱹᱜᱤᱫ ᱯᱩᱥᱴᱟᱹᱣ ᱛᱮ ᱢᱤᱫ ᱯᱷᱚᱨᱢᱟᱴ ᱥᱴᱨᱤᱝ ᱞᱟᱹᱭ ᱦᱩᱭᱩᱜ ᱛᱟᱵᱚᱱᱟ᱾ ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱠᱚᱣᱟᱜ ᱴᱷᱟᱶ ᱥᱮ ᱞᱚᱠᱮᱞ ᱵᱮᱜᱚᱨ ᱠᱟᱛᱮ, ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱚᱠᱛᱚ ᱥᱟᱨᱟ ᱜᱷᱟᱹᱲᱤᱡ ᱕ ᱢᱟᱨᱪ, ᱒᱐᱒᱖, ᱓:᱐᱐:᱐᱐ ᱞᱮᱠᱟ ᱯᱷᱚᱨᱢᱮᱴ ᱦᱩᱭᱩᱜᱼᱟᱟᱹᱭᱩᱵ ᱤ ᱮᱥ ᱴᱤ ᱟᱨᱦᱚᱸ, ᱟᱵᱚ ᱫᱚ ᱯᱩᱥᱴᱟᱹᱣ ᱛᱮ ᱮᱠᱥᱮᱯᱥᱚᱱ ᱵᱟᱝ ᱪᱟᱯᱟᱫ ᱦᱩᱭᱩᱜ ᱛᱟᱵᱚᱱᱟ᱾ ᱡᱩᱫᱤ ᱢᱤᱫ ᱵᱟᱝ ᱴᱷᱤᱠ ᱥᱴᱨᱤᱝ ᱴᱮᱢᱯᱚᱨᱟᱞ.ᱤᱱᱥᱴᱮᱱᱴ.ᱯᱷᱨᱚᱢ ᱨᱮ ᱯᱟᱥ ᱦᱩᱭᱩᱜ ᱠᱷᱟᱱ, ᱴᱮᱢᱯᱚᱨᱟᱞ ᱟᱵᱚ ᱞᱟᱹᱜᱤᱫ ᱮᱠᱥᱮᱯᱥᱚᱱ ᱮ ᱪᱟᱯᱟᱫᱟ᱾ ᱢᱤᱫ ᱠᱟᱛᱷᱟ ᱞᱟᱹᱭ ᱞᱟᱹᱠᱛᱤᱭᱟ ᱡᱮ ᱠᱮᱴᱮᱡ ᱯᱟᱨᱥᱤᱝ ᱛᱩᱞᱩᱡ ᱦᱚᱸ, ᱢᱚᱢᱮᱱᱴ ᱵᱷᱟᱨᱥᱚᱱ ᱫᱚ ᱱᱤᱛ ᱦᱚᱸ ᱟᱹᱰᱤ ᱞᱮᱵᱽᱲᱮᱡ ᱜᱮᱭᱟ ᱾ ᱚᱠᱛᱚ ᱞᱟᱹᱜᱤᱫ ᱥᱴᱨᱤᱝ ᱨᱮᱭᱟᱜ ᱢᱩᱪᱟᱹᱫ ᱨᱮ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱚᱯᱷᱥᱮᱴ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ ᱾ ᱟᱢ ᱱᱚᱶᱟ ᱦᱚᱸ ᱵᱟᱰᱟᱭ ᱢᱮ ᱡᱮ ᱟᱞᱮ ᱫᱚ navigator.language ᱞᱮ ᱵᱮᱵᱚᱦᱟᱨ ᱮᱫᱟ, ᱱᱚᱶᱟ ᱠᱚᱰ ᱫᱚ ᱥᱩᱢᱩᱝ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱯᱟᱨᱤᱵᱮᱥ ᱨᱮ ᱜᱮ ᱪᱟᱞᱟᱜ-ᱟ, ᱪᱮᱫᱟᱜ ᱥᱮ ᱱᱟᱣᱟ ᱫᱚ Node.js ᱯᱟᱨᱤᱵᱮᱥ ᱨᱮ ᱵᱟᱝ ᱵᱩᱡᱷᱟᱹᱣ ᱟᱠᱟᱱᱟ᱾ ᱚᱠᱛᱚ ᱞᱟᱹᱜᱤᱫ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮᱭᱟᱜ ᱱᱟᱦᱟᱜ ᱞᱚᱠᱮᱞ (navigator.language) ᱵᱮᱵᱚᱦᱟᱨᱚᱜ ᱠᱟᱱᱟ, ᱚᱱᱟ ᱛᱮ ᱵᱮᱵᱚᱦᱟᱨᱤᱭᱟᱹ ᱠᱚ ᱟᱡ ᱛᱮ ᱟᱠᱚᱣᱟᱜ ᱞᱚᱠᱟᱞ ᱚᱠᱛᱚ ᱨᱮ ᱯᱷᱚᱨᱢᱮᱴ ᱠᱚ ᱧᱟᱢᱟ᱾ ᱮᱱ-ᱭᱩᱮᱥ ᱞᱚᱠᱮᱞ ᱨᱮ, ᱱᱚᱣᱟ ᱫᱚ ᱕ ᱢᱟᱨᱪ, ᱒᱐᱒᱖, ᱛᱟᱨᱟᱥᱤᱧ ᱓ᱺ᱐᱐ᱺ᱐᱐ ᱤ ᱮᱥ ᱴᱤ ᱠᱟᱱᱟ ᱾ ᱢᱮᱱᱠᱷᱟᱱ, ᱡᱩᱫᱤ ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱞᱚᱱᱰᱚᱱ ᱨᱮ ᱢᱮᱱᱟᱭᱟ, ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮ, ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱚᱠᱛᱚ ᱕ ᱢᱟᱨᱪ ᱒᱐᱒᱖, ᱑᱕:᱐᱐:᱐᱐ ᱡᱤ ᱮᱢ ᱴᱤ-᱕ ᱞᱮᱠᱟ ᱯᱷᱚᱨᱢᱮᱴ ᱦᱩᱭᱩᱜᱼᱟ᱾ ᱥᱟᱨᱠᱟᱛᱷᱟ
ᱠᱟᱹᱢᱤ ᱢᱚᱢᱮᱱᱴ.ᱡᱮᱥ ᱚᱠᱛᱚ ᱞᱮᱠᱟᱱ ᱱᱤᱛᱚᱜ ᱚᱠᱛᱚ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ () ᱴᱮᱢᱯᱚᱨᱟᱞ ᱾ ᱱᱤᱛᱚᱜ ᱾ ᱡᱚᱱᱰᱰᱮᱴᱴᱟᱭᱤᱢ ᱟᱭᱤ ᱮᱥ ᱳ () ᱯᱟᱨᱥᱤᱝ ᱟᱭᱤ ᱮᱥ ᱳ ᱢᱩᱦᱩᱛ (ᱥᱴᱨ) ᱴᱮᱢᱯᱚᱨᱟᱞ᱾ ᱤᱱᱥᱴᱟᱱᱴ᱾ᱯᱷᱨᱚᱢ(ᱮᱥᱴᱟᱨ) ᱚᱠᱛᱚ ᱥᱮᱞᱮᱫ ᱢᱮ ᱾ ᱥᱮᱞᱮᱫ (᱗, 'ᱢᱟᱦᱟᱸ') (ᱢᱭᱩᱴᱮᱴᱥ) ᱾ ᱥᱮᱞᱮᱫ ({ ᱢᱟᱦᱟᱸ: ᱗ }) (ᱱᱟᱶᱟ ᱡᱤᱱᱤᱥ) ᱵᱷᱮᱜᱟᱨ ᱾ ᱵᱷᱮᱜᱟᱨ (ᱮᱴᱟᱜ, 'ᱴᱟᱲᱟᱝ') ᱾ ᱛᱟᱭᱚᱢ ᱠᱷᱚᱱ (ᱮᱴᱟᱜ) ᱴᱟᱲᱟᱝ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ .ᱴᱡᱽ('ᱡᱚᱱ/ᱧᱩᱛᱩᱢ') ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱥᱟᱶᱛᱮ ('ᱴᱚᱴᱷᱟ/ᱧᱩᱛᱩᱢ')
ᱢᱟᱲᱟᱝ ᱧᱮᱞ ᱨᱮ, ᱵᱮᱜᱟᱨ ᱫᱚ ᱱᱟᱥᱮ ᱵᱷᱮᱜᱟᱨ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ (ᱟᱨ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱨᱮ, ᱚᱠᱟ ᱚᱠᱟ ᱫᱚ ᱵᱟᱹᱲᱛᱤ ᱥᱟᱵᱟᱫᱽ ᱟᱨ ᱵᱟᱹᱲᱛᱤ ᱠᱮᱴᱮᱡ) ᱥᱤᱱᱴᱮᱠᱥ, ᱢᱮᱱᱠᱷᱟᱱ Moment.js ᱪᱮᱛᱟᱱ ᱨᱮ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱵᱮᱵᱷᱟᱨ ᱨᱮ ᱟᱭᱢᱟ ᱢᱩᱲᱩᱫ ᱵᱷᱟᱹᱜᱤ ᱢᱮᱱᱟᱜᱼᱟ:
ᱵᱟᱹᱲᱛᱤ ᱯᱩᱥᱴᱟᱹᱣ ᱛᱟᱦᱮᱱ ᱨᱮᱭᱟᱜ ᱢᱮᱱᱮᱛ ᱫᱚ ᱠᱚᱢ ᱦᱟᱦᱟᱲᱟ ᱟᱨ ᱵᱤᱱ ᱡᱚᱥ ᱛᱤᱡᱩ ᱠᱚ ᱾ ᱢᱩᱦᱩᱫ ᱫᱚ ᱟᱹᱰᱤ ᱞᱮᱵᱽᱲᱮᱡ ᱞᱮᱠᱟ ᱧᱮᱞᱚᱜ-ᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱣᱟ ᱨᱮ “ᱟᱱᱩᱢᱟᱱ ᱠᱟᱹᱢᱤ” ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜ-ᱟ, ᱚᱠᱟ ᱫᱚ ᱚᱠᱟ ᱚᱠᱟ ᱫᱚ ᱵᱷᱩᱞ ᱢᱟᱹᱦᱤᱛ ᱠᱚ ᱧᱟᱢ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱡᱩᱫᱤ ᱟᱢ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱡᱟᱦᱟᱱᱟᱜ ᱵᱟᱝ ᱴᱷᱤᱠ ᱮᱢᱟᱭᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱦᱩᱰᱟᱹᱜ ᱮ ᱪᱟᱯᱟᱫᱟ᱾ ᱡᱩᱫᱤ ᱠᱚᱰ ᱪᱟᱹᱞᱩᱜ ᱠᱟᱱᱟ, ᱟᱢ ᱵᱟᱲᱟᱭᱟᱢ ᱟᱢ ᱴᱷᱮᱱ ᱢᱟᱱᱭᱟ ᱢᱟᱹᱦᱤᱛ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱢᱚᱢᱮᱱᱴ ᱫᱚ ᱮᱯᱞᱤᱠᱮᱥᱚᱱ ᱨᱮᱭᱟᱜ ᱵᱟᱱᱰᱮᱞ ᱨᱮ ᱞᱟᱹᱠᱛᱤᱭᱟᱱ ᱜᱚᱲᱦᱚᱱ ᱥᱮᱞᱮᱫ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱠᱷᱟᱥ ᱠᱟᱭᱛᱮ ᱡᱩᱫᱤ ᱟᱢ ᱢᱚᱢᱮᱱᱴ-ᱴᱟᱭᱤᱢᱡᱚᱱ ᱯᱮᱠᱮᱡᱽ ᱮᱢ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟ᱾ ᱚᱠᱛᱚ ᱫᱚ ᱪᱮᱫ ᱦᱚᱸ ᱵᱟᱭ ᱥᱮᱞᱮᱫᱟ (ᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱢᱟᱜ ᱡᱚᱥ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮ ᱠᱩᱞ ᱞᱮᱱᱠᱷᱟᱱ)᱾ ᱤᱢᱩᱴᱮᱵᱤᱞᱤᱴᱤ ᱫᱚ ᱟᱢ ᱯᱟᱹᱛᱤᱭᱟᱹᱣ ᱮᱢᱟᱢᱟ ᱡᱮ ᱟᱢ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱵᱚᱫᱚᱞ ᱟᱨ ᱚᱯᱟᱨᱮᱥᱚᱱ ᱠᱚ ᱠᱚᱨᱟᱣ ᱚᱠᱛᱮ ᱛᱤᱥ ᱦᱚᱸ ᱰᱟᱴᱟ ᱵᱟᱢ ᱟᱫ ᱟᱨ ᱵᱟᱢ ᱚᱞ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱟᱢᱟᱜ ᱞᱟᱹᱠᱛᱤ ᱞᱮᱠᱟᱛᱮ ᱚᱠᱛᱚ ᱨᱮᱭᱟᱜ ᱡᱩᱫᱟᱹ ᱡᱩᱫᱟᱹ ᱩᱫᱩᱜ (Instant, PlainDateTime, ZonedDateTime), ᱡᱟᱦᱟᱸ ᱨᱮ Moment ᱫᱚ ᱥᱟᱨᱟ ᱜᱷᱟᱹᱲᱤᱡ ᱢᱤᱫ UTC ᱚᱠᱛᱚ ᱥᱴᱟᱢᱯ ᱨᱮ ᱢᱤᱫ ᱨᱮᱯᱟᱨ ᱠᱟᱱᱟ᱾ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱫᱚ ᱢᱟᱹᱦᱤᱛ ᱯᱷᱚᱨᱢᱮᱴᱤᱝ ᱞᱟᱹᱜᱤᱫ Intl APIs ᱠᱚ ᱵᱮᱵᱚᱦᱟᱨ ᱮᱫᱟ, ᱡᱟᱦᱟᱸ ᱨᱮᱭᱟᱜ ᱢᱮᱱᱮᱛ ᱫᱚ ᱟᱢ ᱫᱚ ᱴᱚᱠᱚᱱ ᱵᱟᱝ ᱵᱩᱡᱷᱟᱹᱣ ᱠᱟᱛᱮ ᱞᱚᱠᱮᱞ-ᱟᱣᱟᱨ ᱯᱷᱚᱨᱢᱮᱴᱤᱝ ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾
ᱯᱚᱞᱤᱯᱷᱤᱞ ᱨᱮ ᱱᱚᱴ ᱠᱚ ᱢᱟᱲᱟᱝ ᱨᱮ ᱞᱟᱹᱭ ᱟᱠᱟᱱ ᱞᱮᱠᱟ, ᱢᱤᱫ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱯᱚᱞᱤᱯᱷᱤᱞ ᱢᱮᱱᱟᱜᱼᱟ, ᱚᱱᱟ ᱫᱚ @js-temporal/polyfill ᱧᱩᱛᱩᱢ ᱛᱮ npm ᱯᱮᱠᱮᱡᱽ ᱞᱮᱠᱟᱛᱮ ᱦᱟᱴᱤᱱᱜ ᱠᱟᱱᱟ᱾ ᱡᱩᱫᱤ ᱟᱢ ᱛᱮᱦᱮᱧ ᱴᱮᱢᱯᱚᱨᱟᱞ ᱵᱮᱵᱷᱟᱨ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ, ᱟᱢ ᱫᱚ ᱱᱚᱶᱟ ᱯᱚᱞᱤᱯᱷᱤᱞ ᱥᱟᱯᱷᱟᱨᱤ ᱞᱮᱠᱟᱱ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱠᱚ ᱥᱟᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ ᱚᱠᱟ ᱫᱚ ᱱᱤᱛ ᱦᱚᱸ API ᱵᱟᱝ ᱥᱤᱯ ᱟᱠᱟᱫᱟ᱾ ᱱᱚᱣᱟ ᱥᱟᱶ ᱵᱟᱹᱲᱤᱡ ᱠᱷᱚᱵᱚᱨ ᱫᱚ ᱱᱚᱣᱟ ᱠᱟᱱᱟ ᱡᱮ ᱱᱚᱣᱟ ᱟᱢᱟᱜ ᱵᱟᱱᱰᱮᱞ ᱥᱟᱭᱤᱡᱽ ᱨᱮ ᱥᱮᱞᱮᱫᱚᱜᱼᱟ ᱾ ᱱᱟᱯᱟᱭ ᱠᱷᱚᱵᱚᱨ ᱫᱚ ᱱᱚᱶᱟ ᱠᱟᱱᱟ ᱡᱮ ᱱᱚᱶᱟ ᱱᱤᱛ ᱦᱚᱸ ᱢᱩᱦᱩᱛ ᱥᱮ ᱢᱩᱦᱩᱛ ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱠᱷᱚᱱ ᱟᱹᱰᱤ ᱠᱚᱢ ᱥᱮᱞᱮᱫ ᱢᱮᱱᱟᱜᱼᱟ᱾ ᱱᱚᱸᱰᱮ ᱵᱟᱱᱰᱮᱞ ᱜᱚᱲᱦᱚᱱ ᱨᱮᱭᱟᱜ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱮᱞᱠᱟ Bundlephobia.com ᱦᱚᱛᱮᱛᱮ ᱨᱤᱯᱚᱨᱴ ᱟᱠᱟᱱᱟ, ᱢᱤᱫ ᱣᱮᱵᱽᱥᱟᱭᱤᱴ ᱡᱟᱦᱟᱸ ᱫᱚ npm ᱯᱮᱠᱮᱡᱽ ᱜᱚᱲᱦᱚᱱ ᱨᱮᱭᱟᱜ ᱵᱟᱯᱟᱰᱟᱭ ᱥᱚᱫᱚᱨ ᱮᱫᱟ (ᱵᱟᱱᱰᱮᱞᱯᱷᱚᱵᱤᱭᱟ ᱵᱤᱰᱟᱹᱣ ᱧᱮᱞ ᱞᱟᱹᱜᱤᱫ ᱥᱟᱱᱟᱢ ᱯᱮᱠᱮᱡᱽ ᱧᱩᱛᱩᱢ ᱨᱮ ᱞᱤᱱ ᱢᱮ):
ᱯᱮᱠᱮᱡᱽ ᱢᱤᱱᱤᱯᱷᱟᱭᱤᱰ ᱢᱤᱱᱤᱯᱷᱟᱭᱤᱰ ᱟᱨ ᱡᱤᱡᱤᱯ @ᱡᱮᱥ-ᱴᱮᱢᱯᱚᱨᱟᱞ/ᱯᱚᱞᱤᱯᱷᱤᱞ ᱑᱕᱔.᱑ ᱠᱮᱵᱤ ᱔᱔.᱑ ᱠᱮᱵᱤ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ ᱒᱙᱔.᱔ ᱠᱮᱵᱤ ᱗᱕.᱔ ᱠᱮᱵᱤ ᱢᱩᱦᱩᱛ-ᱚᱠᱛᱚ ᱴᱚᱴᱷᱟ ᱑ ᱮᱢᱵᱤ ᱑᱑᱔.᱒ ᱠᱮᱵᱤ
ᱯᱚᱞᱤᱯᱷᱤᱞ ᱨᱮ ᱦᱚᱸ ᱱᱟᱜᱟᱢ ᱞᱮᱠᱟᱛᱮ ᱢᱮᱢᱚᱨᱤ ᱵᱮᱵᱚᱦᱟᱨ ᱨᱮ ᱟᱫᱚᱢ ᱠᱟᱹᱢᱤ ᱠᱚ ᱢᱮᱱᱟᱜ-ᱟ, ᱟᱨ ᱚᱞ ᱚᱠᱛᱮ ᱨᱮ ᱱᱚᱶᱟ ᱫᱚ ᱟᱞᱯᱷᱟ ᱥᱴᱮᱴ ᱨᱮ ᱢᱮᱱᱟᱜ-ᱟ᱾ ᱱᱚᱣᱟ ᱠᱷᱟᱹᱛᱤᱨ, ᱟᱢ ᱫᱚ ᱱᱚᱣᱟ ᱯᱨᱚᱰᱟᱠᱥᱚᱱ ᱨᱮ ᱵᱟᱝ ᱵᱮᱵᱷᱟᱨ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ ᱛᱤᱱ ᱦᱟᱹᱵᱤᱡ ᱱᱚᱣᱟ ᱵᱟᱹᱲᱛᱤ ᱯᱟᱠᱷᱟ ᱚᱵᱚᱥᱛᱟ ᱨᱮ ᱵᱟᱝ ᱥᱮᱴᱮᱨᱚᱜᱼᱟ ᱾ ᱮᱴᱟᱜ ᱱᱟᱯᱟᱭ ᱠᱷᱚᱵᱚᱨ ᱫᱚ ᱱᱚᱶᱟ ᱠᱟᱱᱟ ᱡᱮ ᱟᱥᱟ ᱢᱮᱱᱟᱜᱼᱟ ᱯᱚᱞᱤᱯᱷᱤᱞ ᱫᱚ ᱟᱹᱰᱤ ᱜᱷᱟᱹᱲᱤᱡ ᱵᱟᱝ ᱞᱟᱹᱠᱛᱤᱭᱟ (ᱡᱩᱫᱤ ᱟᱢ ᱢᱟᱨᱮ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱥᱟᱯᱚᱨᱴ ᱞᱟᱹᱠᱛᱤ ᱵᱟᱝ ᱦᱩᱭᱩᱜ-ᱟ, ᱥᱟᱨᱤ ᱜᱮ)᱾ ᱚᱞ ᱚᱠᱛᱚ ᱨᱮ, ᱴᱮᱢᱯᱚᱨᱟᱞ ᱠᱨᱚᱢ, ᱮᱡᱽ ᱟᱨ ᱯᱷᱟᱭᱟᱨᱯᱷᱚᱠᱥ ᱨᱮ ᱠᱩᱞ ᱟᱠᱟᱱᱟ ᱾ ᱱᱚᱶᱟ ᱫᱚ ᱱᱤᱛ ᱦᱚᱸ ᱥᱟᱯᱟᱨᱤ ᱨᱮ ᱵᱟᱝ ᱥᱟᱯᱲᱟᱣ ᱟᱠᱟᱱᱟ, ᱡᱩᱫᱤ ᱦᱚᱸ ᱱᱚᱶᱟ ᱫᱚ ᱱᱟᱶᱟ ᱴᱮᱠᱱᱚᱞᱚᱡᱤ ᱯᱨᱤᱵᱷᱤᱭᱩ ᱨᱮ ᱨᱟᱱᱴᱟᱭᱤᱢ ᱯᱷᱞᱟᱜᱽ ᱥᱟᱶᱛᱮ ᱧᱟᱢᱚᱜ ᱠᱟᱱᱟ᱾
