cssesc-source 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjcxZDUwMWEzMmI0NDQwYmE5MWM2OTNmNTVjMTEzYWM0MWVjMTAwYg==
+  data.tar.gz: !binary |-
+    YzdiNThjODZjYzVmNWUyZmNkZmNlNTJkN2FjNjAzNzAyNWFmOGQ5Zg==
+SHA512:
+  metadata.gz: !binary |-
+    MTc5ZjdkZDEzYzEwMGFjNmQwYWY5MzYyOWRkMWIwNTAxN2ZmZmRiYzUyNDUw
+    YjdkZDVjZjNiNTkzZDUzYzk5NjU4NzlkMTkzZjYyZDgyODc0ZGNkNWZiOTA5
+    ZDdlNDk1ZGVhNDVkOTk0YzQ5YTlkYzU0ZjQ3MmFlMzEyNDljZjM=
+  data.tar.gz: !binary |-
+    NmUxYjdjYWFlMmQyN2MyYjVkZjBiNzI4YTJiZTJhOTQ0MTk0NjlkZDcwYmZj
+    MmVmOTkzZDY0MTJkNmQ5NmQ5NWIxY2EzZDZjMzM3MjY1MzZjZDQwM2U0YjQ5
+    Mjc2ZDUxNTEyZGY0YmM5YzcxZDliZWI1NzIyY2Q4M2NjNWUzMmU=

data/lib/cssesc/source.rb

@@ -0,0 +1,7 @@
+module CSSEsc
+  module Source
+    def self.bundled_path
+      File.expand_path("../../../vendor/cssesc.js", __FILE__)
+    end
+  end
+end

data/vendor/LICENSE-MIT.txt

@@ -0,0 +1,20 @@
+Copyright Mathias Bynens <http://mathiasbynens.be/>
+
+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.

data/vendor/README.md

