@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.100

package/dist/treeshaking/_virtual/@videojs/xhr/lib/index.js.mjs

@@ -0,0 +1,242 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+import { require_extends } from "../../../@babel/runtime/helpers/extends.js.mjs";
+import { require_is_function } from "../../../is-function/index.js.mjs";
+import { require_interceptors } from "./interceptors.js.mjs";
+import { require_retry } from "./retry.js.mjs";
+import { require_http_handler } from "./http-handler.js.mjs";
+// ../../node_modules/.pnpm/@videojs+xhr@2.7.0/node_modules/@videojs/xhr/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var window = require_window();
+	var _extends = require_extends();
+	var isFunction = require_is_function();
+	var InterceptorsStorage = require_interceptors();
+	var RetryManager = require_retry();
+	createXHR.httpHandler = require_http_handler();
+	createXHR.requestInterceptorsStorage = new InterceptorsStorage();
+	createXHR.responseInterceptorsStorage = new InterceptorsStorage();
+	createXHR.retryManager = new RetryManager();
+	/**
+	* @license
+	* slighly modified parse-headers 2.0.2 <https://github.com/kesla/parse-headers/>
+	* Copyright (c) 2014 David Björklund
+	* Available under the MIT license
+	* <https://github.com/kesla/parse-headers/blob/master/LICENCE>
+	*/
+	var parseHeaders = function parseHeaders(headers) {
+		var result = {};
+		if (!headers) return result;
+		headers.trim().split("\n").forEach(function(row) {
+			var index = row.indexOf(":");
+			var key = row.slice(0, index).trim().toLowerCase();
+			var value = row.slice(index + 1).trim();
+			if (typeof result[key] === "undefined") result[key] = value;
+			else if (Array.isArray(result[key])) result[key].push(value);
+			else result[key] = [result[key], value];
+		});
+		return result;
+	};
+	module.exports = createXHR;
+	module.exports.default = createXHR;
+	createXHR.XMLHttpRequest = window.XMLHttpRequest || noop;
+	createXHR.XDomainRequest = "withCredentials" in new createXHR.XMLHttpRequest() ? createXHR.XMLHttpRequest : window.XDomainRequest;
+	forEachArray([
+		"get",
+		"put",
+		"post",
+		"patch",
+		"head",
+		"delete"
+	], function(method) {
+		createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
+			options = initParams(uri, options, callback);
+			options.method = method.toUpperCase();
+			return _createXHR(options);
+		};
+	});
+	function forEachArray(array, iterator) {
+		for (var i = 0; i < array.length; i++) iterator(array[i]);
+	}
+	function isEmpty(obj) {
+		for (var i in obj) if (obj.hasOwnProperty(i)) return false;
+		return true;
+	}
+	function initParams(uri, options, callback) {
+		var params = uri;
+		if (isFunction(options)) {
+			callback = options;
+			if (typeof uri === "string") params = { uri };
+		} else params = _extends({}, options, { uri });
+		params.callback = callback;
+		return params;
+	}
+	function createXHR(uri, options, callback) {
+		options = initParams(uri, options, callback);
+		return _createXHR(options);
+	}
+	function _createXHR(options) {
+		if (typeof options.callback === "undefined") throw new Error("callback argument missing");
+		if (options.requestType && createXHR.requestInterceptorsStorage.getIsEnabled()) {
+			var requestInterceptorPayload = {
+				uri: options.uri || options.url,
+				headers: options.headers || {},
+				body: options.body,
+				metadata: options.metadata || {},
+				retry: options.retry,
+				timeout: options.timeout
+			};
+			var updatedPayload = createXHR.requestInterceptorsStorage.execute(options.requestType, requestInterceptorPayload);
+			options.uri = updatedPayload.uri;
+			options.headers = updatedPayload.headers;
+			options.body = updatedPayload.body;
+			options.metadata = updatedPayload.metadata;
+			options.retry = updatedPayload.retry;
+			options.timeout = updatedPayload.timeout;
+		}
+		var called = false;
+		var callback = function cbOnce(err, response, body) {
+			if (!called) {
+				called = true;
+				options.callback(err, response, body);
+			}
+		};
+		function readystatechange() {
+			if (xhr.readyState === 4 && !createXHR.responseInterceptorsStorage.getIsEnabled()) setTimeout(loadFunc, 0);
+		}
+		function getBody() {
+			var body = void 0;
+			if (xhr.response) body = xhr.response;
+			else body = xhr.responseText || getXml(xhr);
+			if (isJson) try {
+				body = JSON.parse(body);
+			} catch (e) {}
+			return body;
+		}
+		function errorFunc(evt) {
+			clearTimeout(timeoutTimer);
+			clearTimeout(options.retryTimeout);
+			if (!(evt instanceof Error)) evt = /* @__PURE__ */ new Error("" + (evt || "Unknown XMLHttpRequest Error"));
+			evt.statusCode = 0;
+			if (!aborted && createXHR.retryManager.getIsEnabled() && options.retry && options.retry.shouldRetry()) {
+				options.retryTimeout = setTimeout(function() {
+					options.retry.moveToNextAttempt();
+					options.xhr = xhr;
+					_createXHR(options);
+				}, options.retry.getCurrentFuzzedDelay());
+				return;
+			}
+			if (options.requestType && createXHR.responseInterceptorsStorage.getIsEnabled()) {
+				var responseInterceptorPayload = {
+					headers: failureResponse.headers || {},
+					body: failureResponse.body,
+					responseUrl: xhr.responseURL,
+					responseType: xhr.responseType
+				};
+				var _updatedPayload = createXHR.responseInterceptorsStorage.execute(options.requestType, responseInterceptorPayload);
+				failureResponse.body = _updatedPayload.body;
+				failureResponse.headers = _updatedPayload.headers;
+			}
+			return callback(evt, failureResponse);
+		}
+		function loadFunc() {
+			if (aborted) return;
+			var status;
+			clearTimeout(timeoutTimer);
+			clearTimeout(options.retryTimeout);
+			if (options.useXDR && xhr.status === void 0) status = 200;
+			else status = xhr.status === 1223 ? 204 : xhr.status;
+			var response = failureResponse;
+			var err = null;
+			if (status !== 0) {
+				response = {
+					body: getBody(),
+					statusCode: status,
+					method,
+					headers: {},
+					url: uri,
+					rawRequest: xhr
+				};
+				if (xhr.getAllResponseHeaders) response.headers = parseHeaders(xhr.getAllResponseHeaders());
+			} else err = /* @__PURE__ */ new Error("Internal XMLHttpRequest Error");
+			if (options.requestType && createXHR.responseInterceptorsStorage.getIsEnabled()) {
+				var responseInterceptorPayload = {
+					headers: response.headers || {},
+					body: response.body,
+					responseUrl: xhr.responseURL,
+					responseType: xhr.responseType
+				};
+				var _updatedPayload2 = createXHR.responseInterceptorsStorage.execute(options.requestType, responseInterceptorPayload);
+				response.body = _updatedPayload2.body;
+				response.headers = _updatedPayload2.headers;
+			}
+			return callback(err, response, response.body);
+		}
+		var xhr = options.xhr || null;
+		if (!xhr) {
+			if (options.cors || options.useXDR) xhr = new createXHR.XDomainRequest();
+			else xhr = new createXHR.XMLHttpRequest();
+		}
+		var key;
+		var aborted;
+		var uri = xhr.url = options.uri || options.url;
+		var method = xhr.method = options.method || "GET";
+		var body = options.body || options.data;
+		var headers = xhr.headers = options.headers || {};
+		var sync = !!options.sync;
+		var isJson = false;
+		var timeoutTimer;
+		var failureResponse = {
+			body: void 0,
+			headers: {},
+			statusCode: 0,
+			method,
+			url: uri,
+			rawRequest: xhr
+		};
+		if ("json" in options && options.json !== false) {
+			isJson = true;
+			headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json");
+			if (method !== "GET" && method !== "HEAD") {
+				headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json");
+				body = JSON.stringify(options.json === true ? body : options.json);
+			}
+		}
+		xhr.onreadystatechange = readystatechange;
+		xhr.onload = loadFunc;
+		xhr.onerror = errorFunc;
+		xhr.onprogress = function() {};
+		xhr.onabort = function() {
+			aborted = true;
+			clearTimeout(options.retryTimeout);
+		};
+		xhr.ontimeout = errorFunc;
+		xhr.open(method, uri, !sync, options.username, options.password);
+		if (!sync) xhr.withCredentials = !!options.withCredentials;
+		if (!sync && options.timeout > 0) timeoutTimer = setTimeout(function() {
+			if (aborted) return;
+			aborted = true;
+			xhr.abort("timeout");
+			var e = /* @__PURE__ */ new Error("XMLHttpRequest timeout");
+			e.code = "ETIMEDOUT";
+			errorFunc(e);
+		}, options.timeout);
+		if (xhr.setRequestHeader) {
+			for (key in headers) if (headers.hasOwnProperty(key)) xhr.setRequestHeader(key, headers[key]);
+		} else if (options.headers && !isEmpty(options.headers)) throw new Error("Headers cannot be set on an XDomainRequest object");
+		if ("responseType" in options) xhr.responseType = options.responseType;
+		if ("beforeSend" in options && typeof options.beforeSend === "function") options.beforeSend(xhr);
+		xhr.send(body || null);
+		return xhr;
+	}
+	function getXml(xhr) {
+		try {
+			if (xhr.responseType === "document") return xhr.responseXML;
+			var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === "parsererror";
+			if (xhr.responseType === "" && !firefoxBugTakenEffect) return xhr.responseXML;
+		} catch (e) {}
+		return null;
+	}
+	function noop() {}
+}));
+export default require_lib();
+export { require_lib };

