guard-sass-lint 0.1.0 → 0.1.1

data/node_modules/es5-ext/object/is-copy.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var eq     = require('./eq')
+  , value  = require('./valid-value')
+
+  , keys = Object.keys
+  , propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = function (a, b) {
+	var k1, k2;
+
+	if (eq(value(a), value(b))) return true;
+
+	a = Object(a);
+	b = Object(b);
+
+	k1 = keys(a);
+	k2 = keys(b);
+	if (k1.length !== k2.length) return false;
+	return k1.every(function (key) {
+		if (!propertyIsEnumerable.call(b, key)) return false;
+		return eq(a[key], b[key]);
+	});
+};

data/node_modules/es5-ext/object/is-empty.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var value = require('./valid-value')
+
+  , propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = function (obj) {
+	var i;
+	value(obj);
+	for (i in obj) { //jslint: ignore
+		if (propertyIsEnumerable.call(obj, i)) return false;
+	}
+	return true;
+};

data/node_modules/es5-ext/object/is-number-value.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = function (value) { return (value != null) && !isNaN(value); };

data/node_modules/es5-ext/object/is-object.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var map = { 'function': true, object: true };
+
+module.exports = function (x) {
+	return ((x != null) && map[typeof x]) || false;
+};

data/node_modules/es5-ext/object/is-plain-object.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var getPrototypeOf = Object.getPrototypeOf, prototype = Object.prototype
+  , toString = prototype.toString
+
+  , id = Object().toString();
+
+module.exports = function (value) {
+	var proto, constructor;
+	if (!value || (typeof value !== 'object') || (toString.call(value) !== id)) {
+		return false;
+	}
+	proto = getPrototypeOf(value);
+	if (proto === null) {
+		constructor = value.constructor;
+		if (typeof constructor !== 'function') return true;
+		return (constructor.prototype !== value);
+	}
+	return (proto === prototype) || (getPrototypeOf(proto) === null);
+};

data/node_modules/es5-ext/object/is-value.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var _undefined = require('../function/noop')(); // Support ES3 engines
+
+module.exports = function (val) { return ((val !== _undefined) && (val !== null)); };

data/node_modules/es5-ext/object/is.js

@@ -0,0 +1,10 @@
+// Implementation credits go to:
+// http://wiki.ecmascript.org/doku.php?id=harmony:egal
+
+'use strict';
+
+module.exports = function (x, y) {
+	return (x === y) ?
+			((x !== 0) || ((1 / x) === (1 / y))) :
+			((x !== x) && (y !== y)); //jslint: ignore
+};

data/node_modules/es5-ext/object/key-of.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var eq   = require('./eq')
+  , some = require('./some');
+
+module.exports = function (obj, searchValue) {
+	var r;
+	return some(obj, function (value, name) {
+		if (eq(value, searchValue)) {
+			r = name;
+			return true;
+		}
+		return false;
+	}) ? r : null;
+};

data/node_modules/es5-ext/object/keys/implement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+if (!require('./is-implemented')()) {
+	Object.defineProperty(Object, 'keys', { value: require('./shim'),
+		configurable: true, enumerable: false, writable: true });
+}

data/node_modules/es5-ext/object/keys/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = require('./is-implemented')()
+	? Object.keys
+	: require('./shim');

data/node_modules/es5-ext/object/keys/is-implemented.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function () {
+	try {
+		Object.keys('primitive');
+		return true;
+	} catch (e) { return false; }
+};

data/node_modules/es5-ext/object/keys/shim.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var keys = Object.keys;
+
+module.exports = function (object) {
+	return keys(object == null ? object : Object(object));
+};

data/node_modules/es5-ext/object/map-keys.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var callable = require('./valid-callable')
+  , forEach  = require('./for-each')
+
+  , call = Function.prototype.call;
+
+module.exports = function (obj, cb/*, thisArg*/) {
+	var o = {}, thisArg = arguments[2];
+	callable(cb);
+	forEach(obj, function (value, key, obj, index) {
+		o[call.call(cb, thisArg, key, value, this, index)] = value;
+	}, obj);
+	return o;
+};

data/node_modules/es5-ext/object/map.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var callable = require('./valid-callable')
+  , forEach  = require('./for-each')
+
+  , call = Function.prototype.call;
+
+module.exports = function (obj, cb/*, thisArg*/) {
+	var o = {}, thisArg = arguments[2];
+	callable(cb);
+	forEach(obj, function (value, key, obj, index) {
+		o[key] = call.call(cb, thisArg, value, key, obj, index);
+	});
+	return o;
+};

