    
    out = process.stdout
    err = process.stderr
-
+   
    heart = '💖 '
    salutation = 'Paws loves you. Bye!'
    

         heart: if Paws.use_colour() then heart else '<3'
         b: ->(text, r)-> T.bold r text
         u: ->(text, r)-> T.underline r text
         c: ->(text, r)-> T.invert r text
         
         op:   ->(text, r)-> T.fg 2, r text
         flag: ->(text, r)-> T.fg 6, r text
         
         title: ->(text, r)-> T.bold T.underline r text
         link:  ->(text, r)->
            if Paws.use_colour() then T.sgr(34) + T.underline(r text) + T.sgr(39) else r text
         pre:  ->(text, r)->
            if Paws.use_colour()
               lines = text.split "\n"
               lines = _(lines).map (line)->
                  sanitized_line = line.replace /\{\{\{?[^}]+\}?\}\}/g, ''
                  line + new Array(T.columns - sanitized_line.length + 1).join(' ')
               T.invert r lines.join("\n")
            else r text
      
      version()
   

      #  -- standard 80-column terminal ------------------------------------------------|
      usage = seperator + "\n" + _(figlets).sample() + """
         
{{#title}}Usage:{{/title}}
{{#pre}}{{prompt}} paws.js [{{#bgflag}}flags{{/bgflag}}] {{#bgop}}operation{{/bgop}} [operation parameters]
         
           # for example,
         {{prompt}} paws.js {{#u}}foo.paws{{/u}} [[--] arguments]
         {{prompt}} paws.js {{#bgop}}interact{{/bgop}}
         {{prompt}} paws.js {{#bgop}}parse{{/bgop}} {{#u}}bar.paws{{/u}}{{/pre}}
         
         The first non-flag argument will be an operation to preform; the second depends
         on the operation, but is usually a path to a file to load. If no operation is
         instructed, then the {{#op}}start{{/op}} operation is used.
         
         In true UNIX style, single-letter flags may be combined serially; that is,
         {{#c}}-aBc{{/c}} is synonymous with {{#c}}-a -B -c{{/c}}. Furthermore, all arguments following a
         bare {{#c}}--{{/c}} are passed to the program un-parsed (that is, even if it's a flag that
         would otherwise be interpreted by the Paws.js CLI, it will be ignored and passed
         verbatim to the Paws runtime.)
         
{{#title}}Operations:{{/title}}
            {{#op}}start{{/op}} {{#u}}filename.paws{{/u}}           Start the Paws reactor, load the given unit
            {{#op}}parse{{/op}} {{#u}}filename.paws{{/u}}           Show the computed parse-tree for a cPaws file
            {{#op}}interact{{/op}}                      Begin an interactive Paws session (a ‘repl’)
         
{{#title}}Flags:{{/title}}
{{#flag}}   --help{{/flag}}:        Show this usage information
{{#flag}}   --version{{/flag}}:     Show version information
            
{{#flag}}   -e "EXPR"{{/flag}},{{#flag}} --expression="EXPR"{{/flag}}:
               For {{#op}}parse{{/op}} and {{#op}}start{{/op}}, allows you to provide a cPaws expression at the
               command-line, to substitute for a file. (If at least one {{#c}}--expression{{/c}}
               is included, the filname for those operations, normally a required
               parameter, may be omitted.)
            
{{#flag}}   --[no-]start{{/flag}}:
               Disable the self-scheduling reactor functionality. Under normal
               circumstances (i.e. {{#c}}--start{{/c}}, the default) a Paws reactor runs
               indefinately, processing combinations when they become available.
               
               With the {{#c}}--no-start{{/c}} flag, however, the reactor will shut down as soon
               as all immediately-known stagings have been completed. This means your
               program will more intuitively ‘automatically exit,’ but it also means any
               deferred stagings in your code (stagings that cannot immediately execute,
               for instance those with ownership-conflicts, or those deferred by timing
