diff --git a/__tests__/Area.test.tsx b/__tests__/Area.test.tsx
index 9c9fb98..1fd71ca 100644
--- a/__tests__/Area.test.tsx
+++ b/__tests__/Area.test.tsx
@@ -4,6 +4,7 @@ import { Validator } from '@/Validator';
 import { ValidatorArea, ValidatorAreaProps } from '@/components/ValidatorArea';
 import ValidatorProvider, { ValidatorProviderProps } from '@/components/ValidatorProvider';
 import { ProviderScope } from '@/ProviderScope';
+import required from '@/rules/required';
 
 const tick = () => {
     return new Promise(resolve => {
@@ -21,6 +22,7 @@ describe('test ValidatorProvider', () => {
                 return 'not passed';
             }
         });
+        Validator.extend('required', required)
     });
 
     it('should render input', () => {
@@ -83,7 +85,7 @@ describe('test ValidatorProvider', () => {
     it('should apply rules on blur', () => {
         const area = mount<ValidatorArea, ValidatorAreaProps>(
             <ValidatorArea rules="passes_not">
-                <input name="test" />
+                <input name="test" value="test" />
             </ValidatorArea>
         );
 
@@ -107,7 +109,7 @@ describe('test ValidatorProvider', () => {
             <ValidatorArea rules="passes_not">
                 {({ errors }) => (
                     <>
-                        <input name="test" />
+                        <input name="test" value="test" />
                         {errors.length && <div>{errors[0]}</div>}
                     </>
                 )}
@@ -123,7 +125,7 @@ describe('test ValidatorProvider', () => {
 
         const area = mount<ValidatorArea, ValidatorAreaProps>(
             <ValidatorArea rules="passes_not">
-                <input name="test" onBlur={mockFn} />
+                <input name="test" onBlur={mockFn} value="test" />
             </ValidatorArea>
         );
 
@@ -137,7 +139,7 @@ describe('test ValidatorProvider', () => {
                 return validator.refs().length === 2;
             },
             message(): string {
-                return 'test';
+                return '';
             }
         }))
         const mockFn = jest.fn();
@@ -147,10 +149,10 @@ describe('test ValidatorProvider', () => {
                 {({ validate }: ProviderScope) => (
                     <>
                         <ValidatorArea name="test1">
-                            <input value="" />
+                            <input value="test" />
                         </ValidatorArea>
                         <ValidatorArea>
-                            <input value="" name="test2" />
+                            <input value="test" name="test2" />
                         </ValidatorArea>
                         <button onClick={() => validate(mockFn)} />
                     </>
@@ -180,11 +182,11 @@ describe('test ValidatorProvider', () => {
                 {({ validate }: ProviderScope) => (
                     <>
                         <ValidatorArea name="test1">
-                            <input value="" />
-                            <input value="" />
+                            <input value="test" />
+                            <input value="test" />
                         </ValidatorArea>
                         <ValidatorArea>
-                            <input value="" name="test2" />
+                            <input value="test" name="test2" />
                         </ValidatorArea>
                         <button onClick={() => validate(mockFn)} />
                     </>
@@ -213,10 +215,10 @@ describe('test ValidatorProvider', () => {
                 {({ validate }: ProviderScope) => (
                     <>
                         <ValidatorArea name="test1">
-                            <input value="" />
+                            <input value="test" />
                         </ValidatorArea>
                         <ValidatorArea>
-                            <input value="" name="test2" />
+                            <input value="test" name="test2" />
                         </ValidatorArea>
                         <button onClick={() => validate(mockFn)} />
                     </>
@@ -243,7 +245,7 @@ describe('test ValidatorProvider', () => {
 
         const area = mount<ValidatorArea, ValidatorAreaProps>(
             <ValidatorArea rules="no_other_areas">
-                <input name="test" onBlur={mockFn} />
+                <input name="test" value="test" onBlur={mockFn} />
             </ValidatorArea>
         );
 
@@ -270,10 +272,10 @@ describe('test ValidatorProvider', () => {
                 {({ validate }: ProviderScope) => (
                     <>
                         <ValidatorArea name="test1">
-                            <textarea value="" />
+                            <textarea value="test" />
                         </ValidatorArea>
                         <ValidatorArea>
-                            <input value="" name="test2" />
+                            <input value="test" name="test2" />
                         </ValidatorArea>
                         <button onClick={() => validate(mockFn)} />
                     </>
@@ -298,7 +300,7 @@ describe('test ValidatorProvider', () => {
 
         const area = mount<ValidatorArea, ValidatorAreaProps>(
             <ValidatorArea validationName="Foo" rules="passes_not">
-                <input name="test" />
+                <input name="test" value="test" />
             </ValidatorArea>
         );
 
diff --git a/__tests__/Provider.test.tsx b/__tests__/Provider.test.tsx
index cbc57be..7db969a 100644
--- a/__tests__/Provider.test.tsx
+++ b/__tests__/Provider.test.tsx
@@ -90,10 +90,10 @@ describe('test ValidatorProvider', () => {
                 {({ validate }) => (
                     <>
                         <ValidatorArea rules="passes_not" name="test1">
-                            <input value="" />
+                            <input value="test" />
                         </ValidatorArea>
                         <ValidatorArea rules="passes_not" name="test2">
-                            <input value="" />
+                            <input value="test" />
                         </ValidatorArea>
                         <button onClick={() => validate(mockFn)} />
                     </>
diff --git a/__tests__/Validator.test.tsx b/__tests__/Validator.test.tsx
index 16a4c52..899e595 100644
--- a/__tests__/Validator.test.tsx
+++ b/__tests__/Validator.test.tsx
@@ -43,13 +43,16 @@ describe('test validator', () => {
 
         Validator.extend('testRule', rule);
 
-        expect(Validator.hasRule('testRule')).toBeTruthy();
+        expect(Validator.ruleExists('testRule')).toBeTruthy();
     });
 
     it('should validate rules as string', () => {
+        const input = document.createElement<'input'>('input');
+        input.value = 'test';
+
         const validator = new Validator(
             [
-                document.createElement<'input'>('input')
+                input
             ],
             'rule_one|rule_two',
             'test'
@@ -60,9 +63,11 @@ describe('test validator', () => {
     });
 
     it('should validate rules as array', () => {
+        const input = document.createElement<'input'>('input');
+        input.value = 'test';
         const validator = new Validator(
             [
-                document.createElement<'input'>('input')
+                input
             ],
             ['rule_one', 'rule_two'],
             'test'
@@ -73,9 +78,12 @@ describe('test validator', () => {
     });
 
     it('should validate with parameters', () => {
+        const input = document.createElement<'input'>('input');
+        input.value = 'test';
+
         const validator = new Validator(
             [
-                document.createElement<'input'>('input')
+                input
             ],
             ['rule_with_params:1,2,3,4'],
             'test'
@@ -86,10 +94,12 @@ describe('test validator', () => {
     });
 
     it('throws an exception when rule is not found', () => {
+        const input = document.createElement<'input'>('input');
+        input.value = 'test';
         const throws = () => {
             const validator = new Validator(
                 [
-                    document.createElement<'input'>('input')
+                    input
                 ],
                 ['not_existing_rule'],
                 'test'
@@ -118,5 +128,34 @@ describe('test validator', () => {
         }
 
         expect(() => throws()).toThrowError('Areas are only available when validating React components.')
+    });
+
+    it('should be able to check if the value is required', () => {
+        const input = document.createElement<'input'>('input');
+        input.value = 'test';
+        Validator.extend('check_if_required', (validator: Validator) => ({
+            passed(elements: HTMLElement[]): boolean {
+                return !elements.every((element: HTMLElement) => validator.shouldValidate(element));
+            },
+            message(): string {
+                return 'Value is false negative required'
+            }
+        }));
+
+        const validator = new Validator(
+            [
+                input
+            ],
+            ['required', 'check_if_required'],
+            'test'
+        );
+
+        validator.validate();
+
+        expect(validator.getErrors()[0]).toBe('Value is false negative required');
+    })
+
+    it('should return empty array when no refs provided', () => {
+
     })
 });
diff --git a/__tests__/rules/max.test.tsx b/__tests__/rules/max.test.tsx
index 3688cb8..7cb4726 100644
--- a/__tests__/rules/max.test.tsx
+++ b/__tests__/rules/max.test.tsx
@@ -3,6 +3,7 @@ import { mount } from 'enzyme';
 import max from '@/rules/max';
 import { Validator } from '@/Validator';
 import { ValidatorArea, ValidatorAreaProps } from '@/components/ValidatorArea';
+import { IncorrectArgumentTypeError } from '@/rules';
 
 describe('test max rule', () => {
     beforeEach(() => {
@@ -11,39 +12,72 @@ describe('test max rule', () => {
 
     it('should always validate inputs and not validate non-inputs', () => {
         const input = document.createElement('input');
-        input.value = '5';
-
-        const throwsArgumentError = () => {
-            const validator = new Validator([
-                input
-            ], ['max:foo'],
-            'validate_throws'
-            );
-            validator.validate();
-        }
+        const meter = document.createElement('meter');
+        const output = document.createElement('output');
+        const progress = document.createElement('progress');
+        const canvas = document.createElement('canvas');
+        input.value = '7';
+        output.value = '7';
+        meter.value = 6;
+        meter.max = 10;
+        progress.value = 6;
 
         const validator_input = new Validator([
             input
         ],
-        ['max:4'],
-        'validator_input');
+        ['max:5'],
+        '');
 
-        const progress = document.createElement('progress');
-        progress.value = 5;
+        const validator_meter = new Validator([
+            meter
+        ],
+        ['max:5'],
+        '');
+
+        const validator_output = new Validator([
+            output
+        ],
+        ['max:5'],
+        '');
 
         const validator_progress = new Validator([
             progress
         ],
-        ['max:4'],
-        'validate_progress');
+        ['max:5'],
+        '');
+
+        const validator_canvas = new Validator([
+            canvas
+        ],
+        ['max:5'],
+        '');
 
-        expect(() => throwsArgumentError()).toThrowError('max rule has incorrect argument foo. Expected a number.')
+        const validator_wrong_arg = new Validator([
+            input
+        ],
+        ['max:foo'],
+        '');
 
         validator_input.validate();
         expect(validator_input.getErrors().length).toBe(1);
 
+        validator_meter.validate();
+        expect(validator_meter.getErrors().length).toBe(1);
+
+        validator_output.validate();
+        expect(validator_output.getErrors().length).toBe(1);
+
         validator_progress.validate();
-        expect(validator_progress.getErrors().length).toBe(0);
+        expect(validator_progress.getErrors().length).toBe(1);
+
+        validator_canvas.validate();
+        expect(validator_canvas.getErrors().length).toBe(0);
+
+        const throwsInvalidArgument = () => {
+            validator_wrong_arg.validate();
+        }
+
+        expect(() => throwsInvalidArgument()).toThrowError(IncorrectArgumentTypeError);
     });
 
     it('should validate select', () => {
diff --git a/__tests__/rules/min.test.tsx b/__tests__/rules/min.test.tsx
index b4c06c8..34f34f0 100644
--- a/__tests__/rules/min.test.tsx
+++ b/__tests__/rules/min.test.tsx
@@ -3,6 +3,7 @@ import { Validator } from '@/Validator';
 import { mount } from 'enzyme';
 import { ValidatorArea, ValidatorAreaProps } from '@/components/ValidatorArea';
 import React from 'react';
+import { IncorrectArgumentTypeError } from '@/rules';
 
 describe('test min rule', () => {
     beforeEach(() => {
@@ -11,39 +12,72 @@ describe('test min rule', () => {
 
     it('should always validate inputs and not validate non-inputs', () => {
         const input = document.createElement('input');
-        input.value = '5';
-
-        const throwsArgumentError = () => {
-            const validator = new Validator([
-                input
-            ], ['min:foo'],
-            'validate_throws'
-            );
-            validator.validate();
-        }
+        const meter = document.createElement('meter');
+        const output = document.createElement('output');
+        const progress = document.createElement('progress');
+        const canvas = document.createElement('canvas');
+        input.value = '4';
+        output.value = '4';
+        meter.value = 4;
+        meter.max = 10;
+        progress.value = 4;
 
         const validator_input = new Validator([
             input
         ],
-        ['min:6'],
-        'validator_input');
+        ['min:5'],
+        '');
 
-        const progress = document.createElement('progress');
-        progress.value = 5;
+        const validator_meter = new Validator([
+            meter
+        ],
+        ['min:5'],
+        '');
+
+        const validator_output = new Validator([
+            output
+        ],
+        ['min:5'],
+        '');
 
         const validator_progress = new Validator([
             progress
         ],
-        ['min:4'],
-        'validate_progress');
+        ['min:5'],
+        '');
+
+        const validator_canvas = new Validator([
+            canvas
+        ],
+        ['min:5'],
+        '');
 
-        expect(() => throwsArgumentError()).toThrowError('min rule has incorrect argument foo. Expected a number.')
+        const validator_wrong_arg = new Validator([
+            input
+        ],
+        ['min:foo'],
+        '');
 
         validator_input.validate();
         expect(validator_input.getErrors().length).toBe(1);
 
+        validator_meter.validate();
+        expect(validator_meter.getErrors().length).toBe(1);
+
+        validator_output.validate();
+        expect(validator_output.getErrors().length).toBe(1);
+
         validator_progress.validate();
-        expect(validator_progress.getErrors().length).toBe(0);
+        expect(validator_progress.getErrors().length).toBe(1);
+
+        validator_canvas.validate();
+        expect(validator_canvas.getErrors().length).toBe(0);
+
+        const throwsInvalidArgument = () => {
+            validator_wrong_arg.validate();
+        }
+
+        expect(() => throwsInvalidArgument()).toThrowError(IncorrectArgumentTypeError);
     });
 
     it('should validate select', () => {
diff --git a/__tests__/rules/required.test.tsx b/__tests__/rules/required.test.tsx
index 4afd641..6da15a3 100644
--- a/__tests__/rules/required.test.tsx
+++ b/__tests__/rules/required.test.tsx
@@ -23,23 +23,56 @@ describe('test required rule', () => {
         expect(area.state().errors[0]).toBe('Test is required');
     });
 
-    it('should always validate inputs and not validate non-inputs', () => {
+    it('should always validate validatable and not validate non-validatable', () => {
+        const input = document.createElement('input');
+        const meter = document.createElement('meter');
+        const output = document.createElement('output');
+        const progress = document.createElement('progress');
+        const div = document.createElement('div');
+
         const validator_input = new Validator([
-            document.createElement('input')
+            input
+        ],
+        ['required'],
+        'validator_input');
+
+        const validator_meter = new Validator([
+            meter
+        ],
+        ['required'],
+        'validator_input');
+
+        const validator_output = new Validator([
+            output
         ],
         ['required'],
         'validator_input');
 
         const validator_progress = new Validator([
-            document.createElement('progress')
+            progress
         ],
         ['required'],
-        'validate_progress');
+        'validator_input');
+
+        const validator_div = new Validator([
+            div
+        ],
+        ['required'],
+        'validator_input');
 
         validator_input.validate();
         expect(validator_input.getErrors().length).toBe(1);
 
+        validator_meter.validate();
+        expect(validator_meter.getErrors().length).toBe(1);
+
+        validator_output.validate();
+        expect(validator_output.getErrors().length).toBe(1);
+
         validator_progress.validate();
-        expect(validator_progress.getErrors().length).toBe(0);
+        expect(validator_progress.getErrors().length).toBe(1);
+
+        validator_div.validate();
+        expect(validator_div.getErrors().length).toBe(0);
     });
 });
diff --git a/__tests__/utils/dom.test.ts b/__tests__/utils/dom.test.ts
index 59a8cac..b0e4cc4 100644
--- a/__tests__/utils/dom.test.ts
+++ b/__tests__/utils/dom.test.ts
@@ -1,4 +1,4 @@
-import { getValue, htmlCollectionToArray, isInputElement, isSelectElement } from '@/utils/dom';
+import { getValue, htmlCollectionToArray, isInputElement, isSelectElement } from '@/common/dom';
 
 describe('dom helpers test', () => {
     it('should convert HtmlCollection to array', () => {
@@ -30,8 +30,8 @@ describe('dom helpers test', () => {
         const div = document.createElement('div');
 
         expect(getValue(select)).toEqual(expect.arrayContaining(['foo', 'bar']));
-        expect(getValue(input)).toBe('baz');
-        expect(getValue(div)).toBeNull();
+        expect(getValue(input)).toEqual(expect.arrayContaining(['baz']));
+        expect(getValue(div)).toEqual([]);
     });
 
     it('should check whether an element is an input element', () => {
diff --git a/src/Validator.ts b/src/Validator.ts
index 7732baa..efb48d3 100644
--- a/src/Validator.ts
+++ b/src/Validator.ts
@@ -6,18 +6,22 @@ import {
 } from '@formatjs/intl'
 import { Rule, RuleFunction, RuleObject } from '@/Rule';
 import { RuleOptions } from '@/RuleOptions';
-import { capitalize } from '@/utils/utils';
+import { capitalize } from '@/common/utils';
 import { ValidatorArea } from '@/components/ValidatorArea';
+import required from './rules/required';
+import { getValue, isCanvasElement } from '@/common/dom';
 
 export class Validator {
     public static VALIDATABLE_ELEMENTS: string[] = [
-        'a', 'audio', 'button', 'canvas', 'input', 'meter', 'select', 'textarea', 'output', 'progress'
+        'canvas', 'input', 'meter', 'select', 'textarea', 'output', 'progress'
     ];
 
     /**
      * Map containing the rule object belonging to a rule string
      */
-    public static rules: Record<string, Rule> = {};
+    public static rules: Record<string, Rule> = {
+        required
+    };
 
     /**
      * The elements to be validated
@@ -83,23 +87,35 @@ export class Validator {
         }, this.intlCache);
     }
 
+    /**
+     * Get the rule list as array
+     */
+    private getRuleList(): string[] {
+        if (typeof this.validationRules === 'string') {
+            return this.validationRules.split('|');
+        }
+
+        return this.validationRules;
+    }
+
+    public hasRule(rule: string): boolean {
+        return this.getRuleList().indexOf(rule) !== -1;
+    }
+
     /**
      * Validate the elements
      */
     public validate(): boolean {
-        let ruleList: string[];
         this.errors = [];
 
-        if (typeof this.validationRules === 'string') {
-            ruleList = this.validationRules.split('|');
-        } else {
-            ruleList = this.validationRules;
+        if (this.hasValidatableElements()) {
+            return !this.getRuleList()
+                .map((rule: string) => this.validateRule(rule))
+                .filter((passed: boolean) => !passed)
+                .length;
         }
 
-        return !ruleList
-            .map((rule: string) => this.validateRule(rule))
-            .filter((passed: boolean) => !passed)
-            .length;
+        return true;
     }
 
     /**
@@ -114,9 +130,11 @@ export class Validator {
      */
     private validateRule(rule: string): boolean {
         const [ruleName, ruleArgs = ''] = rule.split(':');
-        if (Validator.hasRule(ruleName)) {
+
+        if (Validator.ruleExists(ruleName)) {
             const ruleObj: RuleObject = Validator.isRuleFunction(ruleName)
-                ? (Validator.rules[ruleName] as RuleFunction)(this) : Validator.rules[ruleName] as RuleObject;
+                ? (Validator.rules[ruleName] as RuleFunction)(this)
+                : Validator.rules[ruleName] as RuleObject;
 
             const ruleArgsArray = ruleArgs.split(',');
 
@@ -131,6 +149,20 @@ export class Validator {
         throw new Error(`Validation rule ${rule} not found.`);
     }
 
+    public hasValidatableElements(): boolean {
+        return this.elements.some((element: HTMLElement) => this.shouldValidate(element));
+    }
+
+    public shouldValidate(element: HTMLElement): boolean {
+        if (this.hasRule('required')) {
+            return true;
+        }
+
+        return !!(getValue(element).length
+            || isCanvasElement(element)
+        );
+    }
+
     /*
      * Get the capitalized, localized message
      */
@@ -204,7 +236,7 @@ export class Validator {
     /**
      * Check whether the validator has a rule
      */
-    public static hasRule(name: string): boolean {
+    public static ruleExists(name: string): boolean {
         return Object.prototype.hasOwnProperty.call(Validator.rules, name);
     }
 }
diff --git a/src/common/dom.ts b/src/common/dom.ts
new file mode 100644
index 0000000..2d54f30
--- /dev/null
+++ b/src/common/dom.ts
@@ -0,0 +1,87 @@
+/**
+ * Returns whether element is an input element
+ */
+const isInputElement = (element: HTMLElement): element is HTMLInputElement|HTMLTextAreaElement => {
+    return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;
+}
+
+/**
+ * Returns whether element is an canvas element
+ */
+const isCanvasElement = (element: HTMLElement): element is HTMLCanvasElement => {
+    return element instanceof HTMLCanvasElement;
+}
+
+/**
+ * Returns whether element is a meter element
+ */
+const isMeterElement = (element: HTMLElement): element is HTMLMeterElement => {
+    return element instanceof HTMLMeterElement;
+}
+/**
+ * Returns whether element is an output element
+ */
+const isOutputElement = (element: HTMLElement): element is HTMLOutputElement => {
+    return element instanceof HTMLOutputElement;
+}
+
+/**
+ * Returns whether element is an select element
+ */
+const isSelectElement = (element: HTMLElement): element is HTMLSelectElement => {
+    return element instanceof HTMLSelectElement
+}
+
+/**
+ * Returns whether element is a progress element
+ */
+const isProgressElement = (element: HTMLElement): element is HTMLProgressElement => {
+    return element instanceof HTMLProgressElement;
+}
+
+/**
+ * Returns an flexible array representation of an html element collection
+ */
+const htmlCollectionToArray = <T extends Element>(collection: HTMLCollectionOf<T>): T[] => {
+    const arr: T[] = [];
+
+    for(let i = 0; i < collection.length; i++) {
+        arr.push(collection.item(i) as T);
+    }
+
+    return arr;
+}
+
+/**
+ * Returns the value of the element, when it exists
+ */
+const getValue = (element: HTMLElement): string[] => {
+    if (
+        isInputElement(element)
+        || isMeterElement(element)
+        || isOutputElement(element)
+        || isOutputElement(element)
+        || isProgressElement(element)
+    ) {
+        return [(element.value || '').toString()].filter(Boolean);
+    }
+
+    if (isSelectElement(element)) {
+        return htmlCollectionToArray<HTMLOptionElement>(element.selectedOptions)
+            .map((option: HTMLOptionElement) => option.value)
+            .filter(Boolean);
+    }
+
+    return [];
+}
+
+export {
+    isInputElement,
+    isSelectElement,
+    isCanvasElement,
+    isMeterElement,
+    isOutputElement,
+    isProgressElement,
+    htmlCollectionToArray,
+    getValue,
+};
diff --git a/src/utils/utils.ts b/src/common/utils.ts
similarity index 100%
rename from src/utils/utils.ts
rename to src/common/utils.ts
diff --git a/src/rules/max.ts b/src/rules/max.ts
index a537ce3..28d938c 100644
--- a/src/rules/max.ts
+++ b/src/rules/max.ts
@@ -1,6 +1,13 @@
-import { isNumeric } from '@/utils/utils';
+import { isNumeric } from '@/common/utils';
 import { IncorrectArgumentTypeError } from '@/rules/IncorrectArgumentTypeError';
-import { getValue, isInputElement, isSelectElement } from '@/utils/dom';
+import {
+    getValue,
+    isInputElement,
+    isMeterElement,
+    isOutputElement,
+    isProgressElement,
+    isSelectElement
+} from '@/common/dom';
 
 export default {
     passed(elements: HTMLElement[], max: string): boolean {
@@ -9,18 +16,18 @@ export default {
         }
 
         return elements.every((element: HTMLElement) => {
-            if (isInputElement(element) || isSelectElement(element)) {
+            if (
+                isInputElement(element)
+                || isSelectElement(element)
+                || isProgressElement(element)
+                || isMeterElement(element)
+                || isOutputElement(element)
+            ) {
                 const value = getValue(element);
 
-                if (Array.isArray(value)) {
-                    return value.every((val: string) => {
-                        return isNumeric(val) && parseFloat(val) <= parseFloat(max);
-                    });
-                } else {
-                    return value
-                        && isNumeric(value)
-                        && parseFloat(value) <= parseFloat(max);
-                }
+                return value.every((val: string) => {
+                    return isNumeric(val) && parseFloat(val) <= parseFloat(max);
+                });
             }
 
             return true;
@@ -29,4 +36,4 @@ export default {
     message(): string {
         return `{name} should be not greater than {0}`
     }
-}
+};
diff --git a/src/rules/min.ts b/src/rules/min.ts
index 46c7a15..469e0ae 100644
--- a/src/rules/min.ts
+++ b/src/rules/min.ts
@@ -1,5 +1,12 @@
-import { getValue, isInputElement, isSelectElement } from '@/utils/dom';
-import { isNumeric } from '@/utils/utils';
+import {
+    getValue,
+    isInputElement,
+    isMeterElement,
+    isOutputElement,
+    isProgressElement,
+    isSelectElement
+} from '@/common/dom';
+import { isNumeric } from '@/common/utils';
 import { IncorrectArgumentTypeError } from '@/rules/IncorrectArgumentTypeError';
 
 export default {
@@ -9,18 +16,18 @@ export default {
         }
 
         return elements.every((element: HTMLElement) => {
-            if (isInputElement(element) || isSelectElement(element)) {
+            if (
+                isInputElement(element)
+                || isSelectElement(element)
+                || isProgressElement(element)
+                || isMeterElement(element)
+                || isOutputElement(element)
+            ) {
                 const value = getValue(element);
 
-                if (Array.isArray(value)) {
-                    return value.every((val: string) => {
-                        return isNumeric(val) && parseFloat(val) >= parseFloat(min);
-                    });
-                } else {
-                    return value
-                        && isNumeric(value)
-                        && parseFloat(value) >= parseFloat(min);
-                }
+                return value.every((val: string) => {
+                    return isNumeric(val) && parseFloat(val) >= parseFloat(min);
+                });
             }
 
             return true;
@@ -29,4 +36,4 @@ export default {
     message(): string {
         return `{name} should be at least {0}`
     }
-}
+};
diff --git a/src/rules/required.ts b/src/rules/required.ts
index 0b05b08..af8c06d 100644
--- a/src/rules/required.ts
+++ b/src/rules/required.ts
@@ -1,12 +1,25 @@
-import { getValue, isInputElement, isSelectElement } from '@/utils/dom';
+import {
+    getValue,
+    isInputElement,
+    isMeterElement,
+    isOutputElement,
+    isProgressElement,
+    isSelectElement
+} from '@/common/dom';
 
 export default {
     passed(elements: HTMLElement[]): boolean {
         return elements.every((element: HTMLElement) => {
-            if (isInputElement(element) || isSelectElement(element)) {
-                const value = getValue(element);
+            if (
+                isInputElement(element)
+                || isSelectElement(element)
+                || isMeterElement(element)
+                || isOutputElement(element)
+                || isProgressElement(element)
+            ) {
+                const value = getValue(element).filter(Boolean);
 
-                return value && value.length;
+                return value.length;
             }
 
             return true;
diff --git a/src/utils/dom.ts b/src/utils/dom.ts
deleted file mode 100644
index bbb42d7..0000000
--- a/src/utils/dom.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Returns whether element is an input element
- */
-const isInputElement = (element: HTMLElement): element is HTMLInputElement => {
-    return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement;
-}
-
-/**
- * Returns whether element is an select element
- */
-const isSelectElement = (element: HTMLElement): element is HTMLSelectElement => {
-    return element instanceof HTMLSelectElement
-}
-
-/**
- * Returns an flexible array representation of an html element collection
- */
-const htmlCollectionToArray = <T extends Element>(collection: HTMLCollectionOf<T>): T[] => {
-    const arr: T[] = [];
-
-    for(let i = 0; i < collection.length; i++) {
-        arr.push(collection.item(i) as T);
-    }
-
-    return arr;
-}
-
-/**
- * Returns the value of the element, when it exists
- */
-const getValue = (element: HTMLElement): string | string[] | null => {
-    if (isInputElement(element)) {
-        return element.value;
-    }
-
-    if (isSelectElement(element)) {
-        return htmlCollectionToArray<HTMLOptionElement>(element.selectedOptions)
-            .map((option: HTMLOptionElement) => option.value)
-            .filter(Boolean);
-    }
-
-    return null;
-}
-
-export {
-    isInputElement,
-    isSelectElement,
-    htmlCollectionToArray,
-    getValue,
-};