package/dist/treeshaking/_virtual/@videojs/xhr/lib/interceptors.js.mjs

@@ -0,0 +1,94 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/@videojs+xhr@2.7.0/node_modules/@videojs/xhr/lib/interceptors.js
+var require_interceptors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+		var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+		if (it) return (it = it.call(o)).next.bind(it);
+		if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+			if (it) o = it;
+			var i = 0;
+			return function() {
+				if (i >= o.length) return { done: true };
+				return {
+					done: false,
+					value: o[i++]
+				};
+			};
+		}
+		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+		if (!o) return;
+		if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+		var n = Object.prototype.toString.call(o).slice(8, -1);
+		if (n === "Object" && o.constructor) n = o.constructor.name;
+		if (n === "Map" || n === "Set") return Array.from(o);
+		if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+		if (len == null || len > arr.length) len = arr.length;
+		for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+		return arr2;
+	}
+	module.exports = /* @__PURE__ */ function() {
+		function InterceptorsStorage() {
+			this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+			this.enabled_ = false;
+		}
+		var _proto = InterceptorsStorage.prototype;
+		_proto.getIsEnabled = function getIsEnabled() {
+			return this.enabled_;
+		};
+		_proto.enable = function enable() {
+			this.enabled_ = true;
+		};
+		_proto.disable = function disable() {
+			this.enabled_ = false;
+		};
+		_proto.reset = function reset() {
+			this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+			this.enabled_ = false;
+		};
+		_proto.addInterceptor = function addInterceptor(type, interceptor) {
+			if (!this.typeToInterceptorsMap_.has(type)) this.typeToInterceptorsMap_.set(type, /* @__PURE__ */ new Set());
+			var interceptorsSet = this.typeToInterceptorsMap_.get(type);
+			if (interceptorsSet.has(interceptor)) return false;
+			interceptorsSet.add(interceptor);
+			return true;
+		};
+		_proto.removeInterceptor = function removeInterceptor(type, interceptor) {
+			var interceptorsSet = this.typeToInterceptorsMap_.get(type);
+			if (interceptorsSet && interceptorsSet.has(interceptor)) {
+				interceptorsSet.delete(interceptor);
+				return true;
+			}
+			return false;
+		};
+		_proto.clearInterceptorsByType = function clearInterceptorsByType(type) {
+			if (!this.typeToInterceptorsMap_.get(type)) return false;
+			this.typeToInterceptorsMap_.delete(type);
+			this.typeToInterceptorsMap_.set(type, /* @__PURE__ */ new Set());
+			return true;
+		};
+		_proto.clear = function clear() {
+			if (!this.typeToInterceptorsMap_.size) return false;
+			this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+			return true;
+		};
+		_proto.getForType = function getForType(type) {
+			return this.typeToInterceptorsMap_.get(type) || /* @__PURE__ */ new Set();
+		};
+		_proto.execute = function execute(type, payload) {
+			for (var _iterator = _createForOfIteratorHelperLoose(this.getForType(type)), _step; !(_step = _iterator()).done;) {
+				var interceptor = _step.value;
+				try {
+					payload = interceptor(payload);
+				} catch (e) {}
+			}
+			return payload;
+		};
+		return InterceptorsStorage;
+	}();
+}));
+export default require_interceptors();
+export { require_interceptors };

