@depup/testing-library__user-event 14.6.3-depup.0

package/dist/cjs/utility/selectOptions.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var dom = require('@testing-library/dom');
+var isElementType = require('../utils/misc/isElementType.js');
+require('../utils/dataTransfer/Clipboard.js');
+var isDisabled = require('../utils/misc/isDisabled.js');
+var wait = require('../utils/misc/wait.js');
+var cssPointerEvents = require('../utils/pointer/cssPointerEvents.js');
+require('../event/behavior/click.js');
+require('../event/behavior/cut.js');
+require('../event/behavior/keydown.js');
+require('../event/behavior/keypress.js');
+require('../event/behavior/keyup.js');
+require('../event/behavior/paste.js');
+var focus = require('../event/focus.js');
+
+async function selectOptions(select, values) {
+    return selectOptionsBase.call(this, true, select, values);
+}
+async function deselectOptions(select, values) {
+    return selectOptionsBase.call(this, false, select, values);
+}
+async function selectOptionsBase(newValue, select, values) {
+    if (!newValue && !select.multiple) {
+        throw dom.getConfig().getElementError(`Unable to deselect an option in a non-multiple select. Use selectOptions to change the selection instead.`, select);
+    }
+    const valArray = Array.isArray(values) ? values : [
+        values
+    ];
+    const allOptions = Array.from(select.querySelectorAll('option, [role="option"]'));
+    const selectedOptions = valArray.map((val)=>{
+        if (typeof val !== 'string' && allOptions.includes(val)) {
+            return val;
+        } else {
+            const matchingOption = allOptions.find((o)=>o.value === val || o.innerHTML === val);
+            if (matchingOption) {
+                return matchingOption;
+            } else {
+                throw dom.getConfig().getElementError(`Value "${String(val)}" not found in options`, select);
+            }
+        }
+    }).filter((option)=>!isDisabled.isDisabled(option));
+    if (isDisabled.isDisabled(select) || !selectedOptions.length) return;
+    const selectOption = (option)=>{
+        option.selected = newValue;
+        this.dispatchUIEvent(select, 'input', {
+            bubbles: true,
+            cancelable: false,
+            composed: true
+        });
+        this.dispatchUIEvent(select, 'change');
+    };
+    if (isElementType.isElementType(select, 'select')) {
+        if (select.multiple) {
+            for (const option of selectedOptions){
+                const withPointerEvents = this.config.pointerEventsCheck === 0 ? true : cssPointerEvents.hasPointerEvents(this, option);
+                // events fired for multiple select are weird. Can't use hover...
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'pointerover');
+                    this.dispatchUIEvent(select, 'pointerenter');
+                    this.dispatchUIEvent(option, 'mouseover');
+                    this.dispatchUIEvent(select, 'mouseenter');
+                    this.dispatchUIEvent(option, 'pointermove');
+                    this.dispatchUIEvent(option, 'mousemove');
+                    this.dispatchUIEvent(option, 'pointerdown');
+                    this.dispatchUIEvent(option, 'mousedown');
+                }
+                focus.focusElement(select);
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'pointerup');
+                    this.dispatchUIEvent(option, 'mouseup');
+                }
+                selectOption(option);
+                if (withPointerEvents) {
+                    this.dispatchUIEvent(option, 'click');
+                }
+                await wait.wait(this.config);
+            }
+        } else if (selectedOptions.length === 1) {
+            const withPointerEvents = this.config.pointerEventsCheck === 0 ? true : cssPointerEvents.hasPointerEvents(this, select);
+            // the click to open the select options
+            if (withPointerEvents) {
+                await this.click(select);
+            } else {
+                focus.focusElement(select);
+            }
+            selectOption(selectedOptions[0]);
+            if (withPointerEvents) {
+                // the browser triggers another click event on the select for the click on the option
+                // this second click has no 'down' phase
+                this.dispatchUIEvent(select, 'pointerover');
+                this.dispatchUIEvent(select, 'pointerenter');
+                this.dispatchUIEvent(select, 'mouseover');
+                this.dispatchUIEvent(select, 'mouseenter');
+                this.dispatchUIEvent(select, 'pointerup');
+                this.dispatchUIEvent(select, 'mouseup');
+                this.dispatchUIEvent(select, 'click');
+            }
+            await wait.wait(this.config);
+        } else {
+            throw dom.getConfig().getElementError(`Cannot select multiple options on a non-multiple select`, select);
+        }
+    } else if (select.getAttribute('role') === 'listbox') {
+        for (const option of selectedOptions){
+            await this.click(option);
+            await this.unhover(option);
+        }
+    } else {
+        throw dom.getConfig().getElementError(`Cannot select options on elements that are neither select nor listbox elements`, select);
+    }
+}
+
+exports.deselectOptions = deselectOptions;
+exports.selectOptions = selectOptions;

