{"version":3,"file":"38.3ae3d2b2f18ef4b9ebe9.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/factory.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/pattern/chunk-tail-details.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/pattern/cursor.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/pattern/fixed-definition.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/pattern/input-definition.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/regexp.js","webpack://silverstripe-base/./node_modules/imask/esm/masked/pattern.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 { isString, isObject, pick } from '../core/utils.js';\nimport IMask from '../core/holder.js';\n\n// TODO can't use overloads here because of https://github.com/microsoft/TypeScript/issues/50754\n// export function maskedClass(mask: string): typeof MaskedPattern;\n// export function maskedClass(mask: DateConstructor): typeof MaskedDate;\n// export function maskedClass(mask: NumberConstructor): typeof MaskedNumber;\n// export function maskedClass(mask: Array<any> | ArrayConstructor): typeof MaskedDynamic;\n// export function maskedClass(mask: MaskedDate): typeof MaskedDate;\n// export function maskedClass(mask: MaskedNumber): typeof MaskedNumber;\n// export function maskedClass(mask: MaskedEnum): typeof MaskedEnum;\n// export function maskedClass(mask: MaskedRange): typeof MaskedRange;\n// export function maskedClass(mask: MaskedRegExp): typeof MaskedRegExp;\n// export function maskedClass(mask: MaskedFunction): typeof MaskedFunction;\n// export function maskedClass(mask: MaskedPattern): typeof MaskedPattern;\n// export function maskedClass(mask: MaskedDynamic): typeof MaskedDynamic;\n// export function maskedClass(mask: Masked): typeof Masked;\n// export function maskedClass(mask: typeof Masked): typeof Masked;\n// export function maskedClass(mask: typeof MaskedDate): typeof MaskedDate;\n// export function maskedClass(mask: typeof MaskedNumber): typeof MaskedNumber;\n// export function maskedClass(mask: typeof MaskedEnum): typeof MaskedEnum;\n// export function maskedClass(mask: typeof MaskedRange): typeof MaskedRange;\n// export function maskedClass(mask: typeof MaskedRegExp): typeof MaskedRegExp;\n// export function maskedClass(mask: typeof MaskedFunction): typeof MaskedFunction;\n// export function maskedClass(mask: typeof MaskedPattern): typeof MaskedPattern;\n// export function maskedClass(mask: typeof MaskedDynamic): typeof MaskedDynamic;\n// export function maskedClass<Mask extends typeof Masked> (mask: Mask): Mask;\n// export function maskedClass(mask: RegExp): typeof MaskedRegExp;\n// export function maskedClass(mask: (value: string, ...args: any[]) => boolean): typeof MaskedFunction;\n/** Get Masked class by mask type */\nfunction maskedClass(mask) /* TODO */{\n  if (mask == null) throw new Error('mask property should be defined');\n  if (mask instanceof RegExp) return IMask.MaskedRegExp;\n  if (isString(mask)) return IMask.MaskedPattern;\n  if (mask === Date) return IMask.MaskedDate;\n  if (mask === Number) return IMask.MaskedNumber;\n  if (Array.isArray(mask) || mask === Array) return IMask.MaskedDynamic;\n  if (IMask.Masked && mask.prototype instanceof IMask.Masked) return mask;\n  if (IMask.Masked && mask instanceof IMask.Masked) return mask.constructor;\n  if (mask instanceof Function) return IMask.MaskedFunction;\n  console.warn('Mask not found for mask', mask); // eslint-disable-line no-console\n  return IMask.Masked;\n}\nfunction normalizeOpts(opts) {\n  if (!opts) throw new Error('Options in not defined');\n  if (IMask.Masked) {\n    if (opts.prototype instanceof IMask.Masked) return {\n      mask: opts\n    };\n\n    /*\n      handle cases like:\n      1) opts = Masked\n      2) opts = { mask: Masked, ...instanceOpts }\n    */\n    const {\n      mask = undefined,\n      ...instanceOpts\n    } = opts instanceof IMask.Masked ? {\n      mask: opts\n    } : isObject(opts) && opts.mask instanceof IMask.Masked ? opts : {};\n    if (mask) {\n      const _mask = mask.mask;\n      return {\n        ...pick(mask, (_, k) => !k.startsWith('_')),\n        mask: mask.constructor,\n        _mask,\n        ...instanceOpts\n      };\n    }\n  }\n  if (!isObject(opts)) return {\n    mask: opts\n  };\n  return {\n    ...opts\n  };\n}\n\n// TODO can't use overloads here because of https://github.com/microsoft/TypeScript/issues/50754\n\n// From masked\n// export default function createMask<Opts extends Masked, ReturnMasked=Opts> (opts: Opts): ReturnMasked;\n// // From masked class\n// export default function createMask<Opts extends MaskedOptions<typeof Masked>, ReturnMasked extends Masked=InstanceType<Opts['mask']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedDate>, ReturnMasked extends MaskedDate=MaskedDate<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedNumber>, ReturnMasked extends MaskedNumber=MaskedNumber<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedEnum>, ReturnMasked extends MaskedEnum=MaskedEnum<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedRange>, ReturnMasked extends MaskedRange=MaskedRange<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedRegExp>, ReturnMasked extends MaskedRegExp=MaskedRegExp<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedFunction>, ReturnMasked extends MaskedFunction=MaskedFunction<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedPattern>, ReturnMasked extends MaskedPattern=MaskedPattern<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<typeof MaskedDynamic>, ReturnMasked extends MaskedDynamic=MaskedDynamic<Opts['parent']>> (opts: Opts): ReturnMasked;\n// // From mask opts\n// export default function createMask<Opts extends MaskedOptions<Masked>, ReturnMasked=Opts extends MaskedOptions<infer M> ? M : never> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedNumberOptions, ReturnMasked extends MaskedNumber=MaskedNumber<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedDateFactoryOptions, ReturnMasked extends MaskedDate=MaskedDate<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedEnumOptions, ReturnMasked extends MaskedEnum=MaskedEnum<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedRangeOptions, ReturnMasked extends MaskedRange=MaskedRange<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedPatternOptions, ReturnMasked extends MaskedPattern=MaskedPattern<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedDynamicOptions, ReturnMasked extends MaskedDynamic=MaskedDynamic<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<RegExp>, ReturnMasked extends MaskedRegExp=MaskedRegExp<Opts['parent']>> (opts: Opts): ReturnMasked;\n// export default function createMask<Opts extends MaskedOptions<Function>, ReturnMasked extends MaskedFunction=MaskedFunction<Opts['parent']>> (opts: Opts): ReturnMasked;\n\n/** Creates new {@link Masked} depending on mask type */\nfunction createMask(opts) {\n  if (IMask.Masked && opts instanceof IMask.Masked) return opts;\n  const nOpts = normalizeOpts(opts);\n  const MaskedClass = maskedClass(nOpts.mask);\n  if (!MaskedClass) throw new Error('Masked class is not found for provided mask, appropriate module needs to be imported manually before creating mask.');\n  if (nOpts.mask === MaskedClass) delete nOpts.mask;\n  if (nOpts._mask) {\n    nOpts.mask = nOpts._mask;\n    delete nOpts._mask;\n  }\n  return new MaskedClass(nOpts);\n}\nIMask.createMask = createMask;\n\nexport { createMask as default, maskedClass, normalizeOpts };\n","import ChangeDetails from '../../core/change-details.js';\nimport { isString } from '../../core/utils.js';\nimport ContinuousTailDetails from '../../core/continuous-tail-details.js';\nimport IMask from '../../core/holder.js';\n\nclass ChunksTailDetails {\n  /** */\n\n  constructor(chunks, from) {\n    if (chunks === void 0) {\n      chunks = [];\n    }\n    if (from === void 0) {\n      from = 0;\n    }\n    this.chunks = chunks;\n    this.from = from;\n  }\n  toString() {\n    return this.chunks.map(String).join('');\n  }\n  extend(tailChunk) {\n    if (!String(tailChunk)) return;\n    tailChunk = isString(tailChunk) ? new ContinuousTailDetails(String(tailChunk)) : tailChunk;\n    const lastChunk = this.chunks[this.chunks.length - 1];\n    const extendLast = lastChunk && (\n    // if stops are same or tail has no stop\n    lastChunk.stop === tailChunk.stop || tailChunk.stop == null) &&\n    // if tail chunk goes just after last chunk\n    tailChunk.from === lastChunk.from + lastChunk.toString().length;\n    if (tailChunk instanceof ContinuousTailDetails) {\n      // check the ability to extend previous chunk\n      if (extendLast) {\n        // extend previous chunk\n        lastChunk.extend(tailChunk.toString());\n      } else {\n        // append new chunk\n        this.chunks.push(tailChunk);\n      }\n    } else if (tailChunk instanceof ChunksTailDetails) {\n      if (tailChunk.stop == null) {\n        // unwrap floating chunks to parent, keeping `from` pos\n        let firstTailChunk;\n        while (tailChunk.chunks.length && tailChunk.chunks[0].stop == null) {\n          firstTailChunk = tailChunk.chunks.shift(); // not possible to be `undefined` because length was checked above\n          firstTailChunk.from += tailChunk.from;\n          this.extend(firstTailChunk);\n        }\n      }\n\n      // if tail chunk still has value\n      if (tailChunk.toString()) {\n        // if chunks contains stops, then popup stop to container\n        tailChunk.stop = tailChunk.blockIndex;\n        this.chunks.push(tailChunk);\n      }\n    }\n  }\n  appendTo(masked) {\n    if (!(masked instanceof IMask.MaskedPattern)) {\n      const tail = new ContinuousTailDetails(this.toString());\n      return tail.appendTo(masked);\n    }\n    const details = new ChangeDetails();\n    for (let ci = 0; ci < this.chunks.length && !details.skip; ++ci) {\n      const chunk = this.chunks[ci];\n      const lastBlockIter = masked._mapPosToBlock(masked.displayValue.length);\n      const stop = chunk.stop;\n      let chunkBlock;\n      if (stop != null && (\n      // if block not found or stop is behind lastBlock\n      !lastBlockIter || lastBlockIter.index <= stop)) {\n        if (chunk instanceof ChunksTailDetails ||\n        // for continuous block also check if stop is exist\n        masked._stops.indexOf(stop) >= 0) {\n          const phDetails = masked._appendPlaceholder(stop);\n          details.aggregate(phDetails);\n        }\n        chunkBlock = chunk instanceof ChunksTailDetails && masked._blocks[stop];\n      }\n      if (chunkBlock) {\n        const tailDetails = chunkBlock.appendTail(chunk);\n        tailDetails.skip = false; // always ignore skip, it will be set on last\n        details.aggregate(tailDetails);\n        masked._value += tailDetails.inserted;\n\n        // get not inserted chars\n        const remainChars = chunk.toString().slice(tailDetails.rawInserted.length);\n        if (remainChars) details.aggregate(masked.append(remainChars, {\n          tail: true\n        }));\n      } else {\n        details.aggregate(masked.append(chunk.toString(), {\n          tail: true\n        }));\n      }\n    }\n    return details;\n  }\n  get state() {\n    return {\n      chunks: this.chunks.map(c => c.state),\n      from: this.from,\n      stop: this.stop,\n      blockIndex: this.blockIndex\n    };\n  }\n  set state(state) {\n    const {\n      chunks,\n      ...props\n    } = state;\n    Object.assign(this, props);\n    this.chunks = chunks.map(cstate => {\n      const chunk = \"chunks\" in cstate ? new ChunksTailDetails() : new ContinuousTailDetails();\n      chunk.state = cstate;\n      return chunk;\n    });\n  }\n  unshift(beforePos) {\n    if (!this.chunks.length || beforePos != null && this.from >= beforePos) return '';\n    const chunkShiftPos = beforePos != null ? beforePos - this.from : beforePos;\n    let ci = 0;\n    while (ci < this.chunks.length) {\n      const chunk = this.chunks[ci];\n      const shiftChar = chunk.unshift(chunkShiftPos);\n      if (chunk.toString()) {\n        // chunk still contains value\n        // but not shifted - means no more available chars to shift\n        if (!shiftChar) break;\n        ++ci;\n      } else {\n        // clean if chunk has no value\n        this.chunks.splice(ci, 1);\n      }\n      if (shiftChar) return shiftChar;\n    }\n    return '';\n  }\n  shift() {\n    if (!this.chunks.length) return '';\n    let ci = this.chunks.length - 1;\n    while (0 <= ci) {\n      const chunk = this.chunks[ci];\n      const shiftChar = chunk.shift();\n      if (chunk.toString()) {\n        // chunk still contains value\n        // but not shifted - means no more available chars to shift\n        if (!shiftChar) break;\n        --ci;\n      } else {\n        // clean if chunk has no value\n        this.chunks.splice(ci, 1);\n      }\n      if (shiftChar) return shiftChar;\n    }\n    return '';\n  }\n}\n\nexport { ChunksTailDetails as default };\n","import { DIRECTION } from '../../core/utils.js';\n\nclass PatternCursor {\n  constructor(masked, pos) {\n    this.masked = masked;\n    this._log = [];\n    const {\n      offset,\n      index\n    } = masked._mapPosToBlock(pos) || (pos < 0 ?\n    // first\n    {\n      index: 0,\n      offset: 0\n    } :\n    // last\n    {\n      index: this.masked._blocks.length,\n      offset: 0\n    });\n    this.offset = offset;\n    this.index = index;\n    this.ok = false;\n  }\n  get block() {\n    return this.masked._blocks[this.index];\n  }\n  get pos() {\n    return this.masked._blockStartPos(this.index) + this.offset;\n  }\n  get state() {\n    return {\n      index: this.index,\n      offset: this.offset,\n      ok: this.ok\n    };\n  }\n  set state(s) {\n    Object.assign(this, s);\n  }\n  pushState() {\n    this._log.push(this.state);\n  }\n  popState() {\n    const s = this._log.pop();\n    if (s) this.state = s;\n    return s;\n  }\n  bindBlock() {\n    if (this.block) return;\n    if (this.index < 0) {\n      this.index = 0;\n      this.offset = 0;\n    }\n    if (this.index >= this.masked._blocks.length) {\n      this.index = this.masked._blocks.length - 1;\n      this.offset = this.block.displayValue.length; // TODO this is stupid type error, `block` depends on index that was changed above\n    }\n  }\n\n  _pushLeft(fn) {\n    this.pushState();\n    for (this.bindBlock(); 0 <= this.index; --this.index, this.offset = ((_this$block = this.block) == null ? void 0 : _this$block.displayValue.length) || 0) {\n      var _this$block;\n      if (fn()) return this.ok = true;\n    }\n    return this.ok = false;\n  }\n  _pushRight(fn) {\n    this.pushState();\n    for (this.bindBlock(); this.index < this.masked._blocks.length; ++this.index, this.offset = 0) {\n      if (fn()) return this.ok = true;\n    }\n    return this.ok = false;\n  }\n  pushLeftBeforeFilled() {\n    return this._pushLeft(() => {\n      if (this.block.isFixed || !this.block.value) return;\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.FORCE_LEFT);\n      if (this.offset !== 0) return true;\n    });\n  }\n  pushLeftBeforeInput() {\n    // cases:\n    // filled input: 00|\n    // optional empty input: 00[]|\n    // nested block: XX<[]>|\n    return this._pushLeft(() => {\n      if (this.block.isFixed) return;\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.LEFT);\n      return true;\n    });\n  }\n  pushLeftBeforeRequired() {\n    return this._pushLeft(() => {\n      if (this.block.isFixed || this.block.isOptional && !this.block.value) return;\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.LEFT);\n      return true;\n    });\n  }\n  pushRightBeforeFilled() {\n    return this._pushRight(() => {\n      if (this.block.isFixed || !this.block.value) return;\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.FORCE_RIGHT);\n      if (this.offset !== this.block.value.length) return true;\n    });\n  }\n  pushRightBeforeInput() {\n    return this._pushRight(() => {\n      if (this.block.isFixed) return;\n\n      // const o = this.offset;\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.NONE);\n      // HACK cases like (STILL DOES NOT WORK FOR NESTED)\n      // aa|X\n      // aa<X|[]>X_    - this will not work\n      // if (o && o === this.offset && this.block instanceof PatternInputDefinition) continue;\n      return true;\n    });\n  }\n  pushRightBeforeRequired() {\n    return this._pushRight(() => {\n      if (this.block.isFixed || this.block.isOptional && !this.block.value) return;\n\n      // TODO check |[*]XX_\n      this.offset = this.block.nearestInputPos(this.offset, DIRECTION.NONE);\n      return true;\n    });\n  }\n}\n\nexport { PatternCursor as default };\n","import ChangeDetails from '../../core/change-details.js';\nimport { DIRECTION, isString } from '../../core/utils.js';\nimport ContinuousTailDetails from '../../core/continuous-tail-details.js';\nimport '../../core/holder.js';\n\nclass PatternFixedDefinition {\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  constructor(opts) {\n    Object.assign(this, opts);\n    this._value = '';\n    this.isFixed = true;\n  }\n  get value() {\n    return this._value;\n  }\n  get unmaskedValue() {\n    return this.isUnmasking ? this.value : '';\n  }\n  get rawInputValue() {\n    return this._isRawInput ? this.value : '';\n  }\n  get displayValue() {\n    return this.value;\n  }\n  reset() {\n    this._isRawInput = false;\n    this._value = '';\n  }\n  remove(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this._value.length;\n    }\n    this._value = this._value.slice(0, fromPos) + this._value.slice(toPos);\n    if (!this._value) this._isRawInput = false;\n    return new ChangeDetails();\n  }\n  nearestInputPos(cursorPos, direction) {\n    if (direction === void 0) {\n      direction = DIRECTION.NONE;\n    }\n    const minPos = 0;\n    const maxPos = this._value.length;\n    switch (direction) {\n      case DIRECTION.LEFT:\n      case DIRECTION.FORCE_LEFT:\n        return minPos;\n      case DIRECTION.NONE:\n      case DIRECTION.RIGHT:\n      case DIRECTION.FORCE_RIGHT:\n      default:\n        return maxPos;\n    }\n  }\n  totalInputPositions(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this._value.length;\n    }\n    return this._isRawInput ? toPos - fromPos : 0;\n  }\n  extractInput(fromPos, toPos, flags) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this._value.length;\n    }\n    if (flags === void 0) {\n      flags = {};\n    }\n    return flags.raw && this._isRawInput && this._value.slice(fromPos, toPos) || '';\n  }\n  get isComplete() {\n    return true;\n  }\n  get isFilled() {\n    return Boolean(this._value);\n  }\n  _appendChar(ch, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    const details = new ChangeDetails();\n    if (this.isFilled) return details;\n    const appendEager = this.eager === true || this.eager === 'append';\n    const appended = this.char === ch;\n    const isResolved = appended && (this.isUnmasking || flags.input || flags.raw) && (!flags.raw || !appendEager) && !flags.tail;\n    if (isResolved) details.rawInserted = this.char;\n    this._value = details.inserted = this.char;\n    this._isRawInput = isResolved && (flags.raw || flags.input);\n    return details;\n  }\n  _appendEager() {\n    return this._appendChar(this.char, {\n      tail: true\n    });\n  }\n  _appendPlaceholder() {\n    const details = new ChangeDetails();\n    if (this.isFilled) return details;\n    this._value = details.inserted = this.char;\n    return details;\n  }\n  extractTail() {\n    return new ContinuousTailDetails('');\n  }\n  appendTail(tail) {\n    if (isString(tail)) tail = new ContinuousTailDetails(String(tail));\n    return tail.appendTo(this);\n  }\n  append(str, flags, tail) {\n    const details = this._appendChar(str[0], flags);\n    if (tail != null) {\n      details.tailShift += this.appendTail(tail).tailShift;\n    }\n    return details;\n  }\n  doCommit() {}\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    this._isRawInput = Boolean(state._rawInputValue);\n  }\n}\n\nexport { PatternFixedDefinition as default };\n","import createMask from '../factory.js';\nimport ChangeDetails from '../../core/change-details.js';\nimport { DIRECTION } from '../../core/utils.js';\nimport '../../core/holder.js';\n\nclass PatternInputDefinition {\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  /** */\n\n  constructor(opts) {\n    const {\n      parent,\n      isOptional,\n      placeholderChar,\n      displayChar,\n      lazy,\n      eager,\n      ...maskOpts\n    } = opts;\n    this.masked = createMask(maskOpts);\n    Object.assign(this, {\n      parent,\n      isOptional,\n      placeholderChar,\n      displayChar,\n      lazy,\n      eager\n    });\n  }\n  reset() {\n    this.isFilled = false;\n    this.masked.reset();\n  }\n  remove(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.value.length;\n    }\n    if (fromPos === 0 && toPos >= 1) {\n      this.isFilled = false;\n      return this.masked.remove(fromPos, toPos);\n    }\n    return new ChangeDetails();\n  }\n  get value() {\n    return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : '');\n  }\n  get unmaskedValue() {\n    return this.masked.unmaskedValue;\n  }\n  get rawInputValue() {\n    return this.masked.rawInputValue;\n  }\n  get displayValue() {\n    return this.masked.value && this.displayChar || this.value;\n  }\n  get isComplete() {\n    return Boolean(this.masked.value) || this.isOptional;\n  }\n  _appendChar(ch, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    if (this.isFilled) return new ChangeDetails();\n    const state = this.masked.state;\n    // simulate input\n    const details = this.masked._appendChar(ch, this.currentMaskFlags(flags));\n    if (details.inserted && this.doValidate(flags) === false) {\n      details.inserted = details.rawInserted = '';\n      this.masked.state = state;\n    }\n    if (!details.inserted && !this.isOptional && !this.lazy && !flags.input) {\n      details.inserted = this.placeholderChar;\n    }\n    details.skip = !details.inserted && !this.isOptional;\n    this.isFilled = Boolean(details.inserted);\n    return details;\n  }\n  append(str, flags, tail) {\n    // TODO probably should be done via _appendChar\n    return this.masked.append(str, this.currentMaskFlags(flags), tail);\n  }\n  _appendPlaceholder() {\n    const details = new ChangeDetails();\n    if (this.isFilled || this.isOptional) return details;\n    this.isFilled = true;\n    details.inserted = this.placeholderChar;\n    return details;\n  }\n  _appendEager() {\n    return new ChangeDetails();\n  }\n  extractTail(fromPos, toPos) {\n    return this.masked.extractTail(fromPos, toPos);\n  }\n  appendTail(tail) {\n    return this.masked.appendTail(tail);\n  }\n  extractInput(fromPos, toPos, flags) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.value.length;\n    }\n    return this.masked.extractInput(fromPos, toPos, flags);\n  }\n  nearestInputPos(cursorPos, direction) {\n    if (direction === void 0) {\n      direction = DIRECTION.NONE;\n    }\n    const minPos = 0;\n    const maxPos = this.value.length;\n    const boundPos = Math.min(Math.max(cursorPos, minPos), maxPos);\n    switch (direction) {\n      case DIRECTION.LEFT:\n      case DIRECTION.FORCE_LEFT:\n        return this.isComplete ? boundPos : minPos;\n      case DIRECTION.RIGHT:\n      case DIRECTION.FORCE_RIGHT:\n        return this.isComplete ? boundPos : maxPos;\n      case DIRECTION.NONE:\n      default:\n        return boundPos;\n    }\n  }\n  totalInputPositions(fromPos, toPos) {\n    if (fromPos === void 0) {\n      fromPos = 0;\n    }\n    if (toPos === void 0) {\n      toPos = this.value.length;\n    }\n    return this.value.slice(fromPos, toPos).length;\n  }\n  doValidate(flags) {\n    return this.masked.doValidate(this.currentMaskFlags(flags)) && (!this.parent || this.parent.doValidate(this.currentMaskFlags(flags)));\n  }\n  doCommit() {\n    this.masked.doCommit();\n  }\n  get state() {\n    return {\n      _value: this.value,\n      _rawInputValue: this.rawInputValue,\n      masked: this.masked.state,\n      isFilled: this.isFilled\n    };\n  }\n  set state(state) {\n    this.masked.state = state.masked;\n    this.isFilled = state.isFilled;\n  }\n  currentMaskFlags(flags) {\n    var _flags$_beforeTailSta;\n    return {\n      ...flags,\n      _beforeTailState: (flags == null || (_flags$_beforeTailSta = flags._beforeTailState) == null ? void 0 : _flags$_beforeTailSta.masked) || (flags == null ? void 0 : flags._beforeTailState)\n    };\n  }\n}\nPatternInputDefinition.DEFAULT_DEFINITIONS = {\n  '0': /\\d/,\n  'a': /[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0\\u08A2-\\u08AC\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA697\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA80-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/,\n  // http://stackoverflow.com/a/22075070\n  '*': /./\n};\n\nexport { PatternInputDefinition as default };\n","import Masked from './base.js';\nimport IMask from '../core/holder.js';\nimport '../core/change-details.js';\nimport '../core/continuous-tail-details.js';\nimport '../core/utils.js';\n\n/** Masking by RegExp */\nclass MaskedRegExp extends Masked {\n  /** */\n\n  /** Enable characters overwriting */\n\n  /** */\n\n  /** */\n\n  updateOptions(opts) {\n    super.updateOptions(opts);\n  }\n  _update(opts) {\n    const mask = opts.mask;\n    if (mask) opts.validate = value => value.search(mask) >= 0;\n    super._update(opts);\n  }\n}\nIMask.MaskedRegExp = MaskedRegExp;\n\nexport { MaskedRegExp as default };\n","import ChangeDetails from '../core/change-details.js';\nimport IMask from '../core/holder.js';\nimport { DIRECTION } from '../core/utils.js';\nimport Masked from './base.js';\nimport createMask, { normalizeOpts } from './factory.js';\nimport ChunksTailDetails from './pattern/chunk-tail-details.js';\nimport PatternCursor from './pattern/cursor.js';\nimport PatternFixedDefinition from './pattern/fixed-definition.js';\nimport PatternInputDefinition from './pattern/input-definition.js';\nimport './regexp.js';\nimport '../core/continuous-tail-details.js';\n\n/** Pattern mask */\nclass MaskedPattern extends Masked {\n  /** */\n\n  /** */\n\n  /** Single char for empty input */\n\n  /** Single char for filled input */\n\n  /** Show placeholder only when needed */\n\n  /** Enable characters overwriting */\n\n  /** */\n\n  /** */\n\n  constructor(opts) {\n    super({\n      ...MaskedPattern.DEFAULTS,\n      ...opts,\n      definitions: Object.assign({}, PatternInputDefinition.DEFAULT_DEFINITIONS, opts == null ? void 0 : opts.definitions)\n    });\n  }\n  updateOptions(opts) {\n    super.updateOptions(opts);\n  }\n  _update(opts) {\n    opts.definitions = Object.assign({}, this.definitions, opts.definitions);\n    super._update(opts);\n    this._rebuildMask();\n  }\n  _rebuildMask() {\n    const defs = this.definitions;\n    this._blocks = [];\n    this.exposeBlock = undefined;\n    this._stops = [];\n    this._maskedBlocks = {};\n    const pattern = this.mask;\n    if (!pattern || !defs) return;\n    let unmaskingBlock = false;\n    let optionalBlock = false;\n    for (let i = 0; i < pattern.length; ++i) {\n      if (this.blocks) {\n        const p = pattern.slice(i);\n        const bNames = Object.keys(this.blocks).filter(bName => p.indexOf(bName) === 0);\n        // order by key length\n        bNames.sort((a, b) => b.length - a.length);\n        // use block name with max length\n        const bName = bNames[0];\n        if (bName) {\n          const {\n            expose,\n            ...blockOpts\n          } = normalizeOpts(this.blocks[bName]);\n          const maskedBlock = createMask({\n            lazy: this.lazy,\n            eager: this.eager,\n            placeholderChar: this.placeholderChar,\n            displayChar: this.displayChar,\n            overwrite: this.overwrite,\n            ...blockOpts,\n            parent: this\n          });\n          if (maskedBlock) {\n            this._blocks.push(maskedBlock);\n            if (expose) this.exposeBlock = maskedBlock;\n\n            // store block index\n            if (!this._maskedBlocks[bName]) this._maskedBlocks[bName] = [];\n            this._maskedBlocks[bName].push(this._blocks.length - 1);\n          }\n          i += bName.length - 1;\n          continue;\n        }\n      }\n      let char = pattern[i];\n      let isInput = (char in defs);\n      if (char === MaskedPattern.STOP_CHAR) {\n        this._stops.push(this._blocks.length);\n        continue;\n      }\n      if (char === '{' || char === '}') {\n        unmaskingBlock = !unmaskingBlock;\n        continue;\n      }\n      if (char === '[' || char === ']') {\n        optionalBlock = !optionalBlock;\n        continue;\n      }\n      if (char === MaskedPattern.ESCAPE_CHAR) {\n        ++i;\n        char = pattern[i];\n        if (!char) break;\n        isInput = false;\n      }\n      const def = isInput ? new PatternInputDefinition({\n        isOptional: optionalBlock,\n        lazy: this.lazy,\n        eager: this.eager,\n        placeholderChar: this.placeholderChar,\n        displayChar: this.displayChar,\n        ...normalizeOpts(defs[char]),\n        parent: this\n      }) : new PatternFixedDefinition({\n        char,\n        eager: this.eager,\n        isUnmasking: unmaskingBlock\n      });\n      this._blocks.push(def);\n    }\n  }\n  get state() {\n    return {\n      ...super.state,\n      _blocks: this._blocks.map(b => b.state)\n    };\n  }\n  set state(state) {\n    const {\n      _blocks,\n      ...maskedState\n    } = state;\n    this._blocks.forEach((b, bi) => b.state = _blocks[bi]);\n    super.state = maskedState;\n  }\n  reset() {\n    super.reset();\n    this._blocks.forEach(b => b.reset());\n  }\n  get isComplete() {\n    return this.exposeBlock ? this.exposeBlock.isComplete : this._blocks.every(b => b.isComplete);\n  }\n  get isFilled() {\n    return this._blocks.every(b => b.isFilled);\n  }\n  get isFixed() {\n    return this._blocks.every(b => b.isFixed);\n  }\n  get isOptional() {\n    return this._blocks.every(b => b.isOptional);\n  }\n  doCommit() {\n    this._blocks.forEach(b => b.doCommit());\n    super.doCommit();\n  }\n  get unmaskedValue() {\n    return this.exposeBlock ? this.exposeBlock.unmaskedValue : this._blocks.reduce((str, b) => str += b.unmaskedValue, '');\n  }\n  set unmaskedValue(unmaskedValue) {\n    if (this.exposeBlock) {\n      const tail = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);\n      this.exposeBlock.unmaskedValue = unmaskedValue;\n      this.appendTail(tail);\n      this.doCommit();\n    } else super.unmaskedValue = unmaskedValue;\n  }\n  get value() {\n    return this.exposeBlock ? this.exposeBlock.value :\n    // TODO return _value when not in change?\n    this._blocks.reduce((str, b) => str += b.value, '');\n  }\n  set value(value) {\n    if (this.exposeBlock) {\n      const tail = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);\n      this.exposeBlock.value = value;\n      this.appendTail(tail);\n      this.doCommit();\n    } else super.value = value;\n  }\n  get typedValue() {\n    return this.exposeBlock ? this.exposeBlock.typedValue : super.typedValue;\n  }\n  set typedValue(value) {\n    if (this.exposeBlock) {\n      const tail = this.extractTail(this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length);\n      this.exposeBlock.typedValue = value;\n      this.appendTail(tail);\n      this.doCommit();\n    } else super.typedValue = value;\n  }\n  get displayValue() {\n    return this._blocks.reduce((str, b) => str += b.displayValue, '');\n  }\n  appendTail(tail) {\n    return super.appendTail(tail).aggregate(this._appendPlaceholder());\n  }\n  _appendEager() {\n    var _this$_mapPosToBlock;\n    const details = new ChangeDetails();\n    let startBlockIndex = (_this$_mapPosToBlock = this._mapPosToBlock(this.displayValue.length)) == null ? void 0 : _this$_mapPosToBlock.index;\n    if (startBlockIndex == null) return details;\n\n    // TODO test if it works for nested pattern masks\n    if (this._blocks[startBlockIndex].isFilled) ++startBlockIndex;\n    for (let bi = startBlockIndex; bi < this._blocks.length; ++bi) {\n      const d = this._blocks[bi]._appendEager();\n      if (!d.inserted) break;\n      details.aggregate(d);\n    }\n    return details;\n  }\n  _appendCharRaw(ch, flags) {\n    if (flags === void 0) {\n      flags = {};\n    }\n    const blockIter = this._mapPosToBlock(this.displayValue.length);\n    const details = new ChangeDetails();\n    if (!blockIter) return details;\n    for (let bi = blockIter.index;; ++bi) {\n      var _flags$_beforeTailSta;\n      const block = this._blocks[bi];\n      if (!block) break;\n      const blockDetails = block._appendChar(ch, {\n        ...flags,\n        _beforeTailState: (_flags$_beforeTailSta = flags._beforeTailState) == null || (_flags$_beforeTailSta = _flags$_beforeTailSta._blocks) == null ? void 0 : _flags$_beforeTailSta[bi]\n      });\n      const skip = blockDetails.skip;\n      details.aggregate(blockDetails);\n      if (skip || blockDetails.rawInserted) break; // go next char\n    }\n\n    return details;\n  }\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    const chunkTail = new ChunksTailDetails();\n    if (fromPos === toPos) return chunkTail;\n    this._forEachBlocksInRange(fromPos, toPos, (b, bi, bFromPos, bToPos) => {\n      const blockChunk = b.extractTail(bFromPos, bToPos);\n      blockChunk.stop = this._findStopBefore(bi);\n      blockChunk.from = this._blockStartPos(bi);\n      if (blockChunk instanceof ChunksTailDetails) blockChunk.blockIndex = bi;\n      chunkTail.extend(blockChunk);\n    });\n    return chunkTail;\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    if (flags === void 0) {\n      flags = {};\n    }\n    if (fromPos === toPos) return '';\n    let input = '';\n    this._forEachBlocksInRange(fromPos, toPos, (b, _, fromPos, toPos) => {\n      input += b.extractInput(fromPos, toPos, flags);\n    });\n    return input;\n  }\n  _findStopBefore(blockIndex) {\n    let stopBefore;\n    for (let si = 0; si < this._stops.length; ++si) {\n      const stop = this._stops[si];\n      if (stop <= blockIndex) stopBefore = stop;else break;\n    }\n    return stopBefore;\n  }\n\n  /** Appends placeholder depending on laziness */\n  _appendPlaceholder(toBlockIndex) {\n    const details = new ChangeDetails();\n    if (this.lazy && toBlockIndex == null) return details;\n    const startBlockIter = this._mapPosToBlock(this.displayValue.length);\n    if (!startBlockIter) return details;\n    const startBlockIndex = startBlockIter.index;\n    const endBlockIndex = toBlockIndex != null ? toBlockIndex : this._blocks.length;\n    this._blocks.slice(startBlockIndex, endBlockIndex).forEach(b => {\n      if (!b.lazy || toBlockIndex != null) {\n        var _blocks2;\n        const bDetails = b._appendPlaceholder((_blocks2 = b._blocks) == null ? void 0 : _blocks2.length);\n        this._value += bDetails.inserted;\n        details.aggregate(bDetails);\n      }\n    });\n    return details;\n  }\n\n  /** Finds block in pos */\n  _mapPosToBlock(pos) {\n    let accVal = '';\n    for (let bi = 0; bi < this._blocks.length; ++bi) {\n      const block = this._blocks[bi];\n      const blockStartPos = accVal.length;\n      accVal += block.displayValue;\n      if (pos <= accVal.length) {\n        return {\n          index: bi,\n          offset: pos - blockStartPos\n        };\n      }\n    }\n  }\n  _blockStartPos(blockIndex) {\n    return this._blocks.slice(0, blockIndex).reduce((pos, b) => pos += b.displayValue.length, 0);\n  }\n  _forEachBlocksInRange(fromPos, toPos, fn) {\n    if (toPos === void 0) {\n      toPos = this.displayValue.length;\n    }\n    const fromBlockIter = this._mapPosToBlock(fromPos);\n    if (fromBlockIter) {\n      const toBlockIter = this._mapPosToBlock(toPos);\n      // process first block\n      const isSameBlock = toBlockIter && fromBlockIter.index === toBlockIter.index;\n      const fromBlockStartPos = fromBlockIter.offset;\n      const fromBlockEndPos = toBlockIter && isSameBlock ? toBlockIter.offset : this._blocks[fromBlockIter.index].displayValue.length;\n      fn(this._blocks[fromBlockIter.index], fromBlockIter.index, fromBlockStartPos, fromBlockEndPos);\n      if (toBlockIter && !isSameBlock) {\n        // process intermediate blocks\n        for (let bi = fromBlockIter.index + 1; bi < toBlockIter.index; ++bi) {\n          fn(this._blocks[bi], bi, 0, this._blocks[bi].displayValue.length);\n        }\n\n        // process last block\n        fn(this._blocks[toBlockIter.index], toBlockIter.index, 0, toBlockIter.offset);\n      }\n    }\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    const removeDetails = super.remove(fromPos, toPos);\n    this._forEachBlocksInRange(fromPos, toPos, (b, _, bFromPos, bToPos) => {\n      removeDetails.aggregate(b.remove(bFromPos, bToPos));\n    });\n    return removeDetails;\n  }\n  nearestInputPos(cursorPos, direction) {\n    if (direction === void 0) {\n      direction = DIRECTION.NONE;\n    }\n    if (!this._blocks.length) return 0;\n    const cursor = new PatternCursor(this, cursorPos);\n    if (direction === DIRECTION.NONE) {\n      // -------------------------------------------------\n      // NONE should only go out from fixed to the right!\n      // -------------------------------------------------\n      if (cursor.pushRightBeforeInput()) return cursor.pos;\n      cursor.popState();\n      if (cursor.pushLeftBeforeInput()) return cursor.pos;\n      return this.displayValue.length;\n    }\n\n    // FORCE is only about a|* otherwise is 0\n    if (direction === DIRECTION.LEFT || direction === DIRECTION.FORCE_LEFT) {\n      // try to break fast when *|a\n      if (direction === DIRECTION.LEFT) {\n        cursor.pushRightBeforeFilled();\n        if (cursor.ok && cursor.pos === cursorPos) return cursorPos;\n        cursor.popState();\n      }\n\n      // forward flow\n      cursor.pushLeftBeforeInput();\n      cursor.pushLeftBeforeRequired();\n      cursor.pushLeftBeforeFilled();\n\n      // backward flow\n      if (direction === DIRECTION.LEFT) {\n        cursor.pushRightBeforeInput();\n        cursor.pushRightBeforeRequired();\n        if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;\n        cursor.popState();\n        if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;\n        cursor.popState();\n      }\n      if (cursor.ok) return cursor.pos;\n      if (direction === DIRECTION.FORCE_LEFT) return 0;\n      cursor.popState();\n      if (cursor.ok) return cursor.pos;\n      cursor.popState();\n      if (cursor.ok) return cursor.pos;\n      return 0;\n    }\n    if (direction === DIRECTION.RIGHT || direction === DIRECTION.FORCE_RIGHT) {\n      // forward flow\n      cursor.pushRightBeforeInput();\n      cursor.pushRightBeforeRequired();\n      if (cursor.pushRightBeforeFilled()) return cursor.pos;\n      if (direction === DIRECTION.FORCE_RIGHT) return this.displayValue.length;\n\n      // backward flow\n      cursor.popState();\n      if (cursor.ok) return cursor.pos;\n      cursor.popState();\n      if (cursor.ok) return cursor.pos;\n      return this.nearestInputPos(cursorPos, DIRECTION.LEFT);\n    }\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    let total = 0;\n    this._forEachBlocksInRange(fromPos, toPos, (b, _, bFromPos, bToPos) => {\n      total += b.totalInputPositions(bFromPos, bToPos);\n    });\n    return total;\n  }\n\n  /** Get block by name */\n  maskedBlock(name) {\n    return this.maskedBlocks(name)[0];\n  }\n\n  /** Get all blocks by name */\n  maskedBlocks(name) {\n    const indices = this._maskedBlocks[name];\n    if (!indices) return [];\n    return indices.map(gi => this._blocks[gi]);\n  }\n}\nMaskedPattern.DEFAULTS = {\n  lazy: true,\n  placeholderChar: '_'\n};\nMaskedPattern.STOP_CHAR = '`';\nMaskedPattern.ESCAPE_CHAR = '\\\\';\nMaskedPattern.InputDefinition = PatternInputDefinition;\nMaskedPattern.FixedDefinition = PatternFixedDefinition;\nIMask.MaskedPattern = MaskedPattern;\n\nexport { MaskedPattern 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","maskedClass","MaskedRegExp","MaskedPattern","MaskedDate","Number","MaskedNumber","MaskedDynamic","Function","MaskedFunction","console","warn","normalizeOpts","instanceOpts","_mask","startsWith","createMask","nOpts","MaskedClass","ChunksTailDetails","chunks","map","join","tailChunk","lastChunk","extendLast","push","firstTailChunk","blockIndex","chunk","lastBlockIter","_mapPosToBlock","chunkBlock","index","_stops","phDetails","_blocks","remainChars","c","props","cstate","chunkShiftPos","PatternCursor","pos","_log","ok","block","_blockStartPos","s","pushState","popState","pop","bindBlock","_pushLeft","_this$block","_pushRight","pushLeftBeforeFilled","isFixed","pushLeftBeforeInput","pushLeftBeforeRequired","isOptional","pushRightBeforeFilled","pushRightBeforeInput","pushRightBeforeRequired","PatternFixedDefinition","isUnmasking","_isRawInput","maxPos","appendEager","isResolved","char","PatternInputDefinition","placeholderChar","displayChar","lazy","maskOpts","currentMaskFlags","boundPos","max","_flags$_beforeTailSta","DEFAULT_DEFINITIONS","super","search","definitions","_rebuildMask","defs","exposeBlock","_maskedBlocks","pattern","unmaskingBlock","optionalBlock","blocks","p","bNames","filter","bName","sort","expose","blockOpts","maskedBlock","isInput","STOP_CHAR","ESCAPE_CHAR","def","maskedState","forEach","bi","every","_this$_mapPosToBlock","startBlockIndex","blockIter","blockDetails","chunkTail","_forEachBlocksInRange","bFromPos","bToPos","blockChunk","_findStopBefore","stopBefore","si","toBlockIndex","startBlockIter","endBlockIndex","_blocks2","bDetails","accVal","blockStartPos","fromBlockIter","toBlockIter","isSameBlock","fromBlockStartPos","fromBlockEndPos","removeDetails","cursor","total","maskedBlocks","indices","gi","InputDefinition","FixedDefinition"],"sourceRoot":""}