ends with "," or with "end of string"
359233
function pathExpression (token, tokens) {
  const expression = []
  while (true) {
    if (!token) {
      break
    }
    if (token === ')') {
      tokens.unshift(token)
      break
    }
    if (includes('}]', token)) {
      throw new Error(`A fragment can't contain "${token}"`)
    }

    if (token === ',') {
      break
    }

    if (token === '[') {
      expression.push(escapedFragment(token, tokens))
    } else if (token === '(') {
      expression.push(pathExpressions(token, tokens))
    } else if (token === '{') {
      expression.push(customFragment(token, tokens))
    } else {
      expression.push(unescapedFragment(token, tokens))
    }
    token = tokens.shift()
  }
  return { _type: pathExpression.name, expression }
}
1213876
@Override
    public void endElement(String uri, String name, String qName) {
	setContent(content.toString().trim());
	content = new StringBuffer();
	inside = "";
	/*
	 * if(tag!=null && tag.getName().equalsIgnoreCase("input")) {
	 * print.ln(tag.getName()+"-"+att.getName()+":"+inside+"-"+insideTag+"-"+insideAtt);
	 * 
	 * }
	 */
	if (qName.equals("tag")) endTag();
	else if (qName.equals("attribute")) endAtt();
	else if (qName.equals("script")) endScript();

    }
1151173
public static function endsWith($value, $end)
    {
        if (is_array($value)) {
            return self::last($value) == $end;
        }

        $end = "$end";

        return substr($value, -strlen($end)) === $end;
    }
669846
public boolean endsWith(final String str) {
        if (str == null) {
            return false;
        }
        final int len = str.length();
        if (len == 0) {
            return true;
        }
        if (len > size) {
            return false;
        }
        int pos = size - len;
        for (int i = 0; i < len; i++,pos++) {
            if (buffer[pos] != str.charAt(i)) {
                return false;
            }
        }
        return true;
    }
931482
def endswith(self, suffix, start=None, end=None):
        
        suffix = Bits(suffix)
        start, end = self._validate_slice(start, end)
        if start + suffix.len > end:
            return False
        start = end - suffix.len
        return self._slice(start, end) == suffix
154691
function endsWithString(endingValue, valueToTest) {
  const position = valueToTest.length - endingValue.length;
  const lastIndexOfValue = valueToTest.lastIndexOf(endingValue);

  return !!~lastIndexOfValue && lastIndexOfValue === position;
}
461415
public static boolean endWith(@Nullable CharSequence s, char c) {
		if (StringUtils.isEmpty(s)) {
			return false;
		}
		return s.charAt(s.length() - 1) == c;
	}
725299
function current_word_ends_with(tagged_sentence, i, parameter) {
              var word = tagged_sentence[i][0];
              if (!parameter || (parameter.length > word.length)) {
                return false;
              }
              return(word.indexOf(parameter) === (word.length - parameter.length));
            }
322277
boolean endsWith(final Literal literal) {

        // Check whether the answer is already in the cache
        final int index = literal.getIndex();
        final Boolean cached = myPostfixCache.get(index);
        if (cached != null) {
            return cached.booleanValue();
        }

        // Get the answer and cache the result
        final boolean result = literal.matches(myChars, myChars.length - literal.getLength());
        myPostfixCache.set(index, result);
        return result;
    }
1238798
public static function endsWith(string $string, string $search): bool
    {
        return (substr($string, -strlen($search)) === $search);
    }
1101338
public static function endsWith($string, $suffix) {
    return (mb_strrpos($string,$suffix) === mb_strlen($string) - mb_strlen($suffix));
  }
495144
function ends_withp(str, substr) {
        return slice(str, str.length - substr.length) == substr
    }
799546
public static function endsWith($string, $needle, $strict = true) {
        $end = static::extract($string, -mb_strlen($needle));

        if ($strict) {
            return ($end === $needle);
        }

        return (mb_strtolower($end) === mb_strtolower($needle));
    }
320684
function wrap(input, wrap, ends) {
  return isString(input) && isDefined(wrap)
    ? [wrap, input, ends || wrap].join('')
    : input;
}
353286
def endswith(self, suffix, ignore_case=False, options=None):
        
        return self.regex(re.escape(suffix) + '$', ignore_case=ignore_case, options=options)
933803
static int findEndOfString(String sb) {
        int result;
        for (result = sb.length(); result > 0; result --) {
            if (!Character.isWhitespace(sb.charAt(result - 1))) {
                break;
            }
        }
        return result;
    }
45248
public static boolean endsWithIgnoreCase(String str, String suffix) {
        if (str == null || suffix == null) {
            return false;
        }
        if (str.endsWith(suffix)) {
            return true;
        }
        if (str.length() < suffix.length()) {
            return false;
        }

        String lcStr = str.substring(str.length() - suffix.length()).toLowerCase();
        String lcSuffix = suffix.toLowerCase();
        return lcStr.equals(lcSuffix);
    }