data/node_modules/es5-ext/object/mixin-prototypes.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var value = require('./valid-value')
+  , mixin = require('./mixin')
+
+  , defineProperty = Object.defineProperty
+  , getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+  , getOwnPropertyNames = Object.getOwnPropertyNames
+  , getPrototypeOf = Object.getPrototypeOf
+  , hasOwnProperty = Object.prototype.hasOwnProperty;
+
+module.exports = function (target, source) {
+	var error, end, define;
+	target = Object(value(target));
+	source = Object(value(source));
+	end = getPrototypeOf(target);
+	if (source === end) return target;
+	try {
+		mixin(target, source);
+	} catch (e) { error = e; }
+	source = getPrototypeOf(source);
+	define = function (name) {
+		if (hasOwnProperty.call(target, name)) return;
+		try {
+			defineProperty(target, name, getOwnPropertyDescriptor(source, name));
+		} catch (e) { error = e; }
+	};
+	while (source && (source !== end)) {
+		getOwnPropertyNames(source).forEach(define);
+		source = getPrototypeOf(source);
+	}
+	if (error) throw error;
+	return target;
+};

data/node_modules/es5-ext/object/mixin.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var value = require('./valid-value')
+
+  , defineProperty = Object.defineProperty
+  , getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+  , getOwnPropertyNames = Object.getOwnPropertyNames
+  , getOwnPropertySymbols = Object.getOwnPropertySymbols;
+
+module.exports = function (target, source) {
+	var error, sourceObject = Object(value(source));
+	target = Object(value(target));
+	getOwnPropertyNames(sourceObject).forEach(function (name) {
+		try {
+			defineProperty(target, name, getOwnPropertyDescriptor(source, name));
+		} catch (e) { error = e; }
+	});
+	if (typeof getOwnPropertySymbols === 'function') {
+		getOwnPropertySymbols(sourceObject).forEach(function (symbol) {
+			try {
+				defineProperty(target, symbol, getOwnPropertyDescriptor(source, symbol));
+			} catch (e) { error = e; }
+		});
+	}
+	if (error !== undefined) throw error;
+	return target;
+};

data/node_modules/es5-ext/object/normalize-options.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var forEach = Array.prototype.forEach, create = Object.create;
+
+var process = function (src, obj) {
+	var key;
+	for (key in src) obj[key] = src[key];
+};
+
+module.exports = function (options/*, …options*/) {
+	var result = create(null);
+	forEach.call(arguments, function (options) {
+		if (options == null) return;
+		process(Object(options), result);
+	});
+	return result;
+};

data/node_modules/es5-ext/object/primitive-set.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var forEach = Array.prototype.forEach, create = Object.create;
+
+module.exports = function (arg/*, …args*/) {
+	var set = create(null);
+	forEach.call(arguments, function (name) { set[name] = true; });
+	return set;
+};

data/node_modules/es5-ext/object/safe-traverse.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var value = require('./valid-value');
+
+module.exports = function (obj/*, …names*/) {
+	var length, current = 1;
+	value(obj);
+	length = arguments.length - 1;
+	if (!length) return obj;
+	while (current < length) {
+		obj = obj[arguments[current++]];
+		if (obj == null) return undefined;
+	}
+	return obj[arguments[current]];
+};

data/node_modules/es5-ext/object/serialize.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var toArray  = require('./to-array')
+  , isDate   = require('../date/is-date')
+  , isRegExp = require('../reg-exp/is-reg-exp')
+
+  , isArray = Array.isArray, stringify = JSON.stringify
+  , keyValueToString = function (value, key) { return stringify(key) + ':' + exports(value); };
+
+var sparseMap = function (arr) {
+	var i, l = arr.length, result = new Array(l);
+	for (i = 0; i < l; ++i) {
+		if (!arr.hasOwnProperty(i)) continue;
+		result[i] = exports(arr[i]);
+	}
+	return result;
+};
+
+module.exports = exports = function (obj) {
+	if (obj == null) return String(obj);
+	switch (typeof obj) {
+	case 'string':
+		return stringify(obj);
+	case 'number':
+	case 'boolean':
+	case 'function':
+		return String(obj);
+	case 'object':
+		if (isArray(obj)) return '[' + sparseMap(obj) + ']';
+		if (isRegExp(obj)) return String(obj);
+		if (isDate(obj)) return 'new Date(' + obj.valueOf() + ')';
+		return '{' + toArray(obj, keyValueToString) + '}';
+	default:
+		throw new TypeError("Serialization of " + String(obj) + "is unsupported");
+	}
+};

