home/alospiesjs/www/apis/youtube/vendor/illuminate/support/Stringable.php000060400000062634151156305110023110 0ustar00value = (string) $value; } /** * Return the remainder of a string after the first occurrence of a given value. * * @param string $search * @return static */ public function after($search) { return new static(Str::after($this->value, $search)); } /** * Return the remainder of a string after the last occurrence of a given value. * * @param string $search * @return static */ public function afterLast($search) { return new static(Str::afterLast($this->value, $search)); } /** * Append the given values to the string. * * @param array $values * @return static */ public function append(...$values) { return new static($this->value.implode('', $values)); } /** * Append a new line to the string. * * @param int $count * @return $this */ public function newLine($count = 1) { return $this->append(str_repeat(PHP_EOL, $count)); } /** * Transliterate a UTF-8 value to ASCII. * * @param string $language * @return static */ public function ascii($language = 'en') { return new static(Str::ascii($this->value, $language)); } /** * Get the trailing name component of the path. * * @param string $suffix * @return static */ public function basename($suffix = '') { return new static(basename($this->value, $suffix)); } /** * Get the basename of the class path. * * @return static */ public function classBasename() { return new static(class_basename($this->value)); } /** * Get the portion of a string before the first occurrence of a given value. * * @param string $search * @return static */ public function before($search) { return new static(Str::before($this->value, $search)); } /** * Get the portion of a string before the last occurrence of a given value. * * @param string $search * @return static */ public function beforeLast($search) { return new static(Str::beforeLast($this->value, $search)); } /** * Get the portion of a string between two given values. * * @param string $from * @param string $to * @return static */ public function between($from, $to) { return new static(Str::between($this->value, $from, $to)); } /** * Get the smallest possible portion of a string between two given values. * * @param string $from * @param string $to * @return static */ public function betweenFirst($from, $to) { return new static(Str::betweenFirst($this->value, $from, $to)); } /** * Convert a value to camel case. * * @return static */ public function camel() { return new static(Str::camel($this->value)); } /** * Determine if a given string contains a given substring. * * @param string|string[] $needles * @return bool */ public function contains($needles) { return Str::contains($this->value, $needles); } /** * Determine if a given string contains all array values. * * @param array $needles * @return bool */ public function containsAll(array $needles) { return Str::containsAll($this->value, $needles); } /** * Get the parent directory's path. * * @param int $levels * @return static */ public function dirname($levels = 1) { return new static(dirname($this->value, $levels)); } /** * Determine if a given string ends with a given substring. * * @param string|string[] $needles * @return bool */ public function endsWith($needles) { return Str::endsWith($this->value, $needles); } /** * Determine if the string is an exact match with the given value. * * @param \Illuminate\Support\Stringable|string $value * @return bool */ public function exactly($value) { if ($value instanceof Stringable) { $value = $value->toString(); } return $this->value === $value; } /** * Extracts an excerpt from text that matches the first instance of a phrase. * * @param string $phrase * @param array $options * @return string|null */ public function excerpt($phrase = '', $options = []) { return Str::excerpt($this->value, $phrase, $options); } /** * Explode the string into an array. * * @param string $delimiter * @param int $limit * @return \Illuminate\Support\Collection */ public function explode($delimiter, $limit = PHP_INT_MAX) { return collect(explode($delimiter, $this->value, $limit)); } /** * Split a string using a regular expression or by length. * * @param string|int $pattern * @param int $limit * @param int $flags * @return \Illuminate\Support\Collection */ public function split($pattern, $limit = -1, $flags = 0) { if (filter_var($pattern, FILTER_VALIDATE_INT) !== false) { return collect(mb_str_split($this->value, $pattern)); } $segments = preg_split($pattern, $this->value, $limit, $flags); return ! empty($segments) ? collect($segments) : collect(); } /** * Cap a string with a single instance of a given value. * * @param string $cap * @return static */ public function finish($cap) { return new static(Str::finish($this->value, $cap)); } /** * Determine if a given string matches a given pattern. * * @param string|array $pattern * @return bool */ public function is($pattern) { return Str::is($pattern, $this->value); } /** * Determine if a given string is 7 bit ASCII. * * @return bool */ public function isAscii() { return Str::isAscii($this->value); } /** * Determine if a given string is a valid UUID. * * @return bool */ public function isUuid() { return Str::isUuid($this->value); } /** * Determine if the given string is empty. * * @return bool */ public function isEmpty() { return $this->value === ''; } /** * Determine if the given string is not empty. * * @return bool */ public function isNotEmpty() { return ! $this->isEmpty(); } /** * Convert a string to kebab case. * * @return static */ public function kebab() { return new static(Str::kebab($this->value)); } /** * Return the length of the given string. * * @param string $encoding * @return int */ public function length($encoding = null) { return Str::length($this->value, $encoding); } /** * Limit the number of characters in a string. * * @param int $limit * @param string $end * @return static */ public function limit($limit = 100, $end = '...') { return new static(Str::limit($this->value, $limit, $end)); } /** * Convert the given string to lower-case. * * @return static */ public function lower() { return new static(Str::lower($this->value)); } /** * Convert GitHub flavored Markdown into HTML. * * @param array $options * @return static */ public function markdown(array $options = []) { return new static(Str::markdown($this->value, $options)); } /** * Masks a portion of a string with a repeated character. * * @param string $character * @param int $index * @param int|null $length * @param string $encoding * @return static */ public function mask($character, $index, $length = null, $encoding = 'UTF-8') { return new static(Str::mask($this->value, $character, $index, $length, $encoding)); } /** * Get the string matching the given pattern. * * @param string $pattern * @return static */ public function match($pattern) { return new static(Str::match($pattern, $this->value)); } /** * Get the string matching the given pattern. * * @param string $pattern * @return \Illuminate\Support\Collection */ public function matchAll($pattern) { return Str::matchAll($pattern, $this->value); } /** * Determine if the string matches the given pattern. * * @param string $pattern * @return bool */ public function test($pattern) { return $this->match($pattern)->isNotEmpty(); } /** * Pad both sides of the string with another. * * @param int $length * @param string $pad * @return static */ public function padBoth($length, $pad = ' ') { return new static(Str::padBoth($this->value, $length, $pad)); } /** * Pad the left side of the string with another. * * @param int $length * @param string $pad * @return static */ public function padLeft($length, $pad = ' ') { return new static(Str::padLeft($this->value, $length, $pad)); } /** * Pad the right side of the string with another. * * @param int $length * @param string $pad * @return static */ public function padRight($length, $pad = ' ') { return new static(Str::padRight($this->value, $length, $pad)); } /** * Parse a Class@method style callback into class and method. * * @param string|null $default * @return array */ public function parseCallback($default = null) { return Str::parseCallback($this->value, $default); } /** * Call the given callback and return a new string. * * @param callable $callback * @return static */ public function pipe(callable $callback) { return new static($callback($this)); } /** * Get the plural form of an English word. * * @param int $count * @return static */ public function plural($count = 2) { return new static(Str::plural($this->value, $count)); } /** * Pluralize the last word of an English, studly caps case string. * * @param int $count * @return static */ public function pluralStudly($count = 2) { return new static(Str::pluralStudly($this->value, $count)); } /** * Prepend the given values to the string. * * @param array $values * @return static */ public function prepend(...$values) { return new static(implode('', $values).$this->value); } /** * Remove any occurrence of the given string in the subject. * * @param string|array $search * @param bool $caseSensitive * @return static */ public function remove($search, $caseSensitive = true) { return new static(Str::remove($search, $this->value, $caseSensitive)); } /** * Reverse the string. * * @return static */ public function reverse() { return new static(Str::reverse($this->value)); } /** * Repeat the string. * * @param int $times * @return static */ public function repeat(int $times) { return new static(str_repeat($this->value, $times)); } /** * Replace the given value in the given string. * * @param string|string[] $search * @param string|string[] $replace * @return static */ public function replace($search, $replace) { return new static(str_replace($search, $replace, $this->value)); } /** * Replace a given value in the string sequentially with an array. * * @param string $search * @param array $replace * @return static */ public function replaceArray($search, array $replace) { return new static(Str::replaceArray($search, $replace, $this->value)); } /** * Replace the first occurrence of a given value in the string. * * @param string $search * @param string $replace * @return static */ public function replaceFirst($search, $replace) { return new static(Str::replaceFirst($search, $replace, $this->value)); } /** * Replace the last occurrence of a given value in the string. * * @param string $search * @param string $replace * @return static */ public function replaceLast($search, $replace) { return new static(Str::replaceLast($search, $replace, $this->value)); } /** * Replace the patterns matching the given regular expression. * * @param string $pattern * @param \Closure|string $replace * @param int $limit * @return static */ public function replaceMatches($pattern, $replace, $limit = -1) { if ($replace instanceof Closure) { return new static(preg_replace_callback($pattern, $replace, $this->value, $limit)); } return new static(preg_replace($pattern, $replace, $this->value, $limit)); } /** * Parse input from a string to a collection, according to a format. * * @param string $format * @return \Illuminate\Support\Collection */ public function scan($format) { return collect(sscanf($this->value, $format)); } /** * Remove all "extra" blank space from the given string. * * @return static */ public function squish() { return new static(Str::squish($this->value)); } /** * Begin a string with a single instance of a given value. * * @param string $prefix * @return static */ public function start($prefix) { return new static(Str::start($this->value, $prefix)); } /** * Strip HTML and PHP tags from the given string. * * @param string $allowedTags * @return static */ public function stripTags($allowedTags = null) { return new static(strip_tags($this->value, $allowedTags)); } /** * Convert the given string to upper-case. * * @return static */ public function upper() { return new static(Str::upper($this->value)); } /** * Convert the given string to title case. * * @return static */ public function title() { return new static(Str::title($this->value)); } /** * Convert the given string to title case for each word. * * @return static */ public function headline() { return new static(Str::headline($this->value)); } /** * Get the singular form of an English word. * * @return static */ public function singular() { return new static(Str::singular($this->value)); } /** * Generate a URL friendly "slug" from a given string. * * @param string $separator * @param string|null $language * @return static */ public function slug($separator = '-', $language = 'en') { return new static(Str::slug($this->value, $separator, $language)); } /** * Convert a string to snake case. * * @param string $delimiter * @return static */ public function snake($delimiter = '_') { return new static(Str::snake($this->value, $delimiter)); } /** * Determine if a given string starts with a given substring. * * @param string|string[] $needles * @return bool */ public function startsWith($needles) { return Str::startsWith($this->value, $needles); } /** * Convert a value to studly caps case. * * @return static */ public function studly() { return new static(Str::studly($this->value)); } /** * Returns the portion of the string specified by the start and length parameters. * * @param int $start * @param int|null $length * @return static */ public function substr($start, $length = null) { return new static(Str::substr($this->value, $start, $length)); } /** * Returns the number of substring occurrences. * * @param string $needle * @param int|null $offset * @param int|null $length * @return int */ public function substrCount($needle, $offset = null, $length = null) { return Str::substrCount($this->value, $needle, $offset ?? 0, $length); } /** * Replace text within a portion of a string. * * @param string|array $replace * @param array|int $offset * @param array|int|null $length * @return static */ public function substrReplace($replace, $offset = 0, $length = null) { return new static(Str::substrReplace($this->value, $replace, $offset, $length)); } /** * Swap multiple keywords in a string with other keywords. * * @param array $map * @return static */ public function swap(array $map) { return new static(strtr($this->value, $map)); } /** * Trim the string of the given characters. * * @param string $characters * @return static */ public function trim($characters = null) { return new static(trim(...array_merge([$this->value], func_get_args()))); } /** * Left trim the string of the given characters. * * @param string $characters * @return static */ public function ltrim($characters = null) { return new static(ltrim(...array_merge([$this->value], func_get_args()))); } /** * Right trim the string of the given characters. * * @param string $characters * @return static */ public function rtrim($characters = null) { return new static(rtrim(...array_merge([$this->value], func_get_args()))); } /** * Make a string's first character lowercase. * * @return static */ public function lcfirst() { return new static(Str::lcfirst($this->value)); } /** * Make a string's first character uppercase. * * @return static */ public function ucfirst() { return new static(Str::ucfirst($this->value)); } /** * Split a string by uppercase characters. * * @return \Illuminate\Support\Collection */ public function ucsplit() { return collect(Str::ucsplit($this->value)); } /** * Execute the given callback if the string contains a given substring. * * @param string|string[] $needles * @param callable $callback * @param callable|null $default * @return static */ public function whenContains($needles, $callback, $default = null) { return $this->when($this->contains($needles), $callback, $default); } /** * Execute the given callback if the string contains all array values. * * @param array $needles * @param callable $callback * @param callable|null $default * @return static */ public function whenContainsAll(array $needles, $callback, $default = null) { return $this->when($this->containsAll($needles), $callback, $default); } /** * Execute the given callback if the string is empty. * * @param callable $callback * @param callable|null $default * @return static */ public function whenEmpty($callback, $default = null) { return $this->when($this->isEmpty(), $callback, $default); } /** * Execute the given callback if the string is not empty. * * @param callable $callback * @param callable|null $default * @return static */ public function whenNotEmpty($callback, $default = null) { return $this->when($this->isNotEmpty(), $callback, $default); } /** * Execute the given callback if the string ends with a given substring. * * @param string|string[] $needles * @param callable $callback * @param callable|null $default * @return static */ public function whenEndsWith($needles, $callback, $default = null) { return $this->when($this->endsWith($needles), $callback, $default); } /** * Execute the given callback if the string is an exact match with the given value. * * @param string $value * @param callable $callback * @param callable|null $default * @return static */ public function whenExactly($value, $callback, $default = null) { return $this->when($this->exactly($value), $callback, $default); } /** * Execute the given callback if the string matches a given pattern. * * @param string|array $pattern * @param callable $callback * @param callable|null $default * @return static */ public function whenIs($pattern, $callback, $default = null) { return $this->when($this->is($pattern), $callback, $default); } /** * Execute the given callback if the string is 7 bit ASCII. * * @param callable $callback * @param callable|null $default * @return static */ public function whenIsAscii($callback, $default = null) { return $this->when($this->isAscii(), $callback, $default); } /** * Execute the given callback if the string is a valid UUID. * * @param callable $callback * @param callable|null $default * @return static */ public function whenIsUuid($callback, $default = null) { return $this->when($this->isUuid(), $callback, $default); } /** * Execute the given callback if the string starts with a given substring. * * @param string|string[] $needles * @param callable $callback * @param callable|null $default * @return static */ public function whenStartsWith($needles, $callback, $default = null) { return $this->when($this->startsWith($needles), $callback, $default); } /** * Execute the given callback if the string matches the given pattern. * * @param string $pattern * @param callable $callback * @param callable|null $default * @return static */ public function whenTest($pattern, $callback, $default = null) { return $this->when($this->test($pattern), $callback, $default); } /** * Limit the number of words in a string. * * @param int $words * @param string $end * @return static */ public function words($words = 100, $end = '...') { return new static(Str::words($this->value, $words, $end)); } /** * Get the number of words a string contains. * * @return int */ public function wordCount() { return str_word_count($this->value); } /** * Wrap the string with the given strings. * * @param string $before * @param string|null $after * @return static */ public function wrap($before, $after = null) { return new static($before.$this->value.($after ??= $before)); } /** * Convert the string into a `HtmlString` instance. * * @return \Illuminate\Support\HtmlString */ public function toHtmlString() { return new HtmlString($this->value); } /** * Dump the string. * * @return $this */ public function dump() { VarDumper::dump($this->value); return $this; } /** * Dump the string and end the script. * * @return never */ public function dd() { $this->dump(); exit(1); } /** * Get the underlying string value. * * @return string */ public function value() { return $this->toString(); } /** * Get the underlying string value. * * @return string */ public function toString() { return $this->value; } /** * Convert the object to a string when JSON encoded. * * @return string */ public function jsonSerialize(): string { return $this->__toString(); } /** * Proxy dynamic properties onto methods. * * @param string $key * @return mixed */ public function __get($key) { return $this->{$key}(); } /** * Get the raw string value. * * @return string */ public function __toString() { return (string) $this->value; } }