s2/gitlit
1
0
Fork 0
mirror of https://github.com/S2-/gitlit synced 2025-08-03 12:50:04 +02:00
Code Issues Releases Wiki Activity

remove node_modules

Browse Source
This commit is contained in:
s2
2018-05-19 20:19:16 +02:00
parent 460c610361
commit a3f65f089b
1856 changed files with 0 additions and 309697 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
app/node_modules/object-keys/.npmignore generated vendored
View File

@@ -1 +0,0 @@
node_modules

5
app/node_modules/object-keys/.travis.yml generated vendored
View File

@@ -1,5 +0,0 @@
language: node_js
node_js:
- "0.10"
- "0.8"
- "0.6"

39
app/node_modules/object-keys/README.md generated vendored
View File

@@ -1,39 +0,0 @@
#object-keys <sup>[![Version Badge][2]][1]</sup>
[![Build Status][3]][4] [![dependency status][5]][6]
[![browser support][7]][8]
An Object.keys shim. Uses Object.keys if available.
## Example
```js
var keys = require('object-keys');
var assert = require('assert');
var obj = {
a: true,
b: true,
c: true
};
assert.equal(keys(obj), ['a', 'b', 'c']);
```
## Source
Implementation taken directly from [es5-shim]([9]), with modifications, including from [lodash]([10]).
## Tests
Simply clone the repo, `npm install`, and run `npm test`
[1]: https://npmjs.org/package/object-keys
[2]: http://vb.teelaun.ch/ljharb/object-keys.svg
[3]: https://travis-ci.org/ljharb/object-keys.png
[4]: https://travis-ci.org/ljharb/object-keys
[5]: https://david-dm.org/ljharb/object-keys.png
[6]: https://david-dm.org/ljharb/object-keys
[7]: https://ci.testling.com/ljharb/object-keys.png
[8]: https://ci.testling.com/ljharb/object-keys
[9]: https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js#L542-589
[10]: https://github.com/bestiejs/lodash

40
app/node_modules/object-keys/foreach.js generated vendored
View File

@@ -1,40 +0,0 @@
var hasOwn = Object.prototype.hasOwnProperty;
var toString = Object.prototype.toString;
var isFunction = function (fn) {
var isFunc = (typeof fn === 'function' && !(fn instanceof RegExp)) || toString.call(fn) === '[object Function]';
if (!isFunc && typeof window !== 'undefined') {
isFunc = fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt;
}
return isFunc;
};
module.exports = function forEach(obj, fn) {
if (!isFunction(fn)) {
throw new TypeError('iterator must be a function');
}
var i, k,
isString = typeof obj === 'string',
l = obj.length,
context = arguments.length > 2 ? arguments[2] : null;
if (l === +l) {
for (i = 0; i < l; i++) {
if (context === null) {
fn(isString ? obj.charAt(i) : obj[i], i, obj);
} else {
fn.call(context, isString ? obj.charAt(i) : obj[i], i, obj);
}
}
} else {
for (k in obj) {
if (hasOwn.call(obj, k)) {
if (context === null) {
fn(obj[k], k, obj);
} else {
fn.call(context, obj[k], k, obj);
}
}
}
}
};

2
app/node_modules/object-keys/index.js generated vendored
View File

@@ -1,2 +0,0 @@
module.exports = Object.keys || require('./shim');

16
app/node_modules/object-keys/isArguments.js generated vendored
View File

@@ -1,16 +0,0 @@
var toString = Object.prototype.toString;
module.exports = function isArguments(value) {
var str = toString.call(value);
var isArguments = str === '[object Arguments]';
if (!isArguments) {
isArguments = str !== '[object Array]'
&& value !== null
&& typeof value === 'object'
&& typeof value.length === 'number'
&& value.length >= 0
&& toString.call(value.callee) === '[object Function]';
}
return isArguments;
};

77
app/node_modules/object-keys/package.json generated vendored
View File

