                             {
                                 try self.completeActiveParameter()
                                 
-                                self.activeParameterStartIndex = index
-                                self.activeParameterStringLength = 1
-                                self.lookingForParameter = false
+                                self.beginParameterAtIndex(index: index)
                                 self.seenPeriod = true
                             }
                             else

                        
                        switch character
                        {
                        case "Z", "z":
                            resultTokens.append(PathToken.close)
                            parseState = .lookingForOperand
                        case "l", "L", "H", "h", "Q", "q", "V", "v", "C", "c", "T", "t", "S", "s", "A", "a", "m", "M":
                            self.tokenBuilder = TokenBuilder(pathString: pathString, operand: character)
                            parseState = .buildingToken
                        case " ", "\t", "\n", "\r", ",":
                            parseState = .lookingForOperand
                        default:
                            
                            guard newToken.impliesSubsequentOperand else
                            {
                                throw PathToken.FailureReason.missingMoveAtStart
                            }
                            self.tokenBuilder = TokenBuilder(pathString: pathString, operand: newToken.impliedSubsequentOperand)
                            parseState = .buildingToken
                        }
                        
                    }
                    else

                case .lookingForFirstOperand:
                    switch character
                    {
                        case " ", "\t", "\n", "\r": // possible leading whitespace
                            break
                        case "m", "M":
                            self.parseState = .buildingToken
                        case "l", "L", "H", "h", "Q", "q", "V", "v", "C", "c", "T", "t", "S", "s", "A", "a":
                            throw PathToken.FailureReason.missingMoveAtStart
                        default:
                            throw PathToken.FailureReason.unexpectedCharacter(badCharacter: character, offset: self.pathString.distance(from: self.pathString.startIndex, to: index))
                    }
                    
                case .lookingForOperand:
                    switch character
                    {
                        case " ", "\t", "\n", "\r", ",": // possible operand separators
                            break
                        case "z", "Z":
                            resultTokens.append(PathToken.close)
                        case "l", "L", "H", "h", "Q", "q", "V", "v", "C", "c", "T", "t", "S", "s", "A", "a", "m", "M":
                            self.tokenBuilder = TokenBuilder(pathString: pathString, operand: character)
                            parseState = .buildingToken
                        case "-", "+", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".": // an implied
                            guard  let mostRecentToken = self.resultTokens.last else
                            {
                                throw PathToken.FailureReason.missingMoveAtStart
                            }
                            
                            guard mostRecentToken.impliesSubsequentOperand else
                            {
                                throw PathToken.FailureReason.missingMoveAtStart
                            }
                            
                            self.tokenBuilder = TokenBuilder(pathString: pathString, operand: mostRecentToken.impliedSubsequentOperand)
                            parseState = .buildingToken
                            let _ = try self.tokenBuilder.testCompletionCharacter(character: character, atIndex: index) // I know it's not completed
                            
                            
                        default:
                            let failureReason = PathToken.FailureReason.unexpectedCharacter(badCharacter: character, offset: self.pathString.distance(from: self.pathString.startIndex, to: index))
                            resultTokens.append(PathToken.bad(character, failureReason))
                            throw failureReason
                    }
                    
                case .buildingToken:
