[Question]
  [
Given an ordered list of same-case letter strings (a-z XOR A-Z) where each string is preceded by 0 or more space ( ) characters, output the same list but with the strings sorted at each level of indentation. Indentation depths under different parents count as distinct lists for sorting purposes.
## Example
If your input is:
```
bdellium
  fox
  hound
  alien
aisle
  wasabi
    elf
    alien
  horseradish
    xeno
irk
wren
tsunami
djinn
      zebra
```
your output should be
```
aisle
  horseradish
    xeno
  wasabi
    alien
    elf
bdellium
  alien
  fox
  hound
djinn
      zebra
irk
tsunami
wren
```
If you like, think of it like a directory listing, and you need to sort the names within each directory.
## Minutiae
* An item may be indented by any number of spaces. If it is indented by the same number of spaces as the previous item it belongs in the same sort hierarchy as the previous item. If it is indented by more spaces it is the start of a new sub-hierarchy.
* If a line is indented by *fewer* spaces than the line above it, it links up to the closest sub group above it with the same # or fewer spaces before it (like horseradish in the above example, which links onto the wasabi group above it because wasabi is the first item above it to not have more spaces than horseradish)
* You must preserve the indenting level of each input item in your output
* Tabs in the output are disallowed
* The first line of the input will never be indented
* Your program must handle at least one of all-uppercase and all-lowercase strings; it doesn't have to handle both.
## Scoring
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the answer which uses the fewest bytes wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/), 117 bytes
```
lambda S:[s[-1]for s in sorted(reduce(lambda t,s:t+[[v for v in t[-1]if v.count(' ')<s.count(' ')]+[s]],S,[[]]))[1:]]
```
[Try it online!](https://tio.run/##bYzNboMwEITP5SlWuRgUGik9ouYBeuqBo@ODiY3Y1KyRf0jal6e4DlIO3dPM7DczfYfB0tvSn86LkWOnJLQN9/z1KHrrwAMSeOuCVqXTKl50@aBC7Zuw53yGxM2JC6mFPcyHi40USgasevdPRuy5F6Jua86FqCp@bIRY2hMvXlintDEYR1YDg3XynsWwdlWW0qCmJCV6o3N2k152yOp1ANbTps/5E502nNdOKvTD9r1rsn8tdF8pu7kMBx9JjpikuiLRxgP86M5JVoiimBxSgN0HTTE0u4dlZ2KHq0Uq2ypHG/cZw/9gv6LV8gs "Python 2 – Try It Online")
Takes as input a list of strings; and outputs a list of strings, sorted as required.
The idea is to turn each element into a list which contains the "absolute path" as a list; and then let Python handle the sorting. E.g. if the input is:
```
[
 'a',
 ' c',
 '  d',
 ' b'
]
```
Then via the `reduce()`, we convert to a list of lists:
```
[
 ['a'],
 ['a',' c'],
 ['a',' c', '  d'],
 ['a',' b']
]
```
which gets sorted as:
```
[
 ['a'],
 ['a',' b']
 ['a',' c'],
 ['a',' c', '  d'],
]
```
and then output the last element of each list in the list-of-lists to get:
```
[
 'a',
 ' b'
 ' c',
 '  d',
]
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 31 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous prefix lambda, takes and returns list of strings.
```
{⍵[⍋{1=≢⍵:⍺⋄⍵}⍀↑' '(,⊂⍨⊣=,)¨⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79boR73d1Ya2jzoXATlWj3p3PepuAbJqH/U2PGqbqK6grqHzqKvpUe@KR12LbXU0D60ASsbW/k971DbhUW/fo76pnv6PupoPrTcGqgbygoOcgWSIh2fwf6BAmoJ6UkpqTk5maS7QJAWFtPwKMJ2RX5qXAmYl5mSm5gFZiZnFOalgkfLE4sSkTDBTQSE1Jw3KgikEaS4qTi1KTMkszoDKVaTm5QOZmUXZQLK8CKyupLg0LzEXZE5KVmZeHlSlgkJValJRojoA "APL (Dyalog Unicode) – Try It Online")
`{`…`}` "dfn"; `⍵` is argument
 `⍵[`…`]` index the argument with the following indices:
  `' '(`…`)¨⍵` apply the following tacit function to each string with space as left argument:
   `,` concatenate the space to the string
   `⊣=` Boolean list indicating where the space is equal to each character that
   `,⊂⍨` use that to partition (begin part where true) the concatenation of space and string
  `↑` mix list of lists of strings into matrix of strings
  `{`…`}⍀` vertical cumulative reduction by this "dfn"; `⍺` and `⍵` are upper and lower args:
   `≢⍵` the length of the lower string
   `1=` is that equal to 1? (i.e. is there nothing but the single space there?)
   `:⍺` if so, return the upper argument
   `⋄⍵` else, return the lower argument
  `⍋` grade up (find indices which will sort that)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 47 bytes
```
+-1m`(?<=^\2(\S+).*?¶( *)) 
$1 
O$`
$L$&
\S+ 
 
```
[Try it online!](https://tio.run/##JYs9DsIwDEZ3n8JDhPojkMoM6gWQGBhYKlRXcVVDkkpJKyoOxgG4WAhl@Z7t58/zJI6qGMttZdusPhxvzT5rLmW@K@rPO8MizxFUhXBWLaiT2kCSCBhjp9kYmS0g9uOSchhnpxPJCDsgCYbT9qRAnaQBkU2/8v/wK/jAnrSEYb0v7EYQ/4CrT34KsyMroO/i3OoRX9x5@gI "Retina – Try It Online") Note: Several lines have trailing spaces. Explanation:
```
+-1m`(?<=^\2(\S+).*?¶( *)) 
$1 
```
The first step is to insert each word into following lines at the same indentation. For example, with the lines `aisle`,  `wasabi` and  `elf` the resulting lines are `aisle`, `aisle wasabi` and `aisle wasabi elf`. I discovered this regex by trial and error so there may be edge cases with it.
```
O$`
$L$&
```
We can now sort the lines case-insensitively.
```
\S+ 
 
```
Delete all of the inserted words.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~120 83 81 63 54 37 47~~ 42 bytes
*-5 bytes thanks to nwellnhof*
```
{my@a;.sort:{@a[+.comb(' ')..*+1]=$_;~@a}}
```
[Try it online!](https://tio.run/##bY5BC8IwDIXv/RVhiG4KBS8eHML@h4qkLsNom0rr0Cn612edBy9e3kvyvgc5U7CL3nUwbmAF/cN1FZY6@nBZPipcz/TeO5NPYFJoPZ3Nt6vRrnxV@Hz2pYrYQZNnpiZruXUKoPG3pAffSp0cLZMo5GgpbVeMaDgNAGSbwb/ApxAiBaw5Hob7jcQrDid1DSm/xFbQsaqPLDLkAHcyATNtWSgW@uhZ8mwjWaF@XyXyrjCp@cv1bw "Perl 6 – Try It Online")
This uses [Chas Brown's method](https://codegolf.stackexchange.com/a/171009/76162). An anonymous code block that takes a list of lines and returns a list of lines.
### Explanation:
```
{                                        }  # Anonymous code block
 my@a;  # Declare a local list
      .sort # Sort the given list of lines
           :{                           }  # By converting each line to:
             @a[+.comb(' ')..*+1]=$_;      # Set the element at that indentation level onwards to that line
                                     ~@a   # And return the list coerced to a string
```
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), ~~112~~ 101 bytes
```
import StdEnv
f=flatten
?e=[0\\' '<-e]
$[h:t]#(a,b)=span(\u= ?u> ?h)t
=sort[[h:f($a)]: $b]
$e=[]
```
# 
```
f o$
```
[Try it online!](https://tio.run/##TZC9bsMwDIR3PwWBGLANJEDnoGqWdijQLaOtgbapWK1MBfpp0j58XQWO6278jrwDjp0h5Gm0fTQEI2qe9Hi2LsAx9C/8mSmhDIZAnB1I1A9NU0DxuCOZ5fWwD3JT4rathD8jl00UcIhPcBiqkAmfQup0o8ocK7mHvE2eFCGnY0AXsg2oyF3QlkGAApsnxQen@eSTUNdF25MxOo6F3EJdACh7XcbBRu4XQKOJZ0DtDS36BT22eiEAMmqFf6ZbnPPksNd@WC@uxHYm7T7m4eIWT/CRcbyH9@@aeTUCfFPrsJAyS8XS84xm8lD@1b23rKafLq1Pftq9vk3PX7fALkH7Cw "Clean – Try It Online")
Anonymous function `:: [[Char]] -> [[Char]]` which wraps `$ :: [[Char]] -> [[[Char]]]` into the right output format. `$` groups the strings into "more spaces than" and "everything else afterwards", recurses over each group and sorts when they're adjoined. At each step, the list being sorted looks like:
```
[[head-of-group-1,child-1,child-2..],[head-of-group-2,child-1,child-2..]..]
```
# [Clean](https://github.com/Ourous/curated-clean-linux), 127 bytes
```
import StdEnv
$l=[x++y\\z<- ?(map(span((>)'!'))l),(x,y)<-z]
?[h:t]#(a,b)=span(\(u,_)=u>fst h)t
=sort[[h:flatten(?a)]: ?b]
?e=[]
```
[Try it online!](https://tio.run/##TZDBbsIwEETv@YqtQIotwg8gTC7toVJvHI1VbRKHuHU2ke2UwMc3NYWU3vbtzow0W1qNNLVdNVgNLRqaTNt3LsA@VC/0lSytkONqdT4cLts15KzFnvkeibEdT59Szi3P2Jid@XZ9UUkum01QC4ZZwcWv7MCG7J2LYVf7AA0PifAxXUZdbTEETSxHrjaQF9GthVTTPqALyQLqgcpgOgIBy4g@OENHH0nKtKi0tWZoU5WBTAHqbpzHphuomgGt0XQDNN7qeX9Cj4WZCUDb@gH/TNc457XDyvjmoRg1dTcy7vM2nNzsCX4gbO/h1YchehgBLrpwmCqVCLg@wBrSHthf13tLPn2X8Xz00/r1bXo@XwPLCMUP "Clean – Try It Online")
Defines the function `$ :: [[Char]] -> [[Char]]` which separates the strings into tuples in the form `(spaces, letters)` which are recursively sorted by the helper function `? :: [([Char],[Char])] -> [[([Char],[Char])]]`.
Explained:
```
$ list                                  // the function $ of the list
    = [                                 // is
        spaces ++ letters               // the spaces joined with the letters
        \\ sublist <- ? (               // from each sublist in the application of ? to
            map (                       // the application of
                span ((>)'!')           // a function separating spaces and letters
            ) list                      // to every element in the list
        )
        , (spaces, letters) <- sublist  // the spaces and letters from the sublist
    ]
? [head: tail]                              // in the function ? of the head and tail of the input
    # (group, others)                       // let the current group and the others equal
        = span (                            // the result of separating until ... is false
            \(u, _) = u >                   // only elements where there are more spaces
                          fst head          // than in the head of the input
        ) tail                              // the tail of the input
    = sort [
        [head                               // prepend the head of the input to
             : flatten (?group)             // the flat application of ? to the first group
                               ]            // and prepend this to
                                : ?others   // the application of ? to the other group(s)
    ]
? empty = [] // match the empty list
```
[Answer]
# [Pyth](https://pyth.readthedocs.io), 23 bytes
```
jeMtSuaG+f</Td/HdeGHQ]Y
```
[Try it here!](https://pyth.herokuapp.com/?code=jeMtSuaG%2Bf%3C%2FTd%2FHdeGHQ%5DY&input=%5B%27bdellium%27%2C+%27++fox%27%2C+%27++hound%27%2C+%27++alien%27%2C+%27aisle%27%2C+%27++wasabi%27%2C+%27++++elf%27%2C+%27++++alien%27%2C+%27++horseradish%27%2C+%27++++xeno%27%2C+%27irk%27%2C+%27wren%27%2C+%27tsunami%27%2C+%27djinn%27%2C+%27++++++zebra%27%5D&debug=0)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~114~~ ~~100~~ ~~92~~ 88 bytes
```
x=>x.map(y=>a=a.split(/ */.exec(y)[0]||a)[0]+y,a="_").sort().map(x=>/ *\w+$/.exec(x)[0])
```
[Try it online!](https://tio.run/##LY/RbsMgDEXf@QpU7QHWju69oj@yVYsTnNUtgQgnC5n67xlJ9@Jj@95ryTf4AW4S9cNbiA6X1i7ZnrPpoFezPYMFw72nQR3l69FgxkbN@uP98njAiv18ALv72mnDMQ1Kb7lyoLg/p/3LfyKvVr2cmhg4ejQ@fqtWVbVD72nshJRtzKVe4xhcIXjCIIDYY5kmYKipNFKibzc@DWsgMSZwxNdtnzFEQekuplT0gccAHQl3oxA2XcpfrBNUz58qUWl9Wv4A "JavaScript (Node.js) – Try It Online")
Similar approach to Chas Brown's Python answer, but using regular expressions instead.
## Explanation
```
x => x.map(                         // 
 y => a = a.split(                  // Renders the indentation paths
  / */.exec(y)[0]                   //  Checks the indentation level
  || a                              //  If this is the top level, go to root
 )[0] + y,                          //  Appends the child to the parent
 a = "_"                            // At first the cursor is at the root
)                                   // 
.sort()                             // Sorts the indentation paths
.map(                               // 
 x => / *\w+$/.exec(x)[0]           // Extracts only the last level of the path
)                                   //
```
[Answer]
# [K4](https://kx.com/download/), 51 bytes
**Solution:**
```
{,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x}
```
**Example:**
```
q)k){,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x}("bdellium";"  fox";"  hound";"  alien";"aisle";"  wasabi";"    elf";"    alien";"  horseradish";"    xeno";"irk";"wren";"tsunami";"djinn";"      zebra")
"aisle"
"  horseradish"
"    xeno"
"  wasabi"
"    alien"
"    elf"
"bdellium"
"  alien"
"  fox"
"  hound"
"djinn"
"      zebra"
"irk"
"tsunami"
"wren"
```
**Assumptions:**
a. That each hierarchy will start with the lowest level, i.e. you will not get:
```
bdellium
      fox
    hound
    alien
```
**Explanation:**
```
{,/(1#'r),'.z.s@'1_'r:(w_x)@<x@w:&s=&/s:+/'" "=/:x} / the solution
{                                                 } / lambda function, implicit x
                                           " "=/:x  / " " equal to each right (/:) x
                                        +/'         / sum up each
                                      s:            / save as s
                                    &/              / find the minimum (ie highest level)
                                  s=                / is s equal to the minimum?
                                 &                  / indices where true 
                               w:                   / save as w
                             x@                     / index into x at these indices
                            <                       / return indices to sort ascending
                           @                        / index into
                      (   )                         / do this together
                       w_x                          / cut x at indices w
                    r:                              / save as r
                 1_'                                / drop first from each r
            .z.s@                                   / apply recurse (.z.s)
          ,'                                        / join each both
    (    )                                          / do this together
     1#'r                                           / take first from each r
  ,/                                                / flatten
```
[Answer]
# Perl 5, 166 bytes
```
sub f{my$p=shift;my@r;while(@i){$i[0]=~/\S/;$c=$-[0];if($p<$c){$r[-1].=$_ for f($c)}elsif($p>$c){last}else{push@r,shift@i}}sort@r}push@i,$_ while<>;print sort@{[f 0]}
```
Ungolfed (sort of):
```
sub f {
    my $p = shift;
    my @r;
    while(@i) {
        $i[0] =~ /\S/;
        $c = $-[0];
        if($p < $c) {
            $r[-1] .= $_ for f($c)
        } elsif ($p > $c) {
            last
        } else {
            push @r, shift @i
        }
    }
    sort @r
}
push @i, $_ while <>;
print sort@{[f 0]}
```
It's a pretty straightforward recursive implementation. We check the indentation level by searching for the first non-space character (`/\S/`) and getting its index (`$-[0]`). Unfortunately, we actually have to *declare* a handful of variables that are used in the recursion, or else they'll be implicitly global and the recursion won't work correctly.
]