@@ -1,77 +0,0 @@
{
"_from": "object-keys@~0.4.0",
"_id": "object-keys@0.4.0",
"_inBundle": false,
"_integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=",
"_location": "/object-keys",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "object-keys@~0.4.0",
"name": "object-keys",
"escapedName": "object-keys",
"rawSpec": "~0.4.0",
"saveSpec": null,
"fetchSpec": "~0.4.0"
},
"_requiredBy": [
"/xtend"
],
"_resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz",
"_shasum": "28a6aae7428dd2c3a92f3d95f21335dd204e0336",
"_spec": "object-keys@~0.4.0",
"_where": "E:\\projects\\p\\gitlit\\app\\node_modules\\xtend",
"author": {
"name": "Jordan Harband"
},
"bugs": {
"url": "https://github.com/ljharb/object-keys/issues"
},
"bundleDependencies": false,
"dependencies": {},
"deprecated": false,
"description": "An Object.keys replacement, in case Object.keys is not available. From https://github.com/kriskowal/es5-shim",
"devDependencies": {
"foreach": "~2.0.3",
"indexof": "~0.0.1",
"is": "~0.2.6",
"tape": "~1.0.4"
},
"homepage": "https://github.com/ljharb/object-keys#readme",
"keywords": [
"Object.keys",
"keys",
"ES5",
"shim"
],
"license": "MIT",
"main": "index.js",
"name": "object-keys",
"repository": {
"type": "git",
"url": "git://github.com/ljharb/object-keys.git"
},
"scripts": {
"test": "node test/index.js"
},
"testling": {
"files": "test/index.js",
"browsers": [
"iexplore/6.0..latest",
"firefox/3.0..6.0",
"firefox/15.0..latest",
"firefox/nightly",
"chrome/4.0..10.0",
"chrome/20.0..latest",
"chrome/canary",
"opera/10.0..latest",
"opera/next",
"safari/4.0..latest",
"ipad/6.0..latest",
"iphone/6.0..latest",
"android-browser/4.2"
]
},
"version": "0.4.0"
}

62
app/node_modules/object-keys/shim.js generated vendored
View File

@@ -1,62 +0,0 @@
(function () {
"use strict";
// modified from https://github.com/kriskowal/es5-shim
var has = Object.prototype.hasOwnProperty,
toString = Object.prototype.toString,
forEach = require('./foreach'),
isArgs = require('./isArguments'),
hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
dontEnums = [
"toString",
"toLocaleString",
"valueOf",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"constructor"
],
keysShim;
keysShim = function keys(object) {
var isObject = object !== null && typeof object === 'object',
isFunction = toString.call(object) === '[object Function]',
isArguments = isArgs(object),
theKeys = [];
if (!isObject && !isFunction && !isArguments) {
throw new TypeError("Object.keys called on a non-object");
}
if (isArguments) {
forEach(object, function (value) {
theKeys.push(value);
});
} else {
var name,
skipProto = hasProtoEnumBug && isFunction;
for (name in object) {
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
theKeys.push(name);
}
}
}
if (hasDontEnumBug) {
var ctor = object.constructor,
skipConstructor = ctor && ctor.prototype === object;
forEach(dontEnums, function (dontEnum) {
if (!(skipConstructor && dontEnum === 'constructor') && has.call(object, dontEnum)) {
theKeys.push(dontEnum);
}
});
}
return theKeys;
};
module.exports = keysShim;
}());

156
app/node_modules/object-keys/test/foreach.js generated vendored
View File

