In This Article

ᱡᱚᱠᱷᱚᱱ ᱟᱢ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱯᱞᱟᱜᱽ ᱤᱱ ᱢᱮ, ᱟᱢ ᱵᱩᱛᱟᱢ ᱢᱮᱥ ᱢᱮ, ᱞᱟᱴᱠᱟᱣ ᱢᱮ, ᱴᱨᱤᱜᱚᱨ ᱚᱨ ᱢᱮ... ᱟᱨ ᱰᱮᱵᱷᱞᱚᱯᱟᱨ ᱞᱮᱠᱟᱛᱮ, ᱟᱢ ᱱᱚᱶᱟ ᱠᱚ ᱢᱩᱫᱽ ᱨᱮ ᱪᱮᱫ ᱦᱚᱸ ᱵᱟᱢ ᱧᱮᱞᱟ᱾ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱫᱚ ᱱᱚᱣᱟ ᱮ ᱦᱟᱛᱟᱣ ᱮᱫᱟ, ᱯᱟᱹᱛᱤᱭᱟᱹᱣ, ᱢᱮᱱᱠᱷᱟᱱ ᱡᱟᱦᱟᱸ ᱛᱤᱱ ᱦᱟᱹᱵᱤᱡ ᱟᱢ ᱠᱚᱱᱥᱚᱞ ᱨᱮ ᱮᱞ ᱵᱟᱢ ᱞᱚᱜᱤᱝ ᱮᱫᱟ, ᱱᱚᱣᱟ ᱫᱚ ᱵᱟᱝ ᱧᱮᱞᱚᱜᱼᱟ᱾ ᱜᱮᱢᱯᱮᱰ ᱮᱯᱤᱟᱭ ᱥᱟᱶ ᱚᱱᱟ ᱫᱚ ᱵᱚᱦᱚᱜ ᱦᱟᱥᱚ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱥᱮᱨᱢᱟ ᱠᱷᱚᱱ ᱜᱮ ᱢᱮᱱᱟᱜᱼᱟ, ᱟᱨ ᱱᱚᱣᱟ ᱫᱚ ᱥᱟᱹᱨᱤ ᱛᱮ ᱟᱹᱰᱤ ᱫᱟᱲᱮᱭᱟᱱ ᱜᱮᱭᱟ᱾ ᱟᱢ ᱵᱩᱛᱟᱢ, ᱞᱟᱴᱠᱟ, ᱴᱨᱤᱜᱚᱨ, ᱠᱟᱹᱢᱤ ᱠᱚ ᱯᱟᱲᱦᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ ᱢᱮᱱᱠᱷᱟᱱ ᱵᱤᱥᱛᱤ ᱦᱚᱲ ᱱᱚᱣᱟ ᱵᱟᱠᱚ ᱡᱚᱴᱮᱫᱟ᱾ ᱪᱫᱟ ᱪᱮᱫᱟᱜ? ᱪᱮᱫᱟᱜ ᱥᱮ ᱚᱱᱰᱮ ᱪᱮᱫ ᱦᱚᱸ ᱯᱷᱤᱰᱵᱮᱠ ᱵᱟᱹᱱᱩᱜᱼᱟ᱾ ᱰᱮᱵᱷᱞᱚᱯᱟᱨ ᱴᱩᱞᱥ ᱨᱮ ᱯᱮᱱᱮᱞ ᱵᱟᱹᱱᱩᱜᱼᱟ ᱾ ᱵᱟᱰᱟᱭ ᱞᱟᱹᱜᱤᱫ ᱪᱮᱫ ᱦᱚᱸ ᱯᱩᱥᱴᱟᱹᱣ ᱰᱟᱦᱟᱨ ᱵᱟᱹᱱᱩᱜᱼᱟ ᱡᱮ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱫᱚ ᱟᱢ ᱪᱮᱫ ᱮᱢ ᱩᱭᱦᱟᱹᱨ ᱮᱫᱟ ᱚᱱᱟ ᱦᱚᱸ ᱠᱚᱨᱟᱣ ᱮᱫᱟᱭ ᱥᱮ ᱵᱟᱝ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱵᱞᱟᱭᱤᱱᱰ ᱩᱰᱟᱹᱣ ᱞᱮᱠᱟ ᱟᱹᱭᱠᱟᱹᱣᱚᱜ ᱠᱟᱱᱟ ᱾ ᱚᱱᱟ ᱤᱧ ᱢᱤᱫ ᱦᱩᱰᱤᱧ ᱥᱟᱯᱟᱵ ᱵᱮᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱵᱟᱜᱽ ᱠᱮᱫᱤᱧᱟᱭ: ᱜᱮᱢᱯᱮᱰ ᱠᱟᱥᱠᱮᱰ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱾ ᱠᱚᱱᱥᱚᱞ ᱟᱩᱴᱯᱩᱴ ᱥᱮᱫ ᱠᱚᱭᱚᱜ ᱵᱚᱫᱚᱞ ᱛᱮ, ᱟᱢ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱨᱮᱭᱟᱜ ᱞᱟᱭᱤᱵᱽ, ᱤᱱᱴᱟᱨᱮᱠᱴᱤᱵᱷ ᱧᱮᱞ ᱧᱟᱢᱟᱢ᱾ ᱡᱟᱦᱟᱱᱟᱜ ᱫᱟᱵᱟᱣ ᱢᱮ ᱟᱨ ᱱᱚᱣᱟ ᱥᱠᱨᱤᱱ ᱨᱮ ᱨᱤᱭᱟᱠᱴ ᱦᱩᱭᱩᱜᱼᱟ ᱾ ᱟᱨ CSS Cascade Leyers ᱥᱟᱶᱛᱮ, ᱥᱴᱟᱭᱤᱞ ᱠᱚ ᱥᱟᱯᱲᱟᱣ ᱛᱟᱦᱮᱱᱟ, ᱚᱱᱟᱛᱮ ᱰᱤᱵᱟᱜᱽ ᱞᱟᱹᱜᱤᱫ ᱱᱚᱶᱟ ᱥᱟᱯᱷᱟ ᱜᱮᱭᱟ᱾ ᱱᱚᱶᱟ ᱯᱚᱥᱴ ᱨᱮ, ᱤᱧ ᱫᱚ ᱟᱢ ᱩᱫᱩᱜ ᱢᱮᱭᱟ ᱡᱮ ᱰᱤᱵᱟᱜᱽ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱫᱚ ᱪᱮᱫ ᱞᱮᱠᱟ ᱵᱟᱹᱲᱤᱡ ᱜᱮᱭᱟ, ᱪᱮᱫ ᱞᱮᱠᱟ ᱛᱮ CSS ᱫᱚ ᱱᱚᱶᱟ ᱥᱟᱯᱷᱟᱭ ᱞᱟᱹᱜᱤᱫ ᱜᱚᱲᱚ ᱮᱢᱟᱢᱟ, ᱟᱨ ᱟᱢ ᱫᱚ ᱟᱢᱟᱜ ᱯᱨᱚᱡᱮᱠᱴ ᱞᱟᱹᱜᱤᱫ ᱫᱚᱦᱚ ᱞᱟᱹᱜᱤᱫ ᱪᱮᱫ ᱞᱮᱠᱟ ᱛᱮ ᱵᱮᱵᱷᱟᱨ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾

ᱟᱢ ᱡᱩᱫᱤ ᱚᱱᱟ ᱠᱚ ᱥᱟᱱᱟᱢ ᱞᱚᱜᱽ ᱫᱟᱲᱮᱭᱟᱜ ᱠᱷᱟᱱ ᱦᱚᱸ, ᱟᱢ ᱩᱥᱟᱹᱨᱟ ᱜᱮ ᱵᱟᱝ ᱯᱟᱲᱦᱟᱣ ᱞᱮᱠᱟᱱ ᱠᱚᱱᱥᱚᱞ ᱥᱯᱟᱢ ᱥᱟᱶ ᱢᱩᱪᱟᱹᱫᱚᱜᱼᱟᱢ᱾ ᱫᱟᱹᱭᱠᱟᱹ ᱞᱮᱠᱟᱛᱮᱺ [᱐,᱐,᱑,᱐,᱐,᱐.᱕,᱐,...] [᱐,᱐,᱐,᱐,᱑,᱐,᱐,...] [᱐,᱐,᱑,᱐,᱐,᱐,᱐,...]

ᱪᱮᱫ ᱟᱢᱮᱢ ᱞᱟᱹᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱚᱠᱟ ᱵᱩᱛᱟᱢ ᱫᱟᱵᱟᱣ ᱞᱮᱱᱟ? ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱟᱢᱟᱜ ᱢᱮᱫ ᱫᱟᱵᱟᱣ ᱠᱟᱛᱮ ᱟᱨ ᱛᱤᱱᱟᱹᱜ ᱜᱟᱱ ᱤᱱᱯᱩᱴ ᱟᱫ ᱠᱟᱛᱮ ᱜᱮ ᱾ ᱚᱱᱟᱛᱮ, ᱵᱟᱝ, ᱰᱤᱵᱟᱜᱽ ᱫᱚ ᱟᱞᱜᱟ ᱛᱮ ᱵᱟᱝ ᱦᱤᱡᱩᱜ ᱠᱟᱱᱟ ᱡᱚᱠᱷᱚᱱ ᱤᱱᱯᱩᱴ ᱯᱟᱲᱦᱟᱣ ᱨᱮᱭᱟᱜ ᱠᱟᱛᱷᱟ ᱦᱮᱡ ᱮᱱᱟ᱾ ᱮᱴᱠᱮᱴᱚᱬᱮ ᱓: ᱥᱴᱨᱟᱠᱪᱟᱨ ᱨᱮᱭᱟᱜ ᱠᱚᱢ ᱟᱢ ᱡᱩᱫᱤ ᱩᱥᱟᱹᱨᱟ ᱧᱮᱞᱚᱢ ᱢᱤᱫ ᱥᱟᱶᱛᱮᱢ ᱪᱟᱯᱟᱫ ᱠᱷᱟᱱ ᱦᱚᱸ, ᱥᱴᱟᱭᱤᱞ ᱩᱥᱟᱹᱨᱟ ᱜᱮ ᱡᱚᱵᱽᱨᱟ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱰᱤᱯᱷᱚᱞᱴ, ᱮᱠᱴᱤᱵᱷ, ᱟᱨ ᱰᱤᱵᱟᱜᱽ ᱥᱴᱮᱴ ᱠᱚ ᱚᱵᱷᱟᱨᱞᱟᱯ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨ ᱯᱩᱥᱴᱟᱹᱣ ᱥᱴᱨᱟᱠᱪᱟᱨ ᱵᱮᱜᱚᱨ ᱛᱮ, ᱟᱢᱟᱜ CSS ᱫᱚ ᱵᱷᱟᱹᱜᱤ ᱟᱨ ᱯᱟᱥᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱟᱸᱴ ᱦᱩᱭᱩᱜᱼᱟ᱾ ᱥᱤ ᱮᱥ ᱮᱥ ᱠᱟᱥᱠᱮᱰ ᱞᱮᱭᱟᱨ ᱜᱚᱲᱚ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱭ ᱾ ᱩᱱᱠᱩ ᱥᱴᱟᱭᱤᱞ ᱠᱚ “ᱞᱮᱭᱟᱨ” ᱨᱮ ᱜᱟᱫᱮᱞ ᱮᱫᱟ ᱚᱠᱟ ᱫᱚ ᱯᱨᱟᱭᱚᱨᱤᱴᱤ ᱞᱮᱠᱟᱛᱮ ᱚᱨᱰᱟᱨ ᱟᱠᱟᱱᱟ, ᱚᱱᱟ ᱛᱮ ᱟᱢ ᱫᱚ ᱵᱷᱟᱹᱜᱤ ᱥᱟᱶ ᱞᱟᱹᱲᱦᱟᱹᱭ ᱵᱚᱱᱫᱚ ᱢᱮ ᱟᱨ ᱟᱴᱠᱟᱨ ᱢᱮ, “ᱤᱧᱟᱜ ᱰᱤᱵᱟᱜᱽ ᱥᱴᱟᱭᱤᱞ ᱪᱮᱫᱟᱜ ᱵᱟᱝ ᱧᱮᱞᱚᱜ ᱠᱟᱱᱟ?” ᱱᱚᱣᱟ ᱵᱚᱫᱚᱞ ᱛᱮ, ᱟᱢ ᱟᱞᱟᱝᱜᱟᱲ ᱪᱤᱱᱛᱟᱹ ᱫᱚᱦᱚᱭ ᱢᱮ:

ᱵᱮᱥ: ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱟᱜ ᱥᱴᱮᱱᱰᱟᱨ, ᱮᱛᱚᱦᱚᱵ ᱧᱮᱞᱚᱜ᱾ ᱮᱠᱴᱤᱵᱷ: ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱ ᱵᱩᱛᱟᱢ ᱟᱨ ᱚᱪᱚᱜ ᱠᱟᱱ ᱞᱟᱴᱠᱟᱣ ᱠᱚ ᱞᱟᱹᱜᱤᱫ ᱦᱟᱭᱞᱟᱭᱤᱴ᱾ ᱰᱤᱵᱟᱜᱽ: ᱩᱛᱱᱟᱹᱣᱠᱚ ᱞᱟᱹᱜᱤᱫ ᱚᱵᱷᱟᱨᱞᱮ (ᱡᱮᱞᱠᱟ, ᱞᱮᱠᱷᱟ ᱯᱟᱲᱦᱟᱣ, ᱜᱟᱭᱤᱰ, ᱟᱨ ᱚᱱᱠᱟᱱ)᱾

ᱡᱩᱫᱤ ᱟᱵᱚ ᱱᱚᱣᱟ ᱞᱮᱠᱟᱛᱮ CSS ᱨᱮ ᱞᱮᱭᱟᱨ ᱵᱚᱱ ᱩᱱᱩᱨᱩᱢ ᱞᱮᱠᱷᱟᱱ, ᱟᱵᱚ ᱴᱷᱮᱱ ᱛᱟᱦᱮᱸᱱᱟ: /* ᱠᱚᱢ ᱠᱷᱚᱱ ᱪᱮᱛᱟᱱ ᱯᱨᱟᱛᱷᱟᱢᱤᱠᱛᱟ */ @ᱞᱮᱭᱟᱨ ᱵᱮᱥ, ᱮᱠᱴᱤᱵᱷ, ᱰᱤᱵᱟᱜᱽ;

@ᱞᱮᱭᱟᱨ ᱵᱮᱥ { /* ... */ }

@ᱞᱮᱭᱟᱨ ᱮᱠᱴᱤᱵᱷ { /* ... */ }

