diff --git a/Changelog b/Changelog
index 66a24b4..6fc5245 100644
--- a/Changelog
+++ b/Changelog
@@ -2,6 +2,7 @@
   Changed all macros to use DOUBLE_CONVERSION_ as prefix.
   Renamed ALLOW_CASE_INSENSIBILITY to ALLOW_CASE_INSENSITIVITY,
     the old name is still available but officially deprecated.
+  Created and exposed new intermediate function StrtodTrimmed().
 
 2019-05-25:
   Fix `0x` for string->double conversion when Hex Floats are allowed.
diff --git a/double-conversion/strtod.cc b/double-conversion/strtod.cc
index 7feb374..d0bb7f7 100644
--- a/double-conversion/strtod.cc
+++ b/double-conversion/strtod.cc
@@ -446,18 +446,31 @@
   return false;
 }
 
-double Strtod(Vector<const char> buffer, int exponent) {
-  char copy_buffer[kMaxSignificantDecimalDigits];
-  Vector<const char> trimmed;
-  int updated_exponent;
-  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
-             &trimmed, &updated_exponent);
-  exponent = updated_exponent;
+static bool IsDigit(const char d) {
+  return ('0' <= d) && (d <= '9');
+}
 
+static bool IsNonZeroDigit(const char d) {
+  return ('1' <= d) && (d <= '9');
+}
+
+static bool AssertTrimmedDigits(const Vector<const char>& buffer) {
+  for(int i = 0; i < buffer.length(); ++i) {
+    if(!IsDigit(buffer[i])) {
+      return false;
+    }
+  }
+  return (buffer.length() == 0) || (IsNonZeroDigit(buffer[0]) && IsNonZeroDigit(buffer[buffer.length()-1]));
+}
+
+double StrtodTrimmed(Vector<const char> trimmed, int exponent) {
+  DOUBLE_CONVERSION_ASSERT(trimmed.length() <= kMaxSignificantDecimalDigits);
+  DOUBLE_CONVERSION_ASSERT(AssertTrimmedDigits(trimmed));
   double guess;
-  bool is_correct = ComputeGuess(trimmed, exponent, &guess);
-  if (is_correct) return guess;
-
+  const bool is_correct = ComputeGuess(trimmed, exponent, &guess);
+  if (is_correct) {
+    return guess;
+  }
   DiyFp upper_boundary = Double(guess).UpperBoundary();
   int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
   if (comparison < 0) {
@@ -472,6 +485,15 @@
   }
 }
 
+double Strtod(Vector<const char> buffer, int exponent) {
+  char copy_buffer[kMaxSignificantDecimalDigits];
+  Vector<const char> trimmed;
+  int updated_exponent;
+  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
+             &trimmed, &updated_exponent);
+  return StrtodTrimmed(trimmed, updated_exponent);
+}
+
 static float SanitizedDoubletof(double d) {
   DOUBLE_CONVERSION_ASSERT(d >= 0.0);
   // ASAN has a sanitize check that disallows casting doubles to floats if
diff --git a/double-conversion/strtod.h b/double-conversion/strtod.h
index ed0293b..ff0ee47 100644
--- a/double-conversion/strtod.h
+++ b/double-conversion/strtod.h
@@ -40,6 +40,11 @@
 // contain a dot or a sign. It must not start with '0', and must not be empty.
 float Strtof(Vector<const char> buffer, int exponent);
 
+// For special use cases, the heart of the Strtod() function is also available
+// separately, it assumes that 'trimmed' is as produced by TrimAndCut(), i.e.
+// no leading or trailing zeros, also no lone zero, and not 'too many' digits.
+double StrtodTrimmed(Vector<const char> trimmed, int exponent);
+
 }  // namespace double_conversion
 
 #endif  // DOUBLE_CONVERSION_STRTOD_H_
diff --git a/test/cctest/test-strtod.cc b/test/cctest/test-strtod.cc
index 1a6ac3b..62badbd 100644
--- a/test/cctest/test-strtod.cc
+++ b/test/cctest/test-strtod.cc
@@ -21,6 +21,11 @@
 }
 
 
+static double StrtodTrimmedChar(const char* str, int exponent) {
+  return StrtodTrimmed(StringToVector(str), exponent);
+}
+
+
 static float StrtofChar(const char* str, int exponent) {
   return Strtof(StringToVector(str), exponent);
 }
@@ -350,6 +355,276 @@
 }
 
 