package/dist/cjs/utility/type.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var index = require('../keyboard/index.js');
+require('../utils/dataTransfer/Clipboard.js');
+var setSelectionRange = require('../event/selection/setSelectionRange.js');
+
+async function type(element, text, { skipClick = this.config.skipClick, skipAutoClose = this.config.skipAutoClose, initialSelectionStart, initialSelectionEnd } = {}) {
+    // TODO: properly type guard
+    // we use this workaround for now to prevent changing behavior
+    if (element.disabled) return;
+    if (!skipClick) {
+        await this.click(element);
+    }
+    if (initialSelectionStart !== undefined) {
+        setSelectionRange.setSelectionRange(element, initialSelectionStart, initialSelectionEnd !== null && initialSelectionEnd !== void 0 ? initialSelectionEnd : initialSelectionStart);
+    }
+    await this.keyboard(text);
+    if (!skipAutoClose) {
+        await index.releaseAllKeys(this);
+    }
+}
+
+exports.type = type;

package/dist/cjs/utility/upload.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var isElementType = require('../utils/misc/isElementType.js');
+var FileList = require('../utils/dataTransfer/FileList.js');
+require('../utils/dataTransfer/Clipboard.js');
+var setFiles = require('../utils/edit/setFiles.js');
+var isDisabled = require('../utils/misc/isDisabled.js');
+var getWindow = require('../utils/misc/getWindow.js');
+
+async function upload(element, fileOrFiles) {
+    const input = isElementType.isElementType(element, 'label') ? element.control : element;
+    if (!input || !isElementType.isElementType(input, 'input', {
+        type: 'file'
+    })) {
+        throw new TypeError(`The ${input === element ? 'given' : 'associated'} ${input === null || input === void 0 ? void 0 : input.tagName} element does not accept file uploads`);
+    }
+    if (isDisabled.isDisabled(element)) return;
+    const files = (Array.isArray(fileOrFiles) ? fileOrFiles : [
+        fileOrFiles
+    ]).filter((file)=>!this.config.applyAccept || isAcceptableFile(file, input.accept)).slice(0, input.multiple ? undefined : 1);
+    const fileDialog = ()=>{
+        var _input_files;
+        // do not fire an input event if the file selection does not change
+        if (files.length === ((_input_files = input.files) === null || _input_files === void 0 ? void 0 : _input_files.length) && files.every((f, i)=>{
+            var _input_files;
+            return f === ((_input_files = input.files) === null || _input_files === void 0 ? void 0 : _input_files.item(i));
+        })) {
+            return;
+        }
+        setFiles.setFiles(input, FileList.createFileList(getWindow.getWindow(element), files));
+        this.dispatchUIEvent(input, 'input');
+        this.dispatchUIEvent(input, 'change');
+    };
+    input.addEventListener('fileDialog', fileDialog);
+    await this.click(element);
+    input.removeEventListener('fileDialog', fileDialog);
+}
+// When matching files, browsers ignore case and consider jpeg/jpg interchangeable.
+function normalize(nameOrType) {
+    return nameOrType.toLowerCase().replace(/(\.|\/)jpg\b/g, '$1jpeg');
+}
+function isAcceptableFile(file, accept) {
+    if (!accept) {
+        return true;
+    }
+    const wildcards = [
+        'audio/*',
+        'image/*',
+        'video/*'
+    ];
+    return normalize(accept).trim().split(/\s*,\s*/).some((acceptToken)=>{
+        // tokens starting with a dot represent a file extension
+        if (acceptToken.startsWith('.')) {
+            return normalize(file.name).endsWith(acceptToken);
+        } else if (wildcards.includes(acceptToken)) {
+            return normalize(file.type).startsWith(acceptToken.replace('*', ''));
+        }
+        return normalize(file.type) === acceptToken;
+    });
+}
+
+exports.upload = upload;

