+ var MULTI = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/;
+
+ var GLYPH = /([\0-\u02FF\u0370-\u1DBF\u1E00-\u20CF\u2100-\uD7FF\uDC00-\uFE1F\uFE30-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF])([\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]*)/g;
+
+ function diffLerp(a, b, p) {
+ /** Interpolate between two strings based on edit operations
+
+ This interpolation algorithm applys a partial edit of one
+ string into the other. This produces nice looking results,
+ but can take a significant amount of time and memory to
+ compute the edits. It is not recommended for strings
+ longer than a few hundred characters.
+ */
+
+ // If given strings with astral codepoints or combining
+ // characters, split them into arrays of "glyphs" first,
+ // do the edit on the list of "glyphs", and rejoin them.
+ //
+ // This split is not perfect for all languages, but at least
+ // it won't create invalid surrogate pairs or orphaned
+ // combining characters.
+ if (a.match && a.match(MULTI) || b.match && b.match(MULTI)) {
+ var ca = a.match(GLYPH) || [];
+ var cb = b.match(GLYPH) || [];
+ return diffLerp(ca, cb, p).join("");
+ }
+
+ // The edit path works from the string end, forwards, because
+ // that's how Levenshtein edits work. To match LTR reading
+ // direction (and the behavior of fastLerp), swap the strings
+ // and invert the parameter when editing.
+ var edits = diff(b, a);
+ var partial = edits.slice(0, Math.round((1 - p) * edits.length));
+ return patch(partial, b);
+ }
+
+ var NUMBERS = /(-?\d+(?:\.\d+)?)/g;
+
+ function areNumericTwins(a, b) {
+ /** Check if a and b differ only in numerals
+
+ A leading "-" counts as part of numbers; a leading "+"
+ does not. Numbers may contain a single ".", but no other
+ floating point syntax.
+ */
+ return a.replace(NUMBERS, "0") === b.replace(NUMBERS, "0");
+ }
+
+ function nlerp(a, b, p) {
+ return a + (b - a) * p;
+ }
+
+ function numericLerp(a, b, p) {
+ /** Interpolate numerically between two strings containing numbers
+
+ Numbers may have a leading "-" and a single "." to mark
+ the decimal point, but something must be after the ".".
+ If both of the numbers in a pair are integers, the result
+ is clamped to an integer.
+
+ For example, numericLerp("0.0", "100", 0.123) === "12.3"
+ because the "." in "0.0" is interpreted as a decimal
+ point. But numericLerp("0.", "100.", 0.123) === "12."
+ because the strings are interpreted as integers followed
+ by a full stop.
+
+ Calling this functions on strings that differ in more than
+ numerals gives undefined results.
+ */
+ var aParts = a.split(NUMBERS);
+ var bParts = b.split(NUMBERS);
+ for (var i = 1; i < aParts.length; i += 2) {
+ var part = nlerp(+aParts[i], +bParts[i], p);
+ if (aParts[i].indexOf(".") === -1 && bParts[i].indexOf(".") === -1)
+ part = Math.round(part);
+ aParts[i] = part.toString();
+ }
+ return aParts.join("");