data/node_modules/es5-ext/object/set-prototype-of/implement.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var shim;
+
+if (!require('./is-implemented')() && (shim = require('./shim'))) {
+	Object.defineProperty(Object, 'setPrototypeOf',
+		{ value: shim, configurable: true, enumerable: false, writable: true });
+}

data/node_modules/es5-ext/object/set-prototype-of/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = require('./is-implemented')()
+	? Object.setPrototypeOf
+	: require('./shim');

data/node_modules/es5-ext/object/set-prototype-of/is-implemented.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var create = Object.create, getPrototypeOf = Object.getPrototypeOf
+  , x = {};
+
+module.exports = function (/*customCreate*/) {
+	var setPrototypeOf = Object.setPrototypeOf
+	  , customCreate = arguments[0] || create;
+	if (typeof setPrototypeOf !== 'function') return false;
+	return getPrototypeOf(setPrototypeOf(customCreate(null), x)) === x;
+};

data/node_modules/es5-ext/object/set-prototype-of/shim.js

@@ -0,0 +1,73 @@
+// Big thanks to @WebReflection for sorting this out
+// https://gist.github.com/WebReflection/5593554
+
+'use strict';
+
+var isObject      = require('../is-object')
+  , value         = require('../valid-value')
+
+  , isPrototypeOf = Object.prototype.isPrototypeOf
+  , defineProperty = Object.defineProperty
+  , nullDesc = { configurable: true, enumerable: false, writable: true,
+		value: undefined }
+  , validate;
+
+validate = function (obj, prototype) {
+	value(obj);
+	if ((prototype === null) || isObject(prototype)) return obj;
+	throw new TypeError('Prototype must be null or an object');
+};
+
+module.exports = (function (status) {
+	var fn, set;
+	if (!status) return null;
+	if (status.level === 2) {
+		if (status.set) {
+			set = status.set;
+			fn = function (obj, prototype) {
+				set.call(validate(obj, prototype), prototype);
+				return obj;
+			};
+		} else {
+			fn = function (obj, prototype) {
+				validate(obj, prototype).__proto__ = prototype;
+				return obj;
+			};
+		}
+	} else {
+		fn = function self(obj, prototype) {
+			var isNullBase;
+			validate(obj, prototype);
+			isNullBase = isPrototypeOf.call(self.nullPolyfill, obj);
+			if (isNullBase) delete self.nullPolyfill.__proto__;
+			if (prototype === null) prototype = self.nullPolyfill;
+			obj.__proto__ = prototype;
+			if (isNullBase) defineProperty(self.nullPolyfill, '__proto__', nullDesc);
+			return obj;
+		};
+	}
+	return Object.defineProperty(fn, 'level', { configurable: false,
+		enumerable: false, writable: false, value: status.level });
+}((function () {
+	var x = Object.create(null), y = {}, set
+	  , desc = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__');
+
+	if (desc) {
+		try {
+			set = desc.set; // Opera crashes at this point
+			set.call(x, y);
+		} catch (ignore) { }
+		if (Object.getPrototypeOf(x) === y) return { set: set, level: 2 };
+	}
+
+	x.__proto__ = y;
+	if (Object.getPrototypeOf(x) === y) return { level: 2 };
+
+	x = {};
+	x.__proto__ = y;
+	if (Object.getPrototypeOf(x) === y) return { level: 1 };
+
+	return false;
+}())));
+
+require('../create');

data/node_modules/es5-ext/object/some.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./_iterate')('some', false);

data/node_modules/es5-ext/object/to-array.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var callable = require('./valid-callable')
+  , forEach  = require('./for-each')
+
+  , call = Function.prototype.call
+
+  , defaultCb = function (value, key) { return [key, value]; };
+
+module.exports = function (obj/*, cb, thisArg, compareFn*/) {
+	var a = [], cb = arguments[1], thisArg = arguments[2];
+	cb = (cb == null) ? defaultCb : callable(cb);
+
+	forEach(obj, function (value, key, obj, index) {
+		a.push(call.call(cb, thisArg, value, key, this, index));
+	}, obj, arguments[3]);
+	return a;
+};