ikan Uploader :
Directory : /proc/self/root/home/saurabh/.npm/_npx/249ca9fcd30c476a/node_modules/fbjs/lib/
Upload File : |
| Current File : //proc/self/root/home/saurabh/.npm/_npx/249ca9fcd30c476a/node_modules/fbjs/lib/enumerate.js.flow |
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @providesModule enumerate
*
*/
const KIND_KEYS = 'keys';
const KIND_VALUES = 'values';
const KIND_ENTRIES = 'entries';
/**
* Specific Array iterators.
*/
const ArrayIterators = function () {
let hasNative = hasNativeIterator(Array);
let ArrayIterator;
if (!hasNative) {
ArrayIterator = class ArrayIterator {
// 22.1.5.1 CreateArrayIterator Abstract Operation
constructor(array, kind) {
this._iteratedObject = array;
this._kind = kind;
this._nextIndex = 0;
} // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
next() {
if (this._iteratedObject == null) {
return {
value: undefined,
done: true
};
}
let array = this._iteratedObject;
let len = this._iteratedObject.length;
let index = this._nextIndex;
let kind = this._kind;
if (index >= len) {
this._iteratedObject = undefined;
return {
value: undefined,
done: true
};
}
this._nextIndex = index + 1;
if (kind === KIND_KEYS) {
return {
value: index,
done: false
};
} else if (kind === KIND_VALUES) {
return {
value: array[index],
done: false
};
} else if (kind === KIND_ENTRIES) {
return {
value: [index, array[index]],
done: false
};
}
} // 22.1.5.2.2 %ArrayIteratorPrototype%[@@iterator]()
[Symbol.iterator]() {
return this;
}
};
}
return {
keys: hasNative ? array => array.keys() : array => new ArrayIterator(array, KIND_KEYS),
values: hasNative ? array => array.values() : array => new ArrayIterator(array, KIND_VALUES),
entries: hasNative ? array => array.entries() : array => new ArrayIterator(array, KIND_ENTRIES)
};
}(); // -----------------------------------------------------------------
/**
* Specific String iterators.
*/
const StringIterators = function () {
let hasNative = hasNativeIterator(String);
let StringIterator;
if (!hasNative) {
StringIterator = class StringIterator {
// 21.1.5.1 CreateStringIterator Abstract Operation
constructor(string) {
this._iteratedString = string;
this._nextIndex = 0;
} // 21.1.5.2.1 %StringIteratorPrototype%.next()
next() {
if (this._iteratedString == null) {
return {
value: undefined,
done: true
};
}
let index = this._nextIndex;
let s = this._iteratedString;
let len = s.length;
if (index >= len) {
this._iteratedString = undefined;
return {
value: undefined,
done: true
};
}
let ret;
let first = s.charCodeAt(index);
if (first < 0xD800 || first > 0xDBFF || index + 1 === len) {
ret = s[index];
} else {
let second = s.charCodeAt(index + 1);
if (second < 0xDC00 || second > 0xDFFF) {
ret = s[index];
} else {
ret = s[index] + s[index + 1];
}
}
this._nextIndex = index + ret.length;
return {
value: ret,
done: false
};
} // 21.1.5.2.2 %StringIteratorPrototype%[@@iterator]()
[Symbol.iterator]() {
return this;
}
};
}
return {
keys() {
throw TypeError(`Strings default iterator doesn't implement keys.`);
},
values: hasNative ? string => string[Symbol.iterator]() : string => new StringIterator(string),
entries() {
throw TypeError(`Strings default iterator doesn't implement entries.`);
}
};
}();
function hasNativeIterator(classObject) {
return typeof classObject.prototype[Symbol.iterator] === 'function' && typeof classObject.prototype.values === 'function' && typeof classObject.prototype.keys === 'function' && typeof classObject.prototype.entries === 'function';
} // -----------------------------------------------------------------
/**
* Generic object iterator.
*/
class ObjectIterator {
constructor(object, kind) {
this._iteratedObject = object;
this._kind = kind;
this._keys = Object.keys(object);
this._nextIndex = 0;
}
next() {
let len = this._keys.length;
let index = this._nextIndex;
let kind = this._kind;
let key = this._keys[index];
if (index >= len) {
this._iteratedObject = undefined;
return {
value: undefined,
done: true
};
}
this._nextIndex = index + 1;
if (kind === KIND_KEYS) {
return {
value: key,
done: false
};
} else if (kind === KIND_VALUES) {
return {
value: this._iteratedObject[key],
done: false
};
} else if (kind === KIND_ENTRIES) {
return {
value: [key, this._iteratedObject[key]],
done: false
};
}
}
[Symbol.iterator]() {
return this;
}
}
/**
* Generic object iterator, iterates over all own enumerable
* properties. Used only if if no specific iterator is available,
* and object don't implement iterator protocol.
*/
const GenericIterators = {
keys(object) {
return new ObjectIterator(object, KIND_KEYS);
},
values(object) {
return new ObjectIterator(object, KIND_VALUES);
},
entries(object) {
return new ObjectIterator(object, KIND_ENTRIES);
}
}; // -----------------------------------------------------------------
/**
* Main iterator function. Returns default iterator based
* on the class of an instance.
*/
function enumerate(object, kind) {
// First check specific iterators.
if (typeof object === 'string') {
return StringIterators[kind || KIND_VALUES](object);
} else if (Array.isArray(object)) {
return ArrayIterators[kind || KIND_VALUES](object); // Then see if an object implements own.
} else if (object[Symbol.iterator]) {
return object[Symbol.iterator](); // And fallback to generic with entries.
} else {
return GenericIterators[kind || KIND_ENTRIES](object);
}
}
Object.assign(enumerate, {
/**
* Export constants
*/
KIND_KEYS,
KIND_VALUES,
KIND_ENTRIES,
/**
* Convenient explicit iterators for special kinds.
*/
keys(object) {
return enumerate(object, KIND_KEYS);
},
values(object) {
return enumerate(object, KIND_VALUES);
},
entries(object) {
return enumerate(object, KIND_ENTRIES);
},
generic: GenericIterators.entries
});
module.exports = enumerate;
Kontol Shell Bypass