[Question]
  [
Given a list of two or more spelled-out serial numbers of equal length greater than two, e.g.
```
[[ "three" , "one"  , "four"  ],
 [ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "five" , "eight" ]]
```
sort the list by the numbers that the words represent:
```
[[ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "one"  , "four"  ],
 [ "three" , "five" , "eight" ]]
```
You may require the numbers to be spelled in lower or upper, but not mixed, case.
### Test cases
`[["three","one","four"],["one","five","nine"],["two","six","five"],["three","five","eight"]]`  
gives  
`[["one","five","nine"],["two","six","five"],["three","one","four"],["three","five","eight"]]`
`[["two","seven"],["one","eight"],["two","eight"],["one","eight"],["two","eight"],["four","five"]]`  
gives  
`[["one","eight"],["one","eight"],["two","seven"],["two","eight"],["two","eight"],["four","five"]]`
`[["one","four","one","four","two"],["one","three","five","six","two"],["three","seven","three","zero","nine"]]`  
gives  
`[["one","three","five","six","two"],["one","four","one","four","two"],["three","seven","three","zero","nine"]]`
`[["zero","six","one"],["eight","zero","three"],["three","nine","eight"],["eight","seven","four"],["nine","eight","nine"],["four","eight","four"]]`  
gives  
`[["zero","six","one"],["three","nine","eight"],["four","eight","four"],["eight","zero","three"],["eight","seven","four"],["nine","eight","nine"]]`
  
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~9~~ 8 bytes
```
Ö†€¨tfṡn
```
[Try it online!](https://tio.run/##yygtzv7///C0Rw0LHjWtObSiJO3hzoV5////j45WysvMS1WK1YlWSs1MzygBs4pTy1LzIKzMCjCdllkGUZSWX1oEZpRkFKVChErK88F0PsicWAA "Husk – Try It Online")
Algorithm "inspired" by [recursive's Stax answer](https://codegolf.stackexchange.com/a/161676/62393) (I've just changed the lookup string a bit), go upvote him!
The trick is mapping each letter to its position in the string `tfsen` (compressed at the end of this program). Husks lists are 1-based, and missing items return 0, so we get this mapping:
```
"one"        [0,5,4]
"two"        [1,0,0]
"three"      [1,0,0,4,4]
"four"       [2,0,0,0]
"five"       [2,0,0,4]
"six"        [3,0,0]
"seven"      [3,4,0,4,5]
"eight"      [4,0,0,0,1]
"nine"       [5,0,5,4]
```
As you can see, the lists are perfectly ordered.
---
In order to be clear, here's how list comparison works in Husk (and in many other languages): 
1. If one of the two lists is empty, that's the smaller one.
2. If the first elements of the two lists are different, the one with the smaller first element is the smaller list.
3. Otherwise, discard the first element from both lists and go back to point 1.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~24~~ ~~22~~ ~~17~~ ~~16~~ 14 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
▄Ωφ▐╧Kìg▄↕ñ▼!█
```
[Run and debug it](https://staxlang.xyz/#p=dceaeddecf4b8d67dc12a41f21db&i=[[%22three%22,%22one%22,%22four%22],[%22one%22,%22five%22,%22nine%22],[%22two%22,%22six%22,%22five%22],[%22three%22,%22five%22,%22eight%22]]%0A[[%22two%22,%22seven%22],[%22one%22,%22eight%22],[%22two%22,%22eight%22],[%22one%22,%22eight%22],[%22two%22,%22eight%22],[%22four%22,%22five%22]]%0A[[%22one%22,%22four%22,%22one%22,%22four%22,%22two%22],[%22one%22,%22three%22,%22five%22,%22six%22,%22two%22],[%22three%22,%22seven%22,%22three%22,%22zero%22,%22nine%22]]%0A[[%22zero%22,%22six%22,%22one%22],[%22eight%22,%22zero%22,%22three%22],[%22three%22,%22nine%22,%22eight%22],[%22eight%22,%22seven%22,%22four%22],[%22nine%22,%22eight%22,%22nine%22],[%22four%22,%22eight%22,%22four%22]]&a=1&m=2)
This program takes arrays of lowercase spelled digits for input. The output is newline-separated like so.
```
one five nine
two six five
three one four
three five eight
```
This program sorts the inputs using the ordering obtained under a specific transformation. Each character in each word is replaced by its index in the string `"wo thif sen"`. The original arrays are sorted by this ordering. Then the results are printed after joining with a space.
The spaces serve no purpose, but actually allow greater compression in the string literal.
[Answer]
# [Python](https://docs.python.org/3/), 62 bytes
```
lambda m:sorted(m,key=lambda r:[int(s,36)%6779%531for s in r])
```
**[Try it online!](https://tio.run/##TYzLCsMgEEV/ZRACCm6KNKGBfIl1kRKt0kbDaB/5eps3Xc3lnHtnGJMNXmTTXPOz7W9dC30dAybd0Z4/9NhsFGvpfKKRi5IVZVVdirM4mYAQwXlAxfKAc8FQKYEki1oT4ECCn@4cTHjhlBQHudMFu/da9G5hq0@fsPnovuSvuPvj/7HX7m4TAaUYyz8 "Python 3 – Try It Online")** ...or see the [test-suite](https://tio.run/##hVBJbsMgFN33FAgpipHYVFYT1VJOQli4yneMGoMFxG16eZfZpJtuQG/47w/zw45KtutwOq@3fvq49GjqjNIWLs1EP@FxSqzumJC2MbQ9kN3heHzfvbWvg9LIICGR5mT1wIKxHsPS3xoh57ttCOle0Kx9sVdJBvurWMDsCx6iXDBZGWPYjhoAU6ykfwd115hTlqFLcJ8UDnnWfikHjfjOWiBTQjKDuI4Wc6cUPywgq9TkKHkb/k8P4@XWoUM1Nn0GvnbL/DNkXCFbshgH3cw/oFVZP7RLTCxX6SpxvmKP1XVuCKj3yBW5YTn7k7M6fNop89HP@S8 "Python 3 – Try It Online")
Note: 
```
lambda m:sorted(m,key=lambda r:[map("trfsen".find,s)for s in r])
```
which works in Python 2 (but not 3) is longer by two bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
OḌ%⁽Ð¢%147µÞ
```
A monadic link.
**[Try it online!](https://tio.run/##y0rNyan8/9//4Y4e1UeNew9POLRI1dDE/NDWw/P@H273ftS0JvL//@hoBaWSjKLUVCUFHQWl/DwgDWKk5ZcWAVmxOlwK0TBhsHhmGURlXiZYDKqgpDwfqqA4s0IJSSVcAdwKuAmpmekZJUoKsbEA "Jelly – Try It Online")** ...or see the [test-suite](https://tio.run/##jZC/DoIwEMZ3n6JpwtbFxMSHcHA2DWMViIEEEP9suLA4@AQOzq4aFx3gSeRFKr3roXVyanv3@77vrpFaLrdaT1/3g9eWj@ZYn73haFxfm5Nuqkm7v8wGTdUdUVs@61t901pKyXgepEpxJhhP4u40l3mySrubLwaMSapDIywQjUOoEZGvE0tk4YZ/oR@iT@k9VLgIcs58g0gJHoJnqlAxRxUEC8vZElJO6T8KdhKYTpGotB3nYQwce5zf6gWs6VDUx/k//E6lZhT4L4q1NfQw9tYD5@01aPHjD0Y/q5GOsmEH23N4msP5EWqhyvff "Jelly – Try It Online")
### How?
Converting the digits to ordinals and then from base 10 then taking modulos by 4752 then 147 gives an ascending order: 
```
 zero            , one         , two         , three               , four
[122,101,114,111],[111,110,101],[116,119,111],[116,104,114,101,101],[102,111,117,114]
 133351          , 12301       , 12901       , 1276511             , 114384
 295             , 2797        , 3397        , 2975                , 336
 1               , 4           , 16          , 35                  , 42
 five            , six         , seven               , eight               , nine
[102,105,118,101],[115,105,120],[115,101,118,101,110],[101,105,103,104,116],[110,105,110,101]
 113781          , 12670       , 1263920             , 1126456             , 121701
 4485            , 3166        , 4640                , 232                 , 2901
 75              , 79          , 83                  , 85                  , 108
```
This can then be used as a key function by which to sort:
```
OḌ%⁽Ð¢%147µÞ - Link: list of lists of lists of characters
          µÞ - sort (Þ) by the mondadic chain to the left (µ):
O            -   ordinals of the characters
 Ḍ           -   convert from base 10
   ⁽Ð¢       -   literal 4752
  %          -   modulo
      %147   -   modulo by 147
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 12 bytes
```
'nesft'∘⍒⌷¨⊂
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob2pm/qO2CQb/04Ckel5qcVqJ@qOOGY96Jz3q2X5oxaOupv//H7VNBMpOBCIN9ZKMotRUdQX1/DwQmZZfWqSuqQHjZZaBqLxMIA8oWFKeD@QVZ1bApDQR2qFKUzPTM0rUNblsuVDsgGhMLUvNQxgOVQqThXPxy4IdCLMezRokLyigckCGwI1GczLEP1AVMDmIWxFqq1KL8uEhgWYtVA5iTj4kqCDuheuDGINkPtggJG/B1MPshcUDijpETEC9BROGqAYA "APL (Dyalog Classic) – Try It Online")
This is how I found a suitable left argument for dyadic `⍒` (I tried `⍋` and length 6 first):
```
A←⊖a←↑'zero' 'one' 'two' 'three' 'four' 'five' 'six' 'seven' 'eight' 'nine'
{(a≡a[⍵⍒a;])∧A≡a[⍵⍒A;]:⎕←⍵}¨,⊃∘.,/5⍴⊂∪∊a
```
[Answer]
# Ruby, 48 bytes
```
->x{x.sort_by{|y|y.map{|s|s.to_i(35)**2%47394}}}
```
Abuses the fact that `"zero".to_i(35)` is 0 (since 'z' isn't a valid digit in base 35), so it's that much easier to brute-force a formula for the other nine digits.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 47 bytes
```
->x{x.sort_by{|y|y.map{|s|s.to_i(32)%774%538}}}
```
**[Try it online!](https://tio.run/##TY7RCoMgFIbvfYqDEGzQulgb7aa9iEgsyOVFGmqboj67q9ZiV@fn4@P/j5pal1idTnfrbaGlMk3rfHDBFcNj9EEHXRjZ8EN5PmZVdcmu5S3GmMQ0aKiBEMCmV12HIQcsxXyXwOSk5kRzBOSHV85fX1PwlW2CectN0NziP3MX9om9oePP3mCgFKERGFn@oekD "Ruby – Try It Online")**
Utilises the fact that using a base less than the maximum digit yields a result of zero (as pointed out by histocrat in [their answer](https://codegolf.stackexchange.com/a/161697/53748))
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), ~~14~~ 18 bytes
```
{x@<"tfsen"?/:/:x}
```
[Try it online!](https://tio.run/##jVFLDoMgEN17CjMrWTTusUl7GVDSBBKl1rTp2RGcGYSuutHw5v0GHhc72hC0/Gz3K3i9KAu3XvZy@wbddeCnWSkYwNn01e45g2jatmPArOlnTTwh7l8uAovZeEow@ZBAmXHyIERzZKBErTG7NCdSYVsi/3COvtwDw4pFhvqQ5KX1T2Vc6STxGHuf9LeaXb4SzCQIHVy@KmyaFWhQmx8u9U6s4tziTSp29Sq0Ik9QI8IO "K (ngn/k) – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), 37 bytes
```
*.sort:{('digit 'X~$_)».parse-names}
```
[Try it](https://tio.run/##nVRLboMwEN1zihGqmtBCKnWRRaJUHKDLLiohVEVhklgiGNmGJo3Si3XXi1GDbX5KQtuN0fzeezN4nCKLp0XGEfLpZDW3rN0Bblc0QlgUdxNOmZgdx6OIbIiA0evnzZvz/TVJl4yjlyx3yE@FLPAFcgELGFsAQWCLLUO0XZsm5bmmGbNDNzAmyctPQqRVesU7lSYnexOrnBpBJyPZbIUdhq7C/wdQT8pFfN2AgsIck5ZynVVTNfZQvOI1qrpdDIE0IvqgQySdWalYxyjrG97eRNQYTYoJKjFN8gcyWv@Cbl9X8YZF/ZZRUWqvIqH6PqjJ1CUKoY1dgbQnaCoMaX1dOpmtK6dFG7/KN3M4K@oi91moa138TawU5cjlLvf8Re7q3ErjZQL3anEf4FHG1pTpRfaewCdJmgkXfNynuBIYwVF2RbgXIabxAcoXYqyS5HvwTLioDqdV0fbPrVPxAw "Perl 6 – Try It Online")
## Expanded:
```
*\     # WhateverCode lambda (this is the parameter)
.sort:
{  # block with implicit parameter ｢$_｣
  (
    'digit ' X~ $_  # concatenate 'digit ' to each named digit
  )».parse-names    # call .parse-names on each
}
```
The code block will take a value of the form `("three","one","four")` and translate it to `("3","1","4")` which is a value that `.sort` can easily use.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 38 bytes
```
{⍵[⍋(531∘⊥⍤1)(531|6779|36⊥9+⎕A⍳⊢)¨↑⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR71box/1dmuYGhs@6pjxqGvpo94lhpogbo2ZublljbEZUMxS@1HfVMdHvZsfdS3SPLTiUdtEoLbY2v//gaw0BQ31EI8gV1d1BXV/PxDp5h8apK4JFIZyPcNAlJ8nkAcSDQn3B3KDPSNgcppIJkAVu3q6e4Soa3Kp26pzweyAaHMNc/VDMhyqEC6P4BOSB7sS5gJki5A8oYDKARmBMBrNyRAPwZTAJCHuRSiOcg3yhwcGsq1QCYgp/tCggrgWrgtiCLLxYHOQfQXTAbMXHhcoKpFiA@o1mDhEPQA)
Based of Jonathan Allan's [awesome solution](https://codegolf.stackexchange.com/a/161684/65326).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~85~~ ~~81~~ 80 bytes
Simply uses the first two letters of each word to determine the number, then sorts each list using that indexing function as the key.
```
lambda _:sorted(_,key=lambda L:['zeontwthfofisiseeini'.find(s[:2])/2for s in L])
```
[**Try it online!**](https://tio.run/##hVHLboMwEDyXr7C4BCTUqhyRckxPkfoBrhXRsi6rpDayNyHk5ylgm0cvvdja2ZnZWbvpqNYq7@X@o7@UP59VyU6F1YagSk7ZGbq9R48F3z1AK2qpllqiRQuACnfPElWVWF7kIn3JpTbMMlTsKNKeTFdET22NF2CvRWNQEZMJquZKSZpGcP@Chtjh/e1gjDYDtSmt7TmPqTYAcRZrNZ5SX00sMsZDjbfxUjhUE0ytHmqL99B0qDfxdMDvmmIhIj4L4AZqbewpi@UK@J8xxQwBpjGr@Nm2GMUr2z9R3SYzJ3Rd3oX9AKPnd5gGesTpdXgel3HmO/nGebLYLBM0YebyBxvu@hf8aqHhFOIX "Python 2 – Try It Online")
*Saved 4 bytes, thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)*
[Answer]
# [JavaScript (Node.js)](https://nodejs.org/en/), 70 bytes
```
a=>a.sort((a,b)=>(g=a=>a.map(c=>99+parseInt(2+c,34)%607%292))(a)>g(b))
```
[Try it online!](https://tio.run/##hVFLbsMgEN33GEiRQKFR5FStvMD7nsHygjhjhyphLKBu1Mu7tgGbtJG6Ac3Mm/eBD9lLWxvVuWeNJxgaMUhRyJ1F4yiV/MhEQVsx966yo7Uo8nzbSWPhXTuabWt@eGGb1/3bJsszxqhkRUuPjA01aosX2F2wpQ0tS@LOBoBwgno6G/w0pOJlLFU/XVqN1dR1XziWVt3ibG4GhgAG1Z4dqSrGnv6K@X3oQScqYWPhX@v/5rPdaOWhYhKL3xcT16rxK4SPGCFx6I2v4G8wuDzPQ/mA8HQYXtH7X9Y9W6ozE6Y540Y0sHzTHTL5qJAx9j1@dDj8AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 49 bytes
```
->x{x.sort_by{|y|y.map{|s|s.to_i(36)**4%463595}}}
```
[Try it online!](https://tio.run/##TY7LCoMwEEX3fsUQKLRis/EBXdgfCUEqJDULjeTRGozfnqq1oau5HA73jrKtC7wO1/s0T1hLZZrWzd55h/vHOHvtNTayEee8uqRpcSqqvLyVy7KEwfYaaiAEkOkUYwgyQHJY7xa4tGpNNEuA/PDOxetrDmJnh2De8hC0mNCfGYU4ERuYeHYGAaVJMgIn2z80fAA "Ruby – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 27 bytes
```
Σ“¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“#skJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//3OJHDXMOLTw8/VHTmkNbHzXMetSw6FHDvMNrHzUsOLzmdNvhjqOTji48vP7Q/qM7Dq0/tPToAqB65eJsr///o6OVSjKKUlOVdJTy80BkWn5pkVKsTjSMm1kGovIygTyQaEl5PpBbnFkBkwMLQk2AKk7NTM8oUYqNBQA "05AB1E – Try It Online")
---
```
Σ                           # Sort input by...
 “¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“     # "zero one two three four five size seven eight nine"
                       #    # Split on spaces.
                        sk  # Find index of each input...
                          J # Join up.
```
[Answer]
# [Haskell](https://www.haskell.org/), 133 122 109 107 106 bytes
```
import Data.List
sortOn$abs.read.(>>=show.head.(`elemIndices`words"ze on tw th fo fi si se ei ni").take 2)
```
Ungolfed:
```
import Data.List
nums = ["ze","on","tw","th","fo","fi","si","se","ei","ni"]
lookup' :: Eq a => a -> [a] -> Int
lookup' v = head . elemIndices v
wordToInt :: String -> Int
wordToInt (x:y:_) = lookup' [x,y] nums
wordsToInt :: [String] -> Int
wordsToInt = read . concatMap (show . wordToInt)
sortN :: [[String]] -> [[String]]
sortN = sortOn wordsToInt
```
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
lambda m:sorted(m,key=lambda r:[hash(s)%2249518for s in r])
```
[Try it online!](https://tio.run/##TYzbCgIhFEV/5SAECr4kBTUwX2I@GKMppQ5Hu8zX2zQ3ejqbtfY@/VBciqLa9lIfOlw7DaHJCYvpaOB3M7QLxUY6nR3NbCfE4Xzcn2xCyOAjoGK1Rx8LtVRKIMWhMQQ4kBTH@ws2PXFMioNc6YT9ay5GP7HZl3dafPYf8ldc/fZ/2xt/c4WAUozVLw "Python 2 – Try It Online")
Riffing on [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)'s Python 3 solution...
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 132 bytes
```
l->{l.sort((a,b)->s(a)-s(b));}
int s(String[]a){int v=0;for(var s:a)v=v*99+"zeontwthfofisiseini".indexOf(s.substring(0,2));return v;}
```
[Try it online!](https://tio.run/##rVPBbtswDL33KwifpC4Rit0aNwGGXjfs0OOwg@LQiVJbMkTaaRf42zNJdp0OWXqqDFgS3@MjKVF73en5fvN8MnXjPMM@7FXLplK3@c2FrWxtwcbZ/4LEHnUdoaLSRPBDGwvHGwjj0Vlqa/QP3w3xwxN7Y7e/fq9WUMLyVM1Xx@AdxITQs7Wcr0hoOSexljLvc2MZSLz5aHmMhm55l5fOi057oIWW3bK7vb//kv1BZ/nAu9KVhgyhsSZTxm7w5WcpSFG7piQk7mZfg7pHbr2FLu9PeUi0adeVKYBYc5g6ZzZQhyKm4KD9luRYk8VDKlFI5dvwjwL9WSR5J2Dkv4nEDxiJCZYjFMd5BZDxziOCswila32mqKkMiwwyOXtPSwTTIVhj8SqLDw7IvCTmdVKKmMTQbHf8njjx@tmVdGME7NB@mOmF7kWWHzM@QyMe58VBnOsbV32eFqHBIHVYvK3FcGdyqvzfVk5oNIVL/ea9fiWlKe5FBGQ@OpVKFwU2gzXCE/L0Soy1ci2rJmhyZSfO@LJCo9W6EYP6YsFuCC5V4aoKCxaPw@w8KXYptpSjfp@asz/9BQ "Java (JDK 10) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 103 bytes
```
sub c{pop=~s%(..)\w+\s*%zeontwthfofisiseeini=~/$1/;$`=~y///c/2%ger}say s/\R//gr for sort{c($a)<=>c$b}<>
```
[Try it online!](https://tio.run/##TYvJCsJAEETv@Yo@JOCCaRU8mfgHXjznoIaepEGmw/RoXDCf7rgF8VJQVe815A6LEPS4h/LWSJN3mgzSdFi040JHyZXE@tbXRgwrKxFbzjuMZ7iMt3l3QcQS50lF7q67CygWG8TKgREHKs7fykG8G2b5qoz392wVguETgfIZfO2IIrEEvpW@GTm@1J6IruQEeuADfm7iqvZf7@2AZUvRO@C3/dVWHtJ4Fqthsl6k09n0CQ "Perl 5 – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 38 bytes
```
T`z\o\wit\hfsen`d
O`
T`d`z\o\wit\hfsen
```
[Try it online!](https://tio.run/##bU87DsMgDN19j0oduAGH6NCMDFSKU1iMRGhS5fI0PJN@pG7P7@NnZy5RbvV0vnpbB7@55NZYXJhmFj/SxdPgx1@6OiFbS8jMJgmbKT2yBYgLG4nCtqzJzPEJxqoTIsd7KASVFxakwCGh6B/XKrCBjsJ3s9ldyHzVtOpGK4WqLm@cE04koGbcsxYtKsLXk83YL1CHrsLDH01fxi06N/gC "Retina 0.8.2 – Try It Online") Link includes test suite. Works by temporarily replacing the letters `zowithfsen` with their position in that string, which allows the numbers to be sorted lexically.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~30~~ ~~28~~ 27 bytes
```
w@€“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»µÞ
```
[Try it online!](https://tio.run/##y0rNyan8/7/c4VHTmkcNcw4tPLTs4a72hzvbkuoe7mzPerhz1uEZqkemHVn4cOeMhzuWPtwx7@HOfUAZr4c7eg7tPrT18Lz/h9u9gZoj//@PjlZQKskoSk1VUtBRUMrPA9IgRlp@aRGQFavDpRANEwaLZ5ZBVOZlgsWgCkrK86EKijMrlJBUwhXArYCbkJqZnlGihGkC2DKQSallqXlY5KtSi/JRnKAQCwA "Jelly – Try It Online")
-1 thanks to Jonathan Allan.
Finds the index of each digit in the string ‘onetwo...nine’ then sorts using this as a key function with `Þ`. Don't need to include `'zero'` at the beginning because the search for the first two characters of `'zero'` will fail and `0` will be returned instead of an index, making `'zero'` lexicographically "early".
[Answer]
# Python 3, 141 bytes
```
print(sorted(eval(input()),key=lambda l:int(''.join([str("zero one two three four five six seven eight nine".split().index(i))for i in l]))))
```
[Try it online!](https://tio.run/##NY4xDoMwDEWvYmVpIiGWbpV6kigDFaa4TR2UBAq9fGoi8GDrf1vve9ryGPhayhSJs04hZuw1Lp3XxNOctTHNG7e77z6PvgN/268ul/YViLVNOWr1wxggMEL@BshjRIQhzBEGWhASrZBwQQak55iBiVG1afIk6Ja4x1WTMUOIQEAM3hmpUqxVFaUaJWjpO1K5xp5S4DIqbnclW6SknbtqHoTjuH6gnPsD)
[Answer]
# [C (clang)](http://clang.llvm.org/), 229 bytes
```
y,j,k,t[9];char *s="zeontwthfofisiseeini";r(char **x){for(j=y=k=0;k+1<strlen(*x);k+=j,y=y*10+(strstr(s,t)-s)/2)sscanf(*x+k,"%2[^,]%*[^,]%*[,]%n",t,&j);return y;}c(*x,*y){return r(x)-r(y);}f(*x[],l){qsort(&x[0],l,sizeof(x[0]),c);}
```
[Try it online!](https://tio.run/##dVPtktogFP2fp2DYcQcUu0b902K2D5LamTQSRVNoAXfNOj67vXxEUztVJ8I55557uGI9rdtKba9PUtXtcSNW1m2k/rR7zYZIK388QEaqLUDXju3Zgbny85rXu8qgsS3wh9DKvbtdoxtppRVCKom5IVEwPtFzow3ZF11xKGb8MMm9XysUAQq2xZ51RTfOZxMCOHyIZY5OLX2ZU2vrSjUgnBwYHs3L72w9GqcnPBRmjj3vKTfCHY1CHb/UIGbjjp4TZMiJTg3pKL94n3LNWnr@bbVx5PlUzmDLrIQTNMTvKKtBeH3aiEYqgSpjqs4nrSgiJOkqSl9ua19DaZb9ggE5V6cz@zYIANRSdM78QvLMD0GiAs04kmiFWviaTDyPQnFDcDmy65HFDJ1KCQZErtppTr9ihr9gTHl2gXe20U5YV1dWpGbur2aoT@IYAPzmjeA1ffVP74SaxP@rPzpL8DcV@4XsPyupiPfOUsO8XMM5ztjtjBBMK8EafTQQMyzlm2AKpgd7965huqeA@W3QB4GQ253DF95bzntLXyHehEpuURed@vX/cB8itrr7LpJvH/KWlkFl8hrE8mEjEcEQJQk@hNHxYHf7ZbIPnC/W4dwhUSwItTc/X37LG1WxRRrgne9HGLJGJGig9/AKuJzdb6nLKfxqQ3Y@ZOeP7GLILh7Z5ZBdejZL/6kZXI3rHw "C (clang) – Try It Online")
There is no straightforward way of sending array of array of strings to C functions, so in spirit of code-golf, I have taken a minor liberty in input format.
`f()` accepts an array of pointers to strings, where each string is a number, represented by comma separated spelled-out-digits in lower-case. Additionally, it needs number of strings in array in second parameter.
I hope this is acceptable.
`f()` replaces the pointers in place in sorted order using `qsort()`.  
`r()` reads input number from comma-separated number string. It only compares first two characters to identify number.  
`c()` is comparison function
[Answer]
# [Ruby](https://www.ruby-lang.org/), 64 bytes
```
->a{a.sort_by{|b|b.map{|n|"zeontwthfofisiseeini".index n[0,2]}}}
```
[Try it online!](https://tio.run/##nVJbS8MwFH7frzgEBgq1iI/C9GH4IIjC8EVCkHY9XQMzKUm6i@t@e22bpu3KLupLm3P7LidRWbgt4klx8xDsAl9LZT7D7S4P89D/CtJdLnLyjVKYtUliGXPNNSIXnPhcRLgBQW@9O7bf7ws6AqCUEpMoROIRKapvLDNFmEddyFfVT/AyqrJmLctQ842r1ckGoWlGvkgMYcwrCSqK/0ANxJxgqClqDxYLVyh64pu2lquLL9VrYidraOQSTCdjCHuepnXTM@8dBhVARzzYil2la3FFq6Zr/kYl22sYWjuLeFnW7zhbn03assjmWdjttDMWog9eo/S36CYca/tqDjp7L69R7fK2v1vFUVkn2Y@CnfPxN7mMjZiPwTyBSELORZoZD3CT4txglJeSFepsaWACMa2rrMylUB@rU2Y0kEV5nRquxvqawBioG5m0QPAIZC6VKoPllsA9kOfX6dts9jR9f/kgFtJONZgjFFHxAw "Ruby – Try It Online")
A lambda accepting a 2D array of strings and returning a 2D array of strings.
Piggybacking off of [mbomb007's Python 2 answer](https://codegolf.stackexchange.com/a/161678/77973) for -26 bytes off of what I was about to post.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 10 bytes
```
µ→λf∆ċ←⁼;Ṅ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCteKGks67ZuKIhsSL4oaQ4oG8O+G5hCIsIiIsIltbXCJ0d29cIixcInNldmVuXCJdLFtcIm9uZVwiLFwiZWlnaHRcIl0sW1widHdvXCIsXCJlaWdodFwiXSxbXCJvbmVcIixcImVpZ2h0XCJdLFtcInR3b1wiLFwiZWlnaHRcIl0sW1wiZm91clwiLFwiZml2ZVwiXV0iXQ==)
Can be a little bit slow for serial numbers that represent larger decimal numbers, as the explanation will show. Who needs lookup strings anyway?
## Explained
```
µ→λf∆ċ←⁼;Ṅ
µ          # Sort the input by:
 →         #  putting the item into a temporary variable (needed for scoping purposes)
  λ     ;Ṅ #  and getting the first non-negative integer where:
   f∆ċ     #    converting each of the digits in the number to words
      ←⁼   #    equals the list being considered.
```
]