package/dist/cjs/utils/click/isClickableInput.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var isElementType = require('../misc/isElementType.js');
+
+var clickableInputTypes = /*#__PURE__*/ function(clickableInputTypes) {
+    clickableInputTypes["button"] = "button";
+    clickableInputTypes["color"] = "color";
+    clickableInputTypes["file"] = "file";
+    clickableInputTypes["image"] = "image";
+    clickableInputTypes["reset"] = "reset";
+    clickableInputTypes["submit"] = "submit";
+    clickableInputTypes["checkbox"] = "checkbox";
+    clickableInputTypes["radio"] = "radio";
+    return clickableInputTypes;
+}(clickableInputTypes || {});
+function isClickableInput(element) {
+    return isElementType.isElementType(element, 'button') || isElementType.isElementType(element, 'input') && element.type in clickableInputTypes;
+}
+
+exports.isClickableInput = isClickableInput;

package/dist/cjs/utils/dataTransfer/Blob.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// jsdom does not implement Blob.text()
+function readBlobText(blob, FileReader) {
+    return new Promise((res, rej)=>{
+        const fr = new FileReader();
+        fr.onerror = rej;
+        fr.onabort = rej;
+        fr.onload = ()=>{
+            res(String(fr.result));
+        };
+        fr.readAsText(blob);
+    });
+}
+
+exports.readBlobText = readBlobText;

package/dist/cjs/utils/dataTransfer/Clipboard.js

