anchor.diff:    "Parse tokens TOKS, the result of [[lex]]. If CONT is true, then
      \"resumable\" errors will be thrown if the end of the stream is
      reached."
  -  (let* ((index 1)
  +  (let* [(index 1)
            (head '())
            (stack '())
   
  
positive.code:   ;; Attempt to "normalise" strings
    (set! str (string/gsub str "\r\n?" "\n"))
  
    (let* ((lines (string/split str "\n"))
           (line 1)
           (column 1)
           (offset 1)
  
negative.code: 
                (with (val (cond
                             ;; Parse hexadecimal digits
                             [(and (= char "#") (= (string/lower (string/char-at str (succ offset))) "x"))
                              (consume!)
                              (consume!)
                              (with (res (parse-base "hexadecimal" hex-digit? 16))
                                (when negative (set! res (- 0 res)))
                                res)]
                             ;; Parse binary digits
                             [(and (= char "#") (= (string/lower (string/char-at str (succ offset))) "b"))
                              (consume!)
                              (consume!)
                              (with (res (parse-base "binary" bin-digit? 2))
                                (when negative (set! res (- 0 res)))
                                res)]
                             ;; Other leading "#"s are illegal
                             [(and (= char "#") (terminator? (string/lower (string/char-at str (succ offset)))))
                              (logger/do-node-error! logger
                                "Expected hexadecimal (#x) or binary (#b) digit."
                                (range (position))
                                "The '#' character is used for various number representations, such as binary
                                 and hexadecimal digits.
  
                                 If you're looking for the '#' function, this has been replaced with 'n'. We
                                 apologise for the inconvenience."
                                (range (position)) "# must be followed by x or b")]
                             [(= char "#")
                              (consume!)
                              (logger/do-node-error! logger
                                "Expected hexadecimal (#x) or binary (#b) digit specifier."
                                (range (position))
                                "The '#' character is used for various number representations, namely binary
                                 and hexadecimal digits."
                                (range (position)) "# must be followed by x or b")]
                             [true
                              ;; Parse leading digits
                              (while (between? (string/char-at str (succ offset))  "0" "9")
                                (consume!))
  
                              ;; Consume decimal places
                              (when (= (string/char-at str (succ offset)) ".")
                                (consume!)
                                (while (between? (string/char-at str (succ offset))  "0" "9")
                                  (consume!)))
  
                              ;; Consume exponent
                              (set! char (string/char-at str (succ offset)))
                              (when (or (= char "e") (= char "E"))
                                (consume!)
                                (set! char (string/char-at str (succ offset)))
  
                                ;; Gobble positive/negative bit
                                (when (or (= char "-") (= char "+")) (consume!))
  
                                ;; And exponent digits
                                (while (between? (string/char-at str (succ offset)) "0" "9")
                                  (consume!)))
  
                              (string->number (string/sub str (.> start :offset) offset))]))
                  (append-with! {:tag "number" :value val} start)
  
                  ;; Ensure the next character is a terminator of some sort, otherwise we'd allow things like 0x2-2
  