@ᱞᱮᱭᱟᱨ ᱰᱤᱵᱟᱜᱽ { /* ... */ }

ᱪᱮᱫᱟᱜ ᱥᱮ ᱥᱟᱱᱟᱢ ᱞᱮᱭᱟᱨ ᱜᱮ ᱟᱜᱟᱢ ᱞᱮᱠᱟᱛᱮ ᱫᱚᱦᱚᱜ ᱠᱟᱱᱟ, ᱟᱢ ᱥᱟᱨᱟ ᱜᱷᱟᱹᱲᱤᱡ ᱵᱟᱲᱟᱭᱟᱢ ᱚᱠᱟ ᱱᱤᱭᱚᱢ ᱡᱤᱛᱠᱟᱹᱨᱚᱜᱼᱟ ᱾ ᱚᱱᱟ ᱵᱷᱟᱵᱤ ᱫᱟᱲᱮ ᱫᱚ ᱰᱤᱵᱟᱜᱽ ᱫᱚ ᱮᱠᱮᱱ ᱟᱞᱜᱟ ᱵᱟᱝ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱥᱟᱹᱨᱤ ᱛᱮ ᱪᱟᱞᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ ᱜᱮᱭᱟ᱾ ᱟᱞᱮ ᱫᱚ ᱮᱴᱠᱮᱴᱚᱬᱮ (ᱵᱟᱝ ᱧᱮᱞᱚᱜ, ᱡᱷᱟᱹᱯᱲᱤ ᱤᱱᱯᱩᱴ) ᱟᱨ ᱰᱟᱦᱟᱨ (ᱠᱟᱥᱠᱮᱰ ᱞᱮᱭᱟᱨ ᱥᱟᱶᱛᱮ ᱵᱮᱱᱟᱣ ᱧᱮᱞᱚᱜ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ) ᱞᱮ ᱠᱚᱵᱷᱟᱨ ᱟᱠᱟᱫᱟ᱾ ᱱᱤᱛᱚᱜ ᱫᱚ ᱟᱵᱚ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱵᱮᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱥᱴᱮᱯ ᱛᱟᱭᱚᱢ ᱥᱴᱮᱯ ᱯᱨᱚᱠᱨᱤᱭᱟ ᱛᱟᱞᱟ ᱛᱮ ᱵᱚᱱ ᱛᱟᱲᱟᱢᱟ᱾ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱫᱷᱟᱨᱱᱟ ᱩᱠᱩ ᱟᱠᱟᱱ ᱤᱱᱯᱩᱴ ᱧᱮᱞᱚᱜ ᱞᱟᱹᱜᱤᱫ ᱟᱞᱜᱟ ᱰᱟᱦᱟᱨ ᱫᱚ ᱥᱠᱨᱤᱱ ᱨᱮ ᱟᱸᱠᱟᱣ ᱞᱮᱠᱷᱟ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱫᱚ ᱚᱱᱟ ᱜᱮ ᱠᱚᱨᱟᱣ ᱮᱫᱟᱭ ᱾ ᱵᱩᱛᱟᱢ, ᱴᱨᱤᱜᱚᱨ, ᱟᱨ ᱡᱚᱭᱥᱴᱤᱠ ᱥᱟᱱᱟᱢ ᱜᱮ ᱧᱮᱞ ᱧᱟᱢᱚᱜ ᱠᱟᱱᱟ ᱾

ᱞᱤᱱ ᱮ: ᱢᱤᱫ ᱜᱩᱞᱟᱹᱭ ᱢᱟᱨᱥᱟᱞᱚᱜᱼᱟ ᱾ ᱞᱟᱴᱠᱟ ᱛᱷᱚᱠᱟᱣ ᱢᱮ: ᱜᱩᱞᱟᱹᱭ ᱫᱚ ᱜᱚᱴᱟ ᱯᱟᱥᱮ ᱞᱮᱧᱡᱮᱨᱚᱜᱼᱟ ᱾ ᱢᱤᱫ ᱴᱨᱤᱜᱚᱨ ᱟᱫᱷᱟ ᱦᱚᱨ ᱛᱮ ᱚᱨ ᱢᱮ: ᱢᱤᱫ ᱵᱟᱨ ᱟᱫᱷᱟ ᱦᱚᱨ ᱛᱮ ᱯᱮᱨᱮᱡᱚᱜᱼᱟ ᱾

