cssesc-source 0.1.0

data/vendor/node_modules/grunt/node_modules/rimraf/node_modules/graceful-fs/package.json

@@ -0,0 +1,40 @@
+{
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "name": "graceful-fs",
+  "description": "fs monkey-patching to avoid EMFILE and other problems",
+  "version": "1.1.14",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-graceful-fs.git"
+  },
+  "main": "graceful-fs.js",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "keywords": [
+    "fs",
+    "EMFILE",
+    "error",
+    "handling",
+    "monkeypatch"
+  ],
+  "license": "BSD",
+  "readme": "Just like node's `fs` module, but it does an incremental back-off when\nEMFILE is encountered.\n\nUseful in asynchronous situations where one needs to try to open lots\nand lots of files.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/node-graceful-fs/issues"
+  },
+  "homepage": "https://github.com/isaacs/node-graceful-fs",
+  "_id": "graceful-fs@1.1.14",
+  "_from": "graceful-fs@~1.1"
+}

data/vendor/node_modules/grunt/node_modules/rimraf/node_modules/graceful-fs/test/open.js

@@ -0,0 +1,41 @@
+var test = require('tap').test
+var fs = require('../graceful-fs.js')
+
+test('open an existing file works', function (t) {
+  var start = fs._curOpen
+  var fd = fs.openSync(__filename, 'r')
+  t.equal(fs._curOpen, start + 1)
+  fs.closeSync(fd)
+  t.equal(fs._curOpen, start)
+  fs.open(__filename, 'r', function (er, fd) {
+    if (er) throw er
+    t.equal(fs._curOpen, start + 1)
+    fs.close(fd, function (er) {
+      if (er) throw er
+      t.equal(fs._curOpen, start)
+      t.end()
+    })
+  })
+})
+
+test('open a non-existing file throws', function (t) {
+  var start = fs._curOpen
+  var er
+  try {
+    var fd = fs.openSync('this file does not exist', 'r')
+  } catch (x) {
+    er = x
+  }
+  t.ok(er, 'should throw')
+  t.notOk(fd, 'should not get an fd')
+  t.equal(er.code, 'ENOENT')
+  t.equal(fs._curOpen, start)
+
+  fs.open('neither does this file', 'r', function (er, fd) {
+    t.ok(er, 'should throw')
+    t.notOk(fd, 'should not get an fd')
+    t.equal(er.code, 'ENOENT')
+    t.equal(fs._curOpen, start)
+    t.end()
+  })
+})

data/vendor/node_modules/grunt/node_modules/rimraf/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "rimraf",
+  "version": "2.0.3",
+  "main": "rimraf.js",
+  "description": "A deep deletion module for node (like `rm -rf`)",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/isaacs/rimraf/raw/master/LICENSE"
+  },
+  "optionalDependencies": {
+    "graceful-fs": "~1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/rimraf.git"
+  },
+  "scripts": {
+    "test": "cd test && bash run.sh"
+  },
+  "contributors": [
+    {
+      "name": "Isaac Z. Schlueter",
+      "email": "i@izs.me",
+      "url": "http://blog.izs.me"
+    },
+    {
+      "name": "Wayne Larsen",
+      "email": "wayne@larsen.st",
+      "url": "http://github.com/wvl"
+    },
+    {
+      "name": "ritch",
+      "email": "skawful@gmail.com"
+    },
+    {
+      "name": "Marcel Laverdet"
+    },
+    {
+      "name": "Yosef Dinerstein",
+      "email": "yosefd@microsoft.com"
+    }
+  ],
+  "readme": "A `rm -rf` for node.\n\nInstall with `npm install rimraf`, or just drop rimraf.js somewhere.\n\n## API\n\n`rimraf(f, callback)`\n\nThe callback will be called with an error if there is one.  Certain\nerrors are handled for you:\n\n* `EBUSY` -  rimraf will back off a maximum of opts.maxBusyTries times\n  before giving up.\n* `EMFILE` - If too many file descriptors get opened, rimraf will\n  patiently wait until more become available.\n\n\n## rimraf.sync\n\nIt can remove stuff synchronously, too.  But that's not so good.  Use\nthe async API.  It's better.\n",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/isaacs/rimraf/issues"
+  },
+  "homepage": "https://github.com/isaacs/rimraf",
+  "dependencies": {
+    "graceful-fs": "~1.1"
+  },
+  "_id": "rimraf@2.0.3",
+  "_from": "rimraf@~2.0.3"
+}