package/dist/treeshaking/_virtual/@videojs/xhr/lib/retry.js.mjs

@@ -0,0 +1,100 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/@videojs+xhr@2.7.0/node_modules/@videojs/xhr/lib/retry.js
+var require_retry = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var RetryManager = /*#__PURE__*/ function() {
+		function RetryManager() {
+			this.maxAttempts_ = 1;
+			this.delayFactor_ = .1;
+			this.fuzzFactor_ = .1;
+			this.initialDelay_ = 1e3;
+			this.enabled_ = false;
+		}
+		var _proto = RetryManager.prototype;
+		_proto.getIsEnabled = function getIsEnabled() {
+			return this.enabled_;
+		};
+		_proto.enable = function enable() {
+			this.enabled_ = true;
+		};
+		_proto.disable = function disable() {
+			this.enabled_ = false;
+		};
+		_proto.reset = function reset() {
+			this.maxAttempts_ = 1;
+			this.delayFactor_ = .1;
+			this.fuzzFactor_ = .1;
+			this.initialDelay_ = 1e3;
+			this.enabled_ = false;
+		};
+		_proto.getMaxAttempts = function getMaxAttempts() {
+			return this.maxAttempts_;
+		};
+		_proto.setMaxAttempts = function setMaxAttempts(maxAttempts) {
+			this.maxAttempts_ = maxAttempts;
+		};
+		_proto.getDelayFactor = function getDelayFactor() {
+			return this.delayFactor_;
+		};
+		_proto.setDelayFactor = function setDelayFactor(delayFactor) {
+			this.delayFactor_ = delayFactor;
+		};
+		_proto.getFuzzFactor = function getFuzzFactor() {
+			return this.fuzzFactor_;
+		};
+		_proto.setFuzzFactor = function setFuzzFactor(fuzzFactor) {
+			this.fuzzFactor_ = fuzzFactor;
+		};
+		_proto.getInitialDelay = function getInitialDelay() {
+			return this.initialDelay_;
+		};
+		_proto.setInitialDelay = function setInitialDelay(initialDelay) {
+			this.initialDelay_ = initialDelay;
+		};
+		_proto.createRetry = function createRetry(_temp) {
+			var _ref = _temp === void 0 ? {} : _temp, maxAttempts = _ref.maxAttempts, delayFactor = _ref.delayFactor, fuzzFactor = _ref.fuzzFactor, initialDelay = _ref.initialDelay;
+			return new Retry({
+				maxAttempts: maxAttempts || this.maxAttempts_,
+				delayFactor: delayFactor || this.delayFactor_,
+				fuzzFactor: fuzzFactor || this.fuzzFactor_,
+				initialDelay: initialDelay || this.initialDelay_
+			});
+		};
+		return RetryManager;
+	}();
+	var Retry = /*#__PURE__*/ function() {
+		function Retry(options) {
+			this.maxAttempts_ = options.maxAttempts;
+			this.delayFactor_ = options.delayFactor;
+			this.fuzzFactor_ = options.fuzzFactor;
+			this.currentDelay_ = options.initialDelay;
+			this.currentAttempt_ = 1;
+		}
+		var _proto2 = Retry.prototype;
+		_proto2.moveToNextAttempt = function moveToNextAttempt() {
+			this.currentAttempt_++;
+			var delayDelta = this.currentDelay_ * this.delayFactor_;
+			this.currentDelay_ = this.currentDelay_ + delayDelta;
+		};
+		_proto2.shouldRetry = function shouldRetry() {
+			return this.currentAttempt_ < this.maxAttempts_;
+		};
+		_proto2.getCurrentDelay = function getCurrentDelay() {
+			return this.currentDelay_;
+		};
+		_proto2.getCurrentMinPossibleDelay = function getCurrentMinPossibleDelay() {
+			return (1 - this.fuzzFactor_) * this.currentDelay_;
+		};
+		_proto2.getCurrentMaxPossibleDelay = function getCurrentMaxPossibleDelay() {
+			return (1 + this.fuzzFactor_) * this.currentDelay_;
+		};
+		_proto2.getCurrentFuzzedDelay = function getCurrentFuzzedDelay() {
+			var lowValue = this.getCurrentMinPossibleDelay();
+			var highValue = this.getCurrentMaxPossibleDelay();
+			return lowValue + Math.random() * (highValue - lowValue);
+		};
+		return Retry;
+	}();
+	module.exports = RetryManager;
+}));
+export default require_retry();
+export { require_retry };

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/conventions.js.mjs

