const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.js');
const require_assertString$1 = require('./util/assertString.js');
const require_merge$1 = require('./util/merge.js');
const require_isFQDN$1 = require('./isFQDN.js');
const require_isIP$1 = require('./isIP.js');

//#region ../../node_modules/.pnpm/validator@13.12.0/node_modules/validator/lib/isURL.js
var require_isURL = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/validator@13.12.0/node_modules/validator/lib/isURL.js": ((exports, module) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = isURL;
	var _assertString = _interopRequireDefault(require_assertString$1.require_assertString());
	var _isFQDN = _interopRequireDefault(require_isFQDN$1.require_isFQDN());
	var _isIP = _interopRequireDefault(require_isIP$1.require_isIP());
	var _merge = _interopRequireDefault(require_merge$1.require_merge());
	function _interopRequireDefault(obj) {
		return obj && obj.__esModule ? obj : { default: obj };
	}
	function _slicedToArray(arr, i) {
		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
	}
	function _nonIterableRest() {
		throw new TypeError("Invalid attempt to destructure 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;
	}
	function _iterableToArrayLimit(r, l) {
		var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
		if (null != t) {
			var e, n, i, u, a = [], f = !0, o = !1;
			try {
				if (i = (t = t.call(r)).next, 0 === l) {
					if (Object(t) !== t) return;
					f = !1;
				} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
			} catch (r$1) {
				o = !0, n = r$1;
			} finally {
				try {
					if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
				} finally {
					if (o) throw n;
				}
			}
			return a;
		}
	}
	function _arrayWithHoles(arr) {
		if (Array.isArray(arr)) return arr;
	}
	var default_url_options = {
		protocols: [
			"http",
			"https",
			"ftp"
		],
		require_tld: true,
		require_protocol: false,
		require_host: true,
		require_port: false,
		require_valid_protocol: true,
		allow_underscores: false,
		allow_trailing_dot: false,
		allow_protocol_relative_urls: false,
		allow_fragments: true,
		allow_query_components: true,
		validate_length: true
	};
	var wrapped_ipv6 = /^\[([^\]]+)\](?::([0-9]+))?$/;
	function isRegExp(obj) {
		return Object.prototype.toString.call(obj) === "[object RegExp]";
	}
	function checkHost(host, matches) {
		for (var i = 0; i < matches.length; i++) {
			var match = matches[i];
			if (host === match || isRegExp(match) && match.test(host)) return true;
		}
		return false;
	}
	function isURL(url, options) {
		(0, _assertString.default)(url);
		if (!url || /[\s<>]/.test(url)) return false;
		if (url.indexOf("mailto:") === 0) return false;
		options = (0, _merge.default)(options, default_url_options);
		if (options.validate_length && url.length >= 2083) return false;
		if (!options.allow_fragments && url.includes("#")) return false;
		if (!options.allow_query_components && (url.includes("?") || url.includes("&"))) return false;
		var protocol, auth, host, hostname, port, port_str, split = url.split("#"), ipv6;
		url = split.shift();
		split = url.split("?");
		url = split.shift();
		split = url.split("://");
		if (split.length > 1) {
			protocol = split.shift().toLowerCase();
			if (options.require_valid_protocol && options.protocols.indexOf(protocol) === -1) return false;
		} else if (options.require_protocol) return false;
		else if (url.slice(0, 2) === "//") {
			if (!options.allow_protocol_relative_urls) return false;
			split[0] = url.slice(2);
		}
		url = split.join("://");
		if (url === "") return false;
		split = url.split("/");
		url = split.shift();
		if (url === "" && !options.require_host) return true;
		split = url.split("@");
		if (split.length > 1) {
			if (options.disallow_auth) return false;
			if (split[0] === "") return false;
			auth = split.shift();
			if (auth.indexOf(":") >= 0 && auth.split(":").length > 2) return false;
			var _auth$split2 = _slicedToArray(auth.split(":"), 2), user = _auth$split2[0], password = _auth$split2[1];
			if (user === "" && password === "") return false;
		}
		hostname = split.join("@");
		port_str = null;
		ipv6 = null;
		var ipv6_match = hostname.match(wrapped_ipv6);
		if (ipv6_match) {
			host = "";
			ipv6 = ipv6_match[1];
			port_str = ipv6_match[2] || null;
		} else {
			split = hostname.split(":");
			host = split.shift();
			if (split.length) port_str = split.join(":");
		}
		if (port_str !== null && port_str.length > 0) {
			port = parseInt(port_str, 10);
			if (!/^[0-9]+$/.test(port_str) || port <= 0 || port > 65535) return false;
		} else if (options.require_port) return false;
		if (options.host_whitelist) return checkHost(host, options.host_whitelist);
		if (host === "" && !options.require_host) return true;
		if (!(0, _isIP.default)(host) && !(0, _isFQDN.default)(host, options) && (!ipv6 || !(0, _isIP.default)(ipv6, 6))) return false;
		host = host || ipv6;
		if (options.host_blacklist && checkHost(host, options.host_blacklist)) return false;
		return true;
	}
	module.exports = exports.default;
	module.exports.default = exports.default;
}) });

//#endregion
Object.defineProperty(exports, 'default', {
  enumerable: true,
  get: function () {
    return require_isURL();
  }
});