data/vendor/node_modules/grunt/node_modules/rimraf/rimraf.js

@@ -0,0 +1,161 @@
+module.exports = rimraf
+rimraf.sync = rimrafSync
+
+var path = require("path")
+  , fs
+
+try {
+  // optional dependency
+  fs = require("graceful-fs")
+} catch (er) {
+  fs = require("fs")
+}
+
+var lstat = "lstat"
+if (process.platform === "win32") {
+  // not reliable on windows prior to 0.7.9
+  var v = process.version.replace(/^v/, '').split(/\.|-/).map(Number)
+  if (v[0] === 0 && (v[1] < 7 || v[1] == 7 && v[2] < 9)) {
+    lstat = "stat"
+  }
+}
+if (!fs[lstat]) lstat = "stat"
+var lstatSync = lstat + "Sync"
+
+// for EMFILE handling
+var timeout = 0
+exports.EMFILE_MAX = 1000
+exports.BUSYTRIES_MAX = 3
+
+function rimraf (p, cb) {
+
+  if (!cb) throw new Error("No callback passed to rimraf()")
+
+  var busyTries = 0
+
+  rimraf_(p, function CB (er) {
+    if (er) {
+      if (er.code === "EBUSY" && busyTries < exports.BUSYTRIES_MAX) {
+        busyTries ++
+        var time = busyTries * 100
+        // try again, with the same exact callback as this one.
+        return setTimeout(function () {
+          rimraf_(p, CB)
+        }, time)
+      }
+
+      // this one won't happen if graceful-fs is used.
+      if (er.code === "EMFILE" && timeout < exports.EMFILE_MAX) {
+        return setTimeout(function () {
+          rimraf_(p, CB)
+        }, timeout ++)
+      }
+
+      // already gone
+      if (er.code === "ENOENT") er = null
+    }
+
+    timeout = 0
+    cb(er)
+  })
+}
+
+function rimraf_ (p, cb) {
+  fs[lstat](p, function (er, s) {
+    if (er) {
+      // already gone
+      if (er.code === "ENOENT") return cb()
+      // some other kind of error, permissions, etc.
+      return cb(er)
+    }
+
+    return rm_(p, s, false, cb)
+  })
+}
+
+
+var myGid = function myGid () {
+  var g = process.getgid && process.getgid()
+  myGid = function myGid () { return g }
+  return g
+}
+
+var myUid = function myUid () {
+  var u = process.getuid && process.getuid()
+  myUid = function myUid () { return u }
+  return u
+}
+
+
+function writable (s) {
+  var mode = s.mode || 0777
+    , uid = myUid()
+    , gid = myGid()
+  return (mode & 0002)
+      || (gid === s.gid && (mode & 0020))
+      || (uid === s.uid && (mode & 0200))
+}
+
+function rm_ (p, s, didWritableCheck, cb) {
+  if (!didWritableCheck && !writable(s)) {
+    // make file writable
+    // user/group/world, doesn't matter at this point
+    // since it's about to get nuked.
+    return fs.chmod(p, s.mode | 0222, function (er) {
+      if (er) return cb(er)
+      rm_(p, s, true, cb)
+    })
+  }
+
+  if (!s.isDirectory()) {
+    return fs.unlink(p, cb)
+  }
+
+  // directory
+  fs.readdir(p, function (er, files) {
+    if (er) return cb(er)
+    asyncForEach(files.map(function (f) {
+      return path.join(p, f)
+    }), function (file, cb) {
+      rimraf(file, cb)
+    }, function (er) {
+      if (er) return cb(er)
+      fs.rmdir(p, cb)
+    })
+  })
+}
+
+function asyncForEach (list, fn, cb) {
+  if (!list.length) cb()
+  var c = list.length
+    , errState = null
+  list.forEach(function (item, i, list) {
+    fn(item, function (er) {
+      if (errState) return
+      if (er) return cb(errState = er)
+      if (-- c === 0) return cb()
+    })
+  })
+}
+
+// this looks simpler, but it will fail with big directory trees,
+// or on slow stupid awful cygwin filesystems
+function rimrafSync (p) {
+  try {
+    var s = fs[lstatSync](p)
+  } catch (er) {
+    if (er.code === "ENOENT") return
+    throw er
+  }
+
+  if (!writable(s)) {
+    fs.chmodSync(p, s.mode | 0222)
+  }
+
+  if (!s.isDirectory()) return fs.unlinkSync(p)
+
+  fs.readdirSync(p).forEach(function (f) {
+    rimrafSync(path.join(p, f))
+  })
+  fs.rmdirSync(p)
+}