@@ -0,0 +1,177 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/conventions.js
+var require_conventions = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Ponyfill for `Array.prototype.find` which is only available in ES6 runtimes.
+	*
+	* Works with anything that has a `length` property and index access properties, including NodeList.
+	*
+	* @template {unknown} T
+	* @param {Array<T> | ({length:number, [number]: T})} list
+	* @param {function (item: T, index: number, list:Array<T> | ({length:number, [number]: T})):boolean} predicate
+	* @param {Partial<Pick<ArrayConstructor['prototype'], 'find'>>?} ac `Array.prototype` by default,
+	* 				allows injecting a custom implementation in tests
+	* @returns {T | undefined}
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
+	* @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-array.prototype.find
+	*/
+	function find(list, predicate, ac) {
+		if (ac === void 0) ac = Array.prototype;
+		if (list && typeof ac.find === "function") return ac.find.call(list, predicate);
+		for (var i = 0; i < list.length; i++) if (Object.prototype.hasOwnProperty.call(list, i)) {
+			var item = list[i];
+			if (predicate.call(void 0, item, i, list)) return item;
+		}
+	}
+	/**
+	* "Shallow freezes" an object to render it immutable.
+	* Uses `Object.freeze` if available,
+	* otherwise the immutability is only in the type.
+	*
+	* Is used to create "enum like" objects.
+	*
+	* @template T
+	* @param {T} object the object to freeze
+	* @param {Pick<ObjectConstructor, 'freeze'> = Object} oc `Object` by default,
+	* 				allows to inject custom object constructor for tests
+	* @returns {Readonly<T>}
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+	*/
+	function freeze(object, oc) {
+		if (oc === void 0) oc = Object;
+		return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
+	}
+	/**
+	* Since we can not rely on `Object.assign` we provide a simplified version
+	* that is sufficient for our needs.
+	*
+	* @param {Object} target
+	* @param {Object | null | undefined} source
+	*
+	* @returns {Object} target
+	* @throws TypeError if target is not an object
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+	* @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign
+	*/
+	function assign(target, source) {
+		if (target === null || typeof target !== "object") throw new TypeError("target is not an object");
+		for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		return target;
+	}
+	/**
+	* All mime types that are allowed as input to `DOMParser.parseFromString`
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN
+	* @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec
+	* @see DOMParser.prototype.parseFromString
+	*/
+	var MIME_TYPE = freeze({
+		/**
+		* `text/html`, the only mime type that triggers treating an XML document as HTML.
+		*
+		* @see DOMParser.SupportedType.isHTML
+		* @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+		* @see https://en.wikipedia.org/wiki/HTML Wikipedia
+		* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+		* @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+		*/
+		HTML: "text/html",
+		/**
+		* Helper method to check a mime type if it indicates an HTML document
+		*
+		* @param {string} [value]
+		* @returns {boolean}
+		*
+		* @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+		* @see https://en.wikipedia.org/wiki/HTML Wikipedia
+		* @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+		* @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+		isHTML: function(value) {
+			return value === MIME_TYPE.HTML;
+		},
+		/**
+		* `application/xml`, the standard mime type for XML documents.
+		*
+		* @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+		* @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+		* @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+		*/
+		XML_APPLICATION: "application/xml",
+		/**
+		* `text/html`, an alias for `application/xml`.
+		*
+		* @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+		* @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+		* @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+		*/
+		XML_TEXT: "text/xml",
+		/**
+		* `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+		* but is parsed as an XML document.
+		*
+		* @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+		* @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+		* @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+		*/
+		XML_XHTML_APPLICATION: "application/xhtml+xml",
+		/**
+		* `image/svg+xml`,
+		*
+		* @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+		* @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+		* @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+		*/
+		XML_SVG_IMAGE: "image/svg+xml"
+	});
+	/**
+	* Namespaces that are used in this code base.
+	*
+	* @see http://www.w3.org/TR/REC-xml-names
+	*/
+	var NAMESPACE = freeze({
+		/**
+		* The XHTML namespace.
+		*
+		* @see http://www.w3.org/1999/xhtml
+		*/
+		HTML: "http://www.w3.org/1999/xhtml",
+		/**
+		* Checks if `uri` equals `NAMESPACE.HTML`.
+		*
+		* @param {string} [uri]
+		*
+		* @see NAMESPACE.HTML
+		*/
+		isHTML: function(uri) {
+			return uri === NAMESPACE.HTML;
+		},
+		/**
+		* The SVG namespace.
+		*
+		* @see http://www.w3.org/2000/svg
+		*/
+		SVG: "http://www.w3.org/2000/svg",
+		/**
+		* The `xml:` namespace.
+		*
+		* @see http://www.w3.org/XML/1998/namespace
+		*/
+		XML: "http://www.w3.org/XML/1998/namespace",
+		/**
+		* The `xmlns:` namespace
+		*
+		* @see https://www.w3.org/2000/xmlns/
+		*/
+		XMLNS: "http://www.w3.org/2000/xmlns/"
+	});
+	exports.assign = assign;
+	exports.find = find;
+	exports.freeze = freeze;
+	exports.MIME_TYPE = MIME_TYPE;
+	exports.NAMESPACE = NAMESPACE;
+}));
+export default require_conventions();
+export { require_conventions };