Package Exports

parse-domain

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (parse-domain) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

parse-domain

Splits a URL into sub-domain, domain and the effective top-level domain.

Since domains are handled differently across different countries and organizations, splitting a URL into sub-domain, domain and top-level-domain parts is not a simple regexp. parse-domain uses a large list of effective tld names from publicsuffix.org to recognize different parts of the domain.

Please also read the note on effective top-level domains.

Installation

npm install --save parse-domain

Usage

// long subdomains can be handled
expect(parseDomain("some.subdomain.example.co.uk")).to.eql({
    subdomain: "some.subdomain",
    domain: "example",
    tld: "co.uk"
});

// usernames, passwords and ports are disregarded
expect(parseDomain("https://user:password@example.co.uk:8080/some/path?and&query#hash")).to.eql({
    subdomain: "",
    domain: "example",
    tld: "co.uk"
});

// non-canonical top-level domains are ignored
expect(parseDomain("unknown.tld.kk")).to.equal(null);

// invalid urls are also ignored
expect(parseDomain("invalid url")).to.equal(null);
expect(parseDomain({})).to.equal(null);

Introducing custom tlds

// custom top-level domains can optionally be specified
expect(parseDomain("mymachine.local",{ customTlds: ["local"] })).to.eql({
    subdomain: "",
    domain: "mymachine",
    tld: "local"
});

// custom regexps can optionally be specified (instead of customTlds)
expect(parseDomain("localhost",{ customTlds:/localhost|\.local/ })).to.eql({
    subdomain: "",
    domain: "",
    tld: "localhost"
});

It can sometimes be helpful to apply the customTlds argument using a helper function

function parseLocalDomains(url) {
    var options = {
        customTlds: /localhost|\.local/
    };
    return parseDomain(url, options);
}

expect(parseLocalDomains("localhost")).to.eql({
    subdomain: "",
    domain: "",
    tld: "localhost"
});
expect(parseLocalDomains("mymachine.local")).to.eql({
    subdomain: "",
    domain: "mymachine",
    tld: "local"
});

API

`parseDomain(url: String, options: ParseOptions): ParsedDomain|null`

Returns null if url has an unknown tld or if it's not a valid url.

`ParseOptions`

{
    customTlds: RegExp|String[]
}

`ParsedDomain`

{
    tld: String,
    domain: String,
    subdomain: String
}

Note on effective top-level domains

Technically, the top-level domain is always the part after the last dot. That's why publicsuffix.org is a list of effective top-level domains: It lists all top-level domains where users are allowed to host any content. That's why foo.blogspot.com will be split into

{
    tld: "blogspot.com",
    domain: "foo",
    subdomain: ""
}

License

Unlicense