{"version":3,"sources":["jsdelivr-header.js","/npm/@maskito/core@5.4.0/index.cjs.js"],"names":[],"mappings":"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","file":"/npm/@maskito/core@5.4.0/index.cjs.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.48.0.\n * Original file: /npm/@maskito/core@5.4.0/index.cjs.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nfunction getContentEditableSelection(element) {\n    const { anchorOffset = 0, focusOffset = 0 } = element.ownerDocument.getSelection() || {};\n    const from = Math.min(anchorOffset, focusOffset);\n    const to = Math.max(anchorOffset, focusOffset);\n    return [from, to];\n}\n\nfunction setContentEditableSelection(element, [from, to]) {\n    const document = element.ownerDocument;\n    const range = document.createRange();\n    range.setStart(element.firstChild || element, Math.min(from, element.textContent?.length ?? 0));\n    range.setEnd(element.lastChild || element, Math.min(to, element.textContent?.length ?? 0));\n    const selection = document.getSelection();\n    if (selection) {\n        selection.removeAllRanges();\n        selection.addRange(range);\n    }\n}\n\nclass ContentEditableAdapter {\n    constructor(element) {\n        this.element = element;\n        this.maxLength = Infinity;\n    }\n    get value() {\n        return this.element.innerText.replace(/\\n\\n$/, '\\n');\n    }\n    set value(value) {\n        // Setting into innerHTML of element with `white-space: pre;` style\n        this.element.innerHTML = value.replace(/\\n$/, '\\n\\n');\n    }\n    get selectionStart() {\n        return getContentEditableSelection(this.element)[0];\n    }\n    get selectionEnd() {\n        return getContentEditableSelection(this.element)[1];\n    }\n    setSelectionRange(from, to) {\n        setContentEditableSelection(this.element, [from ?? 0, to ?? 0]);\n    }\n    select() {\n        this.setSelectionRange(0, this.value.length);\n    }\n}\nfunction maskitoAdaptContentEditable(element) {\n    const adapter = new ContentEditableAdapter(element);\n    return new Proxy(element, {\n        get(target, prop) {\n            if (prop in adapter) {\n                return adapter[prop];\n            }\n            const nativeProperty = target[prop];\n            return typeof nativeProperty === 'function'\n                ? nativeProperty.bind(target)\n                : nativeProperty;\n        },\n        set(target, prop, val, receiver) {\n            return Reflect.set(prop in adapter ? adapter : target, prop, val, receiver);\n        },\n    });\n}\n\nconst MASKITO_DEFAULT_ELEMENT_PREDICATE = (e) => e.isContentEditable\n    ? maskitoAdaptContentEditable(e)\n    : e.querySelector('input,textarea') ||\n        e;\n\nconst MASKITO_DEFAULT_OPTIONS = {\n    mask: /^.*$/,\n    preprocessors: [],\n    postprocessors: [],\n    plugins: [],\n    overwriteMode: 'shift',\n};\n\nclass MaskHistory {\n    constructor() {\n        this.now = null;\n        this.past = [];\n        this.future = [];\n    }\n    undo() {\n        const state = this.past.pop();\n        if (state && this.now) {\n            this.future.push(this.now);\n            this.updateElement(state, 'historyUndo');\n        }\n    }\n    redo() {\n        const state = this.future.pop();\n        if (state && this.now) {\n            this.past.push(this.now);\n            this.updateElement(state, 'historyRedo');\n        }\n    }\n    updateHistory(state) {\n        if (!this.now) {\n            this.now = state;\n            return;\n        }\n        const isValueChanged = this.now.value !== state.value;\n        const isSelectionChanged = this.now.selection.some((item, index) => item !== state.selection[index]);\n        if (!isValueChanged && !isSelectionChanged) {\n            return;\n        }\n        if (isValueChanged) {\n            this.past.push(this.now);\n            this.future = [];\n        }\n        this.now = state;\n    }\n    updateElement(state, inputType) {\n        this.now = state;\n        this.updateElementState(state, { inputType, data: null });\n    }\n}\n\nfunction areElementValuesEqual(sampleState, ...states) {\n    return states.every(({ value }) => value === sampleState.value);\n}\nfunction areElementStatesEqual(sampleState, ...states) {\n    return states.every(({ value, selection }) => value === sampleState.value &&\n        selection[0] === sampleState.selection[0] &&\n        selection[1] === sampleState.selection[1]);\n}\n\nfunction applyOverwriteMode({ value, selection }, newCharacters, mode) {\n    const [from, to] = selection;\n    const computedMode = typeof mode === 'function' ? mode({ value, selection }) : mode;\n    return {\n        value,\n        selection: computedMode === 'replace'\n            ? [from, Math.max(from + newCharacters.length, to)]\n            : [from, to],\n    };\n}\n\nfunction isFixedCharacter(char) {\n    return typeof char === 'string';\n}\n\nfunction getLeadingFixedCharacters(mask, validatedValuePart, newCharacter, initialElementState) {\n    let leadingFixedCharacters = '';\n    for (let i = validatedValuePart.length; i < mask.length; i++) {\n        const charConstraint = mask[i] || '';\n        const isInitiallyExisted = initialElementState?.value[i] === charConstraint;\n        if (!isFixedCharacter(charConstraint) ||\n            (charConstraint === newCharacter && !isInitiallyExisted)) {\n            return leadingFixedCharacters;\n        }\n        leadingFixedCharacters += charConstraint;\n    }\n    return leadingFixedCharacters;\n}\n\nfunction validateValueWithMask(value, maskExpression) {\n    return Array.isArray(maskExpression)\n        ? value.length === maskExpression.length &&\n            Array.from(value).every((char, i) => {\n                const charConstraint = maskExpression[i] || '';\n                return isFixedCharacter(charConstraint)\n                    ? char === charConstraint\n                    : char.match(charConstraint);\n            })\n        : maskExpression.test(value);\n}\n\nfunction guessValidValueByPattern(elementState, mask, initialElementState) {\n    let maskedFrom = null;\n    let maskedTo = null;\n    const maskedValue = Array.from(elementState.value).reduce((validatedCharacters, char, charIndex) => {\n        const leadingCharacters = getLeadingFixedCharacters(mask, validatedCharacters, char, initialElementState);\n        const newValidatedChars = `${validatedCharacters}${leadingCharacters}`;\n        const charConstraint = mask[newValidatedChars.length] || '';\n        if (maskedFrom === null && charIndex >= elementState.selection[0]) {\n            maskedFrom = newValidatedChars.length;\n        }\n        if (maskedTo === null && charIndex >= elementState.selection[1]) {\n            maskedTo = newValidatedChars.length;\n        }\n        if (isFixedCharacter(charConstraint)) {\n            return `${newValidatedChars}${charConstraint}`;\n        }\n        if (char.match(charConstraint)) {\n            return `${newValidatedChars}${char}`;\n        }\n        return leadingCharacters.startsWith(char)\n            ? newValidatedChars\n            : validatedCharacters;\n    }, '');\n    const trailingFixedCharacters = getLeadingFixedCharacters(mask, maskedValue, '', initialElementState);\n    return {\n        value: validateValueWithMask(`${maskedValue}${trailingFixedCharacters}`, mask)\n            ? `${maskedValue}${trailingFixedCharacters}`\n            : maskedValue,\n        // issues: https://github.com/typescript-eslint/typescript-eslint/issues/12069\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        selection: [maskedFrom ?? maskedValue.length, maskedTo ?? maskedValue.length],\n    };\n}\n\nfunction guessValidValueByRegExp({ value, selection }, maskRegExp) {\n    const [from, to] = selection;\n    let newFrom = from;\n    let newTo = to;\n    const validatedValue = Array.from(value).reduce((validatedValuePart, char, i) => {\n        const newPossibleValue = `${validatedValuePart}${char}`;\n        if (from === i) {\n            newFrom = validatedValuePart.length;\n        }\n        if (to === i) {\n            newTo = validatedValuePart.length;\n        }\n        return newPossibleValue.match(maskRegExp) ? newPossibleValue : validatedValuePart;\n    }, '');\n    return {\n        value: validatedValue,\n        selection: [\n            Math.min(newFrom, validatedValue.length),\n            Math.min(newTo, validatedValue.length),\n        ],\n    };\n}\n\nfunction calibrateValueByMask(elementState, mask, initialElementState = null) {\n    if (validateValueWithMask(elementState.value, mask)) {\n        return elementState;\n    }\n    const { value, selection } = Array.isArray(mask)\n        ? guessValidValueByPattern(elementState, mask, initialElementState)\n        : guessValidValueByRegExp(elementState, mask);\n    return {\n        selection,\n        value: Array.isArray(mask) ? value.slice(0, mask.length) : value,\n    };\n}\n\nfunction removeFixedMaskCharacters(initialElementState, mask) {\n    if (!Array.isArray(mask)) {\n        return initialElementState;\n    }\n    const [from, to] = initialElementState.selection;\n    const selection = [];\n    const unmaskedValue = Array.from(initialElementState.value).reduce((rawValue, char, i) => {\n        const charConstraint = mask[i] || '';\n        if (i === from) {\n            selection.push(rawValue.length);\n        }\n        if (i === to) {\n            selection.push(rawValue.length);\n        }\n        return isFixedCharacter(charConstraint) && charConstraint === char\n            ? rawValue\n            : `${rawValue}${char}`;\n    }, '');\n    if (selection.length < 2) {\n        selection.push(...Array.from({ length: 2 - selection.length }).fill(unmaskedValue.length));\n    }\n    return {\n        value: unmaskedValue,\n        selection: [selection[0], selection[1]],\n    };\n}\n\nclass MaskModel {\n    constructor(initialElementState, maskOptions) {\n        this.maskOptions = maskOptions;\n        this.unmaskInitialState = { value: '', selection: [0, 0] };\n        this.value = '';\n        this.selection = [0, 0];\n        const expression = this.getMaskExpression(initialElementState);\n        const { value, selection } = calibrateValueByMask(initialElementState, expression);\n        this.unmaskInitialState = removeFixedMaskCharacters({ value, selection }, expression);\n        this.value = value;\n        this.selection = selection;\n    }\n    addCharacters(newCharacters) {\n        const { value, selection, maskOptions } = this;\n        const initialElementState = { value, selection };\n        const { selection: [from, to], } = applyOverwriteMode(initialElementState, newCharacters, maskOptions.overwriteMode);\n        const maskExpression = this.getMaskExpression({\n            value: `${value.slice(0, from)}${newCharacters}${value.slice(to)}`,\n            selection: [from + newCharacters.length, from + newCharacters.length],\n        });\n        const [unmaskedFrom, unmaskedTo] = applyOverwriteMode(this.unmaskInitialState, newCharacters, maskOptions.overwriteMode).selection;\n        const newUnmaskedLeadingValuePart = `${this.unmaskInitialState.value.slice(0, unmaskedFrom)}${newCharacters}`;\n        const newCaretIndex = newUnmaskedLeadingValuePart.length;\n        const maskedElementState = calibrateValueByMask({\n            value: `${newUnmaskedLeadingValuePart}${this.unmaskInitialState.value.slice(unmaskedTo)}`,\n            selection: [newCaretIndex, newCaretIndex],\n        }, maskExpression, initialElementState);\n        const prevLeadingPart = value.slice(0, from);\n        const newLeadingPartState = calibrateValueByMask({\n            value: newUnmaskedLeadingValuePart,\n            selection: [newCaretIndex, newCaretIndex],\n        }, maskExpression, initialElementState);\n        const isInvalidCharsInsertion = newLeadingPartState.value === prevLeadingPart ||\n            (newLeadingPartState.value.length < prevLeadingPart.length &&\n                removeFixedMaskCharacters(newLeadingPartState, maskExpression).value ===\n                    this.unmaskInitialState.value.slice(0, unmaskedFrom));\n        if (isInvalidCharsInsertion ||\n            areElementStatesEqual(this, maskedElementState) // If typing new characters does not change value\n        ) {\n            throw new Error('Invalid mask value');\n        }\n        this.value = maskedElementState.value;\n        this.selection = maskedElementState.selection;\n    }\n    deleteCharacters() {\n        const [from, to] = this.selection;\n        if (from === to || !to) {\n            return;\n        }\n        const { value } = this;\n        const maskExpression = this.getMaskExpression({\n            value: `${value.slice(0, from)}${value.slice(to)}`,\n            selection: [from, from],\n        });\n        const initialElementState = { value};\n        const [unmaskedFrom, unmaskedTo] = this.unmaskInitialState.selection;\n        const newUnmaskedValue = `${this.unmaskInitialState.value.slice(0, unmaskedFrom)}${this.unmaskInitialState.value.slice(unmaskedTo)}`;\n        const maskedElementState = calibrateValueByMask({ value: newUnmaskedValue, selection: [unmaskedFrom, unmaskedFrom] }, maskExpression, initialElementState);\n        this.value = maskedElementState.value;\n        this.selection = maskedElementState.selection;\n    }\n    getMaskExpression(elementState) {\n        const { mask } = this.maskOptions;\n        return typeof mask === 'function' ? mask(elementState) : mask;\n    }\n}\n\nclass EventListener {\n    constructor(element) {\n        this.element = element;\n        this.listeners = [];\n    }\n    listen(eventType, fn, options) {\n        const untypedFn = fn;\n        this.element.addEventListener(eventType, untypedFn, options);\n        this.listeners.push(() => this.element.removeEventListener(eventType, untypedFn, options));\n    }\n    destroy() {\n        this.listeners.forEach((stopListen) => stopListen());\n    }\n}\n\nconst HotkeyModifier = {\n    CTRL: 1 << 0,\n    ALT: 1 << 1,\n    SHIFT: 1 << 2,\n    META: 1 << 3,\n};\n// TODO add variants that can be processed correctly\nconst HotkeyCode = {\n    Y: 89,\n    Z: 90,\n};\n/**\n * Checks if the passed keyboard event match the required hotkey.\n *\n * @example\n * input.addEventListener('keydown', (event) => {\n *     if (isHotkey(event, HotkeyModifier.CTRL | HotkeyModifier.SHIFT, HotkeyCode.Z)) {\n *         // redo hotkey pressed\n *     }\n * })\n *\n * @return will return `true` only if the {@link HotkeyCode} matches and only the necessary\n * {@link HotkeyModifier modifiers} have been pressed\n */\nfunction isHotkey(event, modifiers, hotkeyCode) {\n    return (event.ctrlKey === !!(modifiers & HotkeyModifier.CTRL) &&\n        event.altKey === !!(modifiers & HotkeyModifier.ALT) &&\n        event.shiftKey === !!(modifiers & HotkeyModifier.SHIFT) &&\n        event.metaKey === !!(modifiers & HotkeyModifier.META) &&\n        /**\n         * We intentionally use legacy {@link KeyboardEvent#keyCode `keyCode`} property. It is more\n         * \"keyboard-layout\"-independent than {@link KeyboardEvent#key `key`} or {@link KeyboardEvent#code `code`} properties.\n         * @see {@link https://github.com/taiga-family/maskito/issues/315 `KeyboardEvent#code` issue}\n         */\n        event.keyCode === hotkeyCode);\n}\n\nfunction isRedo(event) {\n    return (isHotkey(event, HotkeyModifier.CTRL, HotkeyCode.Y) || // Windows\n        isHotkey(event, HotkeyModifier.CTRL | HotkeyModifier.SHIFT, HotkeyCode.Z) || // Windows & Android\n        isHotkey(event, HotkeyModifier.META | HotkeyModifier.SHIFT, HotkeyCode.Z) // macOS & iOS\n    );\n}\nfunction isUndo(event) {\n    return (isHotkey(event, HotkeyModifier.CTRL, HotkeyCode.Z) || // Windows & Android\n        isHotkey(event, HotkeyModifier.META, HotkeyCode.Z) // macOS & iOS\n    );\n}\n\n/**\n * Sets value to element, and dispatches input event\n * if you passed ELementState, it also sets selection range\n *\n * @example\n * maskitoUpdateElement(input, newValue);\n * maskitoUpdateElement(input, elementState);\n *\n * @see {@link https://github.com/taiga-family/maskito/issues/804 issue}\n *\n * @return void\n */\nfunction maskitoUpdateElement(element, valueOrElementState) {\n    const initialValue = element.value;\n    if (typeof valueOrElementState === 'string') {\n        element.value = valueOrElementState;\n    }\n    else {\n        const [from, to] = valueOrElementState.selection;\n        element.value = valueOrElementState.value;\n        if (element.matches(':focus')) {\n            element.setSelectionRange(from, to);\n        }\n    }\n    if (element.value !== initialValue) {\n        element.dispatchEvent(new Event('input', \n        /**\n         * React handles this event only on bubbling phase\n         *\n         * here is the list of events that are processed in the capture stage, others are processed in the bubbling stage\n         * https://github.com/facebook/react/blob/cb2439624f43c510007f65aea5c50a8bb97917e4/packages/react-dom-bindings/src/events/DOMPluginEventSystem.js#L222\n         */\n        { bubbles: true }));\n    }\n}\n\nfunction getLineSelection({ value, selection }, isForward) {\n    const [from, to] = selection;\n    if (from !== to) {\n        return [from, to];\n    }\n    const nearestBreak = isForward\n        ? value.slice(from).indexOf('\\n') + 1 || value.length\n        : value.slice(0, to).lastIndexOf('\\n') + 1;\n    const selectFrom = isForward ? from : nearestBreak;\n    const selectTo = isForward ? nearestBreak : to;\n    return [selectFrom, selectTo];\n}\n\nfunction getNotEmptySelection({ value, selection }, isForward) {\n    const [from, to] = selection;\n    if (from !== to) {\n        return [from, to];\n    }\n    const notEmptySelection = isForward ? [from, to + 1] : [from - 1, to];\n    return notEmptySelection.map((x) => Math.min(Math.max(x, 0), value.length));\n}\n\nconst TRAILING_SPACES_REG = /\\s+$/g;\nconst LEADING_SPACES_REG = /^\\s+/g;\nconst SPACE_REG = /\\s/;\nfunction getWordSelection({ value, selection }, isForward) {\n    const [from, to] = selection;\n    if (from !== to) {\n        return [from, to];\n    }\n    if (isForward) {\n        const valueAfterSelectionStart = value.slice(from);\n        const [leadingSpaces] = valueAfterSelectionStart.match(LEADING_SPACES_REG) || [\n            '',\n        ];\n        const nearestWordEndIndex = valueAfterSelectionStart\n            .trimStart()\n            .search(SPACE_REG);\n        return [\n            from,\n            nearestWordEndIndex === -1\n                ? value.length\n                : from + leadingSpaces.length + nearestWordEndIndex,\n        ];\n    }\n    const valueBeforeSelectionEnd = value.slice(0, to);\n    const [trailingSpaces] = valueBeforeSelectionEnd.match(TRAILING_SPACES_REG) || [''];\n    const selectedWordLength = valueBeforeSelectionEnd\n        .trimEnd()\n        .split('')\n        .reverse()\n        .findIndex((char) => SPACE_REG.exec(char));\n    return [\n        selectedWordLength === -1 ? 0 : to - trailingSpaces.length - selectedWordLength,\n        to,\n    ];\n}\n\n/**\n * @internal\n */\nfunction maskitoPipe(processors = []) {\n    return (initialData, ...args) => processors.reduce((data, fn) => ({ ...data, ...fn(data, ...args) }), initialData);\n}\n\nfunction maskitoTransform(valueOrState, maskitoOptions) {\n    const options = {\n        ...MASKITO_DEFAULT_OPTIONS,\n        ...maskitoOptions,\n    };\n    const preprocessor = maskitoPipe(options.preprocessors);\n    const postprocessor = maskitoPipe(options.postprocessors);\n    const initialElementState = typeof valueOrState === 'string'\n        ? { value: valueOrState, selection: [0, 0] }\n        : valueOrState;\n    const { elementState } = preprocessor({ elementState: initialElementState, data: '' }, 'validation');\n    const maskModel = new MaskModel(elementState, options);\n    const { value, selection } = postprocessor(maskModel, initialElementState);\n    return typeof valueOrState === 'string' ? value : { value, selection };\n}\n\n/**\n * All `input` events with `inputType=deleteContentBackward` always follows `beforeinput` event with the same `inputType`.\n * If `beforeinput[inputType=deleteContentBackward]` is prevented, subsequent `input[inputType=deleteContentBackward]` is prevented too.\n * There is an exception – Android devices with Microsoft SwiftKey Keyboard in Mobile Chrome.\n * These devices ignores `preventDefault` for `beforeinput` event if Backspace is pressed.\n * @see https://github.com/taiga-family/maskito/issues/2135#issuecomment-2980729647\n * ___\n * TODO: track Chromium bug report and delete this plugin after bug fix\n * https://issues.chromium.org/issues/40885402\n */\nfunction createBrokenDefaultPlugin() {\n    return (element) => {\n        const eventListener = new EventListener(element);\n        let isVirtualAndroidKeyboard = false;\n        let beforeinputEvent;\n        let value = element.value;\n        eventListener.listen('keydown', ({ key }) => {\n            isVirtualAndroidKeyboard = key === 'Unidentified';\n        });\n        eventListener.listen('beforeinput', (event) => {\n            beforeinputEvent = event;\n            value = element.value;\n        });\n        eventListener.listen('input', (event) => {\n            if (isVirtualAndroidKeyboard &&\n                beforeinputEvent.defaultPrevented &&\n                beforeinputEvent.inputType === 'deleteContentBackward' &&\n                event.inputType === 'deleteContentBackward') {\n                element.value = value;\n            }\n        }, { capture: true });\n        return () => eventListener.destroy();\n    };\n}\n\nfunction maskitoChangeEventPlugin() {\n    return (element) => {\n        if (element.isContentEditable) {\n            return;\n        }\n        let value = element.value;\n        const valueListener = () => {\n            value = element.value;\n        };\n        const blurListener = () => {\n            if (element.value !== value) {\n                element.dispatchEvent(new Event('change', { bubbles: true }));\n            }\n        };\n        element.addEventListener('focus', valueListener);\n        element.addEventListener('change', valueListener);\n        element.addEventListener('blur', blurListener);\n        return () => {\n            element.removeEventListener('focus', valueListener);\n            element.removeEventListener('change', valueListener);\n            element.removeEventListener('blur', blurListener);\n        };\n    };\n}\n\nconst SPACE = ' ';\n/**\n * 1. Android user (with G-board keyboard or similar) presses 1st space\n * ```\n * {type: \"beforeinput\", data: \" \", inputType: \"insertText\"}\n * ```\n * 2. User presses 2nd space\n * ```\n * // Android tries to delete previously inserted space\n * {type: \"beforeinput\", inputType: \"deleteContentBackward\"}\n * {type: \"beforeinput\", data: \". \", inputType: \"insertText\"}\n * ```\n * ---------\n * 1. MacOS user presses 1st space\n * ```\n * {type: \"beforeinput\", data: \" \", inputType: \"insertText\"}\n * ```\n * 2. User presses 2nd space\n * ```\n * // MacOS automatically run `element.setSelectionRange(indexBeforeSpace, indexAfterSpace)` and then\n * {type: \"beforeinput\", data: \". \", inputType: \"insertText\"}\n * ```\n * ---------\n * @see https://github.com/taiga-family/maskito/issues/2023\n */\nfunction createDoubleSpacePlugin() {\n    let prevValue = '';\n    let prevCaretIndex = 0;\n    let prevEvent = null;\n    let prevRejectedSpace = false;\n    return (element) => {\n        const eventListener = new EventListener(element);\n        eventListener.listen('beforeinput', (event) => {\n            const { value, selectionStart, selectionEnd } = element;\n            const rejectedSpace = prevEvent?.inputType === 'insertText' &&\n                prevEvent.data === SPACE &&\n                !value.slice(0, Number(selectionEnd)).endsWith(SPACE);\n            if (event.inputType === 'insertText' && event.data === `.${SPACE}`) {\n                if (prevEvent?.inputType === 'deleteContentBackward' &&\n                    prevRejectedSpace) {\n                    // Android\n                    element.value = prevValue;\n                    element.setSelectionRange(prevCaretIndex, prevCaretIndex);\n                }\n                else if (rejectedSpace) {\n                    // Mac OS\n                    element.setSelectionRange(selectionStart, selectionStart);\n                }\n            }\n            prevRejectedSpace = rejectedSpace;\n            prevEvent = event;\n            prevValue = value;\n            prevCaretIndex = Number((rejectedSpace ? prevCaretIndex : selectionEnd) === value.length\n                ? selectionEnd\n                : selectionStart);\n        });\n        return () => eventListener.destroy();\n    };\n}\n\nfunction maskitoInitialCalibrationPlugin(customOptions) {\n    return (element, options) => {\n        const from = element.selectionStart ?? 0;\n        const to = element.selectionEnd ?? 0;\n        maskitoUpdateElement(element, {\n            value: maskitoTransform(element.value, customOptions || options),\n            selection: [from, to],\n        });\n    };\n}\n\nfunction maskitoStrictCompositionPlugin() {\n    return (element, maskitoOptions) => {\n        const listener = (event) => {\n            if (event.inputType !== 'insertCompositionText') {\n                return;\n            }\n            const selection = [\n                element.selectionStart ?? 0,\n                element.selectionEnd ?? 0,\n            ];\n            const elementState = {\n                selection,\n                value: element.value,\n            };\n            const validatedState = maskitoTransform(elementState, maskitoOptions);\n            if (!areElementStatesEqual(elementState, validatedState)) {\n                event.preventDefault();\n                maskitoUpdateElement(element, validatedState);\n            }\n        };\n        element.addEventListener('input', listener);\n        return () => element.removeEventListener('input', listener);\n    };\n}\n\nconst BUILT_IN_PLUGINS = [createDoubleSpacePlugin(), createBrokenDefaultPlugin()];\nclass Maskito extends MaskHistory {\n    constructor(element, maskitoOptions) {\n        super();\n        this.element = element;\n        this.maskitoOptions = maskitoOptions;\n        this.isTextArea = this.element.nodeName === 'TEXTAREA';\n        this.eventListener = new EventListener(this.element);\n        this.options = {\n            ...MASKITO_DEFAULT_OPTIONS,\n            ...this.maskitoOptions,\n        };\n        this.preprocessor = maskitoPipe(this.options.preprocessors);\n        this.postprocessor = maskitoPipe(this.options.postprocessors);\n        this.teardowns = this.options.plugins\n            .concat(BUILT_IN_PLUGINS)\n            .map((plugin) => plugin(this.element, this.options));\n        this.upcomingElementState = null;\n        this.updateHistory(this.elementState);\n        this.eventListener.listen('keydown', (event) => {\n            if (isRedo(event)) {\n                event.preventDefault();\n                return this.redo();\n            }\n            if (isUndo(event)) {\n                event.preventDefault();\n                return this.undo();\n            }\n        });\n        this.eventListener.listen('beforeinput', (event) => {\n            const isForward = event.inputType.includes('Forward');\n            this.updateHistory(this.elementState);\n            switch (event.inputType) {\n                case 'deleteByCut':\n                case 'deleteContentBackward':\n                case 'deleteContentForward':\n                    return this.delete(getNotEmptySelection(this.elementState, isForward), event);\n                case 'deleteHardLineBackward':\n                case 'deleteHardLineForward':\n                case 'deleteSoftLineBackward':\n                case 'deleteSoftLineForward':\n                    return this.delete(getLineSelection(this.elementState, isForward), event);\n                case 'deleteWordBackward':\n                case 'deleteWordForward':\n                    return this.delete(getWordSelection(this.elementState, isForward), event);\n                case 'historyRedo':\n                    event.preventDefault();\n                    return this.redo();\n                // historyUndo/historyRedo will not be triggered if value was modified programmatically\n                case 'historyUndo':\n                    event.preventDefault();\n                    return this.undo();\n                case 'insertCompositionText':\n                    return; // will be handled inside `compositionend` event\n                case 'insertLineBreak':\n                case 'insertParagraph':\n                    return this.handleEnter(event);\n                case 'insertReplacementText':\n                    /**\n                     * According {@link https://www.w3.org/TR/input-events-2 W3C specification}:\n                     * > `insertReplacementText` – insert or replace existing text by means of a spell checker,\n                     * > auto-correct, writing suggestions or similar.\n                     * ___\n                     * Firefox emits `insertReplacementText` event for its suggestion/autofill and for spell checker.\n                     * However, it is impossible to detect which part of the textfield value is going to be replaced\n                     * (`selectionStart` and `selectionEnd` just equal to the last caret position).\n                     * ___\n                     * Chrome does not fire `beforeinput` event for its suggestion/autofill.\n                     * It emits only `input` event with `inputType` and `data` set to `undefined`.\n                     * ___\n                     * All these browser limitations make us to validate the result value later in `input` event.\n                     */\n                    return;\n                case 'insertFromDrop':\n                case 'insertFromPaste':\n                case 'insertText':\n                default:\n                    return this.insert(event.data ??\n                        // `event.data` for `contentEditable` is always `null` for paste/drop events\n                        event.dataTransfer?.getData('text/plain') ??\n                        '', event);\n            }\n        });\n        this.eventListener.listen('input', () => {\n            if (this.upcomingElementState &&\n                !areElementStatesEqual(this.upcomingElementState, this.elementState)) {\n                this.updateElementState(this.upcomingElementState);\n            }\n            this.upcomingElementState = null;\n        }, { capture: true });\n        this.eventListener.listen('input', ({ inputType }) => {\n            if (inputType === 'insertCompositionText') {\n                return; // will be handled inside `compositionend` event\n            }\n            this.ensureValueFitsMask();\n            this.updateHistory(this.elementState);\n        });\n        this.eventListener.listen('compositionend', () => {\n            this.ensureValueFitsMask();\n            this.updateHistory(this.elementState);\n        });\n    }\n    destroy() {\n        this.eventListener.destroy();\n        this.teardowns.forEach((teardown) => teardown?.());\n    }\n    delete(selection, event) {\n        const isForward = event?.inputType.includes('Forward');\n        const initialState = {\n            value: this.elementState.value,\n            selection,\n        };\n        const { elementState } = this.preprocessor({\n            elementState: initialState,\n            data: '',\n        }, isForward ? 'deleteForward' : 'deleteBackward');\n        const maskModel = new MaskModel(elementState, this.options);\n        maskModel.deleteCharacters();\n        const newElementState = this.postprocessor(maskModel, initialState);\n        if (areElementValuesEqual(initialState, elementState, maskModel, newElementState)) {\n            const [from, to] = elementState.selection;\n            event?.preventDefault();\n            // User presses Backspace/Delete for the fixed value\n            return this.updateSelectionRange(isForward ? [to, to] : [from, from]);\n        }\n        this.upcomingElementState = newElementState;\n    }\n    insert(data, event) {\n        const { options, maxLength, elementState: initialElementState } = this;\n        const [from, to] = initialElementState.selection;\n        const { elementState, data: insertedText = data } = this.preprocessor({\n            data,\n            elementState: initialElementState,\n        }, 'insert');\n        const maskModel = new MaskModel(elementState, options);\n        try {\n            maskModel.addCharacters(insertedText);\n        }\n        catch {\n            return event?.preventDefault();\n        }\n        this.upcomingElementState = this.clampState(this.postprocessor(maskModel, initialElementState));\n        /**\n         * When textfield value length is already equal to attribute `maxlength`,\n         * pressing any key (even with valid value) does not emit `input` event\n         * (except to the case when user replaces some characters by selection).\n         */\n        const noInputEventDispatch = initialElementState.value.length >= maxLength && from === to;\n        if (noInputEventDispatch) {\n            if (options.overwriteMode === 'replace' &&\n                !areElementStatesEqual(this.upcomingElementState, initialElementState)) {\n                this.dispatchInputEvent({ inputType: 'insertText', data });\n            }\n            else {\n                /**\n                 * This `beforeinput` event will not be followed by `input` event –\n                 * clear computed state to avoid any possible side effect\n                 * for new possible `input` event without preceding `beforeinput` event\n                 * (e.g. browser autofill, `document.execCommand('delete')` etc.)\n                 */\n                this.upcomingElementState = null;\n            }\n        }\n    }\n    updateElementState({ value, selection }, eventInit) {\n        const initialValue = this.elementState.value;\n        this.updateValue(value);\n        this.updateSelectionRange(selection);\n        if (eventInit && initialValue !== value) {\n            this.dispatchInputEvent(eventInit);\n        }\n    }\n    get elementState() {\n        const { value, selectionStart, selectionEnd } = this.element;\n        return {\n            value,\n            selection: [selectionStart ?? 0, selectionEnd ?? 0],\n        };\n    }\n    get maxLength() {\n        const { maxLength } = this.element;\n        return maxLength === -1 ? Infinity : maxLength;\n    }\n    updateSelectionRange([from, to]) {\n        const { element } = this;\n        if (element.matches(':focus') &&\n            (element.selectionStart !== from || element.selectionEnd !== to)) {\n            element.setSelectionRange(from, to);\n        }\n    }\n    updateValue(value) {\n        /**\n         * Don't \"disturb\" unnecessarily `value`-setter\n         * (i.e. it breaks React controlled input behavior)\n         */\n        if (this.element.value !== value || this.element.isContentEditable) {\n            this.element.value = value;\n        }\n    }\n    ensureValueFitsMask() {\n        this.updateElementState(maskitoTransform(this.elementState, this.options), {\n            inputType: 'insertText',\n            data: null,\n        });\n    }\n    dispatchInputEvent(eventInit = {\n        inputType: 'insertText',\n        data: null,\n    }) {\n        this.element.dispatchEvent(new InputEvent('input', {\n            ...eventInit,\n            bubbles: true,\n            cancelable: false,\n        }));\n    }\n    handleEnter(event) {\n        if (this.isTextArea || this.element.isContentEditable) {\n            this.insert('\\n', event);\n        }\n    }\n    clampState({ value, selection }) {\n        const [from, to] = selection;\n        const max = this.maxLength;\n        return {\n            value: value.slice(0, max),\n            selection: [Math.min(from, max), Math.min(to, max)],\n        };\n    }\n}\n\nexports.MASKITO_DEFAULT_ELEMENT_PREDICATE = MASKITO_DEFAULT_ELEMENT_PREDICATE;\nexports.MASKITO_DEFAULT_OPTIONS = MASKITO_DEFAULT_OPTIONS;\nexports.Maskito = Maskito;\nexports.maskitoAdaptContentEditable = maskitoAdaptContentEditable;\nexports.maskitoChangeEventPlugin = maskitoChangeEventPlugin;\nexports.maskitoInitialCalibrationPlugin = maskitoInitialCalibrationPlugin;\nexports.maskitoPipe = maskitoPipe;\nexports.maskitoStrictCompositionPlugin = maskitoStrictCompositionPlugin;\nexports.maskitoTransform = maskitoTransform;\nexports.maskitoUpdateElement = maskitoUpdateElement;\n"]}