data/vendor/node_modules/grunt/node_modules/rimraf/test/run.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+for i in test-*.js; do
+  echo -n $i ...
+  bash setup.sh
+  node $i
+  ! [ -d target ]
+  echo "pass"
+done
+rm -rf target

data/vendor/node_modules/grunt/node_modules/rimraf/test/setup.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+set -e
+
+files=10
+folders=2
+depth=4
+target="$PWD/target"
+
+rm -rf target
+
+fill () {
+  local depth=$1
+  local files=$2
+  local folders=$3
+  local target=$4
+
+  if ! [ -d $target ]; then
+    mkdir -p $target
+  fi
+
+  local f
+
+  f=$files
+  while [ $f -gt 0 ]; do
+    touch "$target/f-$depth-$f"
+    let f--
+  done
+
+  let depth--
+
+  if [ $depth -le 0 ]; then
+    return 0
+  fi
+
+  f=$folders
+  while [ $f -gt 0 ]; do
+    mkdir "$target/folder-$depth-$f"
+    fill $depth $files $folders "$target/d-$depth-$f"
+    let f--
+  done
+}
+
+fill $depth $files $folders $target
+
+# sanity assert
+[ -d $target ]

data/vendor/node_modules/grunt/node_modules/rimraf/test/test-async.js

@@ -0,0 +1,5 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf(path.join(__dirname, "target"), function (er) {
+  if (er) throw er
+})

data/vendor/node_modules/grunt/node_modules/rimraf/test/test-sync.js

@@ -0,0 +1,3 @@
+var rimraf = require("../rimraf")
+  , path = require("path")
+rimraf.sync(path.join(__dirname, "target"))

data/vendor/node_modules/grunt/node_modules/underscore.string/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'serve'
+gem 'uglifier'
+gem 'rake'

