PHPackages                             jitsu/wrap - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. jitsu/wrap

ActiveLibrary[Utility & Helpers](/categories/utility)

jitsu/wrap
==========

Wrapper classes for strings, arrays, and regexes with chainable methods

0.1.2(10y ago)071MITPHPPHP >=5.3.0

Since Sep 19Pushed 10y ago1 watchersCompare

[ Source](https://github.com/bdusell/jitsu-wrap)[ Packagist](https://packagist.org/packages/jitsu/wrap)[ RSS](/packages/jitsu-wrap/feed)WikiDiscussions master Synced 1mo ago

READMEChangelogDependencies (3)Versions (4)Used By (0)

jitsu/wrap
----------

[](#jitsuwrap)

This package includes object-oriented wrapper classes for PHP strings, arrays, and regular expressions (respectively, `Jitsu\XString`, `Jitsu\XArray`, and `Jitsu\XRegex`). These classes simply build upon the functions in the packages [`jitsu/string`](https://github.com/bdusell/jitsu-string), [`jitsu/array`](https://github.com/bdusell/jitsu-array), and [`jitsu/regex`](https://github.com/bdusell/jitsu-regex), providing an object-oriented interface to the static methods implemented there. The OOP versions automatically unwrap their arguments and wrap their return values.

This package is part of [Jitsu](https://github.com/bdusell/jitsu).

Installation
------------

[](#installation)

Install this package with [Composer](https://getcomposer.org/):

```
composer require jitsu/wrap
```

Namespace
---------

[](#namespace)

All classes are defined under the namespace `Jitsu`.

Usage
-----

[](#usage)

Here's a quick example to illustrate this package's tremendous usefulness:

```
use Jitsu\XArray;
use Jitsu\XString;

// Wisdom from the ancient Romans?
$s = new XString('Repus Terces Egassem');

// Maybe not...
echo $s->split()->map(function($s) {
	return (new XString($s))->lowerFirst()->reverse()->capitalize();
})->join(' '), "\n";
// => Super Secret Message
```

API
---

[](#api)

### class Jitsu\\XString

[](#class-jitsuxstring)

An object-oriented wrapper for the `string` type.

See [jitsu/string](https://github.com/bdusell/jitsu-string).

#### new XString($value = '')

[](#new-xstringvalue--)

Type**`$value`**`string#### $x\_string->\_\_toString()

[](#x_string-__tostring)

#### XString::unwrap($x)

[](#xstringunwrapx)

#### $x\_string->length()

[](#x_string-length)

#### $x\_string->size()

[](#x_string-size)

#### $x\_string->isEmpty()

[](#x_string-isempty)

#### $x\_string->equal($that)

[](#x_string-equalthat)

#### $x\_string->iEqual($that)

[](#x_string-iequalthat)

#### $x\_string->chars()

[](#x_string-chars)

#### $x\_string->chunks($n)

[](#x_string-chunksn)

#### $x\_string->split($delim = null, $limit = null)

[](#x_string-splitdelim--null-limit--null)

#### $x\_string->tokenize($chars)

[](#x_string-tokenizechars)

#### $x\_string->join($strs = null)

[](#x_string-joinstrs--null)

#### $x\_string->trim($chars = null)

[](#x_string-trimchars--null)

#### $x\_string->rtrim($chars = null)

[](#x_string-rtrimchars--null)

#### $x\_string->ltrim($chars = null)

[](#x_string-ltrimchars--null)

#### $x\_string->lower()

[](#x_string-lower)

#### $x\_string->upper()

[](#x_string-upper)

#### $x\_string->lcfirst()

[](#x_string-lcfirst)

#### $x\_string->lowerFirst()

[](#x_string-lowerfirst)

#### $x\_string->ucfirst()

[](#x_string-ucfirst)

#### $x\_string->upperFirst()

[](#x_string-upperfirst)

#### $x\_string->ucwords()

[](#x_string-ucwords)

#### $x\_string->capitalize()

[](#x_string-capitalize)

#### $x\_string->capitalizeWords()

[](#x_string-capitalizewords)

#### $x\_string->replace($old, $new)

[](#x_string-replaceold-new)

#### $x\_string->replaceAndCount($old, $new)

[](#x_string-replaceandcountold-new)

#### $x\_string->iReplace($old, $new)

[](#x_string-ireplaceold-new)

#### $x\_string->iReplaceAndCount($old, $new)

[](#x_string-ireplaceandcountold-new)

#### $x\_string->replaceMultiple($pairs)

[](#x_string-replacemultiplepairs)

#### $x\_string->translate($old, $new)

[](#x_string-translateold-new)

#### $x\_string->substring($offset, $length = null)

[](#x_string-substringoffset-length--null)

#### $x\_string->replaceSubstring($new, $offset, $length = null)

[](#x_string-replacesubstringnew-offset-length--null)

#### $x\_string->slice($i, $j = null)

[](#x_string-slicei-j--null)

#### $x\_string->replaceSlice($new, $i, $j = null)

[](#x_string-replaceslicenew-i-j--null)

#### $x\_string->insert($new, $offset)

[](#x_string-insertnew-offset)

#### $x\_string->pad($n, $pad = ' ')

[](#x_string-padn-pad---)

#### $x\_string->lpad($n, $pad = ' ')

[](#x_string-lpadn-pad---)

#### $x\_string->rpad($n, $pad = ' ')

[](#x_string-rpadn-pad---)

#### $x\_string->wrap($cols, $sep = "\\n")

[](#x_string-wrapcols-sep--n)

#### $x\_string->repeat($n)

[](#x_string-repeatn)

#### $x\_string->reverse()

[](#x_string-reverse)

#### $x\_string->startingWith($substr)

[](#x_string-startingwithsubstr)

#### $x\_string->iStartingWith($substr)

[](#x_string-istartingwithsubstr)

#### $x\_string->rStartingWith($char)

[](#x_string-rstartingwithchar)

#### $x\_string->startingWithChars($chars)

[](#x_string-startingwithcharschars)

#### $x\_string->preceding($substr)

[](#x_string-precedingsubstr)

#### $x\_string->iPreceding($substr)

[](#x_string-iprecedingsubstr)

#### $x\_string->words($chars = null)

[](#x_string-wordschars--null)

#### $x\_string->wordCount($chars = null)

[](#x_string-wordcountchars--null)

#### $x\_string->findWords($chars = null)

[](#x_string-findwordschars--null)

#### $x\_string->wordWrap($width, $sep = "\\n")

[](#x_string-wordwrapwidth-sep--n)

#### $x\_string->compare($that)

[](#x_string-comparethat)

#### $x\_string->iCompare($that)

[](#x_string-icomparethat)

#### $x\_string->nCompare($that, $n)

[](#x_string-ncomparethat-n)

#### $x\_string->inCompare($that, $n)

[](#x_string-incomparethat-n)

#### $x\_string->localeCompare($that)

[](#x_string-localecomparethat)

#### $x\_string->humanCompare($that)

[](#x_string-humancomparethat)

#### $x\_string->iHumanCompare($that)

[](#x_string-ihumancomparethat)

#### $x\_string->substringCompare($that, $offset, $length)

[](#x_string-substringcomparethat-offset-length)

#### $x\_string->iSubstringCompare($that, $offset, $length)

[](#x_string-isubstringcomparethat-offset-length)

#### $x\_string->contains($substr, $offset = 0)

[](#x_string-containssubstr-offset--0)

#### $x\_string->iContains($substr, $offset = 0)

[](#x_string-icontainssubstr-offset--0)

#### $x\_string->containsChars($chars)

[](#x_string-containscharschars)

#### $x\_string->containsChar($char)

[](#x_string-containscharchar)

#### $x\_string->beginsWith($prefix)

[](#x_string-beginswithprefix)

#### $x\_string->iBeginsWith($prefix)

[](#x_string-ibeginswithprefix)

#### $x\_string->endsWith($suffix)

[](#x_string-endswithsuffix)

#### $x\_string->iEndsWith($suffix)

[](#x_string-iendswithsuffix)

#### $x\_string->removePrefix($prefix)

[](#x_string-removeprefixprefix)

#### $x\_string->iRemovePrefix($prefix)

[](#x_string-iremoveprefixprefix)

#### $x\_string->removeSuffix($suffix)

[](#x_string-removesuffixsuffix)

#### $x\_string->iRemoveSuffix($suffix)

[](#x_string-iremovesuffixsuffix)

#### $x\_string->find($substr, $offset = 0)

[](#x_string-findsubstr-offset--0)

#### $x\_string->iFind($substr, $offset = 0)

[](#x_string-ifindsubstr-offset--0)

#### $x\_string->rFind($substr, $offset = 0)

[](#x_string-rfindsubstr-offset--0)

#### $x\_string->before($substr)

[](#x_string-beforesubstr)

#### $x\_string->after($substr)

[](#x_string-aftersubstr)

#### $x\_string->isLower()

[](#x_string-islower)

#### $x\_string->isUpper()

[](#x_string-isupper)

#### $x\_string->isAlphanumeric()

[](#x_string-isalphanumeric)

#### $x\_string->isAlphabetic()

[](#x_string-isalphabetic)

#### $x\_string->isControl()

[](#x_string-iscontrol)

#### $x\_string->isDecimal()

[](#x_string-isdecimal)

#### $x\_string->isHex()

[](#x_string-ishex)

#### $x\_string->isVisible()

[](#x_string-isvisible)

#### $x\_string->isPrintable()

[](#x_string-isprintable)

#### $x\_string->isPunctuation()

[](#x_string-ispunctuation)

#### $x\_string->isWhitespace()

[](#x_string-iswhitespace)

#### $x\_string->count($substr, $offset = 0, $length = null)

[](#x_string-countsubstr-offset--0-length--null)

#### $x\_string->characterRun($chars, $begin = 0, $end = null)

[](#x_string-characterrunchars-begin--0-end--null)

#### $x\_string->escapeCString()

[](#x_string-escapecstring)

#### $x\_string->unescapeCString()

[](#x_string-unescapecstring)

#### $x\_string->escapePhpString()

[](#x_string-escapephpstring)

#### $x\_string->unescapeBackslashes()

[](#x_string-unescapebackslashes)

#### $x\_string->parseInt($base = null)

[](#x_string-parseintbase--null)

#### $x\_string->parseReal()

[](#x_string-parsereal)

#### $x\_string->encodeHex()

[](#x_string-encodehex)

#### $x\_string->decodeHex()

[](#x_string-decodehex)

#### $x\_string->encodeBase64()

[](#x_string-encodebase64)

#### $x\_string->decodeBase64()

[](#x_string-decodebase64)

#### XString::fromAscii($n)

[](#xstringfromasciin)

#### XString::chr($n)

[](#xstringchrn)

#### $x\_string->toAscii()

[](#x_string-toascii)

#### $x\_string->ord()

[](#x_string-ord)

#### $x\_string->byteCounts()

[](#x_string-bytecounts)

#### $x\_string->unique()

[](#x_string-unique)

#### $x\_string->unusedBytes()

[](#x_string-unusedbytes)

#### $x\_string->encodeHtml($noquote = false)

[](#x_string-encodehtmlnoquote--false)

#### $x\_string->escapeHtml($noquote = false)

[](#x_string-escapehtmlnoquote--false)

#### $x\_string->unencodeHtml()

[](#x_string-unencodehtml)

#### XString::encodeHtmlDict($noquote = false)

[](#xstringencodehtmldictnoquote--false)

#### $x\_string->encodeHtmlEntities()

[](#x_string-encodehtmlentities)

#### XString::encodeHtmlEntitiesDict()

[](#xstringencodehtmlentitiesdict)

#### $x\_string->stripTags()

[](#x_string-striptags)

#### $x\_string->parseRawQueryString()

[](#x_string-parserawquerystring)

#### XString::encodeStandardQueryString($data, $sep = '&')

[](#xstringencodestandardquerystringdata-sep--)

#### XString::encodeQueryString($data, $sep = '&')

[](#xstringencodequerystringdata-sep--)

#### $x\_string->encodeStandardUrl()

[](#x_string-encodestandardurl)

#### $x\_string->decodeStandardUrl()

[](#x_string-decodestandardurl)

#### $x\_string->encodeUrl()

[](#x_string-encodeurl)

#### $x\_string->decodeUrl()

[](#x_string-decodeurl)

#### $x\_string->parseCsv($delim = ',', $quote = '"', $escape = '\\\\')

[](#x_string-parsecsvdelim---quote---escape--)

#### $x\_string->md5()

[](#x_string-md5)

#### $x\_string->md5Hex()

[](#x_string-md5hex)

#### $x\_string->sha1()

[](#x_string-sha1)

#### $x\_string->sha1Hex()

[](#x_string-sha1hex)

#### $x\_string->rot13()

[](#x_string-rot13)

#### $x\_string->shuffle()

[](#x_string-shuffle)

#### $x\_string->formatMoney()

[](#x_string-formatmoney)

#### XString::formatNumber($number, $decimals = 0, $decimal\_point = '.', $thousands\_sep = ',')

[](#xstringformatnumbernumber-decimals--0-decimal_point---thousands_sep--)

#### $x\_string->levenshtein($that, $ins = null, $repl = null, $del = null)

[](#x_string-levenshteinthat-ins--null-repl--null-del--null)

#### $x\_string->splitCamelCase()

[](#x_string-splitcamelcase)

#### $x\_string->pluralize()

[](#x_string-pluralize)

#### XString::capture($callback)

[](#xstringcapturecallback)

### class Jitsu\\XArray

[](#class-jitsuxarray)

An object-oriented wrapper class for the `array` type.

See [jitsu/array](https://github.com/bdusell/jitsu-array).

#### new XArray($value = array())

[](#new-xarrayvalue--array)

Type**`$value`**`array#### $x\_array->\_\_toString()

[](#x_array-__tostring)

Typereturns`string`#### $x\_array->count()

[](#x_array-count)

#### $x\_array->getIterator()

[](#x_array-getiterator)

#### $x\_array->offsetExists($offset)

[](#x_array-offsetexistsoffset)

#### $x\_array->offsetGet($offset)

[](#x_array-offsetgetoffset)

#### $x\_array->offsetSet($offset, $value)

[](#x_array-offsetsetoffset-value)

#### $x\_array->offsetUnset($offset)

[](#x_array-offsetunsetoffset)

#### XArray::unwrap($x)

[](#xarrayunwrapx)

#### $x\_array->join($str = '')

[](#x_array-joinstr--)

#### $x\_array->size()

[](#x_array-size)

#### $x\_array->length()

[](#x_array-length)

#### $x\_array->isEmpty()

[](#x_array-isempty)

#### $x\_array->get($key, $default = null)

[](#x_array-getkey-default--null)

#### $x\_array->getRef($key, $default = null)

[](#x_array-getrefkey-default--null)

#### $x\_array->hasKey($key)

[](#x_array-haskeykey)

#### XArray::normalizeKey($k)

[](#xarraynormalizekeyk)

#### $x\_array->remove($key)

[](#x_array-removekey)

#### $x\_array->keys()

[](#x_array-keys)

#### $x\_array->values()

[](#x_array-values)

#### $x\_array->listValues($keys, $default = null)

[](#x_array-listvalueskeys-default--null)

#### $x\_array->requireValues($keys)

[](#x_array-requirevalueskeys)

#### $x\_array->first()

[](#x_array-first)

#### $x\_array->last()

[](#x_array-last)

#### $x\_array->append($value)

[](#x_array-appendvalue)

#### $x\_array->appendMany($values)

[](#x_array-appendmanyvalues)

#### $x\_array->concat($array)

[](#x_array-concatarray)

#### $x\_array->push($value)

[](#x_array-pushvalue)

#### $x\_array->pop()

[](#x_array-pop)

#### $x\_array->shift()

[](#x_array-shift)

#### $x\_array->unshift($value)

[](#x_array-unshiftvalue)

#### $x\_array->keyOf($value)

[](#x_array-keyofvalue)

#### $x\_array->indexOf($value)

[](#x_array-indexofvalue)

#### $x\_array->keysOf($value)

[](#x_array-keysofvalue)

#### $x\_array->contains($value)

[](#x_array-containsvalue)

#### $x\_array->at($i)

[](#x_array-ati)

#### $x\_array->pairAt($i)

[](#x_array-pairati)

#### $x\_array->keyAt($i)

[](#x_array-keyati)

#### $x\_array->slice($i, $j = null)

[](#x_array-slicei-j--null)

#### $x\_array->pairSlice($i, $j = null)

[](#x_array-pairslicei-j--null)

#### $x\_array->assignSlice($sub, $i, $j = null)

[](#x_array-assignslicesub-i-j--null)

#### $x\_array->removeSlice($i, $j = null)

[](#x_array-removeslicei-j--null)

#### $x\_array->reverse()

[](#x_array-reverse)

#### $x\_array->reversePairs()

[](#x_array-reversepairs)

#### XArray::range($i, $j = null, $step = 1)

[](#xarrayrangei-j--null-step--1)

#### XArray::fromPairs($pairs)

[](#xarrayfrompairspairs)

#### XArray::fromLists($keys, $values)

[](#xarrayfromlistskeys-values)

#### $x\_array->toSet($value = true)

[](#x_array-tosetvalue--true)

#### XArray::fill($value, $n)

[](#xarrayfillvalue-n)

#### $x\_array->pad($value, $n)

[](#x_array-padvalue-n)

#### $x\_array->pluck($key)

[](#x_array-pluckkey)

#### $x\_array->pick($keys)

[](#x_array-pickkeys)

#### $x\_array->getPick($keys, $default = null)

[](#x_array-getpickkeys-default--null)

#### $x\_array->invert()

[](#x_array-invert)

#### $x\_array->extend($array)

[](#x_array-extendarray)

#### $x\_array->deepExtend($array)

[](#x_array-deepextendarray)

#### $x\_array->chunks($n)

[](#x_array-chunksn)

#### $x\_array->map($callback)

[](#x_array-mapcallback)

#### $x\_array->filter($callback = null)

[](#x_array-filtercallback--null)

#### $x\_array->filterPairs($callback)

[](#x_array-filterpairscallback)

#### $x\_array->sum()

[](#x_array-sum)

#### $x\_array->product()

[](#x_array-product)

#### $x\_array->reduce($callback, $initial = null)

[](#x_array-reducecallback-initial--null)

#### $x\_array->apply($callback)

[](#x_array-applycallback)

#### $x\_array->traverseLeaves($callback)

[](#x_array-traverseleavescallback)

#### $x\_array->difference($array, $key\_cmp = null, $value\_cmp = true)

[](#x_array-differencearray-key_cmp--null-value_cmp--true)

#### $x\_array->pairDifference($array, $key\_cmp = null, $value\_cmp = null)

[](#x_array-pairdifferencearray-key_cmp--null-value_cmp--null)

#### $x\_array->keyDifference($array, $key\_cmp = null)

[](#x_array-keydifferencearray-key_cmp--null)

#### $x\_array->valueDifference($array, $value\_cmp = null)

[](#x_array-valuedifferencearray-value_cmp--null)

#### $x\_array->pairIntersection($array, $key\_cmp = null, $value\_cmp = null)

[](#x_array-pairintersectionarray-key_cmp--null-value_cmp--null)

#### $x\_array->keyIntersection($array, $key\_cmp = null)

[](#x_array-keyintersectionarray-key_cmp--null)

#### $x\_array->valueIntersection($array, $value\_cmp = null)

[](#x_array-valueintersectionarray-value_cmp--null)

#### $x\_array->uniqueValues()

[](#x_array-uniquevalues)

#### $x\_array->hasOnlyKeys($keys, &$unexpected = null)

[](#x_array-hasonlykeyskeys-unexpected--null)

#### $x\_array->hasKeys($keys, &$missing = null)

[](#x_array-haskeyskeys-missing--null)

#### $x\_array->hasExactKeys($keys, &$unexpected = null, &$missing = null)

[](#x_array-hasexactkeyskeys-unexpected--null-missing--null)

#### $x\_array->randomKey()

[](#x_array-randomkey)

#### $x\_array->randomValue()

[](#x_array-randomvalue)

#### $x\_array->randomPair()

[](#x_array-randompair)

#### $x\_array->randomKeys($n)

[](#x_array-randomkeysn)

#### $x\_array->shuffle()

[](#x_array-shuffle)

#### $x\_array->sort($value\_cmp = null)

[](#x_array-sortvalue_cmp--null)

#### $x\_array->reverseSort()

[](#x_array-reversesort)

#### $x\_array->localeSort()

[](#x_array-localesort)

#### $x\_array->sortPairs($value\_cmp = null)

[](#x_array-sortpairsvalue_cmp--null)

#### $x\_array->reverseSortPairs()

[](#x_array-reversesortpairs)

#### $x\_array->sortKeys($key\_cmp = null)

[](#x_array-sortkeyskey_cmp--null)

#### $x\_array->reverseSortKeys()

[](#x_array-reversesortkeys)

#### $x\_array->humanSortValues()

[](#x_array-humansortvalues)

#### $x\_array->iHumanSortValues()

[](#x_array-ihumansortvalues)

#### $x\_array->lowerKeys()

[](#x_array-lowerkeys)

#### $x\_array->upperKeys()

[](#x_array-upperkeys)

#### $x\_array->isSequential()

[](#x_array-issequential)

#### $x\_array->isAssociative()

[](#x_array-isassociative)

#### $x\_array->looksSequential()

[](#x_array-lookssequential)

#### $x\_array->looksAssociative()

[](#x_array-looksassociative)

#### $x\_array->countValues()

[](#x_array-countvalues)

### class Jitsu\\XRegex

[](#class-jitsuxregex)

An object-oriented wrapper for PHP's PCRE patterns.

See [jitsu/regex](https://github.com/bdusell/jitsu-regex).

#### new XRegex($arg, $flags = '', $start = null, $end = null)

[](#new-xregexarg-flags---start--null-end--null)

TypeDescription**`$arg`**`string\\Jitsu\\XString**`$flags`**`string\\Jitsu\\XString`**`$start`**`string\\Jitsu\\XString**`$start`**`string\\Jitsu\\XString#### $x\_regex->\_\_toString()

[](#x_regex-__tostring)

#### $x\_regex->match($str, $offset = 0)

[](#x_regex-matchstr-offset--0)

#### $x\_regex->matchWithOffsets($str, $offset = 0)

[](#x_regex-matchwithoffsetsstr-offset--0)

#### $x\_regex->matchAll($str, $offset = 0)

[](#x_regex-matchallstr-offset--0)

#### $x\_regex->matchAllWithOffsets($str, $offset = 0)

[](#x_regex-matchallwithoffsetsstr-offset--0)

#### XRegex::escape($str, $delim = null)

[](#xregexescapestr-delim--null)

#### $x\_regex->replace($str, $replacement, $limit = null)

[](#x_regex-replacestr-replacement-limit--null)

#### $x\_regex->replaceAndCount($str, $replacement, $limit = null)

[](#x_regex-replaceandcountstr-replacement-limit--null)

#### $x\_regex->replaceWith($str, $callback, $limit = null)

[](#x_regex-replacewithstr-callback-limit--null)

#### $x\_regex->replaceAndCountWith($str, $callback, $limit = null)

[](#x_regex-replaceandcountwithstr-callback-limit--null)

#### $x\_regex->replaceAndFilter($str, $replacement, $limit = null)

[](#x_regex-replaceandfilterstr-replacement-limit--null)

#### $x\_regex->replaceAndFilterAndCount($str, $replacement, $limit = null)

[](#x_regex-replaceandfilterandcountstr-replacement-limit--null)

#### $x\_regex->grep($strs)

[](#x_regex-grepstrs)

#### $x\_regex->invertedGrep($strs)

[](#x_regex-invertedgrepstrs)

#### $x\_regex->split($str, $limit = null)

[](#x_regex-splitstr-limit--null)

#### $x\_regex->splitWithOffsets($str, $limit = null)

[](#x_regex-splitwithoffsetsstr-limit--null)

#### $x\_regex->splitAndFilter($str, $limit = null)

[](#x_regex-splitandfilterstr-limit--null)

#### $x\_regex->splitAndFilterWithOffsets($str, $limit = null)

[](#x_regex-splitandfilterwithoffsetsstr-limit--null)

#### $x\_regex->inclusiveSplit($str, $limit = null)

[](#x_regex-inclusivesplitstr-limit--null)

#### $x\_regex->inclusiveSplitWithOffsets($str, $limit = null)

[](#x_regex-inclusivesplitwithoffsetsstr-limit--null)

###  Health Score

23

—

LowBetter than 27% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity8

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity50

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~116 days

Total

3

Last Release

3664d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/cca83b66140c874bd446e8cfb132f5c1d4e4747a2a58f465b47d2b618e27ff1c?d=identicon)[bdusell](/maintainers/bdusell)

---

Top Contributors

[![bdusell](https://avatars.githubusercontent.com/u/5336190?v=4)](https://github.com/bdusell "bdusell (10 commits)")

---

Tags

arraymethod-chainingoopphpregexregular-expressionstringweb-developmentarraystringutilityregexwrapperpregchaining

### Embed Badge

![Health badge](/badges/jitsu-wrap/health.svg)

```
[![Health](https://phpackages.com/badges/jitsu-wrap/health.svg)](https://phpackages.com/packages/jitsu-wrap)
```

###  Alternatives

[nette/utils

🛠 Nette Utils: lightweight utilities for string & array manipulation, image handling, safe JSON encoding/decoding, validation, slug or strong password generating etc.

2.1k394.3M1.5k](/packages/nette-utils)[danielstjules/stringy

A string manipulation library with multibyte support

2.4k26.0M191](/packages/danielstjules-stringy)[composer/pcre

PCRE wrapping library that offers type-safe preg\_\* replacements.

699313.8M34](/packages/composer-pcre)[voku/arrayy

Array manipulation library for PHP, called Arrayy!

4875.5M16](/packages/voku-arrayy)[bocharsky-bw/arrayzy

A native PHP arrays easy manipulation library in OOP way.

38425.4k](/packages/bocharsky-bw-arrayzy)[voku/stringy

A string manipulation library with multibyte support

1783.8M19](/packages/voku-stringy)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)