/******/ 		};

/************************************************************************/

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

/**

 * Determines whether the given string looks like a URL.

 *

 * @param {string} url The string to scrutinise.

 *

 * @example

 * ```js

 * const isURL = isURL( 'https://wordpress.org' ); // true

 * ```

 *

 * @see https://url.spec.whatwg.org/

 * @see https://url.spec.whatwg.org/#valid-url-string

 *

 * @return {boolean} Whether or not it looks like a URL.

 */

function isURL(url) {

  // A URL can be considered value if the `URL` constructor is able to parse

  // it. The constructor throws an error for an invalid URL.

  try {

    new URL(url);

    return true;

  } catch {

    return false;

  }

}

const EMAIL_REGEXP = /^(mailto:)?[a-z0-9._%+-]+@[a-z0-9][a-z0-9.-]*\.[a-z]{2,63}$/i;

/**

 * Determines whether the given string looks like an email.

 *

 * @param {string} email The string to scrutinise.

 *

 * @example

 * ```js

 * const isEmail = isEmail( 'hello@wordpress.org' ); // true

 * ```

 *

 * @return {boolean} Whether or not it looks like an email.

 */

function isEmail(email) {

  return EMAIL_REGEXP.test(email);

}

/**

 * Returns the protocol part of the URL.

 *

 * @param {string} url The full URL.

 *

 * @example

 * ```js

 * const protocol1 = getProtocol( 'tel:012345678' ); // 'tel:'

 * const protocol2 = getProtocol( 'https://wordpress.org' ); // 'https:'

 * ```

 *

 * @return {string|void} The protocol part of the URL.

 */

function getProtocol(url) {

  const matches = /^([^\s:]+:)/.exec(url);

  if (matches) {

    return matches[1];

  }

}

/**

 * Tests if a url protocol is valid.

 *

 * @param {string} protocol The url protocol.

 *

 * @example

 * ```js

 * const isValid = isValidProtocol( 'https:' ); // true

 * const isNotValid = isValidProtocol( 'https :' ); // false

 * ```

 *

 * @return {boolean} True if the argument is a valid protocol (e.g. http:, tel:).

 */

function isValidProtocol(protocol) {

  if (!protocol) {

    return false;

  }

  return /^[a-z\-.\+]+[0-9]*:$/i.test(protocol);

}

/**

 * Returns the authority part of the URL.

 *

 * @param {string} url The full URL.

 *

 * @example

 * ```js

 * const authority1 = getAuthority( 'https://wordpress.org/help/' ); // 'wordpress.org'

 * const authority2 = getAuthority( 'https://localhost:8080/test/' ); // 'localhost:8080'

 * ```

 *

 * @return {string|void} The authority part of the URL.

 */

