[Question]
  [
Within the recesses of Unicode characters, there exists a Unicode block of (currently) 63 characters named "Number Forms", which consists of characters that have numerical values such as the roman numeral Ⅻ, vulgar fractions like ⅑ or ↉, or weird ones like ↊ (10) or ↈ (100000).
Your task is to write a program or function that, when given a list of assigned Unicode characters within this block, sorts the list by the numerical values of each character. 
A (sortable) list of characters and values can be found on the [Wikipedia Page](https://en.wikipedia.org/wiki/Number_Forms).
To be self contained though, here's a list of the codepoints and their values:
```
Hex     Char   Value
0x00BC: ¼   = 1/4 or 0.25
0x00BD: ½   = 1/2 or 0.5
0x00BE: ¾   = 3/4 or 0.75
0x2150: ⅐   = 1/7 or 0.142857
0x2151: ⅑   = 1/9 or 0.111111
0x2152: ⅒   = 1/10 or 0.1
0x2153: ⅓   = 1/3 or 0.333333
0x2154: ⅔   = 2/3 or 0.666667
0x2155: ⅕   = 1/5 or 0.2
0x2156: ⅖   = 2/5 or 0.4
0x2157: ⅗   = 3/5 or 0.6
0x2158: ⅘   = 4/5 or 0.8
0x2159: ⅙   = 1/6 or 0.166667
0x215A: ⅚   = 5/6 or 0.833333
0x215B: ⅛   = 1/8 or 0.125
0x215C: ⅜   = 3/8 or 0.375
0x215D: ⅝   = 5/8 or 0.625
0x215E: ⅞   = 7/8 or 0.875
0x215F: ⅟   = 1
0x2160: Ⅰ   = 1
0x2161: Ⅱ   = 2
0x2162: Ⅲ   = 3
0x2163: Ⅳ   = 4
0x2164: Ⅴ   = 5
0x2165: Ⅵ   = 6
0x2166: Ⅶ   = 7
0x2167: Ⅷ   = 8
0x2168: Ⅸ   = 9
0x2169: Ⅹ   = 10
0x216A: Ⅺ   = 11
0x216B: Ⅻ   = 12
0x216C: Ⅼ   = 50
0x216D: Ⅽ   = 100
0x216E: Ⅾ   = 500
0x216F: Ⅿ   = 1000
0x2170: ⅰ   = 1
0x2171: ⅱ   = 2
0x2172: ⅲ   = 3
0x2173: ⅳ   = 4
0x2174: ⅴ   = 5
0x2175: ⅵ   = 6
0x2176: ⅶ   = 7
0x2177: ⅷ   = 8
0x2178: ⅸ   = 9
0x2179: ⅹ   = 10
0x217A: ⅺ   = 11
0x217B: ⅻ   = 12
0x217C: ⅼ   = 50
0x217D: ⅽ   = 100
0x217E: ⅾ   = 500
0x217F: ⅿ   = 1000
0x2180: ↀ   = 1000
0x2181: ↁ   = 5000
0x2182: ↂ   = 10000
0x2183: Ↄ   = 100
0x2184: ↄ   = 100
0x2185: ↅ   = 6
0x2186: ↆ   = 50
0x2187: ↇ   = 50000
0x2188: ↈ   = 100000
0x2189: ↉   = 0
0x218A: ↊   = 10
0x218B: ↋   = 11
```
### Test cases:
```
['½','ↆ','ↂ','⅒','Ⅽ','⅑','ⅷ'] -> ['⅒','⅑','½','ⅷ','ↆ','Ⅽ','ↂ']
['¼','↋','↉','ↅ','⅐','⅟','Ⅻ','ⅺ'] -> ['↉','⅐','¼','⅟','ↅ','↋','ⅺ','Ⅻ']
['¼','½','¾','⅐','⅑','⅒','⅓','⅔','⅕','⅖','⅗','⅘','⅙','⅚','⅛','⅜','⅝','⅞','⅟'] -> ['⅒','⅑','⅛','⅐','⅙','⅕','¼','⅓','⅜','⅖','½','⅗','⅝','⅔','¾','⅘','⅚','⅞','⅟']
'⅞ⅾ↊ↄⅨⅮⅺↁⅸⅰⅩⅱⅶ¾ⅧↅↃ↋ↆ⅔ⅼⅲ⅘⅒ⅽⅦ⅕ⅤⅭⅳↂⅪⅬⅯↇⅠⅷ⅛Ⅵ½ⅵ¼ⅻ⅐Ⅱ⅜⅗⅝⅚Ⅳ⅓ⅴ↉ⅿⅫⅹↀↈ⅙⅑Ⅲ⅖⅟' -> '↉⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↄↃⅮⅾⅯⅿↀↁↂↇↈ'
['Ↄ','ↄ','↊','↋'] -> ['↊','↋','ↄ','Ↄ']
```
Note that four of the symbols (the ones used in the last case) are not unicode numbers, though they still have a numerical value, so make sure to check before just posting a built-in.
### Rules:
* If any more characters are assigned to this block in the future, you won't need to update your code to support them.
* Order of characters with identical values doesn't matter.
* [IO is flexible](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422).
	+ Output must be as the characters though, not the numerical values
* [Standard Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* I'm not banning built-ins that can fetch the numerical value of a character, but I encourage also adding a non-builtin answer if possible.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes for each languages wins! Good luck!
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~216~~ 213 bytes
-3 bytes thanks to TFeld
```
lambda l:sorted(l,key='⅒⅑⅐⅙⅕¼⅓⅖½⅗⅔¾⅘⅚⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄ⅛⅜Ⅾⅾ⅝⅞Ⅿⅿↀↁↂↇↈ'.find)
```
[Try it online!](https://tio.run/##TZJLTxpRGIb3/gp2I8mkG3cm/BJkYQNEIh0MzMZdC76nKhuRq3irWqut4qVeUARN5qe8f4TO98akbp6ZkzkzX@Z5zspquFQK5qb51MK0uPjlc3YxUZyvlMphLjtb9JdzqymP2CYaxBaxQ7SjMdEkOtGE6BKt6JXoEX3ikPhB3BBHxC1xTPwlTog74idxT5wSD3QgfhGPxBkxJM6JJ@I38Uy3SfwhRnR14oJ4IS6JMZ0jBsSErka3RuwSe8QVEY/eJw6Ia@KN7ivdN7oq3Xe6de9TvhBkk9MwVwkrqXTaiyae78XfEqtGbIsDsSEOvYwfbx1rU13cEKHHW@KheCGO/r@gAdHrh42ND1OaYktsix2xK/bEHbEv7op74r548D48o4X9fSzMfJxLxsj@3lzeSGdc4NHanJlxE1eXx5YJtTA9dZ0oRluFBpYq1mcNLs1p7NGKDmX81II/WP0XnYUjReiqQF@dmxbZbVgKq/esIOs6NQ0dh47UpWObNTldEzffXWcyM/lSOWG9EoVA18r8TGKlXAjCWVv53kLg@XndJ7VITv8B "Python 3 – Try It Online")
### With built-in that fetch the numerical value, 111 bytes
```
lambda l:sorted(l,key=lambda c:[10,11,100,100,0]['↊↋Ↄↄ'.find(c)]or numeric(c))
from unicodedata import*
```
[Try it online!](https://tio.run/##TZHJbuJgEITvPIVvhsgagXJD4knAB4JtxRqwkTEHblnofyZwCbNkX2bJMpklsySzJhDJj1IvwjQlpHDwZ7fdv6u6ut1LV@NoeRpUatNmvbXi1a1muRMnqe/lm85Tv1eZv22Uq6WiUyo5pWKRV9Gt2jADmCHMJkzffhKEkZdvFNw4saJuy0/ChlaFXJDELasbhY3Y8716WrfCVlsFlqap30k7lWrVzsa2o/8y5MaM8oL8Qo7I37braOs9m4bkFin8vE2ekp/If48HKJBNFhpHCyovyVfka3KH3CX3yH3ygDwkj8hj8mQu7rKATBhMH/IBcq1OYNYhfyDfIFeQ75Bf2QRyqd6ZnSZo1ADkHvJDFdUYZAy5UD@QM80BcqPJQD5CPkO@wjyDvNFM1AzkPNPen5kevtPxIG/VnLpXc@oY8l4nhNxqXJAHDQfyF2YN5rlOpUFA3unAjG620E1m2icH86xdNxfoUmf7ssKI9045Z7WTMErzs8qxa5HtBHwusChM/wM "Python 3 – Try It Online")
[Answer]
# [Perl 6](http://perl6.org/), 57 bytes
```
*.sort: {%(<Ↄ 100 ↄ 100 ↊ 10 ↋ 11>){$_}//.unival}
```
[Try it online!](https://tio.run/##LY3HTgJRAEV/5S1UYDMwGxdG/RWDRhIMMAbUhEwmsd1n29h7b2DvXTGZTzk/Mr6Fq7M5597hwWqpMynXTUfB9Jgk9GpBdaTLhO3pbuyU8XM5g53@57yjw4Lx/d5M2NYXZbPeaKU4li9FUVLL100hnUL7qOVcl6EmukWf2An0ju7RBXpAr3ELNbByJ24Qa9Eq@kaPaBMtox90jtbQKbpBT9hJdImu0R12Bh2iN7SDzmLnvsQu/kKL6Ajtog20h7bRCVpBz9g59Iuu0Ad2HDuLttASOkbr6CDlDQTl/ow3FBQryR8 "Perl 6 – Try It Online")
Just looks up the four exceptional characters in a hash, or falls back to the built-in `unival` method.
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~192~~ ~~74~~ ~~63~~ 61 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Σ•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
,λ₂Ï¦P(Ì•65в₂+sÇт%k
```
-118 bytes by using characters of 05AB1E's code page only, so we don't need to use UTF-8 encoding.  
-11 bytes thanks to *@Adnan*.  
-2 bytes thanks to *@Grimy*.
[Try it online](https://tio.run/##MzBNTDJM/f//3OJHDYucji480nho/@GJhxee23ZuyuGph5c9ampVOrTO/fDMR01Nh9Yd2nBs2@G1@UqHlh/efLjf5NCOpCPth6coPmpqPrwzyu3wrsMTDq85uoNL59xuoPLD/YeWBWgc7gEabGZ6YRNQRLv4cPvFJtXs//@j1Q/tVddRf9TWBiabQGTrJDC5FkxOBJPb1WMB) or [verify all test cases](https://tio.run/##TdG9TsJQFAfwnbeQxNRERvEBHDBuzhoGSRyMAwOzCRRaVEwABRHFD0DBD0AERT5UknvAxaTRV@iL1Pbfkp7ll9vT2557/ycc2QrtbBv@wJqhVfVoZWVansTEmLJU1npajvJU02XFK1qrVNRlWbRE@7tHzbBX1KlL6SXRD02SlJvT5TgNNgI0pAw1pn2PTxuZ2yktausLdGT@eNn/2zErixFK/snzu8beT4nqPmNTEp@ST9JVFcqWyjFswix8l4Iec@sHNqXgAVTwOgOv4RMcuh@ggfhiG7OsywnMwTw8hQV4BovwHF7AEryEV05zq@HsCd3UQ5hA5R62nMNZ9RjWfdiGD/AF9txD192bqnGWgMqOjmSUDju0fT2Eq9TY9W5ZuF0W@iNswGfUk1jfOANwL383C1VX3qyl3XvEAi6zkAosKjvCKgv@1Z2lMmbzG6AehftsCPboKmxQTvBOMgkWfEoK/gM).
**Explanation:**
```
Σ            # Sort the input by:
 •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
 ,λ₂Ï¦P(Ì•65в₂+
             #  List of ASCII values modulo-100 of the characters we want to sort
 sÇ          #  Get the ASCII value of the current input-character
   т%        #  Take modulo 100 of this ASCII value
 k           #  And get the index in the list of ASCII values, as sorting order
```
So what is `•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂Ï¦P(Ì•65в₂+`?
Based on the order of the characters modulo-100 we get the following list:
```
[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]
```
These are generated by the following program:
```
"↉⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄⅮⅾⅯⅿↀↁↂↇↈ"Çт%
```
[Try it online.](https://tio.run/##Dc1bUoEBGIDhvZjpvi5aEDPto/B@UjcdUFIhOtDBqUKomd8KbOHdyK9nA8/ufja3d5CmGaMsF3IuDTmTulSTpVzKrdSSlVzJnVSSX7mWG7mXprRkKG0ZyYOMpSMT6cqnPMqXgTzJtzzLVF5kJj2ZGyfSlx/jVF5lIW@yNELeZWUUjKJ8yP87kD/j0Dgy8kbJOM6sS5v8TppuAQ)
`•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ\n,λ₂Ï¦P(Ì•65в₂+` is a shorter variation of this list by taking the [compressed number](https://codegolf.stackexchange.com/a/166851/52210) `1485725021600091112740267145165274006958935956446028449609419704394607952161907963838640094709317691369972842282463`, then converting it to Base-65, and then adding 26 to each.
[Try it online](https://tio.run/##AW4Akf8wNWFiMWX//@KAokLFocSBwr/DkcOhzrbOlMOVw6bigoUiwq5Hw5nigoLCrsKwxrbDrW8iwqfDs8OPNMK4YsSHw5Qh4oKDw7laRsO6w5DDrMW4CizOu@KCgsOPwqZQKMOM4oCiNjXQsuKCgiv//w) and [verify that the lists are the same](https://tio.run/##DY07TkJRAAV7duFLTEy00ERcgIW22tpJYu0W5OG5@EsABRX/oIIfQARFvpLcC5ZEtzAbeb52MpmZj27GFraCwMPso2OUQZcojfIoZ/voBF2hUztAZ@gaZe03OkcX6AbdojtURwX0joqoge5REz2gD/SIPjFCJdRCZfSFnlAbPaMO5gC9oC7mEL2iHqqgPsagKhpgEphdVEPh9w0NMTuYOMbHJDF7nkv@@dMRdorL48Iobocu4wqT1iTrcq6EL8/WVl0e37c1W/9pueq2Z8uu6VKLth0bJV12Cj/hOhsrruvSrjJuR@YmvVB3KVtam3FHYXgp@tsIyWxkPQj@AQ).
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~1~~93 bytes (UTF-8)
```
2{O`.
T`¼-¾⅐-↋\LI ^]Q@TU\\[ZYWSPNK\HFDB?=;975X\VR\OMJG\ECA><:86432\-)#1%0,*&.(!"$/+'`Ro
```
[Try it online!](https://tio.run/##HdBLMkNRFIXhvrlQxURUKQO4Gho6KKWnQ1ibSEckJOIRIS@CxCMJQlTdofwTuc4@Azhnff/eWt1eW1@Zz7KFncVkbmY5wY6wQyw3i/5QH03RC7aPHaBf9IwZ@kFPaIJ6WAF9o0fsGH2hB/SJumiMOmiE2pjQELXQB2qid3SP3tAdekUNNEC3qI5uUA1V0zBbRteokobVc3SFSmnYPUMX6ARdoiI6xfKbydJGlsW3U2c4tevsALO96BlEWNga@c8dF3lTIdaUY1DgVP0/r2zHnabnBqzlvM@L@34cl47jfsttQ1dNIqkRmZXorsXGkidbPh6z5/exXT@xJxRjfiir/wM "Retina – Try It Online") Explanation: Sorts the characters in code point order, then maps between the numeric characters and ASCII characters so that the numeric characters with the lowest value map the the ASCII characters with the lowest code point and vice versa. Then repeats the exercise, so that the characters are now sorted in order of this ASCII mapping, which corresponds to the desired numeric order, before they are transformed back. Edit: Saved 100 (!) bytes by specifying the order of the ASCII characters rather than the numeric characters.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 55 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
O%70‘“$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’Œ?¤iµÞ
```
A monadic link accepting a list of characters which yields a list of characters.
**[Try it online!](https://tio.run/##DcvLLgNxAEbxV5HQjZUgESsbS4md2FpYoPYIyQy@f0sjoW4tbVW16lb30plpK5mms@hbzHmRMevzO6vLyeRmFM0npsawcliFkb63NRo6VtiqzGI7C6FTWRqUg@JQMnSdtaA4yExjd4LG4nq/PTmM7U706ont0DuK4dxGkI7jTq8UpMax8v3sjF9d8Zu9UhRFqIS6mEPMPnpAr8jF2KiF3tEj@kA/fhfVMcLsYTIYg85QG32iHMqiDrpH56iKGugLs4ue0At6w6RQGf2ia1TzY9v049lDx@gWFdAlKqIrdIdO0TfmAP2hZ@RgLEwa5dEJqqALdPMP "Jelly – Try It Online")**
### How?
Much simpler than it looks since `“$Żz*ṀḢD⁹VṢaʠƝ lẹkƝʋ9⁽ƭXmż4#⁺3ç%|ọṢLxƈ⁽}ÞƇ2’` is just a large number in base 250 using Jelly's code-page as the digits, I shall use `“...’` in its place.
```
O%70‘“...’Œ?¤iµÞ - Link: list of characters
               Þ - sort by:
              µ  -   the monadic function (i.e. f(character)):
O                -     get the ordinal value of the character
 %70             -     modulo by 70 (get the remainder after dividing by 70)
                 -       - giving integers in [0,69] excluding [52,58]
    ‘            -     increment (below code pattern can't have anything but '↉' map to 0)
            ¤    -     nilad followed by link(s) as a nilad:
     “...’       -       literal 7826363328008670802853323905140295872014816612737076282224746687856347808481112431487214423845098801
          Œ?     -       get the permutation of natural numbers [1,N] with minimal N such
                 -         that this permutation would reside at the given index in a
                 -         sorted list of all permutations of those same numbers
                 -         -> [46,52,53,54,55,56,57,58,61,60,70,59,68,64,49,62,1,65,50,66,2,63,51,67,69,3,4,5,21,6,22,7,23,8,24,9,25,10,26,42,11,27,12,28,13,29,14,30,47,15,31,48,16,32,17,33,43,18,34,40,41,19,35,20,36,37,38,39,44,45]
             i   -     first index of (the ordinal mod 70 plus 1) in that list
```
---
### Aside
Somewhat ironically the nearest to a "use a built-in approach" I could muster was [85 bytes](https://tio.run/##FY45ToJRGEV79@ECjAuws9DCzlhZOURC7O144n04JA44TyCI4oATAv4DaPKIJi7jnY3gs7n5cr/knpOZz2ZXBgNyF6627KOyT2JMB9P2yfaoj/KuvoL5wCTfRR81w9dVfNryyfrYrI9Kv10fN3xsf48xvf7r@ISr/xTC6ZOij6s@3ZoZd9WRyZ8mpuujjk92eHte8PHRokvDTIbcJSb6Lk6HHJoaxsRBBJO6d0wrQMmdLIWVf7ue@5qbc5XQuGAY9Quu5uIx1@6XBkHfbmHz2DXsJnYdW8CuYg02h77QC/pEz6iHnrAWdVEDpegRJegBxegeRegOfaA66qBbrFAb3aAWqqF3dI2aqIreUAW9oitURiV0hk5cQB2gS3TsAu8IXaB9F4iH6BTtonO0h4rYjT8 "Jelly – Try It Online"), this uses a compressed string:
```
from unicodedata import*; copy_to( atoms['
'], numeric( atoms['
'].call()))
```
which is split on newlines and joined with `⁸`s to give the Python code:
```
from unicodedata import*; copy_to( atoms['⁸'], numeric( atoms['⁸'].call()))
```
which is executable within Jelly's interpreter - it will place the Unicode character's numeric value into the left argument nilad, `⁸` for later use.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 72 bytes
```
ñ@`'%!x("y#) z$&*+,<-=.>/?0@1aq2b3c4d5ev6fw7g8hr9iop:j;klmn¡`u bXcuL
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=8UBgHh0nHCUheB8oInkjKSB6JCYqKyw8LT0uPi8/MEAxYXEyYjNjNGQ1ZXY2Znc3Zzhocjlpb3A6ajtrbG1uoWB1IGJYY3VM&input=WyK9IiwiXHUyMTg2IiwiXHUyMTgyIiwiXHUyMTUyIiwiXHUyMTZkIiwiXHUyMTUxIiwiXHUyMTc3Il0=) or [run all test cases](https://ethproductions.github.io/japt/?v=1.4.5&code=8UBgHh0nHCUheB8oInkjKSB6JCYqKyw8LT0uPi8/MEAxYXEyYjNjNGQ1ZXY2Znc3Zzhocjlpb3A6ajtrbG1uoWB1IGJYY3VM&input=WwpbIr0iLCJcdTIxODYiLCJcdTIxODIiLCJcdTIxNTIiLCJcdTIxNmQiLCJcdTIxNTEiLCJcdTIxNzciXQpbIrwiLCJcdTIxOGIiLCJcdTIxODkiLCJcdTIxODUiLCJcdTIxNTAiLCJcdTIxNWYiLCJcdTIxNmIiLCJcdTIxN2EiXQpbIrwiLCK9IiwiviIsIlx1MjE1MCIsIlx1MjE1MSIsIlx1MjE1MiIsIlx1MjE1MyIsIlx1MjE1NCIsIlx1MjE1NSIsIlx1MjE1NiIsIlx1MjE1NyIsIlx1MjE1OCIsIlx1MjE1OSIsIlx1MjE1YSIsIlx1MjE1YiIsIlx1MjE1YyIsIlx1MjE1ZCIsIlx1MjE1ZSIsIlx1MjE1ZiJdClsiXHUyMTVlIiwiXHUyMTdlIiwiXHUyMThhIiwiXHUyMTg0IiwiXHUyMTY4IiwiXHUyMTZlIiwiXHUyMTdhIiwiXHUyMTgxIiwiXHUyMTc4IiwiXHUyMTcwIiwiXHUyMTY5IiwiXHUyMTcxIiwiXHUyMTc2IiwiviIsIlx1MjE2NyIsIlx1MjE4NSIsIlx1MjE4MyIsIlx1MjE4YiIsIlx1MjE4NiIsIlx1MjE1NCIsIlx1MjE3YyIsIlx1MjE3MiIsIlx1MjE1OCIsIlx1MjE1MiIsIlx1MjE3ZCIsIlx1MjE2NiIsIlx1MjE1NSIsIlx1MjE2NCIsIlx1MjE2ZCIsIlx1MjE3MyIsIlx1MjE4MiIsIlx1MjE2YSIsIlx1MjE2YyIsIlx1MjE2ZiIsIlx1MjE4NyIsIlx1MjE2MCIsIlx1MjE3NyIsIlx1MjE1YiIsIlx1MjE2NSIsIr0iLCJcdTIxNzUiLCK8IiwiXHUyMTdiIiwiXHUyMTUwIiwiXHUyMTYxIiwiXHUyMTVjIiwiXHUyMTU3IiwiXHUyMTVkIiwiXHUyMTVhIiwiXHUyMTYzIiwiXHUyMTUzIiwiXHUyMTc0IiwiXHUyMTg5IiwiXHUyMTdmIiwiXHUyMTZiIiwiXHUyMTc5IiwiXHUyMTgwIiwiXHUyMTg4IiwiXHUyMTU5IiwiXHUyMTUxIiwiXHUyMTYyIiwiXHUyMTU2IiwiXHUyMTVmIl0KWyJcdTIxODMiLCJcdTIxODQiLCJcdTIxOGEiLCJcdTIxOGIiXQpdLW1S)
---
## Explanation
```
ñ@                 :Sort by passing each X through a function
  `...`            :  A compressed string, which itself contains a bunch of unprintables (See below for codepoints of original string)
       u           :  Uppercase
         b         :  Index of
          Xc       :   Charcode of X
            uL     :   Mod 100 and get character at that codepoint
```
### Codepoints
```
30,29,39,28,37,33,120,31,40,34,121,35,41,32,122,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,97,113,50,98,51,99,52,100,53,101,118,54,102,119,55,103,56,104,114,57,105,111,112,58,106,59,107,108,109,110,115,116
```
---
## Original Solution, ~~90~~ ~~89~~ 88 bytes
```
ñ!b`(&" )#$*!%'+,-=.>/?0@1a2br3c4d5e6fw7gx8h9:jpq;k<lmÍ/`®iv u nLõd)dÃi6'¼ iA'½ iE'¾
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8SFiYB8eKB0mIiApIyQqISUnKywtPS4+Lz8wQDFhMmJyM2M0ZDVlNmZ3N2d4OGg5iTpqcHE7azxsbc0vYK5pdiB1IG5M9WQpZMNpNie8IGlBJ70gaUUnvg==&input=WyK9IiwiXHUyMTg2IiwiXHUyMTgyIiwiXHUyMTUyIiwiXHUyMTZkIiwiXHUyMTUxIiwiXHUyMTc3Il0=) or [run all test cases](https://ethproductions.github.io/japt/?v=1.4.6&code=8SFiYB8eKB0mIiApIyQqISUnKywtPS4+Lz8wQDFhMmJyM2M0ZDVlNmZ3N2d4OGg5iTpqcHE7azxsbc0vYK5pdiB1IG5M9WQpZMNpNie8IGlBJ70gaUUnvg==&input=WwpbIr0iLCJcdTIxODYiLCJcdTIxODIiLCJcdTIxNTIiLCJcdTIxNmQiLCJcdTIxNTEiLCJcdTIxNzciXQpbIrwiLCJcdTIxOGIiLCJcdTIxODkiLCJcdTIxODUiLCJcdTIxNTAiLCJcdTIxNWYiLCJcdTIxNmIiLCJcdTIxN2EiXQpbIrwiLCK9IiwiviIsIlx1MjE1MCIsIlx1MjE1MSIsIlx1MjE1MiIsIlx1MjE1MyIsIlx1MjE1NCIsIlx1MjE1NSIsIlx1MjE1NiIsIlx1MjE1NyIsIlx1MjE1OCIsIlx1MjE1OSIsIlx1MjE1YSIsIlx1MjE1YiIsIlx1MjE1YyIsIlx1MjE1ZCIsIlx1MjE1ZSIsIlx1MjE1ZiJdClsiXHUyMTVlIiwiXHUyMTdlIiwiXHUyMThhIiwiXHUyMTg0IiwiXHUyMTY4IiwiXHUyMTZlIiwiXHUyMTdhIiwiXHUyMTgxIiwiXHUyMTc4IiwiXHUyMTcwIiwiXHUyMTY5IiwiXHUyMTcxIiwiXHUyMTc2IiwiviIsIlx1MjE2NyIsIlx1MjE4NSIsIlx1MjE4MyIsIlx1MjE4YiIsIlx1MjE4NiIsIlx1MjE1NCIsIlx1MjE3YyIsIlx1MjE3MiIsIlx1MjE1OCIsIlx1MjE1MiIsIlx1MjE3ZCIsIlx1MjE2NiIsIlx1MjE1NSIsIlx1MjE2NCIsIlx1MjE2ZCIsIlx1MjE3MyIsIlx1MjE4MiIsIlx1MjE2YSIsIlx1MjE2YyIsIlx1MjE2ZiIsIlx1MjE4NyIsIlx1MjE2MCIsIlx1MjE3NyIsIlx1MjE1YiIsIlx1MjE2NSIsIr0iLCJcdTIxNzUiLCK8IiwiXHUyMTdiIiwiXHUyMTUwIiwiXHUyMTYxIiwiXHUyMTVjIiwiXHUyMTU3IiwiXHUyMTVkIiwiXHUyMTVhIiwiXHUyMTYzIiwiXHUyMTUzIiwiXHUyMTc0IiwiXHUyMTg5IiwiXHUyMTdmIiwiXHUyMTZiIiwiXHUyMTc5IiwiXHUyMTgwIiwiXHUyMTg4IiwiXHUyMTU5IiwiXHUyMTUxIiwiXHUyMTYyIiwiXHUyMTU2IiwiXHUyMTVmIl0KWyJcdTIxODMiLCJcdTIxODQiLCJcdTIxOGEiLCJcdTIxOGIiXQpdLW1S)
---
### Explanation
```
   `...`                                :A compressed string, which itself contains a bunch of unprintables (See below for codepoints of original string)
        ®                               :Map
         iv                             :  Prepend "v"
            u                           :  Convert to uppercase
               Lõ                       :  Range [1,100]
                 d                      :  Characters at those codepoints
              n   )                     :  Convert from that base to base-10
                   d                    :  Get the character at that codepoint
                    Ã                   :End map
                     i6'¼               :Insert "¼" at (0-based) index 6
                          iA'½          :Insert "½" at index 10
                               iE'¾     :Insert "¾" at index 14
ñ                                       :Sort the input array
 !b                                     :  By finding the index of the current element in the string above
```
**Codepoints**
```
31,30,40,29,38,34,32,41,35,36,42,33,37,39,43,44,45,61,46,62,47,63,48,64,49,97,50,98,114,51,99,52,100,53,101,54,102,119,55,103,120,56,104,57,105,115,58,106,112,113,59,107,60,108,109,110,111,116,117
```
[Answer]
# 05AB1E, ~~56~~ ~~53~~ ~~51~~ ~~50~~ ~~49~~ 48 bytes
```
ΣÇ©1ö•Ω‘~Èr–Õî5®Î¼ÓÂ∍_OûR•42в•мjāl†£•₂°*S>ÅΓ®Íè+
```
[Try it online!](https://tio.run/##DYvLLgNhHEffhxVh6xUkPICQWBCJhL1Mh9@/RSoYpe7VcWldRhV16ajk@6ybPsN5kTGrk5Ocs7w6O7cwn2X92Bddc8R3COr9JkF1zZdWCCJf8cm4S/yOS33kQ0rlmUnfncqrsdFBO8cgXfwrLBHUXJwbYehaQ9MTXv0ov8q@MZxl6AL1sC1sAzVQgr6xAvpELdREL6jjeugOE7aObWOGDlCK2qiK9tEPukUVdI2e0CsWonv0iJ6xIqqhD3SKblzevrt87qJddIXO0BE6RycoRhF6wzbRL3pAX1iAldAx2kN1dIgu/wE "05AB1E – Try It Online")
At the core of this solution is a compressed list mapping unicode code points to a sorting key. Characters that correspond to the same number are mapped to the same key, so we only need 40 different keys.
70 is the smallest number by which we can modulo all input codepoints and get distinct results. Since indexing in 05AB1E wraps around, we don’t need to explicitly `70%`, just make sure the list is length 70.
Notice that there are long stretches of consecutive code points with consecutive keys. Thus, encoding (key - codepoint) rather than simply (key) gives long stretches of identical numbers, which can be run-length encoded. However, the range of code points is very large (damn those 0xBC .. 0xBE), which would be an issue. So instead of (key - codepoint), we encode (key - sum\_of\_digits(codepoint)), which unfortunately limits the stretch length to 10, but does quite well at reducing the range of encoded values. (Other functions are of course possible, like codepoint % constant, but sum of digits gives the best results).
Additionally, it turns out rotating the list by 2 plays well with run-length encoding, so we subtract 2 from the codepoint before indexing.
```
•Ω‘~Èr–Õî5®Î¼ÓÂ∍_OûR•42в    # compressed list [25, 34, 27, 36, 30, 38, 29, 35, 41, 0, 28, 16, 19, 31, 7, 4, 11, 17, 22, 13, 16, 17, 20, 8, 19, 4, 18, 21]
•мjāl†£•                    # compressed integer 79980000101007
        ₂°*                 # times 10**26
           S                # split to a list of digits
            >               # add 1 to each
             ÅΓ             # run-length decode, using the first list as elements and the second list as lengths
Σ                           # sort by
 Ç©1ö                       # sum of digits of the codepoint
           +                # plus
     ...  è                 # the element of the run-length decoded list
        ®Í                  # with index (codepoint - 2) % 70
```
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 117 bytes
```
a=>a.sort((a,b)=>(g=c=>';<=>GHIJCDEF?@AB/37~15:;8-9+6.24,*)0N(DEH@GMJKLH'[(c.charCodeAt()&127^44)%92%76%60])(a)>g(b))
```
[Try it online!](https://tio.run/##jZFbTxpRFIXf/RV9wTmn4ggUoV5migUKausfMDYZR6QoZQhDTHwxXrrH24tardqbt17UtrZqrwo0mZ@y/whud3wgISG@fE9nrbPXWmPGhGGbhUy@2GrnMyOpwnMrN56arI5qVUPTDdW2CkUhDO@w1HSR1kxNV7q6NT2R7O2LxuKPHkR6HrbdC0/52zu77rd2tITUQNB7V/oGRCyejCSe9PU/TiqDwlTNZ0Yhao2keopCNvsD4afBoPR0BDzhkCfkG5LCkHpaDEtZNa2cbWVTatZKi1ExqLhlxaug4zBnrwlrzG/MVeYfZUiqY1YmJ5Q7ipRNdSYlli8zF5nAwhXmDvML8@I2VnyUW6mxWK257CVznbnBfMXcZG4xt5mvmW@Yb5nvmO9vzmp8CjpzHOUFc@kmYkONqqrX9ggVEpAS4RDhhFKjM4PwF@EHwhHCKcJvt4LwmXqiX8iWFqBICCWEM8pAURHKCJ8oIcIHWgPhnPZBOEb4ivAdnXmEXVqG4iF8dOntL5fEl1QYwh7FpT4oLnWAcECdIfykaRD@0xAI/9CZRmeBeqJqEfapwro@qlc "JavaScript (SpiderMonkey) – Try It Online")
[Answer]
# T-SQL, 207 bytes
```
SELECT*FROM t ORDER BY
CHARINDEX(c,N'⅒⅑⅛⅐⅙⅕¼⅓⅜⅖½⅗⅝⅔¾⅘⅚⅞⅟ⅠⅰⅡⅱⅢⅲⅣⅳⅤⅴⅥ
              ⅵↅⅦⅶⅧⅷⅨⅸⅩⅹ↊Ⅺⅺ↋ⅫⅻⅬⅼↆⅭⅽↃↄⅮⅾⅯⅿↀↁↂↇↈ'COLLATE Thai_BIN)
```
Return in the middle of the string is for readability only. I think I got the byte count correct (3 of the numeric characters are 1-byte, the remainder are 2-bytes), character count is 148.
I pre-sorted the string in ascending order, leaving out `↉` (which returns 0) as suggested by other answers.
Any binary collation will work, I used `Thai_BIN` since it has the shortest name. (A collation in SQL prescribes how character sorting/comparison is done, I need binary so each character only matches itself.)
[Per our IO standards](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341), input is taken via pre-existing table **t** with `NCHAR(1)` field **c**.
If you define the input table itself using a binary collation, you can leave that out to save 16 bytes:
```
CREATE TABLE t(c NCHAR(1) COLLATE Thai_BIN)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 77 bytes
Changes all the characters to letters that represent the numerical values and sorts by that.
```
->a{a.sort_by{|e|e.tr'¼-¾⅐-↋','HLPECBIOGKMQFRDJNSaa-pa-ppqrnnfmstAjk'}}
```
[Try it online!](https://tio.run/##TZDXagJhEIXvfQovAnuT9Q0SSO/90oisQUlVs5qAqJDi/En0RtN7771XNbCPch4km3EQElg@WP4Z5jvHnPDF7EBVv61XG3HDFQmZUa8vFk/4E35X1NSsvG4VQVkdKqNVas3t3Q11tS1dTW0dPY299a2dfYahh/kLj5vBYGAsEq0ZHtGSSTvsDLj9k8aos8Lrsd2aVeBlKCWcKZEWhTfCnPBN8zh4NC9DGeGCkOQ5K9wTXgk//xbkgFX8N5j7d2VJuCxcEa4K14Trwg3hpnBLuC3cEe6Wj3scpR9QESoNlQKdg27ZBGoa9A66B12AHkCvpdrO2B1qltNwdhYA5UGPfJHFQAXQKfuAjrkH0BM3A7oEXYPuoOZA@9wJy4BOLJ59sXj5i@OBDliO7VmOjUFHnBD0zHWBvrkc0AfUFNQ8p@IiQIccuGTvGhg0zAh3xlLSbEqYLjfu@QmFo0OhYMTWg78 "Ruby – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~13~~ 52 bytes
```
*.sort:{%(<Ↄ 99 ↄ 99 ↊ 10 ↋ 11>){$_}//.EVAL}
```
[Try it online!](https://tio.run/##K0gtyjH7n1uplmb7X0uvOL@oxKpaVcPmUVuzgqWlwqO2FgjVpWBoAKS6FQwN7TSrVeJr9fX1XMMcfWr/W3MVJ1YqpCloqB/aq66j/qitDUw2gcjWSWByLZicCCa3q2ta/wcA "Perl 6 – Try It Online")
]