electron-devtools-vendor/extensions/ember-inspector/panes-0-0-0/assets/ember-inspector.js

<div align="center"> <h2>electron-devtools-vendor</h2> <img alt="MIT" src="https://img.shields.io/github/license/BlackHole1/electron-devtools-vendor?color=9cf&style=flat-square"> <img alt="GitHub repo size" src="https://img.shields.io/github/r

/* jshint ignore:start */

/* jshint ignore:end */

define('ember-inspector/adapters/basic', ['exports', 'ember', 'ember-inspector/config/environment'], function (exports, Ember, config) {

  'use strict';

  var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();

  /**
   * The adapter stores logic specific to each environment.
   * Extend this object with env specific code (such as chrome/firefox/test),
   * then set the application's `adapter` property to the name of this adapter.
   *
   * example:
   *
   * ```javascript
   * const EmberInspector = App.Create({
   *   adapter: 'chrome'
   * });
   * ```
   */
  var computed = Ember['default'].computed;
  var K = Ember['default'].K;

  exports['default'] = Ember['default'].Object.extend({
    /**
     * Called when the adapter is created (when
     * the inspector app boots).
     *
     * @method init
     */
    init: function init() {
      this._super.apply(this, arguments);
      this._checkVersion();
    },

    /**
     * Listens to `EmberInspectorDebugger` message about
     * Ember version mismatch. If a mismatch message is received
     * it means the current inspector app does not support the current
     * Ember version and needs to switch to an inspector version
     * that does.
     *
     * @method _checkVersion
     * @private
     */
    _checkVersion: function _checkVersion() {
      var _this = this;

      this.onMessageReceived(function (message) {
        var name = message.name;
        var version = message.version;

        if (name === 'version-mismatch') {
          var previousVersions = config['default'].previousEmberVersionsSupported;

          var _config$emberVersionsSupported = _slicedToArray(config['default'].emberVersionsSupported, 2);

          var fromVersion = _config$emberVersionsSupported[0];
          var tillVersion = _config$emberVersionsSupported[1];

          var neededVersion = undefined;

          if (compareVersion(version, fromVersion) === -1) {
            neededVersion = previousVersions[previousVersions.length - 1];
          } else if (tillVersion && compareVersion(version, tillVersion) !== -1) {
            neededVersion = tillVersion;
          } else {
            return;
          }
          _this.onVersionMismatch(neededVersion);
        }
      });
      this.sendMessage({ type: 'check-version', from: 'devtools' });
    },

    /**
     * Hook called when the Ember version is not
     * supported by the current inspector version.
     *
     * Each adapter should implement this hook
     * to switch to an older/new inspector version
     * that supports this Ember version.
     *
     * @method onVersionMismatch
     * @param {String} neededVersion (The version to go to)
     */
    onVersionMismatch: K,

    name: 'basic',

    /**
      Used to send messages to EmberDebug
       @param type {Object} the message to the send
    **/
    sendMessage: function sendMessage() {},

    /**
      Register functions to be called
      when a message from EmberDebug is received
    **/
    onMessageReceived: function onMessageReceived(callback) {
      this.get('_messageCallbacks').pushObject(callback);
    },

    _messageCallbacks: computed(function () {
      return [];
    }),

    _messageReceived: function _messageReceived(message) {
      this.get('_messageCallbacks').forEach(function (callback) {
        callback(message);
      });
    },

    // Called when the "Reload" is clicked by the user
    willReload: K,

    canOpenResource: false,
    openResource: function openResource() /* file, line */{}

  });

  /**
   * Compares two Ember versions.
   *
   * Returns:
   * `-1` if version < version
   * 0 if version1 == version2
   * 1 if version1 > version2
   *
   * @param {String} version1
   * @param {String} version2
   * @return {Boolean} result of the comparison
   */
  function compareVersion(version1, version2) {
    var compared, i;
    version1 = cleanupVersion(version1).split('.');
    version2 = cleanupVersion(version2).split('.');
    for (i = 0; i < 3; i++) {
      compared = compare(+version1[i], +version2[i]);
      if (compared !== 0) {
        return compared;
      }
    }
    return 0;
  }

  /* Remove -alpha, -beta, etc from versions */
  function cleanupVersion(version) {
    return version.replace(/-.*/g, '');
  }

  function compare(val, number) {
    if (val === number) {
      return 0;
    } else if (val < number) {
      return -1;
    } else if (val > number) {
      return 1;
    }
  }

});
define('ember-inspector/adapters/bookmarklet', ['exports', 'ember-inspector/adapters/basic', 'ember'], function (exports, BasicAdapter, Ember) {

  'use strict';

  var computed = Ember['default'].computed;

  exports['default'] = BasicAdapter['default'].extend({
    name: 'bookmarklet',

    /**
     * Called when the adapter is created.
     *
     * @method init
     */
    init: function init() {
      this._connect();
      return this._super.apply(this, arguments);
    },

    inspectedWindow: computed(function () {
      return window.opener || window.parent;
    }),

    inspectedWindowURL: computed(function () {
      return loadPageVar('inspectedWindowURL');
    }),

    sendMessage: function sendMessage(options) {
      options = options || {};
      this.get('inspectedWindow').postMessage(options, this.get('inspectedWindowURL'));
    },

    /**
     * Redirect to the correct inspector version.
     *
     * @method onVersionMismatch
     * @param {String} goToVersion
     */
    onVersionMismatch: function onVersionMismatch(goToVersion) {
      this.sendMessage({ name: 'version-mismatch', version: goToVersion });
      window.location.href = '../panes-' + goToVersion.replace(/\./g, '-') + '/index.html' + window.location.search;
    },

    _connect: function _connect() {
      var _this = this;

      window.addEventListener('message', function (e) {
        var message = e.data;
        if (e.origin !== _this.get('inspectedWindowURL')) {
          return;
        }
        // close inspector if inspected window is unloading
        if (message && message.unloading) {
          window.close();
        }
        if (message.from === 'inspectedWindow') {
          _this._messageReceived(message);
        }
      });
    }
  });

  function loadPageVar(sVar) {
    return decodeURI(window.location.search.replace(new RegExp("^(?:.*[&\\?]" + encodeURI(sVar).replace(/[\.\+\*]/g, "\\$&") + "(?:\\=([^&]*))?)?.*$", "i"), "$1"));
  }

});
define('ember-inspector/adapters/chrome', ['exports', 'ember-inspector/adapters/web-extension'], function (exports, WebExtension) {

  'use strict';

  exports['default'] = WebExtension['default'].extend({
    name: 'chome',

    canOpenResource: true,

    openResource: function openResource(file, line) {
      /*global chrome */
      // For some reason it opens the line after the one specified
      chrome.devtools.panels.openResource(file, line - 1);
    },

    onResourceAdded: function onResourceAdded() {
      chrome.devtools.inspectedWindow.onResourceAdded.addListener(function (opts) {
        if (opts.type === 'document') {
          this.sendIframes([opts.url]);
        }
      });
    }
  });

});
define('ember-inspector/adapters/firefox', ['exports', 'ember-inspector/adapters/web-extension'], function (exports, WebExtension) {

  'use strict';

  exports['default'] = WebExtension['default'].extend({
    name: 'firefox'
  });

});
define('ember-inspector/adapters/web-extension', ['exports', 'ember-inspector/adapters/basic', 'ember', 'ember-inspector/config/environment'], function (exports, BasicAdapter, Ember, config) {

  'use strict';

  /* globals chrome */
  var computed = Ember['default'].computed;

  var emberDebug = null;

  exports['default'] = BasicAdapter['default'].extend({
    /**
     * Called when the adapter is created.
     *
     * @method init
     */
    init: function init() {
      this._connect();
      this._handleReload();
      this._injectDebugger();
      return this._super.apply(this, arguments);
    },

    name: 'web-extension',

    sendMessage: function sendMessage(options) {
      options = options || {};
      this.get('_chromePort').postMessage(options);
    },

    _chromePort: computed(function () {
      return chrome.runtime.connect();
    }),

    _connect: function _connect() {
      var _this = this;

      var chromePort = this.get('_chromePort');
      chromePort.postMessage({ appId: chrome.devtools.inspectedWindow.tabId });

      chromePort.onMessage.addListener(function (message) {
        if (typeof message.type === 'string' && message.type === 'iframes') {
          _this.sendIframes(message.urls);
        }
        _this._messageReceived(message);
      });
    },

    _handleReload: function _handleReload() {
      var self = this;
      chrome.devtools.network.onNavigated.addListener(function () {
        self._injectDebugger();
        location.reload(true);
      });
    },

    _injectDebugger: function _injectDebugger() {
      chrome.devtools.inspectedWindow.eval(loadEmberDebug());
      this.onResourceAdded();
    },

    onResourceAdded: function onResourceAdded() /*callback*/{},

    willReload: function willReload() {
      this._injectDebugger();
    },

    /**
     * Redirect to the correct inspector version.
     *
     * @method onVersionMismatch
     * @param {String} goToVersion
     */
    onVersionMismatch: function onVersionMismatch(goToVersion) {
      window.location.href = '../panes-' + goToVersion.replace(/\./g, '-') + '/index.html';
    },

    /**
      We handle the reload here so we can inject
      scripts as soon as possible into the new page.
    */
    reloadTab: function reloadTab() {
      chrome.devtools.inspectedWindow.reload({
        injectedScript: loadEmberDebug()
      });
    },

    canOpenResource: false,

    sendIframes: function sendIframes(urls) {
      urls.forEach(function (url) {
        chrome.devtools.inspectedWindow.eval(loadEmberDebug(), { frameURL: url });
      });
    }
  });

  function loadEmberDebug() {
    var minimumVersion = config['default'].emberVersionsSupported[0].replace(/\./g, '-');
    var xhr = undefined;
    if (!emberDebug) {
      xhr = new XMLHttpRequest();
      xhr.open("GET", chrome.runtime.getURL('/panes-' + minimumVersion + '/ember_debug.js'), false);
      xhr.send();
      emberDebug = xhr.responseText;
    }
    return emberDebug;
  }

});
define('ember-inspector/adapters/websocket', ['exports', 'ember', 'ember-inspector/adapters/basic'], function (exports, Ember, BasicAdapter) {

  'use strict';

  var computed = Ember['default'].computed;

  exports['default'] = BasicAdapter['default'].extend({
    init: function init() {
      this._super();
      this._connect();
    },

    sendMessage: function sendMessage(options) {
      options = options || {};
      this.get('socket').emit('emberInspectorMessage', options);
    },

    socket: computed(function () {
      return window.EMBER_INSPECTOR_CONFIG.remoteDebugSocket;
    }),

    _connect: function _connect() {
      var _this = this;

      this.get('socket').on('emberInspectorMessage', function (message) {
        Ember['default'].run(function () {
          _this._messageReceived(message);
        });
      });
    },

    _disconnect: function _disconnect() {
      this.get('socket').removeAllListeners("emberInspectorMessage");
    },

    willDestroy: function willDestroy() {
      this._disconnect();
    }
  });

});
define('ember-inspector/app', ['exports', 'ember', 'ember/resolver', 'ember/load-initializers', 'ember-inspector/config/environment', 'ember-inspector/port', 'ember-inspector/libs/promise-assembler', 'ember-inspector/helpers/ms-to-time'], function (exports, Ember, Resolver, loadInitializers, config, Port, PromiseAssembler, msToTime) {

  'use strict';

  Ember['default'].MODEL_FACTORY_INJECTIONS = true;

  var version = '1.10.0';

  var App = Ember['default'].Application.extend({
    modulePrefix: config['default'].modulePrefix,
    podModulePrefix: config['default'].podModulePrefix,
    Resolver: Resolver['default']
  });

  config['default'].VERSION = version;

  // Register Helpers
  Ember['default'].Handlebars.helper('ms-to-time', msToTime['default']);

  // Inject adapter
  App.initializer({
    name: "extension-init",

    initialize: function initialize(container, app) {
      // chrome is replaced by the build process.
      app.adapter = 'chrome';

      // register and inject adapter
      var Adapter = undefined;
      if (Ember['default'].typeOf(app.adapter) === 'string') {
        Adapter = container.resolve('adapter:' + app.adapter);
      } else {
        Adapter = app.adapter;
      }
      container.register('adapter:main', Adapter);
      container.typeInjection('port', 'adapter', 'adapter:main');
      container.injection('route:application', 'adapter', 'adapter:main');
      container.injection('route:deprecations', 'adapter', 'adapter:main');
      container.injection('controller:deprecations', 'adapter', 'adapter:main');

      // register config
      container.register('config:main', config['default'], { instantiate: false });
      container.typeInjection('route', 'config', 'config:main');

      // inject port
      container.register('port:main', app.Port || Port['default']);
      container.typeInjection('controller', 'port', 'port:main');
      container.typeInjection('route', 'port', 'port:main');
      container.typeInjection('promise-assembler', 'port', 'port:main');

      // register and inject promise assembler
      container.register('promise-assembler:main', PromiseAssembler['default']);
      container.injection('route:promiseTree', 'assembler', 'promise-assembler:main');
    }
  });

  loadInitializers['default'](App, config['default'].modulePrefix);

  exports['default'] = App;

});
define('ember-inspector/components/action-checkbox', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Component = Ember['default'].Component;

  exports['default'] = Component.extend({
    tagName: 'input',
    attributeBindings: ['type', 'checked'],
    type: 'checkbox',

    checked: false,

    change: function change() {
      this._updateElementValue();
    },

    _updateElementValue: function _updateElementValue() {
      this.set('checked', this.$().prop('checked'));
      this.sendAction('on-update', this.get('checked'));
    }
  });

});
define('ember-inspector/components/clear-button', ['exports', 'ember-inspector/components/icon-button'], function (exports, IconButton) {

  'use strict';

  exports['default'] = IconButton['default'].extend({
    title: 'Clear'
  });

});
define('ember-inspector/components/date-property-field', ['exports', 'ember', 'ember-inspector/components/pikaday-input'], function (exports, Ember, DatePicker) {

  'use strict';

  var on = Ember['default'].on;
  var once = Ember['default'].run.once;

  var KEY_EVENTS = {
    enter: 13,
    escape: 27
  };

  exports['default'] = DatePicker['default'].extend({
    attributeBindings: ['label:data-label'],

    openDatePicker: on('didInsertElement', function () {
      once(this.$(), 'click');
    }),

    keyUp: function keyUp(e) {
      if (e.keyCode === KEY_EVENTS.enter) {
        this.insertNewline();
      } else if (e.keyCode === KEY_EVENTS.escape) {
        this.cancel();
      }
    },

    insertNewline: function insertNewline() {
      this.sendAction('save-property');
      this.sendAction('finished-editing');
    },

    cancel: function cancel() {
      this.sendAction('finished-editing');
    }
  });

});
define('ember-inspector/components/drag-handle', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var SafeString = Ember['default'].Handlebars.SafeString;

  exports['default'] = Ember['default'].Component.extend({
    classNames: ['drag-handle'],
    classNameBindings: ['isLeft:drag-handle--left', 'isRight:drag-handle--right', 'class'],
    attributeBindings: ['style'],
    position: 0,
    side: '',
    isRight: Ember['default'].computed.equal('side', 'right'),
    isLeft: Ember['default'].computed.equal('side', 'left'),
    minWidth: 60,

    startDragging: function startDragging() {
      var _this = this;

      var $container = this.$().parent();
      var $containerOffsetLeft = $container.offset().left;
      var $containerOffsetRight = $containerOffsetLeft + $container.width();
      var namespace = 'drag-' + this.get('elementId');

      this.sendAction('action', true);

      Ember['default'].$('body').on('mousemove.' + namespace, function (e) {
        var position = _this.get('isLeft') ? e.pageX - $containerOffsetLeft : $containerOffsetRight - e.pageX;

        if (position >= _this.get('minWidth')) {
          _this.set('position', position);
        }
      }).on('mouseup.' + namespace + ' mouseleave.' + namespace, function () {
        _this.stopDragging();
      });
    },

    stopDragging: function stopDragging() {
      this.sendAction('action', false);
      Ember['default'].$('body').off('.drag-' + this.get('elementId'));
    },

    willDestroyElement: function willDestroyElement() {
      this._super();
      this.stopDragging();
    },

    mouseDown: function mouseDown() {
      this.startDragging();
      return false;
    },

    style: computed('side', 'position', function () {
      if (this.get('side')) {
        return new SafeString(this.get('side') + ': ' + this.get('position') + 'px;');
      }
      return '';
    })
  });

});
define('ember-inspector/components/draggable-column', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  // DraggableColumn
  // ===============
  // A wrapper for a resizable-column and a drag-handle component

  var Component = Ember['default'].Component;
  var computed = Ember['default'].computed;

  exports['default'] = Component.extend({
    tagName: '', // Prevent wrapping in a div
    side: 'left',
    minWidth: 60,
    setIsDragging: 'setIsDragging',
    classes: computed('classNames.[]', function () {
      return this.get('classNames').join(' ');
    }),
    actions: {
      setIsDragging: function setIsDragging(isDragging) {
        this.sendAction('setIsDragging', isDragging);
      }
    }
  });

});
define('ember-inspector/components/icon-button', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Component = Ember['default'].Component;

  exports['default'] = Component.extend({
    attributeBindings: ['dataLabel:data-label', 'title'],

    tagName: 'button',

    title: null,

    click: function click() {
      this.sendAction();
    }
  });

});
define('ember-inspector/components/pikaday-input', ['exports', 'ember', 'ember-pikaday/components/pikaday-input'], function (exports, Ember, PikadayInputComponent) {

	'use strict';

	exports['default'] = PikadayInputComponent['default'];

});
define('ember-inspector/components/property-field', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].TextField.extend({
    attributeBindings: ['label:data-label'],

    didInsertElement: function didInsertElement() {
      this._super();
      this.$().select();
    },

    insertNewline: function insertNewline() {
      this.sendAction('save-property');
      this.sendAction('finished-editing');
    },

    cancel: function cancel() {
      this.sendAction('finished-editing');
    },

    focusOut: function focusOut() {
      this.sendAction('finished-editing');
    }
  });

});
define('ember-inspector/components/record-item', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Component = Ember['default'].Component;
  var computed = Ember['default'].computed;
  var SafeString = Ember['default'].Handlebars.SafeString;
  var isEmpty = Ember['default'].isEmpty;

  var COLOR_MAP = {
    red: '#ff2717',
    blue: '#174fff',
    green: '#006400'
  };

  exports['default'] = Component.extend({
    modelTypeColumns: null,

    classNames: ['list-tree__item', 'row', 'row_highlight'],

    attributeBindings: ['label:data-label'],

    label: 'record-row',

    // TODO: Color record based on `color` property.
    style: computed('model.color', function () {
      var colorName = this.get('model.color');
      if (!isEmpty(colorName)) {
        var color = COLOR_MAP[colorName];
        if (color) {
          return new SafeString('color: ' + color + ';');
        }
      }
      return '';
    }),

    columns: computed('modelTypeColumns.@each', 'model.columnValues', function () {
      var _this = this;

      var columns = this.get('modelTypeColumns') || [];
      return columns.map(function (col) {
        return { name: col.name, value: _this.get('model.columnValues.' + col.name) };
      });
    }),

    click: function click() {
      this.sendAction('inspect', this.get('model'));
      return false;
    }
  });

});
define('ember-inspector/components/reload-button', ['exports', 'ember-inspector/components/icon-button'], function (exports, IconButton) {

  'use strict';

  exports['default'] = IconButton['default'].extend({
    title: 'Reload'
  });

});
define('ember-inspector/components/resizable-column', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Component = Ember['default'].Component;
  var computed = Ember['default'].computed;
  var SafeString = Ember['default'].Handlebars.SafeString;

  exports['default'] = Component.extend({
    width: null,

    attributeBindings: ['style'],

    style: computed('width', function () {
      return new SafeString('-webkit-flex: none; flex: none; width: ' + this.get('width') + 'px;');
    }),

    didInsertElement: function didInsertElement() {
      if (!this.get('width')) {
        this.set('width', this.$().width());
      }
    }
  });

});
define('ember-inspector/components/route-item', ['exports', 'ember', 'ember-inspector/utils/check-current-route'], function (exports, Ember, checkCurrentRoute) {

  'use strict';

  var Component = Ember['default'].Component;
  var computed = Ember['default'].computed;
  var SafeString = Ember['default'].Handlebars.SafeString;

  exports['default'] = Component.extend({
    // passed as an attribute to the component
    currentRoute: null,

    classNames: ['list-tree__item', 'row'],
    classNameBindings: ['isCurrent:row_highlight'],
    attributeBindings: ['label:data-label'],

    label: 'route-node',

    labelStyle: computed('model.parentCount', function () {
      return new SafeString('padding-left: ' + (+this.get('model.parentCount') * 20 + 5) + 'px;');
    }),

    isCurrent: computed('currentRoute', 'model.value.name', function () {
      var currentRoute = this.get('currentRoute');
      if (!currentRoute) {
        return false;
      }

      return checkCurrentRoute['default'](currentRoute, this.get('model.value.name'));
    })
  });

});
define('ember-inspector/components/send-to-console', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Component.extend({
    tagName: 'button',
    classNames: ['send-to-console'],
    attributeBindings: ['dataLabel:data-label'],
    dataLabel: 'send-to-console-btn',
    action: 'sendValueToConsole',
    click: function click() {
      this.sendAction('action', this.get('param'));
    }
  });

});
define('ember-inspector/components/sidebar-toggle', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Component.extend({

    tagName: 'button',

    side: 'right',

    isExpanded: false,

    isRight: Ember['default'].computed.equal('side', 'right'),

    classNames: 'sidebar-toggle',

    classNameBindings: 'isRight:sidebar-toggle--right:sidebar-toggle--left',

    click: function click() {
      this.sendAction();
    }

  });

});
define('ember-inspector/components/view-item', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var Component = Ember['default'].Component;
  var SafeString = Ember['default'].Handlebars.SafeString;
  var not = computed.not;
  var bool = computed.bool;

  exports['default'] = Component.extend({
    classNames: ['list-tree__item', 'row'],

    classNameBindings: ['isCurrent:row_highlight'],

    hasView: not('model.value.isVirtual'),
    hasElement: not('model.value.isVirtual'),
    hasModel: bool('model.value.model'),

    // passed as an attribute
    pinnedObjectId: null,

    isCurrent: computed('pinnedObjectId', 'model.value.objectId', function () {
      return this.get('pinnedObjectId') === this.get('model.value.objectId');
    }),

    hasController: bool('model.value.controller'),

    modelInspectable: computed('hasModel', 'model.value.model.type', function () {
      return this.get('hasModel') && this.get('model.value.model.type') === 'type-ember-object';
    }),

    labelStyle: computed('model.parentCount', function () {
      return new SafeString('padding-left: ' + (+this.get('model.parentCount') * 20 + 5) + 'px;');
    }),

    actions: {
      inspectView: function inspectView() {
        if (this.get('hasView')) {
          this.sendAction('inspect', this.get('model.value.objectId'));
        }
      },
      inspectElement: function inspectElement(objectId) {
        if (!objectId && this.get('hasElement')) {
          objectId = this.get('model.value.objectId');
        }

        if (objectId) {
          this.sendAction('inspectElement', objectId);
        }
      },
      inspectModel: function inspectModel(objectId) {
        if (this.get('modelInspectable')) {
          this.sendAction('inspect', objectId);
        }
      }
    }

  });

});
define('ember-inspector/computed/custom-filter', ['exports', 'ember'], function (exports, Ember) {

  'use strict';


  exports['default'] = filterComputed;
  function filterComputed() {
    var dependentKeys = undefined,
        callback = undefined;

    if (arguments.length > 1) {
      var slice = [].slice;
      dependentKeys = slice.call(arguments, 0, -1);
      callback = slice.call(arguments, -1)[0];
    }
    var options = {
      initialize: function initialize(array, changeMeta, instanceMeta) {
        instanceMeta.filteredArrayIndexes = new Ember['default'].SubArray();
      },

      addedItem: function addedItem(array, item, changeMeta, instanceMeta) {
        var match = !!callback.call(this, item);
        var filterIndex = instanceMeta.filteredArrayIndexes.addItem(changeMeta.index, match);

        if (match) {
          array.insertAt(filterIndex, item);
        }

        return array;
      },

      removedItem: function removedItem(array, item, changeMeta, instanceMeta) {
        var filterIndex = instanceMeta.filteredArrayIndexes.removeItem(changeMeta.index);

        if (filterIndex > -1) {
          array.removeAt(filterIndex);
        }

        return array;
      }
    };
    var args = dependentKeys;
    args.push(options);

    /*jshint validthis:true */
    return Ember['default'].arrayComputed.apply(this, args);
  }

});
define('ember-inspector/computed/debounce', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var run = Ember['default'].run;
  var computed = Ember['default'].computed;
  var debounce = run.debounce;

  // Use this if you want a property to debounce
  // another property with a certain delay.
  // This means that every time this prop changes,
  // the other prop will change to the same val after [delay]
  exports['default'] = function (prop, delay, callback) {
    var value = undefined;

    var updateVal = function updateVal() {
      this.set(prop, value);
      if (callback) {
        callback.call(this);
      }
    };

    return computed(function (key, val) {
      if (arguments.length > 1) {
        value = val;
        debounce(this, updateVal, delay);
        return val;
      }
    });
  }

});
define('ember-inspector/controllers/application', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var _Ember$computed = Ember['default'].computed;
  var readOnly = _Ember$computed.readOnly;
  var equal = _Ember$computed.equal;

  exports['default'] = Ember['default'].Controller.extend({
    needs: ['mixin-stack', 'mixin-details'],

    emberApplication: false,
    navWidth: 180,
    inspectorWidth: 360,
    mixinStack: readOnly('controllers.mixin-stack'),
    mixinDetails: readOnly('controllers.mixin-details'),
    isChrome: equal('port.adapter.name', 'chrome'),

    deprecationCount: 0,

    // Indicates that the extension window is focused,
    active: true,

    inspectorExpanded: false,

    pushMixinDetails: function pushMixinDetails(name, property, objectId, details, errors) {
      details = {
        name: name,
        property: property,
        objectId: objectId,
        mixins: details,
        errors: errors
      };

      this.get('mixinStack').pushObject(details);
      this.set('mixinDetails.model', details);
    },

    popMixinDetails: function popMixinDetails() {
      var mixinStack = this.get('controllers.mixin-stack');
      var item = mixinStack.popObject();
      this.set('mixinDetails.model', mixinStack.get('lastObject'));
      this.get('port').send('objectInspector:releaseObject', { objectId: item.objectId });
    },

    activateMixinDetails: function activateMixinDetails(name, objectId, details, errors) {
      var _this = this;

      this.get('mixinStack').forEach(function (item) {
        _this.get('port').send('objectInspector:releaseObject', { objectId: item.objectId });
      });

      this.set('mixinStack.model', []);
      this.pushMixinDetails(name, undefined, objectId, details, errors);
    },

    droppedObject: function droppedObject(objectId) {
      var mixinStack = this.get('mixinStack.model');
      var obj = mixinStack.findProperty('objectId', objectId);
      if (obj) {
        var index = mixinStack.indexOf(obj);
        var objectsToRemove = [];
        for (var i = index; i >= 0; i--) {
          objectsToRemove.pushObject(mixinStack.objectAt(i));
        }
        objectsToRemove.forEach(function (item) {
          mixinStack.removeObject(item);
        });
      }
      if (mixinStack.get('length') > 0) {
        this.set('mixinDetails.model', mixinStack.get('lastObject'));
      } else {
        this.set('mixinDetails.model', null);
      }
    }
  });

});
define('ember-inspector/controllers/container-type', ['exports', 'ember', 'ember-inspector/computed/debounce', 'ember-inspector/utils/search-match'], function (exports, Ember, debounceComputed, searchMatch) {

  'use strict';

  var ArrayController = Ember['default'].ArrayController;
  var computed = Ember['default'].computed;
  var get = Ember['default'].get;
  var filter = computed.filter;

  exports['default'] = ArrayController.extend({
    needs: ['application'],
    sortProperties: ['name'],

    searchVal: debounceComputed['default']('search', 300),

    search: null,

    arrangedContent: filter('model', function (item) {
      return searchMatch['default'](get(item, 'name'), this.get('search'));
    }).property('model.@each.name', 'search')
  });

});
define('ember-inspector/controllers/container-types', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Controller = Ember['default'].Controller;
  var sort = Ember['default'].computed.sort;

  exports['default'] = Controller.extend({
    sortProperties: ['name'],
    sorted: sort('model', 'sortProperties')
  });

});
define('ember-inspector/controllers/deprecation-item', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Controller = Ember['default'].Controller;
  var computed = Ember['default'].computed;
  var notEmpty = computed.notEmpty;

  exports['default'] = Controller.extend({
    isExpanded: true,

    hasMap: notEmpty('model.hasSourceMap'),

    expandedClass: computed('hasMap', 'isExpanded', function () {
      if (this.get('isExpanded')) {
        return 'row_arrow_expanded';
      } else {
        return 'row_arrow_collapsed';
      }
    }),

    actions: {
      toggleExpand: function toggleExpand() {
        this.toggleProperty('isExpanded');
      }

    }
  });

});
define('ember-inspector/controllers/deprecation-source', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Controller = Ember['default'].Controller;
  var computed = Ember['default'].computed;
  var bool = computed.bool;
  var readOnly = computed.readOnly;
  var and = computed.and;

  exports['default'] = Controller.extend({
    known: bool('model.map.source'),

    url: computed('model.map.source', 'model.map.line', 'known', function () {
      var source = this.get('model.map.source');
      if (this.get('known')) {
        return source + ':' + this.get('model.map.line');
      } else {
        return 'Unkown source';
      }
    }),

    adapter: readOnly('port.adapter'),

    isClickable: and('known', 'adapter.canOpenResource')
  });

});
define('ember-inspector/controllers/deprecations', ['exports', 'ember', 'ember-inspector/computed/debounce', 'ember-inspector/utils/search-match'], function (exports, Ember, debounceComputed, searchMatch) {

  'use strict';

  var Controller = Ember['default'].Controller;
  var computed = Ember['default'].computed;
  var get = Ember['default'].get;
  var filter = computed.filter;

  exports['default'] = Controller.extend({
    needs: ['application'],
    search: null,
    searchVal: debounceComputed['default']('search', 300),
    filtered: filter('model', function (item) {
      return searchMatch['default'](get(item, 'message'), this.get('search'));
    }).property('model.@each.message', 'search')
  });

});
define('ember-inspector/controllers/iframes', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var ArrayController = Ember['default'].ArrayController;
  var computed = Ember['default'].computed;
  var run = Ember['default'].run;
  var observer = Ember['default'].observer;
  var alias = computed.alias;
  var map = computed.map;

  exports['default'] = ArrayController.extend({
    model: map('port.detectedApplications', function (item) {
      var name = item.split('__');
      return {
        name: name[1],
        val: item
      };
    }),

    selectedApp: alias('port.applicationId'),

    selectedDidChange: observer('selectedApp', function () {
      // Change iframe being debugged
      var url = '/';
      var applicationId = this.get('selectedApp');
      var list = this.get('port').get('detectedApplications');
      var app = this.container.lookup('application:main');

      run(app, app.reset);
      var router = app.__container__.lookup('router:main');
      var port = app.__container__.lookup('port:main');
      port.set('applicationId', applicationId);
      port.set('detectedApplications', list);

      // start
      router.location.setURL(url);
      run(app, app.handleURL, url);
    })
  });

});
define('ember-inspector/controllers/info', ['exports', 'ember'], function (exports, Ember) {

	'use strict';

	var Controller = Ember['default'].Controller;

	exports['default'] = Controller;

});
define('ember-inspector/controllers/mixin-detail', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var oneWay = computed.oneWay;

  exports['default'] = Ember['default'].ObjectController.extend({
    needs: ['mixin-details'],

    mixinDetails: oneWay('controllers.mixin-details').readOnly(),
    objectId: oneWay('mixinDetails.model.objectId').readOnly(),

    isExpanded: computed('model.expand', 'model.properties.length', function () {
      return this.get('model.expand') && this.get('model.properties.length') > 0;
    }),

    actions: {
      calculate: function calculate(property) {
        var objectId = this.get('objectId');
        var mixinIndex = this.get('mixinDetails.model.mixins').indexOf(this.get('model'));

        this.get('port').send('objectInspector:calculate', {
          objectId: objectId,
          property: property.name,
          mixinIndex: mixinIndex
        });
      },

      sendToConsole: function sendToConsole(property) {
        var objectId = this.get('objectId');

        this.get('port').send('objectInspector:sendToConsole', {
          objectId: objectId,
          property: property.name
        });
      },

      toggleExpanded: function toggleExpanded() {
        this.toggleProperty('isExpanded');
      },

      digDeeper: function digDeeper(property) {
        var objectId = this.get('objectId');

        this.get('port').send('objectInspector:digDeeper', {
          objectId: objectId,
          property: property.name
        });
      },

      saveProperty: function saveProperty(prop, val, type) {
        var mixinIndex = this.get('mixinDetails.model.mixins').indexOf(this.get('model'));

        this.get('port').send('objectInspector:saveProperty', {
          objectId: this.get('objectId'),
          property: prop,
          value: val,
          mixinIndex: mixinIndex,
          dataType: type
        });
      }
    }
  });

});
define('ember-inspector/controllers/mixin-details', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Controller = Ember['default'].Controller;

  exports['default'] = Controller.extend({
    actions: {
      traceErrors: function traceErrors() {
        this.get('port').send('objectInspector:traceErrors', {
          objectId: this.get('model.objectId')
        });
      }
    }
  });

});
define('ember-inspector/controllers/mixin-property', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var equal = computed.equal;
  var alias = computed.alias;

  exports['default'] = Ember['default'].ObjectController.extend({
    isEdit: false,

    // Bound to editing textbox
    txtValue: null,
    dateValue: null,

    isCalculated: computed('value.type', function () {
      return this.get('value.type') !== 'type-descriptor';
    }),

    isEmberObject: equal('value.type', 'type-ember-object'),

    isComputedProperty: alias('value.computed'),

    isFunction: equal('value.type', 'type-function'),

    isArray: equal('value.type', 'type-array'),

    isDate: equal('value.type', 'type-date'),

    _parseTextValue: function _parseTextValue(value) {
      var parsedValue = undefined;
      try {
        parsedValue = JSON.parse(value);
      } catch (e) {
        // if surrounded by quotes, remove quotes
        var match = value.match(/^"(.*)"$/);
        if (match && match.length > 1) {
          parsedValue = match[1];
        } else {
          parsedValue = value;
        }
      }
      return parsedValue;
    },

    actions: {
      valueClick: function valueClick() {
        if (this.get('isEmberObject') || this.get('isArray')) {
          this.get('target').send('digDeeper', this.get('model'));
          return;
        }

        if (this.get('isComputedProperty') && !this.get('isCalculated')) {
          this.get('target').send('calculate', this.get('model'));
          return;
        }

        if (this.get('isFunction') || this.get('overridden') || this.get('readOnly')) {
          return;
        }

        var value = this.get('value.inspect');
        var type = this.get('value.type');
        if (type === 'type-string') {
          value = '"' + value + '"';
        }
        if (!this.get('isDate')) {
          this.set('txtValue', value);
        } else {
          this.set('dateValue', new Date(value));
        }
        this.set('isEdit', true);
      },

      saveProperty: function saveProperty() {
        var realValue = undefined,
            dataType = undefined;
        if (!this.get('isDate')) {
          realValue = this._parseTextValue(this.get('txtValue'));
        } else {
          realValue = this.get('dateValue').getTime();
          dataType = 'date';
        }
        this.get('target').send('saveProperty', this.get('name'), realValue, dataType);
      },

      finishedEditing: function finishedEditing() {
        this.set('isEdit', false);
      }
    }
  });

});
define('ember-inspector/controllers/mixin-stack', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;

  exports['default'] = Ember['default'].ArrayController.extend({
    needs: ['application'],

    trail: computed('[]', function () {
      var nested = this.slice(1);
      if (nested.length === 0) {
        return "";
      }
      return "." + nested.mapProperty('property').join(".");
    }),

    isNested: computed('[]', function () {
      return this.get('length') > 1;
    }),

    actions: {
      popStack: function popStack() {
        if (this.get('isNested')) {
          this.get('controllers.application').popMixinDetails();
        }
      },

      sendObjectToConsole: function sendObjectToConsole(obj) {
        var objectId = Ember['default'].get(obj, 'objectId');
        this.get('port').send('objectInspector:sendToConsole', {
          objectId: objectId
        });
      }
    }
  });

});
define('ember-inspector/controllers/model-type-item', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var oneWay = computed.oneWay;

  exports['default'] = Ember['default'].ObjectController.extend({
    needs: ['model-types'],

    modelTypes: oneWay('controllers.model-types').readOnly(),

    selected: computed('modelTypes.selected', function () {
      return this.get('model') === this.get('modelTypes.selected');
    })
  });

});
define('ember-inspector/controllers/model-types', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var Controller = Ember['default'].Controller;
  var _Ember$computed = Ember['default'].computed;
  var sort = _Ember$computed.sort;
  var filter = _Ember$computed.filter;
  var get = Ember['default'].get;

  exports['default'] = Controller.extend({
    navWidth: 180,
    sortProperties: ['name'],
    options: {
      hideEmptyModelTypes: false
    },

    sorted: sort('filtered', 'sortProperties'),

    filtered: filter('model', function (typeItem) {
      var hideEmptyModels = get(this, 'options.hideEmptyModelTypes');

      if (hideEmptyModels) {
        return !!get(typeItem, 'count');
      } else {
        return true;
      }
    }).property('model', 'options.hideEmptyModelTypes')
  });

});
define('ember-inspector/controllers/promise-item', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  var computed = Ember['default'].computed;
  var SafeString = Ember['default'].Handlebars.SafeString;
  var alias = computed.alias;
  var notEmpty = computed.notEmpty;
  var empty = computed.empty;
  var gt = computed.gt;
  var equal = computed.equal;

  var COLOR_MAP = {
    red: '#ff2717',
    blue: '#174fff',
    green: '#006400'
  };

  exports['default'] = Ember['default'].ObjectProxy.extend({
    promiseTreeController: computed(function () {
      return this.container.lookup('controller:promiseTree');
    }),

    filter: alias('promiseTreeController.filter'),
    effectiveSearch: alias('promiseTreeController.effectiveSearch'),

    model: alias('content'),

    isError: equal('reason.type', 'type-error'),

    style: computed('model.state', function () {
      var color = '';
      if (this.get('isFulfilled')) {
        color = 'green';
      } else if (this.get('isRejected')) {
        color = 'red';
      } else {
        color = 'blue';
      }
      return new SafeString('background-color: ' + COLOR_MAP[color] + '; color: white;');
    }),

    nodeStyle: computed('state', 'filter', 'effectiveSearch', function () {
      var relevant = undefined;
      switch (this.get('filter')) {
        case 'pending':
          relevant = this.get('isPending');
          break;
        case 'rejected':
          relevant = this.get('isRejected');
          break;
        case 'fulfilled':
          relevant = this.get('isFulfilled');
          break;
        default:
          relevant = true;
      }
      if (relevant && !Ember['default'].isEmpty(this.get('effectiveSearch'))) {
        relevant = this.get('model').matchesExactly(this.get('effectiveSearch'));
      }
      if (!relevant) {
        return new SafeString('opacity: 0.3;');
      }
    }),

    labelStyle: computed('level', function () {
      return new SafeString('padding-left: ' + (+this.get('level') * 20 + 5) + 'px;');
    }),

    expandedClass: computed('hasChildren', 'isExpanded', function () {
      if (!this.get('hasChildren')) {
        return;
      }

      if (this.get('isExpanded')) {
        return 'row_arrow_expanded';
      } else {
        return 'row_arrow_collapsed';
      }
    }),

    hasChildren: gt('children.length', 0),

    isTopNode: empty('parent'),

    settledValue: computed('value', function () {
      if (this.get('isFulfilled')) {
        return this.get('value');
      } else if (this.get('isRejected')) {
        return this.get('reason');
      } else {
        return '--';
      }
    }),

    isValueInspectable: notEmpty('settledValue.objectId'),

    hasValue: computed('settledValue', 'isSettled', function () {
      return this.get('isSettled') && this.get('settledValue.type') !== 'type-undefined';
    }),

    label: computed('model.label', function () {
      return this.get('model.label') || !!this.get('model.parent') && 'Then' || '<Unknown Promise>';
    }),

    state: computed('model.state', function () {
      if (this.get('isFulfilled')) {
        return 'Fulfilled';
      } else if (this.get('isRejected')) {
        return 'Rejected';
      } else if (this.get('parent') && !this.get('parent.isSettled')) {
        return 'Waiting for parent';
      } else {
        return 'Pending';
      }
    }),

    timeToSettle: computed('createdAt', 'settledAt', 'parent.settledAt', function () {
      if (!this.get('createdAt') || !this.get('settledAt')) {
        return ' -- ';
      }
      var startedAt = this.get('parent.settledAt') || this.get('createdAt');
      var remaining = this.get('settledAt').getTime() - startedAt.getTime();
      return remaining;
    })
  });

});
define('ember-inspector/controllers/promise-tree', ['exports', 'ember', 'ember-inspector/computed/custom-filter'], function (exports, Ember, filterComputed) {

  'use strict';

  var computed = Ember['default'].computed;
  var observer = Ember['default'].observer;
  var equal = computed.equal;
  var bool = computed.bool;
  var and = computed.and;
  var not = computed.not;

  // Manual implementation of item controllers
  function itemProxyComputed(dependentKey, itemProxy) {
    var options = {
      addedItem: function addedItem(array, item, changeMeta) {
        var proxy = itemProxy.create({ content: item });
        array.insertAt(changeMeta.index, proxy);
        return array;
      },
      removedItem: function removedItem(array, item, changeMeta) {
        var proxy = array.objectAt(changeMeta.index);
        array.removeAt(changeMeta.index, 1);
        proxy.destroy();
        return array;
      }
    };

    return Ember['default'].arrayComputed(dependentKey, options);
  }

  exports['default'] = Ember['default'].ArrayController.extend({
    needs: ['application'],

    queryParams: ['filter'],

    createdAfter: null,

    // below used to show the "refresh" message
    isEmpty: equal('model.length', 0),
    wasCleared: bool('createdAfter'),
    neverCleared: not('wasCleared'),
    shouldRefresh: and('isEmpty', 'neverCleared'),

    // Keep track of promise stack traces.
    // It is opt-in due to performance reasons.
    instrumentWithStack: false,

    init: function init() {
      this._super.apply(this, arguments);
      // List-view does not support item controllers
      this.reopen({
        items: itemProxyComputed('filtered', this.get('promiseItemController'))
      });
    },

    promiseItemController: computed(function () {
      return this.container.lookupFactory('controller:promise-item');
    }),

    /* jscs:disable validateIndentation */
    // TODO: This filter can be further optimized
    filtered: filterComputed['default']('model.@each.createdAt', 'model.@each.fulfilledBranch', 'model.@each.rejectedBranch', 'model.@each.pendingBranch', 'model.@each.isVisible', function (item) {

      // exclude cleared promises
      if (this.get('createdAfter') && item.get('createdAt') < this.get('createdAfter')) {
        return false;
      }

      if (!item.get('isVisible')) {
        return false;
      }

      // Exclude non-filter complying promises
      // If at least one of their children passes the filter,
      // then they pass
      var include = true;
      if (this.get('filter') === 'pending') {
        include = item.get('pendingBranch');
      } else if (this.get('filter') === 'rejected') {
        include = item.get('rejectedBranch');
      } else if (this.get('filter') === 'fulfilled') {
        include = item.get('fulfilledBranch');
      }
      if (!include) {
        return false;
      }

      // Search filter
      // If they or at least one of their children
      // match the search, then include them
      var search = this.get('effectiveSearch');
      if (!E