text: 'use strict';
  
  // Load modules
  
  const Net = require('net');
  const Hoek = require('hoek');
  let Isemail;                            // Loaded on demand
  const Any = require('../any');
  const Ref = require('../../ref');
  const JoiDate = require('../date');
  const Uri = require('./uri');
  const Ip = require('./ip');
  
  // Declare internals
  
  const internals = {
      uriRegex: Uri.createUriRegex(),
      ipRegex: Ip.createIpRegex(['ipv4', 'ipv6', 'ipvfuture'], 'optional')
  };
  
  internals.String = class extends Any {
  
      constructor() {
  
          super();
          this._type = 'string';
          this._invalids.add('');
      }
  
      _base(value, state, options) {
  
          if (typeof value === 'string' &&
              options.convert) {
  
              if (this._flags.case) {
                  value = (this._flags.case === 'upper' ? value.toLocaleUpperCase() : value.toLocaleLowerCase());
              }
  
              if (this._flags.trim) {
                  value = value.trim();
              }
  
              if (this._inner.replacements) {
  
                  for (let i = 0; i < this._inner.replacements.length; ++i) {
                      const replacement = this._inner.replacements[i];
                      value = value.replace(replacement.pattern, replacement.replacement);
                  }
              }
  
              if (this._flags.truncate) {
                  for (let i = 0; i < this._tests.length; ++i) {
                      const test = this._tests[i];
                      if (test.name === 'max') {
                          value = value.slice(0, test.arg);
                          break;
                      }
                  }
              }
          }
  
          return {
              value,
              errors: (typeof value === 'string') ? null : this.createError('string.base', { value }, state, options)
          };
      }
  
      insensitive() {
  
          if (this._flags.insensitive) {
              return this;
          }
  
          const obj = this.clone();
          obj._flags.insensitive = true;
          return obj;
      }
  
      creditCard() {
  
          return this._test('creditCard', undefined, function (value, state, options) {
  
              let i = value.length;
              let sum = 0;
              let mul = 1;
  
              while (i--) {
                  const char = value.charAt(i) * mul;
                  sum = sum + (char - (char > 9) * 9);
                  mul = mul ^ 3;
              }
  
              const check = (sum % 10 === 0) && (sum > 0);
              return check ? value : this.createError('string.creditCard', { value }, state, options);
          });
      }
  
      regex(pattern, patternOptions) {
  
          Hoek.assert(pattern instanceof RegExp, 'pattern must be a RegExp');
  
          const patternObject = {
              pattern: new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined)         // Future version should break this and forbid unsupported regex flags
          };
  
          if (typeof patternOptions === 'string') {
              patternObject.name = patternOptions;
          }
          else if (typeof patternOptions === 'object') {
              patternObject.invert = !!patternOptions.invert;
  
              if (patternOptions.name) {
                  patternObject.name = patternOptions.name;
              }
          }
  
          const errorCode = ['string.regex', patternObject.invert ? '.invert' : '', patternObject.name ? '.name' : '.base'].join('');
  
          return this._test('regex', patternObject, function (value, state, options) {
  
              const patternMatch = patternObject.pattern.test(value);
  
              if (patternMatch ^ patternObject.invert) {
                  return value;
              }
  
              return this.createError(errorCode, { name: patternObject.name, pattern: patternObject.pattern, value }, state, options);
          });
      }
  
      alphanum() {
  
          return this._test('alphanum', undefined, function (value, state, options) {
  
              if (/^[a-zA-Z0-9]+$/.test(value)) {
                  return value;
              }
  
              return this.createError('string.alphanum', { value }, state, options);
          });
      }
  
      token() {
  
          return this._test('token', undefined, function (value, state, options) {
  
              if (/^\w+$/.test(value)) {
                  return value;
              }
  
              return this.createError('string.token', { value }, state, options);
          });
      }
  
      email(isEmailOptions) {
  
          if (isEmailOptions) {
              Hoek.assert(typeof isEmailOptions === 'object', 'email options must be an object');
              Hoek.assert(typeof isEmailOptions.checkDNS === 'undefined', 'checkDNS option is not supported');
              Hoek.assert(typeof isEmailOptions.tldWhitelist === 'undefined' ||
                  typeof isEmailOptions.tldWhitelist === 'object', 'tldWhitelist must be an array or object');
              Hoek.assert(typeof isEmailOptions.minDomainAtoms === 'undefined' ||
                  Number.isSafeInteger(isEmailOptions.minDomainAtoms) && isEmailOptions.minDomainAtoms > 0,
                  'minDomainAtoms must be a positive integer');
              Hoek.assert(typeof isEmailOptions.errorLevel === 'undefined' || typeof isEmailOptions.errorLevel === 'boolean' ||
                  (Number.isSafeInteger(isEmailOptions.errorLevel) && isEmailOptions.errorLevel >= 0),
                  'errorLevel must be a non-negative integer or boolean');
          }
  
          return this._test('email', isEmailOptions, function (value, state, options) {
  
              Isemail = Isemail || require('isemail');
  
              try {
                  const result = Isemail.validate(value, isEmailOptions);
                  if (result === true || result === 0) {
                      return value;
                  }
              }
              catch (e) { }
  
              return this.createError('string.email', { value }, state, options);
          });
      }
  
      ip(ipOptions) {
  
          let regex = internals.ipRegex;
          ipOptions = ipOptions || {};
          Hoek.assert(typeof ipOptions === 'object', 'options must be an object');
  
          if (ipOptions.cidr) {
              Hoek.assert(typeof ipOptions.cidr === 'string', 'cidr must be a string');
              ipOptions.cidr = ipOptions.cidr.toLowerCase();
  
              Hoek.assert(ipOptions.cidr in Ip.cidrs, 'cidr must be one of ' + Object.keys(Ip.cidrs).join(', '));
  
              // If we only received a `cidr` setting, create a regex for it. But we don't need to create one if `cidr` is "optional" since that is the default
              if (!ipOptions.version && ipOptions.cidr !== 'optional') {
                  regex = Ip.createIpRegex(['ipv4', 'ipv6', 'ipvfuture'], ipOptions.cidr);
              }
          }
          else {
  
              // Set our default cidr strategy
              ipOptions.cidr = 'optional';
          }
  
          let versions;
          if (ipOptions.version) {
              if (!Array.isArray(ipOptions.version)) {
                  ipOptions.version = [ipOptions.version];
              }
  
              Hoek.assert(ipOptions.version.length >= 1, 'version must have at least 1 version specified');
  
              versions = [];
              for (let i = 0; i < ipOptions.version.length; ++i) {
                  let version = ipOptions.version[i];
                  Hoek.assert(typeof version === 'string', 'version at position ' + i + ' must be a string');
                  version = version.toLowerCase();
                  Hoek.assert(Ip.versions[version], 'version at position ' + i + ' must be one of ' + Object.keys(Ip.versions).join(', '));
                  versions.push(version);
              }
  
              // Make sure we have a set of versions
              versions = Hoek.unique(versions);
  
              regex = Ip.createIpRegex(versions, ipOptions.cidr);
          }
  
          return this._test('ip', ipOptions, function (value, state, options) {
  
              if (regex.test(value)) {
                  return value;
              }
  
              if (versions) {
                  return this.createError('string.ipVersion', { value, cidr: ipOptions.cidr, version: versions }, state, options);
              }
  
              return this.createError('string.ip', { value, cidr: ipOptions.cidr }, state, options);
          });
      }
  
      uri(uriOptions) {
  
          let customScheme = '';
          let allowRelative = false;
          let relativeOnly = false;
          let regex = internals.uriRegex;
  
          if (uriOptions) {
              Hoek.assert(typeof uriOptions === 'object', 'options must be an object');
  
              if (uriOptions.scheme) {
                  Hoek.assert(uriOptions.scheme instanceof RegExp || typeof uriOptions.scheme === 'string' || Array.isArray(uriOptions.scheme), 'scheme must be a RegExp, String, or Array');
  
                  if (!Array.isArray(uriOptions.scheme)) {
                      uriOptions.scheme = [uriOptions.scheme];
                  }
  
                  Hoek.assert(uriOptions.scheme.length >= 1, 'scheme must have at least 1 scheme specified');
  
                  // Flatten the array into a string to be used to match the schemes.
                  for (let i = 0; i < uriOptions.scheme.length; ++i) {
                      const scheme = uriOptions.scheme[i];
                      Hoek.assert(scheme instanceof RegExp || typeof scheme === 'string', 'scheme at position ' + i + ' must be a RegExp or String');
  
                      // Add OR separators if a value already exists
                      customScheme = customScheme + (customScheme ? '|' : '');
  
                      // If someone wants to match HTTP or HTTPS for example then we need to support both RegExp and String so we don't escape their pattern unknowingly.
                      if (scheme instanceof RegExp) {
                          customScheme = customScheme + scheme.source;
                      }
                      else {
                          Hoek.assert(/[a-zA-Z][a-zA-Z0-9+-\.]*/.test(scheme), 'scheme at position ' + i + ' must be a valid scheme');
                          customScheme = customScheme + Hoek.escapeRegex(scheme);
                      }
                  }
              }
  
              if (uriOptions.allowRelative) {
                  allowRelative = true;
              }
  
              if (uriOptions.relativeOnly) {
                  relativeOnly = true;
              }
          }
  
          if (customScheme || allowRelative || relativeOnly) {
              regex = Uri.createUriRegex(customScheme, allowRelative, relativeOnly);
          }
  
          return this._test('uri', uriOptions, function (value, state, options) {
  
              if (regex.test(value)) {
                  return value;
              }
  
              if (relativeOnly) {
                  return this.createError('string.uriRelativeOnly', { value }, state, options);
              }
  
              if (customScheme) {
                  return this.createError('string.uriCustomScheme', { scheme: customScheme, value }, state, options);
              }
  
              return this.createError('string.uri', { value }, state, options);
          });
      }
  
      isoDate() {
  
          return this._test('isoDate', undefined, function (value, state, options) {
  
              if (JoiDate._isIsoDate(value)) {
                  return value;
              }
  
              return this.createError('string.isoDate', { value }, state, options);
          });
      }
  
      guid(guidOptions) {
  
          const brackets = {
              '{': '}', '[': ']', '(': ')', '': ''
          };
  
          const uuids = {
              'uuidv1': '1',
              'uuidv2': '2',
              'uuidv3': '3',
              'uuidv4': '4',
              'uuidv5': '5'
          };
  
          const versions = [];
  
          if (guidOptions && guidOptions.version) {
              if (!Array.isArray(guidOptions.version)) {
                  guidOptions.version = [guidOptions.version];
              }
  
              Hoek.assert(guidOptions.version.length >= 1, 'version must have at least 1 valid version specified');
  
              for (let i = 0; i < guidOptions.version.length; ++i) {
                  let version = guidOptions.version[i];
                  Hoek.assert(typeof version === 'string', 'version at position ' + i + ' must be a string');
                  version = version.toLowerCase();
                  Hoek.assert(uuids[version], 'version at position ' + i + ' must be one of ' + Object.keys(uuids).join(', '));
                  Hoek.assert(versions.indexOf(version) === -1, 'version at position ' + i + ' must not be a duplicate.');
                  versions.push(version);
              }
          }
  
          const regex = /^([\[{\(]?)([0-9A-F]{8})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{4})([:-]?)([0-9A-F]{12})([\]}\)]?)$/i;
  
          return this._test('guid', guidOptions, function (value, state, options) {
  
              const results = regex.exec(value);
  
              if (!results) {
                  return this.createError('string.guid', { value }, state, options);
              }
  
              // Matching braces
              if (brackets[results[1]] !== results[11]) {
                  return this.createError('string.guid', { value }, state, options);
              }
  
              // Matching separators
              if (results[3] !== results[5] || results[3] !== results[7] || results[3] !== results[9]) {
                  return this.createError('string.guid', { value }, state, options);
              }
  
              // Specific UUID versions
              if (versions.length) {
                  const validVersions = versions.some((uuidVersion) => {
  
                      return results[6][0] === uuids[uuidVersion];
                  });
  
                  // Valid version and 89AB check
                  if (!(validVersions && /[89AB]/i.test(results[8][0]))) {
                      return this.createError('string.guid', { value }, state, options);
                  }
              }
  
              return value;
          });
      }
  
      hex() {
  
          const regex = /^[a-f0-9]+$/i;
  
          return this._test('hex', regex, function (value, state, options) {
  
              if (regex.test(value)) {
                  return value;
              }
  
              return this.createError('string.hex', { value }, state, options);
          });
      }
  
      base64() {
  
          const regex = /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/;
  
          return this._test('base64', regex, function (value, state, options) {
  
              if (regex.test(value)) {
                  return value;
              }
  
              return this.createError('string.base64', { value }, state, options);
          });
      }
  
      hostname() {
  
          const regex = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
  
          return this._test('hostname', undefined, function (value, state, options) {
  
              if ((value.length <= 255 && regex.test(value)) ||
                  Net.isIPv6(value)) {
  
                  return value;
              }
  
              return this.createError('string.hostname', { value }, state, options);
          });
      }
  
      lowercase() {
  
          const obj = this._test('lowercase', undefined, function (value, state, options) {
  
              if (options.convert ||
                  value === value.toLocaleLowerCase()) {
  
                  return value;
              }
  
              return this.createError('string.lowercase', { value }, state, options);
          });
  
          obj._flags.case = 'lower';
          return obj;
      }
  
      uppercase() {
  
          const obj = this._test('uppercase', undefined, function (value, state, options) {
  
              if (options.convert ||
                  value === value.toLocaleUpperCase()) {
  
                  return value;
              }
  
              return this.createError('string.uppercase', { value }, state, options);
          });
  
          obj._flags.case = 'upper';
          return obj;
      }
  
      trim() {
  
          const obj = this._test('trim', undefined, function (value, state, options) {
  
              if (options.convert ||
                  value === value.trim()) {
  
                  return value;
              }
  
              return this.createError('string.trim', { value }, state, options);
          });
  
          obj._flags.trim = true;
          return obj;
      }
  
      replace(pattern, replacement) {
  
          if (typeof pattern === 'string') {
              pattern = new RegExp(Hoek.escapeRegex(pattern), 'g');
          }
  
          Hoek.assert(pattern instanceof RegExp, 'pattern must be a RegExp');
          Hoek.assert(typeof replacement === 'string', 'replacement must be a String');
  
          // This can not be considere a test like trim, we can't "reject"
          // anything from this rule, so just clone the current object
          const obj = this.clone();
  
          if (!obj._inner.replacements) {
              obj._inner.replacements = [];
          }
  
          obj._inner.replacements.push({
              pattern,
              replacement
          });
  
          return obj;
      }
  
      truncate(enabled) {
  
          const value = enabled === undefined ? true : !!enabled;
  
          if (this._flags.truncate === value) {
              return this;
          }
  
          const obj = this.clone();
          obj._flags.truncate = value;
          return obj;
      }
  
  };
  
  internals.compare = function (type, compare) {
  
      return function (limit, encoding) {
  
          const isRef = Ref.isRef(limit);
  
          Hoek.assert((Number.isSafeInteger(limit) && limit >= 0) || isRef, 'limit must be a positive integer or reference');
          Hoek.assert(!encoding || Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
  
          return this._test(type, limit, function (value, state, options) {
  
              let compareTo;
              if (isRef) {
                  compareTo = limit(state.reference || state.parent, options);
  
                  if (!Number.isSafeInteger(compareTo)) {
                      return this.createError('string.ref', { ref: limit.key }, state, options);
                  }
              }
              else {
                  compareTo = limit;
              }
  
              if (compare(value, compareTo, encoding)) {
                  return value;
              }
  
              return this.createError('string.' + type, { limit: compareTo, value, encoding }, state, options);
          });
      };
  };
  
  
  internals.String.prototype.min = internals.compare('min', (value, limit, encoding) => {
  
      const length = encoding ? Buffer.byteLength(value, encoding) : value.length;
      return length >= limit;
  });
  
  
  internals.String.prototype.max = internals.compare('max', (value, limit, encoding) => {
  
      const length = encoding ? Buffer.byteLength(value, encoding) : value.length;
      return length <= limit;
  });
  
  
  internals.String.prototype.length = internals.compare('length', (value, limit, encoding) => {
  
      const length = encoding ? Buffer.byteLength(value, encoding) : value.length;
      return length === limit;
  });
  
  // Aliases
  
  internals.String.prototype.uuid = internals.String.prototype.guid;
  
  module.exports = new internals.String();
  