vgapp 0.0.1

package/app/utils/js/components/placement.js

@@ -0,0 +1,59 @@
+import {mergeDeepObject, normalizeData} from "../functions";
+
+/**
+ * Класс Placement, определяет и устанавливает местоположение элемента на странице.
+ * TODO класс не дописан
+ */
+
+class Placement {
+	constructor(arg = {}) {
+		this.params = mergeDeepObject({
+			element: null,
+			drop: null
+		}, arg);
+	}
+
+	_getPlacement() {
+		const _this = this;
+		const _parent = (self) => {
+			let parent = self.parentNode,
+				overflow = getComputedStyle(parent).overflow;
+
+			if (parent.tagName !== 'BODY') {
+				if (overflow === 'visible') {
+					_parent(parent)
+				} else {
+					return parent;
+				}
+			} else {
+				return null;
+			}
+		}
+
+		let isFixed = false, top, left,
+			bounds = _this.params.drop.getBoundingClientRect(),
+			parent = _this.params.element.getBoundingClientRect();
+
+		if (_parent(_this.params.element)) {
+			isFixed = true;
+			top = bounds.top;
+			left = bounds.left;
+		} else {
+			let styles = getComputedStyle(_this.params.drop);
+			top = normalizeData(styles.top.slice(0, -2));
+			left = normalizeData(styles.left.slice(0, -2));
+		}
+
+		if ((bounds.left + bounds.width) > window.innerWidth) {
+			left = parent.width - bounds.width;
+		}
+
+		return {
+			isFixed: isFixed,
+			top: top,
+			left: left
+		}
+	}
+}
+
+export default Placement;

package/app/utils/js/components/responsive.js

@@ -0,0 +1,83 @@
+/**
+ * Класс Responsive, работает по таким же медиа точкам, что и bootstrap
+ * и определяет на тач устройства.
+ */
+
+class Responsive {
+	constructor() {
+		this.breakpoints = {
+			xs: 0,
+			sm: 576,
+			md: 768,
+			lg: 992,
+			xl: 1200,
+			xxl: 1400,
+			xxxl: 1600,
+		};
+	}
+
+	/**
+	 * Если наша ширина экрана совпадает с диапазоном который указан в модуле выдаем true, иначе false
+	 * @param module
+	 * @returns {boolean}
+	 */
+	static check(module) {
+		let instance = new this ;
+		return instance.define(module);
+	}
+
+	/**
+	 * Проверяет на тач устройства. TODO не совсем правильно, надо сделать по-другому
+	 * @returns {boolean}
+	 */
+	static checkMobileOrTablet() {
+		let check = false;
+		(function(a) {
+			if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.slice(0,4))){
+				check = true;
+			}
+		})(navigator.userAgent||navigator.vendor||window.opera);
+
+		return check;
+	}
+
+	define(module) {
+		let windowWidth = window.innerWidth,
+			responsive_size = this._checkResponsiveClass(module),
+			breakpoints = this.breakpoints,
+			point = Object.keys(breakpoints).find(key => breakpoints[key] === responsive_size);
+
+		let keys = Object.keys(breakpoints),
+			loc = keys.indexOf(point);
+
+		return windowWidth >= breakpoints[keys[loc + 1]];
+	}
+
+	_checkResponsiveClass(module) {
+		let element = module._element,
+			params = module._params,
+			current_responsive_size = 0;
+
+		if (element.classList.contains(params.classes.XXXL)) {
+			current_responsive_size = this.breakpoints.xxxl;
+		} else if (element.classList.contains(params.classes.XXL)) {
+			current_responsive_size = this.breakpoints.xxl;
+		} else if (element.classList.contains(params.classes.XL)) {
+			current_responsive_size = this.breakpoints.xl;
+		} else if (element.classList.contains(params.classes.LG)) {
+			current_responsive_size = this.breakpoints.lg;
+		} else if (element.classList.contains(params.classes.MD)) {
+			current_responsive_size = this.breakpoints.md;
+		} else if (element.classList.contains(params.classes.SM)) {
+			current_responsive_size = this.breakpoints.sm;
+		} else if (element.classList.contains(params.classes.XS)) {
+			current_responsive_size = this.breakpoints.xs;
+		} else {
+			current_responsive_size = this.breakpoints.xs;
+		}
+
+		return current_responsive_size
+	}
+}
+
+export default Responsive;

