{"version":3,"file":"918.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  /** Additional offset if any changes occurred before tail */\n\n  /** Raw inserted is used by dynamic mask */\n\n  /** Can skip chars */\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      tailShift: 0,\n      skip: false\n    }, details);\n  }\n\n  /** Aggregate changes */\n  aggregate(details) {\n    this.inserted += details.inserted;\n    this.rawInserted += details.rawInserted;\n    this.tailShift += details.tailShift;\n    this.skip = this.skip || details.skip;\n    return this;\n  }\n\n  /** Total offset considering all changes */\n  get offset() {\n    return this.tailShift + this.inserted.length;\n  }\n  get consumed() {\n    return Boolean(this.rawInserted) || this.skip;\n  }\n  equals(details) {\n    return this.inserted === details.inserted && this.tailShift === details.tailShift && this.rawInserted === details.rawInserted && this.skip === details.skip;\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, objectIncludes, 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  /** */\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 (!this.optionsIsChanged(opts)) 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    if (ch) {\n      details = details.aggregate(this._appendCharRaw(ch, flags));\n\n      // TODO handle `skip`?\n\n      // try `autofix` lookahead\n      if (!details.rawInserted && this.autofix === 'pad') {\n        const noFixState = this.state;\n        this.state = consistentState;\n        let fixDetails = this.pad(flags);\n        const chDetails = this._appendCharRaw(ch, flags);\n        fixDetails = fixDetails.aggregate(chDetails);\n\n        // if fix was applied or\n        // if details are equal use skip restoring state optimization\n        if (chDetails.rawInserted || fixDetails.equals(details)) {\n          details = fixDetails;\n        } else {\n          this.state = noFixState;\n        }\n      }\n    }\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          for (let i = 0; i < details.rawInserted.length; ++i) {\n            checkTail.unshift(this.displayValue.length - details.tailShift);\n          }\n        }\n        let tailDetails = this.appendTail(checkTail);\n        appended = tailDetails.rawInserted.length === checkTail.toString().length;\n\n        // not ok, try shift\n        if (!(appended && tailDetails.inserted) && this.overwrite === 'shift') {\n          this.state = beforeTailState;\n          consistentTail = checkTail.state;\n          for (let i = 0; i < details.rawInserted.length; ++i) {\n            checkTail.shift();\n          }\n          tailDetails = this.appendTail(checkTail);\n          appended = tailDetails.rawInserted.length === checkTail.toString().length;\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    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      this.doCommit();\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 (inserted === void 0) {\n      inserted = '';\n    }\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  optionsIsChanged(opts) {\n    return !objectIncludes(this, opts);\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  pad(flags) {\n    return new ChangeDetails();\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\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 \" + nOpts.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; ++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          details.aggregate(masked._appendPlaceholder(stop));\n        }\n        chunkBlock = chunk instanceof ChunksTailDetails && masked._blocks[stop];\n      }\n      if (chunkBlock) {\n        const tailDetails = chunkBlock.appendTail(chunk);\n        details.aggregate(tailDetails);\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  _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    if (this.isFilled) return new ChangeDetails();\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    const details = new ChangeDetails({\n      inserted: this.char,\n      rawInserted: isResolved ? this.char : ''\n    });\n    this._value = 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  pad(flags) {\n    return this._appendPlaceholder();\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    let details = this.masked._appendChar(ch, this.currentMaskFlags(flags));\n    if (details.inserted && this.doValidate(flags) === false) {\n      details = new ChangeDetails();\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    if (this.isFilled || this.isOptional) return new ChangeDetails();\n    this.isFilled = true;\n    return new ChangeDetails({\n      inserted: this.placeholderChar\n    });\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  pad(flags) {\n    return new ChangeDetails();\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  /** */\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  /** */\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            repeat,\n            ...bOpts\n          } = normalizeOpts(this.blocks[bName]); // TODO type Opts<Arg & Extra>\n          const blockOpts = {\n            lazy: this.lazy,\n            eager: this.eager,\n            placeholderChar: this.placeholderChar,\n            displayChar: this.displayChar,\n            overwrite: this.overwrite,\n            autofix: this.autofix,\n            ...bOpts,\n            repeat,\n            parent: this\n          };\n          const maskedBlock = repeat != null ? new IMask.RepeatBlock(blockOpts /* TODO */) : createMask(blockOpts);\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    if (!state) {\n      this.reset();\n      return;\n    }\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, block; block = this._blocks[bi]; ++bi) {\n      var _flags$_beforeTailSta;\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      details.aggregate(blockDetails);\n      if (blockDetails.consumed) break; // go next char\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        details.aggregate(b._appendPlaceholder((_blocks2 = b._blocks) == null ? void 0 : _blocks2.length));\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  pad(flags) {\n    const details = new ChangeDetails();\n    this._forEachBlocksInRange(0, this.displayValue.length, b => details.aggregate(b.pad(flags)));\n    return details;\n  }\n}\nMaskedPattern.DEFAULTS = {\n  ...Masked.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","tailShift","skip","aggregate","offset","length","consumed","Boolean","equals","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","optionsIsChanged","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","autofix","noFixState","fixDetails","pad","chDetails","consistentTail","appended","doValidate","beforeTailState","overwrite","tailDetails","_appendEager","Error","_beforeTailState","doPrepare","ci","d","doSkipInvalid","eager","remove","fn","_refreshing","rawInput","ret","indexOf","runIsolated","_isolated","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","_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","repeat","bOpts","blockOpts","maskedBlock","RepeatBlock","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","accVal","blockStartPos","fromBlockIter","toBlockIter","isSameBlock","fromBlockStartPos","fromBlockEndPos","removeDetails","cursor","total","maskedBlocks","indices","gi","InputDefinition","FixedDefinition"],"sourceRoot":""}