ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇꯇꯥ ꯏꯕꯥ ꯆꯥꯎꯔꯥꯛꯅꯥ ꯃꯈꯜ ꯑꯃꯠꯇꯒꯤ ꯑꯦꯞꯂꯤꯀꯦꯁꯟ ꯑꯁꯤ ꯀꯦꯄꯥꯁꯤꯇꯤ ꯈꯔꯗꯥ ꯃꯇꯝ ꯅꯠꯔꯒꯥ ꯇꯥꯡꯁꯤꯡꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯊꯕꯛ ꯇꯧꯏ꯫ ꯍꯧꯔꯀꯄꯗꯥ ꯃꯁꯤ ꯕꯤꯜꯇ-ꯏꯟ ꯗꯦꯠ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ. ꯃꯁꯤꯒꯤ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯗꯥ ꯕꯦꯁꯤꯛ ꯐꯉ꯭ꯀꯁꯅꯦꯂꯤꯇꯤ ꯌꯥꯑꯣꯔꯤ, ꯑꯗꯨꯕꯨ ꯃꯁꯤꯅꯥ ꯇꯧꯕꯥ ꯉꯝꯕꯁꯤꯡꯗꯥ ꯌꯥꯝꯅꯥ ꯂꯤꯃꯤꯇꯦꯗ ꯑꯣꯏ꯫ Moment.jsꯒꯨꯝꯕꯥ ꯊꯥꯔꯗ ꯄꯥꯔꯇꯤ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤꯁꯤꯡ, ꯑꯃꯁꯨꯡ ꯃꯇꯨꯡ ꯇꯥꯔꯀꯄꯗꯥ Intl APIꯁꯤꯡ ꯑꯃꯁꯨꯡ ꯑꯅꯧꯕꯥ Temporal APIꯒꯨꯝꯕꯥ ꯕꯤꯜꯇ-ꯏꯟ APIꯁꯤꯡꯅꯥ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡꯁꯤꯡꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯊꯕꯛ ꯇꯧꯕꯗꯥ ꯌꯥꯝꯅꯥ ꯍꯦꯟꯅꯥ ꯐ꯭ꯂꯦꯛꯁꯤꯕꯤꯂꯤꯇꯤ ꯍꯥꯄꯆꯤꯜꯂꯤ꯫ ꯗ ꯔꯥꯏꯖ ꯑꯦꯟꯗ ꯐꯣꯜ ꯑꯣꯐ ꯃꯣꯃꯦꯟꯇ.ꯖꯦ.ꯑꯦꯁ Moment.js ꯑꯁꯤ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯊꯕꯛ ꯇꯧꯅꯕꯒꯤꯗꯃꯛ ꯁꯛꯇꯤ ꯂꯩꯕꯥ ꯌꯨꯇꯤꯂꯤꯇꯤꯁꯤꯡ ꯂꯩꯕꯥ ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯃꯅꯤ꯫ ꯃꯁꯤꯗꯥ ꯕꯦꯁꯤꯛ ꯗꯦꯠ APIꯗꯒꯤ ꯃꯥꯡꯈꯤꯕꯥ ꯐꯤꯆꯔꯁꯤꯡ, ꯍꯥꯌꯕꯗꯤ ꯇꯥꯏꯝ ꯖꯣꯟ ꯃꯦꯅꯤꯄꯨꯂꯦꯁꯅꯒꯨꯝꯕꯥ ꯌꯥꯑꯣꯔꯤ, ꯑꯃꯁꯨꯡ ꯀꯃꯟ ꯑꯣꯏꯕꯥ ꯑꯣꯄꯔꯦꯁꯟ ꯀꯌꯥ ꯍꯦꯟꯅꯥ ꯂꯥꯏꯊꯣꯀꯍꯜꯂꯤ꯫ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤꯅꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯃꯁꯤꯡ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯅꯕꯒꯤ ꯐꯉ꯭ꯀꯁꯅꯁꯤꯡꯁꯨ ꯌꯥꯑꯣꯔꯤ꯫ ꯃꯁꯤ ꯇꯣꯉꯥꯟ ꯇꯣꯉꯥꯅꯕꯥ ꯑꯦꯞꯂꯤꯀꯦꯁꯟ ꯀꯌꯥꯗꯥ ꯄꯥꯛ ꯁꯟꯅꯥ ꯁꯤꯖꯤꯟꯅꯕꯥ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯃꯥ ꯑꯣꯏꯔꯀꯈꯤ꯫ ꯑꯗꯨꯕꯨ ꯃꯣꯃꯦꯟꯇꯀꯤꯁꯨ ꯏꯁꯨꯁꯤꯡꯒꯤ ꯁꯔꯨꯛ ꯑꯃꯥ ꯂꯩꯈꯤ꯫ ꯃꯁꯤ ꯑꯆꯧꯕꯥ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯃꯅꯤ, ꯑꯃꯁꯨꯡ ꯑꯦꯞꯂꯤꯀꯦꯁꯟ ꯑꯃꯒꯤ ꯕꯟꯗꯜ ꯁꯥꯏꯖꯗꯥ ꯃꯁꯛ ꯊꯣꯛꯅꯥ ꯍꯥꯄꯆꯤꯅꯕꯥ ꯌꯥꯏ꯫ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯁꯤꯅꯥ ꯎ ꯁꯦꯡꯗꯣꯀꯄꯥ (ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤꯁꯤꯡꯒꯤ ꯁꯤꯖꯤꯟꯅꯗꯕꯥ ꯁꯔꯨꯀꯁꯤꯡ ꯂꯧꯊꯣꯀꯄꯥ ꯉꯝꯕꯥ ꯃꯣꯗꯔꯟ ꯕꯟꯗꯂꯔꯁꯤꯡꯒꯤ ꯃꯁꯛ ꯑꯃꯥ) ꯁꯄꯣꯔꯠ ꯇꯧꯗꯕꯅꯥ ꯃꯔꯝ ꯑꯣꯏꯗꯨꯅꯥ, ꯅꯍꯥꯛꯅꯥ ꯃꯁꯤꯒꯤ ꯐꯉ꯭ꯀꯁꯟ ꯑꯃꯥ ꯅꯠꯠꯔꯒꯥ ꯑꯅꯤ ꯈꯛꯇꯃꯛ ꯁꯤꯖꯤꯟꯅꯔꯕꯁꯨ ꯃꯣꯃꯦꯟꯇ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯄꯨꯝꯅꯃꯛ ꯌꯥꯑꯣꯔꯤ꯫ ꯃꯣꯃꯦꯟꯇꯀꯤ ꯑꯇꯣꯞꯄꯥ ꯋꯥꯐꯝ ꯑꯃꯅꯥ ꯃꯁꯤꯅꯥ ꯁꯦꯃꯒꯠꯄꯥ ꯄꯣꯠꯁꯀꯁꯤꯡ ꯑꯁꯤ ꯃ꯭ꯌꯨꯇꯦꯕꯜ ꯑꯣꯏꯕꯅꯤ꯫ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯗꯥ ꯑꯀꯛꯅꯕꯥ ꯐꯉ꯭ꯀꯁꯅꯁꯤꯡ ꯀꯧꯕꯅꯥ ꯁꯥꯏꯗ ꯏꯐꯦꯛꯇ ꯂꯩ ꯑꯃꯁꯨꯡ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨꯒꯤ ꯚꯦꯜꯌꯨ ꯑꯗꯨ ꯃ꯭ꯌꯨꯇꯦꯁꯟ ꯇꯧꯏ꯫ ꯃꯁꯤꯅꯥ ꯊꯥꯖꯗꯕꯥ ꯂꯃꯆꯠ-ꯁꯥꯖꯠ ꯅꯠꯠꯔꯒꯥ ꯕꯥꯒꯁꯤꯡ ꯊꯣꯀꯍꯅꯕꯥ ꯌꯥꯏ꯫ ꯲꯰꯲꯰ꯗꯥ ꯃꯣꯃꯦꯟꯇꯀꯤ ꯃꯦꯟꯇꯦꯅꯔꯁꯤꯡꯅꯥ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯁꯤ ꯃꯦꯟꯇꯦꯅꯦꯟꯁ ꯃꯣꯗꯇꯥ ꯊꯝꯅꯕꯥ ꯋꯥꯔꯦꯞ ꯂꯧꯈꯤ꯫ ꯑꯅꯧꯕꯥ ꯐꯤꯆꯔ ꯗꯤꯕꯦꯂꯄꯃꯦꯟꯇ ꯑꯃꯠꯇꯥ ꯇꯧꯗ꯭ꯔꯤ, ꯑꯃꯁꯨꯡ ꯃꯦꯟꯇꯦꯅꯔꯁꯤꯡꯅꯥ ꯃꯁꯤ ꯑꯅꯧꯕꯥ ꯄ꯭ꯔꯣꯖꯦꯛꯇꯁꯤꯡꯒꯤꯗꯃꯛꯇꯥ ꯁꯤꯖꯤꯟꯅꯗꯅꯕꯥ ꯄꯥꯎꯇꯥꯛ ꯄꯤꯔꯤ꯫ ꯑꯇꯣꯞꯄꯥ ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇꯀꯤ ꯇꯥꯡ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤꯁꯤꯡ ꯂꯩ, ꯍꯥꯌꯕꯗꯤ date-fns, ꯑꯗꯨꯕꯨ ꯁꯍꯔꯗꯥ ꯑꯅꯧꯕꯥ ꯄ꯭ꯂꯦꯌꯥꯔ ꯑꯃꯥ ꯂꯩ, ꯃꯁꯤ ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇꯇꯥ ꯍꯀꯊꯦꯡꯅꯅꯥ ꯁꯦꯝꯕꯥ API ꯑꯃꯅꯤ: ꯇꯦꯝꯄꯣꯔꯦꯜ꯫ ꯃꯁꯤ ꯑꯅꯧꯕꯥ ꯁ꯭ꯇꯦꯟꯗꯔꯗ ꯑꯃꯅꯤ ꯃꯁꯤꯅꯥ ꯑꯔꯤꯕꯥ ꯗꯦꯠ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯒꯤ ꯍꯣꯂꯁꯤꯡ ꯃꯄꯨꯡ ꯐꯥꯍꯅꯕꯇꯥ ꯅꯠꯇꯅꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯃꯁꯨꯡ ꯑꯇꯣꯞꯄꯥ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤꯁꯤꯡꯗꯥ ꯐꯪꯂꯤꯕꯥ ꯂꯤꯃꯤꯇꯦꯁꯟ ꯈꯔꯗꯤ ꯀꯣꯀꯍꯜꯂꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯍꯥꯌꯕꯁꯤ ꯀꯔꯤꯅꯣ? ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯁꯤ ꯃꯣꯗꯔꯟ ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇ ꯗꯤꯐꯥꯏꯟ ꯇꯧꯔꯤꯕꯥ ꯏ.ꯁꯤ.ꯑꯦꯝ.ꯑꯦ.ꯁ꯭ꯛꯔꯤꯞꯇ ꯁ꯭ꯇꯦꯟꯗꯔꯗꯇꯥ ꯍꯥꯄꯆꯤꯜꯂꯀꯄꯥ ꯑꯅꯧꯕꯥ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡ API ꯑꯃꯅꯤ꯫ ꯃꯥꯔꯆ ꯲꯰꯲꯶꯶ ꯐꯥꯑꯣꯕꯗꯥ, ꯃꯁꯤꯅꯥ ꯇꯤ.ꯁꯤ.꯳꯹ ꯄ꯭ꯔꯣꯁꯦꯁꯀꯤ ꯁ꯭ꯇꯦꯖ ꯴ꯗꯥ ꯌꯧꯔꯦ (ꯖꯥꯚꯥꯁ꯭ꯛꯔꯤꯞꯇ ꯂꯣꯂꯗꯥ ꯄ꯭ꯔꯄꯣꯖꯦꯂꯁꯤꯡ ꯑꯃꯁꯨꯡ ꯑꯦꯗꯤꯁꯅꯁꯤꯡ ꯌꯦꯡꯁꯤꯜꯂꯤꯕꯥ ꯀꯝꯃꯤꯇꯤ), ꯑꯃꯁꯨꯡ ꯏ.ꯁꯤ.ꯑꯦꯝ.ꯑꯦ.ꯁ꯭ꯛꯔꯤꯞꯇ ꯁ꯭ꯄꯦꯁꯤꯐꯤꯀꯦꯁꯅꯒꯤ ꯃꯊꯪꯒꯤ ꯚꯔꯖꯅꯗꯥ ꯌꯥꯑꯣꯒꯅꯤ꯫ ꯃꯁꯤ ꯍꯥꯟꯅꯅꯥ ꯕ꯭ꯔꯥꯎꯖꯔ ꯀꯌꯥꯗꯥ ꯏꯃꯞꯂꯤꯃꯦꯟꯇ ꯇꯧꯈ꯭ꯔꯦ: ꯀ꯭ꯔꯣꯝ ꯱꯴꯴+ ꯑꯃꯁꯨꯡ ꯐꯥꯏꯔꯐꯛꯁ ꯱꯳꯹+, ꯃꯁꯤꯒꯤ ꯃꯇꯨꯡꯗꯥ ꯁꯥꯐꯥꯔꯤꯅꯥ ꯑꯊꯨꯕꯥ ꯃꯇꯃꯗꯥ ꯂꯥꯛꯀꯅꯤ ꯍꯥꯌꯅꯥ ꯄꯥꯅꯔꯤ꯫ ꯁꯄꯣꯔꯠ ꯇꯧꯗꯕꯥ ꯕ꯭ꯔꯥꯎꯖꯔꯁꯤꯡ ꯑꯃꯁꯨꯡ Node.jsꯒꯤꯗꯃꯛꯇꯁꯨ ꯄꯣꯂꯤꯐꯤꯜ ꯑꯃꯥ ꯐꯪꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯅꯥ, ꯃꯍꯧꯁꯥꯅꯥ, ꯃꯇꯃꯒꯤ ꯃꯣꯃꯦꯟꯇꯃꯁꯤꯡ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯕꯥ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯁꯦꯝꯃꯤ꯫ ꯍꯥꯌꯔꯤꯕꯁꯤꯡ ꯑꯁꯤ ꯑꯄꯤꯕꯥ ꯃꯇꯃꯒꯤ ꯖꯣꯟ ꯑꯃꯗꯥ ꯐꯨꯜ-ꯇꯥꯏꯝ ꯑꯃꯁꯨꯡ ꯗꯦꯠ ꯁ꯭ꯇꯦꯝꯄꯁꯤꯡ ꯑꯣꯏꯕꯥ ꯌꯥꯏ, ꯅꯠꯠꯔꯒꯥ ꯃꯈꯣꯌ ꯑꯁꯤ ꯇꯥꯏꯝ ꯖꯣꯟ ꯅꯠꯠꯔꯒꯥ ꯇꯥꯡꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯑꯃꯠꯇꯥ ꯌꯥꯎꯗꯅꯥ “ꯋꯥꯜ ꯀ꯭ꯂꯣꯛ” ꯃꯇꯃꯒꯤ ꯖꯦꯅꯦꯔꯦꯜ ꯏꯟꯁꯇꯦꯟꯁ ꯑꯃꯥ ꯑꯣꯏꯕꯥ ꯌꯥꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯒꯤ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯃꯁꯛ ꯈꯔꯗꯤ ꯃꯈꯥꯗꯥ ꯄꯤꯔꯤ:
ꯇꯥꯡ ꯂꯩꯕꯥ ꯅꯠꯠꯔꯒꯥ ꯂꯩꯇꯕꯥ ꯃꯇꯃꯁꯤꯡ꯫ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯅꯥ ꯑꯀꯛꯅꯕꯥ ꯇꯥꯡ ꯑꯃꯗꯥ ꯑꯀꯛꯅꯕꯥ ꯃꯇꯝ ꯑꯃꯥ, ꯅꯠꯠꯔꯒꯥ ꯇꯥꯡꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯑꯃꯠꯇꯥ ꯂꯩꯇꯕꯥ ꯃꯇꯝ ꯑꯃꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ ꯑꯀꯛꯅꯕꯥ ꯇꯥꯡ ꯑꯃꯥ, ꯃꯇꯝ ꯑꯃꯠꯇꯥ ꯌꯥꯑꯣꯗꯅꯥ, ꯔꯤꯞꯔꯗꯛꯇ ꯇꯧꯕꯁꯨ ꯌꯥꯏ꯫ ꯇꯥꯏꯝ ꯖꯣꯟ ꯁꯄꯣꯔꯠ꯫ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯁꯤ ꯃꯄꯨꯡꯐꯥꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯦꯋꯥꯔ ꯑꯣꯏ ꯑꯃꯁꯨꯡ ꯇꯣꯉꯥꯟ-ꯇꯣꯉꯥꯅꯕꯥ ꯇꯥꯏꯝ ꯖꯣꯅꯁꯤꯡꯒꯤ ꯃꯔꯛꯇꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ ꯌꯥꯏ꯫ ꯃꯣꯃꯦꯟꯇꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯅꯁꯤꯡꯁꯨ ꯁꯄꯣꯔꯠ ꯇꯧꯏ, ꯑꯗꯨꯕꯨ ꯃꯁꯤꯗꯥ ꯑꯍꯦꯅꯕꯥ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯃꯊꯧ ꯇꯥꯏ꯫ ꯏꯝꯌꯨꯇꯦꯕꯤꯂꯤꯇꯤ.ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯂꯕꯥ ꯃꯇꯨꯡꯗꯥ ꯃꯗꯨ ꯍꯣꯡꯗꯣꯀꯄꯥ ꯌꯥꯔꯣꯏ꯫ ꯃꯇꯃꯒꯤ ꯑꯦꯔꯤꯊꯃꯦꯇꯤꯛ ꯅꯠꯠꯔꯒꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯀꯟꯕꯔꯁꯅꯁꯤꯡꯅꯥ ꯑꯟꯗꯔꯂꯥꯏꯟ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨ ꯃꯣꯗꯤꯐꯥꯏ ꯇꯧꯗꯦ꯫ ꯃꯗꯨꯒꯤ ꯃꯍꯨꯠꯇꯥ ꯃꯈꯣꯌꯅꯥ ꯑꯅꯧꯕꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯃꯤ꯫ ꯱ꯗꯥ ꯌꯨꯝꯐꯝ ꯑꯣꯏꯕꯥ ꯏꯟꯗꯦꯛꯁ ꯇꯧꯕꯥ꯫ꯗꯦꯠ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯒꯥ ꯂꯣꯌꯅꯅꯥ (ꯃꯣꯃꯦꯟꯇꯒꯥ ꯂꯣꯌꯅꯅꯥ) ꯕꯥꯒꯁꯤꯡꯒꯤ ꯀꯃꯟ ꯑꯣꯏꯕꯥ ꯁꯣꯔꯁ ꯑꯃꯗꯤ ꯊꯥꯁꯤꯡ ꯑꯁꯤ ꯖꯤꯔꯣ-ꯏꯟꯗꯦꯛꯁ ꯇꯧꯕꯅꯤ꯫ ꯃꯁꯤꯅꯥ ꯇꯥꯀꯄꯗꯤ ꯖꯅꯨꯋꯥꯔꯤ ꯑꯁꯤ ꯊꯥ ꯰ꯅꯤ, ꯑꯩꯈꯣꯌ ꯄꯨꯝꯅꯃꯛꯅꯥ ꯇꯁꯦꯡꯅꯥ ꯄꯨꯟꯁꯤꯗꯥ ꯈꯉꯂꯤꯕꯥ ꯃꯇꯨꯡ ꯏꯟꯅꯥ ꯊꯥ ꯱ꯅꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯃꯁꯤ ꯱ꯗꯥ ꯌꯨꯝꯐꯝ ꯑꯣꯏꯕꯥ ꯏꯟꯗꯦꯛꯁ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ ꯐꯤꯛꯁ ꯇꯧꯏ — ꯖꯅꯨꯋꯥꯔꯤ ꯑꯁꯤ ꯊꯥ ꯱ꯅꯤ꯫ ꯃꯁꯤ ꯕ꯭ꯔꯥꯎꯖꯔꯗꯥ ꯁꯦꯃꯈꯤꯕꯅꯤ꯫ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯁꯤ ꯕ꯭ꯔꯥꯎꯖꯔ ꯃꯁꯥꯃꯛꯇꯗꯥ ꯂꯩꯕꯥ API ꯑꯃꯅꯤ ꯃꯔꯝ ꯑꯗꯨꯅꯥ ꯃꯁꯤꯅꯥ ꯅꯍꯥꯛꯀꯤ ꯑꯦꯞꯂꯤꯀꯦꯁꯅꯒꯤ ꯕꯟꯗꯜ ꯁꯥꯏꯖꯗꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯃꯠꯇꯥ ꯍꯥꯄꯆꯤꯅꯗꯦ꯫
ꯃꯁꯤꯃꯁꯨ ꯈꯉꯖꯤꯅꯕꯥ ꯃꯔꯨ ꯑꯣꯏ ꯃꯗꯨꯗꯤ ꯗꯦꯠ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ. ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯒꯤ ꯃꯍꯨꯠ ꯁꯤꯜꯂꯤꯉꯩꯗꯥ, ꯃꯁꯤ ꯂꯧꯊꯣꯀꯄꯥ ꯅꯠꯔꯒꯥ ꯂꯧꯊꯣꯀꯄꯥ ꯉꯃꯗ꯭ꯔꯤ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯕ꯭ꯔꯥꯎꯖꯔꯁꯤꯡꯅꯥ ꯈꯪꯍꯧꯗꯅꯥ Date API ꯂꯧꯊꯣꯛꯂꯕꯗꯤ ꯑꯦꯞꯂꯤꯀꯦꯁꯟ ꯀꯌꯥ ꯁꯣꯀꯍꯅꯒꯅꯤ꯫ ꯑꯗꯨꯝ ꯑꯣꯏꯅꯃꯛ, ꯃꯁꯤꯁꯨ ꯅꯤꯡꯁꯤꯡꯕꯤꯌꯨ ꯃꯗꯨꯗꯤ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤ ꯍꯧꯖꯤꯛꯇꯤ ꯃꯦꯟꯇꯦꯅꯦꯟꯁ ꯃꯣꯗꯇꯥ ꯂꯦꯒꯦꯁꯤ ꯄ꯭ꯔꯣꯖꯦꯛꯇ ꯑꯃꯥ ꯑꯣꯏꯅꯥ ꯂꯧꯅꯔꯦ꯫ ꯑꯥꯔꯇꯤꯀꯜ ꯑꯁꯤꯒꯤ ꯑꯇꯣꯞꯄꯥ ꯁꯔꯨꯀꯁꯤꯡꯗꯥ, ꯑꯩꯈꯣꯌꯅꯥ ꯃꯣꯃꯦꯟꯇꯇꯥ ꯌꯨꯝꯐꯝ ꯑꯣꯏꯕꯥ ꯀꯣꯗ ꯑꯁꯤ ꯑꯅꯧꯕꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯗꯥ ꯃꯥꯏꯒ꯭ꯔꯦꯠ ꯇꯧꯅꯕꯒꯤ “ꯔꯦꯁꯤꯄꯤ” ꯈꯔꯥ ꯌꯦꯡꯒꯅꯤ꯫ ꯔꯤꯐꯦꯛꯇ ꯇꯧꯕꯥ ꯍꯧꯔꯁꯤ! ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯃꯒꯤ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯁꯦꯝꯕꯥ꯫ ꯑꯩꯈꯣꯌꯅꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯃꯦꯅꯤꯄꯨꯂꯦꯠ ꯇꯧꯗ꯭ꯔꯤꯉꯩ ꯃꯃꯥꯡꯗꯥ ꯃꯈꯣꯌꯕꯨ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤꯕꯥ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯁꯦꯃꯒꯠꯀꯗꯕꯅꯤ꯫ ꯍꯧꯖꯤꯛꯀꯤ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯑꯗꯨ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤꯕꯥ Moment ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯅꯕꯥ, ꯃꯣꯃꯦꯟꯇ ꯐꯉ꯭ꯀꯁꯟ ꯁꯤꯖꯤꯟꯅꯧ꯫ const ꯍꯧꯖꯤꯛ = ꯃꯣꯃꯦꯟꯇꯝ(); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯱꯸ꯇꯤ꯲꯱:꯲꯶:꯲꯹-꯰꯵:꯰꯰>
ꯍꯧꯖꯤꯛꯇꯤ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯁꯤ ꯃꯊꯧ ꯇꯥꯕꯒꯤ ꯃꯇꯨꯡ ꯏꯟꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯕꯥ ꯅꯠꯔꯒꯥ ꯃꯦꯅꯤꯄꯨꯂꯦꯠ ꯇꯧꯕꯥ ꯌꯥꯔꯦ꯫
// UTCꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ꯫ //warning: ꯃꯁꯤꯅꯥ Moment ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨ ꯃ꯭ꯌꯨꯇꯦꯁꯟ ꯇꯧꯏ ꯑꯃꯁꯨꯡ ꯃꯁꯤ UTC ꯃꯣꯗꯇꯥ ꯊꯝꯃꯤ! ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.utc()); // ꯃꯣꯃꯦꯟꯇ<2026-02-19T02:26:29Z>
// ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯄ꯭ꯔꯤꯟꯇ ꯇꯧꯕꯥ - ꯃꯁꯤꯅꯥ ꯍꯧꯖꯤꯛ UTCꯒꯤ ꯃꯇꯝ ꯁꯤꯖꯤꯟꯅꯔꯤ ꯍꯥꯌꯕꯥ ꯈꯉꯖꯤꯅꯕꯤꯌꯨ꯫ console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // ꯰꯲/꯱꯹/꯲꯰꯲꯶ ꯑꯌꯨꯛ ꯄꯨꯡ ꯰꯲:꯲꯷:꯰꯷ꯗꯥ ꯊꯣꯀꯈꯤ꯫
ꯃꯣꯃꯦꯟꯇꯀꯤ ꯃꯇꯥꯡꯗꯥ ꯅꯤꯡꯁꯤꯡꯒꯗꯕꯥ ꯃꯔꯨ ꯑꯣꯏꯕꯥ ꯋꯥꯐꯃꯗꯤ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯗꯥ ꯃꯇꯝ ꯄꯨꯝꯅꯃꯛꯇꯥ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡꯒꯤ ꯃꯇꯥꯡꯗꯥ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯌꯥꯑꯣꯏ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯃꯇꯃꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯅꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯊꯕꯛ ꯇꯧꯕꯥ ꯈꯛꯇꯃꯛ ꯃꯊꯧ ꯇꯥꯔꯕꯗꯤ, ꯃꯁꯤ ꯃꯍꯧꯁꯥꯅꯥ ꯐꯩ, ꯑꯗꯨꯕꯨ ꯃꯁꯤꯅꯥ ꯗꯦꯂꯥꯏꯠ ꯁꯦꯚꯤꯡ ꯇꯥꯏꯝ ꯅꯠꯠꯔꯒꯥ ꯂꯤꯞ ꯏꯌꯔꯒꯨꯝꯕꯥ ꯐꯤꯚꯃꯁꯤꯡꯗꯥ ꯊꯥꯖꯗꯕꯥ ꯂꯃꯆꯠ-ꯁꯥꯖꯠ ꯊꯣꯀꯍꯅꯕꯥ ꯌꯥꯏ, ꯃꯐꯃꯗꯨꯗꯥ ꯇꯥꯡ ꯑꯗꯨꯅꯥ ꯃꯇꯃꯒꯤ ꯀꯦꯂꯀꯨꯂꯦꯁꯅꯁꯤꯡꯗꯥ ꯏꯐꯦꯛꯇ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯁꯤ ꯍꯦꯟꯅꯥ ꯐ꯭ꯂꯦꯛꯁꯤꯕꯜ ꯑꯣꯏ꯫ ꯅꯍꯥꯛꯅꯥ Temporal.Instant ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯃꯗꯨꯅꯥ ꯍꯧꯖꯤꯛꯀꯤ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯑꯗꯨ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤꯕꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯕꯥ ꯌꯥꯏ꯫ ꯃꯁꯤꯅꯥ “ꯏꯄꯣꯛ” (ꯖꯅꯨꯋꯥꯔꯤ ꯱, ꯱꯹꯷꯰ꯗꯥ ꯅꯨꯃꯤꯗꯥꯡꯋꯥꯏꯔꯝ ꯌꯨ.ꯇꯤ.ꯁꯤ.)ꯗꯒꯤ ꯍꯧꯅꯥ ꯃꯇꯝ ꯑꯗꯨꯅꯥ ꯂꯦꯄꯊꯣꯀꯄꯥ ꯃꯇꯃꯒꯤ ꯄꯣꯏꯟꯇ ꯑꯃꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯅꯦꯅꯣꯁꯦꯀꯦꯟꯗ-ꯂꯦꯕꯦꯜ ꯄ꯭ꯔꯤꯁꯤꯁꯅꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯃꯇꯃꯒꯤ ꯃꯇꯨꯡ ꯏꯟꯅꯥ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯁꯤ ꯔꯤꯐꯔꯦꯟꯁ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ const now = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ();
// ꯏꯄꯣꯀꯇꯒꯤ ꯍꯧꯅꯥ ꯑꯀꯪꯕꯥ ꯅꯦꯅꯣꯁꯦꯀꯦꯟꯗꯁꯤꯡ ꯌꯦꯡꯕꯤꯌꯨ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯏꯄꯣꯀꯅꯦꯅꯣꯁꯦꯀꯦꯟꯗ); // ꯱꯷꯷꯱꯴꯶꯶꯳꯴꯲꯶꯱꯲꯰꯰꯰꯰꯰꯰꯰꯰ꯑꯦꯟ
// ꯌꯨ.ꯇꯤ.ꯁꯤ.ꯒꯤꯗꯃꯛ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯕꯥ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯲꯰꯲꯶-꯰꯲-꯱꯹ꯇꯤ꯰꯱:꯵꯵:꯲꯷.꯸꯴꯴ꯖꯦꯗ
// ꯑꯀꯛꯅꯕꯥ ꯃꯇꯃꯒꯤ ꯃꯐꯝ ꯑꯃꯒꯤꯗꯃꯛ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯕꯥ꯫ console.log(now.toString({ ꯇꯥꯏꯃꯖꯣꯟ: 'ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ' })); // ꯲꯰꯲꯶-꯰꯲-꯱꯸ꯇꯤ꯲꯰:꯵꯶:꯵꯷.꯹꯰꯵-꯰꯵:꯰꯰ꯗꯥ ꯐꯣꯉꯈ꯭ꯔꯦ꯫
ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯏꯟꯁꯇꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯁꯤ ꯐ꯭ꯔꯝ ꯁ꯭ꯇꯦꯇꯤꯛ ꯃꯦꯊꯗ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ ꯑꯀꯛꯅꯕꯥ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡ ꯑꯃꯒꯤꯗꯃꯛꯇꯁꯨ ꯁꯦꯝꯕꯥ ꯌꯥꯏ꯫
const myInstant = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯏꯟꯁꯇꯦꯟꯇ.ꯐ꯭ꯔꯣꯝ('꯲꯰꯲꯶-꯰꯲-꯱꯸ꯇꯤ꯲꯱:꯱꯰:꯰꯰-꯰꯵:꯰꯰');
// ꯂꯣꯀꯦꯜ ꯇꯥꯏꯝ ꯖꯣꯅꯗꯥ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯗꯨ ꯐꯣꯔꯃꯦꯠ ꯇꯧ꯫ ꯃꯁꯤꯅꯥ ꯀꯟꯠꯔꯣꯜ ꯈꯛꯇꯃꯛ ꯇꯧꯏ ꯍꯥꯌꯕꯁꯤ ꯈꯪꯖꯤꯅꯕꯤꯌꯨ꯫ // ꯐꯣꯔꯃꯦꯇꯤꯡ ꯑꯗꯨ - ꯃꯁꯤꯅꯥ moment.utc ꯇꯧꯕꯒꯨꯝꯅꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨ ꯃ꯭ꯌꯨꯇꯦꯁꯟ ꯇꯧꯗꯦ꯫ console.log(myInstant.toString({ ꯇꯥꯏꯃꯖꯣꯟ: 'ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ' })); // ꯲꯰꯲꯶-꯰꯲-꯱꯸ꯇꯤ꯲꯱:꯱꯰:꯰꯰-꯰꯵:꯰꯰ꯗꯥ ꯐꯣꯉꯈ꯭ꯔꯦ꯫
ꯑꯗꯣꯝꯅꯥ ꯑꯇꯣꯞꯄꯥ ꯃꯈꯂꯒꯤ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯁꯨ ꯁꯦꯝꯕꯥ ꯌꯥꯏ, ꯃꯈꯣꯌꯁꯤꯡ ꯑꯗꯨꯗꯤ:
Temporal.PlainDate: ꯃꯇꯃꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯂꯩꯇꯕꯥ ꯇꯥꯡ ꯑꯃꯅꯤ꯫ Temporal.PlainTime: ꯇꯥꯡꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯂꯩꯇꯕꯥ ꯃꯇꯝ ꯑꯃꯅꯤ꯫ Temporal.ZonedDateTime: ꯑꯀꯛꯅꯕꯥ ꯃꯇꯃꯒꯤ ꯖꯣꯟ ꯑꯃꯗꯥ ꯂꯩꯕꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯑꯃꯅꯤ꯫
ꯃꯁꯤꯒꯤ ꯃꯅꯨꯡꯗꯥ ꯈꯨꯗꯤꯡꯃꯛꯀꯤ ꯐ꯭ꯔꯣꯝ ꯃꯦꯊꯗ ꯑꯃꯥ ꯂꯩ ꯃꯗꯨꯗꯤ ꯃꯁꯤ ꯇꯥꯡ ꯑꯃꯁꯨꯡ/ꯅꯠꯠꯔꯒꯥ ꯃꯇꯝ ꯑꯗꯨ ꯇꯥꯀꯄꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯀꯧꯕꯥ ꯌꯥꯏ, ꯅꯠꯠꯔꯒꯥ ꯄꯥꯔꯁ ꯇꯧꯅꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯂꯩ꯫ // ꯁꯨꯞꯅꯇꯒꯤ ꯇꯥꯡ ꯑꯃꯈꯛꯇꯅꯤ꯫ const today = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯗꯦꯠ.ꯐ꯭ꯔꯣꯝ({ ꯆꯍꯤ: ꯲꯰꯲꯶, ꯲꯰꯲꯰꯫ ꯊꯥ: ꯲, // ꯅꯣꯠ ꯑꯩꯈꯣꯌꯅꯥ ꯐꯦꯕ꯭ꯔꯨꯋꯥꯔꯤꯒꯤꯗꯃꯛ ꯲ ꯁꯤꯖꯤꯟꯅꯔꯤ꯫ ꯅꯨꯃꯤꯠ: ꯱꯸ }); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯉꯁꯤ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯲꯰꯲꯶-꯰꯲-꯱꯸ꯗꯥ ꯊꯣꯀꯈꯤ꯫
// ꯃꯇꯝ ꯑꯃꯈꯛꯇꯅꯤ꯫ const lunchTime = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ({ ꯄꯨꯡ: ꯱꯲ }); console.log(ꯂꯟꯆꯇꯥꯏꯝ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯱꯲:꯰꯰:꯰꯰ ꯇꯥꯕꯥ ꯃꯇꯃꯗꯥ꯫
// ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯏꯁ꯭ꯇꯔꯟ ꯇꯥꯏꯝ ꯖꯣꯅꯗꯥ ꯂꯩꯕꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯑꯃꯥ꯫ const dueAt = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯖꯣꯅꯦꯗꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ({ timeZone: ‘ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ’, ꯳. ꯆꯍꯤ: ꯲꯰꯲꯶, ꯲꯰꯲꯰꯫ ꯊꯥ: ꯳, ꯳. ꯅꯨꯃꯤꯠ: ꯱, ꯴. ꯄꯨꯡ: ꯱꯲, ꯴. ꯃꯤꯅꯤꯠ: ꯰, ꯴. ꯑꯅꯤꯁꯨꯕꯥ: ꯰ }); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯗ꯭ꯌꯨꯑꯦꯠ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯲꯰꯲꯶-꯰꯳-꯰꯱ꯇꯤ꯱꯲:꯰꯰:꯰꯰-꯰꯵:꯰꯰[ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ]
ꯄꯥꯔꯁꯤꯡ ꯇꯧꯕꯥ꯫ ꯑꯩꯈꯣꯌꯅꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯃꯒꯤ ꯏꯅꯐꯣꯔꯃꯦꯁꯅꯒꯤ ꯄ꯭ꯔꯣꯒ꯭ꯔꯥꯃꯦꯇꯤꯛ ꯀ꯭ꯔꯤꯌꯦꯁꯟ ꯑꯁꯤ ꯀꯚꯔ ꯇꯧꯈ꯭ꯔꯦ꯫ ꯍꯧꯖꯤꯛ ꯄꯥꯔꯁ ꯇꯧꯕꯒꯤ ꯃꯇꯥꯡꯗꯥ ꯌꯦꯡꯁꯤ꯫ ꯄꯥꯔꯁꯤꯡ ꯑꯁꯤ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤ ꯕꯤꯜꯇ-ꯏꯟ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯗꯒꯤ ꯍꯦꯟꯅꯥ ꯐ꯭ꯂꯦꯛꯁꯤꯕꯜ ꯑꯣꯏꯕꯥ ꯂꯝ ꯑꯃꯅꯤ꯫ ꯅꯍꯥꯛꯅꯥ ꯗꯦꯠ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯃꯣꯃꯦꯟꯇ ꯐꯉ꯭ꯀꯁꯟꯗꯥ ꯄꯥꯁ ꯇꯧꯗꯨꯅꯥ ꯄꯥꯔꯁ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ ꯑꯥꯔꯒꯨꯃꯦꯟꯇ ꯑꯃꯈꯛꯇꯒꯥ ꯂꯣꯌꯅꯅꯥ, ꯃꯣꯃꯦꯟꯇꯅꯥ ISO ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯑꯦꯛꯁꯄꯦꯛꯇ ꯇꯧꯏ, ꯑꯗꯨꯕꯨ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯁꯤꯖꯤꯟꯅꯔꯤꯕꯥ ꯇꯥꯡꯒꯤ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨ ꯇꯥꯀꯄꯥ ꯑꯅꯤꯁꯨꯕꯥ ꯑꯥꯔꯒꯨꯃꯦꯟꯇ ꯑꯃꯥ ꯄꯤꯔꯕꯗꯤ ꯅꯍꯥꯛꯅꯥ ꯑꯇꯣꯞꯄꯥ ꯐꯣꯔꯃꯦꯇꯁꯤꯡ ꯁꯤꯖꯤꯟꯅꯕꯥ ꯌꯥꯏ꯫
const isoDate = ꯃꯣꯃꯦꯟꯇ('꯲꯰꯲꯶-꯰꯲-꯲꯱ꯇꯤ꯰꯹:꯰꯰:꯰꯰'); const formattedDate = moment('꯲/꯲꯱/꯲꯶ ꯹:꯰꯰:꯰꯰', 'ꯑꯦꯝ/ꯗꯤ/ꯋꯥꯏ.ꯋꯥꯏ.ꯑꯩꯆ.:ꯃꯤ.ꯑꯦꯝ.:ꯑꯦꯁ.ꯑꯦꯁ.');
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯑꯥꯏꯁꯣꯗꯦꯠ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯱T꯰꯹:꯰꯰:꯰꯰-꯰꯵:꯰꯰>
console.log(ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯇꯥꯡ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯱T꯰꯹:꯰꯰:꯰꯰-꯰꯵:꯰꯰>
ꯑꯔꯤꯕꯥ ꯚꯔꯖꯅꯁꯤꯡꯗꯥ, ꯃꯣꯃꯦꯟꯇꯅꯥ ꯑꯔꯕꯤꯠꯔꯦꯔꯤ ꯑꯣꯏꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯍꯦꯛꯇꯕꯨ ꯄꯥꯔꯁ ꯇꯧꯅꯕꯥ ꯈ꯭ꯕꯥꯏꯗꯒꯤ ꯐꯕꯥ ꯒꯦꯁ ꯑꯃꯥ ꯁꯦꯃꯒꯅꯤ꯫ ꯃꯁꯤꯅꯥ ꯊꯥꯖꯗꯕꯥ ꯐꯂꯁꯤꯡ ꯄꯨꯔꯀꯄꯥ ꯌꯥꯏ꯫ ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ, ꯰꯲-꯰꯳-꯲꯰꯲꯶ ꯑꯁꯤ ꯐꯦꯕ꯭ꯔꯨꯋꯥꯔꯤ ꯲ ꯅꯠꯔꯒꯥ ꯃꯥꯔꯆ ꯳ꯅꯤ? ꯃꯔꯝ ꯑꯁꯤꯅꯥ, ꯃꯣꯃꯦꯟꯇꯀꯤ ꯑꯅꯧꯕꯥ ꯚꯔꯖꯅꯁꯤꯡꯅꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯃꯁꯤ ISO ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯌꯥꯑꯣꯗꯅꯥ ꯀꯧꯔꯕꯗꯤ (ꯑꯄꯥꯝꯕꯥ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯑꯅꯤꯁꯨꯕꯥ ꯑꯥꯔꯒꯨꯃꯦꯟꯇ ꯑꯗꯨꯁꯨ ꯄꯤꯗ꯭ꯔꯕꯗꯤ) ꯃꯁꯛ ꯊꯣꯀꯄꯥ ꯗꯤꯞꯔꯦꯁꯟ ꯋꯥꯔꯅꯤꯡ ꯑꯃꯥ ꯎꯠꯂꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯑꯀꯛꯅꯕꯥ ꯑꯣꯏꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯈꯛꯇꯃꯛ ꯄꯥꯔꯁ ꯇꯧꯒꯅꯤ꯫ ꯁ꯭ꯠꯔꯤꯡ ꯑꯗꯨ ISO 8601 ꯐꯣꯔꯃꯦꯠ ꯅꯠꯠꯔꯒꯥ ꯃꯁꯤꯒꯤ ꯑꯦꯛꯁꯇꯦꯟꯁꯟ, RFC 9557ꯒꯥ ꯆꯨꯅꯕꯥ ꯑꯣꯏꯒꯗꯕꯅꯤ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯟ-ꯀꯃꯞꯂꯥꯏꯑꯦꯟꯇ ꯑꯣꯏꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯐ꯭ꯔꯝ ꯃꯦꯊꯗ ꯑꯃꯗꯥ ꯄꯥꯁ ꯇꯧꯔꯕꯗꯤ, ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ RangeError ꯑꯃꯥ ꯊꯥꯗꯣꯛꯀꯅꯤ꯫
// RFC 9557 ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ꯫ const myDate = Temporal.Instant.from('꯲꯰꯲꯶-꯰꯲-꯲꯱T꯰꯹:꯰꯰:꯰꯰-꯰꯵:꯰꯰[ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ]'); console.log(myDate.toString({ ꯇꯥꯏꯃꯖꯣꯟ: 'ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ' })); // ꯲꯰꯲꯶-꯰꯲-꯲꯱ꯇꯤ꯰꯹:꯰꯰:꯰꯰-꯰꯵:꯰꯰ꯗꯥ ꯊꯣꯀꯈꯤ꯫
// ꯃꯁꯛ ꯈꯪꯗꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ꯫ const otherDate = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯏꯟꯁꯇꯦꯟꯇ.ꯐ꯭ꯔꯣꯝ('꯲/꯲꯱/꯲꯶ ꯹:꯰꯰:꯰꯰'); // RangeError: ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦꯔꯥꯔ: ꯆꯍꯤꯒꯤ ꯚꯦꯜꯌꯨ ꯄꯥꯔꯁ ꯇꯧꯕꯥ ꯃꯇꯃꯗꯥ ꯑꯁꯣꯌꯕꯥ ꯆꯦꯛꯔꯦꯇꯔ꯫
ꯗꯦꯠ ꯁ꯭ꯠꯔꯤꯡꯒꯤ ꯑꯀꯛꯅꯕꯥ ꯃꯊꯧ ꯇꯥꯕꯁꯤꯡ ꯑꯁꯤ ꯅꯍꯥꯛꯅꯥ ꯀꯔꯤ ꯃꯈꯂꯒꯤ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯁꯦꯝꯂꯤꯕꯒꯦ ꯍꯥꯌꯕꯗꯨꯒꯤ ꯃꯈꯥ ꯄꯣꯜꯂꯤ꯫ ꯃꯊꯛꯀꯤ ꯈꯨꯗꯝ ꯑꯁꯤꯗꯥ, Temporal.Instant ꯑꯁꯤ ꯃꯄꯨꯡꯐꯥꯕꯥ ISO ꯑꯃꯥ ꯃꯊꯧ ꯇꯥꯏ꯫8601 ꯅꯠꯠꯔꯒꯥ RFC 9557 ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯣꯐꯁꯦꯠ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯝ ꯑꯗꯨ ꯇꯥꯀꯄꯥ, ꯑꯗꯨꯕꯨ ꯅꯍꯥꯛꯅꯥ ꯇꯥꯡ ꯐꯣꯔꯃꯦꯇꯀꯤ ꯁꯕꯁꯦꯠ ꯈꯛꯇꯃꯛ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ PlainDate ꯅꯠꯠꯔꯒꯥ PlainTime ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯁꯨ ꯁꯦꯝꯕꯥ ꯌꯥꯏ꯫ const myDate = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯗꯦꯠ.ꯐ꯭ꯔꯣꯝ('꯲꯰꯲꯶-꯰꯲-꯲꯱'); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯃꯥꯏꯗꯦꯠ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯲꯰꯲꯶-꯰꯲-꯲꯱ꯗꯥ ꯊꯣꯀꯈꯤ꯫
const myTime = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ('꯰꯹:꯰꯰:꯰꯰'); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯃꯥꯏꯇꯥꯏꯝ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯰꯹:꯰꯰:꯰꯰ ꯇꯥꯕꯥ ꯃꯇꯃꯗꯥ꯫
ꯁ꯭ꯠꯔꯤꯡꯁꯤꯡ ꯑꯁꯤ ꯍꯧꯖꯤꯀꯁꯨ ꯑꯦꯛꯁꯄꯦꯛꯇꯦꯗ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨꯒꯥ ꯃꯥꯟꯅꯒꯗꯕꯅꯤ ꯍꯥꯌꯕꯁꯤ ꯈꯪꯖꯤꯅꯕꯤꯌꯨ, ꯅꯠꯔꯕꯗꯤ ꯑꯁꯣꯌꯕꯥ ꯑꯃꯥ ꯊꯥꯗꯣꯛꯀꯅꯤ꯫
// ꯅꯟ-ꯀꯃꯞꯂꯥꯏꯑꯦꯟꯇ ꯇꯥꯏꯝ ꯁ꯭ꯠꯔꯤꯡꯁꯤꯡ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ꯫ ꯍꯥꯌꯔꯤꯕꯥ ꯄꯨꯝꯅꯃꯛ ꯑꯁꯤꯅꯥ RangeError ꯑꯃꯥ ꯊꯥꯗꯣꯛꯀꯅꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ('꯹:꯰꯰'); ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ('꯹:꯰꯰:꯰꯰ ꯑꯦ.ꯑꯦꯝ.');
ꯄ꯭ꯔꯣ ꯇꯤꯞ: ꯅꯟ-ꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ. ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯀꯤ ꯗꯦꯇꯥ ꯁꯣꯔꯁꯅꯥ ꯑꯁꯤꯒꯨꯝꯕꯥ ꯁ꯭ꯠꯔꯤꯡꯁꯤꯡ ꯑꯁꯤ ꯁꯤꯖꯤꯟꯅꯔꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯇꯦꯝꯄꯣꯔꯦꯂꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯁꯤꯖꯤꯟꯅꯅꯕꯥ ꯍꯣꯠꯅꯗ꯭ꯔꯤꯉꯩ ꯃꯃꯥꯡꯗꯥ ꯚꯦꯜꯌꯨꯁꯤꯡ ꯑꯗꯨ 2026-02-01ꯒꯨꯝꯕꯥ ISO ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯗꯥ ꯑꯃꯨꯛ ꯍꯟꯅꯥ ꯁꯦꯃꯗꯣꯛ-ꯁꯦꯃꯖꯤꯟ ꯇꯧꯅꯕꯥ ꯁ꯭ꯠꯔꯤꯡ ꯃꯦꯅꯤꯄꯨꯂꯦꯁꯟ ꯈꯔꯥ ꯇꯧꯕꯥ ꯃꯊꯧ ꯇꯥꯏ꯫
ꯐꯣꯔꯃꯦꯇꯤꯡ ꯇꯧꯕꯥ꯫ ꯅꯍꯥꯛꯅꯥ Moment ꯅꯠꯔꯒꯥ Temporal ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯂꯩꯔꯕꯥ ꯃꯇꯨꯡꯗꯥ, ꯅꯍꯥꯛꯅꯥ ꯃꯗꯨ ꯃꯇꯝ ꯈꯔꯒꯤ ꯑꯣꯏꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ ꯄꯥꯝꯂꯕꯁꯨ ꯌꯥꯏ꯫ ꯃꯁꯤ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤ ꯈꯔꯥ ꯍꯦꯟꯅꯥ ꯇꯦꯔꯁ ꯑꯣꯏꯕꯥ ꯏꯟꯁꯇꯦꯟꯁꯟ ꯑꯃꯅꯤ꯫ ꯅꯍꯥꯛꯅꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨꯒꯤ ꯐꯣꯔꯃꯦꯠ ꯃꯦꯊꯗ ꯑꯗꯨ ꯑꯄꯥꯝꯕꯥ ꯇꯥꯡꯒꯤ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨ ꯇꯥꯀꯄꯥ ꯇꯣꯀꯦꯅꯁꯤꯡꯒꯤ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯀꯧꯏ꯫ ꯀꯟꯁꯠ ꯇꯥꯡ = ꯃꯣꯃꯦꯟꯇꯝ();
console.log(date.format('ꯑꯦꯝ.ꯑꯦꯝ./ꯗꯤ.ꯗꯤ./ꯋꯥꯏ.ꯋꯥꯏ.ꯋꯥꯏ.')); // ꯰꯲/꯲꯲/꯲꯰꯲꯶ꯇꯥ ꯊꯣꯀꯈꯤ꯫
console.log(date.format('ꯑꯦꯝ.ꯑꯦꯝ.ꯑꯦꯝ.ꯑꯦꯝ.ꯅꯥ ꯋꯥꯏ.ꯋꯥꯏ.ꯋꯥꯏ., h:mm:ss a')); // ꯐꯦꯕ꯭ꯔꯨꯋꯥꯔꯤ ꯲꯲, ꯲꯰꯲꯶, ꯅꯨꯃꯤꯗꯥꯡ ꯄꯨꯡ ꯸:꯱꯸:꯳꯰꯫
ꯑꯃꯔꯣꯃꯗꯥ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯑꯗꯣꯃꯕꯨ ꯈꯔꯥ ꯍꯦꯟꯅꯥ ꯋꯥꯍꯟꯊꯣꯛ ꯄꯤꯕꯥ ꯃꯊꯧ ꯇꯥꯏ꯫ ꯏꯟꯁꯇꯦꯟꯇꯒꯨꯝꯕꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯗꯥ, ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯒꯤ ꯄ꯭ꯔꯣꯄꯔꯇꯤ ꯑꯣꯏꯅꯥ ꯁꯦꯃꯗꯣꯀꯄꯥ ꯇꯣꯉꯥꯟ ꯇꯣꯉꯥꯅꯕꯥ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯑꯣꯄꯁꯅꯁꯤꯡ ꯌꯥꯕꯥ toLocaleString ꯃꯦꯊꯗ ꯑꯃꯥ ꯂꯩ꯫
const date = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ();
// ꯑꯥꯔꯒꯨꯃꯦꯟꯇ ꯑꯃꯠꯇꯥ ꯂꯩꯇꯅꯥ, ꯑꯩꯈꯣꯌꯅꯥ ꯍꯧꯖꯤꯛꯀꯤ ꯂꯣꯀꯦꯂꯒꯤ ꯗꯤꯐꯣꯜꯇ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨ ꯐꯪꯒꯅꯤ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯇꯥꯡ.ꯇꯨꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡ()); // ꯲/꯲꯲/꯲꯰꯲꯶, ꯸:꯲꯳:꯳꯶ ꯄꯤ.ꯑꯦꯝ.(ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯂꯣꯀꯦꯜ ꯑꯃꯥ ꯂꯧꯔꯒꯥ)
// ꯀꯁ꯭ꯇꯝ ꯐꯣꯔꯃꯦꯠ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯁꯦꯝꯅꯕꯥ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯑꯣꯄꯁꯅꯁꯤꯡ ꯄꯥꯁ ꯇꯧꯕꯥ꯫ console.log(date.toLocaleString('ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.', { ꯊꯥ: ‘ꯂꯝꯕꯥ’, ꯴. ꯅꯨꯃꯤꯠ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯆꯍꯤ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯄꯨꯡ: ‘꯲-ꯗꯤꯖꯤꯠ’, ꯴. ꯃꯤꯅꯤꯠ: ‘꯲-ꯗꯤꯖꯤꯠ’꯫ })); // ꯐꯦꯕ꯭ꯔꯨꯋꯥꯔꯤ ꯲꯲, ꯲꯰꯲꯶ꯇꯥ ꯄꯨꯡ ꯸:꯲꯳ ꯄꯤ.ꯑꯦꯝ
// ꯐꯣꯔꯃꯦꯠ ꯁ꯭ꯠꯔꯤꯡꯗꯥ ꯅꯍꯥꯛꯅꯥ ꯄꯥꯝꯂꯤꯕꯥ ꯐꯤꯜꯗꯁꯤꯡ ꯈꯛꯇꯃꯛ ꯄꯥꯁ ꯇꯧ꯫ console.log(date.toLocaleString('ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.', { ꯊꯥ: ‘ꯁꯣꯔꯠ’, ꯴. ꯅꯨꯃꯤꯠ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’꯫ })); // ꯐꯦꯕ꯭ꯔꯨꯋꯥꯔꯤ ꯲꯲ꯗꯥ ꯊꯣꯀꯈꯤ꯫
ꯇꯦꯝꯄꯣꯔꯦꯜ ꯗꯦꯠ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯑꯁꯤꯅꯥ ꯇꯁꯦꯡꯅꯥ ꯍꯨꯗꯀꯤ ꯃꯈꯥꯗꯥ ꯂꯩꯕꯥ Intl.DateTimeFormat API (ꯃꯁꯤ ꯍꯥꯟꯅꯅꯥ ꯃꯣꯗꯔꯟ ꯕ꯭ꯔꯥꯎꯖꯔꯁꯤꯡꯗꯥ ꯐꯖꯅꯥ ꯐꯪꯂꯦ) ꯁꯤꯖꯤꯟꯅꯩ꯫ ꯃꯁꯤꯅꯥ ꯇꯥꯀꯄꯗꯤ ꯅꯍꯥꯛꯅꯥ ꯅꯍꯥꯛꯀꯤ ꯀꯁ꯭ꯇꯝ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯑꯣꯄꯁꯅꯁꯤꯡꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯑꯃꯨꯛ ꯍꯟꯅꯥ ꯁꯤꯖꯤꯟꯅꯕꯥ ꯌꯥꯕꯥ DateTimeFormat ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯕꯥ ꯌꯥꯏ, ꯃꯗꯨꯒꯤ ꯃꯇꯨꯡꯗꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯗꯨ ꯃꯁꯤꯒꯤ ꯐꯣꯔꯃꯦꯠ ꯃꯦꯊꯗꯇꯥ ꯄꯥꯁ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ ꯃꯁꯤꯅꯥ ꯃꯔꯝ ꯑꯣꯏꯗꯨꯅꯥ ꯃꯁꯤꯅꯥ ꯃꯣꯃꯦꯟꯇꯅꯥ ꯇꯧꯕꯒꯨꯝꯅꯥ ꯀꯁ꯭ꯇꯝ ꯗꯦꯠ ꯐꯣꯔꯃꯦꯠꯁꯤꯡ ꯁꯄꯣꯔꯠ ꯇꯧꯗꯦ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ‘Q1 2026’ ꯅꯠꯠꯔꯒꯥ ꯑꯇꯩ ꯑꯈꯟꯅꯕꯥ ꯐꯣꯔꯃꯦꯇꯤꯡꯒꯨꯝꯕꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯃꯥ ꯃꯊꯧ ꯇꯥꯔꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯀꯁ꯭ꯇꯃꯔ ꯗꯦꯠ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯀꯣꯗ ꯈꯔꯥ ꯃꯊꯧ ꯇꯥꯕꯥ ꯌꯥꯏ ꯅꯠꯠꯔꯒꯥ ꯊꯥꯔꯗ ꯄꯥꯔꯇꯤ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯃꯒꯤꯗꯃꯛ ꯌꯧꯕꯥ ꯌꯥꯏ꯫ const formatter = ꯑꯅꯧꯕꯥ Intl.DateTimeFormat('ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.', { ꯊꯥ: ‘꯲-ꯗꯤꯖꯤꯠ’, ꯴. ꯅꯨꯃꯤꯠ: ‘꯲-ꯗꯤꯖꯤꯠ’, ꯴. ꯆꯍꯤ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’꯫ });
const date = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ(); console.log(ꯐꯣꯔꯃꯦꯇꯔ.ꯐꯣꯔꯃꯦꯠ(ꯇꯥꯡ)); // ꯰꯲/꯲꯲/꯲꯰꯲꯶ꯇꯥ ꯊꯣꯀꯈꯤ꯫
ꯃꯣꯃꯦꯟꯇꯀꯤ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯇꯣꯀꯦꯅꯁꯤꯡ ꯑꯁꯤ ꯏꯕꯥ ꯌꯥꯝꯅꯥ ꯂꯥꯏ, ꯑꯗꯨꯕꯨ ꯃꯈꯣꯌ ꯑꯁꯤ ꯂꯣꯀꯦꯜ-ꯐ꯭ꯔꯦꯟꯗꯂꯤ ꯑꯣꯏꯗꯦ꯫ ꯐꯣꯔꯃꯦꯠ ꯑꯁꯤꯅꯥ ꯊꯥ/ꯅꯨꯃꯤꯠꯀꯤ ꯑꯣꯔꯗꯔꯒꯨꯝꯕꯥ ꯄꯣꯠꯁꯤꯡ “ꯍꯥꯔꯗ ꯀꯣꯗ” ꯁ꯭ꯠꯔꯤꯡ ꯇꯧꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯇꯧꯕꯒꯨꯝꯅꯥ ꯀꯅꯐꯤꯒꯔꯦꯁꯟ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯕꯒꯤ ꯀꯥꯟꯅꯕꯗꯤ ꯃꯁꯤꯅꯥ ꯑꯄꯤꯕꯥ ꯂꯣꯀꯦꯜ ꯑꯃꯍꯦꯛꯇꯗꯥ ꯃꯁꯥ ꯃꯊꯟꯇꯥ ꯑꯦꯗꯞꯇꯦꯠ ꯇꯧꯒꯅꯤ ꯑꯃꯁꯨꯡ ꯑꯆꯨꯝꯕꯥ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨ ꯁꯤꯖꯤꯟꯅꯒꯅꯤ꯫ const date = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ();
ꯀꯟꯁꯠ ꯐꯣꯔꯃꯦꯇꯑꯣꯄꯁꯅꯁꯤꯡ = { ꯊꯥ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯅꯨꯃꯤꯠ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯆꯍꯤ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’꯫ };
console.log(date.toLocaleString('ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.', ꯐꯣꯔꯃꯦꯇꯑꯣꯄꯁꯅꯁꯤꯡ)); // ꯲/꯲꯲/꯲꯰꯲꯶ꯇꯥ ꯊꯣꯀꯈꯤ꯫
console.log(date.toLocaleString('ꯑꯦꯟ-ꯖꯤ.ꯕꯤ.', ꯐꯣꯔꯃꯦꯇꯑꯣꯄꯁꯅꯁꯤꯡ)); // ꯲꯲/꯰꯲/꯲꯰꯲꯶ꯇꯥ ꯊꯣꯀꯈꯤ꯫
ꯇꯥꯡꯒꯤ ꯍꯤꯁꯥꯕ ꯇꯧꯕꯥ꯫ ꯑꯦꯞꯂꯤꯀꯦꯁꯟ ꯀꯌꯥꯗꯥ, ꯅꯍꯥꯛꯅꯥ ꯇꯥꯡ ꯑꯃꯗꯥ ꯀꯦꯂꯀꯨꯂꯦꯁꯟ ꯈꯔꯥ ꯄꯥꯡꯊꯣꯀꯄꯥ ꯂꯣꯌꯁꯤꯅꯕꯥ ꯃꯊꯧ ꯇꯥꯏ꯫ ꯅꯍꯥꯛꯅꯥ ꯃꯇꯃꯒꯤ ꯌꯨꯅꯤꯠꯁꯤꯡ (ꯅꯨꯃꯤꯠ, ꯄꯨꯡ, ꯁꯦꯀꯦꯟꯗ, ꯑꯁꯤꯅꯆꯤꯡꯕꯥ) ꯍꯥꯄꯆꯤꯅꯕꯥ ꯅꯠꯠꯔꯒꯥ ꯂꯧꯊꯣꯀꯄꯥ ꯄꯥꯝꯂꯕꯁꯨ ꯌꯥꯏ꯫ ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ, ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯍꯧꯖꯤꯛꯀꯤ ꯇꯥꯡ ꯑꯗꯨ ꯂꯩꯔꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯌꯨꯖꯔ ꯑꯗꯨꯗꯥ ꯍꯧꯖꯤꯛꯀꯤ ꯅꯨꯃꯤꯠ 1ꯅꯤꯒꯤ ꯃꯇꯨꯡꯗꯥ ꯇꯥꯡ ꯑꯗꯨ ꯎꯠꯄꯥ ꯄꯥꯝꯂꯕꯁꯨ ꯌꯥꯏ꯫ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯗꯥ ꯑꯣꯄꯔꯦꯁꯅꯁꯤꯡ ꯑꯁꯤ ꯄꯥꯡꯊꯣꯀꯄꯥ ꯑꯦꯗ ꯑꯃꯁꯨꯡ ꯁꯕꯠꯔꯦꯛꯇꯒꯨꯝꯕꯥ ꯃꯦꯊꯗꯁꯤꯡ ꯂꯩ꯫ ꯐꯉ꯭ꯀꯁꯅꯁꯤꯡ ꯑꯁꯤꯅꯥ ꯚꯦꯜꯌꯨ ꯑꯃꯥ ꯑꯃꯁꯨꯡ ꯌꯨꯅꯤꯠ ꯑꯃꯥ ꯂꯧꯏ, ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ: add(7, 'days'). ꯑꯗꯨꯝ ꯑꯣꯏꯅꯃꯛ, ꯃꯣꯃꯦꯟꯇ ꯑꯃꯁꯨꯡ ꯇꯦꯝꯄꯣꯔꯦꯂꯒꯤ ꯃꯔꯛꯇꯥ ꯌꯥꯝꯅꯥ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯈꯦꯠꯅꯕꯥ ꯑꯃꯗꯤ ꯗꯦꯠ ꯀꯦꯂꯀꯨꯂꯦꯁꯅꯁꯤꯡ ꯑꯁꯤ ꯄꯥꯡꯊꯣꯀꯄꯥ ꯃꯇꯃꯗꯥ ꯃꯈꯥꯗꯥ ꯂꯩꯔꯤꯕꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨ ꯃꯣꯗꯤꯐꯥꯏ ꯇꯧꯏ ꯑꯃꯁꯨꯡ ꯃꯁꯤꯒꯤ ꯑꯔꯤꯕꯥ ꯚꯦꯜꯌꯨ ꯑꯗꯨ ꯃꯥꯡꯈꯤ꯫ const ꯍꯧꯖꯤꯛ = ꯃꯣꯃꯦꯟꯇꯝ();
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯴ꯇꯤ꯲꯰:꯰꯸:꯳꯶-꯰꯵:꯰꯰>
const nextWeek = now.add(꯷, 'ꯅꯨꯃꯤꯠꯁꯤꯡ'); console.log(ꯃꯊꯪꯒꯤ ꯅꯨꯃꯤꯠ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯳-꯰꯳ꯇꯤ꯲꯰:꯰꯸:꯳꯶-꯰꯵:꯰꯰>
// ꯒꯣꯠꯆꯥ - ꯑꯔꯤꯕꯥ ꯄꯣꯠꯁꯛ ꯑꯗꯨ ꯃ꯭ꯌꯨꯇꯦꯁꯟ ꯇꯧꯈꯤ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯳-꯰꯳ꯇꯤ꯲꯰:꯰꯸:꯳꯶-꯰꯵:꯰꯰>
ꯑꯔꯤꯕꯥ ꯇꯥꯡ ꯑꯗꯨ ꯃꯥꯡꯍꯟꯗꯅꯕꯥ, ꯅꯍꯥꯛꯅꯥ ꯀꯣꯄꯤ ꯑꯃꯥ ꯁꯦꯝꯅꯕꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇꯇꯥ ꯀ꯭ꯂꯣꯟ ꯀꯧꯕꯥ ꯌꯥꯏ꯫ ꯀꯟꯁꯠ ꯇꯧꯕꯥ ꯍꯧꯖꯤꯛ꯫= ꯃꯣꯃꯦꯟꯇꯝ(); const nextWeek = now.clone().add(7, 'ꯅꯨꯃꯤꯠꯁꯤꯡ');
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯴ꯇꯤ꯲꯰:꯱꯲:꯵꯵-꯰꯵:꯰꯰>
console.log(ꯃꯊꯪꯒꯤ ꯅꯨꯃꯤꯠ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯳-꯰꯳ꯇꯤ꯲꯰:꯱꯲:꯵꯵-꯰꯵:꯰꯰>
ꯑꯃꯔꯣꯃꯗꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯁꯤ ꯏꯝꯌꯨꯇꯦꯕꯜ ꯑꯣꯏ꯫ ꯅꯍꯥꯛꯅꯥ ꯏꯟꯁꯇꯦꯟꯇ, ꯄ꯭ꯂꯦꯅꯗꯦꯠ, ꯑꯁꯤꯅꯆꯤꯡꯕꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯦꯝꯂꯕꯥ ꯃꯇꯨꯡꯗꯥ, ꯑꯣꯕꯖꯦꯛꯇ ꯑꯗꯨꯒꯤ ꯚꯦꯜꯌꯨ ꯑꯗꯨ ꯀꯩꯗꯧꯉꯩꯗꯥ ꯍꯣꯡꯂꯣꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯗꯁꯨ ꯑꯦꯗ ꯑꯃꯁꯨꯡ ꯁꯕꯠꯔꯦꯛꯇ ꯃꯦꯊꯗ ꯂꯩ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯁꯤ ꯀꯔꯝꯕꯥ ꯑꯣꯕꯖꯦꯛꯇ ꯃꯈꯂꯁꯤꯡꯗꯥ ꯀꯔꯤ ꯇꯥꯏꯝ ꯌꯨꯅꯤꯠ ꯍꯥꯄꯆꯤꯅꯕꯥ ꯌꯥꯕꯒꯦ ꯍꯥꯌꯕꯗꯨ ꯈꯔꯥ ꯄꯤꯀꯏ꯫ ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ, ꯅꯍꯥꯛꯅꯥ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯃꯗꯥ ꯅꯨꯃꯤꯠꯁꯤꯡ ꯍꯥꯄꯆꯤꯅꯕꯥ ꯌꯥꯔꯣꯏ:
const now = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ(); const nextWeek = now.add({ ꯅꯨꯃꯤꯠꯁꯤꯡ: ꯷ }); // RangeError: ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦꯔꯥꯔ: ꯈ꯭ꯕꯥꯏꯗꯒꯤ ꯆꯥꯎꯕꯥ ꯌꯨꯅꯤꯠ ꯑꯁꯤ ꯗꯦꯠ ꯌꯨꯅꯤꯠ ꯑꯣꯏꯕꯥ ꯌꯥꯔꯣꯏ꯫
ꯃꯁꯤꯒꯤ ꯃꯔꯃꯗꯤ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯅꯥ UTCꯗꯥ ꯑꯀꯛꯅꯕꯥ ꯃꯇꯃꯒꯤ ꯄꯣꯏꯟꯇ ꯑꯃꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯏ ꯑꯃꯁꯨꯡ ꯀꯦꯂꯦꯟꯗꯔ-ꯑꯦꯒ꯭ꯅꯣꯁ꯭ꯇꯤꯛ ꯑꯣꯏ꯫ ꯃꯔꯃꯗꯤ ꯅꯨꯃꯤꯠ ꯑꯃꯒꯤ ꯂꯝꯕꯤ ꯑꯁꯤ ꯗꯦꯂꯥꯏꯠ ꯁꯦꯚꯤꯡ ꯇꯥꯏꯃꯒꯨꯝꯕꯥ ꯇꯥꯏꯝ ꯖꯣꯅꯒꯤ ꯀꯥꯡꯂꯣꯅꯁꯤꯡꯗꯥ ꯌꯨꯝꯐꯝ ꯑꯣꯏꯗꯨꯅꯥ ꯍꯣꯡꯗꯣꯀꯄꯥ ꯌꯥꯏ, ꯃꯁꯤꯒꯤ ꯀꯦꯂꯀꯨꯂꯦꯁꯟ ꯑꯁꯤ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯃꯗꯥ ꯐꯪꯗꯦ꯫ ꯑꯗꯨꯝ ꯑꯣꯏꯅꯃꯛ, ꯅꯍꯥꯛꯅꯥ ꯑꯣꯄꯔꯦꯁꯟ ꯑꯁꯤ ꯑꯇꯣꯞꯄꯥ ꯃꯈꯂꯒꯤ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯗꯥ ꯄꯥꯡꯊꯣꯀꯄꯥ ꯌꯥꯏ, ꯃꯗꯨꯗꯤ PlainDateTime: const now = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯄ꯭ꯂꯦꯅꯗꯦꯇꯇꯥꯏꯃꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ.(); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡꯗꯥ()); // ꯲/꯲꯴/꯲꯰꯲꯶, ꯸:꯲꯳:꯵꯹ ꯄꯤ.ꯑꯦꯝ
const nextWeek = now.add({ ꯅꯨꯃꯤꯠꯁꯤꯡ: ꯷ });
// ꯑꯔꯤꯕꯥ PlainDateTime ꯑꯁꯤ ꯍꯣꯡꯗꯣꯀꯄꯥ ꯂꯩꯇꯅꯥ ꯂꯩꯔꯤ ꯍꯥꯌꯕꯥ ꯈꯉꯖꯤꯅꯕꯤꯌꯨ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡꯗꯥ()); // ꯲/꯲꯴/꯲꯰꯲꯶, ꯸:꯲꯳:꯵꯹ ꯄꯤ.ꯑꯦꯝ
console.log(ꯃꯊꯪꯒꯤ ꯅꯨꯃꯤꯠ.ꯇꯨꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡ()); // ꯳/꯳/꯲꯰꯲꯶, ꯸:꯲꯳:꯵꯹ ꯄꯤ.ꯑꯦꯝ
Moment ꯅꯠꯔꯒꯥ Temporal ꯑꯣꯕꯖꯦꯛꯇ ꯑꯅꯤꯒꯤ ꯃꯔꯛꯇꯥ ꯃꯇꯝ ꯀꯌꯥ ꯂꯩꯕꯒꯦ ꯍꯥꯌꯕꯗꯨꯁꯨ ꯅꯍꯥꯛꯅꯥ ꯂꯦꯄꯊꯣꯀꯄꯥ ꯌꯥꯏ꯫ ꯃꯣꯃꯦꯟꯇꯀꯤ ꯗꯤꯐ ꯐꯉ꯭ꯀꯁꯅꯒꯥ ꯂꯣꯌꯅꯅꯥ, ꯅꯍꯥꯛꯅꯥ ꯒ꯭ꯔꯦꯅꯨꯂꯦꯔꯤꯇꯤꯒꯤꯗꯃꯛ ꯌꯨꯅꯤꯠ ꯑꯃꯥ ꯄꯤꯕꯥ ꯃꯊꯧ ꯇꯥꯏ, ꯅꯠꯔꯕꯗꯤ ꯃꯁꯤꯅꯥ ꯈꯦꯠꯅꯕꯥ ꯑꯗꯨ ꯃꯤꯂꯤꯁꯦꯀꯦꯟꯗꯇꯥ ꯍꯜꯂꯛꯀꯅꯤ꯫ const date1 = ꯃꯣꯃꯦꯟꯇ('꯲꯰꯲꯶-꯰꯲-꯲꯱ꯇꯤ꯰꯹:꯰꯰:꯰꯰'); const date2 = ꯃꯣꯃꯦꯟꯇ('꯲꯰꯲꯶-꯰꯲-꯲꯲ꯇꯤ꯱꯰:꯳꯰:꯰꯰');
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯇꯥꯡ꯲.ꯗꯤꯐ(ꯇꯥꯡ꯱)); // ꯹꯱꯸꯰꯰꯰꯰꯰ꯗꯥ ꯂꯩ꯫
console.log(date2.diff(ꯇꯥꯡ1, 'ꯅꯨꯃꯤꯠ')); // ꯱
ꯃꯁꯤ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯇꯧꯅꯕꯒꯤꯗꯃꯛ, ꯅꯍꯥꯛꯅꯥ ꯑꯇꯣꯞꯄꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯃꯁꯤꯒꯤ ꯇꯤꯜ ꯅꯠꯔꯒꯥ ꯁꯤꯟꯁ ꯃꯦꯊꯗꯁꯤꯡꯗꯥ ꯄꯥꯁ ꯇꯧꯕꯥ ꯌꯥꯏ꯫ ꯃꯁꯤꯅꯥ ꯃꯇꯃꯒꯤ ꯈꯦꯠꯅꯕꯥ ꯑꯗꯨꯒꯤ ꯃꯇꯥꯡꯗꯥ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯌꯥꯎꯕꯥ Temporal.Duration ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯔꯤꯇꯔ ꯇꯧꯏ꯫ Duration ꯑꯣꯕꯖꯦꯛꯇ ꯑꯁꯤꯅꯥ ꯈꯦꯠꯅꯕꯥ ꯑꯗꯨꯒꯤ ꯀꯝꯄꯣꯅꯦꯟꯇ ꯈꯨꯗꯤꯡꯃꯛꯀꯤ ꯄ꯭ꯔꯣꯄꯔꯇꯤ ꯂꯩ, ꯑꯃꯁꯨꯡ ꯃꯇꯃꯒꯤ ꯈꯦꯠꯅꯕꯥ ꯑꯗꯨ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤꯕꯥ ISO 8601 ꯗ꯭ꯌꯨꯔꯦꯁꯟ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯁꯨ ꯖꯦꯅꯦꯔꯦꯠ ꯇꯧꯕꯥ ꯌꯥꯏ꯫
const date1 = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯗꯦꯇꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ('꯲꯰꯲꯶-꯰꯲-꯲꯱ꯇꯤ꯰꯹:꯰꯰:꯰꯰'); const date2 = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯗꯦꯇꯇꯥꯏꯝ.ꯐ꯭ꯔꯣꯝ('꯲꯰꯲꯶-꯰꯲-꯲꯲ꯇꯤ꯱꯰:꯳꯰:꯰꯰');
// largestUnitꯅꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯒꯗꯕꯥ ꯃꯇꯃꯒꯤ ꯈ꯭ꯕꯥꯏꯗꯒꯤ ꯆꯥꯎꯕꯥ ꯌꯨꯅꯤꯠ ꯑꯗꯨ ꯇꯥꯀꯏ꯫ // ꯃꯇꯃꯒꯤ ꯀꯦꯂꯀꯨꯂꯦꯁꯟꯗꯥ꯫ const diff = date2.since(ꯇꯥꯔꯤꯈ1, { ꯈ꯭ꯕꯥꯏꯗꯒꯤ ꯆꯥꯎꯕꯥ ꯌꯨꯅꯤꯠ: 'ꯅꯨꯃꯤꯠ' });
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯗꯤꯐ.ꯗꯦꯁ); // ꯱
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯗꯤꯐ.ꯍꯣꯔꯁ); // ꯱
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯗꯤꯐ.ꯃꯤꯅꯤꯠ); // ꯳꯰
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯗꯤꯐ.ꯇꯨꯁ꯭ꯠꯔꯤꯡ()); // ꯄꯤ꯱ꯗꯤꯇꯤ꯱ꯑꯩꯆ꯳꯰ꯑꯦꯝ // (ꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ. ꯸꯶꯰꯱ꯒꯤ ꯃꯇꯝ ꯁ꯭ꯠꯔꯤꯡ: ꯅꯨꯃꯤꯠ ꯱, ꯄꯨꯡ ꯱, ꯃꯤꯅꯤꯠ ꯳꯰)
ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯃꯁꯤꯡ ꯆꯥꯡꯗꯝꯅꯕꯥ꯫ ꯃꯣꯃꯦꯟꯇ ꯑꯃꯁꯨꯡ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯅꯤꯃꯛꯅꯥ ꯑꯗꯣꯃꯗꯥ ꯑꯇꯣꯞꯄꯥ ꯑꯃꯒꯤ ꯃꯃꯥꯡꯗꯥ ꯀꯅꯥꯅꯥ ꯂꯥꯛꯀꯅꯤ ꯍꯥꯌꯕꯥ ꯈꯉꯗꯣꯛꯅꯕꯥ ꯇꯥꯡ ꯑꯃꯁꯨꯡ ꯃꯇꯃꯁꯤꯡ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯌꯥꯍꯜꯂꯤ, ꯑꯗꯨꯕꯨ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ.ꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯇꯣꯉꯥꯟ ꯇꯣꯉꯥꯅꯕꯥ ꯑꯦꯞꯔꯣꯆꯁꯤꯡ ꯂꯧꯈꯠꯂꯤ꯫ ꯃꯣꯃꯦꯟꯇꯅꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯅꯤ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯌꯥꯅꯕꯥ isBefore, isAfter, ꯑꯃꯁꯨꯡ isSameꯒꯨꯝꯕꯥ ꯃꯦꯊꯗꯁꯤꯡ ꯄꯤꯔꯤ꯫ const date1 = ꯃꯣꯃꯦꯟꯇ('꯲꯰꯲꯶-꯰꯲-꯲꯱ꯇꯤ꯰꯹:꯰꯰:꯰꯰'); const date2 = ꯃꯣꯃꯦꯟꯇ('꯲꯰꯲꯶-꯰꯲-꯲꯲ꯇꯤ꯱꯰:꯳꯰:꯰꯰');
console.log(ꯇꯥꯔꯤꯈ1.isBefore(ꯇꯥꯡ2)); // ꯑꯆꯨꯝꯕꯥ꯫
ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯆꯞ ꯃꯥꯟꯅꯕꯥ ꯃꯈꯂꯒꯤ ꯄꯣꯠꯂꯝ ꯑꯅꯤꯒꯤ ꯃꯔꯛꯇꯥ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯑꯃꯥ ꯄꯥꯡꯊꯣꯛꯅꯕꯥ ꯁ꯭ꯇꯦꯇꯤꯛ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯃꯦꯊꯗ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯩ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯍꯥꯅꯕꯥ ꯇꯥꯡ ꯑꯗꯨ ꯑꯅꯤꯁꯨꯕꯥ ꯇꯥꯡꯀꯛ ꯑꯗꯨꯒꯤ ꯃꯃꯥꯡꯗꯥ ꯂꯥꯛꯂꯕꯗꯤ ꯃꯁꯤꯅꯥ -1 ꯔꯤꯇꯔ ꯇꯧꯏ, ꯀꯔꯤꯒꯨꯝꯕꯥ ꯃꯈꯣꯌꯅꯥ ꯃꯥꯟꯅꯕꯥ ꯑꯣꯏꯔꯕꯗꯤ 0, ꯅꯠꯠꯔꯒꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯍꯥꯅꯕꯥ ꯇꯥꯡ ꯑꯗꯨ ꯑꯅꯤꯁꯨꯕꯥ ꯇꯥꯡ ꯑꯗꯨꯒꯤ ꯃꯇꯨꯡꯗꯥ ꯂꯥꯛꯂꯕꯗꯤ 1 ꯔꯤꯇꯔꯟ ꯇꯧꯏ꯫ ꯃꯈꯥꯗꯥ ꯄꯤꯔꯤꯕꯥ ꯈꯨꯗꯝ ꯑꯁꯤꯅꯥ PlainDate ꯑꯣꯕꯖꯦꯛꯇ ꯑꯅꯤ ꯑꯁꯤ ꯀꯔꯝꯅꯥ ꯆꯥꯡꯗꯝꯅꯒꯗꯒꯦ ꯍꯥꯌꯕꯗꯨ ꯎꯠꯂꯤ꯫ Temporal.PlainDate.compareꯗꯥ ꯂꯩꯕꯥ ꯑꯥꯔꯒꯨꯃꯦꯟꯇ ꯑꯅꯤꯃꯛ PlainDate ꯑꯣꯕꯖꯦꯛꯇ ꯑꯣꯏꯒꯗꯕꯅꯤ꯫
const date1 = Temporal.PlainDate.from({ ꯆꯍꯤ: ꯲꯰꯲꯶, ꯊꯥ: ꯲, ꯅꯨꯃꯤꯠ: ꯲꯴ }); const date2 = Temporal.PlainDate.from({ ꯆꯍꯤ: ꯲꯰꯲꯶, ꯊꯥ: ꯳, ꯅꯨꯃꯤꯠ: ꯲꯴ });
// date1 ꯑꯁꯤ date2ꯒꯤ ꯃꯃꯥꯡꯗꯥ ꯂꯥꯀꯏ, ꯃꯔꯝ ꯑꯗꯨꯅꯥ -1 console.log(Temporal.PlainDate.compare(ꯇꯥꯔꯤꯈ1, ꯇꯥꯡ2));
// ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯩꯈꯣꯌꯅꯥ ꯇꯣꯉꯥꯟ ꯇꯣꯉꯥꯅꯕꯥ ꯃꯈꯂꯒꯤ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯅꯤ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯍꯣꯠꯅꯔꯕꯗꯤ ꯑꯦꯔꯥꯔ꯫ console.log(Temporal.PlainDate.compare(ꯇꯥꯔꯤꯈ1, ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯏꯟꯁꯇꯦꯟꯇ())); // TypeError: ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯦꯔꯥꯔ: ꯑꯁꯣꯌꯕꯥ PlainDate ꯐꯤꯜꯗꯁꯤꯡ ꯄꯤꯈ꯭ꯔꯦ꯫
ꯃꯔꯨꯑꯣꯏꯅꯥ ꯃꯁꯤꯅꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯒꯤ ꯑꯦꯔꯦ ꯑꯃꯥ ꯀ꯭ꯔꯣꯅꯣꯂꯣꯖꯤꯀꯦꯜ ꯑꯣꯏꯅꯥ ꯁꯣꯔꯠ ꯇꯧꯕꯗꯥ ꯂꯥꯏꯍꯜꯂꯤ꯫ // Temporal.PlainDate ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡꯒꯤ ꯑꯦꯔꯦ ꯑꯃꯥ꯫ ꯀꯟꯁꯠ ꯇꯥꯡꯁꯤꯡ = [ ... ];
// Temporal.PlainDate.compare ꯑꯁꯤ ꯀꯝꯄꯥꯔꯦꯇꯔ ꯐꯉ꯭ꯀꯁꯟ ꯑꯣꯏꯅꯥ ꯁꯤꯖꯤꯟꯅꯧ dates.sort(ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯄ꯭ꯂꯦꯅꯗꯦꯠ.ꯀꯝꯄꯥꯌꯥꯔ ꯇꯧꯕꯥ);
ꯇꯥꯏꯝ ꯖꯣꯟ ꯀꯟꯕꯔꯁꯅꯁꯤꯡ꯫ ꯀꯣꯔ ꯃꯣꯃꯦꯟꯇ ꯂꯥꯏꯕ꯭ꯔꯦꯔꯤ ꯑꯁꯤꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯀꯟꯕꯔꯁꯅꯁꯤꯡ ꯁꯄꯣꯔꯠ ꯇꯧꯗꯦ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯐꯉ꯭ꯀꯁꯅꯦꯂꯤꯇꯤ ꯑꯁꯤ ꯃꯊꯧ ꯇꯥꯔꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯄꯦꯀꯦꯖꯁꯨ ꯏꯅꯁ꯭ꯇꯣꯜ ꯇꯧꯕꯥ ꯃꯊꯧ ꯇꯥꯏ꯫ ꯄꯦꯀꯦꯖ ꯑꯁꯤ ꯎ-ꯋꯥꯍꯩ-ꯋꯥꯍꯩꯁꯤꯡꯅꯥ ꯁꯣꯀꯍꯅꯕꯥ ꯌꯥꯕꯥ ꯅꯠꯇꯦ, ꯑꯃꯁꯨꯡ ꯃꯔꯝ ꯑꯁꯤꯅꯥ ꯅꯍꯥꯛꯀꯤ ꯕꯟꯗꯜ ꯁꯥꯏꯖꯗꯥ ꯃꯁꯛ ꯊꯣꯛꯅꯥ ꯍꯥꯄꯆꯤꯅꯕꯥ ꯌꯥꯏ꯫ ꯅꯍꯥꯛꯅꯥ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯏꯅꯁ꯭ꯇꯣꯜ ꯇꯧꯔꯕꯥ ꯃꯇꯨꯡꯗꯥ, ꯅꯍꯥꯛꯅꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯗꯨ tz ꯃꯦꯊꯗꯅꯥ ꯇꯣꯉꯥꯟ-ꯇꯣꯉꯥꯅꯕꯥ ꯇꯥꯏꯝ ꯖꯣꯅꯁꯤꯡꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ ꯌꯥꯏ꯫ ꯑꯇꯣꯞꯄꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯣꯄꯔꯦꯁꯅꯁꯤꯡꯒꯨꯝꯅꯥ, ꯃꯁꯤꯅꯥ ꯑꯟꯗꯔꯂꯥꯏꯟ ꯑꯗꯨ ꯃ꯭ꯌꯨꯇꯦꯁꯟ ꯇꯧꯏ꯫ꯄꯣꯠꯂꯝ. // ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯏꯁ꯭ꯇꯔꯟ ꯇꯥꯏꯝ ꯍꯥꯌꯅꯥ ꯂꯧꯗꯨꯅꯥ꯫ const ꯍꯧꯖꯤꯛ = ꯃꯣꯃꯦꯟꯇꯝ(); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯸ꯇꯤ꯲꯰:꯰꯸:꯲꯰-꯰꯵:꯰꯰>
// ꯄꯦꯁꯤꯐꯤꯛ ꯃꯇꯃꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ꯫ // ꯑꯔꯤꯕꯥ ꯏꯁ꯭ꯇꯔꯟ ꯃꯇꯝ ꯑꯗꯨ ꯃꯥꯡꯈ꯭ꯔꯦ꯫ now.tz('ꯑꯃꯦꯔꯤꯀꯥ/ꯂꯣꯁ_ꯑꯦꯟꯖꯦꯂꯁ'); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ); // ꯃꯣꯃꯦꯟꯇ<꯲꯰꯲꯶-꯰꯲-꯲꯸ꯇꯤ꯱꯷:꯰꯸:꯲꯰-꯰꯸:꯰꯰>
Temporal.ZonedDateTime ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯕꯗꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯐꯉ꯭ꯀꯁꯅꯦꯂꯤꯇꯤ ꯑꯁꯤ Temporal APIꯗꯥ ꯁꯦꯃꯒꯠꯂꯤ꯫ ꯍꯥꯌꯔꯤꯕꯥ ꯑꯣꯕꯖꯦꯛꯇꯁꯤꯡ ꯑꯁꯤꯗꯥ withTimeZone ꯃꯦꯊꯗ ꯑꯃꯥ ꯌꯥꯑꯣꯔꯤ ꯃꯗꯨꯅꯥ ꯃꯇꯃꯒꯤ ꯃꯇꯨꯡ ꯏꯟꯅꯥ ꯆꯞ ꯃꯥꯟꯅꯕꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯗꯨ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯔꯤꯕꯥ ꯑꯅꯧꯕꯥ ZonedDateTime ꯑꯃꯥ ꯔꯤꯇꯔꯟ ꯇꯧꯏ, ꯑꯗꯨꯕꯨ ꯑꯀꯛꯅꯕꯥ ꯃꯇꯃꯒꯤ ꯖꯣꯟ ꯑꯗꯨꯗꯥ꯫ // ꯑꯃꯨꯛ ꯍꯟꯅꯥ, ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯏꯁ꯭ꯇꯔꯟ ꯇꯥꯏꯝ ꯍꯥꯌꯅꯥ ꯂꯧꯗꯨꯅꯥ꯫ const now = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯖꯣꯟ ꯇꯧꯔꯕꯥ ꯇꯥꯡꯇꯥꯏꯃꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ.(); ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡꯗꯥ()); // ꯲/꯲꯸/꯲꯰꯲꯶, ꯸:꯱꯲:꯰꯲ ꯄꯤ.ꯑꯦꯝ.ꯏ.ꯑꯦꯁ.ꯇꯤ
// ꯄꯦꯁꯤꯐꯤꯛ ꯃꯇꯃꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ꯫ const nowPacific = now.withTimeZone('ꯑꯃꯦꯔꯤꯀꯥ/ꯂꯣꯁ_ꯑꯦꯟꯖꯦꯂꯁ'); console.log(ꯍꯧꯖꯤꯛ ꯄꯦꯁꯤꯐꯤꯛ.ꯇꯨꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡ()); // ꯲/꯲꯸/꯲꯰꯲꯶, ꯵:꯱꯲:꯰꯲ ꯄꯤ.ꯑꯦꯝ.ꯄꯤ.ꯑꯦꯁ.ꯇꯤ
// ꯑꯔꯤꯖꯤꯅꯦꯜ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯁꯤ ꯍꯣꯡꯗꯣꯀꯄꯥ ꯂꯩꯇꯦ꯫ ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯍꯧꯖꯤꯛ.ꯂꯣꯀꯦꯜꯁ꯭ꯠꯔꯤꯡꯗꯥ()); // ꯲/꯲꯸/꯲꯰꯲꯶, ꯸:꯱꯲:꯰꯲ ꯄꯤ.ꯑꯦꯝ.ꯏ.ꯑꯦꯁ.ꯇꯤ
ꯅꯣꯠ: toLocaleStringꯅꯥ ꯍꯜꯂꯀꯄꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯚꯦꯜꯌꯨꯁꯤꯡ ꯑꯁꯤ, ꯃꯃꯤꯡꯅꯥ ꯇꯥꯀꯄꯒꯨꯝꯅꯥ, ꯂꯣꯀꯦꯜ-ꯗꯤꯄꯦꯟꯗꯦꯟꯇ ꯑꯣꯏ꯫ ꯁꯦꯝꯄꯜ ꯀꯣꯗ ꯑꯁꯤ ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯂꯣꯀꯦꯂꯗꯥ ꯁꯦꯃꯈꯤꯕꯅꯤ, ꯃꯔꯝ ꯑꯗꯨꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯑꯁꯤ ꯑꯁꯤꯒꯨꯝꯅꯥ ꯑꯣꯏꯔꯤ: ꯲/꯲꯸/꯲꯰꯲꯶, ꯵:꯱꯲:꯰꯲ ꯄꯤ.ꯑꯦꯝ.ꯄꯤ.ꯑꯦꯁ.ꯇꯤ. ꯑꯇꯣꯞꯄꯥ ꯂꯣꯀꯦꯜ ꯑꯃꯗꯥ, ꯃꯁꯤ ꯇꯣꯉꯥꯅꯕꯥ ꯑꯣꯏꯕꯥ ꯌꯥꯏ꯫ ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ, ꯑꯦꯟ-ꯖꯤ.ꯕꯤ.ꯒꯤ ꯂꯣꯀꯦꯂꯗꯥ, ꯅꯍꯥꯛꯅꯥ ꯲꯸/꯲/꯲꯰꯲꯶, ꯱꯷:꯱꯲:꯰꯲ ꯖꯤ.ꯑꯦꯝ.ꯇꯤ.-꯸ꯒꯨꯝꯕꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯈꯔꯥ ꯐꯪꯒꯅꯤ꯫ ꯔꯤꯑꯦꯜ-ꯋꯥꯔꯜꯗ ꯔꯤꯐꯦꯛꯇꯔꯤꯡ ꯑꯃꯥ꯫ ꯑꯩꯈꯣꯌꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯄꯨꯝꯅꯃꯛꯇꯥ ꯊꯧꯔꯃꯁꯤꯡ ꯁꯦꯗ꯭ꯌꯨꯜ ꯇꯧꯅꯕꯒꯤꯗꯃꯛ ꯑꯦꯞ ꯑꯃꯥ ꯁꯦꯃꯒꯠꯂꯤ ꯍꯥꯌꯅꯥ ꯂꯧꯔꯁꯤ꯫ ꯑꯦꯞ ꯑꯁꯤꯒꯤ ꯁꯔꯨꯛ ꯑꯃꯥ ꯑꯣꯏꯅꯥ ꯐꯉ꯭ꯀꯁꯟ ꯑꯃꯅꯤ, getEventTimes, ꯃꯁꯤꯅꯥ ꯊꯧꯗꯣꯛ ꯑꯗꯨꯒꯤ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡ, ꯂꯣꯀꯦꯜ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯃꯥ, ꯑꯃꯁꯨꯡ ꯇꯥꯔꯒꯦꯠ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯃꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯕꯥ ISO 8601 ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯂꯧꯏ꯫ ꯐꯉ꯭ꯀꯁꯟ ꯑꯁꯤꯅꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯅꯤꯃꯛꯇꯥ ꯂꯩꯕꯥ ꯊꯧꯗꯣꯛ ꯑꯗꯨꯒꯤꯗꯃꯛ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯔꯕꯥ ꯃꯇꯝ ꯑꯃꯁꯨꯡ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡꯁꯤꯡ ꯁꯦꯝꯃꯤ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯐꯉ꯭ꯀꯁꯟ ꯑꯗꯨꯗꯥ ꯆꯠꯅꯕꯥ ꯌꯥꯕꯥ ꯃꯇꯝ/ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯅꯠꯇꯕꯥ ꯏꯅꯄꯨꯠ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯄꯤꯔꯕꯗꯤ, ꯃꯁꯤꯅꯥ ꯑꯁꯣꯌꯕꯥ ꯑꯃꯥ ꯊꯥꯗꯣꯛꯀꯅꯤ꯫ ꯃꯐꯝ ꯑꯁꯤꯗꯥ ꯑꯔꯤꯕꯥ ꯏꯃꯞꯂꯤꯃꯦꯟꯇ ꯇꯧꯕꯥ, ꯃꯣꯃꯦꯟꯇ ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ (ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯄꯦꯀꯦꯖ ꯁꯤꯖꯤꯟꯅꯕꯁꯨ ꯃꯊꯧ ꯇꯥꯏ)꯫
‘ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ’ꯗꯒꯤ ꯃꯣꯃꯦꯟꯇ ꯏꯝꯄꯣꯔꯠ ꯇꯧꯕꯥ;
function getEventTimes(inputString, ꯌꯨꯖꯔꯇꯥꯏꯃꯖꯣꯟ, ꯇꯥꯔꯒꯦꯇꯇꯥꯏꯃꯖꯣꯟ) { const timeFormat = 'ꯑꯦꯝ.ꯑꯦꯝ.ꯑꯦꯝ.ꯗꯤ, ꯋꯥꯏ.ꯋꯥꯏ.ꯋꯥꯏ., h:mm:ss a z';
// 1. ꯌꯨꯖꯔꯒꯤ ꯇꯥꯏꯝ ꯖꯣꯅꯗꯥ ꯑꯍꯥꯅꯕꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯗꯨ ꯁꯦꯝꯃꯨ꯫ ꯀꯟꯁꯠ ꯏꯚꯦꯟꯇꯇꯥꯏꯝ = ꯃꯣꯃꯦꯟꯇ.tz( ꯏꯅꯄꯨꯠꯁ꯭ꯠꯔꯤꯡ, ꯴. moment.ISO_8601, // ISO 8601 ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯑꯦꯛꯁꯄꯦꯛꯇ ꯇꯧꯔꯣ true, // ꯑꯀꯅꯕꯥ ꯄꯥꯔꯁꯤꯡ ꯇꯧꯕꯥ꯫ ꯌꯨꯖꯔꯇꯥꯏꯃꯖꯣꯟ꯫ );
// ꯀꯔꯤꯒꯨꯝꯕꯥ inputStringꯅꯥ ꯆꯠꯅꯕꯥ ꯌꯥꯕꯥ ꯇꯥꯡ ꯑꯃꯥ ꯔꯤꯞꯔꯖꯦꯟꯇ ꯇꯧꯗ꯭ꯔꯕꯗꯤ ꯑꯦꯔꯥꯔ ꯑꯃꯥ ꯊꯥꯗꯣꯀꯎ ꯀꯔꯤꯒꯨꯝꯕꯥ (!ꯏꯚꯦꯟꯇꯇꯥꯏꯝ.ꯏꯁꯚꯦꯂꯤꯗ()) { throw new Error('ꯑꯁꯣꯌꯕꯥ ꯇꯥꯡ/ꯃꯇꯝ ꯏꯅꯄꯨꯠ'); }
// 2. ꯇꯥꯔꯒꯦꯠ ꯃꯇꯝ ꯑꯗꯨ ꯂꯦꯄꯊꯣꯀꯄꯥ꯫ // CRITICAL: ꯑꯩꯈꯣꯌꯅꯥ ꯀ꯭ꯂꯣꯟ ꯇꯧꯒꯗꯕꯅꯤ, ꯅꯠꯔꯒꯥ 'eventTime' ꯃꯇꯝ ꯆꯨꯞꯄꯒꯤ ꯑꯣꯏꯅꯥ ꯍꯣꯡꯂꯛꯀꯅꯤ! const targetTime = ꯏꯚꯦꯟꯇꯇꯥꯏꯝ.ꯀ꯭ꯂꯣꯟ().tz(ꯇꯥꯔꯒꯦꯇꯇꯥꯏꯃꯖꯣꯟ);
return { ꯂꯣꯀꯦꯜ: ꯏꯚꯦꯟꯇꯇꯥꯏꯝ.ꯐꯣꯔꯃꯦꯠ(ꯇꯥꯏꯃꯐꯣꯔꯃꯦꯠ), ꯄꯥꯟꯗꯝ: ꯇꯥꯔꯒꯦꯇꯇꯥꯏꯝ.ꯐꯣꯔꯃꯦꯠ(ꯇꯥꯏꯃꯐꯣꯔꯃꯦꯠ), }; }
ꯀꯟꯁꯠ ꯁꯦꯗ꯭ꯌꯨꯜ = getEventTimes( ‘꯲꯰꯲꯶-꯰꯳-꯰꯵ꯇꯤ꯱꯵:꯰꯰-꯰꯵:꯰꯰’, ‘ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ’, ꯴. ‘ꯌꯨꯔꯣꯞ/ꯂꯟꯗꯟ’, ꯴. );
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯁꯦꯗ꯭ꯌꯨꯜ.ꯂꯣꯀꯦꯜ); // ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯅꯨꯃꯤꯗꯥꯡ ꯄꯨꯡ ꯳:꯰꯰:꯰꯰ ꯏ.ꯑꯦꯁ.ꯇꯤ
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯁꯦꯗ꯭ꯌꯨꯜ.ꯇꯥꯔꯒꯦꯠ); // ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯅꯨꯃꯤꯗꯥꯡ ꯄꯨꯡ ꯸:꯰꯰:꯰꯰ꯗꯥ ꯖꯤ.ꯑꯦꯝ.ꯇꯤ
ꯈꯨꯗꯝ ꯑꯁꯤꯗꯥ, ꯑꯩꯈꯣꯌꯅꯥ ꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ.꯸꯶꯰꯱ꯒꯤ ꯑꯦꯛꯁꯄꯦꯛꯇꯦꯗ ꯗꯦꯠ ꯐꯣꯔꯃꯦꯠ ꯑꯃꯥ ꯁꯤꯖꯤꯟꯅꯔꯤ, ꯃꯁꯤ ꯃꯇꯦꯡ ꯄꯥꯡꯗꯨꯅꯥ ꯃꯣꯃꯦꯟꯇꯇꯥ ꯁꯦꯃꯈꯤꯕꯅꯤ꯫ ꯑꯩꯈꯣꯌꯅꯥ ꯑꯀꯅꯕꯥ ꯄꯥꯔꯁꯤꯡꯁꯨ ꯁꯤꯖꯤꯟꯅꯔꯤ, ꯃꯁꯤꯅꯥ ꯇꯥꯀꯄꯗꯤ ꯃꯣꯃꯦꯟꯇꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯑꯗꯨꯒꯥ ꯃꯥꯟꯅꯗꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯒꯦꯁ ꯇꯧꯅꯕꯥ ꯍꯣꯠꯅꯔꯣꯏ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯟ-ISO ꯗꯦꯠ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯄꯥꯁ ꯇꯧꯔꯕꯗꯤ, ꯃꯁꯤꯅꯥ ꯑꯁꯣꯌꯕꯥ ꯗꯦꯠ ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯊꯣꯀꯍꯅꯒꯅꯤ, ꯑꯃꯁꯨꯡ ꯑꯩꯈꯣꯌꯅꯥ ꯑꯦꯔꯥꯔ ꯑꯃꯥ ꯊꯥꯏ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯏꯃꯞꯂꯤꯃꯦꯟꯇꯦꯁꯟ ꯑꯁꯤ ꯃꯥꯟꯅꯕꯥ ꯃꯑꯣꯡꯗꯥ ꯎꯕꯥ ꯐꯪꯏ, ꯑꯗꯨꯕꯨ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯈꯦꯠꯅꯕꯥ ꯈꯔꯥ ꯂꯩ꯫
function getEventTimes(inputString, ꯌꯨꯖꯔꯇꯥꯏꯃꯖꯣꯟ, ꯇꯥꯔꯒꯦꯇꯇꯥꯏꯃꯖꯣꯟ) { // 1. ꯏꯅꯄꯨꯠ ꯑꯗꯨ ꯍꯀꯊꯦꯡꯅꯅꯥ ꯏꯟꯁꯇꯦꯟꯇ ꯑꯃꯗꯥ ꯄꯥꯔꯁ ꯇꯧ, ꯃꯗꯨꯒꯤ ꯃꯇꯨꯡꯗꯥ ꯁꯦꯝꯃꯨ꯫ // ꯌꯨꯖꯔꯒꯤ ꯖꯣꯅꯗꯥ ꯂꯩꯕꯥ ZonedDateTime ꯑꯃꯥ꯫ const instant = ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯏꯟꯁꯇꯦꯟꯇ.ꯐ꯭ꯔꯣꯝ(ꯏꯅꯄꯨꯠꯁ꯭ꯠꯔꯤꯡ); const eventTime = ꯏꯟꯁꯇꯦꯟꯇ.ꯇꯨꯖꯣꯅꯦꯗꯗꯦꯇꯇꯥꯏꯃꯑꯥꯏꯑꯦꯁꯑꯣ(ꯌꯨꯖꯔꯇꯥꯏꯃꯖꯣꯟ);
// 2. ꯇꯥꯔꯒꯦꯠ ꯖꯣꯅꯗꯥ ꯑꯣꯟꯊꯣꯀꯄꯥ꯫ // ꯃꯁꯤꯅꯥ ꯑꯣꯇꯣꯃꯦꯇꯤꯛ ꯑꯣꯏꯅꯥ NEW ꯑꯣꯕꯖꯦꯛꯇ ꯑꯃꯥ ꯔꯤꯇꯔ ꯇꯧꯏ; 'eventTime' ꯑꯁꯤ ꯁꯦꯐ ꯑꯣꯏ꯫ const targetTime = ꯏꯚꯦꯟꯇꯇꯥꯏꯝ.withTimeZone(ꯇꯥꯔꯒꯦꯇꯇꯥꯏꯃꯖꯣꯟ);
// 3. Intl (ꯕꯤꯜꯇ-ꯏꯟ) ꯁꯤꯖꯤꯟꯅꯗꯨꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯕꯥ ꯀꯟꯁꯠ ꯑꯣꯄꯁꯅꯁꯤꯡ = { ꯆꯍꯤ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯊꯥ: ‘ꯁꯣꯔꯠ’, ꯴. ꯅꯨꯃꯤꯠ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯄꯨꯡ: ‘ꯅ꯭ꯌꯨꯃꯦꯔꯤꯛ’, ꯴. ꯃꯤꯅꯤꯠ: ‘꯲-ꯗꯤꯖꯤꯠ’, ꯴. ꯑꯅꯤꯁꯨꯕꯗꯥ: ‘꯲-ꯗꯤꯖꯤꯠ’, ꯴. timeZoneName: 'ꯁꯣꯔꯠ' ꯇꯧꯕꯥ꯫ };
return { ꯂꯣꯀꯦꯜ: eventTime.toLocaleString(ꯅꯦꯚꯤꯒꯦꯇꯔ.ꯂꯣꯜ, ꯑꯣꯄꯁꯅꯁꯤꯡ), target: targetTime.toLocaleString(ꯅꯦꯚꯤꯒꯦꯇꯔ.ꯂꯣꯜ, ꯑꯣꯄꯁꯅꯁꯤꯡ) }; }
ꯀꯟꯁꯠ ꯁꯦꯗ꯭ꯌꯨꯜ = getEventTimes( ‘꯲꯰꯲꯶-꯰꯳-꯰꯵ꯇꯤ꯱꯵:꯰꯰-꯰꯵:꯰꯰’, ‘ꯑꯃꯦꯔꯤꯀꯥ/ꯅ꯭ꯌꯨ_ꯌꯣꯔꯛ’, ꯴. ‘ꯌꯨꯔꯣꯞ/ꯂꯟꯗꯟ’, ꯴. );
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯁꯦꯗ꯭ꯌꯨꯜ.ꯂꯣꯀꯦꯜ); // ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯄꯨꯡ ꯳:꯰꯰:꯰꯰ ꯄꯤ.ꯑꯦꯝ.ꯏ.ꯑꯦꯁ.ꯇꯤ
ꯀꯟꯁꯣꯜ.ꯂꯣꯒ(ꯁꯦꯗ꯭ꯌꯨꯜ.ꯇꯥꯔꯒꯦꯠ); // ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯄꯨꯡ ꯸:꯰꯰:꯰꯰ ꯄꯤ.ꯑꯦꯝ.ꯖꯤ.ꯑꯦꯝ.ꯇꯤ
ꯃꯣꯃꯦꯟꯇꯀꯥ ꯂꯣꯌꯅꯅꯥ, ꯑꯩꯈꯣꯌꯅꯥ ꯔꯤꯖꯜꯇ ꯑꯣꯏꯕꯥ ꯇꯥꯡ ꯁ꯭ꯠꯔꯤꯡꯁꯤꯡꯒꯤꯗꯃꯛ ꯐꯣꯔꯃꯦꯠ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ ꯃꯌꯦꯛ ꯁꯦꯡꯅꯥ ꯇꯥꯀꯄꯥ ꯇꯥꯏ꯫ ꯌꯨꯖꯔꯒꯤ ꯃꯐꯝ ꯅꯠꯔꯒꯥ ꯂꯣꯀꯦꯜ ꯌꯦꯡꯗꯅꯥ, ꯊꯧꯔꯝ ꯑꯁꯤꯒꯤ ꯃꯇꯃꯁꯤꯡ ꯑꯁꯤ ꯃꯇꯝ ꯄꯨꯝꯅꯃꯛꯇꯥ ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯳:꯰꯰:꯰꯰ ꯍꯥꯌꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯒꯅꯤ꯫ꯄꯤ.ꯑꯦꯝ.ꯏ.ꯑꯦꯁ.ꯇꯤ. ꯑꯃꯗꯤ, ꯑꯩꯈꯣꯌꯅꯥ ꯃꯌꯦꯛ ꯁꯦꯡꯅꯥ ꯑꯦꯛꯁꯦꯞꯁꯟ ꯑꯃꯥ ꯊꯥꯗꯣꯀꯄꯥ ꯃꯊꯧ ꯇꯥꯗꯦ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯁꯣꯌꯕꯥ ꯁ꯭ꯠꯔꯤꯡ ꯑꯃꯥ Temporal.Instant.from ꯗꯥ ꯄꯥꯁ ꯇꯧꯔꯕꯗꯤ, Temporalꯅꯥ ꯑꯩꯈꯣꯌꯒꯤꯗꯃꯛ ꯑꯦꯛꯁꯦꯞꯁꯟ ꯑꯗꯨ ꯊꯥꯗꯣꯛꯀꯅꯤ꯫ ꯅꯣꯠ ꯇꯧꯒꯗꯕꯥ ꯋꯥꯐꯝ ꯑꯃꯅꯥ ꯑꯀꯅꯕꯥ ꯄꯥꯔꯁꯤꯡ ꯇꯧꯔꯕꯁꯨ ꯃꯣꯃꯦꯟꯇ ꯚꯔꯖꯟ ꯑꯁꯤ ꯍꯧꯖꯤꯀꯁꯨ ꯍꯦꯟꯅꯥ ꯂꯦꯡꯗꯕꯥ ꯑꯣꯏꯔꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯁ꯭ꯠꯔꯤꯡꯒꯤ ꯑꯔꯣꯏꯕꯗꯥ ꯂꯩꯕꯥ ꯇꯥꯏꯝ ꯖꯣꯟ ꯑꯣꯐꯁꯦꯠ ꯃꯊꯧ ꯇꯥꯏ꯫ ꯅꯍꯥꯛꯅꯥ ꯃꯁꯤꯃꯁꯨ ꯈꯪꯖꯤꯅꯒꯗꯕꯗꯤ ꯑꯩꯈꯣꯌꯅꯥ navigator.language ꯁꯤꯖꯤꯟꯅꯔꯤꯕꯅꯥ ꯃꯔꯝ ꯑꯣꯏꯗꯨꯅꯥ, ꯀꯣꯗ ꯑꯁꯤ ꯕ꯭ꯔꯥꯎꯖꯔ ꯑꯦꯅꯚꯥꯏꯔꯅꯃꯦꯟꯇ ꯑꯃꯈꯛꯇꯗꯥ ꯆꯠꯀꯅꯤ, ꯃꯔꯃꯗꯤ ꯅꯦꯚꯤꯒꯦꯇꯔ ꯑꯁꯤ Node.js ꯑꯦꯅꯚꯥꯏꯔꯅꯃꯦꯟꯇ ꯑꯃꯗꯥ ꯗꯤꯐꯥꯏꯟ ꯇꯧꯗꯦ꯫ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯏꯃꯞꯂꯤꯃꯦꯟꯇꯦꯁꯟ ꯑꯁꯤꯅꯥ ꯕ꯭ꯔꯥꯎꯖꯔꯒꯤ ꯍꯧꯖꯤꯛꯀꯤ ꯂꯣꯀꯦꯜ (navigator.language) ꯁꯤꯖꯤꯟꯅꯩ, ꯃꯔꯝ ꯑꯗꯨꯅꯥ ꯌꯨꯖꯔꯅꯥ ꯃꯈꯣꯌꯒꯤ ꯂꯣꯀꯦꯜ ꯇꯥꯏꯝ ꯐꯣꯔꯃꯦꯠꯇꯥ ꯏꯚꯦꯟꯇ ꯇꯥꯏꯃꯁꯤꯡ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯕꯥ ꯑꯣꯇꯣꯃꯦꯇꯤꯛ ꯑꯣꯏꯅꯥ ꯐꯪꯒꯅꯤ꯫ ꯑꯦꯟ-ꯌꯨ.ꯑꯦꯁ.ꯀꯤ ꯂꯣꯀꯦꯂꯗꯥ, ꯃꯁꯤ ꯃꯥꯔꯆ ꯵, ꯲꯰꯲꯶, ꯅꯨꯃꯤꯗꯥꯡ ꯄꯨꯡ ꯳:꯰꯰:꯰꯰ ꯏ.ꯑꯦꯁ.ꯇꯤ. ꯑꯗꯨꯝ ꯑꯣꯏꯅꯃꯛ, ꯀꯔꯤꯒꯨꯝꯕꯥ ꯌꯨꯖꯔ ꯑꯗꯨ ꯈꯨꯗꯝ ꯑꯣꯏꯅꯥ ꯂꯟꯗꯟꯗꯥ ꯂꯩꯔꯕꯗꯤ, ꯊꯧꯔꯝ ꯑꯁꯤꯒꯤ ꯃꯇꯃꯁꯤꯡ ꯑꯁꯤ ꯵ ꯃꯥꯔꯆ ꯲꯰꯲꯶, ꯱꯵:꯰꯰:꯰꯰ ꯖꯤ.ꯑꯦꯝ.ꯇꯤ.-꯵ ꯍꯥꯌꯅꯥ ꯐꯣꯔꯃꯦꯠ ꯇꯧꯒꯅꯤ꯫ ꯁꯃꯖꯤꯟꯅꯐꯝ ꯑꯣꯏꯕꯥ꯫
ꯑꯦꯛꯁꯟ ꯂꯧꯈꯠꯄꯥ꯫ ꯃꯣꯃꯦꯟꯇ.ꯖꯦ.ꯑꯦꯁ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯣꯏꯕꯥ꯫ ꯍꯧꯖꯤꯛꯀꯤ ꯃꯇꯝ꯫ ꯃꯣꯃꯦꯟꯇ() ꯴. ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯍꯧꯖꯤꯛ.ꯖꯣꯟ ꯇꯧꯔꯕꯥ ꯇꯥꯡꯇꯥꯏꯃꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ.() ꯄꯥꯔꯁꯤꯡ ꯇꯧꯕꯥ ꯑꯥꯏ.ꯑꯦꯁ.ꯑꯣ ꯃꯣꯃꯦꯟꯇ(ꯁ꯭ꯠꯔ) ꯑꯃꯁꯨꯡ ꯑꯦꯝ. ꯇꯦꯝꯄꯣꯔꯦꯜ.ꯏꯟꯁꯇꯦꯟꯇ.ꯐ꯭ꯔꯣꯝ(str) ꯃꯇꯝ ꯍꯥꯄꯆꯤꯅꯕꯥ꯫ .add(7, 'ꯅꯨꯃꯤꯠ') (ꯃ꯭ꯌꯨꯇꯦꯠ ꯇꯧꯕꯥ) .add({ ꯅꯨꯃꯤꯠ: ꯷ }) (ꯑꯅꯧꯕꯥ ꯄꯣꯠꯁꯛ) ꯈꯦꯟꯅꯕꯥ ꯂꯩꯕꯥ꯫ .diff(ꯑꯇꯣꯞꯄꯥ, 'ꯄꯨꯡꯁꯤꯡ') .ꯃꯔꯃꯗꯒꯤ(ꯑꯇꯣꯞꯄꯥ).ꯄꯨꯡꯁꯤꯡ꯫ ꯃꯇꯃꯒꯤ ꯃꯐꯝ꯫ .tz('ꯖꯣꯟ/ꯃꯃꯤꯡ') .withTimeZone('ꯖꯣꯟ/ꯃꯃꯤꯡ')
ꯑꯍꯥꯅꯕꯥ ꯌꯦꯡꯕꯗꯥ, ꯈꯦꯠꯅꯕꯥ ꯑꯁꯤ ꯈꯔꯥ ꯇꯣꯉꯥꯅꯕꯥ ꯑꯣꯏꯕꯥ ꯌꯥꯏ (ꯑꯗꯨꯒꯥ ꯇꯦꯝꯄꯣꯔꯦꯂꯒꯤ ꯑꯣꯏꯅꯗꯤ, ꯀꯔꯤꯒꯨꯝꯕꯥ ꯃꯇꯃꯗꯥ ꯍꯦꯟꯅꯥ ꯋꯥꯍꯟꯊꯣꯛ ꯂꯩꯕꯥ ꯑꯃꯁꯨꯡ ꯍꯦꯟꯅꯥ ꯀꯟꯅꯥ) ꯁꯤꯟꯇꯦꯛꯁ ꯑꯣꯏꯕꯥ ꯌꯥꯏ, ꯑꯗꯨꯕꯨ Moment.jsꯗꯒꯤ ꯍꯦꯟꯅꯥ Temporal ꯁꯤꯖꯤꯟꯅꯕꯒꯤ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯀꯥꯟꯅꯕꯥ ꯀꯌꯥ ꯂꯩ:
ꯍꯦꯟꯅꯥ ꯃꯌꯦꯛ ꯁꯦꯡꯕꯥ ꯍꯥꯌꯕꯁꯤꯅꯥ ꯑꯉꯀꯄꯥ ꯑꯃꯁꯨꯡ ꯑꯅꯤꯡꯕꯥ ꯑꯄꯥꯝꯕꯥ ꯍꯟꯊꯍꯅꯕꯥ ꯍꯥꯌꯕꯁꯤꯅꯤ꯫ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤ ꯍꯦꯟꯅꯥ ꯂꯦꯡ-ꯑꯣꯠꯄꯥ ꯑꯣꯏꯅꯥ ꯎꯕꯥ ꯌꯥꯏ, ꯑꯗꯨꯕꯨ ꯃꯁꯤꯗꯥ “ꯒꯦꯁꯋꯔꯛ” ꯌꯥꯑꯣꯏ, ꯃꯁꯤꯅꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯃꯇꯃꯗꯥ ꯑꯔꯥꯅꯕꯥ ꯇꯥꯡꯁꯤꯡ ꯊꯣꯀꯍꯅꯕꯥ ꯌꯥꯏ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ Temporal ꯗꯥ ꯑꯁꯣꯌꯕꯥ ꯑꯃꯥ ꯄꯤꯔꯕꯗꯤ, ꯃꯁꯤꯅꯥ ꯑꯦꯔꯥꯔ ꯑꯃꯥ ꯊꯥꯏ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯀꯣꯗ ꯑꯗꯨ ꯆꯠꯂꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯆꯠꯅꯕꯥ ꯌꯥꯕꯥ ꯇꯥꯡ ꯑꯃꯥ ꯐꯪꯂꯦ ꯍꯥꯌꯕꯥ ꯈꯪꯒꯅꯤ꯫ ꯃꯣꯃꯦꯟꯇꯅꯥ ꯑꯦꯞꯂꯤꯀꯦꯁꯅꯒꯤ ꯕꯟꯗꯂꯗꯥ ꯃꯔꯨꯑꯣꯏꯕꯥ ꯁꯥꯏꯖ ꯍꯥꯄꯆꯤꯅꯕꯥ ꯌꯥꯏ, ꯃꯔꯨꯑꯣꯏꯅꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯄꯦꯀꯦꯖ ꯁꯤꯖꯤꯟꯅꯔꯕꯗꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯑꯃꯠꯇꯥ ꯍꯥꯄꯆꯤꯜꯂꯤ (ꯃꯁꯤ ꯅꯍꯥꯛꯀꯤ ꯇꯥꯔꯒꯦꯠ ꯕ꯭ꯔꯥꯎꯖꯔꯁꯤꯡꯗꯥ ꯊꯥꯔꯀꯄꯥ ꯃꯇꯃꯗꯥ)꯫ ꯏꯝꯌꯨꯇꯦꯕꯤꯂꯤꯇꯤꯅꯥ ꯅꯍꯥꯀꯄꯨ ꯗꯦꯠ ꯀꯟꯕꯔꯁꯟ ꯑꯃꯁꯨꯡ ꯑꯣꯄꯔꯦꯁꯅꯁꯤꯡ ꯄꯥꯡꯊꯣꯀꯄꯥ ꯃꯇꯃꯗꯥ ꯀꯩꯗꯧꯉꯩꯗꯥ ꯗꯦꯇꯥ ꯃꯥꯡꯍꯅꯕꯥ ꯅꯠꯠꯔꯒꯥ ꯑꯣꯚꯔꯔꯥꯏꯠ ꯇꯧꯔꯣꯏ ꯍꯥꯌꯕꯒꯤ ꯊꯥꯖꯕꯥ ꯄꯤꯔꯤ꯫ ꯑꯗꯣꯃꯒꯤ ꯗꯔꯀꯥꯔ ꯑꯣꯏꯕꯁꯤꯡꯒꯤ ꯃꯇꯨꯡ ꯏꯟꯅꯥ ꯃꯇꯃꯒꯤ ꯇꯣꯉꯥꯟ ꯇꯣꯉꯥꯅꯕꯥ ꯔꯤꯞꯔꯖꯦꯟꯇꯦꯁꯅꯁꯤꯡ (Instant, PlainDateTime, ZonedDateTime), ꯃꯐꯝ ꯑꯗꯨꯗꯥ ꯃꯣꯃꯦꯟꯇ ꯑꯁꯤ ꯃꯇꯝ ꯄꯨꯝꯕꯗꯥ UTC ꯇꯥꯏꯃꯁ꯭ꯇꯦꯝꯄ ꯑꯃꯒꯤ ꯑꯀꯣꯌꯕꯗꯥ ꯔꯦꯄꯔ ꯑꯃꯅꯤ꯫ ꯇꯦꯝꯄꯣꯔꯦꯂꯅꯥ ꯇꯥꯡ ꯐꯣꯔꯃꯦꯇꯤꯡꯒꯤꯗꯃꯛ Intl APIꯁꯤꯡ ꯁꯤꯖꯤꯟꯅꯩ, ꯃꯁꯤꯅꯥ ꯇꯥꯀꯄꯗꯤ ꯅꯍꯥꯛꯅꯥ ꯇꯣꯀꯦꯅꯁꯤꯡ ꯃꯌꯦꯛ ꯁꯦꯡꯅꯥ ꯇꯥꯀꯄꯥ ꯃꯊꯧ ꯇꯥꯗꯅꯥ ꯂꯣꯀꯦꯜ-ꯑꯦꯋꯥꯔ ꯐꯣꯔꯃꯦꯇꯤꯡ ꯂꯩꯕꯥ ꯌꯥꯏ꯫
ꯅꯣꯇꯁ ꯑꯣꯟ ꯗꯤ ꯄꯣꯂꯤꯐꯤꯜ꯫ ꯃꯃꯥꯡꯗꯥ ꯍꯥꯌꯈꯤꯕꯒꯨꯝꯅꯥ, ꯇꯦꯝꯄꯣꯔꯦꯜ ꯄꯣꯂꯤꯐꯤꯜ ꯑꯃꯥ ꯐꯪꯏ, ꯃꯁꯤ @js-temporal/polyfill ꯍꯥꯌꯅꯥ ꯃꯃꯤꯡ ꯊꯣꯅꯕꯥ npm ꯄꯦꯀꯦꯖ ꯑꯃꯥ ꯑꯣꯏꯅꯥ ꯌꯦꯟꯊꯣꯀꯏ꯫ ꯀꯔꯤꯒꯨꯝꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯉꯁꯤ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯁꯤꯖꯤꯟꯅꯕꯥ ꯄꯥꯝꯂꯕꯗꯤ, ꯅꯍꯥꯛꯅꯥ ꯍꯧꯖꯤꯛ ꯐꯥꯑꯣꯕꯥ ꯑꯦ.ꯄꯤ.ꯑꯥꯏ. ꯃꯁꯤꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯐꯠꯇꯕꯥ ꯄꯥꯎ ꯑꯃꯗꯤ ꯃꯁꯤꯅꯥ ꯅꯍꯥꯛꯀꯤ ꯕꯟꯗꯜ ꯁꯥꯏꯖꯗꯥ ꯑꯍꯦꯅꯕꯥ ꯄꯤꯒꯅꯤ꯫ ꯅꯨꯡꯉꯥꯏꯕꯥ ꯄꯥꯎ ꯑꯃꯗꯤ ꯃꯁꯤꯅꯥ ꯍꯧꯖꯤꯀꯁꯨ ꯃꯣꯃꯦꯟꯇ ꯅꯠꯔꯒꯥ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯅꯗꯒꯤ ꯌꯥꯝꯅꯥ ꯍꯟꯊꯅꯥ ꯍꯥꯄꯆꯤꯜꯂꯤ꯫ ꯃꯐꯃꯁꯤꯗꯥ npm ꯄꯦꯀꯦꯖ ꯁꯥꯏꯖꯁꯤꯡꯒꯤ ꯃꯇꯥꯡꯗꯥ ꯏꯅꯐꯣꯔꯃꯦꯁꯟ ꯄꯤꯔꯤꯕꯥ ꯋꯦꯕꯁꯥꯏꯠ ꯑꯃꯥ ꯑꯣꯏꯔꯤꯕꯥ Bundlephobia.comꯅꯥ ꯔꯤꯄꯣꯔꯠ ꯇꯧꯔꯀꯄꯒꯤ ꯃꯇꯨꯡꯏꯟꯅꯥ ꯕꯟꯗꯜ ꯁꯥꯏꯖꯁꯤꯡꯒꯤ ꯆꯥꯡꯗꯝꯅꯕꯥ ꯑꯃꯥ ꯄꯤꯔꯤ (ꯕꯟꯗꯂꯐꯣꯕꯤꯌꯥ ꯑꯦꯅꯥꯂꯥꯏꯁꯤꯁ ꯌꯦꯡꯅꯕꯒꯤꯗꯃꯛ ꯄꯦꯀꯦꯖ ꯈꯨꯗꯤꯡꯃꯛꯀꯤ ꯃꯃꯤꯡꯗꯥ ꯀ꯭ꯂꯤꯛ ꯇꯧꯕꯤꯌꯨ):
ꯄꯦꯀꯦꯖ ꯑꯁꯤ ꯌꯥꯑꯣꯔꯤ꯫ ꯃꯤꯅꯤꯐꯥꯏꯗ ꯇꯧꯔꯕꯥ꯫ ꯃꯤꯅꯤꯐꯥꯏꯗ & ꯖꯤ.ꯖꯤ.ꯄꯤ @js-ꯇꯦꯝꯄꯣꯔꯦꯜ/ꯄꯣꯂꯤꯐꯤꯜ ꯇꯧꯕꯥ꯫ ꯱꯵꯴.꯱ ꯀꯦ.ꯕꯤ ꯴꯴.꯱ ꯀꯦ.ꯕꯤ ꯃꯣꯃꯦꯟꯇꯝ ꯑꯃꯥ꯫ ꯲꯹꯴.꯴ ꯀꯦ.ꯕꯤ ꯷꯵.꯴ ꯀꯦ.ꯕꯤ ꯃꯣꯃꯦꯟꯇ-ꯇꯥꯏꯃꯖꯣꯟ ꯑꯣꯏꯕꯥ ꯌꯥꯏ꯫ ꯱ ꯑꯦꯝ.ꯕꯤ ꯱꯱꯴.꯲ ꯀꯦ.ꯕꯤ
ꯄꯣꯂꯤꯐꯤꯜ ꯑꯁꯤꯁꯨ ꯄꯨꯋꯥꯔꯤ ꯑꯣꯏꯅꯥ ꯃꯦꯃꯣꯔꯤ ꯁꯤꯖꯤꯟꯅꯕꯒꯤ ꯑꯀꯣꯌꯕꯗꯥ ꯄꯔꯐꯣꯃꯦꯟꯁꯀꯤ ꯏꯁꯨ ꯈꯔꯥ ꯂꯩꯔꯝꯃꯤ, ꯑꯃꯁꯨꯡ ꯏꯕꯥ ꯃꯇꯃꯗꯥ ꯃꯁꯤ ꯑꯥꯂꯐꯥ ꯁ꯭ꯇꯦꯠꯇꯥ ꯂꯩ ꯍꯥꯌꯅꯥ ꯂꯧꯅꯩ꯫ ꯃꯁꯤꯅꯥ ꯃꯔꯝ ꯑꯣꯏꯗꯨꯅꯥ ꯍꯦꯟꯅꯥ ꯄꯤꯀꯄꯥ ꯐꯤꯚꯝ ꯑꯃꯗꯥ ꯌꯧꯔꯛꯠꯔꯤꯐꯥꯑꯣꯕꯥ ꯅꯍꯥꯛꯅꯥ ꯃꯁꯤ ꯄꯨꯊꯣꯀꯄꯗꯥ ꯁꯤꯖꯤꯟꯅꯕꯥ ꯄꯥꯃꯗꯕꯥ ꯌꯥꯏ꯫ ꯑꯇꯣꯞꯄꯥ ꯅꯨꯡꯉꯥꯏꯕꯥ ꯄꯥꯎ ꯑꯃꯅꯥ ꯄꯣꯂꯤꯐꯤꯜ ꯑꯁꯤ ꯌꯥꯝꯅꯥ ꯁꯥꯡꯅꯥ ꯃꯊꯧ ꯇꯥꯔꯣꯏ ꯍꯥꯌꯅꯥ ꯑꯥꯁꯥ ꯇꯧꯔꯤ (ꯑꯔꯤꯕꯥ ꯕ꯭ꯔꯥꯎꯖꯔꯁꯤꯡꯕꯨ ꯁꯄꯣꯔꯠ ꯇꯧꯕꯥ ꯃꯊꯧ ꯇꯥꯗ꯭ꯔꯕꯗꯤ, ꯇꯁꯦꯡꯕꯗꯤ)꯫ ꯏꯕꯥ ꯃꯇꯃꯗꯥ ꯇꯦꯝꯄꯣꯔꯦꯜ ꯑꯁꯤ ꯀ꯭ꯔꯣꯝ, ꯑꯦꯖ, ꯑꯃꯁꯨꯡ ꯐꯥꯏꯔꯐꯛꯁꯇꯥ ꯊꯥꯗꯣꯀꯈ꯭ꯔꯦ꯫ ꯃꯁꯤ ꯈ꯭ꯕꯥꯏꯗꯒꯤ ꯅꯧꯕꯥ ꯇꯦꯛꯅꯣꯂꯣꯖꯤ ꯄ꯭ꯔꯤꯚꯤꯎꯗꯥ ꯔꯅꯇꯥꯏꯝ ꯐ꯭ꯂꯦꯒ ꯑꯃꯒꯥ ꯂꯣꯌꯅꯅꯥ ꯐꯪꯂꯤꯕꯥ ꯑꯣꯏꯅꯥ ꯎꯕꯥ ꯐꯪꯂꯕꯁꯨ, ꯃꯁꯤ ꯍꯧꯖꯤꯛ ꯐꯥꯑꯣꯕꯥ ꯁꯐꯔꯤꯗꯥ ꯌꯥꯝꯅꯥ ꯁꯦꯝ ꯁꯥꯗ꯭ꯔꯤ꯫
