Don't warn for lines that exceeds limit, but either are part of
translations function first argument or contain single words that alone
are longer that line limit (e.g. long URLs).

@param File $file
@param int $start
@param int $end
@return bool
768579
private function shouldIgnoreLine(File $file, int $start, int $end): bool
    {
        return
            $this->containLongWords($file, $start, $end)
            || $this->isI18nFunction($file, $start, $end);
    }
1209904
public function getBetweenReverse($content, $start, $end)
    {
        return $this->api->getBetweenReverse($content, $start, $end);
    }
650701
public function removeLines(int $startLine, int $endLine): void
    {
        for ($line = $startLine; $line <= $endLine; $line++) {
            $this->removeLine($line);
        }
    }
400602
public function removeRange(int $start, int $end): bool {
        $removed = true;
        foreach ($this->array as $key => $item) {
            if ($key >= $start && $key <= $end) {
                $removed &= $this->remove($key);
            }
        }
        $this->array = \array_values($this->array);
        return $removed;
    }
601437
public function getBetween($content, $start, $end = null)
    {
        return $this->api->getBetween($content, $start, $end);
    }
750784
public static function endsWith($string, $end)
    {
        $l = strlen($end);
        if ($l == 0) {
            return true;
        }
        return substr($string, - $l) === $end;
    }
987836
public function limit($limit = 120, $end = '...') {
        $returnValue = $this->string;

        if($this->length() > $limit) {
            $returnValue = rtrim((string) $this->first($limit)->toString()) . $end;
        }

        return $this->createClone($returnValue);
    }
382904
protected function getStringsBetween($string, $start, $end)
    {

        $pattern = sprintf(
                '/%s(.*?)%s/', preg_quote($start), preg_quote($end)
        );

        preg_match_all($pattern, $string, $matches);

        return $matches[1];
    }
264035
private void matchEndLine() {
		// First, parse all whitespace characters except for new lines
		index = skipLineSpace(index);

		// Second, check whether we've reached the end-of-file (as signaled by
		// running out of tokens), or we've encountered some token which not a
		// newline.
		if (index >= tokens.size()) {
			return; // EOF
		} else if (tokens.get(index).kind != NewLine) {
			syntaxError("expected end-of-line", tokens.get(index));
		} else {
			index = index + 1;
		}
	}
1097751
public function orWhereNotBetween($field, $start, $end)
    {
        $this->prepareWhereBetween($field, $start, $end, 'orNotBetween');

        return $this;
    }
758458
public function substr($key, $start, $end) {
        return $this->returnCommand(['SUBSTR'], $key, [$key, $start, $end]);
    }
430215
protected function quote($s, $start, $end)
    {
        if ($start == $end) {
            return "";
        }
        return preg_quote(substr($s, $start, $end), '#');
    }
9884
protected function processLines(SplFileObject $file)
    {
        $filename = $file->getPathname();

        $lines = [];
        $duplicates = [];
        foreach ($file as $line) {
            $trimLine = trim($line);
            $lineNo = ($file->key() + 1);

            if (isset($lines[$trimLine])) {
                $foundLineNo = $lines[$trimLine];
                if (!in_array($foundLineNo, $duplicates)) {
                    $duplicates[] = $foundLineNo;
                }

               $duplicates[] = $lineNo;
            } else if (strlen($trimLine) > 3) {
                // Non duplicate first line
                $lines[$trimLine] = $lineNo;
            }
        }

        $totalDuplicates = count($duplicates);
        if ($totalDuplicates > 0) {
            sort($duplicates);
            $duplicatesStr = '';
            foreach (array_chunk($duplicates, 10) as $chunk) {
                $duplicatesStr .= implode(', ', $chunk) . PHP_EOL;
            }

            $this->stats[$filename] = [
                'file' => $filename,
                'duplicate' => $totalDuplicates,
                'line_no' => $duplicatesStr,
            ];
        }
    }
1236106
public function getRangeUrls($start,$end){

        $urls = Array();

        if($end > $this->totalPages){
            $end = $this->totalPages;
        }//if

        if($start < 1){
            $start = 1;
        }//if

        for($i = $start; $i <= $end; $i++){
            $urls[] = $this->getPageUrl($i);
        }//for

        return $urls;
       
    }
930238
public function whereNotBetween($field, $start, $end)
    {
        $this->prepareWhereBetween($field, $start, $end, 'notBetween');

        return $this;
    }
1193657
public static function betweenSubstr($string, $start, $end = null)
    {
        if (($start_pos = strpos($string, $start)) !== false) {
            if ($end) {
                if (($end_pos = strpos($string, $end, $start_pos + strlen($start))) !== false) {
                    return substr($string, $start_pos + strlen($start), $end_pos - ($start_pos + strlen($start)));
                }
            } else {
                return substr($string, $start_pos);
            }
        }
        return false;
    }
710732
public static function extension($file, $separator = self::SEPARATOR_BOTH){
        return self::validate($file, $separator) ? substr($file, strrpos($file, '.') + 1) : false;
    }