medikoo

es6-symbol

// Exports true if environment provides native `Symbol` implementation

	if (typeof Symbol !== 'function') return false;

module.exports = typeof Symbol === 'function' && typeof Symbol() === 'symbol';

  "description": "ECMAScript 6 Symbol polyfill",

  "author": "Mariusz Nowak <medyk@medikoo.com> (http://www.medikoo.com/)",

    "url": "git://github.com/medikoo/es6-symbol.git"

    "lint": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --no-cache --no-stream",

    "lint-console": "node node_modules/xlint/bin/xlint --linter=node_modules/xlint-jslint-medikoo/index.js --watch",

    "test": "node ./node_modules/tad/bin/tad"

// ES2015 Symbol polyfill for environments that do not support it (or partially support it)

// ES2015 Symbol polyfill for environments that do not (or partially) support it

  , validateSymbol = require('./validate-symbol')

  , create = Object.create, defineProperties = Object.defineProperties

  , defineProperty = Object.defineProperty, objPrototype = Object.prototype

  , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null)

		var postfix = 0, name, ie11BugWorkaround;

		while (created[desc + (postfix || '')]) ++postfix;

		defineProperty(objPrototype, name, d.gs(null, function (value) {

			// https://connect.microsoft.com/IE/feedbackdetail/view/1928508/

			//    ie11-broken-getters-on-dom-objects

			// https://github.com/medikoo/es6-symbol/issues/12

// Internal constructor (not one exposed) for creating Symbol instances.

// This one is used to ensure that `someSymbol instanceof Symbol` always return false

HiddenSymbol = function Symbol(description) {

	if (this instanceof HiddenSymbol) throw new TypeError('TypeError: Symbol is not a constructor');

	if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');

module.exports = SymbolPolyfill = function Symbol(description) {

	if (this instanceof Symbol) throw new TypeError('TypeError: Symbol is not a constructor');

	if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');

	if (isNativeSafe) return NativeSymbol(description);

	symbol = create(HiddenSymbol.prototype);

	description = (description === undefined ? '' : String(description));

		__name__: d('', generateName(description))

		if (globalSymbols[key]) return globalSymbols[key];

		return (globalSymbols[key] = SymbolPolyfill(String(key)));

		for (key in globalSymbols) if (globalSymbols[key] === s) return key;

	// If there's native implementation of given symbol, let's fallback to it

	// to ensure proper interoperability with other native functions e.g. Array.from

	// To ensure proper interoperability with other native functions (e.g. Array.from)

	// fallback to eventual native implementation of given symbol

	hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),

	isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||

	iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),

	match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),

	replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),

	search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),

	species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),

	split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),

	toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),

	toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),

	unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))

// Internal tweaks for real symbol producer

defineProperties(HiddenSymbol.prototype, {

	toString: d('', function () { return this.__name__; })

// Proper implementation of methods exposed on Symbol.prototype

// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype

defineProperties(SymbolPolyfill.prototype, {

	toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),

	valueOf: d(function () { return validateSymbol(this); })

defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () {

	if (typeof symbol === 'symbol') return symbol;

defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));

// Proper implementaton of toPrimitive and toStringTag for returned symbol instances

defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,

	d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));

// Note: It's important to define `toPrimitive` as last one, as some implementations

// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)

// And that may invoke error in definition flow:

// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149

defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,

	d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));

For more information about symbols see following links

- [Symbols in ECMAScript 6 by Axel Rauschmayer](http://www.2ality.com/2014/12/es6-symbols.html)

- [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol)

- [Specification](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-symbol-constructor)

Underneath it uses real string property names which can easily be retrieved, however accidental collision with other property names is unlikely.

It’s safest to use *es6-symbol* as a [ponyfill](http://kikobeats.com/polyfill-ponyfill-and-prollyfill/) – a polyfill which doesn’t touch global objects:

If you'd like to use native version when it exists and fallback to [ponyfill](https://ponyfill.com) if it doesn't, use *es6-symbol* as following:

If you want to make sure your environment implements `Symbol` globally, do:

If you strictly want to use polyfill even if native `Symbol` exists (hard to find a good reason for that), do:

var Symbol = require('es6-symbol/polyfill');

Best is to refer to [specification](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-symbol-objects). Still if you want quick look, follow examples:

  iterator = possiblyIterable[Symbol.iterator]();

To port it to Browser or any other (non CJS) environment, use your favorite CJS bundler. No favorite yet? Try: [Browserify](http://browserify.org/), [Webmake](https://github.com/medikoo/modules-webmake) or [Webpack](http://webpack.github.io/)

## Tests [![Build Status](https://travis-ci.org/medikoo/es6-symbol.png)](https://travis-ci.org/medikoo/es6-symbol)

		@@ -5,5 +5,2 @@ // Exports true if environment provides native `Symbol` implementation

		module.exports = (function () {
		if (typeof Symbol !== 'function') return false;
		return (typeof Symbol() === 'symbol');
		}());
		module.exports = typeof Symbol === 'function' && typeof Symbol() === 'symbol';

		{
		"name": "es6-symbol",
		"version": "3.1.0",
		"version": "3.1.1",
		"description": "ECMAScript 6 Symbol polyfill",
		@@ -21,7 +21,7 @@ "author": "Mariusz Nowak <medyk@medikoo.com> (http://www.medikoo.com/)",
		"dependencies": {
		"d": "~0.1.1",
		"es5-ext": "~0.10.11"
		"d": "1",
		"es5-ext": "~0.10.14"
		},
		"devDependencies": {
		"tad": "~0.2.4",
		"tad": "~0.2.7",
		"xlint": "~0.2.2",
		@@ -28,0 +28,0 @@ "xlint-jslint-medikoo": "~0.1.4"

Worsened metrics

Dependency changes

		@@ -1,2 +0,2 @@
		// ES2015 Symbol polyfill for environments that do not support it (or partially support it)
		// ES2015 Symbol polyfill for environments that do not (or partially) support it

		@@ -46,3 +46,3 @@ 'use strict';
		HiddenSymbol = function Symbol(description) {
		if (this instanceof HiddenSymbol) throw new TypeError('TypeError: Symbol is not a constructor');
		if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
		return SymbolPolyfill(description);
		@@ -55,3 +55,3 @@ };
		var symbol;
		if (this instanceof Symbol) throw new TypeError('TypeError: Symbol is not a constructor');
		if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
		if (isNativeSafe) return NativeSymbol(description);
		@@ -76,4 +76,4 @@ symbol = create(HiddenSymbol.prototype);

		// If there's native implementation of given symbol, let's fallback to it
		// to ensure proper interoperability with other native functions e.g. Array.from
		// To ensure proper interoperability with other native functions (e.g. Array.from)
		// fallback to eventual native implementation of given symbol
		hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) \|\| SymbolPolyfill('hasInstance')),
		@@ -80,0 +80,0 @@ isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) \|\|

		@@ -15,3 +15,3 @@ # es6-symbol

		It’s safest to use es6-symbol as a [ponyfill](http://kikobeats.com/polyfill-ponyfill-and-prollyfill/) – a polyfill which doesn’t touch global objects:
		If you'd like to use native version when it exists and fallback to [ponyfill](https://ponyfill.com) if it doesn't, use es6-symbol as following:

		@@ -18,0 +18,0 @@ ```javascript