twitst4tz

index.js (6036B)

---

 /*eslint no-var:0, prefer-arrow-callback: 0, object-shorthand: 0 */
 'use strict';
 
 
 var Punycode = require('punycode');
 
 
 var internals = {};
 
 
 //
 // Read rules from file.
 //
 internals.rules = require('./data/rules.json').map(function (rule) {
 
   return {
     rule: rule,
     suffix: rule.replace(/^(\*\.|\!)/, ''),
     punySuffix: -1,
     wildcard: rule.charAt(0) === '*',
     exception: rule.charAt(0) === '!'
   };
 });
 
 
 //
 // Check is given string ends with `suffix`.
 //
 internals.endsWith = function (str, suffix) {
 
   return str.indexOf(suffix, str.length - suffix.length) !== -1;
 };
 
 
 //
 // Find rule for a given domain.
 //
 internals.findRule = function (domain) {
 
   var punyDomain = Punycode.toASCII(domain);
   return internals.rules.reduce(function (memo, rule) {
 
     if (rule.punySuffix === -1){
       rule.punySuffix = Punycode.toASCII(rule.suffix);
     }
     if (!internals.endsWith(punyDomain, '.' + rule.punySuffix) && punyDomain !== rule.punySuffix) {
       return memo;
     }
     // This has been commented out as it never seems to run. This is because
     // sub tlds always appear after their parents and we never find a shorter
     // match.
     //if (memo) {
     //  var memoSuffix = Punycode.toASCII(memo.suffix);
     //  if (memoSuffix.length >= punySuffix.length) {
     //    return memo;
     //  }
     //}
     return rule;
   }, null);
 };
 
 
 //
 // Error codes and messages.
 //
 exports.errorCodes = {
   DOMAIN_TOO_SHORT: 'Domain name too short.',
   DOMAIN_TOO_LONG: 'Domain name too long. It should be no more than 255 chars.',
   LABEL_STARTS_WITH_DASH: 'Domain name label can not start with a dash.',
   LABEL_ENDS_WITH_DASH: 'Domain name label can not end with a dash.',
   LABEL_TOO_LONG: 'Domain name label should be at most 63 chars long.',
   LABEL_TOO_SHORT: 'Domain name label should be at least 1 character long.',
   LABEL_INVALID_CHARS: 'Domain name label can only contain alphanumeric characters or dashes.'
 };
 
 
 //
 // Validate domain name and throw if not valid.
 //
 // From wikipedia:
 //
 // Hostnames are composed of series of labels concatenated with dots, as are all
 // domain names. Each label must be between 1 and 63 characters long, and the
 // entire hostname (including the delimiting dots) has a maximum of 255 chars.
 //
 // Allowed chars:
 //
 // * `a-z`
 // * `0-9`
 // * `-` but not as a starting or ending character
 // * `.` as a separator for the textual portions of a domain name
 //
 // * http://en.wikipedia.org/wiki/Domain_name
 // * http://en.wikipedia.org/wiki/Hostname
 //
 internals.validate = function (input) {
 
   // Before we can validate we need to take care of IDNs with unicode chars.
   var ascii = Punycode.toASCII(input);
 
   if (ascii.length < 1) {
     return 'DOMAIN_TOO_SHORT';
   }
   if (ascii.length > 255) {
     return 'DOMAIN_TOO_LONG';
   }
 
   // Check each part's length and allowed chars.
   var labels = ascii.split('.');
   var label;
 
   for (var i = 0; i < labels.length; ++i) {
     label = labels[i];
     if (!label.length) {
       return 'LABEL_TOO_SHORT';
     }
     if (label.length > 63) {
       return 'LABEL_TOO_LONG';
     }
     if (label.charAt(0) === '-') {
       return 'LABEL_STARTS_WITH_DASH';
     }
     if (label.charAt(label.length - 1) === '-') {
       return 'LABEL_ENDS_WITH_DASH';
     }
     if (!/^[a-z0-9\-]+$/.test(label)) {
       return 'LABEL_INVALID_CHARS';
     }
   }
 };
 
 
 //
 // Public API
 //
 
 
 //
 // Parse domain.
 //
 exports.parse = function (input) {
 
   if (typeof input !== 'string') {
     throw new TypeError('Domain name must be a string.');
   }
 
   // Force domain to lowercase.
   var domain = input.slice(0).toLowerCase();
 
   // Handle FQDN.
   // TODO: Simply remove trailing dot?
   if (domain.charAt(domain.length - 1) === '.') {
     domain = domain.slice(0, domain.length - 1);
   }
 
   // Validate and sanitise input.
   var error = internals.validate(domain);
   if (error) {
     return {
       input: input,
       error: {
         message: exports.errorCodes[error],
         code: error
       }
     };
   }
 
   var parsed = {
     input: input,
     tld: null,
     sld: null,
     domain: null,
     subdomain: null,
     listed: false
   };
 
   var domainParts = domain.split('.');
 
   // Non-Internet TLD
   if (domainParts[domainParts.length - 1] === 'local') {
     return parsed;
   }
 
   var handlePunycode = function () {
 
     if (!/xn--/.test(domain)) {
       return parsed;
     }
     if (parsed.domain) {
       parsed.domain = Punycode.toASCII(parsed.domain);
     }
     if (parsed.subdomain) {
       parsed.subdomain = Punycode.toASCII(parsed.subdomain);
     }
     return parsed;
   };
 
   var rule = internals.findRule(domain);
 
   // Unlisted tld.
   if (!rule) {
     if (domainParts.length < 2) {
       return parsed;
     }
     parsed.tld = domainParts.pop();
     parsed.sld = domainParts.pop();
     parsed.domain = [parsed.sld, parsed.tld].join('.');
     if (domainParts.length) {
       parsed.subdomain = domainParts.pop();
     }
     return handlePunycode();
   }
 
   // At this point we know the public suffix is listed.
   parsed.listed = true;
 
   var tldParts = rule.suffix.split('.');
   var privateParts = domainParts.slice(0, domainParts.length - tldParts.length);
 
   if (rule.exception) {
     privateParts.push(tldParts.shift());
   }
 
   parsed.tld = tldParts.join('.');
 
   if (!privateParts.length) {
     return handlePunycode();
   }
 
   if (rule.wildcard) {
     tldParts.unshift(privateParts.pop());
     parsed.tld = tldParts.join('.');
   }
 
   if (!privateParts.length) {
     return handlePunycode();
   }
 
   parsed.sld = privateParts.pop();
   parsed.domain = [parsed.sld,  parsed.tld].join('.');
 
   if (privateParts.length) {
     parsed.subdomain = privateParts.join('.');
   }
 
   return handlePunycode();
 };
 
 
 //
 // Get domain.
 //
 exports.get = function (domain) {
 
   if (!domain) {
     return null;
   }
   return exports.parse(domain).domain || null;
 };
 
 
 //
 // Check whether domain belongs to a known public suffix.
 //
 exports.isValid = function (domain) {
 
   var parsed = exports.parse(domain);
   return Boolean(parsed.domain && parsed.listed);
 };