How to use es6-set - 10 common examples

structure2dom (structure, domElement) {
    if (this.currentDOMStructure === structure) {
      return
    }
    let timeStart
    if (process.env.NODE_ENV !== 'production') {
      timeStart = window.performance.now()
    }

    let touchedEditorNodes = new Set()
    this.currentEditorNodesFromStructure.clear()
    let processEditorNode = (current, currentElement) => {
      // React.render into old node will update the content (and the component's props).
      let componentClass = editorNodeTypeNameTable[current.type]
      if (!componentClass) {
        if (currentElement) {
          this.recycleNode(currentElement)
          currentElement.remove() // To not complicate matters.
        }
        return null
      }
      let thisEditor = this
      let enDOM = null
      let nodeSet = this.currentEditorNodes
      let nodeSetFromStructure = this.currentEditorNodesFromStructure
      let renderedDOMNode = null

import Set from 'es6-set';
import blockElements from 'block-elements';

const BLOCK_ELEMENTS = new Set(blockElements);
const TEXT_ELEMENTS = {
  h1: 'header1',
  h2: 'header2',
  h3: 'header3',
  h4: 'header4',
  h5: 'header5',
  h6: 'header6',
  p: 'paragraph',
  blockquote: 'blockquote'
};

// inject parse to avoid recursive requires
export default (parse, text) => {
  return (elm, textOpts) => {
    const tagName = elm.tagName.toLowerCase();

const mouseDown = event => {

            if (!(map[modesKey] & CREATE)) {

                // Polygons can only be created when the mode includes create.
                return;

            }

            /**
             * @constant latLngs
             * @type {Set}
             */
            const latLngs = new Set();

            // Create the line iterator and move it to its first `yield` point, passing in the start point
            // from the mouse down event.
            const lineIterator = this.createPath(svg, map.latLngToContainerPoint(event.latlng), options.strokeWidth);

            /**
             * @method mouseMove
             * @param {Object} event
             * @return {void}
             */
            const mouseMove = event => {

                // Resolve the pixel point to the latitudinal and longitudinal equivalent.
                const point = map.mouseEventToContainerPoint(event.originalEvent);

                // Push each lat/lng value into the points set.

import Set from 'es6-set';
import setupEmbed from './embeds';
import setupText from './text';
import setupBlockElement from './block-element';
import toDOM from 'query-dom';

const HEAD_NODE_NAMES = new Set([
  'title', 'base', 'link', 'meta', 'script', 'noscript', 'style'
]);

const linebreak = elm => elm.tagName.toLowerCase() === 'br' ? { type: 'linebreak' } : null;

const isEmptyTextNode = elm => (elm.nodeName === '#text' && elm.data.length === 0);

export default opts => {
  const text = setupText(opts);
  const embed = setupEmbed(opts);

  const parse = (elms, textOpts, result) => {
    for (let i = 0; i < elms.length; i++) {
      let elm = elms[i];

      // ELEMENT_NODE

onAdd(map) {

        // Memorise the map instance.
        this.map = map;

        // Attach the cancel function and the instance to the map.
        map[cancelKey] = () => {};
        map[instanceKey] = this;
        map[notifyDeferredKey] = () => {};

        // Setup the dependency injection for simplifying the polygon.
        map.simplifyPolygon = simplifyPolygon;

        // Add the item to the map.
        polygons.set(map, new Set());

        // Set the initial mode.
        modeFor(map, this.options.mode, this.options);

        // Instantiate the SVG layer that sits on top of the map.
        const svg = this.svg = select(map._container).append('svg')
                                 .classed('free-draw', true).attr('width', '100%').attr('height', '100%')
                                 .style('pointer-events', 'none').style('z-index', '1001').style('position', 'relative');

        // Set the mouse events.
        this.listenForEvents(map, svg, this.options);

    }

module.exports = function (t, a) {
	var proto = create(Set.prototype), initialized, set, event;

	t(proto, function () { initialized = true; });

	set = create(proto);
	set = proto.constructor.call(set);

	set.add('foo');
	a(initialized, undefined, "Not observable");
	set.on('foo', function () {});
	a(initialized, undefined, "Not 'change' listener");
	set.on('change', function (e) { event = e; });
	a(initialized, true, "'change' listener");

	set.add('raz');
	set._emitAdd_('raz');
	a.deep(event, { type: 'add', value: 'raz', target: set }, "Event");

getJsLibraries(targetNode, platform) {
    if (platform === TargetPlatform.JS || platform === TargetPlatform.CANVAS) {
      const jsLibs = targetNode.getAttribute(ATTRIBUTES.JS_LIBS);
      let additionalLibs = new Set(API_URLS.JQUERY.split());
      if (jsLibs) {
        let checkUrl = new RegExp("https?://.+$");
        jsLibs
          .replace(" ", "")
          .split(",")
          .filter(lib => checkUrl.test(lib))
          .forEach(lib => additionalLibs.add(lib));
      }
      return additionalLibs;
    }
  }

let targetPlatform = targetNode.getAttribute('data-target-platform');
    let jsLibs = targetNode.getAttribute('data-js-libs');
    let isFoldedButton = targetNode.getAttribute('folded-button') !== "false";
    targetPlatform = targetPlatform !== null ? targetPlatform : "java";
    const code = targetNode.textContent.replace(/^\s+|\s+$/g, '');
    const cfg = merge(defaultConfig, config);

    /*
      additionalLibs - setting additional JS-library
      Setting JQuery as default JS library
     */
    let additionalLibs;
    targetNode.style.display = 'none';
    targetNode.setAttribute(INITED_ATTRIBUTE_NAME, 'true');
    if (targetPlatform === "js" || targetPlatform === "canvas") {
      additionalLibs = new Set(API_URLS.JQUERY.split());
      if (jsLibs !== null) {
        let checkUrl = new RegExp("https?://.+\.js$");
        jsLibs
          .replace(" ", "")
          .split(",")
          .filter(lib => checkUrl.test(lib))
          .forEach(lib => additionalLibs.add(lib));
      }
    }
    const mountNode = document.createElement('div');
    insertAfter(mountNode, targetNode);

    const view = ExecutableFragment.render(mountNode, {highlightOnly});
    view.update({
      code: code,
      compilerVersion: cfg.compilerVersion,

'use strict';

var d              = require('d')
  , aFrom          = require('es5-ext/array/from')
  , setPrototypeOf = require('es5-ext/object/set-prototype-of')
  , Set            = require('es6-set/polyfill')

  , PlainSet;

module.exports = PlainSet = function (/*iterable*/) {
	return setPrototypeOf(new Set(arguments[0]), PlainSet.prototype);
};
setPrototypeOf(PlainSet, Set);

PlainSet.prototype = Object.create(Set.prototype, {
	first: d.gs(require('es6-set/ext/get-first')),
	last: d.gs(require('es6-set/ext/get-last')),
	copy: d(require('es6-set/ext/copy')),
	every: d(require('es6-set/ext/every')),
	some: d(require('es6-set/ext/some')),
	toArray: d(function () { return aFrom(this); })
});

, defineProperties = Object.defineProperties
  , ReverseSet;

ReverseSet = module.exports = function (key, sKey, descriptor) {
	return defineProperties(setPrototypeOf(new Set(), ReverseSet.prototype), {
		__key__: d('', key),
		__sKey__: d('', sKey),
		__descriptor__: d('', descriptor),
		__isObjectKey__: d('', sKey[0] === '7'),
		__lastModifiedMap__: d('', create(null)),
		__lastEventMap__: d('', create(null))
	});
};
setPrototypeOf(ReverseSet, Set);

ReverseSet.prototype = Object.create(Set.prototype, {
	constructor: d(ReverseSet),
	add: d(function (obj) {
		var desc, sKey, rDesc;
		this._assertReverse_();
		desc = this.__descriptor__;
		desc.object.constructor.validate(obj);
		sKey = desc._sKey_;
		rDesc = obj._getDescriptor_(sKey);
		if (rDesc.multiple) {
			obj._multipleAdd_(sKey, obj._validateMultipleAdd_(sKey, this.__key__), this.__sKey__);
			return this;
		}
		obj._set_(sKey, obj._validateSet_(sKey, this.__key__));
		return this;
	}),
	clear: d(function () {