rsuite 5.76.2 → 6.0.0-canary-20250103

package/esm/MaskedInput/TextMask.js

@@ -1,10 +1,7 @@
 'use client';
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["mask", "guide", "placeholderChar", "value", "showMask", "pipe", "render", "onChange"];
 import React, { useCallback, useEffect, useRef } from 'react';
 import omit from 'lodash/omit';
-import PropTypes from 'prop-types';
 import createTextMaskInputElement from "./createTextMaskInputElement.js";
 import { mergeRefs } from "../internals/utils/index.js";
 
@@ -12,60 +9,49 @@ import { mergeRefs } from "../internals/utils/index.js";
  * https://github.com/text-mask/text-mask/blob/master/componentDocumentation.md#guide
  */
 
-var defaultRender = function defaultRender(ref, props) {
-  return /*#__PURE__*/React.createElement("input", _extends({
-    ref: ref
-  }, props));
-};
+const defaultRender = (ref, props) => /*#__PURE__*/React.createElement("input", _extends({
+  ref: ref
+}, props));
 
 /**
  * The `TextMask` component is used to format the user input data.
  * @see https://rsuitejs.com/components/input/#masked-input
  */
-var TextMask = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var mask = props.mask,
-    _props$guide = props.guide,
-    guide = _props$guide === void 0 ? true : _props$guide,
-    placeholderChar = props.placeholderChar,
-    value = props.value,
-    showMask = props.showMask,
-    pipe = props.pipe,
-    _props$render = props.render,
-    render = _props$render === void 0 ? defaultRender : _props$render,
-    onChange = props.onChange,
-    rest = _objectWithoutPropertiesLoose(props, _excluded);
-  var inputRef = useRef(null);
-  var textMaskInputElement = useRef();
-  var initTextMask = useCallback(function () {
+const TextMask = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    mask,
+    guide = true,
+    placeholderChar,
+    value,
+    showMask,
+    pipe,
+    render = defaultRender,
+    onChange,
+    ...rest
+  } = props;
+  const inputRef = useRef(null);
+  const textMaskInputElement = useRef();
+  const initTextMask = useCallback(() => {
     var _textMaskInputElement;
-    textMaskInputElement.current = createTextMaskInputElement(_extends({
-      inputElement: inputRef.current
-    }, props));
+    textMaskInputElement.current = createTextMaskInputElement({
+      inputElement: inputRef.current,
+      ...props
+    });
     (_textMaskInputElement = textMaskInputElement.current) === null || _textMaskInputElement === void 0 || _textMaskInputElement.update(value);
   }, [props, value]);
-  var handleChange = useCallback(function (event) {
+  const handleChange = useCallback(event => {
     var _textMaskInputElement2;
     (_textMaskInputElement2 = textMaskInputElement.current) === null || _textMaskInputElement2 === void 0 || _textMaskInputElement2.update();
     onChange === null || onChange === void 0 || onChange(event);
   }, [onChange]);
-  useEffect(function () {
+  useEffect(() => {
     initTextMask();
   }, [guide, placeholderChar, showMask, pipe, mask, value, initTextMask]);
-  return render(mergeRefs(inputRef, ref), _extends({
+  return render(mergeRefs(inputRef, ref), {
     onChange: handleChange,
-    defaultValue: value
-  }, omit(rest, ['keepCharPositions'])));
+    defaultValue: value,
+    ...omit(rest, ['keepCharPositions'])
+  });
 });
 TextMask.displayName = 'TextMask';
-TextMask.propTypes = {
-  render: PropTypes.func,
-  onChange: PropTypes.func,
-  mask: PropTypes.oneOfType([PropTypes.array, PropTypes.func, PropTypes.bool]).isRequired,
-  guide: PropTypes.bool,
-  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-  pipe: PropTypes.func,
-  placeholderChar: PropTypes.string,
-  keepCharPositions: PropTypes.bool,
-  showMask: PropTypes.bool
-};
 export default TextMask;

package/esm/MaskedInput/adjustCaretPosition.js

@@ -1,40 +1,37 @@
 'use client';
-var defaultArray = [];
-var emptyString = '';
+const defaultArray = [];
+const emptyString = '';
 export default function adjustCaretPosition(_ref) {
-  var _ref$previousConforme = _ref.previousConformedValue,
-    previousConformedValue = _ref$previousConforme === void 0 ? emptyString : _ref$previousConforme,
-    _ref$previousPlacehol = _ref.previousPlaceholder,
-    previousPlaceholder = _ref$previousPlacehol === void 0 ? emptyString : _ref$previousPlacehol,
-    _ref$currentCaretPosi = _ref.currentCaretPosition,
-    currentCaretPosition = _ref$currentCaretPosi === void 0 ? 0 : _ref$currentCaretPosi,
-    conformedValue = _ref.conformedValue,
-    rawValue = _ref.rawValue,
-    placeholderChar = _ref.placeholderChar,
-    placeholder = _ref.placeholder,
-    _ref$indexesOfPipedCh = _ref.indexesOfPipedChars,
-    indexesOfPipedChars = _ref$indexesOfPipedCh === void 0 ? defaultArray : _ref$indexesOfPipedCh,
-    _ref$caretTrapIndexes = _ref.caretTrapIndexes,
-    caretTrapIndexes = _ref$caretTrapIndexes === void 0 ? defaultArray : _ref$caretTrapIndexes;
+  let {
+    previousConformedValue = emptyString,
+    previousPlaceholder = emptyString,
+    currentCaretPosition = 0,
+    conformedValue,
+    rawValue,
+    placeholderChar,
+    placeholder,
+    indexesOfPipedChars = defaultArray,
+    caretTrapIndexes = defaultArray
+  } = _ref;
   if (currentCaretPosition === 0 || !rawValue.length) {
     return 0;
   }
 
   // Store lengths for faster performance?
-  var rawValueLength = rawValue.length;
-  var previousConformedValueLength = previousConformedValue.length;
-  var placeholderLength = placeholder.length;
-  var conformedValueLength = conformedValue.length;
+  const rawValueLength = rawValue.length;
+  const previousConformedValueLength = previousConformedValue.length;
+  const placeholderLength = placeholder.length;
+  const conformedValueLength = conformedValue.length;
 
   // This tells us how long the edit is. If user modified input from `(2__)` to `(243__)`,
   // we know the user in this instance pasted two characters
-  var editLength = rawValueLength - previousConformedValueLength;
+  const editLength = rawValueLength - previousConformedValueLength;
 
   // If the edit length is positive, that means the user is adding characters, not deleting.
-  var isAddition = editLength > 0;
+  const isAddition = editLength > 0;
 
   // This is the first raw value the user entered that needs to be conformed to mask
-  var isFirstRawValue = previousConformedValueLength === 0;
+  const isFirstRawValue = previousConformedValueLength === 0;
 
   // A partial multi-character edit happens when the user makes a partial selection in their
   // input and edits that selection. That is going from `(123) 432-4348` to `() 432-4348` by
@@ -42,7 +39,7 @@ export default function adjustCaretPosition(_ref) {
   //
   // Such cases can also happen when the user presses the backspace while holding down the ALT
   // key.
-  var isPartialMultiCharEdit = editLength > 1 && !isFirstRawValue;
+  const isPartialMultiCharEdit = editLength > 1 && !isFirstRawValue;
 
   // This algorithm doesn't support all cases of multi-character edits, so we just return
   // the current caret position.
@@ -56,10 +53,10 @@ export default function adjustCaretPosition(_ref) {
   // `f` so the `rawValue` becomes (1f__), the new `conformedValue` would be (1__), which is the
   // same as the original `previousConformedValue`. We handle this case differently for caret
   // positioning.
-  var possiblyHasRejectedChar = isAddition && (previousConformedValue === conformedValue || conformedValue === placeholder);
-  var startingSearchIndex = 0;
-  var trackRightCharacter;
-  var targetChar;
+  const possiblyHasRejectedChar = isAddition && (previousConformedValue === conformedValue || conformedValue === placeholder);
+  let startingSearchIndex = 0;
+  let trackRightCharacter;
+  let targetChar;
   if (possiblyHasRejectedChar) {
     startingSearchIndex = currentCaretPosition - editLength;
   } else {
@@ -71,17 +68,15 @@ export default function adjustCaretPosition(_ref) {
 
     // First, we need to normalize the inputs so that letter capitalization between raw input and
     // conformed input wouldn't matter.
-    var normalizedConformedValue = conformedValue.toLowerCase();
-    var normalizedRawValue = rawValue.toLowerCase();
+    const normalizedConformedValue = conformedValue.toLowerCase();
+    const normalizedRawValue = rawValue.toLowerCase();
 
     // Then we take all characters that come before where the caret currently is.
-    var leftHalfChars = normalizedRawValue.substr(0, currentCaretPosition).split(emptyString);
+    const leftHalfChars = normalizedRawValue.substr(0, currentCaretPosition).split(emptyString);
 
     // Now we find all the characters in the left half that exist in the conformed input
     // This step ensures that we don't look for a character that was filtered out or rejected by `conformToMask`.
-    var intersection = leftHalfChars.filter(function (char) {
-      return normalizedConformedValue.indexOf(char) !== -1;
-    });
+    const intersection = leftHalfChars.filter(char => normalizedConformedValue.indexOf(char) !== -1);
 
     // The last character in the intersection is the character we want to look for in the conformed
     // value and the one we want to adjust the caret close to
@@ -89,21 +84,17 @@ export default function adjustCaretPosition(_ref) {
 
     // Calculate the number of mask characters in the previous placeholder
     // from the start of the string up to the place where the caret is
-    var previousLeftMaskChars = previousPlaceholder.substr(0, intersection.length).split(emptyString).filter(function (char) {
-      return char !== placeholderChar;
-    }).length;
+    const previousLeftMaskChars = previousPlaceholder.substr(0, intersection.length).split(emptyString).filter(char => char !== placeholderChar).length;
 
     // Calculate the number of mask characters in the current placeholder
     // from the start of the string up to the place where the caret is
-    var leftMaskChars = placeholder.substr(0, intersection.length).split(emptyString).filter(function (char) {
-      return char !== placeholderChar;
-    }).length;
+    const leftMaskChars = placeholder.substr(0, intersection.length).split(emptyString).filter(char => char !== placeholderChar).length;
 
     // Has the number of mask characters up to the caret changed?
-    var masklengthChanged = leftMaskChars !== previousLeftMaskChars;
+    const masklengthChanged = leftMaskChars !== previousLeftMaskChars;
 
     // Detect if `targetChar` is a mask character and has moved to the left
-    var targetIsMaskMovingLeft = previousPlaceholder[intersection.length - 1] !== undefined && placeholder[intersection.length - 2] !== undefined && previousPlaceholder[intersection.length - 1] !== placeholderChar && previousPlaceholder[intersection.length - 1] !== placeholder[intersection.length - 1] && previousPlaceholder[intersection.length - 1] === placeholder[intersection.length - 2];
+    const targetIsMaskMovingLeft = previousPlaceholder[intersection.length - 1] !== undefined && placeholder[intersection.length - 2] !== undefined && previousPlaceholder[intersection.length - 1] !== placeholderChar && previousPlaceholder[intersection.length - 1] !== placeholder[intersection.length - 1] && previousPlaceholder[intersection.length - 1] === placeholder[intersection.length - 2];
 
     // If deleting and the `targetChar` `is a mask character and `masklengthChanged` is true
     // or the mask is moving to the left, we can't use the selected `targetChar` any longer
@@ -121,36 +112,27 @@ export default function adjustCaretPosition(_ref) {
 
     // If the `conformedValue` got piped, we need to know which characters were piped in so that when we look for
     // our `targetChar`, we don't select a piped char by mistake
-    var pipedChars = indexesOfPipedChars.map(function (index) {
-      return normalizedConformedValue[index];
-    });
+    const pipedChars = indexesOfPipedChars.map(index => normalizedConformedValue[index]);
 
     // We need to know how many times the `targetChar` occurs in the piped characters.
-    var countTargetCharInPipedChars = pipedChars.filter(function (char) {
-      return char === targetChar;
-    }).length;
+    const countTargetCharInPipedChars = pipedChars.filter(char => char === targetChar).length;
 
     // We need to know how many times it occurs in the intersection
-    var countTargetCharInIntersection = intersection.filter(function (char) {
-      return char === targetChar;
-    }).length;
+    const countTargetCharInIntersection = intersection.filter(char => char === targetChar).length;
 
     // We need to know if the placeholder contains characters that look like
     // our `targetChar`, so we don't select one of those by mistake.
-    var countTargetCharInPlaceholder = placeholder.substr(0, placeholder.indexOf(placeholderChar)).split(emptyString).filter(function (char, index) {
-      return (
-        // Check if `char` is the same as our `targetChar`, so we account for it
-        char === targetChar &&
-        // but also make sure that both the `rawValue` and placeholder don't have the same character at the same
-        // index because if they are equal, that means we are already counting those characters in
-        // `countTargetCharInIntersection`
-        rawValue[index] !== char
-      );
-    }).length;
+    const countTargetCharInPlaceholder = placeholder.substr(0, placeholder.indexOf(placeholderChar)).split(emptyString).filter((char, index) =>
+    // Check if `char` is the same as our `targetChar`, so we account for it
+    char === targetChar &&
+    // but also make sure that both the `rawValue` and placeholder don't have the same character at the same
+    // index because if they are equal, that means we are already counting those characters in
+    // `countTargetCharInIntersection`
+    rawValue[index] !== char).length;
 
     // The number of times we need to see occurrences of the `targetChar` before we know it is the one we're looking
     // for is:
-    var requiredNumberOfMatches = countTargetCharInPlaceholder + countTargetCharInIntersection + countTargetCharInPipedChars + (
+    const requiredNumberOfMatches = countTargetCharInPlaceholder + countTargetCharInIntersection + countTargetCharInPipedChars + (
     // The character to the right of the caret isn't included in `intersection`
     // so add one if we are tracking the character to the right
     trackRightCharacter ? 1 : 0);
@@ -159,9 +141,9 @@ export default function adjustCaretPosition(_ref) {
     // We keep looping forward and store the index in every iteration. Once we have encountered
     // enough occurrences of the target character, we break out of the loop
     // If are searching for the second `1` in `1214`, `startingSearchIndex` will point at `4`.
-    var numberOfEncounteredMatches = 0;
-    for (var i = 0; i < conformedValueLength; i++) {
-      var conformedValueChar = normalizedConformedValue[i];
+    let numberOfEncounteredMatches = 0;
+    for (let i = 0; i < conformedValueLength; i++) {
+      const conformedValueChar = normalizedConformedValue[i];
       startingSearchIndex = i + 1;
       if (conformedValueChar === targetChar) {
         numberOfEncounteredMatches++;
@@ -182,18 +164,18 @@ export default function adjustCaretPosition(_ref) {
     // We want to remember the last placeholder character encountered so that if the mask
     // contains more characters after the last placeholder character, we don't forward the caret
     // that far to the right. Instead, we stop it at the last encountered placeholder character.
-    var lastPlaceholderChar = startingSearchIndex;
-    for (var _i = startingSearchIndex; _i <= placeholderLength; _i++) {
-      if (placeholder[_i] === placeholderChar) {
-        lastPlaceholderChar = _i;
+    let lastPlaceholderChar = startingSearchIndex;
+    for (let i = startingSearchIndex; i <= placeholderLength; i++) {
+      if (placeholder[i] === placeholderChar) {
+        lastPlaceholderChar = i;
       }
       if (
       // If we're adding, we can position the caret at the next placeholder character.
-      placeholder[_i] === placeholderChar ||
+      placeholder[i] === placeholderChar ||
       // If a caret trap was set by a mask function, we need to stop at the trap.
-      caretTrapIndexes.indexOf(_i) !== -1 ||
+      caretTrapIndexes.indexOf(i) !== -1 ||
       // This is the end of the placeholder. We cannot move any further. Let's put the caret there.
-      _i === placeholderLength) {
+      i === placeholderLength) {
         return lastPlaceholderChar;
       }
     }
@@ -202,26 +184,26 @@ export default function adjustCaretPosition(_ref) {
     if (trackRightCharacter) {
       // Searching for the character that was to the right of the caret
       // We start at `startingSearchIndex` - 1 because it includes one character extra to the right
-      for (var _i2 = startingSearchIndex - 1; _i2 >= 0; _i2--) {
+      for (let i = startingSearchIndex - 1; i >= 0; i--) {
         // If tracking the character to the right of the cursor, we move to the left until
         // we found the character and then place the caret right before it
 
         if (
         // `targetChar` should be in `conformedValue`, since it was in `rawValue`, just
         // to the right of the caret
-        conformedValue[_i2] === targetChar ||
+        conformedValue[i] === targetChar ||
         // If a caret trap was set by a mask function, we need to stop at the trap.
-        caretTrapIndexes.indexOf(_i2) !== -1 ||
+        caretTrapIndexes.indexOf(i) !== -1 ||
         // This is the beginning of the placeholder. We cannot move any further.
         // Let's put the caret there.
-        _i2 === 0) {
-          return _i2;
+        i === 0) {
+          return i;
         }
       }
     } else {
       // Searching for the first placeholder or caret trap to the left
 
-      for (var _i3 = startingSearchIndex; _i3 >= 0; _i3--) {
+      for (let i = startingSearchIndex; i >= 0; i--) {
         // If we're deleting, we stop the caret right before the placeholder character.
         // For example, for mask `(111) 11`, current conformed input `(456) 86`. If user
         // modifies input to `(456 86`. That is, they deleted the `)`, we place the caret
@@ -229,13 +211,13 @@ export default function adjustCaretPosition(_ref) {
 
         if (
         // If we're deleting, we can position the caret right before the placeholder character
-        placeholder[_i3 - 1] === placeholderChar ||
+        placeholder[i - 1] === placeholderChar ||
         // If a caret trap was set by a mask function, we need to stop at the trap.
-        caretTrapIndexes.indexOf(_i3) !== -1 ||
+        caretTrapIndexes.indexOf(i) !== -1 ||
         // This is the beginning of the placeholder. We cannot move any further.
         // Let's put the caret there.
-        _i3 === 0) {
-          return _i3;
+        i === 0) {
+          return i;
         }
       }
     }

package/esm/MaskedInput/conformToMask.js

@@ -31,39 +31,35 @@ export default function conformToMask(rawValue, mask, config) {
   }
 
   // These configurations tell us how to conform the mask
-  var _config = config,
-    _config$guide = _config.guide,
-    guide = _config$guide === void 0 ? true : _config$guide,
-    _config$previousConfo = _config.previousConformedValue,
-    previousConformedValue = _config$previousConfo === void 0 ? '' : _config$previousConfo,
-    _config$placeholderCh = _config.placeholderChar,
-    placeholderChar = _config$placeholderCh === void 0 ? defaultPlaceholderChar : _config$placeholderCh,
-    _config$placeholder = _config.placeholder,
-    placeholder = _config$placeholder === void 0 ? convertMaskToPlaceholder(mask, placeholderChar) : _config$placeholder,
-    _config$currentCaretP = _config.currentCaretPosition,
-    currentCaretPosition = _config$currentCaretP === void 0 ? 0 : _config$currentCaretP,
-    keepCharPositions = _config.keepCharPositions;
+  const {
+    guide = true,
+    previousConformedValue = '',
+    placeholderChar = defaultPlaceholderChar,
+    placeholder = convertMaskToPlaceholder(mask, placeholderChar),
+    currentCaretPosition = 0,
+    keepCharPositions
+  } = config;
 
   // The configs below indicate that the user wants the algorithm to work in *no guide* mode
-  var suppressGuide = guide === false && previousConformedValue !== undefined;
+  const suppressGuide = guide === false && previousConformedValue !== undefined;
 
   // Calculate lengths once for performance
-  var rawValueLength = rawValue.length;
-  var previousConformedValueLength = previousConformedValue.length;
-  var placeholderLength = placeholder.length;
-  var maskLength = mask.length;
+  const rawValueLength = rawValue.length;
+  const previousConformedValueLength = previousConformedValue.length;
+  const placeholderLength = placeholder.length;
+  const maskLength = mask.length;
 
   // This tells us the number of edited characters and the direction in which they were edited (+/-)
-  var editDistance = rawValueLength - previousConformedValueLength;
+  const editDistance = rawValueLength - previousConformedValueLength;
 
   // In *no guide* mode, we need to know if the user is trying to add a character or not
-  var isAddition = editDistance > 0;
+  const isAddition = editDistance > 0;
 
   // Tells us the index of the first change. For (438) 394-4938 to (38) 394-4938, that would be 1
-  var indexOfFirstChange = currentCaretPosition + (isAddition ? -editDistance : 0);
+  const indexOfFirstChange = currentCaretPosition + (isAddition ? -editDistance : 0);
 
   // We're also gonna need the index of last change, which we can derive as follows...
-  var indexOfLastChange = indexOfFirstChange + Math.abs(editDistance);
+  const indexOfLastChange = indexOfFirstChange + Math.abs(editDistance);
 
   // If `conformToMask` is configured to keep character positions, that is, for mask 111, previous value
   // _2_ and raw value 3_2_, the new conformed value should be 32_, not 3_2 (default behavior). That's in the case of
@@ -75,10 +71,10 @@ export default function conformToMask(rawValue, mask, config) {
   // To do this, we want to compensate for all characters that were deleted
   if (keepCharPositions === true && !isAddition) {
     // We will be storing the new placeholder characters in this variable.
-    var compensatingPlaceholderChars = '';
+    let compensatingPlaceholderChars = '';
 
     // For every character that was deleted from a placeholder position, we add a placeholder char
-    for (var i = indexOfFirstChange; i < indexOfLastChange; i++) {
+    for (let i = indexOfFirstChange; i < indexOfLastChange; i++) {
       if (placeholder[i] === placeholderChar) {
         compensatingPlaceholderChars += placeholderChar;
       }
@@ -93,35 +89,35 @@ export default function conformToMask(rawValue, mask, config) {
   // Convert `rawValue` string to an array, and mark characters based on whether they are newly added or have
   // existed in the previous conformed value. Identifying new and old characters is needed for `conformToMask`
   // to work if it is configured to keep character positions.
-  var rawValueArr = rawValue.split('').map(function (char, i) {
-    return {
-      char: char,
-      isNew: i >= indexOfFirstChange && i < indexOfLastChange
-    };
-  });
+  const rawValueArr = rawValue.split('').map((char, i) => ({
+    char,
+    isNew: i >= indexOfFirstChange && i < indexOfLastChange
+  }));
 
   // The loop below removes masking characters from user input. For example, for mask
   // `00 (111)`, the placeholder would be `00 (___)`. If user input is `00 (234)`, the loop below
   // would remove all characters but `234` from the `rawValueArr`. The rest of the algorithm
   // then would lay `234` on top of the available placeholder positions in the mask.
-  for (var _i = rawValueLength - 1; _i >= 0; _i--) {
-    var char = rawValueArr[_i].char;
+  for (let i = rawValueLength - 1; i >= 0; i--) {
+    const {
+      char
+    } = rawValueArr[i];
     if (char !== placeholderChar) {
-      var shouldOffset = _i >= indexOfFirstChange && previousConformedValueLength === maskLength;
-      if (char === placeholder[shouldOffset ? _i - editDistance : _i]) {
-        rawValueArr.splice(_i, 1);
+      const shouldOffset = i >= indexOfFirstChange && previousConformedValueLength === maskLength;
+      if (char === placeholder[shouldOffset ? i - editDistance : i]) {
+        rawValueArr.splice(i, 1);
       }
     }
   }
 
   // This is the variable that we will be filling with characters as we figure them out
   // in the algorithm below
-  var conformedValue = '';
-  var someCharsRejected = false;
+  let conformedValue = '';
+  let someCharsRejected = false;
 
   // Ok, so first we loop through the placeholder looking for placeholder characters to fill up.
-  placeholderLoop: for (var _i2 = 0; _i2 < placeholderLength; _i2++) {
-    var charInPlaceholder = placeholder[_i2];
+  placeholderLoop: for (let i = 0; i < placeholderLength; i++) {
+    const charInPlaceholder = placeholder[i];
 
     // We see one. Let's find out what we can put in it.
     if (charInPlaceholder === placeholderChar) {
@@ -131,10 +127,10 @@ export default function conformToMask(rawValue, mask, config) {
         // or we find at least one character that we can map.
         while (rawValueArr.length > 0) {
           // Let's retrieve the first user character in the queue of characters we have left
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          var _ref = rawValueArr.shift(),
-            rawValueChar = _ref.char,
-            isNew = _ref.isNew;
+          const {
+            char: rawValueChar,
+            isNew
+          } = rawValueArr.shift();
 
           // If the character we got from the user input is a placeholder character (which happens
           // regularly because user input could be something like (540) 90_-____, which includes
@@ -148,7 +144,7 @@ export default function conformToMask(rawValue, mask, config) {
 
             // Else if, the character we got from the user input is not a placeholder, let's see
             // if the current position in the mask can accept it.
-          } else if (mask[_i2].test(rawValueChar)) {
+          } else if (mask[i].test(rawValueChar)) {
             // we map the character differently based on whether we are keeping character positions or not.
             // If any of the conditions below are met, we simply map the raw value character to the
             // placeholder position.
@@ -162,20 +158,20 @@ export default function conformToMask(rawValue, mask, config) {
               // For example, for mask `1111`, previous conformed value `_2__`, raw value `942_2__`. We can map the
               // `9`, to the first available placeholder position, but then, there are no more spots available for the
               // `4` and `2`. So, we discard them and end up with a conformed value of `92__`.
-              var rawValueArrLength = rawValueArr.length;
-              var indexOfNextAvailablePlaceholderChar = null;
+              const rawValueArrLength = rawValueArr.length;
+              let indexOfNextAvailablePlaceholderChar = null;
 
               // Let's loop through the remaining raw value characters. We are looking for either a suitable spot, ie,
               // a placeholder character or a non-suitable spot, ie, a non-placeholder character that is not new.
               // If we see a suitable spot first, we store its position and exit the loop. If we see a non-suitable
               // spot first, we exit the loop and our `indexOfNextAvailablePlaceholderChar` will stay as `null`.
-              for (var _i3 = 0; _i3 < rawValueArrLength; _i3++) {
-                var charData = rawValueArr[_i3];
+              for (let i = 0; i < rawValueArrLength; i++) {
+                const charData = rawValueArr[i];
                 if (charData.char !== placeholderChar && charData.isNew === false) {
                   break;
                 }
                 if (charData.char === placeholderChar) {
-                  indexOfNextAvailablePlaceholderChar = _i3;
+                  indexOfNextAvailablePlaceholderChar = i;
                   break;
                 }
               }
@@ -190,7 +186,7 @@ export default function conformToMask(rawValue, mask, config) {
                 // If `indexOfNextAvailablePlaceholderChar` is `null`, that means the character is blocked. We have to
                 // discard it.
               } else {
-                _i2--;
+                i--;
               }
             }
 
@@ -208,7 +204,7 @@ export default function conformToMask(rawValue, mask, config) {
       //
       // That is, for mask `(111)` and user input `2`, we want to return `(2`, not `(2__)`.
       if (suppressGuide === false) {
-        conformedValue += placeholder.substr(_i2, placeholderLength);
+        conformedValue += placeholder.substr(i, placeholderLength);
       }
 
       // And we break
@@ -228,12 +224,12 @@ export default function conformToMask(rawValue, mask, config) {
   // That's why the logic below finds the last filled placeholder character, and removes everything
   // from that point on.
   if (suppressGuide && isAddition === false) {
-    var indexOfLastFilledPlaceholderChar = null;
+    let indexOfLastFilledPlaceholderChar = null;
 
     // Find the last filled placeholder position and substring from there
-    for (var _i4 = 0; _i4 < conformedValue.length; _i4++) {
-      if (placeholder[_i4] === placeholderChar) {
-        indexOfLastFilledPlaceholderChar = _i4;
+    for (let i = 0; i < conformedValue.length; i++) {
+      if (placeholder[i] === placeholderChar) {
+        indexOfLastFilledPlaceholderChar = i;
       }
     }
     if (indexOfLastFilledPlaceholderChar !== null) {
@@ -246,9 +242,9 @@ export default function conformToMask(rawValue, mask, config) {
     }
   }
   return {
-    conformedValue: conformedValue,
+    conformedValue,
     meta: {
-      someCharsRejected: someCharsRejected
+      someCharsRejected
     }
   };
 }