+TEST(StrtodTrimmed) {
+  Vector<const char> vector;
+
+  vector = StringToVector("1");
+  CHECK_EQ(1.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(10.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(100.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(1e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(1e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(1e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(1e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(1e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(1e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(1e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(1e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(1e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(1e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(1e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(1e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(1e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(1e-39, StrtodTrimmed(vector, -39));
+
+  vector = StringToVector("2");
+  CHECK_EQ(2.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(20.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(200.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(2e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(2e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(2e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(2e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(2e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(2e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(2e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(2e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(2e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(2e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(2e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(2e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(2e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(2e-39, StrtodTrimmed(vector, -39));
+
+  vector = StringToVector("9");
+  CHECK_EQ(9.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(90.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(900.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(9e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(9e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(9e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(9e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(9e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(9e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(9e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(9e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(9e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(9e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(9e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(9e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(9e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(9e-39, StrtodTrimmed(vector, -39));
+
+  vector = StringToVector("12345");
+  CHECK_EQ(12345.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(123450.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(1234500.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(12345e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(12345e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(12345e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(12345e30, StrtodTrimmed(vector, 30));
+  CHECK_EQ(12345e31, StrtodTrimmed(vector, 31));
+  CHECK_EQ(12345e32, StrtodTrimmed(vector, 32));
+  CHECK_EQ(12345e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(12345e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(12345e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(12345e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(12345e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(12345e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(12345e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(12345e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(12345e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(12345e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(12345e-39, StrtodTrimmed(vector, -39));
+
+  vector = StringToVector("12345678901234");
+  CHECK_EQ(12345678901234.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(123456789012340.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(1234567890123400.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(12345678901234e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(12345678901234e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(12345678901234e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(12345678901234e30, StrtodTrimmed(vector, 30));
+  CHECK_EQ(12345678901234e31, StrtodTrimmed(vector, 31));
+  CHECK_EQ(12345678901234e32, StrtodTrimmed(vector, 32));
+  CHECK_EQ(12345678901234e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(12345678901234e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(12345678901234e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(12345678901234e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(12345678901234e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(12345678901234e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(12345678901234e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(12345678901234e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(12345678901234e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(12345678901234e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(12345678901234e-39, StrtodTrimmed(vector, -39));
+
+  vector = StringToVector("123456789012345");
+  CHECK_EQ(123456789012345.0, StrtodTrimmed(vector, 0));
+  CHECK_EQ(1234567890123450.0, StrtodTrimmed(vector, 1));
+  CHECK_EQ(12345678901234500.0, StrtodTrimmed(vector, 2));
+  CHECK_EQ(123456789012345e20, StrtodTrimmed(vector, 20));
+  CHECK_EQ(123456789012345e22, StrtodTrimmed(vector, 22));
+  CHECK_EQ(123456789012345e23, StrtodTrimmed(vector, 23));
+  CHECK_EQ(123456789012345e35, StrtodTrimmed(vector, 35));
+  CHECK_EQ(123456789012345e36, StrtodTrimmed(vector, 36));
+  CHECK_EQ(123456789012345e37, StrtodTrimmed(vector, 37));
+  CHECK_EQ(123456789012345e39, StrtodTrimmed(vector, 39));
+  CHECK_EQ(123456789012345e-1, StrtodTrimmed(vector, -1));
+  CHECK_EQ(123456789012345e-2, StrtodTrimmed(vector, -2));
+  CHECK_EQ(123456789012345e-5, StrtodTrimmed(vector, -5));
+  CHECK_EQ(123456789012345e-20, StrtodTrimmed(vector, -20));
+  CHECK_EQ(123456789012345e-22, StrtodTrimmed(vector, -22));
+  CHECK_EQ(123456789012345e-23, StrtodTrimmed(vector, -23));
+  CHECK_EQ(123456789012345e-25, StrtodTrimmed(vector, -25));
+  CHECK_EQ(123456789012345e-39, StrtodTrimmed(vector, -39));
+
+  CHECK_EQ(0.0, StrtodTrimmedChar("", 1324));
+  CHECK_EQ(0.0, StrtodTrimmedChar("2", -324));
+  CHECK_EQ(4e-324, StrtodTrimmedChar("3", -324));
+  // It would be more readable to put non-zero literals on the left side (i.e.
+  //   CHECK_EQ(1e-325, StrtodChar("1", -325))), but then Gcc complains that
+  // they are truncated to zero.
+  CHECK_EQ(0.0, StrtodTrimmedChar("1", -325));
+  CHECK_EQ(0.0, StrtodTrimmedChar("1", -325));
+
+  // It would be more readable to put the literals (and not Double::Infinity())
+  // on the left side (i.e. CHECK_EQ(1e309, StrtodChar("1", 309))), but then Gcc
+  // complains that the floating constant exceeds range of 'double'.
+  CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("1", 309));
+  CHECK_EQ(1e308, StrtodTrimmedChar("1", 308));
+  CHECK_EQ(1234e305, StrtodTrimmedChar("1234", 305));
+  CHECK_EQ(1234e304, StrtodTrimmedChar("1234", 304));
+  CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("18", 307));
+  CHECK_EQ(17e307, StrtodTrimmedChar("17", 307));
+
+  CHECK_EQ(1.7976931348623157E+308, StrtodTrimmedChar("17976931348623157", 292));
+  CHECK_EQ(1.7976931348623158E+308, StrtodTrimmedChar("17976931348623158", 292));
+  CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("17976931348623159", 292));
+
+  // The following number is the result of 89255.0/1e-22. Both floating-point
+  // numbers can be accurately represented with doubles. However on Linux,x86
+  // the floating-point stack is set to 80bits and the double-rounding
+  // introduces an error.
+  CHECK_EQ(89255e-22, StrtodTrimmedChar("89255", -22));
+
+  // Some random values.
+  CHECK_EQ(358416272e-33, StrtodTrimmedChar("358416272", -33));
+  CHECK_EQ(104110013277974872254e-225,
+           StrtodTrimmedChar("104110013277974872254", -225));
+
+  CHECK_EQ(123456789e108, StrtodTrimmedChar("123456789", 108));
+  CHECK_EQ(123456789e109, StrtodTrimmedChar("123456789", 109));
+  CHECK_EQ(123456789e110, StrtodTrimmedChar("123456789", 110));
+  CHECK_EQ(123456789e111, StrtodTrimmedChar("123456789", 111));
+  CHECK_EQ(123456789e112, StrtodTrimmedChar("123456789", 112));
+  CHECK_EQ(123456789e113, StrtodTrimmedChar("123456789", 113));
+  CHECK_EQ(123456789e114, StrtodTrimmedChar("123456789", 114));
+  CHECK_EQ(123456789e115, StrtodTrimmedChar("123456789", 115));
+  CHECK_EQ(1234567890123456789012345e108,
+           StrtodTrimmedChar("1234567890123456789012345", 108));
+  CHECK_EQ(1234567890123456789012345e109,
+           StrtodTrimmedChar("1234567890123456789012345", 109));
+  CHECK_EQ(1234567890123456789012345e110,
+           StrtodTrimmedChar("1234567890123456789012345", 110));
+  CHECK_EQ(1234567890123456789012345e111,
+           StrtodTrimmedChar("1234567890123456789012345", 111));
+  CHECK_EQ(1234567890123456789012345e112,
+           StrtodTrimmedChar("1234567890123456789012345", 112));
+  CHECK_EQ(1234567890123456789012345e113,
+           StrtodTrimmedChar("1234567890123456789012345", 113));
+  CHECK_EQ(1234567890123456789012345e114,
+           StrtodTrimmedChar("1234567890123456789012345", 114));
+  CHECK_EQ(1234567890123456789012345e115,
+           StrtodTrimmedChar("1234567890123456789012345", 115));
+
+  CHECK_EQ(1234567890123456789052345e108,
+           StrtodTrimmedChar("1234567890123456789052345", 108));
+  CHECK_EQ(1234567890123456789052345e109,
+           StrtodTrimmedChar("1234567890123456789052345", 109));
+  CHECK_EQ(1234567890123456789052345e110,
+           StrtodTrimmedChar("1234567890123456789052345", 110));
+  CHECK_EQ(1234567890123456789052345e111,
+           StrtodTrimmedChar("1234567890123456789052345", 111));
+  CHECK_EQ(1234567890123456789052345e112,
+           StrtodTrimmedChar("1234567890123456789052345", 112));
+  CHECK_EQ(1234567890123456789052345e113,
+           StrtodTrimmedChar("1234567890123456789052345", 113));
+  CHECK_EQ(1234567890123456789052345e114,
+           StrtodTrimmedChar("1234567890123456789052345", 114));
+  CHECK_EQ(1234567890123456789052345e115,
+           StrtodTrimmedChar("1234567890123456789052345", 115));
+
+  // Boundary cases. Boundaries themselves should round to even.
+  //
+  // 0x1FFFFFFFFFFFF * 2^3 = 72057594037927928
+  //                   next: 72057594037927936
+  //               boundary: 72057594037927932  should round up.
+  CHECK_EQ(72057594037927928.0, StrtodTrimmedChar("72057594037927928", 0));
+  CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("72057594037927936", 0));
+  CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("72057594037927932", 0));
+  CHECK_EQ(72057594037927928.0, StrtodTrimmedChar("7205759403792793199999", -5));
+  CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("7205759403792793200001", -5));
+
+  // 0x1FFFFFFFFFFFF * 2^10 = 9223372036854774784
+  //                    next: 9223372036854775808
+  //                boundary: 9223372036854775296 should round up.
+  CHECK_EQ(9223372036854774784.0, StrtodTrimmedChar("9223372036854774784", 0));
+  CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("9223372036854775808", 0));
+  CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("9223372036854775296", 0));
+  CHECK_EQ(9223372036854774784.0, StrtodTrimmedChar("922337203685477529599999", -5));
+  CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("922337203685477529600001", -5));
+
+  // 0x1FFFFFFFFFFFF * 2^50 = 10141204801825834086073718800384
+  //                    next: 10141204801825835211973625643008
+  //                boundary: 10141204801825834649023672221696 should round up.
+  CHECK_EQ(10141204801825834086073718800384.0,
+           StrtodTrimmedChar("10141204801825834086073718800384", 0));
+  CHECK_EQ(10141204801825835211973625643008.0,
+           StrtodTrimmedChar("10141204801825835211973625643008", 0));
+  CHECK_EQ(10141204801825835211973625643008.0,
+           StrtodTrimmedChar("10141204801825834649023672221696", 0));
+  CHECK_EQ(10141204801825834086073718800384.0,
+           StrtodTrimmedChar("1014120480182583464902367222169599999", -5));
+  CHECK_EQ(10141204801825835211973625643008.0,
+           StrtodTrimmedChar("1014120480182583464902367222169600001", -5));
+
+  // 0x1FFFFFFFFFFFF * 2^99 = 5708990770823838890407843763683279797179383808
+  //                    next: 5708990770823839524233143877797980545530986496
+  //                boundary: 5708990770823839207320493820740630171355185152
+  // The boundary should round up.
+  CHECK_EQ(5708990770823838890407843763683279797179383808.0,
+           StrtodTrimmedChar("5708990770823838890407843763683279797179383808", 0));
+  CHECK_EQ(5708990770823839524233143877797980545530986496.0,
+           StrtodTrimmedChar("5708990770823839524233143877797980545530986496", 0));
+  CHECK_EQ(5708990770823839524233143877797980545530986496.0,
+           StrtodTrimmedChar("5708990770823839207320493820740630171355185152", 0));
+  CHECK_EQ(5708990770823838890407843763683279797179383808.0,
+           StrtodTrimmedChar("5708990770823839207320493820740630171355185151999", -3));
+  CHECK_EQ(5708990770823839524233143877797980545530986496.0,
+           StrtodTrimmedChar("5708990770823839207320493820740630171355185152001", -3));
+
+  // The following test-cases got some public attention in early 2011 when they
+  // sent Java and PHP into an infinite loop.
+  CHECK_EQ(2.225073858507201e-308, StrtodTrimmedChar("22250738585072011", -324));
+  CHECK_EQ(2.22507385850720138309e-308,
+           StrtodTrimmedChar("22250738585072011360574097967091319759348195463516456480"
+                      "23426109724822222021076945516529523908135087914149158913"
+                      "03962110687008643869459464552765720740782062174337998814"
+                      "10632673292535522868813721490129811224514518898490572223"
+                      "07285255133155755015914397476397983411801999323962548289"
+                      "01710708185069063066665599493827577257201576306269066333"
+                      "26475653000092458883164330377797918696120494973903778297"
+                      "04905051080609940730262937128958950003583799967207254304"
+                      "36028407889577179615094551674824347103070260914462157228"
+                      "98802581825451803257070188608721131280795122334262883686"
+                      "22321503775666622503982534335974568884423900265498198385"
+                      "48794829220689472168983109969836584681402285424333066033"
+                      "98508864458040010349339704275671864433837704860378616227"
+                      "71738545623065874679014086723327636718751", -1076));
+}
+
+
 TEST(Strtof) {
   Vector<const char> vector;