1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
/**
* Implement a factory allowing to plug different implementations of suffix
* lookup (e.g.: using a trie or the packed hashes datastructures). This is used
* and exposed in `tldts.ts` and `tldts-experimental.ts` bundle entrypoints.
*/
import getDomain from './domain';
import extractHostname from './extract-hostname';
import isIp from './is-ip';
import isValidHostname from './is-valid';
import { setDefaults } from './options';
import getSubdomain from './subdomain';
export function parseImpl(url, step, suffixLookup, partialOptions) {
var options = setDefaults(partialOptions);
var result = {
domain: null,
hostname: null,
isIcann: null,
isIp: null,
isPrivate: null,
publicSuffix: null,
subdomain: null
};
// Very fast approximate check to make sure `url` is a string. This is needed
// because the library will not necessarily be used in a typed setup and
// values of arbitrary types might be given as argument.
if (typeof url !== 'string') {
return result;
}
// Extract hostname from `url` only if needed. This can be made optional
// using `options.extractHostname`. This option will typically be used
// whenever we are sure the inputs to `parse` are already hostnames and not
// arbitrary URLs.
//
// `mixedInput` allows to specify if we expect a mix of URLs and hostnames
// as input. If only hostnames are expected then `extractHostname` can be
// set to `false` to speed-up parsing. If only URLs are expected then
// `mixedInputs` can be set to `false`. The `mixedInputs` is only a hint
// and will not change the behavior of the library.
if (options.extractHostname === false) {
result.hostname = url;
}
else if (options.mixedInputs === true) {
result.hostname = extractHostname(url, isValidHostname(url));
}
else {
result.hostname = extractHostname(url, false);
}
if (step === 0 /* HOSTNAME */ || result.hostname === null) {
return result;
}
// Check if `hostname` is a valid ip address
if (options.detectIp === true) {
result.isIp = isIp(result.hostname);
if (result.isIp === true) {
return result;
}
}
// Perform optional hostname validation. If hostname is not valid, no need to
// go further as there will be no valid domain or sub-domain.
if (options.validateHostname === true &&
options.extractHostname === true &&
isValidHostname(result.hostname) === false) {
result.hostname = null;
return result;
}
// Extract public suffix
suffixLookup(result.hostname, options, result);
if (step === 2 /* PUBLIC_SUFFIX */ || result.publicSuffix === null) {
return result;
}
// Extract domain
result.domain = getDomain(result.publicSuffix, result.hostname, options);
if (step === 3 /* DOMAIN */ || result.domain === null) {
return result;
}
// Extract subdomain
result.subdomain = getSubdomain(result.hostname, result.domain);
return result;
}
//# sourceMappingURL=factory.js.map
|