function getAuthority(url) {

  const matches = /^[^\/\s:]+:(?:\/\/)?\/?([^\/\s#?]+)[\/#?]{0,1}\S*$/.exec(url);

  if (matches) {

    return matches[1];

  }

}

/**

 * Checks for invalid characters within the provided authority.

 *

 * @param {string} authority A string containing the URL authority.

 *

 * @example

 * ```js

 * const isValid = isValidAuthority( 'wordpress.org' ); // true

 * const isNotValid = isValidAuthority( 'wordpress#org' ); // false

 * ```

 *

 * @return {boolean} True if the argument contains a valid authority.

 */

function isValidAuthority(authority) {

  if (!authority) {

    return false;

  }

  return /^[^\s#?]+$/.test(authority);

}

/**

 * Returns the path part of the URL.

 *

 * @param {string} url The full URL.

 *

 * @example

 * ```js

 * const path1 = getPath( 'http://localhost:8080/this/is/a/test?query=true' ); // 'this/is/a/test'

 * const path2 = getPath( 'https://wordpress.org/help/faq/' ); // 'help/faq'

 * ```

 *

 * @return {string|void} The path part of the URL.

 */

function getPath(url) {

  const matches = /^[^\/\s:]+:(?:\/\/)?[^\/\s#?]+[\/]([^\s#?]+)[#?]{0,1}\S*$/.exec(url);

  if (matches) {

    return matches[1];

  }

}

/**

 * Checks for invalid characters within the provided path.

 *

 * @param {string} path The URL path.

 *

 * @example

 * ```js

 * const isValid = isValidPath( 'test/path/' ); // true

 * const isNotValid = isValidPath( '/invalid?test/path/' ); // false

 * ```

 *

 * @return {boolean} True if the argument contains a valid path

 */

function isValidPath(path) {

  if (!path) {

    return false;

  }

  return /^[^\s#?]+$/.test(path);

}

/**

 * Returns the query string part of the URL.

 *

 * @param {string} url The full URL.

 *

 * @example

 * ```js

 * const queryString = getQueryString( 'http://localhost:8080/this/is/a/test?query=true#fragment' ); // 'query=true'

 * ```

 *

 * @return {string|void} The query string part of the URL.

 */

function getQueryString(url) {

  let query;

  try {

    query = new URL(url, 'http://example.com').search.substring(1);

  } catch (error) {}

  if (query) {

    return query;

  }

}

/**

 * Generates URL-encoded query string using input query data.

 *

 * It is intended to behave equivalent as PHP's `http_build_query`, configured

 * with encoding type PHP_QUERY_RFC3986 (spaces as `%20`).

 *

 * @example

 * ```js

 * const queryString = buildQueryString( {

 *    simple: 'is ok',

 *    arrays: [ 'are', 'fine', 'too' ],

 *    objects: {

 *       evenNested: {

 *          ok: 'yes',

 *       },

 *    },

 * } );

 * // "simple=is%20ok&arrays%5B0%5D=are&arrays%5B1%5D=fine&arrays%5B2%5D=too&objects%5BevenNested%5D%5Bok%5D=yes"

 * ```

 *

 * @param {Record<string,*>} data Data to encode.

 *

 * @return {string} Query string.

 */

function buildQueryString(data) {

  let string = '';

  const stack = Object.entries(data);

  let pair;

  while (pair = stack.shift()) {

    let [key, value] = pair; // Support building deeply nested data, from array or object values.

    const hasNestedData = Array.isArray(value) || value && value.constructor === Object;

    if (hasNestedData) {

      // Push array or object values onto the stack as composed of their

      // original key and nested index or key, retaining order by a

      // combination of Array#reverse and Array#unshift onto the stack.

      const valuePairs = Object.entries(value).reverse();

      for (const [member, memberValue] of valuePairs) {

        stack.unshift([`${key}[${member}]`, memberValue]);

      }

    } else if (value !== undefined) {

      // Null is treated as special case, equivalent to empty string.

      if (value === null) {

        value = '';

      }

      string += '&' + [key, value].map(encodeURIComponent).join('=');

    }

  } // Loop will concatenate with leading `&`, but it's only expected for all

  // but the first query parameter. This strips the leading `&`, while still

  // accounting for the case that the string may in-fact be empty.

  return string.substr(1);

}

/**

 * Checks for invalid characters within the provided query string.

 *

 * @param {string} queryString The query string.

 *

 * @example

 * ```js

 * const isValid = isValidQueryString( 'query=true&another=false' ); // true

 * const isNotValid = isValidQueryString( 'query=true?another=false' ); // false

 * ```

 *

 * @return {boolean} True if the argument contains a valid query string.

 */

function isValidQueryString(queryString) {

  if (!queryString) {

    return false;

  }

  return /^[^\s#?\/]+$/.test(queryString);

}

/**

 * Internal dependencies

 */

/**

 * Returns the path part and query string part of the URL.

 *

 * @param {string} url The full URL.

 *

 * @example

 * ```js

 * const pathAndQueryString1 = getPathAndQueryString( 'http://localhost:8080/this/is/a/test?query=true' ); // '/this/is/a/test?query=true'

 * const pathAndQueryString2 = getPathAndQueryString( 'https://wordpress.org/help/faq/' ); // '/help/faq'

 * ```

 *

 * @return {string} The path part and query string part of the URL.

 */

function getPathAndQueryString(url) {

  const path = getPath(url);

  const queryString = getQueryString(url);

  let value = '/';

  if (path) value += path;

  if (queryString) value += `?${queryString}`;

  return value;

}

/**

 * Returns the fragment part of the URL.

 *

 * @param {string} url The full URL

 *