*
 * @return   {url:URLObject}
 *           An object of url details
 */
export const parseUrl = function(url) {
  const props = ['protocol', 'hostname', 'port', 'pathname', 'search', 'hash', 'host'];

  // add the url to an anchor and let the browser parse the URL
  let a = document.createElement('a');

  a.href = url;

  // IE8 (and 9?) Fix
  // ie8 doesn't parse the URL correctly until the anchor is actually

Package.onUse((api) => {
  api.use('url');
});
```

After installing the package you can then import the `URL` and `URLSearchParams` from the package and use it as described at MDN and Node documentations.

### URL
```js
import { URL } from 'meteor/url';

const url = new URL('https://www.meteor.com');
```

You can then use `URL` for example in a [fetch](/packages/fetch) call:
```js
import { URL } from 'meteor/url';

  end

  sig { returns(T.nilable(String)) }
  def raw_interpolated_url
    return @raw_interpolated_url if defined?(@raw_interpolated_url)

    @raw_interpolated_url =
      Pathname(@caller_location.path)
      .each_line.drop(@caller_location.lineno - 1)
      .first&.then { |line| line[/url\s+"([^"]+)"/, 1] }
  end
  private :raw_interpolated_url

  sig { params(ignore_major_version: T::Boolean).returns(T::Boolean) }

    return url_is_from_any_domain(
        url, [spider.name] + list(getattr(spider, "allowed_domains", []))
    )


def url_has_any_extension(url, extensions):
    """Return True if the url ends with one of the extensions provided"""
    lowercase_path = parse_url(url).path.lower()
    return any(lowercase_path.endswith(ext) for ext in extensions)


def parse_url(url, encoding=None):

		Scheme: parts[0],
		Path:   parts[1],
	}, nil
}

// String implements the stringer interface.
func (u URL) String() string {
	if u.Scheme != "" {
		return fmt.Sprintf("%s://%s", u.Scheme, u.Path)
	}
	return u.Path
}

// TerminalString implements the log.TerminalStringer interface.
func (u URL) TerminalString() string {
	url := u.String()
	if len(url) > 32 {
		return url[:31] + ".."
	}
	return url
}

package github

import (
	"net/url"
	"strings"
)

type URL struct {
	url.URL
	*Project
}

func (url URL) ProjectPath() (projectPath string) {
	split := strings.SplitN(url.Path, "/", 4)
	if len(split) > 3 {
		projectPath = split[3]
	}

	return
}

func ParseURL(rawurl string) (*URL, error) {
	url, err := url.Parse(rawurl)
	if err != nil {
		return nil, err
	}

// explicitly indicate that such a URL is expected and safe by encapsulating it
// in a template.URL value.
func urlFilter(args ...any) string {
	s, t := stringify(args...)
	if t == contentTypeURL {
		return s
	}
	if !isSafeURL(s) {
		return "#" + filterFailsafe
	}
	return s
}

// isSafeURL is true if s is a relative URL or if URL has a protocol in
// (http, https, mailto).

import { URL } from 'url';

export const constructUrl = (storybookUrl: string, id: string) => {
  const storyUrl = `/iframe.html?id=${id}`;
  const { protocol, host, pathname, search } = new URL(storybookUrl);
  const pname = pathname.replace(/\/$/, ''); // removes trailing /
  const query = search.replace('?', '&'); // convert leading ? to &
  return `${protocol}//${host}${pname}${storyUrl}${query}`;

 * @method static void flushMacros()
 *
 * @see \Illuminate\Routing\UrlGenerator
 */
class URL extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'url';
    }

    #
    # Returns the unsanitized String URL
    def generated_url
      @generated_url ||= generate_url(@template)
    end

    # Internal: Generate the URL by replacing all placeholders with their
    # respective values in the given template
    #
    # Returns the unsanitized String URL
    def generate_url(template)
      if @placeholders.is_a? Drops::UrlDrop
        generate_url_from_drop(template)
      else