@aws-amplify/graphql-api-construct 1.1.0

package/node_modules/libphonenumber-js/source/findNumbers/LRUCache.js

@@ -0,0 +1,107 @@
+// https://medium.com/dsinjs/implementing-lru-cache-in-javascript-94ba6755cda9
+
+class Node {
+  constructor(key, value, next = null, prev = null) {
+    this.key = key;
+    this.value = value;
+    this.next = next;
+    this.prev = prev;
+  }
+}
+
+export default class LRUCache {
+  //set default limit of 10 if limit is not passed.
+  constructor(limit = 10) {
+    this.size = 0;
+    this.limit = limit;
+    this.head = null;
+    this.tail = null;
+    this.cache = {};
+  }
+
+  // Write Node to head of LinkedList
+  // update cache with Node key and Node reference
+  put(key, value){
+    this.ensureLimit();
+
+    if(!this.head){
+      this.head = this.tail = new Node(key, value);
+    }else{
+      const node = new Node(key, value, this.head);
+      this.head.prev = node;
+      this.head = node;
+    }
+
+    //Update the cache map
+    this.cache[key] = this.head;
+    this.size++;
+  }
+
+  // Read from cache map and make that node as new Head of LinkedList
+  get(key){
+    if(this.cache[key]){
+      const value = this.cache[key].value;
+
+      // node removed from it's position and cache
+      this.remove(key)
+      // write node again to the head of LinkedList to make it most recently used
+      this.put(key, value);
+
+      return value;
+    }
+
+    console.log(`Item not available in cache for key ${key}`);
+  }
+
+  ensureLimit(){
+    if(this.size === this.limit){
+      this.remove(this.tail.key)
+    }
+  }
+
+  remove(key){
+    const node = this.cache[key];
+
+    if(node.prev !== null){
+      node.prev.next = node.next;
+    }else{
+      this.head = node.next;
+    }
+
+    if(node.next !== null){
+      node.next.prev = node.prev;
+    }else{
+      this.tail = node.prev
+    }
+
+    delete this.cache[key];
+    this.size--;
+  }
+
+  clear() {
+    this.head = null;
+    this.tail = null;
+    this.size = 0;
+    this.cache = {};
+  }
+
+  // // Invokes the callback function with every node of the chain and the index of the node.
+  // forEach(fn) {
+  //   let node = this.head;
+  //   let counter = 0;
+  //   while (node) {
+  //     fn(node, counter);
+  //     node = node.next;
+  //     counter++;
+  //   }
+  // }
+
+  // // To iterate over LRU with a 'for...of' loop
+  // *[Symbol.iterator]() {
+  //   let node = this.head;
+  //   while (node) {
+  //     yield node;
+  //     node = node.next;
+  //   }
+  // }
+}

package/node_modules/libphonenumber-js/source/findNumbers/Leniency.js

