1 files changed, 142 insertions, 0 deletions
diff --git a/bin/wiki/ImportarDesdeURL/node_modules/tldts-core/dist/es6/src/extract-hostname.js b/bin/wiki/ImportarDesdeURL/node_modules/tldts-core/dist/es6/src/extract-hostname.js
new file mode 100644
index 00000000..7970b00a
--- /dev/null
+++ b/bin/wiki/ImportarDesdeURL/node_modules/tldts-core/dist/es6/src/extract-hostname.js
@@ -0,0 +1,142 @@
+/**
+ * @param url - URL we want to extract a hostname from.
+ * @param urlIsValidHostname - hint from caller; true if `url` is already a valid hostname.
+ */
+export default function extractHostname(url, urlIsValidHostname) {
+    var start = 0;
+    var end = url.length;
+    var hasUpper = false;
+    // If url is not already a valid hostname, then try to extract hostname.
+    if (urlIsValidHostname === false) {
+        // Trim leading spaces
+        while (start < url.length && url.charCodeAt(start) <= 32) {
+            start += 1;
+        }
+        // Trim trailing spaces
+        while (end > start + 1 && url.charCodeAt(end - 1) <= 32) {
+            end -= 1;
+        }
+        // Skip scheme.
+        if (url.charCodeAt(start) === 47 /* '/' */ &&
+            url.charCodeAt(start + 1) === 47 /* '/' */) {
+            start += 2;
+        }
+        else {
+            var indexOfProtocol = url.indexOf(':/', start);
+            if (indexOfProtocol !== -1) {
+                // Implement fast-path for common protocols. We expect most protocols
+                // should be one of these 4 and thus we will not need to perform the
+                // more expansive validity check most of the time.
+                var protocolSize = indexOfProtocol - start;
+                var c0 = url.charCodeAt(start);
+                var c1 = url.charCodeAt(start + 1);
+                var c2 = url.charCodeAt(start + 2);
+                var c3 = url.charCodeAt(start + 3);
+                var c4 = url.charCodeAt(start + 4);
+                if (protocolSize === 5 &&
+                    c0 === 104 /* 'h' */ &&
+                    c1 === 116 /* 't' */ &&
+                    c2 === 116 /* 't' */ &&
+                    c3 === 112 /* 'p' */ &&
+                    c4 === 115 /* 's' */) {
+                    // https
+                }
+                else if (protocolSize === 4 &&
+                    c0 === 104 /* 'h' */ &&
+                    c1 === 116 /* 't' */ &&
+                    c2 === 116 /* 't' */ &&
+                    c3 === 112 /* 'p' */) {
+                    // http
+                }
+                else if (protocolSize === 3 &&
+                    c0 === 119 /* 'w' */ &&
+                    c1 === 115 /* 's' */ &&
+                    c2 === 115 /* 's' */) {
+                    // wss
+                }
+                else if (protocolSize === 2 &&
+                    c0 === 119 /* 'w' */ &&
+                    c1 === 115 /* 's' */) {
+                    // ws
+                }
+                else {
+                    // Check that scheme is valid
+                    for (var i = start; i < indexOfProtocol; i += 1) {
+                        var lowerCaseCode = url.charCodeAt(i) | 32;
+                        if (((lowerCaseCode >= 97 && lowerCaseCode <= 122) || // [a, z]
+                            (lowerCaseCode >= 48 && lowerCaseCode <= 57) || // [0, 9]
+                            lowerCaseCode === 46 || // '.'
+                            lowerCaseCode === 45 || // '-'
+                            lowerCaseCode === 43) === false // '+'
+                        ) {
+                            return null;
+                        }
+                    }
+                }
+                // Skip 0, 1 or more '/' after ':/'
+                start = indexOfProtocol + 2;
+                while (url.charCodeAt(start) === 47 /* '/' */) {
+                    start += 1;
+                }
+            }
+        }
+        // Detect first occurrence of '/', '?' or '#'. We also keep track of the
+        // last occurrence of '@', ']' or ':' to speed-up subsequent parsing of
+        // (respectively), identifier, ipv6 or port.
+        var indexOfIdentifier = -1;
+        var indexOfClosingBracket = -1;
+        var indexOfPort = -1;
+        for (var i = start; i < end; i += 1) {
+            var code = url.charCodeAt(i);
+            if (code === 35 || // '#'
+                code === 47 || // '/'
+                code === 63 // '?'
+            ) {
+                end = i;
+                break;
+            }
+            else if (code === 64) {
+                // '@'
+                indexOfIdentifier = i;
+            }
+            else if (code === 93) {
+                // ']'
+                indexOfClosingBracket = i;
+            }
+            else if (code === 58) {
+                // ':'
+                indexOfPort = i;
+            }
+            else if (code >= 65 && code <= 90) {
+                hasUpper = true;
+            }
+        }
+        // Detect identifier: '@'
+        if (indexOfIdentifier !== -1 &&
+            indexOfIdentifier > start &&
+            indexOfIdentifier < end) {
+            start = indexOfIdentifier + 1;
+        }
+        // Handle ipv6 addresses
+        if (url.charCodeAt(start) === 91 /* '[' */) {
+            if (indexOfClosingBracket !== -1) {
+                return url.slice(start + 1, indexOfClosingBracket).toLowerCase();
+            }
+            return null;
+        }
+        else if (indexOfPort !== -1 && indexOfPort > start && indexOfPort < end) {
+            // Detect port: ':'
+            end = indexOfPort;
+        }
+    }
+    // Trim trailing dots
+    while (end > start + 1 && url.charCodeAt(end - 1) === 46 /* '.' */) {
+        end -= 1;
+    }
+    var hostname = start !== 0 || end !== url.length ? url.slice(start, end) : url;
+    if (hasUpper) {
+        return hostname.toLowerCase();
+    }
+    return hostname;
+}
+//# sourceMappingURL=extract-hostname.js.map
+\ No newline at end of file