@@ -1,156 +0,0 @@
var test = require('tape');
var forEach = require('../foreach.js');
test('second argument: iterator', function (t) {
var arr = [];
t.throws(function () { forEach(arr); }, TypeError, 'undefined is not a function');
t.throws(function () { forEach(arr, null); }, TypeError, 'null is not a function');
t.throws(function () { forEach(arr, ''); }, TypeError, 'string is not a function');
t.throws(function () { forEach(arr, /a/); }, TypeError, 'regex is not a function');
t.throws(function () { forEach(arr, true); }, TypeError, 'true is not a function');
t.throws(function () { forEach(arr, false); }, TypeError, 'false is not a function');
t.throws(function () { forEach(arr, NaN); }, TypeError, 'NaN is not a function');
t.throws(function () { forEach(arr, 42); }, TypeError, '42 is not a function');
t.doesNotThrow(function () { forEach(arr, function () {}); }, 'function is a function');
t.doesNotThrow(function () { forEach(arr, setTimeout); }, 'setTimeout is a function');
if (typeof window !== 'undefined') {
t.doesNotThrow(function () { forEach(arr, window.alert); }, 'alert is a function');
}
t.end();
});
test('array', function (t) {
var arr = [1, 2, 3];
t.test('iterates over every item', function (st) {
var index = 0;
forEach(arr, function () { index += 1; });
st.equal(index, arr.length, 'iterates ' + arr.length + ' times');
st.end();
});
t.test('first iterator argument', function (st) {
var index = 0;
st.plan(arr.length);
forEach(arr, function (item) {
st.equal(arr[index], item, 'item ' + index + ' is passed as first argument');
index += 1;
});
st.end();
});
t.test('second iterator argument', function (st) {
var counter = 0;
st.plan(arr.length);
forEach(arr, function (item, index) {
st.equal(counter, index, 'index ' + index + ' is passed as second argument');
counter += 1;
});
st.end();
});
t.test('third iterator argument', function (st) {
st.plan(arr.length);
forEach(arr, function (item, index, array) {
st.deepEqual(arr, array, 'array is passed as third argument');
});
st.end();
});
t.test('context argument', function (st) {
var context = {};
st.plan(arr.length);
forEach(arr, function () {
st.equal(this, context, '"this" is the passed context');
}, context);
st.end();
});
t.end();
});
test('object', function (t) {
var obj = {
a: 1,
b: 2,
c: 3
};
var keys = ['a', 'b', 'c'];
var F = function () {
this.a = 1;
this.b = 2;
};
F.prototype.c = 3;
var fKeys = ['a', 'b'];
t.test('iterates over every object literal key', function (st) {
var counter = 0;
forEach(obj, function () { counter += 1; });
st.equal(counter, keys.length, 'iterated ' + counter + ' times');
st.end();
});
t.test('iterates only over own keys', function (st) {
var counter = 0;
forEach(new F(), function () { counter += 1; });
st.equal(counter, fKeys.length, 'iterated ' + fKeys.length + ' times');
st.end();
});
t.test('first iterator argument', function (st) {
var index = 0;
st.plan(keys.length);
forEach(obj, function (item) {
st.equal(obj[keys[index]], item, 'item at key ' + keys[index] + ' is passed as first argument');
index += 1;
});
st.end();
});
t.test('second iterator argument', function (st) {
var counter = 0;
st.plan(keys.length);
forEach(obj, function (item, key) {
st.equal(keys[counter], key, 'key ' + key + ' is passed as second argument');
counter += 1;
});
st.end();
});
t.test('third iterator argument', function (st) {
st.plan(keys.length);
forEach(obj, function (item, key, object) {
st.deepEqual(obj, object, 'object is passed as third argument');
});
st.end();
});
t.test('context argument', function (st) {
var context = {};
st.plan(1);
forEach({foo: 'bar'}, function () {
st.equal(this, context, '"this" is the passed context');
}, context);
st.end();
});
t.end();
});
test('string', function (t) {
var str = 'str';
t.test('second iterator argument', function (st) {
var counter = 0;
st.plan(str.length * 2 + 1);
forEach(str, function (item, index) {
st.equal(counter, index, 'index ' + index + ' is passed as second argument');
st.equal(str.charAt(index), item);
counter += 1;
});
st.equal(counter, str.length, 'iterates ' + str.length + ' times');
});
t.end();
});

6
app/node_modules/object-keys/test/index.js generated vendored
View File

@@ -1,6 +0,0 @@
require('./foreach');
require('./isArguments');
require('./shim');

10
app/node_modules/object-keys/test/isArguments.js generated vendored
View File

