(command.CommandList
  children: [
    (command.ShFunction
      name: throw
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_Star '$*'))}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:BRIEF) op:assign_op.Equal rhs:{<0>} spids:[28])]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LEAFONLY)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [31]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:PRUNE) op:assign_op.Equal rhs:{<0>} spids:[34])]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:NO_HEAD)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [37]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:NORMALIZE_SOLIDUS)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [40]
        )
      ]
    )
    (command.ShFunction
      name: usage
      body: 
        (BraceGroup
          children: [
            (C {<echo>})
            (C {<echo>} {(DQ <'Usage: JSON.sh [-b] [-l] [-p] [-s] [-h]'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'-p - Prune empty. Exclude fields with empty values.'>)})
            (C {<echo>} {(DQ <'-l - Leaf only. Only show leaf nodes, which stops data duplication.'>)})
            (C {<echo>} {(DQ <'-b - Brief. Combines \'Leaf only\' and \'Prune empty\' options.'>)})
            (C {<echo>} 
              {(DQ <'-n - No-head. Do not show nodes that have no path (lines that start with []).'>)}
            )
            (C {<echo>} {(DQ <'-s - Remove escaping of the solidus symbol (straight slash).'>)})
            (C {<echo>} {(DQ <'-h - This help text.'>)})
            (C {<echo>})
          ]
        )
    )
    (command.ShFunction
      name: parse_options
      body: 
        (BraceGroup
          children: [
            (C {<Id.KW_Set set>} {<-->} {(DQ ($ Id.VSub_At '$@'))})
            (C {<local>} {<Id.Lit_VarLike 'ARGN='> ($ Id.VSub_Pound '$#')})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$ARGN'))} {<-ne>} {<0>} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ Id.VSub_Number '$1')}
                      arms: [
                        (case_arm
                          pat_list: [{<-h>}]
                          action: [
                            (C {<usage>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [158 159 169 -1]
                        )
                        (case_arm
                          pat_list: [{<-b>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BRIEF)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [175]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:LEAFONLY)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [179]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:PRUNE)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [183]
                                )
                              ]
                            )
                          ]
                          spids: [172 173 187 -1]
                        )
                        (case_arm
                          pat_list: [{<-l>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:LEAFONLY)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [193]
                                )
                              ]
                            )
                          ]
                          spids: [190 191 197 -1]
                        )
                        (case_arm
                          pat_list: [{<-p>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:PRUNE)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [203]
                                )
                              ]
                            )
                          ]
                          spids: [200 201 207 -1]
                        )
                        (case_arm
                          pat_list: [{<-n>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:NO_HEAD)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [213]
                                )
                              ]
                            )
                          ]
                          spids: [210 211 217 -1]
                        )
                        (case_arm
                          pat_list: [{<-s>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:NORMALIZE_SOLIDUS)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [223]
                                )
                              ]
                            )
                          ]
                          spids: [220 221 227 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<echo>} {(DQ <'ERROR: Unknown option.'>)})
                            (C {<usage>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [230 232 249 -1]
                        )
                      ]
                    )
                    (C {<shift>} {<1>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ARGN)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Minus
                                    left: <Id.Lit_ArithVarLike ARGN>
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [260]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: awk_egrep
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'pattern_string='> ($ Id.VSub_Number '$1')})
            (C {<gawk>} 
              {
                (SQ <'{\n'> <'    while ($0) {\n'> <'      start=match($0, pattern);\n'> 
                  <'      token=substr($0, start, RLENGTH);\n'> <'      print token;\n'> <'      $0=substr($0, start+RLENGTH);\n'> <'    }\n'> <'  }'>
                )
              } {<Id.Lit_VarLike 'pattern='> (DQ ($ Id.VSub_DollarName '$pattern_string'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: tokenize
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<GREP>})
            (C {<local>} {<ESCAPE>})
            (C {<local>} {<CHAR>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [
                            (C {<echo>} {(DQ <'test string'>)})
                            (command.Simple
                              words: [
                                {<egrep>}
                                {<-ao>}
                                {<--color> <Id.Lit_Equals '='> <never>}
                                {(DQ <test>)}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          negated: F
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GREP)
                          op: assign_op.Equal
                          rhs: {(SQ <'egrep -ao --color=never'>)}
                          spids: [366]
                        )
                      ]
                    )
                  ]
                  spids: [334 363]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GREP)
                      op: assign_op.Equal
                      rhs: {(SQ <'egrep -ao'>)}
                      spids: [375]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [
                            (C {<echo>} {(DQ <'test string'>)})
                            (command.Simple
                              words: [{<egrep>} {<-o>} {(DQ <test>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          negated: F
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ESCAPE)
                          op: assign_op.Equal
                          rhs: {(SQ <'(\\\\[^u[:cntrl:]]|\\\\u[0-9a-fA-F]{4})'>)}
                          spids: [413]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:CHAR)
                          op: assign_op.Equal
                          rhs: {(SQ <'[^[:cntrl:]"\\\\]'>)}
                          spids: [419]
                        )
                      ]
                    )
                  ]
                  spids: [385 410]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GREP)
                      op: assign_op.Equal
                      rhs: {<awk_egrep>}
                      spids: [428]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ESCAPE)
                      op: assign_op.Equal
                      rhs: {(SQ <'(\\\\\\\\[^u[:cntrl:]]|\\\\u[0-9a-fA-F]{4})'>)}
                      spids: [432]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:CHAR)
                      op: assign_op.Equal
                      rhs: {(SQ <'[^[:cntrl:]"\\\\\\\\]'>)}
                      spids: [438]
                    )
                  ]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'STRING='> 
                (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                  ($ Id.VSub_DollarName '$CHAR') <'*('> ($ Id.VSub_DollarName '$ESCAPE') ($ Id.VSub_DollarName '$CHAR') <'*)*'> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'NUMBER='> (SQ <'-?(0|[1-9][0-9]*)([.][0-9]*)?([eE][+-]?[0-9]*)?'>)}
            )
            (C {<local>} {<Id.Lit_VarLike 'KEYWORD='> (SQ <'null|false|true'>)})
            (C {<local>} {<Id.Lit_VarLike 'SPACE='> (SQ <'[[:space:]]+'>)})
            (C {<local>} 
              {<Id.Lit_VarLike 'is_wordsplit_disabled='> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.Pipeline
                      children: [
                        (command.Simple
                          words: [{<unsetopt>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<grep>} {<-c>} {(SQ <'^shwordsplit$'>)})
                      ]
                      negated: F
                    )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {($ Id.VSub_DollarName '$is_wordsplit_disabled')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Sentence
                      child: (C {<setopt>} {<shwordsplit>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  spids: [512 526]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {($ Id.VSub_DollarName '$GREP')} 
                  {
                    (DQ ($ Id.VSub_DollarName '$STRING') <'|'> ($ Id.VSub_DollarName '$NUMBER') <'|'> 
                      ($ Id.VSub_DollarName '$KEYWORD') <'|'> ($ Id.VSub_DollarName '$SPACE') <'|.'>
                    )
                  }
                )
                (C {<egrep>} {<-v>} {(DQ <'^'> ($ Id.VSub_DollarName '$SPACE') <Id.Lit_Dollar '$'>)})
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {($ Id.VSub_DollarName '$is_wordsplit_disabled')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Sentence
                      child: (C {<unsetopt>} {<shwordsplit>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  spids: [562 576]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: parse_array
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'index='> <0>})
            (C {<local>} {<Id.Lit_VarLike 'ary='> (SQ )})
            (C {<read>} {<-r>} {<token>})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
              arms: [
                (case_arm pat_list:[{(SQ <']'>)}] spids:[625 628 630 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<parse_value>} {(DQ ($ Id.VSub_Number '$1'))} 
                              {(DQ ($ Id.VSub_DollarName '$index'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:index)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (word_part.ArithSub
                                        anode: 
                                          (arith_expr.Binary
                                            op_id: Id.Arith_Plus
                                            left: <Id.Lit_ArithVarLike index>
                                            right: {<Id.Lit_Digits 1>}
                                          )
                                      )
                                    }
                                  spids: [656]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ary)
                                  op: assign_op.Equal
                                  rhs: 
                                    {(DQ ($ Id.VSub_DollarName '$ary')) 
                                      (DQ ($ Id.VSub_DollarName '$value'))
                                    }
                                  spids: [665]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ <']'>)}]
                                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                                  spids: [691 694 698 -1]
                                )
                                (case_arm
                                  pat_list: [{(SQ <','>)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ary)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$ary') <','>)}
                                          spids: [706]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [701 704 712 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<throw>} 
                                      {
                                        (DQ <'EXPECTED , or ] GOT '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name token>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VTest_ColonHyphen
                                                arg_word: {<EOF>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [715 716 729 -1]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                          ]
                        )
                    )
                  ]
                  spids: [633 634 745 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$BRIEF'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:value)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<printf>} {(SQ <'[%s]'>)} {(DQ ($ Id.VSub_DollarName '$ary'))})
                          )
                        }
                      spids: [765]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:value)
                      op: assign_op.Equal
                      rhs: (word.Empty)
                      spids: [780]
                    )
                  ]
                )
              ]
            )
            (C {<Id.Lit_Colon ':'>})
          ]
        )
    )
    (command.ShFunction
      name: parse_object
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<key>})
            (C {<local>} {<Id.Lit_VarLike 'obj='> (SQ )})
            (C {<read>} {<-r>} {<token>})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
              arms: [
                (case_arm pat_list:[{(SQ <'}'>)}] spids:[824 827 829 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ <'"'>) <Id.Lit_Star '*'> (SQ <'"'>)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:key)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$token')}
                                          spids: [862]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [853 860 865 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<throw>} 
                                      {
                                        (DQ <'EXPECTED string GOT '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name token>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VTest_ColonHyphen
                                                arg_word: {<EOF>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [868 869 882 -1]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ <':'>)}]
                                  spids: [904 907 909 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<throw>} 
                                      {
                                        (DQ <'EXPECTED : GOT '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name token>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VTest_ColonHyphen
                                                arg_word: {<EOF>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [912 913 926 -1]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                            (C {<parse_value>} {(DQ ($ Id.VSub_Number '$1'))} 
                              {(DQ ($ Id.VSub_DollarName '$key'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:obj)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$obj') ($ Id.VSub_DollarName '$key') 
                                        <':'> ($ Id.VSub_DollarName '$value')
                                      )
                                    }
                                  spids: [950]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ <'}'>)}]
                                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                                  spids: [976 979 983 -1]
                                )
                                (case_arm
                                  pat_list: [{(SQ <','>)}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:obj)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$obj') <','>)}
                                          spids: [991]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [986 989 997 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<throw>} 
                                      {
                                        (DQ <'EXPECTED , or } GOT '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name token>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VTest_ColonHyphen
                                                arg_word: {<EOF>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1000 1001 1014 -1]
                                )
                              ]
                            )
                            (C {<read>} {<-r>} {<token>})
                          ]
                        )
                    )
                  ]
                  spids: [832 833 1030 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$BRIEF'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:value)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<printf>} {(SQ <'{%s}'>)} {(DQ ($ Id.VSub_DollarName '$obj'))})
                          )
                        }
                      spids: [1050]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:value)
                      op: assign_op.Equal
                      rhs: (word.Empty)
                      spids: [1065]
                    )
                  ]
                )
              ]
            )
            (C {<Id.Lit_Colon ':'>})
          ]
        )
    )
    (command.ShFunction
      name: parse_value
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'jpath='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Unary
                        op_id: Id.VTest_ColonPlus
                        arg_word: {($ Id.VSub_Number '$1') <','>}
                      )
                  ) ($ Id.VSub_Number '$2')
                )
              } {<Id.Lit_VarLike 'isleaf='> <0>} {<Id.Lit_VarLike 'isempty='> <0>} {<Id.Lit_VarLike 'print='> <0>}
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ <'{'>)}]
                  action: [(C {<parse_object>} {(DQ ($ Id.VSub_DollarName '$jpath'))})]
                  spids: [1113 1116 1124 -1]
                )
                (case_arm
                  pat_list: [{(SQ <'['>)}]
                  action: [(C {<parse_array>} {(DQ ($ Id.VSub_DollarName '$jpath'))})]
                  spids: [1127 1130 1138 -1]
                )
                (case_arm
                  pat_list: [
                    {(SQ )}
                    {<Id.Lit_LBracket '['> <Id.KW_Bang '!'> <0-9> <Id.Lit_RBracket ']'>}
                  ]
                  action: [
                    (C {<throw>} 
                      {
                        (DQ <'EXPECTED value GOT '> 
                          (braced_var_sub
                            token: <Id.VSub_Name token>
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<EOF>})
                          )
                        )
                      }
                    )
                  ]
                  spids: [1145 1152 1165 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:value)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$token')}
                          spids: [1171]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$NORMALIZE_SOLIDUS'))} 
                          {<-eq>} {<1>} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:value)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {(DQ ($ Id.VSub_DollarName '$value'))})
                                          (C {<sed>} {(SQ <'s#\\\\/#/#g'>)})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [1193]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:isleaf)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1211]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$value'))} 
                          {<Id.Lit_Equals '='>} {(SQ <'""'>)} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:isempty)
                              op: assign_op.Equal
                              rhs: {<1>}
                              spids: [1231]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1168 1169 1235 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$value'))} {<Id.Lit_Equals '='>} {(SQ )} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$NO_HEAD'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$jpath'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$LEAFONLY'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PRUNE'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:print)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [1317]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$LEAFONLY'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$isleaf'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$PRUNE')} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:print)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [1361]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$LEAFONLY'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PRUNE'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$isempty'))} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:print)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [1407]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$LEAFONLY'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$isleaf'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$PRUNE')} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$isempty')} {<-eq>} {<0>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:print)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [1465]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$print'))} {<-eq>} {<1>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<printf>} 
                  {(DQ <'[%s]'> <Id.Lit_BadBackslash '\\'> <'t%s'> <Id.Lit_BadBackslash '\\'> <n>)} {(DQ ($ Id.VSub_DollarName '$jpath'))} {(DQ ($ Id.VSub_DollarName '$value'))}
                )
              ]
            )
            (C {<Id.Lit_Colon ':'>})
          ]
        )
    )
    (command.ShFunction
      name: parse
      body: 
        (BraceGroup
          children: [
            (C {<read>} {<-r>} {<token>})
            (C {<parse_value>})
            (C {<read>} {<-r>} {<token>})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$token'))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[1541 1543 1545 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<throw>} {(DQ <'EXPECTED EOF GOT '> ($ Id.VSub_DollarName '$token'))})]
                  spids: [1548 1549 1558 -1]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Subshell
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$0'))} 
                              {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$BASH_SOURCE'))} {<Id.Lit_RBracket ']'>}
                            )
                            (command.Pipeline
                              children: [
                                (C {<Id.Lit_LBracket '['>} {<-n>} 
                                  {(DQ ($ Id.VSub_DollarName '$BASH_SOURCE'))} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                              negated: T
                            )
                          ]
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<parse_options>} {(DQ ($ Id.VSub_At '$@'))})
            (command.Pipeline children:[(C {<tokenize>}) (C {<parse>})] negated:F)
          ]
          spids: [1566 1599]
        )
      ]
    )
  ]
)