@@ -0,0 +1,174 @@
+'use strict';
+
+var getWindow = require('../misc/getWindow.js');
+var Blob = require('./Blob.js');
+var DataTransfer = require('./DataTransfer.js');
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+// MDN lists string|Blob|Promise<Blob|string> as possible types in ClipboardItemData
+// lib.dom.d.ts lists only Promise<Blob|string>
+// https://developer.mozilla.org/en-US/docs/Web/API/ClipboardItem/ClipboardItem#syntax
+function createClipboardItem(window, ...blobs) {
+    const dataMap = Object.fromEntries(blobs.map((b)=>[
+            typeof b === 'string' ? 'text/plain' : b.type,
+            Promise.resolve(b)
+        ]));
+    // use real ClipboardItem if available
+    /* istanbul ignore if */ if (typeof window.ClipboardItem !== 'undefined') {
+        return new window.ClipboardItem(dataMap);
+    }
+    return new class ClipboardItem {
+        get types() {
+            return Array.from(Object.keys(this.data));
+        }
+        async getType(type) {
+            const value = await this.data[type];
+            if (!value) {
+                throw new Error(`${type} is not one of the available MIME types on this item.`);
+            }
+            return value instanceof window.Blob ? value : new window.Blob([
+                value
+            ], {
+                type
+            });
+        }
+        constructor(d){
+            _define_property(this, "data", void 0);
+            this.data = d;
+        }
+    }(dataMap);
+}
+const ClipboardStubControl = Symbol('Manage ClipboardSub');
+function createClipboardStub(window, control) {
+    return Object.assign(new class Clipboard extends window.EventTarget {
+        async read() {
+            return Array.from(this.items);
+        }
+        async readText() {
+            let text = '';
+            for (const item of this.items){
+                const type = item.types.includes('text/plain') ? 'text/plain' : item.types.find((t)=>t.startsWith('text/'));
+                if (type) {
+                    text += await item.getType(type).then((b)=>Blob.readBlobText(b, window.FileReader));
+                }
+            }
+            return text;
+        }
+        async write(data) {
+            this.items = data;
+        }
+        async writeText(text) {
+            this.items = [
+                createClipboardItem(window, text)
+            ];
+        }
+        constructor(...args){
+            super(...args), _define_property(this, "items", []);
+        }
+    }(), {
+        [ClipboardStubControl]: control
+    });
+}
+function isClipboardStub(clipboard) {
+    return !!(clipboard === null || clipboard === void 0 ? void 0 : clipboard[ClipboardStubControl]);
+}
+function attachClipboardStubToView(window) {
+    if (isClipboardStub(window.navigator.clipboard)) {
+        return window.navigator.clipboard[ClipboardStubControl];
+    }
+    const realClipboard = Object.getOwnPropertyDescriptor(window.navigator, 'clipboard');
+    let stub;
+    const control = {
+        resetClipboardStub: ()=>{
+            stub = createClipboardStub(window, control);
+        },
+        detachClipboardStub: ()=>{
+            /* istanbul ignore if */ if (realClipboard) {
+                Object.defineProperty(window.navigator, 'clipboard', realClipboard);
+            } else {
+                Object.defineProperty(window.navigator, 'clipboard', {
+                    value: undefined,
+                    configurable: true
+                });
+            }
+        }
+    };
+    stub = createClipboardStub(window, control);
+    Object.defineProperty(window.navigator, 'clipboard', {
+        get: ()=>stub,
+        configurable: true
+    });
+    return stub[ClipboardStubControl];
+}
+function resetClipboardStubOnView(window) {
+    if (isClipboardStub(window.navigator.clipboard)) {
+        window.navigator.clipboard[ClipboardStubControl].resetClipboardStub();
+    }
+}
+function detachClipboardStubFromView(window) {
+    if (isClipboardStub(window.navigator.clipboard)) {
+        window.navigator.clipboard[ClipboardStubControl].detachClipboardStub();
+    }
+}
+async function readDataTransferFromClipboard(document) {
+    const window = document.defaultView;
+    const clipboard = window === null || window === void 0 ? void 0 : window.navigator.clipboard;
+    const items = clipboard && await clipboard.read();
+    if (!items) {
+        throw new Error('The Clipboard API is unavailable.');
+    }
+    const dt = DataTransfer.createDataTransfer(window);
+    for (const item of items){
+        for (const type of item.types){
+            dt.setData(type, await item.getType(type).then((b)=>Blob.readBlobText(b, window.FileReader)));
+        }
+    }
+    return dt;
+}
+async function writeDataTransferToClipboard(document, clipboardData) {
+    const window = getWindow.getWindow(document);
+    const clipboard = window.navigator.clipboard;
+    const items = [];
+    for(let i = 0; i < clipboardData.items.length; i++){
+        const dtItem = clipboardData.items[i];
+        const blob = await DataTransfer.getBlobFromDataTransferItem(window, dtItem);
+        items.push(createClipboardItem(window, blob));
+    }
+    const written = clipboard && await clipboard.write(items).then(()=>true, // Can happen with other implementations that e.g. require permissions
+    /* istanbul ignore next */ ()=>false);
+    if (!written) {
+        throw new Error('The Clipboard API is unavailable.');
+    }
+}
+const g = globalThis;
+/* istanbul ignore else */ if (typeof g.afterEach === 'function') {
+    g.afterEach(()=>{
+        if (typeof globalThis.window !== 'undefined') {
+            resetClipboardStubOnView(globalThis.window);
+        }
+    });
+}
+/* istanbul ignore else */ if (typeof g.afterAll === 'function') {
+    g.afterAll(()=>{
+        if (typeof globalThis.window !== 'undefined') {
+            detachClipboardStubFromView(globalThis.window);
+        }
+    });
+}
+
+exports.attachClipboardStubToView = attachClipboardStubToView;
+exports.createClipboardItem = createClipboardItem;
+exports.detachClipboardStubFromView = detachClipboardStubFromView;
+exports.readDataTransferFromClipboard = readDataTransferFromClipboard;
+exports.resetClipboardStubOnView = resetClipboardStubOnView;
+exports.writeDataTransferToClipboard = writeDataTransferToClipboard;

package/dist/cjs/utils/dataTransfer/DataTransfer.js