data/vendor/node_modules/grunt/node_modules/underscore.string/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    execjs (1.3.0)
+      multi_json (~> 1.0)
+    i18n (0.6.0)
+    multi_json (1.2.0)
+    rack (1.4.1)
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rake (0.9.2.2)
+    serve (1.5.1)
+      activesupport (~> 3.0)
+      i18n
+      rack (~> 1.2)
+      rack-test (~> 0.5)
+      tilt (~> 1.3)
+      tzinfo
+    tilt (1.3.3)
+    tzinfo (0.3.33)
+    uglifier (1.2.4)
+      execjs (>= 0.3.0)
+      multi_json (>= 1.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  serve
+  uglifier

data/vendor/node_modules/grunt/node_modules/underscore.string/README.markdown

@@ -0,0 +1,668 @@
+# Underscore.string [![Build Status](https://secure.travis-ci.org/epeli/underscore.string.png?branch=master)](http://travis-ci.org/epeli/underscore.string) #
+
+
+
+Javascript lacks complete string manipulation operations.
+This an attempt to fill that gap. List of build-in methods can be found
+for example from [Dive Into JavaScript][d].
+
+[d]: http://www.diveintojavascript.com/core-javascript-reference/the-string-object
+
+
+As name states this an extension for [Underscore.js][u], but it can be used
+independently from **_s**-global variable. But with Underscore.js you can
+use Object-Oriented style and chaining:
+
+[u]: http://documentcloud.github.com/underscore/
+
+```javascript
+_("   epeli  ").chain().trim().capitalize().value()
+=> "Epeli"
+```
+
+## Download ##
+
+  * [Development version](https://raw.github.com/epeli/underscore.string/master/lib/underscore.string.js) *Uncompressed with Comments 18kb*
+  * [Production version](https://github.com/epeli/underscore.string/raw/master/dist/underscore.string.min.js) *Minified 7kb*
+
+
+## Node.js installation ##
+
+**npm package**
+
+    npm install underscore.string
+
+**Standalone usage**:
+
+```javascript
+var _s = require('underscore.string');
+```
+
+**Integrate with Underscore.js**:
+
+```javascript
+var _  = require('underscore');
+
+// Import Underscore.string to separate object, because there are conflict functions (include, reverse, contains)
+_.str = require('underscore.string');
+
+// Mix in non-conflict functions to Underscore namespace if you want
+_.mixin(_.str.exports());
+
+// All functions, include conflict, will be available through _.str object
+_.str.include('Underscore.string', 'string'); // => true
+```
+
+## String Functions ##
+
+For availability of functions in this way you need to mix in Underscore.string functions:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+otherwise functions from examples will be available through _.string or _.str objects:
+
+```javascript
+_.str.capitalize('epeli')
+=> "Epeli"
+```
+
+**capitalize** _.capitalize(string)
+
+Converts first letter of the string to uppercase.
+
+```javascript
+_.capitalize("foo Bar")
+=> "Foo Bar"
+```
+
+**chop** _.chop(string, step)
+
+```javascript
+_.chop('whitespace', 3)
+=> ['whi','tes','pac','e']
+```
+
+**clean** _.clean(str)
+
+Compress some whitespaces to one.
+
+```javascript
+_.clean(" foo    bar   ")
+=> 'foo bar'
+```
+
+**chars** _.chars(str)
+
+```javascript
+_.chars('Hello')
+=> ['H','e','l','l','o']
+```
+
+**includes** _.includes(string, substring)
+
+Tests if string contains a substring.
+
+```javascript
+_.includes("foobar", "ob")
+=> true
+```
+
+**include** available only through _.str object, because Underscore has function with the same name.
+
+```javascript
+_.str.include("foobar", "ob")
+=> true
+```
+
+**includes** function was removed
+
+But you can create it in this way, for compatibility with previous versions:
+
+```javascript
+_.includes = _.str.include
+```
+
+**count** _.count(string, substring)
+
+```javascript
+_('Hello world').count('l')
+=> 3
+```
+
+**escapeHTML** _.escapeHTML(string)
+
+Converts HTML special characters to their entity equivalents.
+
+```javascript
+_('<div>Blah blah blah</div>').escapeHTML();
+=> '&lt;div&gt;Blah blah blah&lt;/div&gt;'
+```
+
+**unescapeHTML** _.unescapeHTML(string)
+
+Converts entity characters to HTML equivalents.
+
+```javascript
+_('&lt;div&gt;Blah blah blah&lt;/div&gt;').unescapeHTML();
+=> '<div>Blah blah blah</div>'
+```
+
+**insert** _.insert(string, index, substing)
+
+```javascript
+_('Hello ').insert(6, 'world')
+=> 'Hello world'
+```
+
+**isBlank** _.isBlank(string)
+
+```javascript
+_('').isBlank(); // => true
+_('\n').isBlank(); // => true
+_(' ').isBlank(); // => true
+_('a').isBlank(); // => false
+```
+
+**join** _.join(separator, *strings)
+
+Joins strings together with given separator
+
+```javascript
+_.join(" ", "foo", "bar")
+=> "foo bar"
+```
+
+**lines** _.lines(str)
+
+```javascript
+_.lines("Hello\nWorld")
+=> ["Hello", "World"]
+```
+
+**reverse** available only through _.str object, because Underscore has function with the same name.
+
+Return reversed string:
+
+```javascript
+_.str.reverse("foobar")
+=> 'raboof'
+```
+
+**splice**  _.splice(string, index, howmany, substring)
+
+Like a array splice.
+
+```javascript
+_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')
+=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'
+```
+
+**startsWith** _.startsWith(string, starts)
+
+This method checks whether string starts with starts.
+
+```javascript
+_("image.gif").startsWith("image")
+=> true
+```
+
+**endsWith** _.endsWith(string, ends)
+
+This method checks whether string ends with ends.
+
+```javascript
+_("image.gif").endsWith("gif")
+=> true
+```
+
+**succ**  _.succ(str)
+
+Returns the successor to str.
+
+```javascript
+_('a').succ()
+=> 'b'
+
+_('A').succ()
+=> 'B'
+```
+
+**supplant**
+
+Supplant function was removed, use Underscore.js [template function][p].
+
+[p]: http://documentcloud.github.com/underscore/#template
+
+**strip** alias for *trim*
+
+**lstrip** alias for *ltrim*
+
+**rstrip** alias for *rtrim*
+
+**titleize** _.titleize(string)
+
+```javascript
+_('my name is epeli').titleize()
+=> 'My Name Is Epeli'
+```
+
+**camelize** _.camelize(string)
+
+Converts underscored or dasherized string to a camelized one
+
+```javascript
+_('-moz-transform').camelize()
+=> 'MozTransform'
+```
+
+**classify** _.classify(string)
+
+Converts string to camelized class name
+
+```javascript
+_('some_class_name').classify()
+=> 'SomeClassName'
+```
+
+**underscored** _.underscored(string)
+
+Converts a camelized or dasherized string into an underscored one
+
+```javascript
+_('MozTransform').underscored()
+=> 'moz_transform'
+```
+
+**dasherize** _.dasherize(string)
+
+Converts a underscored or camelized string into an dasherized one
+
+```javascript
+_('MozTransform').dasherize()
+=> '-moz-transform'
+```
+
+**humanize** _.humanize(string)
+
+Converts an underscored, camelized, or dasherized string into a humanized one.
+Also removes beginning and ending whitespace, and removes the postfix '_id'.
+
+```javascript
+_('  capitalize dash-CamelCase_underscore trim  ').humanize()
+=> 'Capitalize dash camel case underscore trim'
+```
+
+**trim** _.trim(string, [characters])
+
+trims defined characters from begining and ending of the string.
+Defaults to whitespace characters.
+
+```javascript
+_.trim("  foobar   ")
+=> "foobar"
+
+_.trim("_-foobar-_", "_-")
+=> "foobar"
+```
+
+
+**ltrim** _.ltrim(string, [characters])
+
+Left trim. Similar to trim, but only for left side.
+
+
+**rtrim** _.rtrim(string, [characters])
+
+Right trim. Similar to trim, but only for right side.
+
+**truncate** _.truncate(string, length, truncateString)
+
+```javascript
+_('Hello world').truncate(5)
+=> 'Hello...'
+
+_('Hello').truncate(10)
+=> 'Hello'
+```
+
+**prune** _.prune(string, length, pruneString)
+
+Elegant version of truncate.
+Makes sure the pruned string does not exceed the original length.
+Avoid half-chopped words when truncating.
+
+```javascript
+_('Hello, world').prune(5)
+=> 'Hello...'
+
+_('Hello, world').prune(8)
+=> 'Hello...'
+
+_('Hello, world').prune(5, ' (read a lot more)')
+=> 'Hello, world' (as adding "(read a lot more)" would be longer than the original string)
+
+_('Hello, cruel world').prune(15)
+=> 'Hello, cruel...'
+
+_('Hello').prune(10)
+=> 'Hello'
+```
+
+**words** _.words(str, delimiter=" ")
+
+Split string by delimiter (String or RegExp), ' ' by default.
+
+```javascript
+_.words("I love you")
+=> ["I","love","you"]
+
+_.words("I_love_you", "_")
+=> ["I","love","you"]
+
+_.words("I-love-you", /-/)
+=> ["I","love","you"]
+```
+
+**sprintf** _.sprintf(string format, *arguments)
+
+C like string formatting.
+Credits goes to [Alexandru Marasteanu][o].
+For more detailed documentation, see the [original page][o].
+
+[o]: http://www.diveintojavascript.com/projects/sprintf-for-javascript
+
+```javascript
+_.sprintf("%.1f", 1.17)
+"1.2"
+```
+
+**pad** _.pad(str, length, [padStr, type])
+
+pads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`" "`). `padStr` is truncated to a single character if necessary.
+
+```javascript
+_.pad("1", 8)
+-> "       1";
+
+_.pad("1", 8, '0')
+-> "00000001";
+
+_.pad("1", 8, '0', 'right')
+-> "10000000";
+
+_.pad("1", 8, '0', 'both')
+-> "00001000";
+
+_.pad("1", 8, 'bleepblorp', 'both')
+-> "bbbb1bbb";
+```
+
+**lpad** _.lpad(str, length, [padStr])
+
+left-pad a string. Alias for `pad(str, length, padStr, 'left')`
+
+```javascript
+_.lpad("1", 8, '0')
+-> "00000001";
+```
+
+**rpad** _.rpad(str, length, [padStr])
+
+right-pad a string. Alias for `pad(str, length, padStr, 'right')`
+
+```javascript
+_.rpad("1", 8, '0')
+-> "10000000";
+```
+
+**lrpad** _.lrpad(str, length, [padStr])
+
+left/right-pad a string. Alias for `pad(str, length, padStr, 'both')`
+
+```javascript
+_.lrpad("1", 8, '0')
+-> "00001000";
+```
+
+**center** alias for **lrpad**
+
+**ljust** alias for *rpad*
+
+**rjust** alias for *lpad*
+
+**toNumber**  _.toNumber(string, [decimals])
+
+Parse string to number. Returns NaN if string can't be parsed to number.
+
+```javascript
+_('2.556').toNumber()
+=> 3
+
+_('2.556').toNumber(1)
+=> 2.6
+```
+
+**strRight**  _.strRight(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRight('_')
+=> "is_a_test_string";
+```
+
+**strRightBack**  _.strRightBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRightBack('_')
+=> "string";
+```
+
+**strLeft**  _.strLeft(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeft('_')
+=> "This";
+```
+
+**strLeftBack**  _.strLeftBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeftBack('_')
+=> "This_is_a_test";
+```
+
+**stripTags**
+
+Removes all html tags from string.
+
+```javascript
+_('a <a href="#">link</a>').stripTags()
+=> 'a link'
+
+_('a <a href="#">link</a><script>alert("hello world!")</script>').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence**  _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+## Changelog ##
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+    includeString: _.str.include,
+    reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+
+*  Esa-Matti Suuronen <esa-matti@suuronen.org> (<http://esa-matti.suuronen.org/>),
+*  Edward Tsech <edtsech@gmail.com>,
+*  Sasha Koss <kossnocorp@gmail.com> (<http://koss.nocorp.me/>),
+*  Vladimir Dronnikov <dronnikov@gmail.com>,
+*  Pete Kruckenberg (<https://github.com/kruckenb>),
+*  Paul Chavard <paul@chavard.net> (<http://tchak.net>),
+*  Ed Finkler <coj@funkatron.com> (<http://funkatron.com>)
+*  Pavel Pravosud <rwz@duckroll.ru>
+*  Anton Lindqvist <anton@qvister.se> (<http://qvister.se>)
+
+## Licence ##
+
+The MIT License
+
+Copyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.