@@ -1,10 +0,0 @@
var test = require('tape');
var isArguments = require('../isArguments');
test('is.arguments', function (t) {
t.notOk(isArguments([]), 'array is not arguments');
(function () { t.ok(isArguments(arguments), 'arguments is arguments'); }());
(function () { t.notOk(isArguments(Array.prototype.slice.call(arguments)), 'sliced arguments is not arguments'); }());
t.end();
});

134
app/node_modules/object-keys/test/shim.js generated vendored
View File

@@ -1,134 +0,0 @@
var test = require('tape');
var shimmedKeys = require('../index.js');
var is = require('is');
var keys = require('../shim.js');
var forEach = require('foreach');
var indexOf = require('indexof');
var obj = {
"str": "boz",
"obj": {},
"arr": [],
"bool": true,
"num": 42,
"aNull": null,
"undef": undefined
};
var objKeys = ['str', 'obj', 'arr', 'bool', 'num', 'aNull', 'undef'];
test('exports a function', function (t) {
if (Object.keys) {
t.equal(Object.keys, shimmedKeys, 'Object.keys is supported and exported');
} else {
t.equal(keys, shimmedKeys, 'Object.keys is not supported; shim is exported');
}
t.end();
});
test('working with actual shim', function (t) {
t.notEqual(Object.keys, keys, 'keys shim is not native Object.keys');
t.end();
});
test('works with an object literal', function (t) {
var theKeys = keys(obj);
t.equal(is.array(theKeys), true, 'returns an array');
t.deepEqual(theKeys, objKeys, 'Object has expected keys');
t.end();
});
test('works with an array', function (t) {
var arr = [1, 2, 3];
var theKeys = keys(arr);
t.equal(is.array(theKeys), true, 'returns an array');
t.deepEqual(theKeys, ['0', '1', '2'], 'Array has expected keys');
t.end();
});
test('works with a function', function (t) {
var foo = function () {};
foo.a = true;
t.doesNotThrow(function () { return keys(foo); }, 'does not throw an error');
t.deepEqual(keys(foo), ['a'], 'returns expected keys');
t.end();
});
test('returns names which are own properties', function (t) {
forEach(keys(obj), function (name) {
t.equal(obj.hasOwnProperty(name), true, name + ' should be returned');
});
t.end();
});
test('returns names which are enumerable', function (t) {
var k, loopedValues = [];
for (k in obj) {
loopedValues.push(k);
}
forEach(keys(obj), function (name) {
t.notEqual(indexOf(loopedValues, name), -1, name + ' is not enumerable');
});
t.end();
});
test('throws an error for a non-object', function (t) {
t.throws(
function () { return keys(42); },
new TypeError('Object.keys called on a non-object'),
'throws on a non-object'
);
t.end();
});
test('works with an object instance', function (t) {
var Prototype = function () {};
Prototype.prototype.foo = true;
var obj = new Prototype();
obj.bar = true;
var theKeys = keys(obj);
t.equal(is.array(theKeys), true, 'returns an array');
t.deepEqual(theKeys, ['bar'], 'Instance has expected keys');
t.end();
});
test('works in iOS 5 mobile Safari', function (t) {
var Foo = function () {};
Foo.a = function () {};
// the bug is keys(Foo) => ['a', 'prototype'] instead of ['a']
t.deepEqual(keys(Foo), ['a'], 'has expected keys');
t.end();
});
test('works in environments with the dontEnum bug (IE < 9)', function (t) {
var Foo = function () {};
Foo.prototype.a = function () {};
// the bug is keys(Foo.prototype) => ['a', 'constructor'] instead of ['a']
t.deepEqual(keys(Foo.prototype), ['a'], 'has expected keys');
t.end();
});
test('shadowed properties', function (t) {
var shadowedProps = [
'dummyControlProp', /* just to be sure */
'constructor',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toLocaleString',
'toString',
'valueOf'
];
shadowedProps.sort();
var shadowedObject = {};
forEach(shadowedProps, function (value, index) {
shadowedObject[value] = index;
});
var shadowedObjectKeys = keys(shadowedObject);
shadowedObjectKeys.sort();
t.deepEqual(shadowedObjectKeys, shadowedProps, 'troublesome shadowed properties are keys of object literals');
t.end();
});