@@ -0,0 +1,134 @@
+'use strict';
+
+var FileList = require('./FileList.js');
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+// DataTransfer is not implemented in jsdom.
+// DataTransfer with FileList is being created by the browser on certain events.
+class DataTransferItemStub {
+    getAsFile() {
+        return this.file;
+    }
+    getAsString(callback) {
+        if (typeof this.data === 'string') {
+            callback(this.data);
+        }
+    }
+    /* istanbul ignore next */ webkitGetAsEntry() {
+        throw new Error('not implemented');
+    }
+    constructor(dataOrFile, type){
+        _define_property(this, "kind", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "file", null);
+        _define_property(this, "data", undefined);
+        if (typeof dataOrFile === 'string') {
+            this.kind = 'string';
+            this.type = String(type);
+            this.data = dataOrFile;
+        } else {
+            this.kind = 'file';
+            this.type = dataOrFile.type;
+            this.file = dataOrFile;
+        }
+    }
+}
+class DataTransferItemListStub extends Array {
+    add(...args) {
+        const item = new DataTransferItemStub(args[0], args[1]);
+        this.push(item);
+        return item;
+    }
+    clear() {
+        this.splice(0, this.length);
+    }
+    remove(index) {
+        this.splice(index, 1);
+    }
+}
+function getTypeMatcher(type, exact) {
+    const [group, sub] = type.split('/');
+    const isGroup = !sub || sub === '*';
+    return (item)=>{
+        return exact ? item.type === (isGroup ? group : type) : isGroup ? item.type.startsWith(`${group}/`) : item.type === group;
+    };
+}
+function createDataTransferStub(window) {
+    return new class DataTransferStub {
+        getData(format) {
+            var _this_items_find;
+            const match = (_this_items_find = this.items.find(getTypeMatcher(format, true))) !== null && _this_items_find !== void 0 ? _this_items_find : this.items.find(getTypeMatcher(format, false));
+            let text = '';
+            match === null || match === void 0 ? void 0 : match.getAsString((t)=>{
+                text = t;
+            });
+            return text;
+        }
+        setData(format, data) {
+            const matchIndex = this.items.findIndex(getTypeMatcher(format, true));
+            const item = new DataTransferItemStub(data, format);
+            if (matchIndex >= 0) {
+                this.items.splice(matchIndex, 1, item);
+            } else {
+                this.items.push(item);
+            }
+        }
+        clearData(format) {
+            if (format) {
+                const matchIndex = this.items.findIndex(getTypeMatcher(format, true));
+                if (matchIndex >= 0) {
+                    this.items.remove(matchIndex);
+                }
+            } else {
+                this.items.clear();
+            }
+        }
+        get types() {
+            const t = [];
+            if (this.files.length) {
+                t.push('Files');
+            }
+            this.items.forEach((i)=>t.push(i.type));
+            Object.freeze(t);
+            return t;
+        }
+        /* istanbul ignore next */ setDragImage() {}
+        constructor(){
+            _define_property(this, "dropEffect", 'none');
+            _define_property(this, "effectAllowed", 'uninitialized');
+            _define_property(this, "items", new DataTransferItemListStub());
+            _define_property(this, "files", FileList.createFileList(window, []));
+        }
+    }();
+}
+function createDataTransfer(window, files = []) {
+    // Use real DataTransfer if available
+    const dt = typeof window.DataTransfer === 'undefined' ? createDataTransferStub(window) : /* istanbul ignore next */ new window.DataTransfer();
+    Object.defineProperty(dt, 'files', {
+        get: ()=>FileList.createFileList(window, files)
+    });
+    return dt;
+}
+async function getBlobFromDataTransferItem(window, item) {
+    if (item.kind === 'file') {
+        return item.getAsFile();
+    }
+    return new window.Blob([
+        await new Promise((r)=>item.getAsString(r))
+    ], {
+        type: item.type
+    });
+}
+
+exports.createDataTransfer = createDataTransfer;
+exports.getBlobFromDataTransferItem = getBlobFromDataTransferItem;

