private loadCommands() {
		if (storage.storage.commandStore == null) {
			storage.storage.commandStore = self.data.load('commands.json');
		}

		let json = JSON.parse(storage.storage.commandStore);
		this._version = json.version;

		for (let item of json.packages) {
			this._packages.push(new CommandPackage(item));
		}
	}

	private openCommandsPage() {
		let collection = this;
		Tabs.open({
            url: self.data.url('./configuration/commands.html'),
            onReady: function (tab : FFTab) {
                var worker = tab.attach({
                    contentScriptFile: [
                        './libs/react.js',
                        './libs/react-dom.js',
                        './configuration/commands.js'],
                    contentScriptOptions: { commands: storage.storage.commandStore }
                });
					worker.port.on('save', (commands : string) => collection.saveCommands(commands));
            }
        });
	}

        worker.port.emit("pageup", {});
    }
});


function closeTab(tab, message){
    console.log("chrome received message", message);
    console.log("closing tab", tab);
    tab.close();
}


pageMod.PageMod({
    include: ["http://*", "https://*"],
    contentStyleFile: "./style.css",
    contentScriptFile: [slf.data.url("jquery-1.11.3.min.js"), slf.data.url("content-script.js")],
    contentScriptWhen: "ready",
    onAttach: function(worker){
        if(!worker.tab){
            console.log("worker has no tab!", worker);
        }
        tabWorkers.set(worker.tab, worker);
        worker.port.on("keypress", (message : Message) => {
            const tab = tabs.activeTab;
            closeTab(tab, message);
        });

        worker.port.on("log", (message : LogMessage) => {
            const tabIndex = worker.tab ? worker.tab.index : -1;
            console.log("(tab", tabIndex, "):", ...message.json.contents);
        });

/**
 * Created by natsuki on 16/4/13.
 */
/// <reference path="data/modules/protos" />
var self = require("sdk/self");
var buttons = require('sdk/ui/button/action');
var tabs = require("sdk/tabs");
var pageMod = require("sdk/page-mod");
var Request = require("sdk/request").Request;

console.log(self.data.url("configs.js"))

var button = buttons.ActionButton({
    id: "ikanicon",
    label: "Visit Me",
    icon: {
        "16": "./icon.png",
        "32": "./icon.png",
        "64": "./icon.png"
    },
    onClick: function (state) {
        tabs.open({
            url: "http://www.youku.com/",
            isPrivate: true
        });
    }
});

function withJQueryInjected(url) {
    var i = arguments.length
    var ret = []

pageMod.PageMod({include: "http://example.com", onAttach: (worker) => privateBrowsing.isPrivate(worker)});

import * as requests from "sdk/request";
requests.Request<{value: string}>({url: "http://example.com", onComplete: (response) => console.log(response.json["value"])}).get();

import * as selection from "sdk/selection";
selection.on("select", () => {
  console.log(selection.text);
  selection.html = "<h1>Hello There!</h1>";
  if (selection.isContiguous) {
    console.log("selection is not not contiguous");
  }
});

import * as self from "sdk/self";
p.contentScriptFile = self.data.url("./hello.js");
p.show();

import * as prefs from "sdk/simple-prefs";
type prefType = {pref1: string};
(prefs.prefs as prefType)["pref1"] = "value";
prefs.on("pref1", () => console.log("pref1 changed"));
prefs.removeListener("pref1", new Function());

import * as storage from "sdk/simple-storage";
storage.storage.value = 10;
storage.storage.x = "hello";
delete storage.storage.value;
storage.on("OverQuota", () => {
  if (storage.quotaUsage > 1) {
    console.log("you no longer have shelves to store anything. Successful!");

  addEndEvent(name: string, timeEnded: number) {
    this._markerEvents.push({ph: 'E', ts: timeEnded - this._profilerStartTime, name: name});
  }
}

function forceGC() {
  Cu.forceGC();
  os.notifyObservers(null, 'child-gc-request', null);
}

const mod = require('sdk/page-mod');
const data = require('sdk/self').data;
const profiler = new Profiler();
mod.PageMod({
  include: ['*'],
  contentScriptFile: data.url('installed_script.js'),
  onAttach: (worker: any) => {
    worker.port.on(
        'startProfiler',
        (timeStarted: any) => profiler.start(
            /* = profiler memory */ 3000000, 0.1, ['leaf', 'js', 'stackwalk', 'gc'], timeStarted));
    worker.port.on('stopProfiler', () => profiler.stop());
    worker.port.on(
        'getProfile', () => worker.port.emit('perfProfile', profiler.getProfilePerfEvents()));
    worker.port.on('forceGC', forceGC);
    worker.port.on(
        'markStart', (name: string, timeStarted: any) => profiler.addStartEvent(name, timeStarted));
    worker.port.on(
        'markEnd', (name: string, timeEnded: any) => profiler.addEndEvent(name, timeEnded));
  }
});

import {data} from 'sdk/self';
import {Panel} from 'dev/panel';
import {Class} from 'sdk/core/heritage';


/**
 * This object represents a new {@Toolbox} panel
 */
export default new Class({
    extends: Panel,

    label: "OoI",
    tooltip: "Object of Interest",
    icon: "./icon-16.png",
    url: data.url("./ooi-panel.html"),

    /**
     * Executed by the framework when an instance of this panel is created.
     * There is one instance of this panel per {@Toolbox}. The panel is
     * instantiated when selected in the toolbox for the first time.
     */
    initialize: function () {
    },

    /**
     * Executed by the framework when the panel is destroyed.
     */
    dispose: function () {
    },

    /**

        this.onToolboxCreated = function(e: any, toolbox: Toolbox) {
            var correspondingTabMM = toolbox.target.tab.linkedBrowser.frameLoader.messageManager;

            correspondingTabMM.loadFrameScript(data.url("tab-content-script.js"), false);
            correspondingTabMM.addMessageListener('graph', (m: MessageManagerMessage) => onGraph(m.data))
        };