package/app/utils/js/components/scrollbar.js

@@ -0,0 +1,114 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap util/scrollBar.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import {Manipulator} from "../dom/manipulator";
+import {isElement} from "../functions";
+import Selectors from "../dom/selectors";
+
+/**
+ * Constants
+ */
+
+const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'
+const SELECTOR_STICKY_CONTENT = '.sticky-top'
+const PROPERTY_PADDING = 'padding-right'
+const PROPERTY_MARGIN = 'margin-right'
+
+/**
+ * Class definition
+ */
+
+class ScrollBarHelper {
+	constructor() {
+		this._element = document.body
+	}
+
+	// Public
+	getWidth() {
+		// https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
+		const documentWidth = document.documentElement.clientWidth
+		return Math.abs(window.innerWidth - documentWidth)
+	}
+
+	hide() {
+		const width = this.getWidth()
+		this._disableOverFlow()
+		// give padding to element to balance the hidden scrollbar width
+		this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
+		// trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
+		this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
+		this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width)
+	}
+
+	reset() {
+		this._resetElementAttributes(this._element, 'overflow')
+		this._resetElementAttributes(this._element, PROPERTY_PADDING)
+		this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING)
+		this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN)
+	}
+
+	isOverflowing() {
+		return this.getWidth() > 0
+	}
+
+	// Private
+	_disableOverFlow() {
+		this._saveInitialAttribute(this._element, 'overflow')
+		this._element.style.overflow = 'hidden'
+	}
+
+	_setElementAttributes(selector, styleProperty, callback) {
+		const scrollbarWidth = this.getWidth()
+		const manipulationCallBack = element => {
+			if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
+				return
+			}
+
+			this._saveInitialAttribute(element, styleProperty)
+			const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty)
+			element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`)
+		}
+
+		this._applyManipulationCallback(selector, manipulationCallBack)
+	}
+
+	_saveInitialAttribute(element, styleProperty) {
+		const actualValue = element.style.getPropertyValue(styleProperty)
+		if (actualValue) {
+			Manipulator.get(element, styleProperty, actualValue)
+		}
+	}
+
+	_resetElementAttributes(selector, styleProperty) {
+		const manipulationCallBack = element => {
+			const value = Manipulator.get(element, styleProperty)
+			// We only want to remove the property if the value is `null`; the value can also be zero
+			if (value === null) {
+				element.style.removeProperty(styleProperty)
+				return
+			}
+
+			Manipulator.remove(element, styleProperty)
+			element.style.setProperty(styleProperty, value)
+		}
+
+		this._applyManipulationCallback(selector, manipulationCallBack)
+	}
+
+	_applyManipulationCallback(selector, callBack) {
+		if (isElement(selector)) {
+			callBack(selector)
+			return
+		}
+
+		for (const sel of Selectors.findAll(selector, this._element)) {
+			callBack(sel)
+		}
+	}
+}
+
+export default ScrollBarHelper

package/app/utils/js/dom/data.js

@@ -0,0 +1,51 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap data.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ * Скрипт работает с коллекцией модулей. Подробнее тут https://learn.javascript.ru/map-set
+ */
+
+/**
+ * Константы
+ */
+
+const elementMap = new Map()
+
+export default {
+	set(element, key, instance) {
+		if (!elementMap.has(element)) {
+			elementMap.set(element, new Map())
+		}
+
+		const instanceMap = elementMap.get(element)
+		if (!instanceMap.has(key) && instanceMap.size !== 0) {
+			console.error(`VGApp не допускает более одного экземпляра для каждого элемента. Связанный экземпляр: ${Array.from(instanceMap.keys())[0]}.`)
+			return
+		}
+
+		instanceMap.set(key, instance)
+	},
+
+	get(element, key) {
+		if (elementMap.has(element)) {
+			return elementMap.get(element).get(key) || null
+		}
+
+		return null
+	},
+
+	remove(element, key) {
+		if (!elementMap.has(element)) {
+			return
+		}
+
+		const instanceMap = elementMap.get(element)
+
+		instanceMap.delete(key);
+
+		if (instanceMap.size === 0) {
+			elementMap.delete(element)
+		}
+	}
+}

package/app/utils/js/dom/event.js

@@ -0,0 +1,331 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap event.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ * Скрипт для прослушивания события
+ */
+
+/**
+ * Константы
+ */
+
+const namespaceRegex = /[^.]*(?=\..*)\.|.*/
+const stripNameRegex = /\..*/
+const stripUidRegex = /::\d+$/
+const eventRegistry = {} // Events storage
+let uidEvent = 1
+const customEvents = {
+	mouseenter: 'mouseover',
+	mouseleave: 'mouseout'
+}
+
+const nativeEvents = new Set([
+	'click',
+	'dblclick',
+	'mouseup',
+	'mousedown',
+	'contextmenu',
+	'mousewheel',
+	'DOMMouseScroll',
+	'mouseover',
+	'mouseout',
+	'mousemove',
+	'selectstart',
+	'selectend',
+	'submit',
+	'keydown',
+	'keypress',
+	'keyup',
+	'orientationchange',
+	'touchstart',
+	'touchmove',
+	'touchend',
+	'touchcancel',
+	'pointerdown',
+	'pointermove',
+	'pointerup',
+	'pointerleave',
+	'pointercancel',
+	'gesturestart',
+	'gesturechange',
+	'gestureend',
+	'focus',
+	'blur',
+	'change',
+	'reset',
+	'select',
+	'submit',
+	'focusin',
+	'focusout',
+	'load',
+	'unload',
+	'beforeunload',
+	'resize',
+	'move',
+	'DOMContentLoaded',
+	'readystatechange',
+	'error',
+	'abort',
+	'scroll'
+])
+
+/**
+ * Приватные методы
+ */
+
+function makeEventUid(element, uid) {
+	return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++
+}
+
+function getElementEvents(element) {
+	const uid = makeEventUid(element)
+
+	element.uidEvent = uid
+	eventRegistry[uid] = eventRegistry[uid] || {}
+
+	return eventRegistry[uid]
+}
+
+function bootstrapHandler(element, fn) {
+	return function handler(event) {
+		hydrateObj(event, { delegateTarget: element })
+
+		if (handler.oneOff) {
+			EventHandler.off(element, event.type, fn)
+		}
+
+		return fn.apply(element, [event])
+	}
+}
+
+function bootstrapDelegationHandler(element, selector, fn) {
+	return function handler(event) {
+		const domElements = element.querySelectorAll(selector)
+
+		for (let { target } = event; target && target !== this; target = target.parentNode) {
+			for (const domElement of domElements) {
+				if (domElement !== target) {
+					continue
+				}
+
+				hydrateObj(event, { delegateTarget: target })
+
+				if (handler.oneOff) {
+					EventHandler.off(element, event.type, selector, fn)
+				}
+
+				return fn.apply(target, [event])
+			}
+		}
+	}
+}
+
+function findHandler(events, callable, delegationSelector = null) {
+	return Object.values(events)
+		.find(event => event.callable === callable && event.delegationSelector === delegationSelector)
+}
+
+function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
+	const isDelegated = typeof handler === 'string'
+	// TODO: выдает "false" вместо селектора, поэтому нужно проверить. boot
+	const callable = isDelegated ? delegationFunction : (handler || delegationFunction)
+	let typeEvent = getTypeEvent(originalTypeEvent)
+
+	if (!nativeEvents.has(typeEvent)) {
+		typeEvent = originalTypeEvent
+	}
+
+	return [isDelegated, callable, typeEvent]
+}
+
+function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
+	if (typeof originalTypeEvent !== 'string' || !element) {
+		return
+	}
+
+	let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
+
+	// in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
+	// this prevents the handler from being dispatched the same way as mouseover or mouseout does
+	if (originalTypeEvent in customEvents) {
+		const wrapFunction = fn => {
+			return function (event) {
+				if (!event.relatedTarget || (event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget))) {
+					return fn.call(this, event)
+				}
+			}
+		}
+
+		callable = wrapFunction(callable)
+	}
+
+	const events = getElementEvents(element)
+	const handlers = events[typeEvent] || (events[typeEvent] = {})
+	const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null)
+
+	if (previousFunction) {
+		previousFunction.oneOff = previousFunction.oneOff && oneOff
+
+		return
+	}
+
+	const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''))
+	const fn = isDelegated ?
+		bootstrapDelegationHandler(element, handler, callable) :
+		bootstrapHandler(element, callable)
+
+	fn.delegationSelector = isDelegated ? handler : null
+	fn.callable = callable
+	fn.oneOff = oneOff
+	fn.uidEvent = uid
+	handlers[uid] = fn
+
+	element.addEventListener(typeEvent, fn, isDelegated)
+}
+
+function removeHandler(element, events, typeEvent, handler, delegationSelector) {
+	const fn = findHandler(events[typeEvent], handler, delegationSelector)
+
+	if (!fn) {
+		return
+	}
+
+	element.removeEventListener(typeEvent, fn, Boolean(delegationSelector))
+	delete events[typeEvent][fn.uidEvent]
+}
+
+function removeNamespacedHandlers(element, events, typeEvent, namespace) {
+	const storeElementEvent = events[typeEvent] || {}
+
+	for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
+		if (handlerKey.includes(namespace)) {
+			removeHandler(element, events, typeEvent, event.callable, event.delegationSelector)
+		}
+	}
+}
+
+function getTypeEvent(event) {
+	// allow to get the native events from namespaced events ('click.bs.button' --> 'click')
+	event = event.replace(stripNameRegex, '')
+	return customEvents[event] || event
+}
+
+function hydrateObj(obj, meta = {}) {
+	for (const [key, value] of Object.entries(meta)) {
+		try {
+			obj[key] = value
+		} catch {
+			Object.defineProperty(obj, key, {
+				configurable: true,
+				get() {
+					return value
+				}
+			})
+		}
+	}
+
+	return obj
+}
+
+/**
+ * События
+ * @type {{one(*, *, *, *): void, trigger(*, *, *): (null|*), off(*, *, *, *): void, on(*, *, *, *): void}}
+ */
+const EventHandler = {
+	/**
+	 * Прослушиватель событий (элемент, событие (полный список смотри в константе nativeEvents, источник события или хендлер, функция обратного вызова))
+	 * @param element
+	 * @param event
+	 * @param handler
+	 * @param delegationFunction
+	 */
+	on(element, event, handler, delegationFunction) {
+		addHandler(element, event, handler, delegationFunction, false)
+	},
+
+	/**
+	 * Прослушиватель событий, но замыкается и больше не повторяется на элементе
+	 * @param element
+	 * @param event
+	 * @param handler
+	 * @param delegationFunction
+	 */
+	one(element, event, handler, delegationFunction) {
+		addHandler(element, event, handler, delegationFunction, true)
+	},
+
+	/**
+	 * Удаление обработчика
+	 * @param element
+	 * @param originalTypeEvent
+	 * @param handler
+	 * @param delegationFunction
+	 */
+	off(element, originalTypeEvent, handler, delegationFunction) {
+		if (typeof originalTypeEvent !== 'string' || !element) {
+			return
+		}
+
+		const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
+		const inNamespace = typeEvent !== originalTypeEvent
+		const events = getElementEvents(element)
+		const storeElementEvent = events[typeEvent] || {}
+		const isNamespace = originalTypeEvent.startsWith('.')
+
+		if (typeof callable !== 'undefined') {
+			// Simplest case: handler is passed, remove that listener ONLY.
+			if (!Object.keys(storeElementEvent).length) {
+				return
+			}
+
+			removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null)
+			return
+		}
+
+		if (isNamespace) {
+			for (const elementEvent of Object.keys(events)) {
+				removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1))
+			}
+		}
+
+		for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
+			const handlerKey = keyHandlers.replace(stripUidRegex, '')
+
+			if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
+				removeHandler(element, events, typeEvent, event.callable, event.delegationSelector)
+			}
+		}
+	},
+
+	/**
+	 * Пользовательские события. Подробнее тут https://learn.javascript.ru/dispatch-events
+	 * @param element
+	 * @param event
+	 * @param args
+	 * @returns {*|null}
+	 */
+	trigger(element, event, args) {
+		if (typeof event !== 'string' || !element) {
+			return null
+		}
+
+		let bubbles = true;
+		let nativeDispatch = true;
+		let defaultPrevented = false;
+
+		const evt = hydrateObj(new Event(event, { bubbles, cancelable: true }), args)
+
+		if (defaultPrevented) {
+			evt.preventDefault()
+		}
+
+		if (nativeDispatch) {
+			element.dispatchEvent(evt)
+		}
+
+		return evt
+	}
+}
+
+export default EventHandler

package/app/utils/js/dom/manipulator.js

@@ -0,0 +1,62 @@
+import {isElement, normalizeData} from "../functions";
+
+/**
+ * Манипуляции с атрибутами у элемента:
+ * get (элемент, имя, флаг - вырезать data-) - метод выбирает значение атрибута по его имени, если в поле имени передать 'data' -> будут выбраны только дата атрибуты, если 'all' -> метод вернет значение всех атрибутов
+ * has (элемент, имя) - есть ли атрибут у элемента
+ * set (элемент, имя, значение) - установка у элемента атрибута или его изменение
+ * remove (элемент, имя) - удаляет атрибут у элемента
+ */
+const Manipulator = {
+	get(element, nameAttribute = 'data', isRemoveDataName = true) {
+		if (!element) {
+			return {}
+		}
+
+		if (nameAttribute === 'data') {
+			let elmBase = ['data-vg-toggle', 'data-vg-target', 'data-vg-dismiss'],
+				attributes = {};
+
+			let arr = [].filter.call(element.attributes, function (at) {
+				return /^data-/.test(at.name);
+			});
+
+			if (arr.length) {
+				arr.forEach(function (v) {
+					let name = v.name;
+
+					if (!elmBase.includes(name)) {
+						if (isRemoveDataName) name = name.slice(5);
+						attributes[name] = normalizeData(v.value)
+					}
+				});
+			}
+
+			return attributes;
+		} else if (nameAttribute === 'all') {
+			return element.getAttributeNames().reduce((acc, name) => {
+				return {...acc, [name]: element.getAttribute(name)};
+			}, {});
+		} else {
+			return element.getAttribute(nameAttribute);
+		}
+	},
+
+	has(element, nameAttribute) {
+		return element.hasAttribute(nameAttribute);
+	},
+
+	set(element, name, value) {
+		if (isElement(element) && name) {
+			element.setAttribute(name, value);
+		}
+	},
+
+	remove(element, nameAttribute) {
+		if (isElement(element) && nameAttribute) {
+			element.removeAttribute(nameAttribute);
+		}
+	}
+}
+
+export {Manipulator}