@@ -0,0 +1,396 @@
+import isValidNumber from '../validate_'
+import parseDigits from '../helpers/parseDigits'
+
+import {
+	startsWith,
+	endsWith
+} from './util'
+
+/**
+ * Leniency when finding potential phone numbers in text segments
+ * The levels here are ordered in increasing strictness.
+ */
+export default
+{
+	/**
+	 * Phone numbers accepted are "possible", but not necessarily "valid".
+	 */
+	POSSIBLE(number, candidate, metadata)
+	{
+		return true
+	},
+
+	/**
+	 * Phone numbers accepted are "possible" and "valid".
+	 * Numbers written in national format must have their national-prefix
+	 * present if it is usually written for a number of this type.
+	 */
+	VALID(number, candidate, metadata)
+	{
+		if (!isValidNumber(number, undefined, metadata) ||
+			!containsOnlyValidXChars(number, candidate.toString(), metadata))
+		{
+			return false
+		}
+
+    // Skipped for simplicity.
+		// return isNationalPrefixPresentIfRequired(number, metadata)
+    return true
+  },
+
+	/**
+	 * Phone numbers accepted are "valid" and
+	 * are grouped in a possible way for this locale. For example, a US number written as
+	 * "65 02 53 00 00" and "650253 0000" are not accepted at this leniency level, whereas
+	 * "650 253 0000", "650 2530000" or "6502530000" are.
+	 * Numbers with more than one '/' symbol in the national significant number
+	 * are also dropped at this level.
+	 *
+	 * Warning: This level might result in lower coverage especially for regions outside of
+	 * country code "+1". If you are not sure about which level to use,
+	 * email the discussion group libphonenumber-discuss@googlegroups.com.
+	 */
+	STRICT_GROUPING(number, candidate, metadata, regExpCache)
+	{
+		const candidateString = candidate.toString()
+
+		if (!isValidNumber(number, undefined, metadata)
+			|| !containsOnlyValidXChars(number, candidateString, metadata)
+			|| containsMoreThanOneSlashInNationalNumber(number, candidateString)
+			|| !isNationalPrefixPresentIfRequired(number, metadata))
+		{
+			return false
+		}
+
+		return checkNumberGroupingIsValid
+		(
+			number,
+			candidate,
+			metadata,
+			allNumberGroupsRemainGrouped,
+			regExpCache
+		)
+  },
+
+	/**
+	 * Phone numbers accepted are {@linkplain PhoneNumberUtil#isValidNumber(PhoneNumber) valid} and
+	 * are grouped in the same way that we would have formatted it, or as a single block. For
+	 * example, a US number written as "650 2530000" is not accepted at this leniency level, whereas
+	 * "650 253 0000" or "6502530000" are.
+	 * Numbers with more than one '/' symbol are also dropped at this level.
+	 * <p>
+	 * Warning: This level might result in lower coverage especially for regions outside of country
+	 * code "+1". If you are not sure about which level to use, email the discussion group
+	 * libphonenumber-discuss@googlegroups.com.
+	 */
+	EXACT_GROUPING(number, candidate, metadata, regExpCache)
+	{
+		const candidateString = candidate.toString()
+
+		if (!isValidNumber(number, undefined, metadata)
+			|| !containsOnlyValidXChars(number, candidateString, metadata)
+			|| containsMoreThanOneSlashInNationalNumber(number, candidateString)
+			|| !isNationalPrefixPresentIfRequired(number, metadata))
+		{
+			return false
+		}
+
+		return checkNumberGroupingIsValid
+		(
+			number,
+			candidate,
+			metadata,
+			allNumberGroupsAreExactlyPresent,
+			regExpCache
+		)
+	}
+}
+
+function containsOnlyValidXChars(number, candidate, metadata)
+{
+  // The characters 'x' and 'X' can be (1) a carrier code, in which case they always precede the
+  // national significant number or (2) an extension sign, in which case they always precede the
+  // extension number. We assume a carrier code is more than 1 digit, so the first case has to
+  // have more than 1 consecutive 'x' or 'X', whereas the second case can only have exactly 1 'x'
+  // or 'X'. We ignore the character if it appears as the last character of the string.
+  for (let index = 0; index < candidate.length - 1; index++)
+  {
+    const charAtIndex = candidate.charAt(index)
+
+    if (charAtIndex === 'x' || charAtIndex === 'X')
+    {
+      const charAtNextIndex = candidate.charAt(index + 1)
+
+      if (charAtNextIndex === 'x' || charAtNextIndex === 'X')
+      {
+        // This is the carrier code case, in which the 'X's always precede the national
+        // significant number.
+        index++
+        if (util.isNumberMatch(number, candidate.substring(index)) != MatchType.NSN_MATCH)
+        {
+          return false
+        }
+	      // This is the extension sign case, in which the 'x' or 'X' should always precede the
+	      // extension number.
+      }
+      else if (parseDigits(candidate.substring(index)) !== number.ext)
+      {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+function isNationalPrefixPresentIfRequired(number, _metadata)
+{
+  // First, check how we deduced the country code. If it was written in international format, then
+  // the national prefix is not required.
+  if (number.getCountryCodeSource() != 'FROM_DEFAULT_COUNTRY')
+  {
+    return true
+  }
+
+  const phoneNumberRegion = util.getRegionCodeForCountryCode(number.getCountryCode())
+
+  const metadata = util.getMetadataForRegion(phoneNumberRegion)
+  if (metadata == null)
+  {
+    return true
+  }
+
+  // Check if a national prefix should be present when formatting this number.
+  const nationalNumber = util.getNationalSignificantNumber(number)
+  const formatRule = util.chooseFormattingPatternForNumber(metadata.numberFormats(), nationalNumber)
+
+  // To do this, we check that a national prefix formatting rule was present
+  // and that it wasn't just the first-group symbol ($1) with punctuation.
+  if (formatRule && formatRule.getNationalPrefixFormattingRule().length > 0)
+  {
+    if (formatRule.getNationalPrefixOptionalWhenFormatting())
+    {
+      // The national-prefix is optional in these cases, so we don't need to check if it was
+      // present.
+      return true
+    }
+
+    if (PhoneNumberUtil.formattingRuleHasFirstGroupOnly(
+        formatRule.getNationalPrefixFormattingRule()))
+    {
+      // National Prefix not needed for this number.
+      return true
+    }
+
+    // Normalize the remainder.
+    const rawInputCopy = PhoneNumberUtil.normalizeDigitsOnly(number.getRawInput())
+
+    // Check if we found a national prefix and/or carrier code at the start of the raw input, and
+    // return the result.
+    return util.maybeStripNationalPrefixAndCarrierCode(rawInputCopy, metadata, null)
+  }
+
+  return true
+}
+
+export function containsMoreThanOneSlashInNationalNumber(number, candidate)
+{
+  const firstSlashInBodyIndex = candidate.indexOf('/')
+  if (firstSlashInBodyIndex < 0)
+  {
+    // No slashes, this is okay.
+    return false
+  }
+
+  // Now look for a second one.
+  const secondSlashInBodyIndex = candidate.indexOf('/', firstSlashInBodyIndex + 1)
+  if (secondSlashInBodyIndex < 0)
+  {
+    // Only one slash, this is okay.
+    return false
+  }
+
+  // If the first slash is after the country calling code, this is permitted.
+  const candidateHasCountryCode =
+      (number.getCountryCodeSource() === CountryCodeSource.FROM_NUMBER_WITH_PLUS_SIGN
+       || number.getCountryCodeSource() === CountryCodeSource.FROM_NUMBER_WITHOUT_PLUS_SIGN)
+
+  if (candidateHasCountryCode
+      && PhoneNumberUtil.normalizeDigitsOnly(candidate.substring(0, firstSlashInBodyIndex))
+          === String(number.getCountryCode()))
+  {
+    // Any more slashes and this is illegal.
+    return candidate.slice(secondSlashInBodyIndex + 1).indexOf('/') >= 0
+  }
+
+  return true
+}
+
+function checkNumberGroupingIsValid(
+  number,
+  candidate,
+  metadata,
+  checkGroups,
+  regExpCache
+) {
+  const normalizedCandidate = normalizeDigits(candidate, true /* keep non-digits */)
+  let formattedNumberGroups = getNationalNumberGroups(metadata, number, null)
+  if (checkGroups(metadata, number, normalizedCandidate, formattedNumberGroups)) {
+    return true
+  }
+
+  // If this didn't pass, see if there are any alternate formats that match, and try them instead.
+  const alternateFormats = MetadataManager.getAlternateFormatsForCountry(number.getCountryCode())
+  const nationalSignificantNumber = util.getNationalSignificantNumber(number)
+
+  if (alternateFormats) {
+    for (const alternateFormat of alternateFormats.numberFormats()) {
+      if (alternateFormat.leadingDigitsPatterns().length > 0) {
+        // There is only one leading digits pattern for alternate formats.
+        const leadingDigitsRegExp = regExpCache.getPatternForRegExp('^' + alternateFormat.leadingDigitsPatterns()[0])
+        if (!leadingDigitsRegExp.test(nationalSignificantNumber)) {
+          // Leading digits don't match; try another one.
+          continue
+        }
+      }
+      formattedNumberGroups = getNationalNumberGroups(metadata, number, alternateFormat)
+      if (checkGroups(metadata, number, normalizedCandidate, formattedNumberGroups)) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/**
+ * Helper method to get the national-number part of a number, formatted without any national
+ * prefix, and return it as a set of digit blocks that would be formatted together following
+ * standard formatting rules.
+ */
+function getNationalNumberGroups(
+	metadata,
+	number,
+	formattingPattern
+) {
+  if (formattingPattern) {
+    // We format the NSN only, and split that according to the separator.
+    const nationalSignificantNumber = util.getNationalSignificantNumber(number)
+    return util.formatNsnUsingPattern(nationalSignificantNumber,
+                                      formattingPattern, 'RFC3966', metadata).split('-')
+	}
+
+  // This will be in the format +CC-DG1-DG2-DGX;ext=EXT where DG1..DGX represents groups of digits.
+  const rfc3966Format = formatNumber(number, 'RFC3966', metadata)
+
+  // We remove the extension part from the formatted string before splitting it into different
+  // groups.
+  let endIndex = rfc3966Format.indexOf(';')
+  if (endIndex < 0) {
+    endIndex = rfc3966Format.length
+  }
+
+  // The country-code will have a '-' following it.
+  const startIndex = rfc3966Format.indexOf('-') + 1
+  return rfc3966Format.slice(startIndex, endIndex).split('-')
+}
+
+function allNumberGroupsAreExactlyPresent
+(
+	metadata,
+	number,
+	normalizedCandidate,
+	formattedNumberGroups
+)
+{
+  const candidateGroups = normalizedCandidate.split(NON_DIGITS_PATTERN)
+
+  // Set this to the last group, skipping it if the number has an extension.
+  let candidateNumberGroupIndex =
+      number.hasExtension() ? candidateGroups.length - 2 : candidateGroups.length - 1
+
+  // First we check if the national significant number is formatted as a block.
+  // We use contains and not equals, since the national significant number may be present with
+  // a prefix such as a national number prefix, or the country code itself.
+  if (candidateGroups.length == 1
+      || candidateGroups[candidateNumberGroupIndex].contains(
+          util.getNationalSignificantNumber(number)))
+  {
+    return true
+  }
+
+  // Starting from the end, go through in reverse, excluding the first group, and check the
+  // candidate and number groups are the same.
+  let formattedNumberGroupIndex = (formattedNumberGroups.length - 1)
+  while (formattedNumberGroupIndex > 0 && candidateNumberGroupIndex >= 0)
+  {
+    if (candidateGroups[candidateNumberGroupIndex] !== formattedNumberGroups[formattedNumberGroupIndex])
+    {
+      return false
+    }
+    formattedNumberGroupIndex--
+    candidateNumberGroupIndex--
+  }
+
+  // Now check the first group. There may be a national prefix at the start, so we only check
+  // that the candidate group ends with the formatted number group.
+  return (candidateNumberGroupIndex >= 0
+      && endsWith(candidateGroups[candidateNumberGroupIndex], formattedNumberGroups[0]))
+}
+
+
+function allNumberGroupsRemainGrouped
+(
+	metadata,
+	number,
+	normalizedCandidate,
+	formattedNumberGroups
+)
+{
+  let fromIndex = 0
+  if (number.getCountryCodeSource() !== CountryCodeSource.FROM_DEFAULT_COUNTRY)
+  {
+    // First skip the country code if the normalized candidate contained it.
+    const countryCode = String(number.getCountryCode())
+    fromIndex = normalizedCandidate.indexOf(countryCode) + countryCode.length()
+  }
+
+  // Check each group of consecutive digits are not broken into separate groupings in the
+  // {@code normalizedCandidate} string.
+  for (let i = 0; i < formattedNumberGroups.length; i++)
+  {
+    // Fails if the substring of {@code normalizedCandidate} starting from {@code fromIndex}
+    // doesn't contain the consecutive digits in formattedNumberGroups[i].
+    fromIndex = normalizedCandidate.indexOf(formattedNumberGroups[i], fromIndex)
+    if (fromIndex < 0) {
+      return false
+    }
+    // Moves {@code fromIndex} forward.
+    fromIndex += formattedNumberGroups[i].length()
+    if (i == 0 && fromIndex < normalizedCandidate.length())
+    {
+      // We are at the position right after the NDC. We get the region used for formatting
+      // information based on the country code in the phone number, rather than the number itself,
+      // as we do not need to distinguish between different countries with the same country
+      // calling code and this is faster.
+      const region = util.getRegionCodeForCountryCode(number.getCountryCode())
+      if (util.getNddPrefixForRegion(region, true) != null
+          && Character.isDigit(normalizedCandidate.charAt(fromIndex))) {
+        // This means there is no formatting symbol after the NDC. In this case, we only
+        // accept the number if there is no formatting symbol at all in the number, except
+        // for extensions. This is only important for countries with national prefixes.
+        const nationalSignificantNumber = util.getNationalSignificantNumber(number)
+        return startsWith
+        (
+      	  normalizedCandidate.slice(fromIndex - formattedNumberGroups[i].length),
+           nationalSignificantNumber
+        )
+      }
+    }
+  }
+
+  // The check here makes sure that we haven't mistakenly already used the extension to
+  // match the last group of the subscriber number. Note the extension cannot have
+  // formatting in-between digits.
+  return normalizedCandidate.slice(fromIndex).contains(number.getExtension())
+}

package/node_modules/libphonenumber-js/source/findNumbers/Leniency.test.js

@@ -0,0 +1,41 @@
+/*
+import
+{
+	containsMoreThanOneSlashInNationalNumber
+}
+from './Leniency'
+
+describe('Leniency', () =>
+{
+	it('testContainsMoreThanOneSlashInNationalNumber', () =>
+	{
+		// A date should return true.
+		number.setCountryCode(1)
+		number.setCountryCodeSource(CountryCodeSource.FROM_DEFAULT_COUNTRY)
+		containsMoreThanOneSlashInNationalNumber(number, '1/05/2013').should.equal(true)
+
+		// Here, the country code source thinks it started with a country calling code, but this is not
+		// the same as the part before the slash, so it's still true.
+		number.setCountryCode(274)
+		number.setCountryCodeSource(CountryCodeSource.FROM_NUMBER_WITHOUT_PLUS_SIGN)
+		containsMoreThanOneSlashInNationalNumber(number, '27/4/2013').should.equal(true)
+
+		// Now it should be false, because the first slash is after the country calling code.
+		number.setCountryCode(49)
+		number.setCountryCodeSource(CountryCodeSource.FROM_NUMBER_WITH_PLUS_SIGN)
+		containsMoreThanOneSlashInNationalNumber(number, '49/69/2013').should.equal(false)
+
+		number.setCountryCode(49)
+		number.setCountryCodeSource(CountryCodeSource.FROM_NUMBER_WITHOUT_PLUS_SIGN)
+		containsMoreThanOneSlashInNationalNumber(number, '+49/69/2013').should.equal(false)
+		containsMoreThanOneSlashInNationalNumber(number, '+ 49/69/2013').should.equal(false)
+		containsMoreThanOneSlashInNationalNumber(number, '+ 49/69/20/13').should.equal(true)
+
+		// Here, the first group is not assumed to be the country calling code, even though it is the
+		// same as it, so this should return true.
+		number.setCountryCode(49)
+		number.setCountryCodeSource(CountryCodeSource.FROM_DEFAULT_COUNTRY)
+		containsMoreThanOneSlashInNationalNumber(number, '49/69/2013').should.equal(true)
+	})
+})
+*/

package/node_modules/libphonenumber-js/source/findNumbers/RegExpCache.js

@@ -0,0 +1,20 @@
+import LRUCache from './LRUCache'
+
+// A cache for frequently used country-specific regular expressions. Set to 32 to cover ~2-3
+// countries being used for the same doc with ~10 patterns for each country. Some pages will have
+// a lot more countries in use, but typically fewer numbers for each so expanding the cache for
+// that use-case won't have a lot of benefit.
+export default class RegExpCache {
+	constructor(size) {
+		this.cache = new LRUCache(size)
+	}
+
+	getPatternForRegExp(pattern) {
+		let regExp = this.cache.get(pattern)
+		if (!regExp) {
+			regExp = new RegExp('^' + pattern)
+			this.cache.put(pattern, regExp)
+		}
+		return regExp
+	}
+}

package/node_modules/libphonenumber-js/source/findNumbers/isValidCandidate.js

@@ -0,0 +1,86 @@
+// Copy-pasted from `PhoneNumberMatcher.js`.
+
+import { PLUS_CHARS } from '../constants'
+import { limit } from './util'
+
+import {
+	isLatinLetter,
+	isInvalidPunctuationSymbol
+} from './utf-8'
+
+const OPENING_PARENS = '(\\[\uFF08\uFF3B'
+const CLOSING_PARENS = ')\\]\uFF09\uFF3D'
+const NON_PARENS = `[^${OPENING_PARENS}${CLOSING_PARENS}]`
+
+export const LEAD_CLASS = `[${OPENING_PARENS}${PLUS_CHARS}]`
+
+// Punctuation that may be at the start of a phone number - brackets and plus signs.
+const LEAD_CLASS_LEADING = new RegExp('^' + LEAD_CLASS)
+
+// Limit on the number of pairs of brackets in a phone number.
+const BRACKET_PAIR_LIMIT = limit(0, 3)
+
+/**
+ * Pattern to check that brackets match. Opening brackets should be closed within a phone number.
+ * This also checks that there is something inside the brackets. Having no brackets at all is also
+ * fine.
+ *
+ * An opening bracket at the beginning may not be closed, but subsequent ones should be.  It's
+ * also possible that the leading bracket was dropped, so we shouldn't be surprised if we see a
+ * closing bracket first. We limit the sets of brackets in a phone number to four.
+ */
+const MATCHING_BRACKETS_ENTIRE = new RegExp
+(
+	'^'
+	+ "(?:[" + OPENING_PARENS + "])?" + "(?:" + NON_PARENS + "+" + "[" + CLOSING_PARENS + "])?"
+	+ NON_PARENS + "+"
+	+ "(?:[" + OPENING_PARENS + "]" + NON_PARENS + "+[" + CLOSING_PARENS + "])" + BRACKET_PAIR_LIMIT
+	+ NON_PARENS + "*"
+	+ '$'
+)
+
+/**
+ * Matches strings that look like publication pages. Example:
+ * <pre>Computing Complete Answers to Queries in the Presence of Limited Access Patterns.
+ * Chen Li. VLDB J. 12(3): 211-227 (2003).</pre>
+ *
+ * The string "211-227 (2003)" is not a telephone number.
+ */
+const PUB_PAGES = /\d{1,5}-+\d{1,5}\s{0,4}\(\d{1,4}/
+
+export default function isValidCandidate(candidate, offset, text, leniency)
+{
+	// Check the candidate doesn't contain any formatting
+	// which would indicate that it really isn't a phone number.
+	if (!MATCHING_BRACKETS_ENTIRE.test(candidate) || PUB_PAGES.test(candidate)) {
+		return
+	}
+
+	// If leniency is set to VALID or stricter, we also want to skip numbers that are surrounded
+	// by Latin alphabetic characters, to skip cases like abc8005001234 or 8005001234def.
+	if (leniency !== 'POSSIBLE')
+	{
+		// If the candidate is not at the start of the text,
+		// and does not start with phone-number punctuation,
+		// check the previous character.
+		if (offset > 0 && !LEAD_CLASS_LEADING.test(candidate))
+		{
+			const previousChar = text[offset - 1]
+			// We return null if it is a latin letter or an invalid punctuation symbol.
+			if (isInvalidPunctuationSymbol(previousChar) || isLatinLetter(previousChar)) {
+				return false
+			}
+		}
+
+		const lastCharIndex = offset + candidate.length
+		if (lastCharIndex < text.length)
+		{
+			const nextChar = text[lastCharIndex]
+			if (isInvalidPunctuationSymbol(nextChar) || isLatinLetter(nextChar)) {
+				return false
+			}
+		}
+	}
+
+	return true
+}

package/node_modules/libphonenumber-js/source/findNumbers/isValidPreCandidate.js

@@ -0,0 +1,29 @@
+// Matches strings that look like dates using "/" as a separator.
+// Examples: 3/10/2011, 31/10/96 or 08/31/95.
+const SLASH_SEPARATED_DATES = /(?:(?:[0-3]?\d\/[01]?\d)|(?:[01]?\d\/[0-3]?\d))\/(?:[12]\d)?\d{2}/
+
+// Matches timestamps.
+// Examples: "2012-01-02 08:00".
+// Note that the reg-ex does not include the
+// trailing ":\d\d" -- that is covered by TIME_STAMPS_SUFFIX.
+const TIME_STAMPS = /[12]\d{3}[-/]?[01]\d[-/]?[0-3]\d +[0-2]\d$/
+const TIME_STAMPS_SUFFIX_LEADING = /^:[0-5]\d/
+
+export default function isValidPreCandidate(candidate, offset, text)
+{
+	// Skip a match that is more likely to be a date.
+	if (SLASH_SEPARATED_DATES.test(candidate)) {
+		return false
+	}
+
+	// Skip potential time-stamps.
+	if (TIME_STAMPS.test(candidate))
+	{
+		const followingText = text.slice(offset + candidate.length)
+		if (TIME_STAMPS_SUFFIX_LEADING.test(followingText)) {
+			return false
+		}
+	}
+
+	return true
+}