@opendesign-plus/components 0.0.1-rc.103 → 0.0.1-rc.104

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/nal-helpers.js.mjs

@@ -1,78 +1,82 @@
-import { toUint8, bytesMatch } from "./byte-helpers.js.mjs";
-var NAL_TYPE_ONE = toUint8([0, 0, 0, 1]);
-var NAL_TYPE_TWO = toUint8([0, 0, 1]);
-var EMULATION_PREVENTION = toUint8([0, 0, 3]);
-var discardEmulationPreventionBytes = function discardEmulationPreventionBytes2(bytes) {
-  var positions = [];
-  var i = 1;
-  while (i < bytes.length - 2) {
-    if (bytesMatch(bytes.subarray(i, i + 3), EMULATION_PREVENTION)) {
-      positions.push(i + 2);
-      i++;
-    }
-    i++;
-  }
-  if (positions.length === 0) {
-    return bytes;
-  }
-  var newLength = bytes.length - positions.length;
-  var newData = new Uint8Array(newLength);
-  var sourceIndex = 0;
-  for (i = 0; i < newLength; sourceIndex++, i++) {
-    if (sourceIndex === positions[0]) {
-      sourceIndex++;
-      positions.shift();
-    }
-    newData[i] = bytes[sourceIndex];
-  }
-  return newData;
+import { bytesMatch, toUint8 } from "./byte-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/nal-helpers.js
+var NAL_TYPE_ONE = toUint8([
+	0,
+	0,
+	0,
+	1
+]);
+var NAL_TYPE_TWO = toUint8([
+	0,
+	0,
+	1
+]);
+var EMULATION_PREVENTION = toUint8([
+	0,
+	0,
+	3
+]);
+/**
+* Expunge any "Emulation Prevention" bytes from a "Raw Byte
+* Sequence Payload"
+*
+* @param data {Uint8Array} the bytes of a RBSP from a NAL
+* unit
+* @return {Uint8Array} the RBSP without any Emulation
+* Prevention Bytes
+*/
+var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(bytes) {
+	var positions = [];
+	var i = 1;
+	while (i < bytes.length - 2) {
+		if (bytesMatch(bytes.subarray(i, i + 3), EMULATION_PREVENTION)) {
+			positions.push(i + 2);
+			i++;
+		}
+		i++;
+	}
+	if (positions.length === 0) return bytes;
+	var newLength = bytes.length - positions.length;
+	var newData = new Uint8Array(newLength);
+	var sourceIndex = 0;
+	for (i = 0; i < newLength; sourceIndex++, i++) {
+		if (sourceIndex === positions[0]) {
+			sourceIndex++;
+			positions.shift();
+		}
+		newData[i] = bytes[sourceIndex];
+	}
+	return newData;
 };
-var findNal = function findNal2(bytes, dataType, types, nalLimit) {
-  bytes = toUint8(bytes);
-  types = [].concat(types);
-  var i = 0;
-  var nalStart;
-  var nalsFound = 0;
-  while (i < bytes.length && (nalsFound < nalLimit || nalStart)) {
-    var nalOffset = void 0;
-    if (bytesMatch(bytes.subarray(i), NAL_TYPE_ONE)) {
-      nalOffset = 4;
-    } else if (bytesMatch(bytes.subarray(i), NAL_TYPE_TWO)) {
-      nalOffset = 3;
-    }
-    if (!nalOffset) {
-      i++;
-      continue;
-    }
-    nalsFound++;
-    if (nalStart) {
-      return discardEmulationPreventionBytes(bytes.subarray(nalStart, i));
-    }
-    var nalType = void 0;
-    if (dataType === "h264") {
-      nalType = bytes[i + nalOffset] & 31;
-    } else if (dataType === "h265") {
-      nalType = bytes[i + nalOffset] >> 1 & 63;
-    }
-    if (types.indexOf(nalType) !== -1) {
-      nalStart = i + nalOffset;
-    }
-    i += nalOffset + (dataType === "h264" ? 1 : 2);
-  }
-  return bytes.subarray(0, 0);
+var findNal = function findNal(bytes, dataType, types, nalLimit) {
+	if (nalLimit === void 0) nalLimit = Infinity;
+	bytes = toUint8(bytes);
+	types = [].concat(types);
+	var i = 0;
+	var nalStart;
+	var nalsFound = 0;
+	while (i < bytes.length && (nalsFound < nalLimit || nalStart)) {
+		var nalOffset = void 0;
+		if (bytesMatch(bytes.subarray(i), NAL_TYPE_ONE)) nalOffset = 4;
+		else if (bytesMatch(bytes.subarray(i), NAL_TYPE_TWO)) nalOffset = 3;
+		if (!nalOffset) {
+			i++;
+			continue;
+		}
+		nalsFound++;
+		if (nalStart) return discardEmulationPreventionBytes(bytes.subarray(nalStart, i));
+		var nalType = void 0;
+		if (dataType === "h264") nalType = bytes[i + nalOffset] & 31;
+		else if (dataType === "h265") nalType = bytes[i + nalOffset] >> 1 & 63;
+		if (types.indexOf(nalType) !== -1) nalStart = i + nalOffset;
+		i += nalOffset + (dataType === "h264" ? 1 : 2);
+	}
+	return bytes.subarray(0, 0);
 };
-var findH264Nal = function findH264Nal2(bytes, type, nalLimit) {
-  return findNal(bytes, "h264", type, nalLimit);
+var findH264Nal = function findH264Nal(bytes, type, nalLimit) {
+	return findNal(bytes, "h264", type, nalLimit);
 };
-var findH265Nal = function findH265Nal2(bytes, type, nalLimit) {
-  return findNal(bytes, "h265", type, nalLimit);
-};
-export {
-  EMULATION_PREVENTION,
-  NAL_TYPE_ONE,
-  NAL_TYPE_TWO,
-  discardEmulationPreventionBytes,
-  findH264Nal,
-  findH265Nal,
-  findNal
+var findH265Nal = function findH265Nal(bytes, type, nalLimit) {
+	return findNal(bytes, "h265", type, nalLimit);
 };
+export { EMULATION_PREVENTION, NAL_TYPE_ONE, NAL_TYPE_TWO, discardEmulationPreventionBytes, findH264Nal, findH265Nal, findNal };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/opus-helpers.js.mjs

@@ -0,0 +1,10 @@
+new Uint8Array([
+	79,
+	112,
+	117,
+	115,
+	72,
+	101,
+	97,
+	100
+]);

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/resolve-url.js.mjs

@@ -1,23 +1,17 @@
-import window$1 from "../../../global/window.js.mjs";
+import { __toESM } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/resolve-url.js
+var import_window = /* @__PURE__ */ __toESM(require_window());
 var DEFAULT_LOCATION = "https://example.com";
-var resolveUrl = function resolveUrl2(baseUrl, relativeUrl) {
-  if (/^[a-z]+:/i.test(relativeUrl)) {
-    return relativeUrl;
-  }
-  if (/^data:/.test(baseUrl)) {
-    baseUrl = window$1.location && window$1.location.href || "";
-  }
-  var protocolLess = /^\/\//.test(baseUrl);
-  var removeLocation = !window$1.location && !/\/\//i.test(baseUrl);
-  baseUrl = new window$1.URL(baseUrl, window$1.location || DEFAULT_LOCATION);
-  var newUrl = new URL(relativeUrl, baseUrl);
-  if (removeLocation) {
-    return newUrl.href.slice(DEFAULT_LOCATION.length);
-  } else if (protocolLess) {
-    return newUrl.href.slice(newUrl.protocol.length);
-  }
-  return newUrl.href;
-};
-export {
-  resolveUrl as default
+var resolveUrl = function resolveUrl(baseUrl, relativeUrl) {
+	if (/^[a-z]+:/i.test(relativeUrl)) return relativeUrl;
+	if (/^data:/.test(baseUrl)) baseUrl = import_window.default.location && import_window.default.location.href || "";
+	var protocolLess = /^\/\//.test(baseUrl);
+	var removeLocation = !import_window.default.location && !/\/\//i.test(baseUrl);
+	baseUrl = new import_window.default.URL(baseUrl, import_window.default.location || DEFAULT_LOCATION);
+	var newUrl = new URL(relativeUrl, baseUrl);
+	if (removeLocation) return newUrl.href.slice(DEFAULT_LOCATION.length);
+	else if (protocolLess) return newUrl.href.slice(newUrl.protocol.length);
+	return newUrl.href;
 };
+export { resolveUrl as default };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/stream.js.mjs

@@ -1,51 +1,55 @@
-var Stream = /* @__PURE__ */ (function() {
-  function Stream2() {
-    this.listeners = {};
-  }
-  var _proto = Stream2.prototype;
-  _proto.on = function on(type, listener) {
-    if (!this.listeners[type]) {
-      this.listeners[type] = [];
-    }
-    this.listeners[type].push(listener);
-  };
-  _proto.off = function off(type, listener) {
-    if (!this.listeners[type]) {
-      return false;
-    }
-    var index = this.listeners[type].indexOf(listener);
-    this.listeners[type] = this.listeners[type].slice(0);
-    this.listeners[type].splice(index, 1);
-    return index > -1;
-  };
-  _proto.trigger = function trigger(type) {
-    var callbacks = this.listeners[type];
-    if (!callbacks) {
-      return;
-    }
-    if (arguments.length === 2) {
-      var length = callbacks.length;
-      for (var i = 0; i < length; ++i) {
-        callbacks[i].call(this, arguments[1]);
-      }
-    } else {
-      var args = Array.prototype.slice.call(arguments, 1);
-      var _length = callbacks.length;
-      for (var _i = 0; _i < _length; ++_i) {
-        callbacks[_i].apply(this, args);
-      }
-    }
-  };
-  _proto.dispose = function dispose() {
-    this.listeners = {};
-  };
-  _proto.pipe = function pipe(destination) {
-    this.on("data", function(data) {
-      destination.push(data);
-    });
-  };
-  return Stream2;
-})();
-export {
-  Stream as default
-};
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/stream.js
+/**
+* @file stream.js
+*/
+/**
+* A lightweight readable stream implemention that handles event dispatching.
+*
+* @class Stream
+*/
+var Stream = /*#__PURE__*/ function() {
+	function Stream() {
+		this.listeners = {};
+	}
+	/**
+	* Add a listener for a specified event type.
+	*
+	* @param {string} type the event name
+	* @param {Function} listener the callback to be invoked when an event of
+	* the specified type occurs
+	*/
+	var _proto = Stream.prototype;
+	_proto.on = function on(type, listener) {
+		if (!this.listeners[type]) this.listeners[type] = [];
+		this.listeners[type].push(listener);
+	};
+	_proto.off = function off(type, listener) {
+		if (!this.listeners[type]) return false;
+		var index = this.listeners[type].indexOf(listener);
+		this.listeners[type] = this.listeners[type].slice(0);
+		this.listeners[type].splice(index, 1);
+		return index > -1;
+	};
+	_proto.trigger = function trigger(type) {
+		var callbacks = this.listeners[type];
+		if (!callbacks) return;
+		if (arguments.length === 2) {
+			var length = callbacks.length;
+			for (var i = 0; i < length; ++i) callbacks[i].call(this, arguments[1]);
+		} else {
+			var args = Array.prototype.slice.call(arguments, 1);
+			var _length = callbacks.length;
+			for (var _i = 0; _i < _length; ++_i) callbacks[_i].apply(this, args);
+		}
+	};
+	_proto.dispose = function dispose() {
+		this.listeners = {};
+	};
+	_proto.pipe = function pipe(destination) {
+		this.on("data", function(data) {
+			destination.push(data);
+		});
+	};
+	return Stream;
+}();
+export { Stream as default };

package/dist/treeshaking/_virtual/@videojs/xhr/lib/http-handler.js.mjs

@@ -1,55 +1,40 @@
-import { __require as requireWindow } from "../../../global/window.js2.mjs";
-var httpHandler;
-var hasRequiredHttpHandler;
-function requireHttpHandler() {
-  if (hasRequiredHttpHandler) return httpHandler;
-  hasRequiredHttpHandler = 1;
-  var window = requireWindow();
-  var httpResponseHandler = function httpResponseHandler2(callback, decodeResponseBody) {
-    if (decodeResponseBody === void 0) {
-      decodeResponseBody = false;
-    }
-    return function(err, response, responseBody) {
-      if (err) {
-        callback(err);
-        return;
-      }
-      if (response.statusCode >= 400 && response.statusCode <= 599) {
-        var cause = responseBody;
-        if (decodeResponseBody) {
-          if (window.TextDecoder) {
-            var charset = getCharset(response.headers && response.headers["content-type"]);
-            try {
-              cause = new TextDecoder(charset).decode(responseBody);
-            } catch (e) {
-            }
-          } else {
-            cause = String.fromCharCode.apply(null, new Uint8Array(responseBody));
-          }
-        }
-        callback({
-          cause
-        });
-        return;
-      }
-      callback(null, responseBody);
-    };
-  };
-  function getCharset(contentTypeHeader) {
-    if (contentTypeHeader === void 0) {
-      contentTypeHeader = "";
-    }
-    return contentTypeHeader.toLowerCase().split(";").reduce(function(charset, contentType) {
-      var _contentType$split = contentType.split("="), type = _contentType$split[0], value = _contentType$split[1];
-      if (type.trim() === "charset") {
-        return value.trim();
-      }
-      return charset;
-    }, "utf-8");
-  }
-  httpHandler = httpResponseHandler;
-  return httpHandler;
-}
-export {
-  requireHttpHandler as __require
-};
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+xhr@2.7.0/node_modules/@videojs/xhr/lib/http-handler.js
+var require_http_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var window = require_window();
+	var httpResponseHandler = function httpResponseHandler(callback, decodeResponseBody) {
+		if (decodeResponseBody === void 0) decodeResponseBody = false;
+		return function(err, response, responseBody) {
+			if (err) {
+				callback(err);
+				return;
+			}
+			if (response.statusCode >= 400 && response.statusCode <= 599) {
+				var cause = responseBody;
+				if (decodeResponseBody) {
+					if (window.TextDecoder) {
+						var charset = getCharset(response.headers && response.headers["content-type"]);
+						try {
+							cause = new TextDecoder(charset).decode(responseBody);
+						} catch (e) {}
+					} else cause = String.fromCharCode.apply(null, new Uint8Array(responseBody));
+				}
+				callback({ cause });
+				return;
+			}
+			callback(null, responseBody);
+		};
+	};
+	function getCharset(contentTypeHeader) {
+		if (contentTypeHeader === void 0) contentTypeHeader = "";
+		return contentTypeHeader.toLowerCase().split(";").reduce(function(charset, contentType) {
+			var _contentType$split = contentType.split("="), type = _contentType$split[0], value = _contentType$split[1];
+			if (type.trim() === "charset") return value.trim();
+			return charset;
+		}, "utf-8");
+	}
+	module.exports = httpResponseHandler;
+}));
+export default require_http_handler();
+export { require_http_handler };

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

@@ -1,7 +1,242 @@
-import { getDefaultExportFromCjs } from "../../../_commonjsHelpers.mjs";
-import { __require as requireLib } from "./index.js2.mjs";
-var libExports = requireLib();
-const XHR = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-export {
-  XHR as default
-};
+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 };