ᱱᱤᱛᱚᱜ ᱫᱚ ᱟᱢ ᱐ ᱟᱨ ᱑ ᱥᱮᱫ ᱵᱟᱢ ᱧᱮᱞ ᱮᱫᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱥᱟᱹᱨᱤ ᱛᱮ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱞᱟᱭᱤᱵᱽ ᱨᱮᱭᱟᱠᱴ ᱮᱢ ᱧᱮᱞ ᱮᱫᱟ᱾ ᱥᱟᱹᱨᱤ ᱠᱟᱛᱷᱟ ᱞᱮᱠᱟᱛᱮ, ᱢᱤᱫ ᱫᱷᱟᱣ ᱰᱤᱯᱷᱚᱞᱴ, ᱯᱨᱮᱥ, ᱰᱤᱵᱟᱜᱽ ᱤᱱᱯᱷᱚ, ᱦᱩᱭ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱢᱚᱰ ᱦᱚᱸ, CSS ᱫᱚ ᱢᱟᱨᱟᱝ ᱟᱨ ᱟᱹᱰᱤ ᱡᱩᱞᱩᱜ ᱮᱦᱚᱵᱚᱜ-ᱟ᱾ ᱚᱱᱰᱮ ᱜᱮ ᱠᱟᱥᱠᱮᱰ ᱞᱮᱭᱟᱨ ᱠᱚ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ ᱾ ᱱᱚᱸᱰᱮ ᱢᱤᱫ ᱥᱴᱨᱤᱯᱰ-ᱰᱟᱣᱩᱱ ᱫᱟᱹᱭᱠᱟᱹ ᱢᱮᱱᱟᱜᱼᱟ: @ᱞᱮᱭᱟᱨ ᱵᱮᱥ { ᱾ᱵᱩᱛᱟᱹᱢ { ᱯᱟᱹᱪᱷᱞᱟᱹ: #᱒᱒᱒; ᱥᱤᱢᱟᱹ-ᱛᱷᱩᱢ: ᱕᱐%; ᱚᱥᱟᱨ: ᱔᱐ᱯᱤᱮᱠᱥ; ᱩᱥᱩᱞ: ᱔᱐ᱯᱤᱮᱠᱥ; } }

@ᱞᱮᱭᱟᱨ ᱮᱠᱴᱤᱵᱷ { .ᱵᱩᱛᱟᱹᱢ. ᱞᱤᱱ { ᱯᱟᱹᱪᱷᱞᱟᱹ: #0f0; /* ᱥᱟᱯᱷᱟ ᱦᱟᱹᱨᱭᱟᱹᱲ */ } }

@ᱞᱮᱭᱟᱨ ᱰᱤᱵᱟᱜᱽ { .ᱵᱩᱛᱟᱹᱢ::ᱛᱟᱭᱚᱢ { ᱡᱤᱱᱤᱥ: ᱟᱴᱨ(ᱰᱟᱴᱟ-ᱵᱷᱮᱞᱭᱩ); ᱯᱷᱚᱱᱴ-ᱥᱟᱭᱤᱡᱽ: ᱑᱒ᱯᱤᱮᱠᱥ; ᱨᱚᱝ: #ᱯᱷᱯᱷᱯᱷ; } }

ᱞᱮᱭᱟᱨ ᱚᱨᱰᱟᱨ ᱫᱚ ᱢᱟᱱᱚᱛ ᱠᱟᱱᱟᱺ ᱵᱮᱥ → ᱮᱠᱴᱤᱵᱷ → ᱰᱤᱵᱟᱜᱽ ᱾

ᱵᱮᱥ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱚᱨ ᱮᱫᱟᱭ ᱾ ᱮᱠᱴᱤᱵᱷ ᱦᱮᱱᱰᱞᱥ ᱯᱨᱮᱥᱰ ᱥᱴᱮᱴᱥ ᱾ ᱰᱤᱵᱟᱜᱽ ᱚᱵᱷᱟᱨᱞᱮ ᱨᱮ ᱪᱟᱯᱟᱫ ᱮᱫᱟᱭ ᱾

ᱱᱚᱣᱟ ᱱᱚᱝᱠᱟ ᱨᱟᱹᱯᱩᱫ ᱨᱮᱭᱟᱜ ᱢᱮᱱᱮᱛ ᱫᱚ ᱟᱢ ᱫᱚ ᱵᱟᱹᱲᱤᱡ ᱵᱷᱟᱹᱜᱤ ᱞᱟᱹᱲᱦᱟᱹᱭ ᱥᱟᱶ ᱵᱟᱢ ᱞᱟᱹᱲᱦᱟᱹᱭ ᱠᱟᱱᱟ᱾ ᱥᱟᱱᱟᱢ ᱞᱮᱭᱟᱨ ᱨᱮᱜᱮ ᱟᱯᱱᱟᱨ ᱴᱷᱟᱶ ᱢᱮᱱᱟᱜᱼᱟ, ᱟᱨ ᱟᱢ ᱞᱮᱛᱟᱲ ᱜᱮᱢ ᱵᱟᱲᱟᱭᱟ ᱪᱮᱫ ᱡᱤᱛᱠᱟᱹᱨᱚᱜᱼᱟ ᱾ ᱱᱚᱣᱟ ᱵᱟᱦᱨᱮ ᱛᱮᱭᱟᱨ ᱫᱮᱞᱟ ᱞᱟᱦᱟ ᱥᱠᱨᱤᱱ ᱨᱮ ᱡᱟᱦᱟᱱᱟᱜ ᱧᱟᱢ ᱞᱮᱜᱮ᱾ ᱱᱚᱣᱟ ᱵᱮᱥ ᱧᱮᱞᱚᱜ ᱞᱟᱹᱠᱛᱤ ᱵᱟᱹᱱᱩᱜᱼᱟ — ᱥᱩᱢᱩᱝ ᱛᱟᱦᱮᱱ ᱞᱟᱹᱠᱛᱤᱜ ᱠᱟᱱᱟ ᱡᱮᱢᱚᱱ ᱟᱵᱚ ᱴᱷᱮᱱ ᱠᱟᱹᱢᱤ ᱞᱟᱹᱜᱤᱫ ᱡᱟᱦᱟᱱᱟᱜ ᱛᱟᱦᱮᱱ ᱢᱟ᱾

ᱜᱮᱢᱯᱮᱰ ᱠᱟᱥᱠᱮᱰ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ

<ᱵᱩᱛᱟᱹᱢ ᱟᱭᱤ ᱰᱤ="ᱴᱚᱜᱽᱞ">ᱴᱚᱜᱽᱞ ᱰᱤᱵᱟᱜᱽ

<ᱥᱠᱨᱤᱯᱴ ᱮᱥᱟᱨᱥᱤ="ᱥᱠᱨᱤᱯᱴ.ᱡᱮᱥ">

ᱚᱱᱟ ᱫᱚ ᱥᱟᱹᱨᱤ ᱛᱮ ᱥᱩᱢᱩᱝ ᱵᱟᱠᱥᱟ ᱠᱟᱱᱟ ᱾ ᱱᱤᱛ ᱦᱚᱸ ᱵᱟᱝ ᱩᱢᱡᱷᱟᱹᱣᱜ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱱᱚᱣᱟ ᱟᱵᱚ ᱛᱟᱭᱚᱢ ᱛᱮ ᱥᱤ ᱮᱥ ᱮᱥ ᱟᱨ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱥᱟᱶ ᱥᱟᱵ ᱞᱟᱹᱜᱤᱫ ᱦᱮᱱᱰᱮᱞ ᱮᱢᱟ ᱵᱚᱱᱟ᱾ ᱴᱷᱤᱠ ᱜᱮᱭᱟ, ᱤᱧ ᱱᱚᱸᱰᱮ ᱠᱟᱥᱠᱮᱰ ᱞᱮᱭᱟᱨ ᱵᱮᱵᱷᱟᱨ ᱮᱫᱟᱹᱧ ᱪᱮᱫᱟᱜ ᱥᱮ ᱟᱢ ᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱨᱦᱚᱸ ᱥᱴᱮᱴ ᱥᱮᱞᱮᱫ ᱠᱟᱛᱮ ᱱᱚᱶᱟ ᱡᱤᱱᱤᱥ ᱠᱚ ᱥᱟᱯᱲᱟᱣ ᱫᱚᱦᱚᱭᱟ᱾ ᱱᱚᱸᱰᱮ ᱢᱤᱫ ᱨᱚᱦᱚᱲ ᱯᱟᱥ ᱢᱮᱱᱟᱜᱼᱟ:

/* ================================ ᱠᱟᱥᱠᱮᱰ ᱞᱮᱭᱟᱨᱥ ᱥᱮᱴᱟᱯ ᱚᱨᱰᱟᱨ ᱢᱟᱴᱚᱨᱥ: ᱵᱮᱥ → ᱮᱠᱴᱤᱵᱷ → ᱰᱤᱵᱟᱜᱽ =========================================ᱹ

/* ᱞᱮᱭᱟᱨ ᱚᱨᱰᱟᱨ ᱟᱯᱯᱷᱨᱚᱱᱴ ᱩᱱᱩᱨᱩᱢ ᱢᱮ */ @ᱞᱮᱭᱟᱨ ᱵᱮᱥ, ᱮᱠᱴᱤᱵᱷ, ᱰᱤᱵᱟᱜᱽ;

/* ᱞᱮᱭᱟᱨ ᱑: ᱵᱮᱥ ᱥᱴᱟᱭᱤᱞ ᱠᱚ - ᱰᱤᱯᱷᱚᱞᱴ ᱧᱮᱞᱚᱜ */ @ᱞᱮᱭᱟᱨ ᱵᱮᱥ { ᱾ᱵᱩᱛᱟᱹᱢ { ᱯᱟᱹᱪᱷᱞᱟᱹ: #᱓᱓᱓; ᱥᱤᱢᱟᱹ-ᱛᱷᱩᱢ: ᱕᱐%; ᱚᱥᱟᱨ: ᱗᱐ᱯᱤᱮᱠᱥ; ᱩᱥᱩᱞ: ᱗᱐ᱯᱤᱮᱠᱥ; ᱩᱫᱩᱜ: ᱯᱷᱞᱮᱠᱥ; ᱡᱟᱥᱴᱤᱯᱷᱟᱭ-ᱡᱤᱱᱤᱥ: ᱛᱟᱞᱟ; ᱟᱞᱟᱭᱤᱱ-ᱡᱤᱱᱤᱥᱠᱚ: ᱛᱟᱞᱟ; }

᱾ ᱛᱷᱤᱨ { ᱚᱥᱟᱨ: ᱒᱐ᱯᱤᱮᱠᱥ; ᱩᱥᱩᱞ: ᱗᱐ᱯᱤᱮᱠᱥ; ᱯᱟᱹᱪᱷᱞᱟᱹ: #᱓᱓᱓; ᱩᱫᱩᱜ: ᱤᱱᱞᱟᱭᱤᱱ-ᱵᱞᱚᱠ; } }

/* ᱞᱮᱭᱟᱨ ᱒: ᱮᱠᱴᱤᱵᱷ ᱥᱴᱮᱴᱥ - ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱ ᱵᱩᱛᱟᱢ ᱠᱚ ᱥᱟᱢᱵᱽᱲᱟᱣ ᱮᱫᱟᱭ */ @ᱞᱮᱭᱟᱨ ᱮᱠᱴᱤᱵᱷ { .ᱵᱚᱴᱚᱱ.ᱮᱠᱴᱤᱵᱷ { ᱯᱟᱹᱪᱷᱞᱟᱹ: #0f0; /* ᱫᱟᱵᱟᱣ ᱞᱮᱠᱷᱟᱱ ᱥᱟᱯᱷᱟ ᱦᱟᱹᱨᱭᱟᱹᱲ */ ᱴᱨᱟᱱᱥᱯᱷᱚᱨᱢ: ᱥᱠᱮᱞ (᱑.᱑); /* ᱵᱩᱛᱟᱢ ᱱᱟᱥᱮ ᱢᱟᱨᱟᱝ ᱢᱮ */ }

.ᱯᱚᱡᱽ. ᱮᱠᱴᱤᱵᱷ { ᱯᱟᱹᱪᱷᱞᱟᱹ: #0f0; ᱴᱨᱟᱱᱥᱯᱷᱚᱨᱢ: ᱥᱠᱮᱞᱣᱟᱭ(᱑.᱑); /* ᱫᱟᱵᱟᱣ ᱞᱮᱠᱷᱟᱱ ᱩᱞᱴᱟᱹ ᱞᱮᱠᱟᱛᱮ ᱞᱟᱦᱟᱜᱼᱟ */ } }

/* ᱞᱮᱭᱟᱨ ᱓: ᱰᱤᱵᱟᱜᱽ ᱚᱵᱷᱟᱨᱞᱮᱡᱽ - ᱰᱮᱵᱷᱞᱚᱯᱟᱨ ᱵᱟᱯᱟᱰᱟᱭ */ @ᱞᱮᱭᱟᱨ ᱰᱤᱵᱟᱜᱽ { .ᱵᱩᱛᱟᱹᱢ::ᱛᱟᱭᱚᱢ { ᱡᱤᱱᱤᱥ: ᱟᱴᱨ(ᱰᱟᱴᱟ-ᱵᱷᱮᱞᱭᱩ); /* ᱮᱞᱠᱷᱟ ᱜᱚᱱᱚᱝ ᱩᱫᱩᱜ ᱮᱫᱟᱭ */ ᱯᱷᱚᱱᱴ-ᱥᱟᱭᱤᱡᱽ: ᱑᱒ᱯᱤᱮᱠᱥ; ᱨᱚᱝ: #ᱯᱷᱯᱷᱯᱷ; } }

ᱱᱚᱣᱟ ᱯᱚᱨᱠᱟᱨ ᱨᱮᱭᱟᱜ ᱪᱮᱦᱨᱟ ᱫᱚ ᱱᱚᱣᱟ ᱠᱟᱱᱟ ᱡᱮ ᱥᱟᱱᱟᱢ ᱞᱮᱭᱟᱨ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱯᱩᱥᱴᱟᱹᱣ ᱡᱚᱥ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱵᱮᱥ ᱞᱮᱭᱟᱨ ᱫᱚ ᱮᱠᱴᱤᱵᱷ ᱛᱤᱥ ᱦᱚᱸ ᱵᱟᱭ ᱚᱵᱷᱟᱨᱟᱭᱤᱰ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨ ᱮᱠᱴᱤᱵᱷ ᱫᱚ ᱛᱤᱥ ᱦᱚᱸ ᱰᱤᱵᱟᱜᱽ ᱵᱟᱭ ᱚᱵᱷᱟᱨᱟᱭᱤᱰ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱵᱟᱝ ᱵᱷᱟᱵᱤ ᱠᱟᱛᱮ ᱵᱷᱟᱹᱜᱤ ᱜᱮ᱾ ᱱᱚᱣᱟ ᱫᱚ CSS ᱵᱷᱟᱹᱜᱤ ᱞᱟᱹᱲᱦᱟᱹᱭ ᱠᱚ ᱪᱟᱵᱟᱭᱟ ᱚᱠᱟ ᱫᱚ ᱰᱤᱵᱟᱜᱽ ᱴᱩᱞᱥ ᱠᱚ ᱯᱞᱮᱜᱽ ᱮᱫᱟ᱾ ᱱᱤᱛᱚᱜ ᱫᱚ ᱱᱚᱝᱠᱟ ᱧᱮᱞᱚᱜ ᱠᱟᱱᱟ ᱡᱮ ᱛᱤᱱᱟᱹᱜ ᱜᱟᱱ ᱜᱟᱫᱮᱞ ᱫᱚ ᱦᱮᱱᱫᱮ ᱯᱟᱹᱪᱷᱞᱟᱹ ᱨᱮ ᱫᱩᱲᱩᱵ ᱟᱠᱟᱱᱟ ᱠᱚ ᱾ ᱥᱟᱹᱨᱤ ᱠᱟᱛᱷᱟ, ᱩᱱᱟᱹᱜ ᱵᱟᱹᱲᱤᱡ ᱫᱚ ᱵᱟᱝ ᱠᱟᱱᱟ ᱾

ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱥᱮᱞᱮᱫ ᱢᱮ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ ᱚᱠᱛᱚ᱾ ᱱᱚᱸᱰᱮ ᱜᱮ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱫᱚ ᱥᱟᱹᱨᱤ ᱛᱮ ᱡᱟᱦᱟᱱᱟᱜ ᱠᱚ ᱠᱟᱹᱢᱤᱭᱟ ᱾ ᱟᱞᱮ ᱱᱚᱣᱟ ᱫᱷᱟᱯ ᱛᱟᱭᱚᱢ ᱫᱷᱟᱯ ᱞᱮ ᱵᱮᱱᱟᱣᱟ᱾ ᱫᱷᱟᱯ ᱑: ᱯᱚᱱᱚᱛ ᱵᱮᱵᱮᱥᱛᱟ ᱛᱷᱟᱯᱚᱱ ᱢᱮ ᱯᱩᱭᱞᱩ ᱨᱮ, ᱟᱵᱚ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱟᱜ ᱚᱵᱚᱥᱛᱟ ᱴᱨᱟᱠ ᱞᱟᱹᱜᱤᱫ ᱣᱮᱨᱭᱟᱵᱚᱞ ᱠᱚ ᱞᱟᱹᱠᱛᱤᱭᱟᱹᱹ // ================================ // ᱯᱚᱱᱚᱛ ᱵᱮᱵᱮᱥᱛᱟ // ================================

ᱪᱟᱹᱞᱩ ᱞᱮ ᱢᱮ = ᱵᱟᱝ ᱴᱷᱤᱠ; // ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱮᱠᱴᱤᱵᱷ ᱜᱮᱭᱟᱭ ᱥᱮ ᱵᱟᱝᱟ ᱴᱨᱮᱠ ᱨᱟᱯᱷᱟᱭᱤᱰ ᱫᱚᱦᱚᱭ ᱢᱮ; // ᱵᱟᱛᱤᱞ ᱞᱟᱹᱜᱤᱫ ᱟᱨᱫᱟᱥ ᱮᱱᱤᱢᱮᱥᱚᱱ ᱯᱷᱨᱮᱢ ᱟᱭᱤ ᱰᱤ ᱫᱚᱦᱚᱭᱟ

ᱱᱚᱶᱟ ᱣᱮᱨᱭᱟᱵᱚᱞ ᱠᱚ ᱫᱚ ᱮᱱᱤᱢᱮᱥᱚᱱ ᱞᱩᱯ ᱠᱚ ᱠᱚᱱᱴᱨᱚᱞ ᱮᱫᱟ ᱚᱠᱟ ᱫᱚ ᱞᱮᱛᱟᱲ ᱜᱮ ᱜᱮᱢᱯᱮᱰ ᱤᱱᱯᱩᱴ ᱠᱚ ᱯᱟᱲᱦᱟᱣ ᱮᱫᱟ᱾ ᱫᱷᱟᱯ ᱒: ᱰᱚᱢ ᱨᱮᱯᱷᱮᱨᱮᱱᱥ ᱥᱟᱵ ᱢᱮ ᱤᱱᱟᱹ ᱛᱟᱭᱚᱢ, ᱟᱞᱮ ᱥᱟᱱᱟᱢ HTML ᱮᱞᱤᱢᱮᱱᱴ ᱨᱮᱭᱟᱜ ᱨᱮᱯᱷᱮᱨᱮᱱᱥ ᱞᱮ ᱧᱟᱢᱟ ᱚᱠᱟ ᱟᱞᱮ ᱞᱮ ᱟᱯᱰᱮᱴ ᱮᱫᱟᱺ // ================================ // ᱰᱚᱢ ᱮᱞᱤᱢᱮᱱᱴ ᱨᱮᱯᱷᱮᱨᱮᱱᱥ // ================================

ᱠᱚᱱᱥᱴ ᱵᱤ ᱴᱤ ᱮᱱ ᱮ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱵᱤ ᱴᱤ ᱮᱱ-ᱮ"); ᱠᱚᱱᱥᱴ ᱵᱤᱴᱤᱮᱱᱵᱤ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴᱮᱞᱤᱢᱮᱱᱴᱵᱟᱭᱟᱭᱤᱰᱤ("ᱵᱤᱴᱤᱮᱱ-ᱵᱤ"); ᱠᱚᱱᱥᱴ ᱵᱤᱴᱤᱮᱱᱮᱠᱥ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴᱮᱞᱤᱢᱮᱱᱴᱵᱟᱭᱟᱭᱤᱰᱤ("ᱵᱤᱴᱤᱮᱱ-ᱮᱠᱥ"); ᱠᱚᱱᱥᱴ ᱯᱚᱡᱽ᱑ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭᱟᱭᱤᱰ ("ᱯᱚᱡᱽ᱑"); ᱠᱚᱱᱥᱴ ᱯᱚᱡᱽ᱒ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱵᱚᱸᱫ ᱒"); const ᱥᱴᱮᱴᱟᱥ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱥᱴᱮᱴᱟᱥ");

ᱱᱚᱶᱟ ᱠᱚ ᱥᱟᱠᱟᱢ ᱥᱟᱢᱟᱝ ᱨᱮ ᱫᱚᱦᱚ ᱫᱚ ᱰᱚᱢ ᱵᱟᱨ ᱵᱟᱨ ᱠᱩᱠᱞᱤ ᱠᱷᱚᱱ ᱵᱟᱹᱲᱛᱤ ᱦᱩᱱᱟᱹᱨ ᱜᱮᱭᱟ ᱾ ᱫᱷᱟᱯ ᱓: ᱠᱤᱵᱚᱨᱰ ᱯᱷᱚᱞᱵᱮᱠ ᱥᱮᱞᱮᱫ ᱢᱮ ᱵᱮᱜᱚᱨ ᱯᱷᱤᱡᱤᱠᱟᱞ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱛᱮ ᱵᱤᱱᱤᱰ ᱞᱟᱹᱜᱤᱫ, ᱟᱞᱮ ᱠᱤᱵᱚᱨᱰ ᱠᱤ ᱠᱚ ᱵᱩᱛᱟᱢ ᱨᱮ ᱢᱮᱯ ᱞᱮ ᱮᱢᱟᱺ // ================================ // ᱠᱤᱵᱚᱨᱰ ᱯᱷᱚᱞᱵᱮᱠ (ᱵᱮᱜᱚᱨ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱛᱮ ᱵᱤᱱᱤᱰ ᱞᱟᱹᱜᱤᱫ) // ================================

ᱠᱚᱱᱥᱴ ᱠᱤᱢᱮᱯ = { "ᱮ": ᱵᱤᱴᱤᱮᱱᱮ, "ᱵᱤ": ᱵᱤᱴᱤᱮᱱᱵᱤ, "ᱮᱠᱥ": ᱵᱤᱴᱤᱮᱱᱮᱠᱥ, "p": [ᱵᱚᱸᱫᱚ᱑, ᱵᱚᱱᱫᱚ᱒] // 'p' ᱠᱤ ᱵᱟᱱᱟᱨ ᱵᱚᱱᱫᱚ ᱵᱟᱨ ᱠᱚᱵᱚᱡᱽ ᱮᱫᱟᱭ };

ᱱᱚᱣᱟ ᱛᱮ ᱟᱵᱚ ᱠᱤᱵᱚᱨᱰ ᱨᱮ ᱠᱤ ᱞᱤᱱ ᱠᱟᱛᱮ UI ᱵᱚᱱ ᱵᱤᱱᱤᱰ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱫᱷᱟᱯ ᱔: ᱢᱩᱬ ᱟᱯᱰᱮᱴ ᱞᱩᱯ ᱵᱮᱱᱟᱣ ᱢᱮ ᱱᱚᱸᱰᱮ ᱢᱮᱡᱤᱠ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱾ ᱱᱚᱣᱟ ᱯᱷᱟᱱᱥᱚᱱ ᱫᱚ ᱞᱮᱛᱟᱲ ᱜᱮ ᱪᱟᱹᱞᱩᱜ ᱠᱟᱱᱟ ᱟᱨ ᱜᱮᱢᱯᱮᱰ ᱚᱵᱚᱥᱛᱟ ᱯᱟᱲᱦᱟᱣ ᱮᱫᱟᱭ: // ================================ // ᱢᱩᱲᱩᱫ ᱜᱮᱢᱯᱮᱰ ᱟᱯᱰᱮᱴ ᱞᱩᱯ // ================================

ᱯᱷᱟᱸᱠᱥᱚᱱ ᱟᱯᱰᱮᱴᱜᱮᱢᱯᱮᱰ() { // ᱡᱚᱛᱚ ᱡᱚᱯᱲᱟᱣ ᱜᱮᱢᱯᱮᱰ ᱠᱚ ᱧᱟᱢ ᱢᱮ ᱠᱚᱱᱥᱴ ᱜᱮᱢᱯᱮᱰᱥ = ᱱᱮᱵᱷᱤᱜᱮᱴᱚᱨ. ᱜᱮᱢᱯᱮᱰᱥ ᱧᱟᱢ (); ᱡᱩᱫᱤ (! ᱜᱮᱢᱯᱮᱰᱥ) ᱨᱩᱣᱟᱹᱲ;

// ᱯᱩᱭᱞᱩ ᱡᱚᱯᱲᱟᱣ ᱜᱮᱢᱯᱮᱰ ᱵᱮᱵᱷᱟᱨ ᱢᱮ ᱠᱚᱱᱥᱴ ᱡᱤᱯᱤ = ᱜᱮᱢᱯᱮᱰᱥ[᱐];

ᱡᱩᱫᱤ (ᱡᱤᱯᱤ) { // "ᱮᱠᱴᱤᱵᱷ" ᱪᱟᱱᱟᱪ ᱴᱚᱜᱽᱞ ᱠᱟᱛᱮ ᱵᱩᱛᱟᱢ ᱥᱴᱮᱴ ᱟᱯᱰᱮᱴ ᱢᱮ ᱵᱤᱴᱤᱮᱱᱮ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱡᱤᱯᱤ.ᱵᱩᱛᱟᱢ [᱐]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ); ᱵᱤᱴᱤᱮᱱᱵᱤ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱡᱤᱯᱤ.ᱵᱩᱛᱟᱢ [᱑]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ); ᱵᱤᱴᱤᱮᱱᱮᱠᱥ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱡᱤᱯᱤ.ᱵᱩᱛᱟᱢ [᱒]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ);

// ᱯᱚᱡᱽ ᱵᱩᱛᱟᱢ ᱦᱮᱱᱰᱮᱞ (ᱵᱩᱛᱟᱢ ᱤᱱᱰᱮᱠᱥ ᱙ ᱵᱤᱥᱛᱤ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱨᱮ) ᱠᱚᱱᱥᱴ ᱯᱚᱡᱽ ᱯᱨᱮᱥᱰ = ᱡᱤᱯᱤ. ᱵᱩᱛᱟᱢ [᱙]. ᱯᱨᱮᱥᱰ; ᱯᱚᱡᱽ᱑.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱯᱚᱡᱽᱯᱨᱮᱥᱮᱰ); ᱯᱚᱡᱽ᱒.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱯᱚᱡᱽᱯᱨᱮᱥᱮᱰ);

// ᱥᱴᱮᱴᱟᱥ ᱩᱫᱩᱜ ᱞᱟᱹᱜᱤᱫ ᱱᱤᱛᱚᱜ ᱞᱤᱱ ᱟᱠᱟᱱ ᱵᱩᱛᱟᱢ ᱠᱚᱣᱟᱜ ᱢᱤᱫ ᱛᱟᱞᱠᱟ ᱵᱮᱱᱟᱣ ᱢᱮ ᱫᱟᱵᱟᱣ ᱢᱮ = []; ᱡᱤᱯᱤ.ᱵᱩᱛᱟᱹᱢ.ᱥᱟᱱᱟᱢ ᱞᱟᱹᱜᱤᱫ((ᱵᱤᱴᱤᱮᱱ, ᱤᱧ) => { ᱡᱩᱫᱤ (btn. ᱫᱟᱵᱟᱣ)ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ ᱾ ᱯᱩᱥ ("ᱵᱩᱛᱟᱹᱢ " + ᱤᱧ); });

// ᱡᱩᱫᱤ ᱡᱟᱦᱟᱱ ᱵᱩᱛᱟᱢ ᱞᱤᱱ ᱞᱮᱱᱠᱷᱟᱱ ᱥᱴᱮᱴᱟᱥ ᱚᱞ ᱟᱯᱰᱮᱴ ᱢᱮ ᱡᱩᱫᱤ (ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱ᱾ ᱡᱮᱞᱮᱝ > ᱐) { ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱫᱟᱵᱟᱣ: " + ᱫᱟᱵᱟᱣ.ᱡᱚᱭᱤᱱ(", "); } }

// ᱡᱩᱫᱤ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱪᱟᱹᱞᱩ ᱠᱟᱱ ᱠᱷᱟᱱ ᱞᱩᱯ ᱞᱟᱦᱟᱭ ᱢᱮ ᱡᱩᱫᱤ (ᱧᱤᱨ) { rafId = ᱟᱨᱫᱟᱥ ᱮᱱᱤᱢᱮᱥᱚᱱ ᱯᱷᱨᱮᱢ (ᱟᱯᱰᱮᱴ ᱜᱮᱢᱯᱮᱰ); } }

classList.toggle() ᱯᱚᱫᱷ ᱫᱚ ᱵᱩᱴᱚᱢ ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ ᱥᱮ ᱵᱟᱝᱟ ᱚᱱᱟ ᱞᱟᱹᱜᱤᱫ ᱮᱠᱴᱤᱵᱷ ᱪᱟᱱᱟᱪ ᱥᱮᱞᱮᱫ ᱥᱮ ᱚᱪᱚᱜ ᱠᱟᱱᱟ, ᱚᱠᱟ ᱫᱚ ᱟᱵᱚᱣᱟᱜ CSS ᱞᱮᱭᱟᱨ ᱥᱴᱟᱭᱤᱞ ᱠᱚ ᱴᱨᱤᱜᱚᱨ ᱮᱫᱟ᱾ ᱫᱷᱟᱯ ᱕: ᱠᱤᱵᱚᱨᱰ ᱤᱵᱷᱮᱱᱴ ᱠᱚ ᱥᱟᱢᱵᱽᱲᱟᱣ ᱢᱮ ᱱᱚᱶᱟ ᱠᱟᱹᱢᱤᱦᱚᱨᱟ ᱟᱸᱡᱚᱢᱤᱭᱟᱹ ᱠᱚ ᱠᱤᱵᱚᱨᱰ ᱯᱷᱚᱞᱵᱮᱠ ᱠᱟᱹᱢᱤ ᱠᱚ ᱵᱮᱱᱟᱣᱟᱺ // ================================ // ᱠᱤᱵᱚᱨᱰ ᱤᱵᱷᱮᱱᱴ ᱦᱮᱱᱰᱞᱟᱨ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ ("ᱠᱤᱰᱟᱣᱩᱱ", (ᱮ) => { ᱡᱩᱫᱤ (ᱠᱤᱢᱮᱯ[ᱮ.ᱠᱤ]) { // ᱢᱤᱫ ᱵᱟᱝᱠᱷᱟᱱ ᱵᱟᱹᱲᱛᱤ ᱫᱩᱨᱤᱵᱽ ᱥᱟᱢᱵᱽᱲᱟᱣ ᱡᱩᱫᱤ (ᱟᱨᱮ.ᱤᱥᱮᱨᱮ(ᱠᱤᱢᱮᱯ[ᱤ.ᱠᱤ])) { ᱠᱤᱢᱮᱯ [ᱤ.ᱠᱤ]. ᱥᱟᱱᱟᱢ ᱞᱟᱹᱜᱤᱫ (ᱮᱞ => ᱮᱞ. ᱠᱞᱟᱥᱞᱤᱥᱴ. ᱮᱰ ("ᱮᱠᱴᱤᱵᱷ")); } ᱟᱨᱦᱚᱸ { ᱠᱤᱢᱮᱯ[ᱤ.ᱠᱤ].ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱮᱰ("ᱮᱠᱴᱤᱵᱷ"); } ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱠᱤ ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ: " + ᱤ.ᱠᱤ.ᱴᱩᱯᱟᱨᱠᱮᱥ(); } });

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ ("ᱠᱤᱯ", (ᱮ) => { ᱡᱩᱫᱤ (ᱠᱤᱢᱮᱯ[ᱮ.ᱠᱤ]) { // ᱪᱟᱹᱵᱤ ᱟᱲᱟᱜ ᱞᱮᱱᱠᱷᱟᱱ ᱮᱠᱴᱤᱵᱷ ᱥᱴᱮᱴ ᱚᱪᱚᱜᱽ ᱢᱮ ᱡᱩᱫᱤ (ᱟᱨᱮ.ᱤᱥᱮᱨᱮ(ᱠᱤᱢᱮᱯ[ᱤ.ᱠᱤ])) { ᱠᱤᱢᱮᱯ [ᱤ.ᱠᱤ]. ᱥᱟᱱᱟᱢ ᱞᱟᱹᱜᱤᱫ (ᱮᱞ => ᱮᱞ. ᱠᱞᱟᱥᱞᱤᱥᱴ. ᱚᱪᱚᱜ ("ᱮᱠᱴᱤᱵᱷ")); } ᱟᱨᱦᱚᱸ { ᱠᱤᱢᱮᱯ[ᱤ.ᱠᱤ].ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱨᱤᱢᱩᱵᱷ("ᱮᱠᱴᱤᱵᱷ"); } ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱪᱟᱹᱵᱤ ᱟᱲᱟᱜ ᱮᱱᱟ: " + ᱤ.ᱪᱟᱹᱵᱤ.ᱴᱩᱯᱟᱨᱠᱮᱥ(); } });

ᱫᱷᱟᱯ ᱖: ᱮᱛᱚᱦᱚᱵ/ᱛᱷᱤᱨ ᱠᱚᱱᱴᱨᱚᱞ ᱥᱮᱞᱮᱫ ᱢᱮ ᱢᱩᱪᱟᱹᱫ ᱨᱮ, ᱟᱵᱚ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱪᱟᱹᱞᱩ ᱟᱨ ᱵᱚᱱᱫᱚ ᱞᱟᱹᱜᱤᱫ ᱢᱤᱫ ᱰᱟᱦᱟᱨ ᱞᱟᱹᱠᱛᱤᱭᱟᱹᱜ ᱠᱟᱱᱟᱺ // ================================ // ᱴᱚᱜᱽᱞ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱪᱟᱹᱞᱩ/ᱵᱚᱱᱫᱚ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱴᱚᱜᱽᱞ"). ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ (" ᱚᱛᱟᱭ", () => { ᱧᱤᱨ = !ᱧᱤᱨ; // ᱪᱟᱹᱞᱩ ᱚᱵᱚᱥᱛᱟ ᱩᱞᱴᱟᱹᱭ ᱢᱮ

ᱡᱩᱫᱤ (ᱧᱤᱨ) { ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱪᱟᱹᱞᱩᱜ ᱠᱟᱱᱟ..."; ᱟᱯᱰᱮᱴ ᱜᱮᱢᱯᱮᱰ (); // ᱟᱯᱰᱮᱴ ᱞᱩᱯ ᱮᱦᱚᱵ ᱢᱮ } ᱟᱨᱦᱚᱸ { ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱤᱱᱮᱠᱴᱤᱵᱷ"; ᱮᱱᱤᱢᱮᱥᱚᱱ ᱯᱷᱨᱮᱢ ᱵᱚᱱᱫᱚ (ᱨᱟᱯᱷ ᱟᱭᱤ ᱰᱤ); // ᱞᱩᱯ ᱛᱷᱚᱠᱟᱣ ᱢᱮ } });

ᱮᱱᱠᱷᱟᱱ ᱦᱮᱸ, ᱢᱤᱫ ᱵᱩᱛᱟᱢ ᱞᱤᱱ ᱢᱮ ᱟᱨ ᱱᱚᱣᱟ ᱡᱷᱟᱞᱠᱟᱣᱚᱜᱼᱟ ᱾ ᱞᱟᱴᱠᱟᱣ ᱛᱷᱚᱠᱟᱣ ᱢᱮ ᱟᱨ ᱱᱚᱣᱟ ᱞᱟᱦᱟ ᱪᱟᱞᱟᱜᱼᱟ ᱾ ᱚᱱᱟ ᱠᱟᱱᱟ ᱾ ᱟᱨ ᱢᱤᱫ ᱡᱤᱱᱤᱥ: ᱵᱮᱨᱮᱫ ᱜᱚᱱᱚᱝ ᱠᱚ᱾ ᱢᱤᱢᱤᱫ ᱫᱷᱟᱣ ᱟᱢ ᱫᱚ ᱮᱞᱠᱷᱟ ᱧᱮᱞ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ, ᱢᱟᱨᱥᱟᱞ ᱫᱚ ᱵᱟᱝ ᱾

ᱱᱚᱣᱟ ᱫᱷᱟᱯ ᱨᱮ, ᱟᱢ ᱧᱮᱞ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ:

ᱢᱤᱫ ᱟᱞᱜᱟ ᱚᱱ-ᱥᱠᱨᱤᱱ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ, ᱵᱩᱛᱟᱢ ᱡᱟᱦᱟᱸ ᱫᱚ ᱟᱢ ᱩᱱᱠᱩ ᱥᱟᱶ ᱜᱟᱯᱟᱞᱢᱟᱨᱟᱣ ᱥᱟᱶ ᱥᱟᱶᱛᱮ ᱛᱮᱞᱟ ᱮᱢᱟᱭᱟ, ᱟᱨ ᱢᱤᱫ ᱚᱯᱥᱚᱱᱟᱞ ᱰᱤᱵᱟᱜᱽ ᱨᱤᱰᱟᱣᱩᱴ ᱫᱚ ᱞᱤᱱ ᱟᱠᱟᱱ ᱵᱩᱛᱟᱢ ᱥᱩᱪᱤ ᱩᱫᱩᱜ ᱮᱫᱟᱭ ᱾

ᱱᱚᱣᱟ ᱠᱚᱢ ᱵᱮᱥ ᱵᱮᱱᱟᱣ ᱞᱟᱹᱜᱤᱫ, ᱱᱚᱸᱰᱮ ᱚᱱᱥᱠᱨᱤᱱ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱨᱮᱭᱟᱜ ᱩᱥᱟᱹᱨᱟ ᱰᱮᱢᱚ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱥᱟᱹᱨᱤ ᱚᱠᱛᱚ ᱨᱮ ᱨᱤᱭᱟᱠᱴ ᱮᱫᱟᱭ:

ᱱᱤᱛᱚᱜ, ᱥᱴᱟᱨᱴ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱞᱤᱱ ᱠᱷᱟᱱ ᱥᱟᱱᱟᱢᱟᱜ ᱞᱚᱜᱽ ᱦᱩᱭᱩᱜᱼᱟ ᱛᱤᱱ ᱦᱟᱹᱵᱤᱡ ᱟᱢ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱵᱚᱱᱫᱚ ᱵᱟᱝ ᱮᱢ ᱞᱤᱱᱟ᱾ ᱒. CSV/JSON ᱨᱮ ᱰᱟᱴᱟ ᱮᱠᱥᱯᱚᱨᱴ ᱢᱤᱫ ᱡᱮᱠᱷᱟ ᱟᱞᱮ ᱴᱷᱮᱱ ᱞᱚᱜᱽ ᱛᱟᱦᱮᱱ ᱠᱷᱟᱱ, ᱟᱞᱮ ᱚᱱᱟ ᱵᱟᱧᱪᱟᱣ ᱥᱟᱱᱟ ᱞᱮᱭᱟ ᱾

ᱫᱷᱟᱯ ᱑: ᱰᱟᱩᱱᱞᱳᱰ ᱜᱚᱲᱚᱭᱤᱡ ᱵᱮᱱᱟᱣ ᱢᱮ ᱯᱩᱭᱞᱩ ᱨᱮ, ᱟᱞᱮ ᱢᱤᱫ ᱜᱚᱲᱚᱭᱤᱡ ᱯᱷᱟᱱᱥᱚᱱ ᱞᱟᱹᱠᱛᱤᱭᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱨᱮ ᱨᱮᱫ ᱰᱟᱩᱱᱞᱳᱰ ᱠᱚ ᱥᱟᱢᱵᱽᱲᱟᱣᱟᱭ: // ================================ // ᱨᱮᱫ ᱰᱟᱩᱱᱞᱳᱰ ᱜᱚᱲᱚᱭᱤᱡ // ================================

ᱯᱷᱟᱱᱥᱚᱱ ᱰᱟᱩᱱᱞᱳᱰ ᱨᱮᱫ (ᱨᱮᱫ ᱧᱩᱛᱩᱢ, ᱡᱤᱱᱤᱥ, ᱞᱮᱠᱟ = "ᱚᱞ/ᱥᱟᱫᱷᱟᱨᱚᱱ") { // ᱡᱤᱱᱤᱥ ᱠᱷᱚᱱ ᱢᱤᱫ ᱵᱞᱚᱵᱽ ᱵᱮᱱᱟᱣ ᱢᱮ const blob = ᱱᱟᱶᱟ ᱵᱞᱚᱵᱽ ([ᱡᱤᱱᱤᱥ], { ᱞᱮᱠᱟ }); ᱠᱚᱱᱥᱴ ᱭᱩ ᱟᱨ ᱮᱞ = ᱭᱩ ᱟᱨ ᱮᱞ ᱾ ᱵᱮᱱᱟᱣ ᱚᱵᱡᱮᱠᱴ ᱭᱩ ᱟᱨ ᱮᱞ (ᱵᱽᱞᱚᱵᱽ);

// ᱢᱤᱫ ᱦᱟᱹᱞᱤ ᱞᱟᱹᱜᱤᱫ ᱰᱟᱩᱱᱞᱳᱰ ᱞᱤᱝᱠ ᱵᱮᱱᱟᱣ ᱢᱮ ᱟᱨ ᱚᱱᱟ ᱨᱮ ᱚᱛᱟᱭ ᱢᱮ ᱠᱚᱱᱥᱴ ᱮ = ᱰᱚᱠᱭᱩᱢᱮᱱᱴ ᱾ ᱠᱨᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ("ᱮ"); ᱮ.ᱦᱨᱮᱯ = ᱭᱩᱟᱨᱮᱞ; ᱮ.ᱰᱟᱩᱱᱞᱳᱰ = ᱨᱮᱫ ᱧᱩᱛᱩᱢ; ᱮ. ᱚᱛᱟᱭ ᱢᱮ ();

// ᱰᱟᱩᱱᱞᱳᱰ ᱛᱟᱭᱚᱢ ᱡᱤᱱᱤᱥ URL ᱥᱟᱯᱷᱟᱭ ᱢᱮ ᱥᱮᱴᱴᱟᱭᱤᱢᱟᱣᱩᱴ (() => ᱭᱩᱟᱨᱮᱞ.ᱨᱤᱣᱚᱠᱚᱵᱡᱮᱠᱴ ᱭᱩᱟᱨᱮᱞ (ᱭᱩᱟᱨᱮᱞ), ᱑᱐᱐); }

ᱱᱚᱶᱟ ᱯᱷᱟᱱᱥᱚᱱ ᱫᱚ ᱟᱢᱟᱜ ᱰᱟᱴᱟ ᱠᱷᱚᱱ ᱵᱞᱚᱵ (ᱵᱟᱭᱱᱟᱨᱤ ᱢᱟᱨᱟᱝ ᱡᱤᱱᱤᱥ) ᱵᱮᱱᱟᱣ ᱠᱟᱛᱮ ᱠᱟᱹᱢᱤ ᱠᱟᱱᱟ, ᱱᱚᱶᱟ ᱞᱟᱹᱜᱤᱫ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ URL ᱵᱮᱱᱟᱣ ᱠᱟᱛᱮ, ᱟᱨ ᱯᱨᱚᱜᱚᱨᱢ ᱞᱮᱠᱟᱛᱮ ᱰᱟᱩᱱᱞᱳᱰ ᱞᱤᱝᱠ ᱠᱷᱚᱱ ᱠᱟᱹᱢᱤ ᱠᱟᱱᱟ᱾ ᱥᱟᱯᱷᱟ ᱛᱮ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱟᱵᱚ ᱢᱮᱢᱚᱨᱤ ᱵᱟᱝ ᱞᱤᱠ ᱦᱩᱭᱩᱜ ᱛᱟᱵᱚᱱᱟ᱾ ᱫᱷᱟᱯ ᱒: ᱡᱮᱥᱚᱱ ᱮᱠᱥᱯᱚᱨᱴ ᱥᱟᱢᱵᱽᱲᱟᱣ ᱢᱮ ᱡᱮᱥᱚᱱ ᱫᱚ ᱯᱩᱨᱟᱹ ᱰᱟᱴᱟ ᱥᱴᱨᱟᱠᱪᱟᱨ ᱨᱟᱠᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱮᱠᱫᱚᱢ ᱴᱷᱤᱠ ᱜᱮᱭᱟ:

// ================================ // JSON ᱞᱮᱠᱟᱛᱮ ᱚᱰᱚᱠ ᱢᱮ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱮᱠᱥᱯᱚᱨᱴ-ᱡᱮᱥᱚᱱ"). ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ (" ᱚᱛᱟᱭ ᱢᱮ", () => { // ᱧᱮᱞ ᱢᱮ ᱡᱩᱫᱤ ᱮᱠᱥᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ ᱡᱟᱦᱟᱱᱟᱜ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱩᱫᱤ (! ᱯᱷᱨᱮᱢ ᱠᱚ᱾ ᱡᱮᱞᱮᱝ) { console.warn("ᱮᱠᱥᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ ᱪᱮᱫ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱵᱟᱹᱱᱩᱜᱼᱟ᱾"); ᱨᱩᱣᱟᱹᱲ; }

// ᱢᱮᱴᱟᱰᱟᱴᱟ ᱟᱨ ᱯᱷᱨᱟᱢ ᱠᱚ ᱥᱟᱶ ᱢᱤᱫ ᱯᱮᱞᱳᱰ ᱵᱮᱱᱟᱣ ᱢᱮ ᱠᱚᱱᱥᱴ ᱯᱮᱞᱳᱰ = { ᱵᱮᱱᱟᱣ ᱟᱠᱟᱱᱟ: ᱱᱟᱶᱟ ᱢᱟᱹᱦᱤᱛ (). ᱴᱳ ᱟᱭᱤ ᱮᱥ ᱚ ᱥᱴᱨᱤᱝ (), ᱯᱷᱨᱟᱢ };

// ᱯᱷᱚᱨᱢᱟᱴ ᱟᱠᱟᱱ JSON ᱞᱮᱠᱟᱛᱮ ᱰᱟᱩᱱᱞᱳᱰ ᱢᱮ ᱨᱮᱫ ᱰᱟᱩᱱᱞᱳᱰ( "ᱜᱮᱢᱯᱮᱰ-ᱞᱚᱜᱽ.ᱡᱮᱥᱚᱱ", ᱡᱮᱥᱚᱱ.ᱥᱴᱨᱤᱝᱜᱤᱯᱷᱟᱭ(ᱯᱮᱞᱳᱰ, ᱱᱩᱞ, ᱒), "ᱮᱯᱞᱤᱠᱮᱥᱚᱱ/ᱡᱮᱥᱚᱱ" ); });

JSON ᱯᱨᱚᱨᱩᱢ ᱫᱚ ᱡᱷᱚᱛᱚ ᱜᱮ ᱥᱴᱨᱟᱠᱴᱚᱨ ᱟᱨ ᱟᱞᱜᱟ ᱛᱮ ᱯᱟᱨᱥ ᱫᱟᱲᱮᱭᱟᱜ ᱠᱟᱱᱟ, ᱚᱱᱟ ᱫᱚ ᱰᱮᱵᱷ ᱴᱩᱞ ᱨᱮ ᱞᱳᱰ ᱞᱟᱹᱜᱤᱫ ᱥᱮ ᱜᱟᱛᱮ ᱠᱚ ᱥᱟᱶ ᱦᱟᱹᱴᱤᱧ ᱞᱟᱹᱜᱤᱫ ᱟᱹᱰᱤ ᱵᱮᱥ ᱜᱮᱭᱟ᱾ ᱫᱷᱟᱯ ᱓: ᱥᱤ ᱮᱥ ᱵᱤ ᱮᱠᱥᱯᱚᱨᱴ ᱥᱟᱢᱵᱽᱲᱟᱣ ᱢᱮ CSV ᱮᱠᱥᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ, ᱟᱵᱚ ᱫᱚ ᱯᱟᱫᱟᱱᱩᱠᱨᱟᱢ ᱰᱟᱴᱟ ᱛᱷᱟᱨ ᱟᱨ ᱠᱷᱟᱢᱵᱟ ᱨᱮ ᱪᱮᱯᱲᱮ ᱞᱟᱹᱠᱛᱤᱭᱟᱹᱹᱹ

//=============================== // CSV ᱞᱮᱠᱟᱛᱮ ᱚᱰᱚᱠ ᱢᱮ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱮᱠᱥᱯᱚᱨᱴ-ᱥᱤ ᱮᱥ ᱵᱤ"). ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ (" ᱚᱛᱟᱭ", () => { // ᱧᱮᱞ ᱢᱮ ᱡᱩᱫᱤ ᱮᱠᱥᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ ᱡᱟᱦᱟᱱᱟᱜ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱩᱫᱤ (! ᱯᱷᱨᱮᱢ ᱠᱚ᱾ ᱡᱮᱞᱮᱝ) { console.warn("ᱮᱠᱥᱯᱚᱨᱴ ᱞᱟᱹᱜᱤᱫ ᱪᱮᱫ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱵᱟᱹᱱᱩᱜᱼᱟ᱾"); ᱨᱩᱣᱟᱹᱲ; }

// CSV ᱦᱮᱰᱟᱨ ᱛᱷᱟᱨ ᱵᱮᱱᱟᱣ ᱢᱮ (ᱴᱟᱭᱤᱢ ᱥᱴᱟᱢᱯ ᱞᱟᱹᱜᱤᱫ ᱠᱚᱞᱟᱢ, ᱥᱟᱱᱟᱢ ᱵᱩᱛᱟᱢ, ᱥᱟᱱᱟᱢ ᱟᱠᱥ) ᱠᱚᱱᱥᱴ ᱦᱮᱰᱟᱨᱵᱩᱛᱟᱹᱢ = ᱯᱷᱨᱮᱢᱥ [᱐]. ᱵᱩᱛᱟᱹᱢ᱾ ᱢᱮᱯ ((_, ᱤᱧ) => ᱵᱤ ᱴᱤ ᱮᱱ $ {ᱤᱧ}); ᱠᱚᱱᱥᱴ ᱦᱮᱰᱟᱨ ᱮᱠᱥᱮᱥ = ᱯᱷᱨᱟᱢ [᱐]. ᱮᱠᱥᱮᱥ. ᱢᱮᱯ ((_, ᱤᱧ) => ᱮᱠᱥᱤᱥ $ {ᱤᱧ}); ᱠᱚᱱᱥᱴ ᱦᱮᱰᱟᱨ = ["ᱴᱤ", ... ᱦᱮᱰᱟᱨ ᱵᱩᱛᱟᱢ, ... ᱦᱮᱰᱟᱨ ᱮᱠᱥᱮᱥ]. ᱡᱚᱭᱤᱱ (",") + "\ ᱮᱱ";

// CSV ᱰᱟᱴᱟ ᱛᱷᱟᱨ ᱵᱮᱱᱟᱣ ᱢᱮ ᱠᱚᱱᱥᱴ ᱛᱷᱟᱨ ᱠᱚ = ᱯᱷᱨᱮᱢ ᱠᱚ ᱾ ᱢᱮᱯ (ᱮᱯ => { ᱠᱚᱱᱥᱴ ᱵᱤᱴᱤᱮᱱᱵᱷᱮᱞᱥ = ᱮᱯ.ᱵᱩᱛᱟᱹᱢ.ᱢᱮᱯ(ᱵᱤ => ᱵᱤ.ᱵᱷᱮᱞᱭᱩ); ᱨᱩᱣᱟᱹᱲ [ᱮᱯ.ᱴᱤ, ...ᱵᱤᱴᱤᱮᱱᱵᱷᱟᱞᱥ, ...ᱮᱯ.ᱮᱠᱥᱮᱥ].ᱡᱚᱭᱤᱱ(","); }).ᱡᱚᱭᱤᱱ("\n");

// CSV ᱞᱮᱠᱟᱛᱮ ᱰᱟᱩᱱᱞᱳᱰ ᱢᱮ ᱰᱟᱩᱱᱞᱳᱰ ᱨᱮᱫ ("ᱜᱮᱢᱯᱮᱰ-ᱞᱚᱜᱽ.ᱥᱤᱮᱥᱵᱷᱤ", ᱦᱮᱰᱟᱨ + ᱛᱷᱟᱨ, "ᱚᱞ/ᱥᱤᱮᱥᱵᱷᱤ"); });

CSV ᱫᱚ ᱰᱟᱴᱟ ᱵᱤᱰᱟᱹᱣ ᱞᱟᱹᱜᱤᱫ ᱵᱷᱟᱹᱜᱤ ᱜᱮᱭᱟ ᱪᱮᱫᱟᱜ ᱥᱮ ᱱᱚᱶᱟ ᱫᱚ ᱮᱠᱥᱮᱞ ᱥᱮ ᱜᱩᱜᱚᱞ ᱥᱤᱴ ᱨᱮ ᱥᱚᱡᱷᱮ ᱡᱷᱤᱡᱚᱜ-ᱟ, ᱚᱱᱟ ᱛᱮ ᱟᱢ ᱫᱚ ᱪᱟᱨᱴ, ᱰᱟᱴᱟ ᱯᱷᱤᱞᱴᱟᱨ, ᱥᱮ ᱧᱮᱞ ᱛᱮ ᱯᱮᱴᱟᱨᱱ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱱᱤᱛᱚᱜ ᱡᱮ ᱮᱠᱥᱯᱚᱨᱴ ᱵᱩᱛᱟᱢ ᱢᱮᱱᱟᱜᱼᱟ, ᱟᱢ ᱯᱮᱱᱮᱞ ᱨᱮ ᱵᱟᱨ ᱱᱟᱶᱟ ᱚᱯᱥᱚᱱ ᱧᱮᱞ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ: ᱮᱠᱥᱯᱚᱨᱴ ᱡᱮᱥᱚᱱ ᱟᱨ ᱮᱠᱥᱯᱚᱨᱴ ᱥᱤᱮᱥᱵᱤ᱾ JSON ᱫᱚ ᱱᱟᱯᱟᱭ ᱜᱮᱭᱟ ᱡᱩᱫᱤ ᱟᱢ ᱟᱢᱟᱜ ᱰᱮᱵᱷ ᱴᱩᱞᱥ ᱨᱮ ᱵᱮᱨᱮᱫ ᱞᱚᱜᱽ ᱨᱩᱣᱟᱹᱲ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ ᱟᱨᱵᱟᱝᱠᱷᱟᱱ ᱥᱴᱨᱟᱠᱪᱟᱨ ᱟᱲᱮ ᱟᱲᱮ ᱛᱮ ᱯᱚᱠ ᱥᱟᱱᱟᱭᱮᱫ ᱢᱮᱭᱟ᱾ CSV, ᱱᱷᱟᱛᱮ, ᱥᱤᱫᱷᱟᱹ ᱮᱠᱥᱮᱞ ᱵᱟᱝᱠᱷᱟᱱ ᱜᱩᱜᱚᱞ ᱥᱤᱴ ᱨᱮ ᱡᱷᱤᱡᱽᱚᱜᱼᱟ ᱡᱮᱢᱚᱱ ᱟᱢ ᱪᱟᱨᱴ, ᱯᱷᱤᱞᱴᱟᱨ, ᱵᱟᱝᱠᱷᱟᱱ ᱤᱱᱯᱩᱴ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ᱾ ᱞᱟᱛᱟᱨ ᱨᱮ ᱮᱢ ᱟᱠᱟᱱ ᱪᱤᱛᱟᱹᱨ ᱩᱫᱩᱜ ᱮᱫᱟᱭ ᱚᱱᱟ ᱵᱟᱹᱲᱛᱤ ᱠᱚᱵᱚᱡᱽ ᱥᱟᱶ ᱯᱮᱱᱮᱞ ᱪᱮᱫ ᱞᱮᱠᱟ ᱧᱮᱞᱚᱜᱼᱟ ᱾

᱓. ᱥᱱᱮᱯᱥᱚᱴ ᱥᱤᱥᱴᱚᱢ ᱚᱠᱟ ᱚᱠᱟ ᱫᱚ ᱟᱢ ᱯᱩᱨᱟᱹ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱵᱟᱝ ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ, ᱮᱠᱮᱱ ᱤᱱᱯᱩᱴ ᱥᱴᱮᱴ ᱨᱮᱭᱟᱜ ᱩᱥᱟᱹᱨᱟ “ᱥᱠᱨᱤᱱ ᱥᱚᱴ” ᱞᱟᱹᱠᱛᱤᱭᱟᱢᱟ᱾ ᱚᱱᱰᱮ ᱫᱚ ᱴᱮᱠ ᱥᱱᱮᱯᱥᱚᱴ ᱵᱩᱛᱟᱢ ᱜᱚᱲᱚ ᱮᱢᱟᱭᱟ ᱾

ᱟᱨ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ:

// ================================ // ᱥᱱᱮᱯᱥᱚᱴ ᱦᱟᱛᱟᱣ ᱢᱮ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱥᱱᱮᱯᱥᱚᱴ"). ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ (" ᱚᱛᱟᱭ ᱢᱮ", () => { // ᱡᱚᱛᱚ ᱡᱚᱯᱲᱟᱣ ᱜᱮᱢᱯᱮᱰ ᱠᱚ ᱧᱟᱢ ᱢᱮ ᱠᱚᱱᱥᱴ ᱯᱮᱰᱥ = ᱱᱮᱵᱷᱤᱜᱮᱴᱚᱨ.ᱜᱮᱴᱜᱮᱢᱯᱮᱰᱥ(); ᱠᱚᱱᱥᱴ ᱮᱠᱴᱤᱵᱷ ᱯᱮᱰᱥ = [];

// ᱞᱩᱯ ᱛᱟᱞᱟᱛᱮ ᱟᱨ ᱥᱟᱱᱟᱢ ᱡᱚᱯᱲᱟᱣ ᱜᱮᱢᱯᱮᱰ ᱨᱮᱭᱟᱜ ᱚᱵᱚᱥᱛᱟ ᱥᱟᱵ ᱢᱮ ᱞᱟᱹᱜᱤᱫ (ᱯᱮᱰ ᱨᱮᱭᱟᱜ ᱠᱚᱱᱥᱴ ᱡᱤᱯᱤ) { ᱡᱩᱫᱤ (!gp) ᱞᱟᱦᱟᱜ ᱠᱟᱱᱟ; // ᱠᱷᱟᱹᱞᱤ ᱥᱞᱚᱴ ᱵᱟᱹᱜᱤᱭᱟᱜ ᱢᱮ

ᱮᱠᱴᱤᱵᱷ ᱯᱮᱰᱥ᱾ ᱯᱩᱥ({ ᱟᱭᱤ ᱰᱤ: ᱡᱤ ᱯᱤ. ᱟᱭᱤ ᱰᱤ,// ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱧᱩᱛᱩᱢ/ᱢᱚᱰᱮᱞ ᱚᱠᱛᱚ ᱥᱴᱟᱢᱯ: ᱯᱟᱨᱯᱷᱚᱨᱢᱮᱱᱥ᱾ᱱᱤᱛᱚᱜ(), ᱵᱩᱛᱟᱢ: ᱡᱤᱯᱤ.ᱵᱩᱛᱟᱢ.ᱢᱮᱯ(ᱵᱤ => ({ ᱫᱟᱵᱟᱣ: ᱵᱤ. ᱫᱟᱵᱟᱣ, ᱜᱚᱱᱚᱝ: ᱵᱤ. ᱜᱚᱱᱚᱝ })), ᱟᱠᱥᱮᱥ: [... ᱡᱤ ᱯᱤ. ᱟᱠᱥᱮᱥ] }); }

// ᱧᱮᱞ ᱢᱮ ᱡᱩᱫᱤ ᱡᱟᱦᱟᱱ ᱜᱮᱢᱯᱮᱰ ᱧᱟᱢ ᱮᱱᱟ ᱡᱩᱫᱤ (! ᱮᱠᱴᱤᱵᱷ ᱯᱮᱰᱥ᱾ ᱡᱮᱞᱮᱝ) { console.warn("ᱥᱱᱮᱯᱥᱚᱴ ᱞᱟᱹᱜᱤᱫ ᱪᱮᱫ ᱜᱮᱢᱯᱮᱰ ᱵᱟᱝ ᱡᱚᱯᱲᱟᱣ ᱟᱠᱟᱱᱟ᱾"); ᱮᱞᱟᱨᱴ ("ᱪᱮᱫ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱵᱟᱝ ᱵᱟᱰᱟᱭ ᱧᱟᱢ ᱟᱠᱟᱱᱟ!"); ᱨᱩᱣᱟᱹᱲ; }

// ᱞᱚᱜᱽ ᱟᱨ ᱵᱮᱵᱷᱟᱨᱤᱭᱟᱹ ᱵᱟᱰᱟᱭ ᱚᱪᱚ ᱠᱚᱢ ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ("ᱥᱱᱮᱯᱥᱚᱴ:", ᱮᱠᱴᱤᱵᱷᱯᱮᱰᱥ); ᱮᱞᱟᱨᱴ (ᱥᱱᱮᱯᱥᱚᱴ ᱦᱟᱛᱟᱣ ᱟᱠᱟᱱᱟ! ᱠᱮᱯᱪᱚᱨ ᱟᱠᱟᱱᱟ ${ᱮᱠᱴᱤᱵᱷᱯᱮᱰᱥ.ᱞᱮᱸᱴ} ᱠᱚᱱᱴᱨᱚᱞᱟᱨ(ᱠᱚ)); });

ᱥᱱᱮᱯᱥᱚᱴ ᱫᱚ ᱚᱠᱛᱚ ᱨᱮ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ ᱨᱮ ᱟᱢᱟᱜ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱨᱮᱭᱟᱜ ᱴᱷᱤᱠ ᱚᱵᱚᱥᱛᱟ ᱯᱷᱨᱤᱡᱽ ᱫᱚᱦᱚᱭᱟᱭ ᱾ ᱔. ᱵᱷᱩᱛ ᱤᱱᱯᱩᱴ ᱨᱤᱯᱞᱮ ᱱᱤᱛᱚᱜ ᱫᱚ ᱨᱟᱹᱥᱠᱟᱹ ᱞᱟᱹᱜᱤᱫ: ᱵᱷᱩᱛ ᱤᱱᱯᱩᱴ ᱨᱤᱯᱞᱮ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱢᱤᱫ ᱞᱚᱜᱽ ᱦᱟᱛᱟᱣ ᱠᱟᱛᱮ ᱧᱮᱞ ᱞᱮᱠᱟᱛᱮ ᱪᱟᱹᱞᱩᱭᱟ ᱡᱮᱢᱚᱱ ᱢᱤᱫ ᱯᱷᱮᱱᱴᱚᱢ ᱠᱷᱮᱞᱚᱱᱰ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱵᱮᱵᱷᱟᱨ ᱠᱟᱱ ᱛᱟᱦᱮᱸᱡ ᱾

ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱞᱟᱹᱜᱤᱫ ᱡᱟᱶᱟ ᱥᱠᱨᱤᱯᱴ: // ================================ // ᱵᱷᱩᱛ ᱫᱚᱦᱲᱟ ᱠᱷᱮᱞᱚᱜ // ================================

ᱰᱚᱠᱭᱩᱢᱮᱱᱴ᱾ ᱜᱮᱴ ᱮᱞᱤᱢᱮᱱᱴ ᱵᱟᱭ ᱟᱭᱤ ᱰᱤ ("ᱨᱤᱯᱞᱮ"). ᱮᱰ ᱤᱵᱷᱮᱱᱴ ᱞᱤᱥᱱᱟᱨ (" ᱚᱛᱟᱭ ᱢᱮ", () => { // ᱴᱷᱟᱹᱣᱠᱟᱹ ᱢᱮ ᱟᱞᱮ ᱴᱷᱮᱱ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱞᱟᱹᱜᱤᱫ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱢᱮᱱᱟᱜᱼᱟ ᱡᱩᱫᱤ (! ᱯᱷᱨᱮᱢ ᱠᱚ᱾ ᱡᱮᱞᱮᱝ) { ᱮᱞᱟᱨᱴ ("ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱞᱟᱹᱜᱤᱫ ᱨᱮᱠᱚᱨᱰᱤᱝ ᱵᱟᱹᱱᱩᱜᱼᱟ!"); ᱨᱩᱣᱟᱹᱲ; }

ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ("ᱵᱷᱩᱛ ᱨᱤᱯᱞᱮ ᱮᱦᱚᱵᱚᱜ ᱠᱟᱱᱟ...");

// ᱥᱤᱱᱠᱮᱰ ᱯᱞᱮᱵᱮᱠ ᱞᱟᱹᱜᱤᱫ ᱚᱠᱛᱚ ᱴᱨᱮᱠ ᱮᱛᱚᱦᱚᱵ ᱚᱠᱛᱚ = ᱯᱟᱨᱯᱷᱚᱨᱢᱮᱱᱥ᱾ᱱᱤᱛᱚᱜ (); ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ = ᱐;

// ᱮᱱᱤᱢᱮᱥᱚᱱ ᱞᱩᱯ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩᱭ ᱢᱮ ᱯᱷᱟᱸᱠᱥᱚᱱ ᱥᱴᱮᱯ () { const ᱱᱤᱛᱚᱜ = ᱯᱟᱨᱯᱷᱚᱨᱢᱮᱱᱥ᱾ᱱᱤᱛᱚᱜ(); const ᱮᱞᱟᱯᱥᱰ = ᱱᱤᱛᱚᱜ - ᱮᱛᱚᱦᱚᱵ ᱚᱠᱛᱚ;

// ᱡᱚᱛᱚ ᱯᱷᱨᱟᱢ ᱠᱚ ᱯᱨᱚᱥᱮᱥ ᱢᱮ ᱚᱠᱟ ᱠᱚ ᱫᱚ ᱱᱤᱛ ᱦᱟᱹᱵᱤᱡ ᱦᱩᱭ ᱞᱟᱹᱠᱛᱤ ᱠᱟᱱᱟ ᱡᱚᱠᱷᱚᱱ (ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ < ᱯᱷᱨᱮᱢ ᱠᱚ᱾ ᱡᱮᱞᱮᱝ && ᱯᱷᱨᱮᱢ ᱠᱚ [ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ]. ᱴᱤ <= ᱪᱟᱞᱟᱣ ᱮᱱᱟ) { ᱠᱚᱱᱥᱴ ᱯᱷᱨᱟᱢ = ᱯᱷᱨᱟᱢ [ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ];

// ᱨᱮᱠᱚᱨᱰ ᱵᱩᱛᱟᱢ ᱥᱴᱮᱴ ᱥᱟᱶ UI ᱟᱯᱰᱮᱴ ᱢᱮ ᱵᱤᱴᱤᱮᱱᱮ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱯᱷᱨᱮᱢ.ᱵᱩᱛᱟᱢ [᱐]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ); ᱵᱤᱴᱤᱮᱱᱵᱤ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱯᱷᱨᱟᱢ.ᱵᱩᱛᱟᱢ [᱑]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ); ᱵᱤᱴᱤᱮᱱᱮᱠᱥ.ᱠᱞᱟᱥᱞᱤᱥᱴ.ᱴᱚᱜᱽᱞ("ᱮᱠᱴᱤᱵᱷ", ᱯᱷᱨᱟᱢ.ᱵᱩᱛᱟᱢ [᱒]. ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱᱟ);

// ᱥᱴᱮᱴᱟᱥ ᱰᱤᱥᱯᱞᱮ ᱟᱯᱰᱮᱴ ᱢᱮ ᱫᱟᱵᱟᱣ ᱢᱮ = []; ᱯᱷᱨᱟᱢ᱾ ᱵᱩᱛᱟᱢ᱾ ᱥᱟᱱᱟᱢ ᱞᱟᱹᱜᱤᱫ ((ᱵᱤᱴᱤᱮᱱ, ᱤᱧ) => { ᱡᱩᱫᱤ (btn. ᱞᱤᱱ) ᱞᱤᱱ. ᱯᱩᱥ ("ᱵᱩᱛᱟᱹᱢ" + i); }); ᱡᱩᱫᱤ (ᱫᱟᱵᱟᱣ ᱟᱠᱟᱱ᱾ ᱡᱮᱞᱮᱝ > ᱐) { ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱵᱷᱩᱛ: " + ᱯᱨᱮᱥᱰ.ᱡᱚᱭᱤᱱ(", "); }

ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ++; }

// ᱡᱩᱫᱤ ᱟᱨᱦᱚᱸ ᱯᱷᱨᱟᱢ ᱠᱚ ᱛᱟᱦᱮᱱ ᱠᱷᱟᱱ ᱞᱩᱯ ᱞᱟᱦᱟᱭ ᱢᱮ ᱡᱩᱫᱤ (ᱯᱷᱨᱮᱢ ᱤᱱᱰᱮᱠᱥ < ᱯᱷᱨᱮᱢ ᱠᱚ᱾ ᱡᱮᱞᱮᱝ) { ᱟᱨᱫᱟᱥ ᱮᱱᱤᱢᱮᱥᱚᱱ ᱯᱷᱨᱮᱢ (ᱛᱷᱟᱠ); } ᱟᱨᱦᱚᱸ { ᱠᱚᱱᱥᱚᱞ.ᱞᱚᱜᱽ("ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩᱪᱟᱵᱟ ᱮᱱᱟ᱾"); ᱥᱴᱮᱴᱟᱥ.ᱴᱮᱠᱥᱠᱚᱱᱴᱮᱱᱴ = "ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱯᱩᱨᱟᱹᱣ ᱮᱱᱟ"; } }

// ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱮᱦᱚᱵ ᱢᱮ ᱥᱴᱮᱯ (); });

ᱰᱤᱵᱟᱜᱽ ᱱᱟᱥᱮ ᱵᱟᱹᱲᱛᱤ ᱦᱮᱱᱰᱥ ᱚᱱ ᱞᱟᱹᱜᱤᱫ, ᱤᱧ ᱢᱤᱫ ᱵᱷᱩᱛ ᱨᱤᱯᱞᱮ ᱥᱮᱞᱮᱫ ᱠᱮᱫᱟᱹᱧ ᱾ ᱢᱤᱫ ᱫᱷᱟᱣ ᱥᱮᱥᱚᱱ ᱨᱮᱠᱚᱨᱰ ᱠᱟᱛᱮ, ᱟᱢ ᱨᱤᱯᱞᱮ ᱫᱟᱵᱚᱱ ᱠᱟᱛᱮ UI ᱮᱠᱴᱚᱢ ᱧᱮᱞ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, ᱯᱷᱮᱱᱴᱚᱢ ᱯᱞᱮᱭᱟᱨ ᱯᱮᱰ ᱪᱟᱞᱟᱣ ᱠᱟᱱ ᱞᱮᱠᱟ ᱾ ᱱᱚᱶᱟ ᱞᱟᱹᱜᱤᱫ ᱯᱮᱱᱮᱞ ᱨᱮ ᱢᱤᱫ ᱱᱟᱶᱟ ᱨᱤᱯᱞᱮ ᱜᱳᱥᱴ ᱵᱩᱛᱟᱢ ᱧᱮᱞᱚᱜᱼᱟ ᱾

ᱨᱮᱠᱚᱨᱰ ᱫᱟᱵᱟᱣ ᱢᱮ, ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱥᱟᱶ ᱱᱟᱥᱮ ᱜᱷᱟᱹᱲᱤᱡ ᱢᱮ, ᱛᱷᱤᱨ ᱢᱮ, ᱚᱱᱟ ᱛᱟᱭᱚᱢ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩᱭ ᱢᱮ ᱾ UI ᱫᱚ ᱟᱢ ᱡᱟᱦᱟᱸ ᱜᱮᱢ ᱠᱚᱨᱟᱣ ᱞᱮᱫᱟ ᱚᱱᱟ ᱜᱮ ᱜᱩᱲᱦᱟᱹᱣ ᱮᱫᱟᱭ, ᱡᱮᱢᱚᱱ ᱢᱤᱫ ᱵᱷᱩᱛ ᱟᱢᱟᱜ ᱤᱱᱯᱩᱴ ᱮ ᱯᱟᱧᱡᱟᱭᱮᱫᱟ᱾ ᱱᱚᱶᱟ ᱵᱟᱹᱲᱛᱤ ᱠᱚ ᱥᱟᱶ ᱪᱮᱫᱟᱜ ᱮᱢ ᱵᱚᱛᱚᱨᱚᱜ ᱠᱟᱱᱟ?

ᱨᱮᱠᱚᱨᱰᱤᱝ/ᱮᱠᱥᱯᱚᱨᱴ ᱫᱚ ᱵᱤᱱᱤᱰᱤᱭᱟᱹ ᱠᱚ ᱞᱟᱹᱜᱤᱫ ᱟᱞᱜᱟ ᱛᱮ ᱩᱫᱩᱜ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱪᱮᱫ ᱦᱩᱭ ᱟᱠᱟᱱᱟ ᱾ ᱥᱱᱮᱯᱥᱚᱴ ᱫᱚ ᱚᱠᱛᱚ ᱨᱮ ᱢᱤᱫ ᱜᱷᱟᱹᱲᱤ ᱯᱷᱨᱤᱡᱽ ᱛᱟᱦᱮᱱᱟ, ᱟᱹᱰᱤ ᱞᱟᱹᱠᱛᱤᱭᱟᱱ ᱛᱤᱱ ᱨᱮ ᱟᱢ ᱵᱮᱜᱟᱨ ᱛᱤᱡᱩ ᱠᱚ ᱯᱟᱧᱡᱟᱭᱮᱫ ᱢᱮᱭᱟ᱾ ᱜᱳᱥᱴ ᱨᱤᱯᱞᱮ ᱫᱚ ᱴᱩᱴᱳᱨᱤᱭᱟᱞ, ᱮᱠᱥᱮᱥᱤᱵᱤᱞᱤᱴᱤ ᱪᱮᱠ, ᱥᱮ ᱥᱩᱢᱩᱝ ᱯᱟᱦᱴᱟ ᱛᱮ ᱠᱚᱱᱴᱨᱚᱞ ᱥᱮᱴᱟᱯ ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱞᱟᱹᱜᱤᱫ ᱟᱹᱰᱤ ᱵᱮᱥ ᱜᱮᱭᱟ᱾

ᱱᱚᱣᱟ ᱚᱠᱛᱚ ᱨᱮ, ᱱᱚᱣᱟ ᱫᱚ ᱮᱠᱮᱱ ᱢᱤᱫ ᱥᱟᱯᱷᱟ ᱰᱮᱢᱚ ᱫᱚ ᱵᱟᱝ ᱠᱟᱱᱟ, ᱢᱮᱱᱠᱷᱟᱱ ᱟᱢ ᱫᱚ ᱥᱟᱹᱨᱤ ᱛᱮ ᱠᱟᱹᱢᱤ ᱨᱮ ᱫᱚᱦᱚ ᱠᱟᱛᱮ ᱡᱟᱦᱟᱱᱟᱜ ᱜᱮᱢ ᱫᱚᱦᱚ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱥᱟᱹᱨᱤ-ᱫᱷᱟᱹᱨᱛᱤ ᱵᱮᱵᱷᱟᱨ ᱠᱮᱥ ᱠᱚ ᱱᱤᱛᱚᱜ ᱟᱞᱮ ᱱᱚᱣᱟ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱞᱮ ᱧᱟᱢ ᱠᱮᱫᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱟᱹᱰᱤ ᱜᱟᱱ ᱠᱟᱹᱢᱤ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱭ ᱾ ᱱᱚᱣᱟ ᱫᱚ ᱞᱟᱭᱤᱵᱽ ᱤᱱᱯᱩᱴ ᱩᱫᱩᱜ ᱟᱭ, ᱞᱚᱜᱽ ᱨᱮᱠᱚᱨᱰ ᱮᱫᱟᱭ, ᱚᱱᱟ ᱮᱠᱥᱯᱚᱨᱴ ᱮᱫᱟᱭ, ᱟᱨ ᱡᱤᱱᱤᱥ ᱠᱚ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱦᱚᱸ ᱮᱫᱟᱭ ᱾ ᱢᱮᱱᱠᱷᱟᱱ ᱥᱟᱹᱨᱤ ᱠᱩᱠᱞᱤ ᱫᱚ ᱱᱚᱶᱟ ᱠᱟᱱᱟ: ᱚᱠᱚᱭ ᱥᱟᱹᱨᱤ ᱛᱮ ᱪᱤᱱᱛᱟᱹ ᱮᱢᱟᱭᱟᱭ? ᱱᱚᱣᱟ ᱫᱚ ᱚᱠᱚᱭ ᱞᱟᱹᱜᱤᱫ ᱞᱟᱹᱠᱛᱤᱭᱟᱱᱟ? ᱠᱷᱮᱞ ᱩᱛᱱᱟᱹᱣᱠᱚ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱠᱚ ᱫᱚ ᱠᱟᱹᱢᱤ ᱨᱮᱱᱟᱜ ᱦᱟᱹᱴᱤᱧ ᱠᱟᱱᱟ ᱠᱚ, ᱢᱮᱱᱠᱷᱟᱱ ᱩᱱᱠᱩ ᱰᱤᱵᱟᱜᱽ ᱠᱚ ᱪᱮ? ᱥᱟᱫᱷᱟᱨᱚᱱ ᱢᱤᱫ ᱦᱟᱥᱳ ᱾ ᱟᱢᱟᱜ ᱩᱭᱦᱟᱹᱨ ᱢᱮ ᱟᱢ ᱢᱤᱫ ᱞᱟᱹᱲᱦᱟᱹᱭ ᱠᱷᱮᱞ ᱠᱚᱢᱵᱚ ᱵᱤᱱᱤᱰ ᱮᱫᱟᱢ, ᱡᱮᱞᱠᱟ ↓ → + ᱯᱩᱸᱪ ᱾ ᱱᱮᱦᱚᱨ ᱵᱚᱫᱚᱞ ᱛᱮ, ᱟᱢ ᱱᱚᱣᱟ ᱵᱟᱨ ᱫᱷᱟᱣ ᱢᱤᱫ ᱞᱮᱠᱟᱢ ᱫᱟᱵᱟᱣ ᱠᱮᱫᱟ, ᱟᱢ ᱢᱤᱫ ᱫᱷᱟᱣ ᱨᱮᱠᱚᱨᱰ ᱠᱮᱫᱟᱢ, ᱟᱨ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱠᱮᱫᱟᱢ ᱾ ᱥᱟᱹᱛ ᱮᱱᱟ᱾ ᱟᱨ ᱵᱟᱝ ᱟᱢ ᱫᱚ ᱢᱤᱫ ᱜᱟᱛᱮ ᱥᱟᱶ JSON ᱞᱚᱜᱽ ᱵᱚᱫᱚᱞ ᱠᱟᱛᱮ ᱧᱮᱞ ᱢᱮ ᱡᱮ ᱟᱢᱟᱜ ᱢᱟᱞᱴᱤᱯᱞᱮᱭᱟᱨ ᱠᱚᱰ ᱩᱱᱠᱩᱣᱟᱜ ᱢᱟᱥᱤᱱ ᱨᱮ ᱢᱤᱫ ᱞᱮᱠᱟᱭ ᱨᱤᱭᱟᱠᱴ ᱮᱫᱟ ᱥᱮ ᱵᱟᱝᱟ᱾ ᱚᱱᱟ ᱫᱚ ᱟᱹᱰᱤ ᱢᱟᱨᱟᱝ ᱜᱮᱭᱟ᱾ ᱮᱠᱥᱮᱥᱤᱵᱤᱞᱤᱴᱤ ᱯᱨᱮᱠᱴᱤᱥᱚᱱᱟᱨ ᱱᱚᱣᱟ ᱫᱚ ᱤᱧᱟᱜ ᱨᱤᱫᱟᱹᱭ ᱥᱩᱨ ᱨᱮ ᱢᱮᱱᱟᱜᱼᱟ ᱾ ᱡᱚᱛᱚ ᱦᱚᱲ ᱜᱮ “ᱥᱴᱮᱱᱰᱟᱨᱰ” ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱥᱟᱶ ᱵᱟᱠᱚ ᱠᱷᱮᱞᱚᱜᱼᱟ ᱾ ᱮᱰᱟᱯᱴᱤᱵᱷ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱠᱚ ᱚᱠᱟ ᱚᱠᱟ ᱫᱚ ᱦᱟᱦᱟᱲᱟ ᱥᱤᱜᱽᱱᱟᱞ ᱠᱚ ᱚᱰᱚᱠᱟ᱾ ᱱᱚᱣᱟ ᱥᱟᱯᱟᱵ ᱛᱮ, ᱟᱢ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱧᱮᱞ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ ᱪᱮᱫ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ᱾ ᱢᱟᱪᱮᱛ, ᱠᱷᱚᱱᱫᱽᱨᱚᱱᱤᱭᱟᱹ, ᱡᱟᱦᱟᱸᱭ ᱠᱚ ᱜᱮ᱾ ᱩᱱᱠᱩ ᱞᱚᱜᱽ ᱠᱚ ᱥᱟᱵ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱛᱩᱞᱟᱹ ᱡᱚᱠᱷᱟ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨᱵᱟᱝ ᱯᱟᱦᱴᱟ ᱛᱮ ᱯᱟᱦᱴᱟ ᱛᱮ ᱤᱱᱯᱩᱴ ᱠᱚ ᱫᱚᱦᱲᱟ ᱪᱟᱹᱞᱩ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱾ ᱟᱪᱠᱟ ᱜᱮ, ᱵᱟᱝ ᱧᱮᱞᱚᱜ ᱡᱤᱱᱤᱥ ᱯᱩᱥᱴᱟᱹᱣ ᱮᱱᱟ ᱾ ᱜᱩᱱᱟᱱ ᱟᱥᱭᱚᱨᱮᱱᱥ ᱵᱤᱱᱤᱰ ᱵᱤᱱᱤᱰᱤᱭᱟᱹ ᱠᱚ ᱫᱚ ᱚᱱᱠᱟᱱ ᱱᱚᱴ ᱠᱚ ᱚᱞ ᱮᱫᱟ “ᱤᱧ ᱱᱚᱸᱰᱮ ᱵᱩᱛᱟᱢ ᱠᱚ ᱢᱮᱥ ᱠᱮᱫᱟᱹᱧ ᱟᱨ ᱱᱚᱣᱟ ᱨᱟᱹᱯᱩᱫ ᱮᱱᱟ ᱾” ᱩᱱᱟᱹᱜ ᱜᱚᱲᱚ ᱵᱟᱝ ᱦᱩᱭᱩᱜ ᱠᱟᱱᱟ ᱾ ᱱᱤᱛᱚᱜ? ᱩᱱᱠᱩ ᱴᱷᱟᱹᱣᱠᱟᱹ ᱯᱨᱮᱥ ᱠᱚ ᱥᱟᱵ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱞᱚᱜᱽ ᱠᱚ ᱮᱠᱥᱯᱚᱨᱴ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ, ᱟᱨ ᱠᱚ ᱵᱷᱮᱡᱟ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱾ ᱵᱟᱝ ᱟᱴᱠᱟᱨ ᱾ ᱥᱮᱪᱮᱫᱤᱭᱟᱹ ᱡᱩᱫᱤ ᱟᱢ ᱴᱩᱴᱳᱨᱤᱭᱟᱞ ᱥᱮ ᱭᱩᱴᱭᱩᱵᱽ ᱵᱷᱤᱰ ᱮᱢ ᱵᱮᱱᱟᱣ ᱮᱫᱟ, ᱵᱷᱩᱛ ᱨᱤᱯᱞᱮ ᱫᱚ ᱥᱚᱱᱟ ᱠᱟᱱᱟ᱾ ᱟᱢ ᱥᱟᱹᱨᱤ ᱛᱮ ᱢᱮᱱ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ, “ᱱᱚᱸᱰᱮ ᱤᱧ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱥᱟᱶ ᱪᱮᱫ ᱤᱧ ᱠᱚᱨᱟᱣ ᱠᱮᱫᱟ,” ᱡᱚᱠᱷᱚᱱ UI ᱫᱚ ᱱᱚᱶᱟ ᱦᱩᱭᱩᱜ ᱠᱟᱱ ᱩᱫᱩᱜ ᱠᱟᱱᱟ᱾ ᱵᱩᱡᱷᱟᱹᱣ ᱠᱚ ᱟᱨᱦᱚᱸ ᱯᱩᱥᱴᱟᱹᱣ ᱢᱮ ᱾ ᱠᱷᱮᱞ ᱠᱚ ᱯᱟᱨᱚᱢ ᱟᱨ ᱦᱚᱭ, ᱱᱚᱣᱟ ᱫᱚ ᱠᱷᱟᱹᱞᱤ ᱠᱷᱮᱞ ᱵᱟᱵᱚᱛ ᱫᱚ ᱵᱟᱝ ᱠᱟᱱᱟ ᱾ ᱦᱚᱲ ᱠᱚ ᱨᱚᱵᱚᱴ, ᱟᱨᱴ ᱯᱨᱚᱡᱮᱠᱴ ᱟᱨ ᱥᱮᱴᱮᱨᱚᱜ ᱤᱱᱴᱟᱨᱯᱷᱮᱥ ᱠᱚ ᱞᱟᱹᱜᱤᱫ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱠᱚ ᱵᱮᱵᱷᱟᱨ ᱟᱠᱟᱫᱟ᱾ ᱥᱟᱱᱟᱢ ᱚᱠᱛᱚ ᱢᱤᱫ ᱮᱴᱠᱮᱴᱚᱬᱮ: ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱥᱟᱹᱨᱤ ᱛᱮ ᱪᱮᱫ ᱧᱮᱞ ᱮᱫᱟᱭ? ᱱᱚᱣᱟ ᱥᱟᱶᱛᱮ, ᱟᱢ ᱟᱴᱠᱟᱨ ᱵᱟᱝ ᱦᱩᱭᱩᱜ ᱛᱟᱢᱟ᱾ ᱢᱩᱪᱟᱹᱫ ᱠᱟᱛᱷᱟ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱤᱱᱯᱩᱴ ᱰᱤᱵᱟᱜᱽ ᱫᱚ ᱥᱟᱨᱟ ᱜᱷᱟᱹᱲᱤᱡ ᱩᱰᱟᱹᱣ ᱵᱞᱟᱭᱤᱱᱰ ᱞᱮᱠᱟ ᱟᱹᱭᱠᱟᱹᱣᱚᱜ ᱠᱟᱱᱟ᱾ DOM ᱥᱮ CSS ᱞᱮᱠᱟ ᱵᱟᱝ, ᱜᱮᱢᱯᱮᱰ ᱞᱟᱹᱜᱤᱫ ᱵᱤᱞᱴ-ᱤᱱ ᱤᱱᱥᱯᱮᱠᱴᱚᱨ ᱵᱟᱹᱱᱩᱜᱼᱟ; ᱱᱚᱣᱟ ᱫᱚ ᱠᱚᱱᱥᱚᱞ ᱨᱮ ᱥᱩᱢᱩᱝ ᱵᱮᱨᱮᱫ ᱮᱞ ᱠᱟᱱᱟ, ᱠᱟᱞᱠᱟᱞᱟᱣ ᱨᱮ ᱟᱞᱜᱟ ᱛᱮ ᱟᱫᱚᱜᱼᱟ ᱾ HTML, CSS, ᱟᱨ JavaScript ᱨᱮᱭᱟᱜ ᱛᱤᱱᱟᱹᱜ ᱜᱟᱱ ᱥᱟᱭ ᱞᱟᱭᱤᱱ ᱥᱟᱶᱛᱮ, ᱟᱞᱮ ᱫᱚ ᱡᱟᱦᱟᱱᱟᱜ ᱵᱷᱮᱜᱟᱨ ᱞᱮ ᱵᱮᱱᱟᱣ ᱠᱮᱫᱟᱺ

ᱢᱤᱫ ᱧᱮᱞᱚᱜ ᱰᱤᱵᱟᱜᱽᱜᱟᱨ ᱡᱟᱦᱟᱸ ᱫᱚ ᱵᱟᱝ ᱧᱮᱞᱚᱜ ᱤᱱᱯᱩᱴ ᱠᱚ ᱧᱮᱞᱚᱜ ᱞᱮᱠᱟ ᱵᱮᱱᱟᱣ ᱮᱫᱟᱭ ᱾ ᱢᱤᱫ ᱞᱮᱭᱟᱨᱰ CSS ᱥᱤᱥᱴᱚᱢ ᱡᱟᱦᱟᱸ ᱫᱚ UI ᱥᱟᱯᱷᱟ ᱟᱨ ᱰᱤᱵᱟᱜᱽᱵᱚᱞ ᱫᱚᱦᱚᱭᱟᱭ ᱾ ᱵᱟᱹᱲᱛᱤ ᱨᱮᱭᱟᱜ ᱢᱤᱫ ᱥᱮᱴ (ᱨᱮᱠᱚᱨᱰᱤᱝ, ᱮᱠᱥᱯᱚᱨᱴᱤᱝ, ᱥᱱᱮᱯᱥᱚᱴ, ᱜᱳᱥᱴ ᱨᱤᱯᱞᱮ) ᱚᱠᱟ ᱫᱚ ᱱᱚᱶᱟ ᱰᱮᱢᱚ ᱠᱷᱚᱱ ᱰᱮᱵᱷᱞᱚᱯᱟᱨ ᱴᱩᱞ ᱨᱮ ᱩᱛᱟᱹᱨ ᱮᱫᱟᱭ᱾

ᱱᱚᱶᱟ ᱯᱨᱚᱡᱮᱠᱴ ᱫᱚ ᱩᱫᱩᱜ ᱮᱫᱟ ᱡᱮ ᱟᱢ ᱫᱚ CSS Cascade Layers ᱨᱮ ᱠᱟᱹᱴᱤᱡ ᱥᱤᱨᱡᱚᱱ ᱥᱟᱶ ᱣᱮᱵᱽ ᱯᱞᱮᱴᱯᱷᱚᱨᱢ ᱨᱮᱭᱟᱜ ᱫᱟᱲᱮ ᱢᱮᱥᱟ ᱠᱟᱛᱮ ᱛᱤᱱᱟᱹᱜ ᱥᱟᱺᱜᱤᱧ ᱥᱮᱱ ᱫᱟᱲᱮᱭᱟᱜ-ᱟ᱾ ᱤᱧ ᱡᱟᱦᱟᱸ ᱥᱟᱯᱟᱵ ᱯᱩᱨᱟᱹ ᱛᱮᱧ ᱞᱟᱹᱭ ᱟᱠᱟᱫᱟ ᱚᱱᱟ ᱫᱚ ᱚᱯᱷᱮᱱ-ᱥᱚᱨᱥ ᱠᱟᱱᱟ ᱾ ᱟᱢ ᱜᱤᱴᱦᱟᱵᱽ ᱨᱮᱯᱳ ᱠᱞᱚᱱ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ ᱟᱨ ᱟᱢ ᱟᱢᱛᱮ ᱪᱮᱥᱴᱟᱭ ᱢᱮ ᱾ ᱢᱮᱱᱠᱷᱟᱱ ᱱᱤᱭᱟᱹ ᱠᱷᱚᱱ ᱦᱚᱸ ᱞᱟᱹᱠᱛᱤᱭᱟᱱᱟᱜ ᱠᱟᱛᱷᱟ ᱫᱚ, ᱟᱢ ᱱᱚᱶᱟ ᱟᱢᱟᱜ ᱛᱮᱢ ᱵᱮᱱᱟᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ᱾ ᱟᱢᱟᱜ ᱱᱤᱡᱮᱨ ᱞᱮᱭᱟᱨ ᱥᱮᱞᱮᱫ ᱢᱮ᱾ ᱟᱢᱟᱜ ᱱᱤᱡᱮᱨ ᱨᱤᱯᱞᱮ ᱞᱚᱡᱤᱠ ᱵᱮᱱᱟᱣ ᱢᱮ᱾ ᱱᱚᱣᱟ ᱟᱢᱟᱜ ᱠᱷᱮᱞ ᱯᱨᱚᱴᱚᱴᱟᱭᱤᱯ ᱥᱟᱶ ᱡᱩᱢᱤᱫ ᱢᱮ ᱾ ᱟᱨ ᱵᱟᱝ ᱤᱧ ᱵᱟᱹᱧ ᱩᱭᱦᱟᱹᱨ ᱟᱠᱟᱫ ᱞᱮᱠᱟ ᱵᱮᱵᱷᱟᱨ ᱦᱚᱸ ᱾ ᱪᱮᱫᱚᱜ ᱞᱟᱹᱜᱤᱫ, ᱥᱮᱴᱮᱨᱚᱜ ᱞᱟᱹᱜᱤᱫ, ᱵᱟᱝᱠᱷᱟᱱ ᱰᱟᱴᱟ ᱵᱤᱥᱲᱤ ᱞᱟᱹᱜᱤᱫ᱾ ᱢᱩᱪᱟᱹᱫ ᱢᱟᱦᱟᱸ ᱦᱤᱞᱚᱜ, ᱱᱚᱶᱟ ᱫᱚ ᱮᱠᱮᱱ ᱜᱮᱢᱯᱮᱰ ᱰᱤᱵᱟᱜᱽ ᱵᱟᱵᱚᱛ ᱫᱚ ᱵᱟᱝ ᱠᱟᱱᱟ ᱾ ᱱᱚᱶᱟ ᱫᱚ ᱩᱠᱩ ᱤᱱᱯᱩᱴ ᱨᱮ ᱢᱤᱫ ᱢᱟᱨᱥᱟᱞ ᱡᱷᱟᱞᱠᱟᱣ ᱞᱟᱹᱜᱤᱫ ᱠᱟᱱᱟ, ᱟᱨ ᱰᱮᱵᱷᱞᱚᱯᱟᱨ ᱠᱚ ᱦᱟᱨᱰᱣᱮᱭᱟᱨ ᱥᱟᱶ ᱠᱟᱹᱢᱤ ᱞᱟᱹᱜᱤᱫ ᱯᱟᱹᱛᱤᱭᱟᱹᱣ ᱮᱢ ᱠᱟᱱᱟ ᱡᱟᱦᱟᱸ ᱫᱚ ᱣᱮᱵᱽ ᱫᱚ ᱱᱤᱛ ᱦᱚᱸ ᱵᱟᱭ ᱟᱝᱜᱚᱪ ᱫᱟᱲᱮᱭᱟᱜ ᱠᱟᱱᱟ᱾ ᱚᱱᱟᱛᱮ, ᱟᱢᱟᱜ ᱠᱚᱱᱴᱨᱚᱞᱟᱨ ᱯᱞᱟᱜᱽ ᱤᱱ ᱢᱮ, ᱟᱢᱟᱜ ᱮᱰᱤᱴᱚᱨ ᱡᱷᱤᱡᱽ ᱢᱮ, ᱟᱨ ᱮᱠᱥᱯᱮᱨᱤᱢᱮᱱᱴ ᱮᱦᱚᱵ ᱢᱮ ᱾ ᱟᱢᱟᱜ ᱵᱽᱨᱟᱣᱩᱡᱟᱨ ᱟᱨ ᱟᱢᱟᱜ ᱥᱤ ᱮᱥ ᱮᱥ ᱥᱟᱹᱨᱤ ᱛᱮ ᱪᱮᱫ ᱠᱚ ᱯᱩᱨᱟᱹᱣ ᱫᱟᱲᱮᱭᱟᱜᱼᱟ ᱚᱱᱟ ᱧᱮᱞ ᱠᱟᱛᱮ ᱟᱢ ᱦᱟᱦᱟᱲᱟ ᱛᱟᱦᱮᱸ ᱫᱟᱲᱮᱭᱟᱜᱼᱟᱢ ᱾

You May Also Like

13 Trending Songs on TikTok in March 2026 (+ How to Use Them)

Our Best AI PM Workflows for Prototyping, Strategy, and Personal OS (2026)

China’s Cybersecurity Agency Issues Security Warning About OpenClaw