diff --git a/README.md b/README.md
index 5418ed6..1eb7a14 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ SwiftUI-Version
 
 ![Badge](https://img.shields.io/badge/swift-white.svg?style=flat-square&logo=Swift)
 ![Badge](https://img.shields.io/badge/SwiftUI-001b87.svg?style=flat-square&logo=Swift&logoColor=black)
-![Badge - Version](https://img.shields.io/badge/Version-0.7.0-1177AA?style=flat-square)
+![Badge - Version](https://img.shields.io/badge/Version-0.7.1-1177AA?style=flat-square)
 ![Badge - Swift Package Manager](https://img.shields.io/badge/SPM-compatible-orange?style=flat-square)
 ![Badge - Platform](https://img.shields.io/badge/platform-mac_12|ios_15|watchos_8|tvos_15-yellow?style=flat-square)
 ![Badge - License](https://img.shields.io/badge/license-MIT-black?style=flat-square)  
@@ -171,6 +171,6 @@ Once you have your Swift package set up, adding AnimateNumberText as a dependenc
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/swift-man/AnimateNumberText.git", from: "0.7.0")
+    .package(url: "https://github.com/swift-man/AnimateNumberText.git", from: "0.7.1")
 ]
 ```
diff --git a/Sources/AnimateNumberText/AnimateNumberText.docc/AnimateNumberText.md b/Sources/AnimateNumberText/AnimateNumberText.docc/AnimateNumberText.md
index 1fb1fdb..74991f6 100644
--- a/Sources/AnimateNumberText/AnimateNumberText.docc/AnimateNumberText.md
+++ b/Sources/AnimateNumberText/AnimateNumberText.docc/AnimateNumberText.md
@@ -14,7 +14,7 @@ Add AnimateNumberText to your Swift package dependencies.
 
 ```swift
 dependencies: [
-  .package(url: "https://github.com/swift-man/AnimateNumberText.git", from: "0.7.0")
+  .package(url: "https://github.com/swift-man/AnimateNumberText.git", from: "0.7.1")
 ]
 ```
 
diff --git a/Sources/AnimateNumberText/Private/TextType.swift b/Sources/AnimateNumberText/Private/TextType.swift
index f9de879..0f82f9c 100644
--- a/Sources/AnimateNumberText/Private/TextType.swift
+++ b/Sources/AnimateNumberText/Private/TextType.swift
@@ -93,6 +93,18 @@ extension Array where Element == TextColumn {
     filter(\.value.isNumber).count
   }
 
+  func digitOrdinalsByIndex() -> [Int: Int] {
+    var ordinalsByIndex: [Int: Int] = [:]
+    var digitOrdinal = 0
+
+    for index in indices where self[index].value.isNumber {
+      ordinalsByIndex[index] = digitOrdinal
+      digitOrdinal += 1
+    }
+
+    return ordinalsByIndex
+  }
+
   func preservingReelPositions(_ positions: [UUID: Double]) -> [UUID: Double] {
     var nextPositions: [UUID: Double] = [:]
 
@@ -115,22 +127,50 @@ extension Array where Element == TextColumn {
     return nextPositions
   }
 
+  @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+  func reelPositions(updatingTo characters: [Character],
+                     animation: AnimateNumberTextAnimation,
+                     currentPositions: [UUID: Double]) -> [UUID: Double] {
+    let digitOrdinals = digitOrdinalsByIndex()
+    var nextPositions = preservingReelPositions(currentPositions)
+
+    for (index, character) in characters.enumerated() {
+      let targetValue = TextType(character)
+      guard canAnimateDigitChange(to: targetValue, index: index),
+            let digit = targetValue.digitValue,
+            let digitOrdinal = digitOrdinals[index] else {
+        continue
+      }
+
+      let column = self[index]
+      let currentPosition = nextPositions[column.id]
+        ?? Double(column.value.digitValue ?? digit)
+      nextPositions[column.id] = animation.reelTargetPosition(from: currentPosition,
+                                                              to: digit,
+                                                              ordinal: digitOrdinal)
+    }
+
+    return nextPositions
+  }
+
   func canAnimateDigitChange(to value: Character, index: Int) -> Bool {
+    canAnimateDigitChange(to: TextType(value), index: index)
+  }
+
+  func canAnimateDigitChange(to value: TextType, index: Int) -> Bool {
     guard indices.contains(index) else { return false }
 
-    return self[index].value.isNumber && TextType(value).isNumber
+    return self[index].value.isNumber && value.isNumber
   }
 
   func needsUpdate(to value: Character, index: Int) -> Bool {
-    guard indices.contains(index) else { return false }
-
-    return self[index].value != TextType(value)
+    needsUpdate(to: TextType(value), index: index)
   }
 
-  func digitOrdinal(at index: Int) -> Int? {
-    guard indices.contains(index), self[index].value.isNumber else { return nil }
+  func needsUpdate(to value: TextType, index: Int) -> Bool {
+    guard indices.contains(index) else { return false }
 
-    return self[..<index].filter(\.value.isNumber).count
+    return self[index].value != value
   }
 
   mutating func set(_ value: Character, index: Int) {
diff --git a/Sources/AnimateNumberText/Public/AnimateNumberText.swift b/Sources/AnimateNumberText/Public/AnimateNumberText.swift
index e0e0222..a7e7246 100644
--- a/Sources/AnimateNumberText/Public/AnimateNumberText.swift
+++ b/Sources/AnimateNumberText/Public/AnimateNumberText.swift
@@ -254,11 +254,12 @@ public struct AnimateNumberText: View {
   @MainActor
   private func settingSmoothAnimationRange(_ characters: [Character]) {
     let digitCount = animationRange.digitCount
+    let digitOrdinals = animationRange.digitOrdinalsByIndex()
 
     for (index, value) in characters.enumerated()
       where animationRange.needsUpdate(to: value, index: index)
         && animationRange.canAnimateDigitChange(to: value, index: index) {
-      let digitOrdinal = animationRange.digitOrdinal(at: index) ?? index
+      let digitOrdinal = digitOrdinals[index] ?? index
 
       withAnimation(animation.digitAnimation(at: digitOrdinal,
                                              digitCount: digitCount)) {
@@ -272,23 +273,12 @@ public struct AnimateNumberText: View {
   @MainActor
   private func settingReelAnimationRange(_ characters: [Character]) {
     synchronizeReelPositions()
-    var nextPositions = reelPositions
+    let nextPositions = animationRange.reelPositions(updatingTo: characters,
+                                                     animation: animation,
+                                                     currentPositions: reelPositions)
 
     for (index, value) in characters.enumerated()
       where animationRange.canAnimateDigitChange(to: value, index: index) {
-      guard let digit = TextType(value).digitValue,
-            let digitOrdinal = animationRange.digitOrdinal(at: index) else {
-        continue
-      }
-
-      let columnID = animationRange[index].id
-      let currentPosition = reelPositions[columnID]
-        ?? Double(animationRange[index].value.digitValue ?? digit)
-      let targetPosition = animation.reelTargetPosition(from: currentPosition,
-                                                        to: digit,
-                                                        ordinal: digitOrdinal)
-
-      nextPositions[columnID] = targetPosition
       animationRange.set(value, index: index)
     }
 
diff --git a/Tests/AnimateNumberTextTests/AnimateNumberTextTests.swift b/Tests/AnimateNumberTextTests/AnimateNumberTextTests.swift
index 068b619..d9f2729 100644
--- a/Tests/AnimateNumberTextTests/AnimateNumberTextTests.swift
+++ b/Tests/AnimateNumberTextTests/AnimateNumberTextTests.swift
@@ -277,7 +277,7 @@ struct AnimateNumberTextTests {
   }
 
   @Test
-  func digitOrdinalSkipsFormattedCharacters() {
+  func digitOrdinalsByIndexSkipsFormattedCharacters() {
     let columns = [
       TextColumn(value: .number(3)),
       TextColumn(value: .number(0)),
@@ -289,11 +289,12 @@ struct AnimateNumberTextTests {
       TextColumn(value: .string("s"))
     ]
 
-    #expect(columns.digitOrdinal(at: 0) == 0)
-    #expect(columns.digitOrdinal(at: 1) == 1)
-    #expect(columns.digitOrdinal(at: 2) == 2)
-    #expect(columns.digitOrdinal(at: 3) == nil)
-    #expect(columns.digitOrdinal(at: 4) == 3)
+    #expect(columns.digitOrdinalsByIndex() == [
+      0: 0,
+      1: 1,
+      2: 2,
+      4: 3
+    ])
   }
 
   @Test
@@ -390,4 +391,28 @@ struct AnimateNumberTextTests {
     #expect(animation.reelTargetPosition(from: 5, to: 5, ordinal: 0) == 15)
     #expect(animation.reelTargetPosition(from: 5, to: 5, ordinal: 1) == -5)
   }
+
+  @Test
+  func reelPositionsSpinUnchangedDigitsThroughUpdatePath() {
+    let columns = [
+      TextColumn(value: .number(3)),
+      TextColumn(value: .number(0)),
+      TextColumn(value: .number(1)),
+      TextColumn(value: .string(".")),
+      TextColumn(value: .number(9))
+    ]
+    let animation = AnimateNumberTextAnimation.reel(spinningDuration: 0.9,
+                                                    settleDuration: 0.25,
+                                                    revolutions: 1)
+    let currentPositions = columns.currentDigitPositions()
+
+    let nextPositions = columns.reelPositions(updatingTo: Swift.Array("301.9"),
+                                              animation: animation,
+                                              currentPositions: currentPositions)
+
+    #expect(nextPositions[columns[0].id] == 13)
+    #expect(nextPositions[columns[1].id] == -10)
+    #expect(nextPositions[columns[2].id] == 11)
+    #expect(nextPositions[columns[4].id] == -1)
+  }
 }