package/dist/cjs/utils/dataTransfer/FileList.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// FileList can not be created per constructor.
+function createFileList(window, files) {
+    const list = {
+        ...files,
+        length: files.length,
+        item: (index)=>list[index],
+        [Symbol.iterator]: function* nextFile() {
+            for(let i = 0; i < list.length; i++){
+                yield list[i];
+            }
+        }
+    };
+    list.constructor = window.FileList;
+    // guard for environments without FileList
+    /* istanbul ignore else */ if (window.FileList) {
+        Object.setPrototypeOf(list, window.FileList.prototype);
+    }
+    Object.freeze(list);
+    return list;
+}
+
+exports.createFileList = createFileList;

package/dist/cjs/utils/edit/isContentEditable.js

@@ -0,0 +1,18 @@
+'use strict';
+
+// jsdom is not supporting isContentEditable
+function isContentEditable(element) {
+    return element.hasAttribute('contenteditable') && (element.getAttribute('contenteditable') == 'true' || element.getAttribute('contenteditable') == '');
+}
+/**
+ * If a node is a contenteditable or inside one, return that element.
+ */ function getContentEditable(node) {
+    const element = getElement(node);
+    return element && (element.closest('[contenteditable=""]') || element.closest('[contenteditable="true"]'));
+}
+function getElement(node) {
+    return node.nodeType === 1 ? node : node.parentElement;
+}
+
+exports.getContentEditable = getContentEditable;
+exports.isContentEditable = isContentEditable;

package/dist/cjs/utils/edit/isEditable.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var isElementType = require('../misc/isElementType.js');
+var isContentEditable = require('./isContentEditable.js');
+
+function isEditable(element) {
+    return isEditableInputOrTextArea(element) && !element.readOnly || isContentEditable.isContentEditable(element);
+}
+var editableInputTypes = /*#__PURE__*/ function(editableInputTypes) {
+    editableInputTypes["text"] = "text";
+    editableInputTypes["date"] = "date";
+    editableInputTypes["datetime-local"] = "datetime-local";
+    editableInputTypes["email"] = "email";
+    editableInputTypes["month"] = "month";
+    editableInputTypes["number"] = "number";
+    editableInputTypes["password"] = "password";
+    editableInputTypes["search"] = "search";
+    editableInputTypes["tel"] = "tel";
+    editableInputTypes["time"] = "time";
+    editableInputTypes["url"] = "url";
+    editableInputTypes["week"] = "week";
+    return editableInputTypes;
+}(editableInputTypes || {});
+function isEditableInputOrTextArea(element) {
+    return isElementType.isElementType(element, 'textarea') || isElementType.isElementType(element, 'input') && element.type in editableInputTypes;
+}
+
+exports.isEditable = isEditable;
+exports.isEditableInputOrTextArea = isEditableInputOrTextArea;

package/dist/cjs/utils/edit/maxLength.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var isElementType = require('../misc/isElementType.js');
+
+var maxLengthSupportedTypes = /*#__PURE__*/ function(maxLengthSupportedTypes) {
+    maxLengthSupportedTypes["email"] = "email";
+    maxLengthSupportedTypes["password"] = "password";
+    maxLengthSupportedTypes["search"] = "search";
+    maxLengthSupportedTypes["telephone"] = "telephone";
+    maxLengthSupportedTypes["text"] = "text";
+    maxLengthSupportedTypes["url"] = "url";
+    return maxLengthSupportedTypes;
+}(maxLengthSupportedTypes || {});
+// can't use .maxLength property because of a jsdom bug:
+// https://github.com/jsdom/jsdom/issues/2927
+function getMaxLength(element) {
+    var _element_getAttribute;
+    const attr = (_element_getAttribute = element.getAttribute('maxlength')) !== null && _element_getAttribute !== void 0 ? _element_getAttribute : '';
+    return /^\d+$/.test(attr) && Number(attr) >= 0 ? Number(attr) : undefined;
+}
+function supportsMaxLength(element) {
+    return isElementType.isElementType(element, 'textarea') || isElementType.isElementType(element, 'input') && element.type in maxLengthSupportedTypes;
+}
+
+exports.getMaxLength = getMaxLength;
+exports.supportsMaxLength = supportsMaxLength;