{"version":3,"file":"549.d78969e484da9d82b485.js","mappings":"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","sources":["webpack://silverstripe-base/./node_modules/imask/esm/core/change-details.js","webpack://silverstripe-base/./node_modules/imask/esm/core/continuous-tail-details.js","webpack://silverstripe-base/./node_modules/imask/esm/core/holder.js","webpack://silverstripe-base/./node_modules/imask/esm/core/utils.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/base.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/number.js"],"sourcesContent":["import IMask from './holder.js';\n\n/** Provides details of changing model value */\nclass ChangeDetails {\n  /** Inserted symbols */\n\n  /** Can skip chars */\n\n  /** Additional offset if any changes occurred before tail */\n\n  /** Raw inserted is used by dynamic mask */\n\n  static normalize(prep) {\n    return Array.isArray(prep) ? prep : [prep, new ChangeDetails()];\n  }\n  constructor(details) {\n    Object.assign(this, {\n      inserted: '',\n      rawInserted: '',\n      skip: false,\n      tailShift: 0\n    }, details);\n  }\n\n  /** Aggregate changes */\n  aggregate(details) {\n    this.rawInserted += details.rawInserted;\n    this.skip = this.skip || details.skip;\n    this.inserted += details.inserted;\n    this.tailShift += details.tailShift;\n    return this;\n  }\n\n  /** Total offset considering all changes */\n  get offset() {\n    return this.tailShift + this.inserted.length;\n  }\n}\nIMask.ChangeDetails = ChangeDetails;\n\nexport { ChangeDetails as default };\n","/** Provides details of continuous extracted tail */\nclass ContinuousTailDetails {\n  /** Tail value as string */\n\n  /** Tail start position */\n\n  /** Start position */\n\n  constructor(value, from, stop) {\n    if (value === void 0) {\n      value = '';\n    }\n    if (from === void 0) {\n      from = 0;\n    }\n    this.value = value;\n    this.from = from;\n    this.stop = stop;\n  }\n  toString() {\n    return this.value;\n  }\n  extend(tail) {\n    this.value += String(tail);\n  }\n  appendTo(masked) {\n    return masked.append(this.toString(), {\n      tail: true\n    }).aggregate(masked._appendPlaceholder());\n  }\n  get state() {\n    return {\n      value: this.value,\n      from: this.from,\n      stop: this.stop\n    };\n  }\n  set state(state) {\n    Object.assign(this, state);\n  }\n  unshift(beforePos) {\n    if (!this.value.length || beforePos != null && this.from >= beforePos) return '';\n    const shiftChar = this.value[0];\n    this.value = this.value.slice(1);\n    return shiftChar;\n  }\n  shift() {\n    if (!this.value.length) return '';\n    const shiftChar = this.value[this.value.length - 1];\n    this.value = this.value.slice(0, -1);\n    return shiftChar;\n  }\n}\n\nexport { ContinuousTailDetails as default };\n","/** Applies mask on element */\nfunction IMask(el, opts) {\n  // currently available only for input-like elements\n  return new IMask.InputMask(el, opts);\n}\n\nexport { IMask as default };\n","/** Checks if value is string */\nfunction isString(str) {\n  return typeof str === 'string' || str instanceof String;\n}\n\n/** Checks if value is object */\nfunction isObject(obj) {\n  var _obj$constructor;\n  return typeof obj === 'object' && obj != null && (obj == null || (_obj$constructor = obj.constructor) == null ? void 0 : _obj$constructor.name) === 'Object';\n}\nfunction pick(obj, keys) {\n  if (Array.isArray(keys)) return pick(obj, (_, k) => keys.includes(k));\n  return Object.entries(obj).reduce((acc, _ref) => {\n    let [k, v] = _ref;\n    if (keys(v, k)) acc[k] = v;\n    return acc;\n  }, {});\n}\n\n/** Direction */\nconst DIRECTION = {\n  NONE: 'NONE',\n  LEFT: 'LEFT',\n  FORCE_LEFT: 'FORCE_LEFT',\n  RIGHT: 'RIGHT',\n  FORCE_RIGHT: 'FORCE_RIGHT'\n};\n\n/** Direction */\n\nfunction forceDirection(direction) {\n  switch (direction) {\n    case DIRECTION.LEFT:\n      return DIRECTION.FORCE_LEFT;\n    case DIRECTION.RIGHT:\n      return DIRECTION.FORCE_RIGHT;\n    default:\n      return direction;\n  }\n}\n\n/** Escapes regular expression control chars */\nfunction escapeRegExp(str) {\n  return str.replace(/([.*+?^=!:${}()|[\\]/\\\\])/g, '\\\\$1');\n}\n\n// cloned from https://github.com/epoberezkin/fast-deep-equal with small changes\nfunction objectIncludes(b, a) {\n  if (a === b) return true;\n  const arrA = Array.isArray(a),\n    arrB = Array.isArray(b);\n  let i;\n  if (arrA && arrB) {\n    if (a.length != b.length) return false;\n    for (i = 0; i < a.length; i++) if (!objectIncludes(a[i], b[i])) return false;\n    return true;\n  }\n  if (arrA != arrB) return false;\n  if (a && b && typeof a === 'object' && typeof b === 'object') {\n    const dateA = a instanceof Date,\n      dateB = b instanceof Date;\n    if (dateA && dateB) return a.getTime() == b.getTime();\n    if (dateA != dateB) return false;\n    const regexpA = a instanceof RegExp,\n      regexpB = b instanceof RegExp;\n    if (regexpA && regexpB) return a.toString() == b.toString();\n    if (regexpA != regexpB) return false;\n    const keys = Object.keys(a);\n    // if (keys.length !== Object.keys(b).length) return false;\n\n    for (i = 0; i < keys.length; i++) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n    for (i = 0; i < keys.length; i++) if (!objectIncludes(b[keys[i]], a[keys[i]])) return false;\n    return true;\n  } else if (a && b && typeof a === 'function' && typeof b === 'function') {\n    return a.toString() === b.toString();\n  }\n  return false;\n}\n\n/** Selection range */\n\nexport { DIRECTION, escapeRegExp, forceDirection, isObject, isString, objectIncludes, pick };\n","import ChangeDetails from '../core/change-details.js';\nimport ContinuousTailDetails from '../core/continuous-tail-details.js';\nimport { isString, DIRECTION, forceDirection } from '../core/utils.js';\nimport IMask from '../core/holder.js';\n\n/** Append flags */\n\n/** Extract flags */\n\n// see https://github.com/microsoft/TypeScript/issues/6223\n\n/** Provides common masking stuff */\nclass Masked {\n  /** */\n\n  /** */\n\n  /** Transforms value before mask processing */\n\n  /** Transforms each char before mask processing */\n\n  /** Validates if value is acceptable */\n\n  /** Does additional processing at the end of editing */\n\n  /** Format typed value to string */\n\n  /** Parse string to get typed value */\n\n  /** Enable characters overwriting */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  constructor(opts) {\n    this._value = '';\n    this._update({\n      ...Masked.DEFAULTS,\n      ...opts\n    });\n    this._initialized = true;\n  }\n\n  /** Sets and applies new options */\n  updateOptions(opts) {\n    if (!Object.keys(opts).length) return;\n    this.withValueRefresh(this._update.bind(this, opts));\n  }\n\n  /** Sets new options */\n  _update(opts) {\n    Object.assign(this, opts);\n  }\n\n  /** Mask state */\n  get state() {\n    return {\n      _value: this.value,\n      _rawInputValue: this.rawInputValue\n    };\n  }\n  set state(state) {\n    this._value = state._value;\n  }\n\n  /** Resets value */\n  reset() {\n    this._value = '';\n  }\n  get value() {\n    return this._value;\n  }\n  set value(value) {\n    this.resolve(value, {\n      input: true\n    });\n  }\n\n  /** Resolve new value */\n  resolve(value, flags) {\n    if (flags === void 0) {\n      flags = {\n        input: true\n      };\n    }\n    this.reset();\n    this.append(value, flags, '');\n    this.doCommit();\n  }\n  get unmaskedValue() {\n    return this.value;\n  }\n  set unmaskedValue(value) {\n    this.resolve(value, {});\n  }\n  get typedValue() {\n    return this.parse ? this.parse(this.value, this) : this.unmaskedValue;\n  }\n  set typedValue(value) {\n    if (this.format) {\n      this.value = this.format(value, this);\n    } else {\n      this.unmaskedValue = String(value);\n    }\n  }\n\n  /** Value that includes raw user input */\n  get rawInputValue() {\n    return this.extractInput(0, this.displayValue.length, {\n      raw: true\n    });\n  }\n  set rawInputValue(value) {\n    this.resolve(value, {\n      raw: true\n    });\n  }\n  get displayValue() {\n    return this.value;\n  }\n  get isComplete() {\n    return true;\n  }\n  get isFilled() {\n    return this.isComplete;\n  }\n\n  /** Finds nearest input position in direction */\n  nearestInputPos(cursorPos, direction) {\n    return cursorPos;\n  }\n  totalInputPositions(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    return Math.min(this.displayValue.length, toPos - fromPos);\n  }\n\n  /** Extracts value in range considering flags */\n  extractInput(fromPos, toPos, flags) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    return this.displayValue.slice(fromPos, toPos);\n  }\n\n  /** Extracts tail in range */\n  extractTail(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    return new ContinuousTailDetails(this.extractInput(fromPos, toPos), fromPos);\n  }\n\n  /** Appends tail */\n  appendTail(tail) {\n    if (isString(tail)) tail = new ContinuousTailDetails(String(tail));\n    return tail.appendTo(this);\n  }\n\n  /** Appends char */\n  _appendCharRaw(ch, flags) {\n    if (!ch) return new ChangeDetails();\n    this._value += ch;\n    return new ChangeDetails({\n      inserted: ch,\n      rawInserted: ch\n    });\n  }\n\n  /** Appends char */\n  _appendChar(ch, flags, checkTail) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    const consistentState = this.state;\n    let details;\n    [ch, details] = this.doPrepareChar(ch, flags);\n    details = details.aggregate(this._appendCharRaw(ch, flags));\n    if (details.inserted) {\n      let consistentTail;\n      let appended = this.doValidate(flags) !== false;\n      if (appended && checkTail != null) {\n        // validation ok, check tail\n        const beforeTailState = this.state;\n        if (this.overwrite === true) {\n          consistentTail = checkTail.state;\n          checkTail.unshift(this.displayValue.length - details.tailShift);\n        }\n        let tailDetails = this.appendTail(checkTail);\n        appended = tailDetails.rawInserted === checkTail.toString();\n\n        // not ok, try shift\n        if (!(appended && tailDetails.inserted) && this.overwrite === 'shift') {\n          this.state = beforeTailState;\n          consistentTail = checkTail.state;\n          checkTail.shift();\n          tailDetails = this.appendTail(checkTail);\n          appended = tailDetails.rawInserted === checkTail.toString();\n        }\n\n        // if ok, rollback state after tail\n        if (appended && tailDetails.inserted) this.state = beforeTailState;\n      }\n\n      // revert all if something went wrong\n      if (!appended) {\n        details = new ChangeDetails();\n        this.state = consistentState;\n        if (checkTail && consistentTail) checkTail.state = consistentTail;\n      }\n    }\n    return details;\n  }\n\n  /** Appends optional placeholder at the end */\n  _appendPlaceholder() {\n    return new ChangeDetails();\n  }\n\n  /** Appends optional eager placeholder at the end */\n  _appendEager() {\n    return new ChangeDetails();\n  }\n\n  /** Appends symbols considering flags */\n  append(str, flags, tail) {\n    if (!isString(str)) throw new Error('value should be string');\n    const checkTail = isString(tail) ? new ContinuousTailDetails(String(tail)) : tail;\n    if (flags != null && flags.tail) flags._beforeTailState = this.state;\n    let details;\n    [str, details] = this.doPrepare(str, flags);\n    for (let ci = 0; ci < str.length; ++ci) {\n      const d = this._appendChar(str[ci], flags, checkTail);\n      if (!d.rawInserted && !this.doSkipInvalid(str[ci], flags, checkTail)) break;\n      details.aggregate(d);\n    }\n    if ((this.eager === true || this.eager === 'append') && flags != null && flags.input && str) {\n      details.aggregate(this._appendEager());\n    }\n\n    // append tail but aggregate only tailShift\n    if (checkTail != null) {\n      details.tailShift += this.appendTail(checkTail).tailShift;\n      // TODO it's a good idea to clear state after appending ends\n      // but it causes bugs when one append calls another (when dynamic dispatch set rawInputValue)\n      // this._resetBeforeTailState();\n    }\n\n    return details;\n  }\n  remove(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    this._value = this.displayValue.slice(0, fromPos) + this.displayValue.slice(toPos);\n    return new ChangeDetails();\n  }\n\n  /** Calls function and reapplies current value */\n  withValueRefresh(fn) {\n    if (this._refreshing || !this._initialized) return fn();\n    this._refreshing = true;\n    const rawInput = this.rawInputValue;\n    const value = this.value;\n    const ret = fn();\n    this.rawInputValue = rawInput;\n    // append lost trailing chars at the end\n    if (this.value && this.value !== value && value.indexOf(this.value) === 0) {\n      this.append(value.slice(this.displayValue.length), {}, '');\n    }\n    delete this._refreshing;\n    return ret;\n  }\n  runIsolated(fn) {\n    if (this._isolated || !this._initialized) return fn(this);\n    this._isolated = true;\n    const state = this.state;\n    const ret = fn(this);\n    this.state = state;\n    delete this._isolated;\n    return ret;\n  }\n  doSkipInvalid(ch, flags, checkTail) {\n    return Boolean(this.skipInvalid);\n  }\n\n  /** Prepares string before mask processing */\n  doPrepare(str, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    return ChangeDetails.normalize(this.prepare ? this.prepare(str, this, flags) : str);\n  }\n\n  /** Prepares each char before mask processing */\n  doPrepareChar(str, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    return ChangeDetails.normalize(this.prepareChar ? this.prepareChar(str, this, flags) : str);\n  }\n\n  /** Validates if value is acceptable */\n  doValidate(flags) {\n    return (!this.validate || this.validate(this.value, this, flags)) && (!this.parent || this.parent.doValidate(flags));\n  }\n\n  /** Does additional processing at the end of editing */\n  doCommit() {\n    if (this.commit) this.commit(this.value, this);\n  }\n  splice(start, deleteCount, inserted, removeDirection, flags) {\n    if (removeDirection === void 0) {\n      removeDirection = DIRECTION.NONE;\n    }\n    if (flags === void 0) {\n      flags = {\n        input: true\n      };\n    }\n    const tailPos = start + deleteCount;\n    const tail = this.extractTail(tailPos);\n    const eagerRemove = this.eager === true || this.eager === 'remove';\n    let oldRawValue;\n    if (eagerRemove) {\n      removeDirection = forceDirection(removeDirection);\n      oldRawValue = this.extractInput(0, tailPos, {\n        raw: true\n      });\n    }\n    let startChangePos = start;\n    const details = new ChangeDetails();\n\n    // if it is just deletion without insertion\n    if (removeDirection !== DIRECTION.NONE) {\n      startChangePos = this.nearestInputPos(start, deleteCount > 1 && start !== 0 && !eagerRemove ? DIRECTION.NONE : removeDirection);\n\n      // adjust tailShift if start was aligned\n      details.tailShift = startChangePos - start;\n    }\n    details.aggregate(this.remove(startChangePos));\n    if (eagerRemove && removeDirection !== DIRECTION.NONE && oldRawValue === this.rawInputValue) {\n      if (removeDirection === DIRECTION.FORCE_LEFT) {\n        let valLength;\n        while (oldRawValue === this.rawInputValue && (valLength = this.displayValue.length)) {\n          details.aggregate(new ChangeDetails({\n            tailShift: -1\n          })).aggregate(this.remove(valLength - 1));\n        }\n      } else if (removeDirection === DIRECTION.FORCE_RIGHT) {\n        tail.unshift();\n      }\n    }\n    return details.aggregate(this.append(inserted, flags, tail));\n  }\n  maskEquals(mask) {\n    return this.mask === mask;\n  }\n  typedValueEquals(value) {\n    const tval = this.typedValue;\n    return value === tval || Masked.EMPTY_VALUES.includes(value) && Masked.EMPTY_VALUES.includes(tval) || (this.format ? this.format(value, this) === this.format(this.typedValue, this) : false);\n  }\n}\nMasked.DEFAULTS = {\n  skipInvalid: true\n};\nMasked.EMPTY_VALUES = [undefined, null, ''];\nIMask.Masked = Masked;\n\nexport { Masked as default };\n","import { escapeRegExp, DIRECTION } from '../core/utils.js';\nimport ChangeDetails from '../core/change-details.js';\nimport Masked from './base.js';\nimport IMask from '../core/holder.js';\nimport '../core/continuous-tail-details.js';\n\n/** Number mask */\nclass MaskedNumber extends Masked {\n  /** Single char */\n\n  /** Single char */\n\n  /** Array of single chars */\n\n  /** */\n\n  /** */\n\n  /** Digits after point */\n\n  /** Flag to remove leading and trailing zeros in the end of editing */\n\n  /** Flag to pad trailing zeros after point in the end of editing */\n\n  /** Enable characters overwriting */\n\n  /** */\n\n  /** */\n\n  /** Format typed value to string */\n\n  /** Parse string to get typed value */\n\n  constructor(opts) {\n    super({\n      ...MaskedNumber.DEFAULTS,\n      ...opts\n    });\n  }\n  updateOptions(opts) {\n    super.updateOptions(opts);\n  }\n  _update(opts) {\n    super._update(opts);\n    this._updateRegExps();\n  }\n  _updateRegExps() {\n    const start = '^' + (this.allowNegative ? '[+|\\\\-]?' : '');\n    const mid = '\\\\d*';\n    const end = (this.scale ? \"(\" + escapeRegExp(this.radix) + \"\\\\d{0,\" + this.scale + \"})?\" : '') + '$';\n    this._numberRegExp = new RegExp(start + mid + end);\n    this._mapToRadixRegExp = new RegExp(\"[\" + this.mapToRadix.map(escapeRegExp).join('') + \"]\", 'g');\n    this._thousandsSeparatorRegExp = new RegExp(escapeRegExp(this.thousandsSeparator), 'g');\n  }\n  _removeThousandsSeparators(value) {\n    return value.replace(this._thousandsSeparatorRegExp, '');\n  }\n  _insertThousandsSeparators(value) {\n    // https://stackoverflow.com/questions/2901102/how-to-print-a-number-with-commas-as-thousands-separators-in-javascript\n    const parts = value.split(this.radix);\n    parts[0] = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, this.thousandsSeparator);\n    return parts.join(this.radix);\n  }\n  doPrepareChar(ch, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    const [prepCh, details] = super.doPrepareChar(this._removeThousandsSeparators(this.scale && this.mapToRadix.length && (\n    /*\n      radix should be mapped when\n      1) input is done from keyboard = flags.input && flags.raw\n      2) unmasked value is set = !flags.input && !flags.raw\n      and should not be mapped when\n      1) value is set = flags.input && !flags.raw\n      2) raw value is set = !flags.input && flags.raw\n    */\n    flags.input && flags.raw || !flags.input && !flags.raw) ? ch.replace(this._mapToRadixRegExp, this.radix) : ch), flags);\n    if (ch && !prepCh) details.skip = true;\n    if (prepCh && !this.allowPositive && !this.value && prepCh !== '-') details.aggregate(this._appendChar('-'));\n    return [prepCh, details];\n  }\n  _separatorsCount(to, extendOnSeparators) {\n    if (extendOnSeparators === void 0) {\n      extendOnSeparators = false;\n    }\n    let count = 0;\n    for (let pos = 0; pos < to; ++pos) {\n      if (this._value.indexOf(this.thousandsSeparator, pos) === pos) {\n        ++count;\n        if (extendOnSeparators) to += this.thousandsSeparator.length;\n      }\n    }\n    return count;\n  }\n  _separatorsCountFromSlice(slice) {\n    if (slice === void 0) {\n      slice = this._value;\n    }\n    return this._separatorsCount(this._removeThousandsSeparators(slice).length, true);\n  }\n  extractInput(fromPos, toPos, flags) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    [fromPos, toPos] = this._adjustRangeWithSeparators(fromPos, toPos);\n    return this._removeThousandsSeparators(super.extractInput(fromPos, toPos, flags));\n  }\n  _appendCharRaw(ch, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    if (!this.thousandsSeparator) return super._appendCharRaw(ch, flags);\n    const prevBeforeTailValue = flags.tail && flags._beforeTailState ? flags._beforeTailState._value : this._value;\n    const prevBeforeTailSeparatorsCount = this._separatorsCountFromSlice(prevBeforeTailValue);\n    this._value = this._removeThousandsSeparators(this.value);\n    const appendDetails = super._appendCharRaw(ch, flags);\n    this._value = this._insertThousandsSeparators(this._value);\n    const beforeTailValue = flags.tail && flags._beforeTailState ? flags._beforeTailState._value : this._value;\n    const beforeTailSeparatorsCount = this._separatorsCountFromSlice(beforeTailValue);\n    appendDetails.tailShift += (beforeTailSeparatorsCount - prevBeforeTailSeparatorsCount) * this.thousandsSeparator.length;\n    appendDetails.skip = !appendDetails.rawInserted && ch === this.thousandsSeparator;\n    return appendDetails;\n  }\n  _findSeparatorAround(pos) {\n    if (this.thousandsSeparator) {\n      const searchFrom = pos - this.thousandsSeparator.length + 1;\n      const separatorPos = this.value.indexOf(this.thousandsSeparator, searchFrom);\n      if (separatorPos <= pos) return separatorPos;\n    }\n    return -1;\n  }\n  _adjustRangeWithSeparators(from, to) {\n    const separatorAroundFromPos = this._findSeparatorAround(from);\n    if (separatorAroundFromPos >= 0) from = separatorAroundFromPos;\n    const separatorAroundToPos = this._findSeparatorAround(to);\n    if (separatorAroundToPos >= 0) to = separatorAroundToPos + this.thousandsSeparator.length;\n    return [from, to];\n  }\n  remove(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    [fromPos, toPos] = this._adjustRangeWithSeparators(fromPos, toPos);\n    const valueBeforePos = this.value.slice(0, fromPos);\n    const valueAfterPos = this.value.slice(toPos);\n    const prevBeforeTailSeparatorsCount = this._separatorsCount(valueBeforePos.length);\n    this._value = this._insertThousandsSeparators(this._removeThousandsSeparators(valueBeforePos + valueAfterPos));\n    const beforeTailSeparatorsCount = this._separatorsCountFromSlice(valueBeforePos);\n    return new ChangeDetails({\n      tailShift: (beforeTailSeparatorsCount - prevBeforeTailSeparatorsCount) * this.thousandsSeparator.length\n    });\n  }\n  nearestInputPos(cursorPos, direction) {\n    if (!this.thousandsSeparator) return cursorPos;\n    switch (direction) {\n      case DIRECTION.NONE:\n      case DIRECTION.LEFT:\n      case DIRECTION.FORCE_LEFT:\n        {\n          const separatorAtLeftPos = this._findSeparatorAround(cursorPos - 1);\n          if (separatorAtLeftPos >= 0) {\n            const separatorAtLeftEndPos = separatorAtLeftPos + this.thousandsSeparator.length;\n            if (cursorPos < separatorAtLeftEndPos || this.value.length <= separatorAtLeftEndPos || direction === DIRECTION.FORCE_LEFT) {\n              return separatorAtLeftPos;\n            }\n          }\n          break;\n        }\n      case DIRECTION.RIGHT:\n      case DIRECTION.FORCE_RIGHT:\n        {\n          const separatorAtRightPos = this._findSeparatorAround(cursorPos);\n          if (separatorAtRightPos >= 0) {\n            return separatorAtRightPos + this.thousandsSeparator.length;\n          }\n        }\n    }\n    return cursorPos;\n  }\n  doValidate(flags) {\n    // validate as string\n    let valid = Boolean(this._removeThousandsSeparators(this.value).match(this._numberRegExp));\n    if (valid) {\n      // validate as number\n      const number = this.number;\n      valid = valid && !isNaN(number) && (\n      // check min bound for negative values\n      this.min == null || this.min >= 0 || this.min <= this.number) && (\n      // check max bound for positive values\n      this.max == null || this.max <= 0 || this.number <= this.max);\n    }\n    return valid && super.doValidate(flags);\n  }\n  doCommit() {\n    if (this.value) {\n      const number = this.number;\n      let validnum = number;\n\n      // check bounds\n      if (this.min != null) validnum = Math.max(validnum, this.min);\n      if (this.max != null) validnum = Math.min(validnum, this.max);\n      if (validnum !== number) this.unmaskedValue = this.format(validnum, this);\n      let formatted = this.value;\n      if (this.normalizeZeros) formatted = this._normalizeZeros(formatted);\n      if (this.padFractionalZeros && this.scale > 0) formatted = this._padFractionalZeros(formatted);\n      this._value = formatted;\n    }\n    super.doCommit();\n  }\n  _normalizeZeros(value) {\n    const parts = this._removeThousandsSeparators(value).split(this.radix);\n\n    // remove leading zeros\n    parts[0] = parts[0].replace(/^(\\D*)(0*)(\\d*)/, (match, sign, zeros, num) => sign + num);\n    // add leading zero\n    if (value.length && !/\\d$/.test(parts[0])) parts[0] = parts[0] + '0';\n    if (parts.length > 1) {\n      parts[1] = parts[1].replace(/0*$/, ''); // remove trailing zeros\n      if (!parts[1].length) parts.length = 1; // remove fractional\n    }\n\n    return this._insertThousandsSeparators(parts.join(this.radix));\n  }\n  _padFractionalZeros(value) {\n    if (!value) return value;\n    const parts = value.split(this.radix);\n    if (parts.length < 2) parts.push('');\n    parts[1] = parts[1].padEnd(this.scale, '0');\n    return parts.join(this.radix);\n  }\n  doSkipInvalid(ch, flags, checkTail) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    const dropFractional = this.scale === 0 && ch !== this.thousandsSeparator && (ch === this.radix || ch === MaskedNumber.UNMASKED_RADIX || this.mapToRadix.includes(ch));\n    return super.doSkipInvalid(ch, flags, checkTail) && !dropFractional;\n  }\n  get unmaskedValue() {\n    return this._removeThousandsSeparators(this._normalizeZeros(this.value)).replace(this.radix, MaskedNumber.UNMASKED_RADIX);\n  }\n  set unmaskedValue(unmaskedValue) {\n    super.unmaskedValue = unmaskedValue;\n  }\n  get typedValue() {\n    return this.parse(this.unmaskedValue, this);\n  }\n  set typedValue(n) {\n    this.rawInputValue = this.format(n, this).replace(MaskedNumber.UNMASKED_RADIX, this.radix);\n  }\n\n  /** Parsed Number */\n  get number() {\n    return this.typedValue;\n  }\n  set number(number) {\n    this.typedValue = number;\n  }\n\n  /**\n    Is negative allowed\n  */\n  get allowNegative() {\n    return this.min != null && this.min < 0 || this.max != null && this.max < 0;\n  }\n\n  /**\n    Is positive allowed\n  */\n  get allowPositive() {\n    return this.min != null && this.min > 0 || this.max != null && this.max > 0;\n  }\n  typedValueEquals(value) {\n    // handle  0 -> '' case (typed = 0 even if value = '')\n    // for details see https://github.com/uNmAnNeR/imaskjs/issues/134\n    return (super.typedValueEquals(value) || MaskedNumber.EMPTY_VALUES.includes(value) && MaskedNumber.EMPTY_VALUES.includes(this.typedValue)) && !(value === 0 && this.value === '');\n  }\n}\nMaskedNumber.UNMASKED_RADIX = '.';\nMaskedNumber.EMPTY_VALUES = [...Masked.EMPTY_VALUES, 0];\nMaskedNumber.DEFAULTS = {\n  mask: Number,\n  radix: ',',\n  thousandsSeparator: '',\n  mapToRadix: [MaskedNumber.UNMASKED_RADIX],\n  min: Number.MIN_SAFE_INTEGER,\n  max: Number.MAX_SAFE_INTEGER,\n  scale: 2,\n  normalizeZeros: true,\n  padFractionalZeros: false,\n  parse: Number,\n  format: n => n.toLocaleString('en-US', {\n    useGrouping: false,\n    maximumFractionDigits: 20\n  })\n};\nIMask.MaskedNumber = MaskedNumber;\n\nexport { MaskedNumber as default };\n"],"names":["ChangeDetails","normalize","prep","Array","isArray","constructor","details","Object","assign","this","inserted","rawInserted","skip","tailShift","aggregate","offset","length","ContinuousTailDetails","value","from","stop","toString","extend","tail","String","appendTo","masked","append","_appendPlaceholder","state","unshift","beforePos","shiftChar","slice","shift","IMask","el","opts","InputMask","isString","str","isObject","obj","_obj$constructor","name","pick","keys","_","k","includes","entries","reduce","acc","_ref","v","DIRECTION","NONE","LEFT","FORCE_LEFT","RIGHT","FORCE_RIGHT","forceDirection","direction","escapeRegExp","replace","objectIncludes","b","a","arrA","arrB","i","dateA","Date","dateB","getTime","regexpA","RegExp","regexpB","prototype","hasOwnProperty","call","Masked","_value","_update","DEFAULTS","_initialized","updateOptions","withValueRefresh","bind","_rawInputValue","rawInputValue","reset","resolve","input","flags","doCommit","unmaskedValue","typedValue","parse","format","extractInput","displayValue","raw","isComplete","isFilled","nearestInputPos","cursorPos","totalInputPositions","fromPos","toPos","Math","min","extractTail","appendTail","_appendCharRaw","ch","_appendChar","checkTail","consistentState","doPrepareChar","consistentTail","appended","doValidate","beforeTailState","overwrite","tailDetails","_appendEager","Error","_beforeTailState","doPrepare","ci","d","doSkipInvalid","eager","remove","fn","_refreshing","rawInput","ret","indexOf","runIsolated","_isolated","Boolean","skipInvalid","prepare","prepareChar","validate","parent","commit","splice","start","deleteCount","removeDirection","tailPos","eagerRemove","oldRawValue","startChangePos","valLength","maskEquals","mask","typedValueEquals","tval","EMPTY_VALUES","undefined","MaskedNumber","super","_updateRegExps","allowNegative","end","scale","radix","_numberRegExp","_mapToRadixRegExp","mapToRadix","map","join","_thousandsSeparatorRegExp","thousandsSeparator","_removeThousandsSeparators","_insertThousandsSeparators","parts","split","prepCh","allowPositive","_separatorsCount","to","extendOnSeparators","count","pos","_separatorsCountFromSlice","_adjustRangeWithSeparators","prevBeforeTailValue","prevBeforeTailSeparatorsCount","appendDetails","beforeTailValue","beforeTailSeparatorsCount","_findSeparatorAround","searchFrom","separatorPos","separatorAroundFromPos","separatorAroundToPos","valueBeforePos","valueAfterPos","separatorAtLeftPos","separatorAtLeftEndPos","separatorAtRightPos","valid","match","number","isNaN","max","validnum","formatted","normalizeZeros","_normalizeZeros","padFractionalZeros","_padFractionalZeros","sign","zeros","num","test","push","padEnd","dropFractional","UNMASKED_RADIX","n","Number","MIN_SAFE_INTEGER","MAX_SAFE_INTEGER","toLocaleString","useGrouping","maximumFractionDigits"],"sourceRoot":""}