cloudinary-video-player 3.12.1 → 3.12.2-edge.0

package/lib/document.js

@@ -0,0 +1,770 @@
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.js';
+
+var window_1;
+var hasRequiredWindow;
+
+function requireWindow () {
+	if (hasRequiredWindow) return window_1;
+	hasRequiredWindow = 1;
+	var win;
+
+	if (typeof window !== "undefined") {
+	    win = window;
+	} else if (typeof commonjsGlobal !== "undefined") {
+	    win = commonjsGlobal;
+	} else if (typeof self !== "undefined"){
+	    win = self;
+	} else {
+	    win = {};
+	}
+
+	window_1 = win;
+	return window_1;
+}
+
+var windowExports = requireWindow();
+var window$1 = /*@__PURE__*/getDefaultExportFromCjs(windowExports);
+
+var domWalk;
+var hasRequiredDomWalk;
+
+function requireDomWalk () {
+	if (hasRequiredDomWalk) return domWalk;
+	hasRequiredDomWalk = 1;
+	var slice = Array.prototype.slice;
+
+	domWalk = iterativelyWalk;
+
+	function iterativelyWalk(nodes, cb) {
+	    if (!('length' in nodes)) {
+	        nodes = [nodes];
+	    }
+	    
+	    nodes = slice.call(nodes);
+
+	    while(nodes.length) {
+	        var node = nodes.shift(),
+	            ret = cb(node);
+
+	        if (ret) {
+	            return ret
+	        }
+
+	        if (node.childNodes && node.childNodes.length) {
+	            nodes = slice.call(node.childNodes).concat(nodes);
+	        }
+	    }
+	}
+	return domWalk;
+}
+
+var domComment;
+var hasRequiredDomComment;
+
+function requireDomComment () {
+	if (hasRequiredDomComment) return domComment;
+	hasRequiredDomComment = 1;
+	domComment = Comment;
+
+	function Comment(data, owner) {
+	    if (!(this instanceof Comment)) {
+	        return new Comment(data, owner)
+	    }
+
+	    this.data = data;
+	    this.nodeValue = data;
+	    this.length = data.length;
+	    this.ownerDocument = owner || null;
+	}
+
+	Comment.prototype.nodeType = 8;
+	Comment.prototype.nodeName = "#comment";
+
+	Comment.prototype.toString = function _Comment_toString() {
+	    return "[object Comment]"
+	};
+	return domComment;
+}
+
+var domText;
+var hasRequiredDomText;
+
+function requireDomText () {
+	if (hasRequiredDomText) return domText;
+	hasRequiredDomText = 1;
+	domText = DOMText;
+
+	function DOMText(value, owner) {
+	    if (!(this instanceof DOMText)) {
+	        return new DOMText(value)
+	    }
+
+	    this.data = value || "";
+	    this.length = this.data.length;
+	    this.ownerDocument = owner || null;
+	}
+
+	DOMText.prototype.type = "DOMTextNode";
+	DOMText.prototype.nodeType = 3;
+	DOMText.prototype.nodeName = "#text";
+
+	DOMText.prototype.toString = function _Text_toString() {
+	    return this.data
+	};
+
+	DOMText.prototype.replaceData = function replaceData(index, length, value) {
+	    var current = this.data;
+	    var left = current.substring(0, index);
+	    var right = current.substring(index + length, current.length);
+	    this.data = left + value + right;
+	    this.length = this.data.length;
+	};
+	return domText;
+}
+
+var dispatchEvent_1;
+var hasRequiredDispatchEvent;
+
+function requireDispatchEvent () {
+	if (hasRequiredDispatchEvent) return dispatchEvent_1;
+	hasRequiredDispatchEvent = 1;
+	dispatchEvent_1 = dispatchEvent;
+
+	function dispatchEvent(ev) {
+	    var elem = this;
+	    var type = ev.type;
+
+	    if (!ev.target) {
+	        ev.target = elem;
+	    }
+
+	    if (!elem.listeners) {
+	        elem.listeners = {};
+	    }
+
+	    var listeners = elem.listeners[type];
+
+	    if (listeners) {
+	        return listeners.forEach(function (listener) {
+	            ev.currentTarget = elem;
+	            if (typeof listener === 'function') {
+	                listener(ev);
+	            } else {
+	                listener.handleEvent(ev);
+	            }
+	        })
+	    }
+
+	    if (elem.parentNode) {
+	        elem.parentNode.dispatchEvent(ev);
+	    }
+	}
+	return dispatchEvent_1;
+}
+
+var addEventListener_1;
+var hasRequiredAddEventListener;
+
+function requireAddEventListener () {
+	if (hasRequiredAddEventListener) return addEventListener_1;
+	hasRequiredAddEventListener = 1;
+	addEventListener_1 = addEventListener;
+
+	function addEventListener(type, listener) {
+	    var elem = this;
+
+	    if (!elem.listeners) {
+	        elem.listeners = {};
+	    }
+
+	    if (!elem.listeners[type]) {
+	        elem.listeners[type] = [];
+	    }
+
+	    if (elem.listeners[type].indexOf(listener) === -1) {
+	        elem.listeners[type].push(listener);
+	    }
+	}
+	return addEventListener_1;
+}
+
+var removeEventListener_1;
+var hasRequiredRemoveEventListener;
+
+function requireRemoveEventListener () {
+	if (hasRequiredRemoveEventListener) return removeEventListener_1;
+	hasRequiredRemoveEventListener = 1;
+	removeEventListener_1 = removeEventListener;
+
+	function removeEventListener(type, listener) {
+	    var elem = this;
+
+	    if (!elem.listeners) {
+	        return
+	    }
+
+	    if (!elem.listeners[type]) {
+	        return
+	    }
+
+	    var list = elem.listeners[type];
+	    var index = list.indexOf(listener);
+	    if (index !== -1) {
+	        list.splice(index, 1);
+	    }
+	}
+	return removeEventListener_1;
+}
+
+var serialize;
+var hasRequiredSerialize;
+
+function requireSerialize () {
+	if (hasRequiredSerialize) return serialize;
+	hasRequiredSerialize = 1;
+	serialize = serializeNode;
+
+	var voidElements = ["area","base","br","col","embed","hr","img","input","keygen","link","menuitem","meta","param","source","track","wbr"];
+
+	function serializeNode(node) {
+	    switch (node.nodeType) {
+	        case 3:
+	            return escapeText(node.data)
+	        case 8:
+	            return "<!--" + node.data + "-->"
+	        default:
+	            return serializeElement(node)
+	    }
+	}
+
+	function serializeElement(elem) {
+	    var strings = [];
+
+	    var tagname = elem.tagName;
+
+	    if (elem.namespaceURI === "http://www.w3.org/1999/xhtml") {
+	        tagname = tagname.toLowerCase();
+	    }
+
+	    strings.push("<" + tagname + properties(elem) + datasetify(elem));
+
+	    if (voidElements.indexOf(tagname) > -1) {
+	        strings.push(" />");
+	    } else {
+	        strings.push(">");
+
+	        if (elem.childNodes.length) {
+	            strings.push.apply(strings, elem.childNodes.map(serializeNode));
+	        } else if (elem.textContent || elem.innerText) {
+	            strings.push(escapeText(elem.textContent || elem.innerText));
+	        } else if (elem.innerHTML) {
+	            strings.push(elem.innerHTML);
+	        }
+
+	        strings.push("</" + tagname + ">");
+	    }
+
+	    return strings.join("")
+	}
+
+	function isProperty(elem, key) {
+	    var type = typeof elem[key];
+
+	    if (key === "style" && Object.keys(elem.style).length > 0) {
+	      return true
+	    }
+
+	    return elem.hasOwnProperty(key) &&
+	        (type === "string" || type === "boolean" || type === "number") &&
+	        key !== "nodeName" && key !== "className" && key !== "tagName" &&
+	        key !== "textContent" && key !== "innerText" && key !== "namespaceURI" &&  key !== "innerHTML"
+	}
+
+	function stylify(styles) {
+	    if (typeof styles === 'string') return styles
+	    var attr = "";
+	    Object.keys(styles).forEach(function (key) {
+	        var value = styles[key];
+	        key = key.replace(/[A-Z]/g, function(c) {
+	            return "-" + c.toLowerCase();
+	        });
+	        attr += key + ":" + value + ";";
+	    });
+	    return attr
+	}
+
+	function datasetify(elem) {
+	    var ds = elem.dataset;
+	    var props = [];
+
+	    for (var key in ds) {
+	        props.push({ name: "data-" + key, value: ds[key] });
+	    }
+
+	    return props.length ? stringify(props) : ""
+	}
+
+	function stringify(list) {
+	    var attributes = [];
+	    list.forEach(function (tuple) {
+	        var name = tuple.name;
+	        var value = tuple.value;
+
+	        if (name === "style") {
+	            value = stylify(value);
+	        }
+
+	        attributes.push(name + "=" + "\"" + escapeAttributeValue(value) + "\"");
+	    });
+
+	    return attributes.length ? " " + attributes.join(" ") : ""
+	}
+
+	function properties(elem) {
+	    var props = [];
+	    for (var key in elem) {
+	        if (isProperty(elem, key)) {
+	            props.push({ name: key, value: elem[key] });
+	        }
+	    }
+
+	    for (var ns in elem._attributes) {
+	      for (var attribute in elem._attributes[ns]) {
+	        var prop = elem._attributes[ns][attribute];
+	        var name = (prop.prefix ? prop.prefix + ":" : "") + attribute;
+	        props.push({ name: name, value: prop.value });
+	      }
+	    }
+
+	    if (elem.className) {
+	        props.push({ name: "class", value: elem.className });
+	    }
+
+	    return props.length ? stringify(props) : ""
+	}
+
+	function escapeText(s) {
+	    var str = '';
+
+	    if (typeof(s) === 'string') { 
+	        str = s; 
+	    } else if (s) {
+	        str = s.toString();
+	    }
+
+	    return str
+	        .replace(/&/g, "&amp;")
+	        .replace(/</g, "&lt;")
+	        .replace(/>/g, "&gt;")
+	}
+
+	function escapeAttributeValue(str) {
+	    return escapeText(str).replace(/"/g, "&quot;")
+	}
+	return serialize;
+}
+
+var domElement;
+var hasRequiredDomElement;
+
+function requireDomElement () {
+	if (hasRequiredDomElement) return domElement;
+	hasRequiredDomElement = 1;
+	var domWalk = requireDomWalk();
+	var dispatchEvent = requireDispatchEvent();
+	var addEventListener = requireAddEventListener();
+	var removeEventListener = requireRemoveEventListener();
+	var serializeNode = requireSerialize();
+
+	var htmlns = "http://www.w3.org/1999/xhtml";
+
+	domElement = DOMElement;
+
+	function DOMElement(tagName, owner, namespace) {
+	    if (!(this instanceof DOMElement)) {
+	        return new DOMElement(tagName)
+	    }
+
+	    var ns = namespace === undefined ? htmlns : (namespace || null);
+
+	    this.tagName = ns === htmlns ? String(tagName).toUpperCase() : tagName;
+	    this.nodeName = this.tagName;
+	    this.className = "";
+	    this.dataset = {};
+	    this.childNodes = [];
+	    this.parentNode = null;
+	    this.style = {};
+	    this.ownerDocument = owner || null;
+	    this.namespaceURI = ns;
+	    this._attributes = {};
+
+	    if (this.tagName === 'INPUT') {
+	      this.type = 'text';
+	    }
+	}
+
+	DOMElement.prototype.type = "DOMElement";
+	DOMElement.prototype.nodeType = 1;
+
+	DOMElement.prototype.appendChild = function _Element_appendChild(child) {
+	    if (child.parentNode) {
+	        child.parentNode.removeChild(child);
+	    }
+
+	    this.childNodes.push(child);
+	    child.parentNode = this;
+
+	    return child
+	};
+
+	DOMElement.prototype.replaceChild =
+	    function _Element_replaceChild(elem, needle) {
+	        // TODO: Throw NotFoundError if needle.parentNode !== this
+
+	        if (elem.parentNode) {
+	            elem.parentNode.removeChild(elem);
+	        }
+
+	        var index = this.childNodes.indexOf(needle);
+
+	        needle.parentNode = null;
+	        this.childNodes[index] = elem;
+	        elem.parentNode = this;
+
+	        return needle
+	    };
+
+	DOMElement.prototype.removeChild = function _Element_removeChild(elem) {
+	    // TODO: Throw NotFoundError if elem.parentNode !== this
+
+	    var index = this.childNodes.indexOf(elem);
+	    this.childNodes.splice(index, 1);
+
+	    elem.parentNode = null;
+	    return elem
+	};
+
+	DOMElement.prototype.insertBefore =
+	    function _Element_insertBefore(elem, needle) {
+	        // TODO: Throw NotFoundError if referenceElement is a dom node
+	        // and parentNode !== this
+
+	        if (elem.parentNode) {
+	            elem.parentNode.removeChild(elem);
+	        }
+
+	        var index = needle === null || needle === undefined ?
+	            -1 :
+	            this.childNodes.indexOf(needle);
+
+	        if (index > -1) {
+	            this.childNodes.splice(index, 0, elem);
+	        } else {
+	            this.childNodes.push(elem);
+	        }
+
+	        elem.parentNode = this;
+	        return elem
+	    };
+
+	DOMElement.prototype.setAttributeNS =
+	    function _Element_setAttributeNS(namespace, name, value) {
+	        var prefix = null;
+	        var localName = name;
+	        var colonPosition = name.indexOf(":");
+	        if (colonPosition > -1) {
+	            prefix = name.substr(0, colonPosition);
+	            localName = name.substr(colonPosition + 1);
+	        }
+	        if (this.tagName === 'INPUT' && name === 'type') {
+	          this.type = value;
+	        }
+	        else {
+	          var attributes = this._attributes[namespace] || (this._attributes[namespace] = {});
+	          attributes[localName] = {value: value, prefix: prefix};
+	        }
+	    };
+
+	DOMElement.prototype.getAttributeNS =
+	    function _Element_getAttributeNS(namespace, name) {
+	        var attributes = this._attributes[namespace];
+	        var value = attributes && attributes[name] && attributes[name].value;
+	        if (this.tagName === 'INPUT' && name === 'type') {
+	          return this.type;
+	        }
+	        if (typeof value !== "string") {
+	            return null
+	        }
+	        return value
+	    };
+
+	DOMElement.prototype.removeAttributeNS =
+	    function _Element_removeAttributeNS(namespace, name) {
+	        // Prevent prototype pollution by checking if namespace is a direct property
+	        if (!Object.prototype.hasOwnProperty.call(this._attributes, namespace)) {
+	            return;
+	        }
+	        var attributes = this._attributes[namespace];
+	        if (attributes && Object.prototype.hasOwnProperty.call(attributes, name)) {
+	            delete attributes[name];
+	        }
+	    };
+
+	DOMElement.prototype.hasAttributeNS =
+	    function _Element_hasAttributeNS(namespace, name) {
+	        var attributes = this._attributes[namespace];
+	        return !!attributes && name in attributes;
+	    };
+
+	DOMElement.prototype.setAttribute = function _Element_setAttribute(name, value) {
+	    return this.setAttributeNS(null, name, value)
+	};
+
+	DOMElement.prototype.getAttribute = function _Element_getAttribute(name) {
+	    return this.getAttributeNS(null, name)
+	};
+
+	DOMElement.prototype.removeAttribute = function _Element_removeAttribute(name) {
+	    return this.removeAttributeNS(null, name)
+	};
+
+	DOMElement.prototype.hasAttribute = function _Element_hasAttribute(name) {
+	    return this.hasAttributeNS(null, name)
+	};
+
+	DOMElement.prototype.removeEventListener = removeEventListener;
+	DOMElement.prototype.addEventListener = addEventListener;
+	DOMElement.prototype.dispatchEvent = dispatchEvent;
+
+	// Un-implemented
+	DOMElement.prototype.focus = function _Element_focus() {
+	    return void 0
+	};
+
+	DOMElement.prototype.toString = function _Element_toString() {
+	    return serializeNode(this)
+	};
+
+	DOMElement.prototype.getElementsByClassName = function _Element_getElementsByClassName(classNames) {
+	    var classes = classNames.split(" ");
+	    var elems = [];
+
+	    domWalk(this, function (node) {
+	        if (node.nodeType === 1) {
+	            var nodeClassName = node.className || "";
+	            var nodeClasses = nodeClassName.split(" ");
+
+	            if (classes.every(function (item) {
+	                return nodeClasses.indexOf(item) !== -1
+	            })) {
+	                elems.push(node);
+	            }
+	        }
+	    });
+
+	    return elems
+	};
+
+	DOMElement.prototype.getElementsByTagName = function _Element_getElementsByTagName(tagName) {
+	    tagName = tagName.toLowerCase();
+	    var elems = [];
+
+	    domWalk(this.childNodes, function (node) {
+	        if (node.nodeType === 1 && (tagName === '*' || node.tagName.toLowerCase() === tagName)) {
+	            elems.push(node);
+	        }
+	    });
+
+	    return elems
+	};
+
+	DOMElement.prototype.contains = function _Element_contains(element) {
+	    return domWalk(this, function (node) {
+	        return element === node
+	    }) || false
+	};
+	return domElement;
+}
+
+var domFragment;
+var hasRequiredDomFragment;
+
+function requireDomFragment () {
+	if (hasRequiredDomFragment) return domFragment;
+	hasRequiredDomFragment = 1;
+	var DOMElement = requireDomElement();
+
+	domFragment = DocumentFragment;
+
+	function DocumentFragment(owner) {
+	    if (!(this instanceof DocumentFragment)) {
+	        return new DocumentFragment()
+	    }
+
+	    this.childNodes = [];
+	    this.parentNode = null;
+	    this.ownerDocument = owner || null;
+	}
+
+	DocumentFragment.prototype.type = "DocumentFragment";
+	DocumentFragment.prototype.nodeType = 11;
+	DocumentFragment.prototype.nodeName = "#document-fragment";
+
+	DocumentFragment.prototype.appendChild  = DOMElement.prototype.appendChild;
+	DocumentFragment.prototype.replaceChild = DOMElement.prototype.replaceChild;
+	DocumentFragment.prototype.removeChild  = DOMElement.prototype.removeChild;
+
+	DocumentFragment.prototype.toString =
+	    function _DocumentFragment_toString() {
+	        return this.childNodes.map(function (node) {
+	            return String(node)
+	        }).join("")
+	    };
+	return domFragment;
+}
+
+var event;
+var hasRequiredEvent;
+
+function requireEvent () {
+	if (hasRequiredEvent) return event;
+	hasRequiredEvent = 1;
+	event = Event;
+
+	function Event(family) {}
+
+	Event.prototype.initEvent = function _Event_initEvent(type, bubbles, cancelable) {
+	    this.type = type;
+	    this.bubbles = bubbles;
+	    this.cancelable = cancelable;
+	};
+
+	Event.prototype.preventDefault = function _Event_preventDefault() {
+	    
+	};
+	return event;
+}
+
+var document$2;
+var hasRequiredDocument$1;
+
+function requireDocument$1 () {
+	if (hasRequiredDocument$1) return document$2;
+	hasRequiredDocument$1 = 1;
+	var domWalk = requireDomWalk();
+
+	var Comment = requireDomComment();
+	var DOMText = requireDomText();
+	var DOMElement = requireDomElement();
+	var DocumentFragment = requireDomFragment();
+	var Event = requireEvent();
+	var dispatchEvent = requireDispatchEvent();
+	var addEventListener = requireAddEventListener();
+	var removeEventListener = requireRemoveEventListener();
+
+	document$2 = Document;
+
+	function Document() {
+	    if (!(this instanceof Document)) {
+	        return new Document();
+	    }
+
+	    this.head = this.createElement("head");
+	    this.body = this.createElement("body");
+	    this.documentElement = this.createElement("html");
+	    this.documentElement.appendChild(this.head);
+	    this.documentElement.appendChild(this.body);
+	    this.childNodes = [this.documentElement];
+	    this.nodeType = 9;
+	}
+
+	var proto = Document.prototype;
+	proto.createTextNode = function createTextNode(value) {
+	    return new DOMText(value, this)
+	};
+
+	proto.createElementNS = function createElementNS(namespace, tagName) {
+	    var ns = namespace === null ? null : String(namespace);
+	    return new DOMElement(tagName, this, ns)
+	};
+
+	proto.createElement = function createElement(tagName) {
+	    return new DOMElement(tagName, this)
+	};
+
+	proto.createDocumentFragment = function createDocumentFragment() {
+	    return new DocumentFragment(this)
+	};
+
+	proto.createEvent = function createEvent(family) {
+	    return new Event(family)
+	};
+
+	proto.createComment = function createComment(data) {
+	    return new Comment(data, this)
+	};
+
+	proto.getElementById = function getElementById(id) {
+	    id = String(id);
+
+	    var result = domWalk(this.childNodes, function (node) {
+	        if (String(node.id) === id) {
+	            return node
+	        }
+	    });
+
+	    return result || null
+	};
+
+	proto.getElementsByClassName = DOMElement.prototype.getElementsByClassName;
+	proto.getElementsByTagName = DOMElement.prototype.getElementsByTagName;
+	proto.contains = DOMElement.prototype.contains;
+
+	proto.removeEventListener = removeEventListener;
+	proto.addEventListener = addEventListener;
+	proto.dispatchEvent = dispatchEvent;
+	return document$2;
+}
+
+var minDocument;
+var hasRequiredMinDocument;
+
+function requireMinDocument () {
+	if (hasRequiredMinDocument) return minDocument;
+	hasRequiredMinDocument = 1;
+	var Document = requireDocument$1();
+
+	minDocument = new Document();
+	return minDocument;
+}
+
+var document_1;
+var hasRequiredDocument;
+
+function requireDocument () {
+	if (hasRequiredDocument) return document_1;
+	hasRequiredDocument = 1;
+	var topLevel = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal :
+	    typeof window !== 'undefined' ? window : {};
+	var minDoc = requireMinDocument();
+
+	var doccy;
+
+	if (typeof document !== 'undefined') {
+	    doccy = document;
+	} else {
+	    doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
+
+	    if (!doccy) {
+	        doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
+	    }
+	}
+
+	document_1 = doccy;
+	return document_1;
+}
+
+var documentExports = requireDocument();
+var document$1 = /*@__PURE__*/getDefaultExportFromCjs(documentExports);
+
+export { document$1 as d, window$1 as w };