@@ -0,0 +1,207 @@
+# cssesc [![Build status](https://travis-ci.org/mathiasbynens/cssesc.png?branch=master)](https://travis-ci.org/mathiasbynens/cssesc) [![Dependency status](https://gemnasium.com/mathiasbynens/cssesc.png)](https://gemnasium.com/mathiasbynens/cssesc)
+
+A JavaScript library for escaping CSS strings and identifiers while generating the shortest possible ASCII-only output.
+
+This is a JavaScript library for [escaping text for use in CSS strings or identifiers](http://mathiasbynens.be/notes/css-escapes) while generating the shortest possible valid ASCII-only output. [Here’s an online demo.](http://mothereff.in/css-escapes)
+
+Feel free to fork if you see possible improvements!
+
+## Installation
+
+Via [Bower](http://bower.io/):
+
+```bash
+bower install cssesc
+```
+
+Via [Component](https://github.com/component/component):
+
+```bash
+component install mathiasbynens/cssesc
+```
+
+Via [npm](http://npmjs.org/):
+
+```bash
+npm install cssesc
+```
+
+In a browser:
+
+```html
+<script src="cssesc.js"></script>
+```
+
+In [Node.js](http://nodejs.org/) and [RingoJS](http://ringojs.org/):
+
+```js
+var cssesc = require('cssesc');
+```
+
+In [Narwhal](http://narwhaljs.org/):
+
+```js
+var cssesc = require('cssesc').cssesc;
+```
+
+In [Rhino](http://www.mozilla.org/rhino/):
+
+```js
+load('cssesc.js');
+```
+
+Using an AMD loader like [RequireJS](http://requirejs.org/):
+
+```js
+require(
+  {
+    'paths': {
+      'cssesc': 'path/to/cssesc'
+    }
+  },
+  ['cssesc'],
+  function(cssesc) {
+    console.log(cssesc);
+  }
+);
+```
+
+## API
+
+### `cssesc(value, options)`
+
+This function takes a value and returns an escaped version of the value where any characters that are not printable ASCII symbols are escaped using the shortest possible (but valid) [escape sequences for use in CSS strings or identifiers](http://mathiasbynens.be/notes/css-escapes).
+
+```js
+cssesc('Ich ♥ Bücher');
+// → 'Ich \\2665  B\\FC cher'
+
+cssesc('foo 𝌆 bar');
+// → 'foo \\1D306  bar'
+```
+
+By default, `cssesc` returns a string that can be used as part of a CSS string. If the target is a CSS identifier rather than a CSS string, use the `isIdentifier: true` setting (see below).
+
+The optional `options` argument accepts an object with the following options:
+
+#### `isIdentifier`
+
+The default value for the `isIdentifier` option is `false`. This means that the input text will be escaped for use in a CSS string literal. If you want to use the result as a CSS identifier instead (in a selector, for example), set this option to `true`.
+
+```js
+cssesc('123a2b');
+// → '123a2b'
+
+cssesc('123a2b', {
+  'isIdentifier': true
+});
+// → '\\31 23a2b'
+```
+
+#### `quotes`
+
+The default value for the `quotes` option is `'single'`. This means that any occurences of `'` in the input text will be escaped as `\'`, so that the output can be used in a CSS string literal wrapped in single quotes.
+
+```js
+cssesc('Lorem ipsum "dolor" sit \'amet\' etc.');
+// → 'Lorem ipsum "dolor" sit \\\'amet\\\' etc.'
+// → "Lorem ipsum \"dolor\" sit \\'amet\\' etc."
+
+cssesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'single'
+});
+// → 'Lorem ipsum "dolor" sit \\\'amet\\\' etc.'
+// → "Lorem ipsum \"dolor\" sit \\'amet\\' etc."
+```
+
+If you want to use the output as part of a CSS string literal wrapped in double quotes, set the `quotes` option to `'double'`.
+
+```js
+cssesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'double'
+});
+// → 'Lorem ipsum \\"dolor\\" sit \'amet\' etc.'
+// → "Lorem ipsum \\\"dolor\\\" sit 'amet' etc."
+```
+
+#### `wrap`
+
+The `wrap` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, the output will be a valid CSS string literal wrapped in quotes. The type of quotes can be specified through the `quotes` setting.
+
+```js
+cssesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'single',
+  'wrap': true
+});
+// → '\'Lorem ipsum "dolor" sit \\\'amet\\\' etc.\''
+// → "\'Lorem ipsum \"dolor\" sit \\\'amet\\\' etc.\'"
+
+cssesc('Lorem ipsum "dolor" sit \'amet\' etc.', {
+  'quotes': 'double',
+  'wrap': true
+});
+// → '"Lorem ipsum \\"dolor\\" sit \'amet\' etc."'
+// → "\"Lorem ipsum \\\"dolor\\\" sit \'amet\' etc.\""
+```
+
+#### `escapeEverything`
+
+The `escapeEverything` option takes a boolean value (`true` or `false`), and defaults to `false` (disabled). When enabled, all the symbols in the output will be escaped, even printable ASCII symbols.
+
+```js
+cssesc('lolwat"foo\'bar', {
+  'escapeEverything': true
+});
+// → '\\6C\\6F\\6C\\77\\61\\74\\"\\66\\6F\\6F\\\'\\62\\61\\72'
+// → "\\6C\\6F\\6C\\77\\61\\74\\\"\\66\\6F\\6F\\'\\62\\61\\72"
+```
+
+### `cssesc.version`
+
+A string representing the semantic version number.
+
+### Using the `cssesc` binary
+
+To use the `cssesc` binary in your shell, simply install cssesc globally using npm:
+
+```bash
+npm install -g cssesc
+```
+
+After that you will be able to escape text for use in CSS strings or identifiers from the command line:
+
+```bash
+$ cssesc 'föo ♥ bår 𝌆 baz'
+f\F6o \2665  b\E5r \1D306  baz
+```
+
+If the output needs to be a CSS identifier rather than part of a string literal, use the `-i`/`--identifier` option:
+
+```bash
+$ cssesc --identifier 'föo ♥ bår 𝌆 baz'
+f\F6o\ \2665\ b\E5r\ \1D306\ baz
+```
+
+See `cssesc --help` for the full list of options.
+
+## Support
+
+This library has been tested in at least Chrome 28-30, Firefox 3-23, Safari 4-6, Opera 10-15, IE 6-10, Node.js v0.10.0, Narwhal 0.3.2, RingoJS 0.8-0.9, PhantomJS 1.9.0, and Rhino 1.7RC4.
+
+## Unit tests & code coverage
+
+After cloning this repository, run `npm install` to install the dependencies needed for development and testing. You may want to install Istanbul _globally_ using `npm install istanbul -g`.
+
+Once that’s done, you can run the unit tests in Node using `npm test` or `node tests/tests.js`. To run the tests in Rhino, Ringo, Narwhal, and web browsers as well, use `grunt test`.
+
+To generate [the code coverage report](http://rawgithub.com/mathiasbynens/cssesc/master/coverage/cssesc/cssesc.js.html), use `grunt cover`.
+
+## Author
+
+| [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](http://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](http://mathiasbynens.be/) |
+
+## License
+
+This library is available under the [MIT](http://mths.be/mit) license.

data/vendor/bin/cssesc

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+(function() {
+
+	var fs = require('fs');
+	var cssesc = require('../cssesc.js');
+	var strings = process.argv.splice(2);
+	var stdin = process.stdin;
+	var data;
+	var timeout;
+	var isObject = false;
+	var options = {};
+	var log = console.log;
+
+	var main = function() {
+		var option = strings[0];
+
+		if (/^(?:-h|--help|undefined)$/.test(option)) {
+			log(
+				'cssesc v%s - http://mths.be/cssesc',
+				cssesc.version
+			);
+			log([
+				'\nUsage:\n',
+				'\tcssesc [string]',
+				'\tcssesc [-i | --identifier] [string]',
+				'\tcssesc [-s | --single-quotes] [string]',
+				'\tcssesc [-d | --double-quotes] [string]',
+				'\tcssesc [-w | --wrap] [string]',
+				'\tcssesc [-e | --escape-everything] [string]',
+				'\tcssesc [-v | --version]',
+				'\tcssesc [-h | --help]',
+				'\nExamples:\n',
+				'\tcssesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tcssesc --identifier \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tcssesc --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tcssesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | cssesc'
+			].join('\n'));
+			return process.exit(1);
+		}
+
+		if (/^(?:-v|--version)$/.test(option)) {
+			log('v%s', cssesc.version);
+			return process.exit(1);
+		}
+
+		strings.forEach(function(string) {
+			// Process options
+			if (/^(?:-i|--identifier)$/.test(string)) {
+				options.isIdentifier = true;
+				return;
+			}
+			if (/^(?:-s|--single-quotes)$/.test(string)) {
+				options.quotes = 'single';
+				return;
+			}
+			if (/^(?:-d|--double-quotes)$/.test(string)) {
+				options.quotes = 'double';
+				return;
+			}
+			if (/^(?:-w|--wrap)$/.test(string)) {
+				options.wrap = true;
+				return;
+			}
+			if (/^(?:-e|--escape-everything)$/.test(string)) {
+				options.escapeEverything = true;
+				return;
+			}
+
+			// Process string(s)
+			var result;
+			try {
+				result = cssesc(string, options);
+				log(result);
+			} catch(error) {
+				log(error.message + '\n');
+				log('Error: failed to escape.');
+				log('If you think this is a bug in cssesc, please report it:');
+				log('https://github.com/mathiasbynens/cssesc/issues/new');
+				log(
+					'\nStack trace using cssesc@%s:\n',
+					cssesc.version
+				);
+				log(error.stack);
+				return process.exit(1);
+			}
+		});
+		// Return with exit status 0 outside of the `forEach` loop, in case
+		// multiple strings were passed in.
+		return process.exit(0);
+
+	};
+
+	if (stdin.isTTY) {
+		// handle shell arguments
+		main();
+	} else {
+		// Either the script is called from within a non-TTY context, or `stdin`
+		// content is being piped in.
+		if (!process.stdout.isTTY) {
+			// The script was called from a non-TTY context. This is a rather uncommon
+			// use case we don’t actively support. However, we don’t want the script
+			// to wait forever in such cases, so…
+			timeout = setTimeout(function() {
+				// …if no piped data arrived after a whole minute, handle shell
+				// arguments instead.
+				main();
+			}, 60000);
+		}
+		data = '';
+		stdin.on('data', function(chunk) {
+			clearTimeout(timeout);
+			data += chunk;
+		});
+		stdin.on('end', function() {
+			strings.push(data.trim());
+			main();
+		});
+		stdin.resume();
+	}
+
+}());

data/vendor/cssesc.js

@@ -0,0 +1,177 @@
+/*! http://mths.be/cssesc v0.1.0 by @mathias */
+;(function(root) {
+
+	// Detect free variables `exports`
+	var freeExports = typeof exports == 'object' && exports;
+
+	// Detect free variable `module`
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+
+	// Detect free variable `global`, from Node.js or Browserified code,
+	// and use it as `root`
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var merge = function(options, defaults) {
+		if (!options) {
+			return defaults;
+		}
+		var key;
+		var result = {};
+		for (key in defaults) {
+			// `if (defaults.hasOwnProperty(key) { … }` is not needed here, since
+			// only recognized option names are used
+			result[key] = hasOwnProperty.call(options, key)
+				? options[key]
+				: defaults[key];
+		}
+		return result;
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var regexAnySingleEscape = /[\x20-\x2C\x2E\x2F\x3B-\x40\x5B-\x5E\x60\x7B-\x7E]/;
+	var regexSingleEscape = /[\x20\x21\x23-\x26\x28-\x2C\x2E\x2F\x3B-\x40\x5B\x5D\x5E\x60\x7B-\x7E]/;
+	var regexAlwaysEscape = /['"\\]/;
+	var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+
+	// http://mathiasbynens.be/notes/css-escapes#css
+	var cssesc = function(string, options) {
+
+		// Handle options
+		options = merge(options, cssesc.options);
+		if (options.quotes != 'single' && options.quotes != 'double') {
+			options.quotes = 'single';
+		}
+		var quote = options.quotes == 'double' ? '"' : '\'';
+		var isIdentifier = options.isIdentifier;
+
+		var firstChar = string.charAt(0);
+		var output = '';
+		var counter = 0;
+		var length = string.length;
+		var value;
+		var character;
+		var codePoint;
+		var extra; // used for potential low surrogates
+
+		while (counter < length) {
+			character = string.charAt(counter++);
+			codePoint = character.charCodeAt();
+			// if it’s not a printable ASCII character
+			if (codePoint < 0x20 || codePoint > 0x7E) {
+				if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) {
+					// high surrogate, and there is a next character
+					extra = string.charCodeAt(counter++);
+					if ((extra & 0xFC00) == 0xDC00) { // next character is low surrogate
+						codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+					} else {
+						// unmatched surrogate; only append this code unit, in case the next
+						// code unit is the high surrogate of a surrogate pair
+						counter--;
+					}
+				}
+				value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+			} else {
+				if (options.escapeEverything) {
+					if (regexAnySingleEscape.test(character)) {
+						value = '\\' + character;
+					} else {
+						value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+					}
+				// `:` can be escaped as `\:`, but that fails in IE < 8
+				} else if (/[\t\n\f\r\x0B:]/.test(character)) {
+					if (!isIdentifier && character == ':') {
+						value = character;
+					} else {
+						value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+					}
+				} else if (
+					character == '\\' ||
+					(
+						!isIdentifier &&
+						(
+							(character == '"' && quote == character) ||
+							(character == '\'' && quote == character)
+						)
+					) ||
+					(isIdentifier && regexSingleEscape.test(character))
+				) {
+					value = '\\' + character;
+				} else {
+					value = character;
+				}
+			}
+			output += value;
+		}
+
+		if (isIdentifier) {
+			if (/^_/.test(output)) {
+				// Prevent IE6 from ignoring the rule altogether (in case this is for an
+				// identifier used as a selector)
+				output = '\\_' + output.slice(1);
+			} else if (/^-[-\d]/.test(output)) {
+				output = '\\-' + output.slice(1);
+			} else if (/\d/.test(firstChar)) {
+				output = '\\3' + firstChar + ' ' + output.slice(1);
+			}
+		}
+
+		// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+		// since they’re redundant. Note that this is only possible if the escape
+		// sequence isn’t preceded by an odd number of backslashes.
+		output = output.replace(regexExcessiveSpaces, function($0, $1, $2) {
+			if ($1 && $1.length % 2) {
+				// it’s not safe to remove the space, so don’t
+				return $0;
+			}
+			// strip the space
+			return ($1 || '') + $2;
+		});
+
+		if (!isIdentifier && options.wrap) {
+			return quote + output + quote;
+		}
+		return output;
+	};
+
+	// Expose default options (so they can be overridden globally)
+	cssesc.options = {
+		'escapeEverything': false,
+		'isIdentifier': false,
+		'quotes': 'single',
+		'wrap': false
+	};
+
+	cssesc.version = '0.1.0';
+
+	/*--------------------------------------------------------------------------*/
+
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return cssesc;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js or RingoJS v0.8.0+
+			freeModule.exports = cssesc;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			freeExports.cssesc = cssesc;
+		}
+	} else { // in Rhino or a web browser
+		root.cssesc = cssesc;
+	}
+
+}(this));