diff options
Diffstat (limited to 'addon-sdk/source/lib/dev')
| -rw-r--r-- | addon-sdk/source/lib/dev/debuggee.js | 95 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/frame-script.js | 120 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/panel.js | 259 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/panel/view.js | 14 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/ports.js | 64 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/theme.js | 135 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/theme/hooks.js | 17 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/toolbox.js | 107 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/utils.js | 40 | ||||
| -rw-r--r-- | addon-sdk/source/lib/dev/volcan.js | 3848 |
10 files changed, 4699 insertions, 0 deletions
diff --git a/addon-sdk/source/lib/dev/debuggee.js b/addon-sdk/source/lib/dev/debuggee.js new file mode 100644 index 000000000..0ca0bd37a --- /dev/null +++ b/addon-sdk/source/lib/dev/debuggee.js @@ -0,0 +1,95 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { Cu } = require("chrome"); +const { Class } = require("../sdk/core/heritage"); +const { MessagePort, MessageChannel } = require("../sdk/messaging"); +const { require: devtoolsRequire } = Cu.import("resource://devtools/shared/Loader.jsm", {}); +const { DebuggerServer } = devtoolsRequire("devtools/server/main"); + +const outputs = new WeakMap(); +const inputs = new WeakMap(); +const targets = new WeakMap(); +const transports = new WeakMap(); + +const inputFor = port => inputs.get(port); +const outputFor = port => outputs.get(port); +const transportFor = port => transports.get(port); + +const fromTarget = target => { + const debuggee = new Debuggee(); + const { port1, port2 } = new MessageChannel(); + inputs.set(debuggee, port1); + outputs.set(debuggee, port2); + targets.set(debuggee, target); + + return debuggee; +}; +exports.fromTarget = fromTarget; + +const Debuggee = Class({ + extends: MessagePort.prototype, + close: function() { + const server = transportFor(this); + if (server) { + transports.delete(this); + server.close(); + } + outputFor(this).close(); + }, + start: function() { + const target = targets.get(this); + if (target.isLocalTab) { + // Since a remote protocol connection will be made, let's start the + // DebuggerServer here, once and for all tools. + if (!DebuggerServer.initialized) { + DebuggerServer.init(); + DebuggerServer.addBrowserActors(); + } + + transports.set(this, DebuggerServer.connectPipe()); + } + // TODO: Implement support for remote connections (See Bug 980421) + else { + throw Error("Remote targets are not yet supported"); + } + + // pipe messages send to the debuggee to an actual + // server via remote debugging protocol transport. + inputFor(this).addEventListener("message", ({data}) => + transportFor(this).send(data)); + + // pipe messages received from the remote debugging + // server transport onto the this debuggee. + transportFor(this).hooks = { + onPacket: packet => inputFor(this).postMessage(packet), + onClosed: () => inputFor(this).close() + }; + + inputFor(this).start(); + outputFor(this).start(); + }, + postMessage: function(data) { + return outputFor(this).postMessage(data); + }, + get onmessage() { + return outputFor(this).onmessage; + }, + set onmessage(onmessage) { + outputFor(this).onmessage = onmessage; + }, + addEventListener: function(...args) { + return outputFor(this).addEventListener(...args); + }, + removeEventListener: function(...args) { + return outputFor(this).removeEventListener(...args); + } +}); +exports.Debuggee = Debuggee; diff --git a/addon-sdk/source/lib/dev/frame-script.js b/addon-sdk/source/lib/dev/frame-script.js new file mode 100644 index 000000000..33a197419 --- /dev/null +++ b/addon-sdk/source/lib/dev/frame-script.js @@ -0,0 +1,120 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; +(function({content, sendSyncMessage, addMessageListener, sendAsyncMessage}) { + +const Cc = Components.classes; +const Ci = Components.interfaces; +const observerService = Cc["@mozilla.org/observer-service;1"] + .getService(Ci.nsIObserverService); + +const channels = new Map(); +const handles = new WeakMap(); + +// Takes remote port handle and creates a local one. +// also set's up a messaging channel between them. +// This is temporary workaround until Bug 914974 is fixed +// and port can be transfered through message manager. +const demarshal = (handle) => { + if (handle.type === "MessagePort") { + if (!channels.has(handle.id)) { + const channel = new content.MessageChannel(); + channels.set(handle.id, channel); + handles.set(channel.port1, handle); + channel.port1.onmessage = onOutPort; + } + return channels.get(handle.id).port2; + } + return null; +}; + +const onOutPort = event => { + const handle = handles.get(event.target); + sendAsyncMessage("sdk/port/message", { + port: handle, + message: event.data + }); +}; + +const onInPort = ({data}) => { + const channel = channels.get(data.port.id); + if (channel) + channel.port1.postMessage(data.message); +}; + +const onOutEvent = event => + sendSyncMessage("sdk/event/" + event.type, + { type: event.type, + data: event.data }); + +const onInMessage = (message) => { + const {type, data, origin, bubbles, cancelable, ports} = message.data; + + const event = new content.MessageEvent(type, { + bubbles: bubbles, + cancelable: cancelable, + data: data, + origin: origin, + target: content, + source: content, + ports: ports.map(demarshal) + }); + content.dispatchEvent(event); +}; + +const onReady = event => { + channels.clear(); +}; + +addMessageListener("sdk/event/message", onInMessage); +addMessageListener("sdk/port/message", onInPort); + +const observer = { + handleEvent: ({target, type}) => { + observer.observe(target, type); + }, + observe: (document, topic, data) => { + // When frame associated with message manager is removed from document `docShell` + // is set to `null` but observer is still kept alive. At this point accesing + // `content.document` throws "can't access dead object" exceptions. In order to + // avoid leaking observer and logged errors observer is going to be removed when + // `docShell` is set to `null`. + if (!docShell) { + observerService.removeObserver(observer, topic); + } + else if (document === content.document) { + if (topic.endsWith("-document-interactive")) { + sendAsyncMessage("sdk/event/ready", { + type: "ready", + readyState: document.readyState, + uri: document.documentURI + }); + } + if (topic.endsWith("-document-loaded")) { + sendAsyncMessage("sdk/event/load", { + type: "load", + readyState: document.readyState, + uri: document.documentURI + }); + } + if (topic === "unload") { + channels.clear(); + sendAsyncMessage("sdk/event/unload", { + type: "unload", + readyState: "uninitialized", + uri: document.documentURI + }); + } + } + } +}; + +observerService.addObserver(observer, "content-document-interactive", false); +observerService.addObserver(observer, "content-document-loaded", false); +observerService.addObserver(observer, "chrome-document-interactive", false); +observerService.addObserver(observer, "chrome-document-loaded", false); +addEventListener("unload", observer, false); + +})(this); diff --git a/addon-sdk/source/lib/dev/panel.js b/addon-sdk/source/lib/dev/panel.js new file mode 100644 index 000000000..1ef6a303a --- /dev/null +++ b/addon-sdk/source/lib/dev/panel.js @@ -0,0 +1,259 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { Cu } = require("chrome"); +const { Class } = require("../sdk/core/heritage"); +const { curry } = require("../sdk/lang/functional"); +const { EventTarget } = require("../sdk/event/target"); +const { Disposable, setup, dispose } = require("../sdk/core/disposable"); +const { emit, off, setListeners } = require("../sdk/event/core"); +const { when } = require("../sdk/event/utils"); +const { getFrameElement } = require("../sdk/window/utils"); +const { contract, validate } = require("../sdk/util/contract"); +const { data: { url: resolve }} = require("../sdk/self"); +const { identify } = require("../sdk/ui/id"); +const { isLocalURL, URL } = require("../sdk/url"); +const { encode } = require("../sdk/base64"); +const { marshal, demarshal } = require("./ports"); +const { fromTarget } = require("./debuggee"); +const { removed } = require("../sdk/dom/events"); +const { id: addonID } = require("../sdk/self"); +const { viewFor } = require("../sdk/view/core"); +const { createView } = require("./panel/view"); + +const OUTER_FRAME_URI = module.uri.replace(/\.js$/, ".html"); +const FRAME_SCRIPT = module.uri.replace("/panel.js", "/frame-script.js"); +const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"; +const HTML_NS = "http://www.w3.org/1999/xhtml"; + +const makeID = name => + ("dev-panel-" + addonID + "-" + name). + split("/").join("-"). + split(".").join("-"). + split(" ").join("-"). + replace(/[^A-Za-z0-9_\-]/g, ""); + + +// Weak mapping between `Panel` instances and their frame's +// `nsIMessageManager`. +const managers = new WeakMap(); +// Return `nsIMessageManager` for the given `Panel` instance. +const managerFor = x => managers.get(x); + +// Weak mappinging between iframe's and their owner +// `Panel` instances. +const panels = new WeakMap(); +const panelFor = frame => panels.get(frame); + +// Weak mapping between panels and debugees they're targeting. +const debuggees = new WeakMap(); +const debuggeeFor = panel => debuggees.get(panel); + +const frames = new WeakMap(); +const frameFor = panel => frames.get(panel); + +const setAttributes = (node, attributes) => { + for (var key in attributes) + node.setAttribute(key, attributes[key]); +}; + +const onStateChange = ({target, data}) => { + const panel = panelFor(target); + panel.readyState = data.readyState; + emit(panel, data.type, { target: panel, type: data.type }); +}; + +// port event listener on the message manager that demarshalls +// and forwards to the actual receiver. This is a workaround +// until Bug 914974 is fixed. +const onPortMessage = ({data, target}) => { + const port = demarshal(target, data.port); + if (port) + port.postMessage(data.message); +}; + +// When frame is removed from the toolbox destroy panel +// associated with it to release all the resources. +const onFrameRemove = frame => { + panelFor(frame).destroy(); +}; + +const onFrameInited = frame => { + frame.style.visibility = "visible"; +} + +const inited = frame => new Promise(resolve => { + const { messageManager } = frame.frameLoader; + const listener = message => { + messageManager.removeMessageListener("sdk/event/ready", listener); + resolve(frame); + }; + messageManager.addMessageListener("sdk/event/ready", listener); +}); + +const getTarget = ({target}) => target; + +const Panel = Class({ + extends: Disposable, + implements: [EventTarget], + get id() { + return makeID(this.name || this.label); + }, + readyState: "uninitialized", + ready: function() { + const { readyState } = this; + const isReady = readyState === "complete" || + readyState === "interactive"; + return isReady ? Promise.resolve(this) : + when(this, "ready").then(getTarget); + }, + loaded: function() { + const { readyState } = this; + const isLoaded = readyState === "complete"; + return isLoaded ? Promise.resolve(this) : + when(this, "load").then(getTarget); + }, + unloaded: function() { + const { readyState } = this; + const isUninitialized = readyState === "uninitialized"; + return isUninitialized ? Promise.resolve(this) : + when(this, "unload").then(getTarget); + }, + postMessage: function(data, ports=[]) { + const manager = managerFor(this); + manager.sendAsyncMessage("sdk/event/message", { + type: "message", + bubbles: false, + cancelable: false, + data: data, + origin: this.url, + ports: ports.map(marshal(manager)) + }); + } +}); +exports.Panel = Panel; + +validate.define(Panel, contract({ + label: { + is: ["string"], + msg: "The `option.label` must be a provided" + }, + tooltip: { + is: ["string", "undefined"], + msg: "The `option.tooltip` must be a string" + }, + icon: { + is: ["string"], + map: x => x && resolve(x), + ok: x => isLocalURL(x), + msg: "The `options.icon` must be a valid local URI." + }, + url: { + map: x => resolve(x.toString()), + is: ["string"], + ok: x => isLocalURL(x), + msg: "The `options.url` must be a valid local URI." + }, + invertIconForLightTheme: { + is: ["boolean", "undefined"], + msg: "The `options.invertIconForLightTheme` must be a boolean." + }, + invertIconForDarkTheme: { + is: ["boolean", "undefined"], + msg: "The `options.invertIconForDarkTheme` must be a boolean." + } +})); + +setup.define(Panel, (panel, {window, toolbox, url}) => { + // Hack: Given that iframe created by devtools API is no good for us, + // we obtain original iframe and replace it with the one that has + // desired configuration. + const original = getFrameElement(window); + const container = original.parentNode; + original.remove(); + const frame = createView(panel, container.ownerDocument); + + // Following modifications are a temporary workaround until Bug 1049188 + // is fixed. + // Enforce certain iframe customizations regardless of users request. + setAttributes(frame, { + "id": original.id, + "src": url, + "flex": 1, + "forceOwnRefreshDriver": "", + "tooltip": "aHTMLTooltip" + }); + frame.style.visibility = "hidden"; + frame.classList.add("toolbox-panel-iframe"); + // Inject iframe into designated node until add-on author decides + // to inject it elsewhere instead. + if (!frame.parentNode) + container.appendChild(frame); + + // associate view with a panel + frames.set(panel, frame); + + // associate panel model with a frame view. + panels.set(frame, panel); + + const debuggee = fromTarget(toolbox.target); + // associate debuggee with a panel. + debuggees.set(panel, debuggee); + + + // Setup listeners for the frame message manager. + const { messageManager } = frame.frameLoader; + messageManager.addMessageListener("sdk/event/ready", onStateChange); + messageManager.addMessageListener("sdk/event/load", onStateChange); + messageManager.addMessageListener("sdk/event/unload", onStateChange); + messageManager.addMessageListener("sdk/port/message", onPortMessage); + messageManager.loadFrameScript(FRAME_SCRIPT, false); + + managers.set(panel, messageManager); + + // destroy panel if frame is removed. + removed(frame).then(onFrameRemove); + // show frame when it is initialized. + inited(frame).then(onFrameInited); + + + // set listeners if there are ones defined on the prototype. + setListeners(panel, Object.getPrototypeOf(panel)); + + + panel.setup({ debuggee: debuggee }); +}); + +createView.define(Panel, (panel, document) => { + const frame = document.createElement("iframe"); + setAttributes(frame, { + "sandbox": "allow-scripts", + // We end up using chrome iframe with forced message manager + // as fixing a swapFrameLoader seemed like a giant task (see + // Bug 1075490). + "type": "chrome", + "forcemessagemanager": true, + "transparent": true, + "seamless": "seamless", + }); + return frame; +}); + +dispose.define(Panel, function(panel) { + debuggeeFor(panel).close(); + + debuggees.delete(panel); + managers.delete(panel); + frames.delete(panel); + panel.readyState = "destroyed"; + panel.dispose(); +}); + +viewFor.define(Panel, frameFor); diff --git a/addon-sdk/source/lib/dev/panel/view.js b/addon-sdk/source/lib/dev/panel/view.js new file mode 100644 index 000000000..41cf9c221 --- /dev/null +++ b/addon-sdk/source/lib/dev/panel/view.js @@ -0,0 +1,14 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { method } = require("method/core"); + +const createView = method("dev/panel/view#createView"); +exports.createView = createView; diff --git a/addon-sdk/source/lib/dev/ports.js b/addon-sdk/source/lib/dev/ports.js new file mode 100644 index 000000000..a41f59eb7 --- /dev/null +++ b/addon-sdk/source/lib/dev/ports.js @@ -0,0 +1,64 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +// This module provides `marshal` and `demarshal` functions +// that can be used to send MessagePort's over `nsIFrameMessageManager` +// until Bug 914974 is fixed. + +const { add, iterator } = require("../sdk/lang/weak-set"); +const { curry } = require("../sdk/lang/functional"); + +var id = 0; +const ports = new WeakMap(); + +// Takes `nsIFrameMessageManager` and `MessagePort` instances +// and returns a handle representing given `port`. Messages +// received on given `port` will be forwarded to a message +// manager under `sdk/port/message` and messages like: +// { port: { type: "MessagePort", id: 2}, data: data } +// Where id is an identifier associated with a given `port` +// and `data` is an `event.data` received on port. +const marshal = curry((manager, port) => { + if (!ports.has(port)) { + id = id + 1; + const handle = {type: "MessagePort", id: id}; + // Bind id to the given port + ports.set(port, handle); + + // Obtain a weak reference to a port. + add(exports, port); + + port.onmessage = event => { + manager.sendAsyncMessage("sdk/port/message", { + port: handle, + message: event.data + }); + }; + + return handle; + } + return ports.get(port); +}); +exports.marshal = marshal; + +// Takes `nsIFrameMessageManager` instance and a handle returned +// `marshal(manager, port)` returning a `port` that was passed +// to it. Note that `port` may be GC-ed in which case returned +// value will be `null`. +const demarshal = curry((manager, {type, id}) => { + if (type === "MessagePort") { + for (let port of iterator(exports)) { + if (id === ports.get(port).id) + return port; + } + } + return null; +}); +exports.demarshal = demarshal; diff --git a/addon-sdk/source/lib/dev/theme.js b/addon-sdk/source/lib/dev/theme.js new file mode 100644 index 000000000..05930a502 --- /dev/null +++ b/addon-sdk/source/lib/dev/theme.js @@ -0,0 +1,135 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { Class } = require("../sdk/core/heritage"); +const { EventTarget } = require("../sdk/event/target"); +const { Disposable, setup, dispose } = require("../sdk/core/disposable"); +const { contract, validate } = require("../sdk/util/contract"); +const { id: addonID } = require("../sdk/self"); +const { onEnable, onDisable } = require("dev/theme/hooks"); +const { isString, instanceOf, isFunction } = require("sdk/lang/type"); +const { add } = require("sdk/util/array"); +const { data } = require("../sdk/self"); +const { isLocalURL } = require("../sdk/url"); + +const makeID = name => + ("dev-theme-" + addonID + (name ? "-" + name : "")). + split(/[ . /]/).join("-"). + replace(/[^A-Za-z0-9_\-]/g, ""); + +const Theme = Class({ + extends: Disposable, + implements: [EventTarget], + + initialize: function(options) { + this.name = options.name; + this.label = options.label; + this.styles = options.styles; + + // Event handlers + this.onEnable = options.onEnable; + this.onDisable = options.onDisable; + }, + get id() { + return makeID(this.name || this.label); + }, + setup: function() { + // Any initialization steps done at the registration time. + }, + getStyles: function() { + if (!this.styles) { + return []; + } + + if (isString(this.styles)) { + if (isLocalURL(this.styles)) { + return [data.url(this.styles)]; + } + } + + let result = []; + for (let style of this.styles) { + if (isString(style)) { + if (isLocalURL(style)) { + style = data.url(style); + } + add(result, style); + } else if (instanceOf(style, Theme)) { + result = result.concat(style.getStyles()); + } + } + return result; + }, + getClassList: function() { + let result = []; + for (let style of this.styles) { + if (instanceOf(style, Theme)) { + result = result.concat(style.getClassList()); + } + } + + if (this.name) { + add(result, this.name); + } + + return result; + } +}); + +exports.Theme = Theme; + +// Initialization & dispose + +setup.define(Theme, (theme) => { + theme.classList = []; + theme.setup(); +}); + +dispose.define(Theme, function(theme) { + theme.dispose(); +}); + +// Validation + +validate.define(Theme, contract({ + label: { + is: ["string"], + msg: "The `option.label` must be a provided" + }, +})); + +// Support theme events: apply and unapply the theme. + +onEnable.define(Theme, (theme, {window, oldTheme}) => { + if (isFunction(theme.onEnable)) { + theme.onEnable(window, oldTheme); + } +}); + +onDisable.define(Theme, (theme, {window, newTheme}) => { + if (isFunction(theme.onDisable)) { + theme.onDisable(window, newTheme); + } +}); + +// Support for built-in themes + +const LightTheme = Theme({ + name: "theme-light", + styles: "chrome://devtools/skin/light-theme.css", +}); + +const DarkTheme = Theme({ + name: "theme-dark", + styles: "chrome://devtools/skin/dark-theme.css", +}); + +exports.LightTheme = LightTheme; +exports.DarkTheme = DarkTheme; diff --git a/addon-sdk/source/lib/dev/theme/hooks.js b/addon-sdk/source/lib/dev/theme/hooks.js new file mode 100644 index 000000000..9987f853b --- /dev/null +++ b/addon-sdk/source/lib/dev/theme/hooks.js @@ -0,0 +1,17 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { method } = require("method/core"); + +const onEnable = method("dev/theme/hooks#onEnable"); +const onDisable = method("dev/theme/hooks#onDisable"); + +exports.onEnable = onEnable; +exports.onDisable = onDisable; diff --git a/addon-sdk/source/lib/dev/toolbox.js b/addon-sdk/source/lib/dev/toolbox.js new file mode 100644 index 000000000..43f37759f --- /dev/null +++ b/addon-sdk/source/lib/dev/toolbox.js @@ -0,0 +1,107 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +module.metadata = { + "stability": "experimental" +}; + +const { Cu, Cc, Ci } = require("chrome"); +const { Class } = require("../sdk/core/heritage"); +const { Disposable, setup } = require("../sdk/core/disposable"); +const { contract, validate } = require("../sdk/util/contract"); +const { each, pairs, values } = require("../sdk/util/sequence"); +const { onEnable, onDisable } = require("../dev/theme/hooks"); + +const { gDevTools } = Cu.import("resource://devtools/client/framework/gDevTools.jsm", {}); + +// This is temporary workaround to allow loading of the developer tools client - volcan +// into a toolbox panel, this hack won't be necessary as soon as devtools patch will be +// shipped in nightly, after which it can be removed. Bug 1038517 +const registerSDKURI = () => { + const ioService = Cc['@mozilla.org/network/io-service;1'] + .getService(Ci.nsIIOService); + const resourceHandler = ioService.getProtocolHandler("resource") + .QueryInterface(Ci.nsIResProtocolHandler); + + const uri = module.uri.replace("dev/toolbox.js", ""); + resourceHandler.setSubstitution("sdk", ioService.newURI(uri, null, null)); +}; + +registerSDKURI(); + +const Tool = Class({ + extends: Disposable, + setup: function(params={}) { + const { panels } = validate(this, params); + const { themes } = validate(this, params); + + this.panels = panels; + this.themes = themes; + + each(([key, Panel]) => { + const { url, label, tooltip, icon, invertIconForLightTheme, + invertIconForDarkTheme } = validate(Panel.prototype); + const { id } = Panel.prototype; + + gDevTools.registerTool({ + id: id, + url: "about:blank", + label: label, + tooltip: tooltip, + icon: icon, + invertIconForLightTheme: invertIconForLightTheme, + invertIconForDarkTheme: invertIconForDarkTheme, + isTargetSupported: target => target.isLocalTab, + build: (window, toolbox) => { + const panel = new Panel(); + setup(panel, { window: window, + toolbox: toolbox, + url: url }); + + return panel.ready(); + } + }); + }, pairs(panels)); + + each(([key, theme]) => { + validate(theme); + setup(theme); + + gDevTools.registerTheme({ + id: theme.id, + label: theme.label, + stylesheets: theme.getStyles(), + classList: theme.getClassList(), + onApply: (window, oldTheme) => { + onEnable(theme, { window: window, + oldTheme: oldTheme }); + }, + onUnapply: (window, newTheme) => { + onDisable(theme, { window: window, + newTheme: newTheme }); + } + }); + }, pairs(themes)); + }, + dispose: function() { + each(Panel => gDevTools.unregisterTool(Panel.prototype.id), + values(this.panels)); + + each(Theme => gDevTools.unregisterTheme(Theme.prototype.id), + values(this.themes)); + } +}); + +validate.define(Tool, contract({ + panels: { + is: ["object", "undefined"] + }, + themes: { + is: ["object", "undefined"] + } +})); + +exports.Tool = Tool; diff --git a/addon-sdk/source/lib/dev/utils.js b/addon-sdk/source/lib/dev/utils.js new file mode 100644 index 000000000..48db39e04 --- /dev/null +++ b/addon-sdk/source/lib/dev/utils.js @@ -0,0 +1,40 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const { Cu } = require("chrome"); +const { gDevTools } = Cu.import("resource://devtools/client/framework/gDevTools.jsm", {}); +const { devtools } = Cu.import("resource://devtools/shared/Loader.jsm", {}); + +const { getActiveTab } = require("../sdk/tabs/utils"); +const { getMostRecentBrowserWindow } = require("../sdk/window/utils"); + +const targetFor = target => { + target = target || getActiveTab(getMostRecentBrowserWindow()); + return devtools.TargetFactory.forTab(target); +}; + +const getId = id => ((id.prototype && id.prototype.id) || id.id || id); + +const getCurrentPanel = toolbox => toolbox.getCurrentPanel(); +exports.getCurrentPanel = getCurrentPanel; + +const openToolbox = (id, tab) => { + id = getId(id); + return gDevTools.showToolbox(targetFor(tab), id); +}; +exports.openToolbox = openToolbox; + +const closeToolbox = tab => gDevTools.closeToolbox(targetFor(tab)); +exports.closeToolbox = closeToolbox; + +const getToolbox = tab => gDevTools.getToolbox(targetFor(tab)); +exports.getToolbox = getToolbox; + +const openToolboxPanel = (id, tab) => { + id = getId(id); + return gDevTools.showToolbox(targetFor(tab), id).then(getCurrentPanel); +}; +exports.openToolboxPanel = openToolboxPanel; diff --git a/addon-sdk/source/lib/dev/volcan.js b/addon-sdk/source/lib/dev/volcan.js new file mode 100644 index 000000000..6a68ed12d --- /dev/null +++ b/addon-sdk/source/lib/dev/volcan.js @@ -0,0 +1,3848 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.volcan=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){ +"use strict"; + +var Client = _dereq_("../client").Client; + +function connect(port) { + var client = new Client(); + return client.connect(port); +} +exports.connect = connect; + +},{"../client":4}],2:[function(_dereq_,module,exports){ +"use strict"; + +exports.Promise = Promise; + +},{}],3:[function(_dereq_,module,exports){ +"use strict"; + +var describe = Object.getOwnPropertyDescriptor; +var Class = function(fields) { + var names = Object.keys(fields); + var constructor = names.indexOf("constructor") >= 0 ? fields.constructor : + function() {}; + var ancestor = fields.extends || Object; + + var descriptor = names.reduce(function(descriptor, key) { + descriptor[key] = describe(fields, key); + return descriptor; + }, {}); + + var prototype = Object.create(ancestor.prototype, descriptor); + + constructor.prototype = prototype; + prototype.constructor = constructor; + + return constructor; +}; +exports.Class = Class; + +},{}],4:[function(_dereq_,module,exports){ +"use strict"; + +var Class = _dereq_("./class").Class; +var TypeSystem = _dereq_("./type-system").TypeSystem; +var values = _dereq_("./util").values; +var Promise = _dereq_("es6-promise").Promise; +var MessageEvent = _dereq_("./event").MessageEvent; + +var specification = _dereq_("./specification/core.json"); + +function recoverActorDescriptions(error) { + console.warn("Failed to fetch protocol specification (see reason below). " + + "Using a fallback protocal specification!", + error); + return _dereq_("./specification/protocol.json"); +} + +// Type to represent superviser actor relations to actors they supervise +// in terms of lifetime management. +var Supervisor = Class({ + constructor: function(id) { + this.id = id; + this.workers = []; + } +}); + +var Telemetry = Class({ + add: function(id, ms) { + console.log("telemetry::", id, ms) + } +}); + +// Consider making client a root actor. + +var Client = Class({ + constructor: function() { + this.root = null; + this.telemetry = new Telemetry(); + + this.setupConnection(); + this.setupLifeManagement(); + this.setupTypeSystem(); + }, + + setupConnection: function() { + this.requests = []; + }, + setupLifeManagement: function() { + this.cache = Object.create(null); + this.graph = Object.create(null); + this.get = this.get.bind(this); + this.release = this.release.bind(this); + }, + setupTypeSystem: function() { + this.typeSystem = new TypeSystem(this); + this.typeSystem.registerTypes(specification); + }, + + connect: function(port) { + var client = this; + return new Promise(function(resolve, reject) { + client.port = port; + port.onmessage = client.receive.bind(client); + client.onReady = resolve; + client.onFail = reject; + + port.start(); + }); + }, + send: function(packet) { + this.port.postMessage(packet); + }, + request: function(packet) { + var client = this; + return new Promise(function(resolve, reject) { + client.requests.push(packet.to, { resolve: resolve, reject: reject }); + client.send(packet); + }); + }, + + receive: function(event) { + var packet = event.data; + if (!this.root) { + if (packet.from !== "root") + throw Error("Initial packet must be from root"); + if (!("applicationType" in packet)) + throw Error("Initial packet must contain applicationType field"); + + this.root = this.typeSystem.read("root", null, "root"); + this.root + .protocolDescription() + .catch(recoverActorDescriptions) + .then(this.typeSystem.registerTypes.bind(this.typeSystem)) + .then(this.onReady.bind(this, this.root), this.onFail); + } else { + var actor = this.get(packet.from) || this.root; + var event = actor.events[packet.type]; + if (event) { + var message = new MessageEvent(packet.type, { + data: event.read(packet) + }); + actor.dispatchEvent(message); + } else { + var index = this.requests.indexOf(actor.id); + if (index >= 0) { + var request = this.requests.splice(index, 2).pop(); + if (packet.error) + request.reject(packet); + else + request.resolve(packet); + } else { + console.error(Error("Unexpected packet " + JSON.stringify(packet, 2, 2)), + packet, + this.requests.slice(0)); + } + } + } + }, + + get: function(id) { + return this.cache[id]; + }, + supervisorOf: function(actor) { + for (var id in this.graph) { + if (this.graph[id].indexOf(actor.id) >= 0) { + return id; + } + } + }, + workersOf: function(actor) { + return this.graph[actor.id]; + }, + supervise: function(actor, worker) { + var workers = this.workersOf(actor) + if (workers.indexOf(worker.id) < 0) { + workers.push(worker.id); + } + }, + unsupervise: function(actor, worker) { + var workers = this.workersOf(actor); + var index = workers.indexOf(worker.id) + if (index >= 0) { + workers.splice(index, 1) + } + }, + + register: function(actor) { + var registered = this.get(actor.id); + if (!registered) { + this.cache[actor.id] = actor; + this.graph[actor.id] = []; + } else if (registered !== actor) { + throw new Error("Different actor with same id is already registered"); + } + }, + unregister: function(actor) { + if (this.get(actor.id)) { + delete this.cache[actor.id]; + delete this.graph[actor.id]; + } + }, + + release: function(actor) { + var supervisor = this.supervisorOf(actor); + if (supervisor) + this.unsupervise(supervisor, actor); + + var workers = this.workersOf(actor) + + if (workers) { + workers.map(this.get).forEach(this.release) + } + this.unregister(actor); + } +}); +exports.Client = Client; + +},{"./class":3,"./event":5,"./specification/core.json":23,"./specification/protocol.json":24,"./type-system":25,"./util":26,"es6-promise":2}],5:[function(_dereq_,module,exports){ +"use strict"; + +var Symbol = _dereq_("es6-symbol") +var EventEmitter = _dereq_("events").EventEmitter; +var Class = _dereq_("./class").Class; + +var $bound = Symbol("EventTarget/handleEvent"); +var $emitter = Symbol("EventTarget/emitter"); + +function makeHandler(handler) { + return function(event) { + handler.handleEvent(event); + } +} + +var EventTarget = Class({ + constructor: function() { + Object.defineProperty(this, $emitter, { + enumerable: false, + configurable: true, + writable: true, + value: new EventEmitter() + }); + }, + addEventListener: function(type, handler) { + if (typeof(handler) === "function") { + this[$emitter].on(type, handler); + } + else if (handler && typeof(handler) === "object") { + if (!handler[$bound]) handler[$bound] = makeHandler(handler); + this[$emitter].on(type, handler[$bound]); + } + }, + removeEventListener: function(type, handler) { + if (typeof(handler) === "function") + this[$emitter].removeListener(type, handler); + else if (handler && handler[$bound]) + this[$emitter].removeListener(type, handler[$bound]); + }, + dispatchEvent: function(event) { + event.target = this; + this[$emitter].emit(event.type, event); + } +}); +exports.EventTarget = EventTarget; + +var MessageEvent = Class({ + constructor: function(type, options) { + options = options || {}; + this.type = type; + this.data = options.data === void(0) ? null : options.data; + + this.lastEventId = options.lastEventId || ""; + this.origin = options.origin || ""; + this.bubbles = options.bubbles || false; + this.cancelable = options.cancelable || false; + }, + source: null, + ports: null, + preventDefault: function() { + }, + stopPropagation: function() { + }, + stopImmediatePropagation: function() { + } +}); +exports.MessageEvent = MessageEvent; + +},{"./class":3,"es6-symbol":7,"events":6}],6:[function(_dereq_,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; +} +module.exports = EventEmitter; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +EventEmitter.defaultMaxListeners = 10; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + throw TypeError('Uncaught, unspecified "error" event.'); + } + return false; + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + handler.apply(this, args); + } + } else if (isObject(handler)) { + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + var m; + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.listenerCount = function(emitter, type) { + var ret; + if (!emitter._events || !emitter._events[type]) + ret = 0; + else if (isFunction(emitter._events[type])) + ret = 1; + else + ret = emitter._events[type].length; + return ret; +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}],7:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = _dereq_('./is-implemented')() ? Symbol : _dereq_('./polyfill'); + +},{"./is-implemented":8,"./polyfill":22}],8:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = function () { + var symbol; + if (typeof Symbol !== 'function') return false; + symbol = Symbol('test symbol'); + try { + if (String(symbol) !== 'Symbol (test symbol)') return false; + } catch (e) { return false; } + if (typeof Symbol.iterator === 'symbol') return true; + + // Return 'true' for polyfills + if (typeof Symbol.isConcatSpreadable !== 'object') return false; + if (typeof Symbol.isRegExp !== 'object') return false; + if (typeof Symbol.iterator !== 'object') return false; + if (typeof Symbol.toPrimitive !== 'object') return false; + if (typeof Symbol.toStringTag !== 'object') return false; + if (typeof Symbol.unscopables !== 'object') return false; + + return true; +}; + +},{}],9:[function(_dereq_,module,exports){ +'use strict'; + +var assign = _dereq_('es5-ext/object/assign') + , normalizeOpts = _dereq_('es5-ext/object/normalize-options') + , isCallable = _dereq_('es5-ext/object/is-callable') + , contains = _dereq_('es5-ext/string/#/contains') + + , d; + +d = module.exports = function (dscr, value/*, options*/) { + var c, e, w, options, desc; + if ((arguments.length < 2) || (typeof dscr !== 'string')) { + options = value; + value = dscr; + dscr = null; + } else { + options = arguments[2]; + } + if (dscr == null) { + c = w = true; + e = false; + } else { + c = contains.call(dscr, 'c'); + e = contains.call(dscr, 'e'); + w = contains.call(dscr, 'w'); + } + + desc = { value: value, configurable: c, enumerable: e, writable: w }; + return !options ? desc : assign(normalizeOpts(options), desc); +}; + +d.gs = function (dscr, get, set/*, options*/) { + var c, e, options, desc; + if (typeof dscr !== 'string') { + options = set; + set = get; + get = dscr; + dscr = null; + } else { + options = arguments[3]; + } + if (get == null) { + get = undefined; + } else if (!isCallable(get)) { + options = get; + get = set = undefined; + } else if (set == null) { + set = undefined; + } else if (!isCallable(set)) { + options = set; + set = undefined; + } + if (dscr == null) { + c = true; + e = false; + } else { + c = contains.call(dscr, 'c'); + e = contains.call(dscr, 'e'); + } + + desc = { get: get, set: set, configurable: c, enumerable: e }; + return !options ? desc : assign(normalizeOpts(options), desc); +}; + +},{"es5-ext/object/assign":10,"es5-ext/object/is-callable":13,"es5-ext/object/normalize-options":17,"es5-ext/string/#/contains":19}],10:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = _dereq_('./is-implemented')() + ? Object.assign + : _dereq_('./shim'); + +},{"./is-implemented":11,"./shim":12}],11:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = function () { + var assign = Object.assign, obj; + if (typeof assign !== 'function') return false; + obj = { foo: 'raz' }; + assign(obj, { bar: 'dwa' }, { trzy: 'trzy' }); + return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy'; +}; + +},{}],12:[function(_dereq_,module,exports){ +'use strict'; + +var keys = _dereq_('../keys') + , value = _dereq_('../valid-value') + + , max = Math.max; + +module.exports = function (dest, src/*, …srcn*/) { + var error, i, l = max(arguments.length, 2), assign; + dest = Object(value(dest)); + assign = function (key) { + try { dest[key] = src[key]; } catch (e) { + if (!error) error = e; + } + }; + for (i = 1; i < l; ++i) { + src = arguments[i]; + keys(src).forEach(assign); + } + if (error !== undefined) throw error; + return dest; +}; + +},{"../keys":14,"../valid-value":18}],13:[function(_dereq_,module,exports){ +// Deprecated + +'use strict'; + +module.exports = function (obj) { return typeof obj === 'function'; }; + +},{}],14:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = _dereq_('./is-implemented')() + ? Object.keys + : _dereq_('./shim'); + +},{"./is-implemented":15,"./shim":16}],15:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = function () { + try { + Object.keys('primitive'); + return true; + } catch (e) { return false; } +}; + +},{}],16:[function(_dereq_,module,exports){ +'use strict'; + +var keys = Object.keys; + +module.exports = function (object) { + return keys(object == null ? object : Object(object)); +}; + +},{}],17:[function(_dereq_,module,exports){ +'use strict'; + +var assign = _dereq_('./assign') + + , forEach = Array.prototype.forEach + , create = Object.create, getPrototypeOf = Object.getPrototypeOf + + , process; + +process = function (src, obj) { + var proto = getPrototypeOf(src); + return assign(proto ? process(proto, obj) : obj, src); +}; + +module.exports = function (options/*, …options*/) { + var result = create(null); + forEach.call(arguments, function (options) { + if (options == null) return; + process(Object(options), result); + }); + return result; +}; + +},{"./assign":10}],18:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = function (value) { + if (value == null) throw new TypeError("Cannot use null or undefined"); + return value; +}; + +},{}],19:[function(_dereq_,module,exports){ +'use strict'; + +module.exports = _dereq_('./is-implemented')() + ? String.prototype.contains + : _dereq_('./shim'); + +},{"./is-implemented":20,"./shim":21}],20:[function(_dereq_,module,exports){ +'use strict'; + +var str = 'razdwatrzy'; + +module.exports = function () { + if (typeof str.contains !== 'function') return false; + return ((str.contains('dwa') === true) && (str.contains('foo') === false)); +}; + +},{}],21:[function(_dereq_,module,exports){ +'use strict'; + +var indexOf = String.prototype.indexOf; + +module.exports = function (searchString/*, position*/) { + return indexOf.call(this, searchString, arguments[1]) > -1; +}; + +},{}],22:[function(_dereq_,module,exports){ +'use strict'; + +var d = _dereq_('d') + + , create = Object.create, defineProperties = Object.defineProperties + , generateName, Symbol; + +generateName = (function () { + var created = create(null); + return function (desc) { + var postfix = 0; + while (created[desc + (postfix || '')]) ++postfix; + desc += (postfix || ''); + created[desc] = true; + return '@@' + desc; + }; +}()); + +module.exports = Symbol = function (description) { + var symbol; + if (this instanceof Symbol) { + throw new TypeError('TypeError: Symbol is not a constructor'); + } + symbol = create(Symbol.prototype); + description = (description === undefined ? '' : String(description)); + return defineProperties(symbol, { + __description__: d('', description), + __name__: d('', generateName(description)) + }); +}; + +Object.defineProperties(Symbol, { + create: d('', Symbol('create')), + hasInstance: d('', Symbol('hasInstance')), + isConcatSpreadable: d('', Symbol('isConcatSpreadable')), + isRegExp: d('', Symbol('isRegExp')), + iterator: d('', Symbol('iterator')), + toPrimitive: d('', Symbol('toPrimitive')), + toStringTag: d('', Symbol('toStringTag')), + unscopables: d('', Symbol('unscopables')) +}); + +defineProperties(Symbol.prototype, { + properToString: d(function () { + return 'Symbol (' + this.__description__ + ')'; + }), + toString: d('', function () { return this.__name__; }) +}); +Object.defineProperty(Symbol.prototype, Symbol.toPrimitive, d('', + function (hint) { + throw new TypeError("Conversion of symbol objects is not allowed"); + })); +Object.defineProperty(Symbol.prototype, Symbol.toStringTag, d('c', 'Symbol')); + +},{"d":9}],23:[function(_dereq_,module,exports){ +module.exports={ + "types": { + "root": { + "category": "actor", + "typeName": "root", + "methods": [ + { + "name": "echo", + "request": { + "string": { "_arg": 0, "type": "string" } + }, + "response": { + "string": { "_retval": "string" } + } + }, + { + "name": "listTabs", + "request": {}, + "response": { "_retval": "tablist" } + }, + { + "name": "protocolDescription", + "request": {}, + "response": { "_retval": "json" } + } + ], + "events": { + "tabListChanged": {} + } + }, + "tablist": { + "category": "dict", + "typeName": "tablist", + "specializations": { + "selected": "number", + "tabs": "array:tab", + "url": "string", + "consoleActor": "console", + "inspectorActor": "inspector", + "styleSheetsActor": "stylesheets", + "styleEditorActor": "styleeditor", + "memoryActor": "memory", + "eventLoopLagActor": "eventLoopLag", + "preferenceActor": "preference", + "deviceActor": "device", + + "profilerActor": "profiler", + "chromeDebugger": "chromeDebugger", + "webappsActor": "webapps" + } + }, + "tab": { + "category": "actor", + "typeName": "tab", + "fields": { + "title": "string", + "url": "string", + "outerWindowID": "number", + "inspectorActor": "inspector", + "callWatcherActor": "call-watcher", + "canvasActor": "canvas", + "webglActor": "webgl", + "webaudioActor": "webaudio", + "storageActor": "storage", + "gcliActor": "gcli", + "memoryActor": "memory", + "eventLoopLag": "eventLoopLag", + "styleSheetsActor": "stylesheets", + "styleEditorActor": "styleeditor", + + "consoleActor": "console", + "traceActor": "trace" + }, + "methods": [ + { + "name": "attach", + "request": {}, + "response": { "_retval": "json" } + } + ], + "events": { + "tabNavigated": { + "typeName": "tabNavigated" + } + } + }, + "console": { + "category": "actor", + "typeName": "console", + "methods": [ + { + "name": "evaluateJS", + "request": { + "text": { + "_option": 0, + "type": "string" + }, + "url": { + "_option": 1, + "type": "string" + }, + "bindObjectActor": { + "_option": 2, + "type": "nullable:string" + }, + "frameActor": { + "_option": 2, + "type": "nullable:string" + }, + "selectedNodeActor": { + "_option": 2, + "type": "nullable:string" + } + }, + "response": { + "_retval": "evaluatejsresponse" + } + } + ], + "events": {} + }, + "evaluatejsresponse": { + "category": "dict", + "typeName": "evaluatejsresponse", + "specializations": { + "result": "object", + "exception": "object", + "exceptionMessage": "string", + "input": "string" + } + }, + "object": { + "category": "actor", + "typeName": "object", + "methods": [ + { + "name": "property", + "request": { + "name": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "descriptor": { + "_retval": "json" + } + } + } + ] + } + } +} + +},{}],24:[function(_dereq_,module,exports){ +module.exports={ + "types": { + "longstractor": { + "category": "actor", + "typeName": "longstractor", + "methods": [ + { + "name": "substring", + "request": { + "type": "substring", + "start": { + "_arg": 0, + "type": "primitive" + }, + "end": { + "_arg": 1, + "type": "primitive" + } + }, + "response": { + "substring": { + "_retval": "primitive" + } + } + }, + { + "name": "release", + "release": true, + "request": { + "type": "release" + }, + "response": {} + } + ], + "events": {} + }, + "stylesheet": { + "category": "actor", + "typeName": "stylesheet", + "methods": [ + { + "name": "toggleDisabled", + "request": { + "type": "toggleDisabled" + }, + "response": { + "disabled": { + "_retval": "boolean" + } + } + }, + { + "name": "getText", + "request": { + "type": "getText" + }, + "response": { + "text": { + "_retval": "longstring" + } + } + }, + { + "name": "getOriginalSources", + "request": { + "type": "getOriginalSources" + }, + "response": { + "originalSources": { + "_retval": "nullable:array:originalsource" + } + } + }, + { + "name": "getOriginalLocation", + "request": { + "type": "getOriginalLocation", + "line": { + "_arg": 0, + "type": "number" + }, + "column": { + "_arg": 1, + "type": "number" + } + }, + "response": { + "_retval": "originallocationresponse" + } + }, + { + "name": "update", + "request": { + "type": "update", + "text": { + "_arg": 0, + "type": "string" + }, + "transition": { + "_arg": 1, + "type": "boolean" + } + }, + "response": {} + } + ], + "events": { + "property-change": { + "type": "propertyChange", + "property": { + "_arg": 0, + "type": "string" + }, + "value": { + "_arg": 1, + "type": "json" + } + }, + "style-applied": { + "type": "styleApplied" + } + } + }, + "originalsource": { + "category": "actor", + "typeName": "originalsource", + "methods": [ + { + "name": "getText", + "request": { + "type": "getText" + }, + "response": { + "text": { + "_retval": "longstring" + } + } + } + ], + "events": {} + }, + "stylesheets": { + "category": "actor", + "typeName": "stylesheets", + "methods": [ + { + "name": "getStyleSheets", + "request": { + "type": "getStyleSheets" + }, + "response": { + "styleSheets": { + "_retval": "array:stylesheet" + } + } + }, + { + "name": "addStyleSheet", + "request": { + "type": "addStyleSheet", + "text": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "styleSheet": { + "_retval": "stylesheet" + } + } + } + ], + "events": {} + }, + "originallocationresponse": { + "category": "dict", + "typeName": "originallocationresponse", + "specializations": { + "source": "string", + "line": "number", + "column": "number" + } + }, + "domnode": { + "category": "actor", + "typeName": "domnode", + "methods": [ + { + "name": "getNodeValue", + "request": { + "type": "getNodeValue" + }, + "response": { + "value": { + "_retval": "longstring" + } + } + }, + { + "name": "setNodeValue", + "request": { + "type": "setNodeValue", + "value": { + "_arg": 0, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "getImageData", + "request": { + "type": "getImageData", + "maxDim": { + "_arg": 0, + "type": "nullable:number" + } + }, + "response": { + "_retval": "imageData" + } + }, + { + "name": "modifyAttributes", + "request": { + "type": "modifyAttributes", + "modifications": { + "_arg": 0, + "type": "array:json" + } + }, + "response": {} + } + ], + "events": {} + }, + "appliedstyle": { + "category": "dict", + "typeName": "appliedstyle", + "specializations": { + "rule": "domstylerule#actorid", + "inherited": "nullable:domnode#actorid" + } + }, + "matchedselector": { + "category": "dict", + "typeName": "matchedselector", + "specializations": { + "rule": "domstylerule#actorid", + "selector": "string", + "value": "string", + "status": "number" + } + }, + "matchedselectorresponse": { + "category": "dict", + "typeName": "matchedselectorresponse", + "specializations": { + "rules": "array:domstylerule", + "sheets": "array:stylesheet", + "matched": "array:matchedselector" + } + }, + "appliedStylesReturn": { + "category": "dict", + "typeName": "appliedStylesReturn", + "specializations": { + "entries": "array:appliedstyle", + "rules": "array:domstylerule", + "sheets": "array:stylesheet" + } + }, + "pagestyle": { + "category": "actor", + "typeName": "pagestyle", + "methods": [ + { + "name": "getComputed", + "request": { + "type": "getComputed", + "node": { + "_arg": 0, + "type": "domnode" + }, + "markMatched": { + "_option": 1, + "type": "boolean" + }, + "onlyMatched": { + "_option": 1, + "type": "boolean" + }, + "filter": { + "_option": 1, + "type": "string" + } + }, + "response": { + "computed": { + "_retval": "json" + } + } + }, + { + "name": "getMatchedSelectors", + "request": { + "type": "getMatchedSelectors", + "node": { + "_arg": 0, + "type": "domnode" + }, + "property": { + "_arg": 1, + "type": "string" + }, + "filter": { + "_option": 2, + "type": "string" + } + }, + "response": { + "_retval": "matchedselectorresponse" + } + }, + { + "name": "getApplied", + "request": { + "type": "getApplied", + "node": { + "_arg": 0, + "type": "domnode" + }, + "inherited": { + "_option": 1, + "type": "boolean" + }, + "matchedSelectors": { + "_option": 1, + "type": "boolean" + }, + "filter": { + "_option": 1, + "type": "string" + } + }, + "response": { + "_retval": "appliedStylesReturn" + } + }, + { + "name": "getLayout", + "request": { + "type": "getLayout", + "node": { + "_arg": 0, + "type": "domnode" + }, + "autoMargins": { + "_option": 1, + "type": "boolean" + } + }, + "response": { + "_retval": "json" + } + } + ], + "events": {} + }, + "domstylerule": { + "category": "actor", + "typeName": "domstylerule", + "methods": [ + { + "name": "modifyProperties", + "request": { + "type": "modifyProperties", + "modifications": { + "_arg": 0, + "type": "array:json" + } + }, + "response": { + "rule": { + "_retval": "domstylerule" + } + } + } + ], + "events": {} + }, + "highlighter": { + "category": "actor", + "typeName": "highlighter", + "methods": [ + { + "name": "showBoxModel", + "request": { + "type": "showBoxModel", + "node": { + "_arg": 0, + "type": "domnode" + }, + "region": { + "_option": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "hideBoxModel", + "request": { + "type": "hideBoxModel" + }, + "response": {} + }, + { + "name": "pick", + "request": { + "type": "pick" + }, + "response": {} + }, + { + "name": "cancelPick", + "request": { + "type": "cancelPick" + }, + "response": {} + } + ], + "events": {} + }, + "imageData": { + "category": "dict", + "typeName": "imageData", + "specializations": { + "data": "nullable:longstring", + "size": "json" + } + }, + "disconnectedNode": { + "category": "dict", + "typeName": "disconnectedNode", + "specializations": { + "node": "domnode", + "newParents": "array:domnode" + } + }, + "disconnectedNodeArray": { + "category": "dict", + "typeName": "disconnectedNodeArray", + "specializations": { + "nodes": "array:domnode", + "newParents": "array:domnode" + } + }, + "dommutation": { + "category": "dict", + "typeName": "dommutation", + "specializations": {} + }, + "domnodelist": { + "category": "actor", + "typeName": "domnodelist", + "methods": [ + { + "name": "item", + "request": { + "type": "item", + "item": { + "_arg": 0, + "type": "primitive" + } + }, + "response": { + "_retval": "disconnectedNode" + } + }, + { + "name": "items", + "request": { + "type": "items", + "start": { + "_arg": 0, + "type": "nullable:number" + }, + "end": { + "_arg": 1, + "type": "nullable:number" + } + }, + "response": { + "_retval": "disconnectedNodeArray" + } + }, + { + "name": "release", + "release": true, + "request": { + "type": "release" + }, + "response": {} + } + ], + "events": {} + }, + "domtraversalarray": { + "category": "dict", + "typeName": "domtraversalarray", + "specializations": { + "nodes": "array:domnode" + } + }, + "domwalker": { + "category": "actor", + "typeName": "domwalker", + "methods": [ + { + "name": "release", + "release": true, + "request": { + "type": "release" + }, + "response": {} + }, + { + "name": "pick", + "request": { + "type": "pick" + }, + "response": { + "_retval": "disconnectedNode" + } + }, + { + "name": "cancelPick", + "request": { + "type": "cancelPick" + }, + "response": {} + }, + { + "name": "highlight", + "request": { + "type": "highlight", + "node": { + "_arg": 0, + "type": "nullable:domnode" + } + }, + "response": {} + }, + { + "name": "document", + "request": { + "type": "document", + "node": { + "_arg": 0, + "type": "nullable:domnode" + } + }, + "response": { + "node": { + "_retval": "domnode" + } + } + }, + { + "name": "documentElement", + "request": { + "type": "documentElement", + "node": { + "_arg": 0, + "type": "nullable:domnode" + } + }, + "response": { + "node": { + "_retval": "domnode" + } + } + }, + { + "name": "parents", + "request": { + "type": "parents", + "node": { + "_arg": 0, + "type": "domnode" + }, + "sameDocument": { + "_option": 1, + "type": "primitive" + } + }, + "response": { + "nodes": { + "_retval": "array:domnode" + } + } + }, + { + "name": "retainNode", + "request": { + "type": "retainNode", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": {} + }, + { + "name": "unretainNode", + "request": { + "type": "unretainNode", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": {} + }, + { + "name": "releaseNode", + "request": { + "type": "releaseNode", + "node": { + "_arg": 0, + "type": "domnode" + }, + "force": { + "_option": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "children", + "request": { + "type": "children", + "node": { + "_arg": 0, + "type": "domnode" + }, + "maxNodes": { + "_option": 1, + "type": "primitive" + }, + "center": { + "_option": 1, + "type": "domnode" + }, + "start": { + "_option": 1, + "type": "domnode" + }, + "whatToShow": { + "_option": 1, + "type": "primitive" + } + }, + "response": { + "_retval": "domtraversalarray" + } + }, + { + "name": "siblings", + "request": { + "type": "siblings", + "node": { + "_arg": 0, + "type": "domnode" + }, + "maxNodes": { + "_option": 1, + "type": "primitive" + }, + "center": { + "_option": 1, + "type": "domnode" + }, + "start": { + "_option": 1, + "type": "domnode" + }, + "whatToShow": { + "_option": 1, + "type": "primitive" + } + }, + "response": { + "_retval": "domtraversalarray" + } + }, + { + "name": "nextSibling", + "request": { + "type": "nextSibling", + "node": { + "_arg": 0, + "type": "domnode" + }, + "whatToShow": { + "_option": 1, + "type": "primitive" + } + }, + "response": { + "node": { + "_retval": "nullable:domnode" + } + } + }, + { + "name": "previousSibling", + "request": { + "type": "previousSibling", + "node": { + "_arg": 0, + "type": "domnode" + }, + "whatToShow": { + "_option": 1, + "type": "primitive" + } + }, + "response": { + "node": { + "_retval": "nullable:domnode" + } + } + }, + { + "name": "querySelector", + "request": { + "type": "querySelector", + "node": { + "_arg": 0, + "type": "domnode" + }, + "selector": { + "_arg": 1, + "type": "primitive" + } + }, + "response": { + "_retval": "disconnectedNode" + } + }, + { + "name": "querySelectorAll", + "request": { + "type": "querySelectorAll", + "node": { + "_arg": 0, + "type": "domnode" + }, + "selector": { + "_arg": 1, + "type": "primitive" + } + }, + "response": { + "list": { + "_retval": "domnodelist" + } + } + }, + { + "name": "getSuggestionsForQuery", + "request": { + "type": "getSuggestionsForQuery", + "query": { + "_arg": 0, + "type": "primitive" + }, + "completing": { + "_arg": 1, + "type": "primitive" + }, + "selectorState": { + "_arg": 2, + "type": "primitive" + } + }, + "response": { + "list": { + "_retval": "array:array:string" + } + } + }, + { + "name": "addPseudoClassLock", + "request": { + "type": "addPseudoClassLock", + "node": { + "_arg": 0, + "type": "domnode" + }, + "pseudoClass": { + "_arg": 1, + "type": "primitive" + }, + "parents": { + "_option": 2, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "hideNode", + "request": { + "type": "hideNode", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": {} + }, + { + "name": "unhideNode", + "request": { + "type": "unhideNode", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": {} + }, + { + "name": "removePseudoClassLock", + "request": { + "type": "removePseudoClassLock", + "node": { + "_arg": 0, + "type": "domnode" + }, + "pseudoClass": { + "_arg": 1, + "type": "primitive" + }, + "parents": { + "_option": 2, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "clearPseudoClassLocks", + "request": { + "type": "clearPseudoClassLocks", + "node": { + "_arg": 0, + "type": "nullable:domnode" + } + }, + "response": {} + }, + { + "name": "innerHTML", + "request": { + "type": "innerHTML", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": { + "value": { + "_retval": "longstring" + } + } + }, + { + "name": "outerHTML", + "request": { + "type": "outerHTML", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": { + "value": { + "_retval": "longstring" + } + } + }, + { + "name": "setOuterHTML", + "request": { + "type": "setOuterHTML", + "node": { + "_arg": 0, + "type": "domnode" + }, + "value": { + "_arg": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "removeNode", + "request": { + "type": "removeNode", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": { + "nextSibling": { + "_retval": "nullable:domnode" + } + } + }, + { + "name": "insertBefore", + "request": { + "type": "insertBefore", + "node": { + "_arg": 0, + "type": "domnode" + }, + "parent": { + "_arg": 1, + "type": "domnode" + }, + "sibling": { + "_arg": 2, + "type": "nullable:domnode" + } + }, + "response": {} + }, + { + "name": "getMutations", + "request": { + "type": "getMutations", + "cleanup": { + "_option": 0, + "type": "primitive" + } + }, + "response": { + "mutations": { + "_retval": "array:dommutation" + } + } + }, + { + "name": "isInDOMTree", + "request": { + "type": "isInDOMTree", + "node": { + "_arg": 0, + "type": "domnode" + } + }, + "response": { + "attached": { + "_retval": "boolean" + } + } + }, + { + "name": "getNodeActorFromObjectActor", + "request": { + "type": "getNodeActorFromObjectActor", + "objectActorID": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "nodeFront": { + "_retval": "nullable:disconnectedNode" + } + } + } + ], + "events": { + "new-mutations": { + "type": "newMutations" + }, + "picker-node-picked": { + "type": "pickerNodePicked", + "node": { + "_arg": 0, + "type": "disconnectedNode" + } + }, + "picker-node-hovered": { + "type": "pickerNodeHovered", + "node": { + "_arg": 0, + "type": "disconnectedNode" + } + }, + "highlighter-ready": { + "type": "highlighter-ready" + }, + "highlighter-hide": { + "type": "highlighter-hide" + } + } + }, + "inspector": { + "category": "actor", + "typeName": "inspector", + "methods": [ + { + "name": "getWalker", + "request": { + "type": "getWalker" + }, + "response": { + "walker": { + "_retval": "domwalker" + } + } + }, + { + "name": "getPageStyle", + "request": { + "type": "getPageStyle" + }, + "response": { + "pageStyle": { + "_retval": "pagestyle" + } + } + }, + { + "name": "getHighlighter", + "request": { + "type": "getHighlighter", + "autohide": { + "_arg": 0, + "type": "boolean" + } + }, + "response": { + "highligter": { + "_retval": "highlighter" + } + } + }, + { + "name": "getImageDataFromURL", + "request": { + "type": "getImageDataFromURL", + "url": { + "_arg": 0, + "type": "primitive" + }, + "maxDim": { + "_arg": 1, + "type": "nullable:number" + } + }, + "response": { + "_retval": "imageData" + } + } + ], + "events": {} + }, + "call-stack-item": { + "category": "dict", + "typeName": "call-stack-item", + "specializations": { + "name": "string", + "file": "string", + "line": "number" + } + }, + "call-details": { + "category": "dict", + "typeName": "call-details", + "specializations": { + "type": "number", + "name": "string", + "stack": "array:call-stack-item" + } + }, + "function-call": { + "category": "actor", + "typeName": "function-call", + "methods": [ + { + "name": "getDetails", + "request": { + "type": "getDetails" + }, + "response": { + "info": { + "_retval": "call-details" + } + } + } + ], + "events": {} + }, + "call-watcher": { + "category": "actor", + "typeName": "call-watcher", + "methods": [ + { + "name": "setup", + "oneway": true, + "request": { + "type": "setup", + "tracedGlobals": { + "_option": 0, + "type": "nullable:array:string" + }, + "tracedFunctions": { + "_option": 0, + "type": "nullable:array:string" + }, + "startRecording": { + "_option": 0, + "type": "boolean" + }, + "performReload": { + "_option": 0, + "type": "boolean" + } + }, + "response": {} + }, + { + "name": "finalize", + "oneway": true, + "request": { + "type": "finalize" + }, + "response": {} + }, + { + "name": "isRecording", + "request": { + "type": "isRecording" + }, + "response": { + "_retval": "boolean" + } + }, + { + "name": "resumeRecording", + "request": { + "type": "resumeRecording" + }, + "response": {} + }, + { + "name": "pauseRecording", + "request": { + "type": "pauseRecording" + }, + "response": { + "calls": { + "_retval": "array:function-call" + } + } + }, + { + "name": "eraseRecording", + "request": { + "type": "eraseRecording" + }, + "response": {} + } + ], + "events": {} + }, + "snapshot-image": { + "category": "dict", + "typeName": "snapshot-image", + "specializations": { + "index": "number", + "width": "number", + "height": "number", + "flipped": "boolean", + "pixels": "uint32-array" + } + }, + "snapshot-overview": { + "category": "dict", + "typeName": "snapshot-overview", + "specializations": { + "calls": "array:function-call", + "thumbnails": "array:snapshot-image", + "screenshot": "snapshot-image" + } + }, + "frame-snapshot": { + "category": "actor", + "typeName": "frame-snapshot", + "methods": [ + { + "name": "getOverview", + "request": { + "type": "getOverview" + }, + "response": { + "overview": { + "_retval": "snapshot-overview" + } + } + }, + { + "name": "generateScreenshotFor", + "request": { + "type": "generateScreenshotFor", + "call": { + "_arg": 0, + "type": "function-call" + } + }, + "response": { + "screenshot": { + "_retval": "snapshot-image" + } + } + } + ], + "events": {} + }, + "canvas": { + "category": "actor", + "typeName": "canvas", + "methods": [ + { + "name": "setup", + "oneway": true, + "request": { + "type": "setup", + "reload": { + "_option": 0, + "type": "boolean" + } + }, + "response": {} + }, + { + "name": "finalize", + "oneway": true, + "request": { + "type": "finalize" + }, + "response": {} + }, + { + "name": "isInitialized", + "request": { + "type": "isInitialized" + }, + "response": { + "initialized": { + "_retval": "boolean" + } + } + }, + { + "name": "recordAnimationFrame", + "request": { + "type": "recordAnimationFrame" + }, + "response": { + "snapshot": { + "_retval": "frame-snapshot" + } + } + } + ], + "events": {} + }, + "gl-shader": { + "category": "actor", + "typeName": "gl-shader", + "methods": [ + { + "name": "getText", + "request": { + "type": "getText" + }, + "response": { + "text": { + "_retval": "string" + } + } + }, + { + "name": "compile", + "request": { + "type": "compile", + "text": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "error": { + "_retval": "nullable:json" + } + } + } + ], + "events": {} + }, + "gl-program": { + "category": "actor", + "typeName": "gl-program", + "methods": [ + { + "name": "getVertexShader", + "request": { + "type": "getVertexShader" + }, + "response": { + "shader": { + "_retval": "gl-shader" + } + } + }, + { + "name": "getFragmentShader", + "request": { + "type": "getFragmentShader" + }, + "response": { + "shader": { + "_retval": "gl-shader" + } + } + }, + { + "name": "highlight", + "oneway": true, + "request": { + "type": "highlight", + "tint": { + "_arg": 0, + "type": "array:number" + } + }, + "response": {} + }, + { + "name": "unhighlight", + "oneway": true, + "request": { + "type": "unhighlight" + }, + "response": {} + }, + { + "name": "blackbox", + "oneway": true, + "request": { + "type": "blackbox" + }, + "response": {} + }, + { + "name": "unblackbox", + "oneway": true, + "request": { + "type": "unblackbox" + }, + "response": {} + } + ], + "events": {} + }, + "webgl": { + "category": "actor", + "typeName": "webgl", + "methods": [ + { + "name": "setup", + "oneway": true, + "request": { + "type": "setup", + "reload": { + "_option": 0, + "type": "boolean" + } + }, + "response": {} + }, + { + "name": "finalize", + "oneway": true, + "request": { + "type": "finalize" + }, + "response": {} + }, + { + "name": "getPrograms", + "request": { + "type": "getPrograms" + }, + "response": { + "programs": { + "_retval": "array:gl-program" + } + } + } + ], + "events": { + "program-linked": { + "type": "programLinked", + "program": { + "_arg": 0, + "type": "gl-program" + } + } + } + }, + "audionode": { + "category": "actor", + "typeName": "audionode", + "methods": [ + { + "name": "getType", + "request": { + "type": "getType" + }, + "response": { + "type": { + "_retval": "string" + } + } + }, + { + "name": "isSource", + "request": { + "type": "isSource" + }, + "response": { + "source": { + "_retval": "boolean" + } + } + }, + { + "name": "setParam", + "request": { + "type": "setParam", + "param": { + "_arg": 0, + "type": "string" + }, + "value": { + "_arg": 1, + "type": "nullable:primitive" + } + }, + "response": { + "error": { + "_retval": "nullable:json" + } + } + }, + { + "name": "getParam", + "request": { + "type": "getParam", + "param": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "text": { + "_retval": "nullable:primitive" + } + } + }, + { + "name": "getParamFlags", + "request": { + "type": "getParamFlags", + "param": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "flags": { + "_retval": "nullable:primitive" + } + } + }, + { + "name": "getParams", + "request": { + "type": "getParams" + }, + "response": { + "params": { + "_retval": "json" + } + } + } + ], + "events": {} + }, + "webaudio": { + "category": "actor", + "typeName": "webaudio", + "methods": [ + { + "name": "setup", + "oneway": true, + "request": { + "type": "setup", + "reload": { + "_option": 0, + "type": "boolean" + } + }, + "response": {} + }, + { + "name": "finalize", + "oneway": true, + "request": { + "type": "finalize" + }, + "response": {} + } + ], + "events": { + "start-context": { + "type": "startContext" + }, + "connect-node": { + "type": "connectNode", + "source": { + "_option": 0, + "type": "audionode" + }, + "dest": { + "_option": 0, + "type": "audionode" + } + }, + "disconnect-node": { + "type": "disconnectNode", + "source": { + "_arg": 0, + "type": "audionode" + } + }, + "connect-param": { + "type": "connectParam", + "source": { + "_arg": 0, + "type": "audionode" + }, + "param": { + "_arg": 1, + "type": "string" + } + }, + "change-param": { + "type": "changeParam", + "source": { + "_option": 0, + "type": "audionode" + }, + "param": { + "_option": 0, + "type": "string" + }, + "value": { + "_option": 0, + "type": "string" + } + }, + "create-node": { + "type": "createNode", + "source": { + "_arg": 0, + "type": "audionode" + } + } + } + }, + "old-stylesheet": { + "category": "actor", + "typeName": "old-stylesheet", + "methods": [ + { + "name": "toggleDisabled", + "request": { + "type": "toggleDisabled" + }, + "response": { + "disabled": { + "_retval": "boolean" + } + } + }, + { + "name": "fetchSource", + "request": { + "type": "fetchSource" + }, + "response": {} + }, + { + "name": "update", + "request": { + "type": "update", + "text": { + "_arg": 0, + "type": "string" + }, + "transition": { + "_arg": 1, + "type": "boolean" + } + }, + "response": {} + } + ], + "events": { + "property-change": { + "type": "propertyChange", + "property": { + "_arg": 0, + "type": "string" + }, + "value": { + "_arg": 1, + "type": "json" + } + }, + "source-load": { + "type": "sourceLoad", + "source": { + "_arg": 0, + "type": "string" + } + }, + "style-applied": { + "type": "styleApplied" + } + } + }, + "styleeditor": { + "category": "actor", + "typeName": "styleeditor", + "methods": [ + { + "name": "newDocument", + "request": { + "type": "newDocument" + }, + "response": {} + }, + { + "name": "newStyleSheet", + "request": { + "type": "newStyleSheet", + "text": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "styleSheet": { + "_retval": "old-stylesheet" + } + } + } + ], + "events": { + "document-load": { + "type": "documentLoad", + "styleSheets": { + "_arg": 0, + "type": "array:old-stylesheet" + } + } + } + }, + "cookieobject": { + "category": "dict", + "typeName": "cookieobject", + "specializations": { + "name": "string", + "value": "longstring", + "path": "nullable:string", + "host": "string", + "isDomain": "boolean", + "isSecure": "boolean", + "isHttpOnly": "boolean", + "creationTime": "number", + "lastAccessed": "number", + "expires": "number" + } + }, + "cookiestoreobject": { + "category": "dict", + "typeName": "cookiestoreobject", + "specializations": { + "total": "number", + "offset": "number", + "data": "array:nullable:cookieobject" + } + }, + "storageobject": { + "category": "dict", + "typeName": "storageobject", + "specializations": { + "name": "string", + "value": "longstring" + } + }, + "storagestoreobject": { + "category": "dict", + "typeName": "storagestoreobject", + "specializations": { + "total": "number", + "offset": "number", + "data": "array:nullable:storageobject" + } + }, + "idbobject": { + "category": "dict", + "typeName": "idbobject", + "specializations": { + "name": "nullable:string", + "db": "nullable:string", + "objectStore": "nullable:string", + "origin": "nullable:string", + "version": "nullable:number", + "objectStores": "nullable:number", + "keyPath": "nullable:string", + "autoIncrement": "nullable:boolean", + "indexes": "nullable:string", + "value": "nullable:longstring" + } + }, + "idbstoreobject": { + "category": "dict", + "typeName": "idbstoreobject", + "specializations": { + "total": "number", + "offset": "number", + "data": "array:nullable:idbobject" + } + }, + "storeUpdateObject": { + "category": "dict", + "typeName": "storeUpdateObject", + "specializations": { + "changed": "nullable:json", + "deleted": "nullable:json", + "added": "nullable:json" + } + }, + "cookies": { + "category": "actor", + "typeName": "cookies", + "methods": [ + { + "name": "getStoreObjects", + "request": { + "type": "getStoreObjects", + "host": { + "_arg": 0, + "type": "primitive" + }, + "names": { + "_arg": 1, + "type": "nullable:array:string" + }, + "options": { + "_arg": 2, + "type": "nullable:json" + } + }, + "response": { + "_retval": "cookiestoreobject" + } + } + ], + "events": {} + }, + "localStorage": { + "category": "actor", + "typeName": "localStorage", + "methods": [ + { + "name": "getStoreObjects", + "request": { + "type": "getStoreObjects", + "host": { + "_arg": 0, + "type": "primitive" + }, + "names": { + "_arg": 1, + "type": "nullable:array:string" + }, + "options": { + "_arg": 2, + "type": "nullable:json" + } + }, + "response": { + "_retval": "storagestoreobject" + } + } + ], + "events": {} + }, + "sessionStorage": { + "category": "actor", + "typeName": "sessionStorage", + "methods": [ + { + "name": "getStoreObjects", + "request": { + "type": "getStoreObjects", + "host": { + "_arg": 0, + "type": "primitive" + }, + "names": { + "_arg": 1, + "type": "nullable:array:string" + }, + "options": { + "_arg": 2, + "type": "nullable:json" + } + }, + "response": { + "_retval": "storagestoreobject" + } + } + ], + "events": {} + }, + "indexedDB": { + "category": "actor", + "typeName": "indexedDB", + "methods": [ + { + "name": "getStoreObjects", + "request": { + "type": "getStoreObjects", + "host": { + "_arg": 0, + "type": "primitive" + }, + "names": { + "_arg": 1, + "type": "nullable:array:string" + }, + "options": { + "_arg": 2, + "type": "nullable:json" + } + }, + "response": { + "_retval": "idbstoreobject" + } + } + ], + "events": {} + }, + "storelist": { + "category": "dict", + "typeName": "storelist", + "specializations": { + "cookies": "cookies", + "localStorage": "localStorage", + "sessionStorage": "sessionStorage", + "indexedDB": "indexedDB" + } + }, + "storage": { + "category": "actor", + "typeName": "storage", + "methods": [ + { + "name": "listStores", + "request": { + "type": "listStores" + }, + "response": { + "_retval": "storelist" + } + } + ], + "events": { + "stores-update": { + "type": "storesUpdate", + "data": { + "_arg": 0, + "type": "storeUpdateObject" + } + }, + "stores-cleared": { + "type": "storesCleared", + "data": { + "_arg": 0, + "type": "json" + } + }, + "stores-reloaded": { + "type": "storesRelaoded", + "data": { + "_arg": 0, + "type": "json" + } + } + } + }, + "gcli": { + "category": "actor", + "typeName": "gcli", + "methods": [ + { + "name": "specs", + "request": { + "type": "specs" + }, + "response": { + "_retval": "json" + } + }, + { + "name": "execute", + "request": { + "type": "execute", + "typed": { + "_arg": 0, + "type": "string" + } + }, + "response": { + "_retval": "json" + } + }, + { + "name": "state", + "request": { + "type": "state", + "typed": { + "_arg": 0, + "type": "string" + }, + "start": { + "_arg": 1, + "type": "number" + }, + "rank": { + "_arg": 2, + "type": "number" + } + }, + "response": { + "_retval": "json" + } + }, + { + "name": "typeparse", + "request": { + "type": "typeparse", + "typed": { + "_arg": 0, + "type": "string" + }, + "param": { + "_arg": 1, + "type": "string" + } + }, + "response": { + "_retval": "json" + } + }, + { + "name": "typeincrement", + "request": { + "type": "typeincrement", + "typed": { + "_arg": 0, + "type": "string" + }, + "param": { + "_arg": 1, + "type": "string" + } + }, + "response": { + "_retval": "string" + } + }, + { + "name": "typedecrement", + "request": { + "type": "typedecrement", + "typed": { + "_arg": 0, + "type": "string" + }, + "param": { + "_arg": 1, + "type": "string" + } + }, + "response": { + "_retval": "string" + } + }, + { + "name": "selectioninfo", + "request": { + "type": "selectioninfo", + "typed": { + "_arg": 0, + "type": "string" + }, + "param": { + "_arg": 1, + "type": "string" + }, + "action": { + "_arg": 1, + "type": "string" + } + }, + "response": { + "_retval": "json" + } + } + ], + "events": {} + }, + "memory": { + "category": "actor", + "typeName": "memory", + "methods": [ + { + "name": "measure", + "request": { + "type": "measure" + }, + "response": { + "_retval": "json" + } + } + ], + "events": {} + }, + "eventLoopLag": { + "category": "actor", + "typeName": "eventLoopLag", + "methods": [ + { + "name": "start", + "request": { + "type": "start" + }, + "response": { + "success": { + "_retval": "number" + } + } + }, + { + "name": "stop", + "request": { + "type": "stop" + }, + "response": {} + } + ], + "events": { + "event-loop-lag": { + "type": "event-loop-lag", + "time": { + "_arg": 0, + "type": "number" + } + } + } + }, + "preference": { + "category": "actor", + "typeName": "preference", + "methods": [ + { + "name": "getBoolPref", + "request": { + "type": "getBoolPref", + "value": { + "_arg": 0, + "type": "primitive" + } + }, + "response": { + "value": { + "_retval": "boolean" + } + } + }, + { + "name": "getCharPref", + "request": { + "type": "getCharPref", + "value": { + "_arg": 0, + "type": "primitive" + } + }, + "response": { + "value": { + "_retval": "string" + } + } + }, + { + "name": "getIntPref", + "request": { + "type": "getIntPref", + "value": { + "_arg": 0, + "type": "primitive" + } + }, + "response": { + "value": { + "_retval": "number" + } + } + }, + { + "name": "getAllPrefs", + "request": { + "type": "getAllPrefs" + }, + "response": { + "value": { + "_retval": "json" + } + } + }, + { + "name": "setBoolPref", + "request": { + "type": "setBoolPref", + "name": { + "_arg": 0, + "type": "primitive" + }, + "value": { + "_arg": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "setCharPref", + "request": { + "type": "setCharPref", + "name": { + "_arg": 0, + "type": "primitive" + }, + "value": { + "_arg": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "setIntPref", + "request": { + "type": "setIntPref", + "name": { + "_arg": 0, + "type": "primitive" + }, + "value": { + "_arg": 1, + "type": "primitive" + } + }, + "response": {} + }, + { + "name": "clearUserPref", + "request": { + "type": "clearUserPref", + "name": { + "_arg": 0, + "type": "primitive" + } + }, + "response": {} + } + ], + "events": {} + }, + "device": { + "category": "actor", + "typeName": "device", + "methods": [ + { + "name": "getDescription", + "request": { + "type": "getDescription" + }, + "response": { + "value": { + "_retval": "json" + } + } + }, + { + "name": "getWallpaper", + "request": { + "type": "getWallpaper" + }, + "response": { + "value": { + "_retval": "longstring" + } + } + }, + { + "name": "screenshotToDataURL", + "request": { + "type": "screenshotToDataURL" + }, + "response": { + "value": { + "_retval": "longstring" + } + } + }, + { + "name": "getRawPermissionsTable", + "request": { + "type": "getRawPermissionsTable" + }, + "response": { + "value": { + "_retval": "json" + } + } + } + ], + "events": {} + } + }, + "from": "root" +} + +},{}],25:[function(_dereq_,module,exports){ +"use strict"; + +var Class = _dereq_("./class").Class; +var util = _dereq_("./util"); +var keys = util.keys; +var values = util.values; +var pairs = util.pairs; +var query = util.query; +var findPath = util.findPath; +var EventTarget = _dereq_("./event").EventTarget; + +var TypeSystem = Class({ + constructor: function(client) { + var types = Object.create(null); + var specification = Object.create(null); + + this.specification = specification; + this.types = types; + + var typeFor = function typeFor(typeName) { + typeName = typeName || "primitive"; + if (!types[typeName]) { + defineType(typeName); + } + + return types[typeName]; + }; + this.typeFor = typeFor; + + var defineType = function(descriptor) { + var type = void(0); + if (typeof(descriptor) === "string") { + if (descriptor.indexOf(":") > 0) + type = makeCompoundType(descriptor); + else if (descriptor.indexOf("#") > 0) + type = new ActorDetail(descriptor); + else if (specification[descriptor]) + type = makeCategoryType(specification[descriptor]); + } else { + type = makeCategoryType(descriptor); + } + + if (type) + types[type.name] = type; + else + throw TypeError("Invalid type: " + descriptor); + }; + this.defineType = defineType; + + + var makeCompoundType = function(name) { + var index = name.indexOf(":"); + var baseType = name.slice(0, index); + var subType = name.slice(index + 1); + + return baseType === "array" ? new ArrayOf(subType) : + baseType === "nullable" ? new Maybe(subType) : + null; + }; + + var makeCategoryType = function(descriptor) { + var category = descriptor.category; + return category === "dict" ? new Dictionary(descriptor) : + category === "actor" ? new Actor(descriptor) : + null; + }; + + var read = function(input, context, typeName) { + return typeFor(typeName).read(input, context); + } + this.read = read; + + var write = function(input, context, typeName) { + return typeFor(typeName).write(input); + }; + this.write = write; + + + var Type = Class({ + constructor: function() { + }, + get name() { + return this.category ? this.category + ":" + this.type : + this.type; + }, + read: function(input, context) { + throw new TypeError("`Type` subclass must implement `read`"); + }, + write: function(input, context) { + throw new TypeError("`Type` subclass must implement `write`"); + } + }); + + var Primitve = Class({ + extends: Type, + constuctor: function(type) { + this.type = type; + }, + read: function(input, context) { + return input; + }, + write: function(input, context) { + return input; + } + }); + + var Maybe = Class({ + extends: Type, + category: "nullable", + constructor: function(type) { + this.type = type; + }, + read: function(input, context) { + return input === null ? null : + input === void(0) ? void(0) : + read(input, context, this.type); + }, + write: function(input, context) { + return input === null ? null : + input === void(0) ? void(0) : + write(input, context, this.type); + } + }); + + var ArrayOf = Class({ + extends: Type, + category: "array", + constructor: function(type) { + this.type = type; + }, + read: function(input, context) { + var type = this.type; + return input.map(function($) { return read($, context, type) }); + }, + write: function(input, context) { + var type = this.type; + return input.map(function($) { return write($, context, type) }); + } + }); + + var makeField = function makeField(name, type) { + return { + enumerable: true, + configurable: true, + get: function() { + Object.defineProperty(this, name, { + configurable: false, + value: read(this.state[name], this.context, type) + }); + return this[name]; + } + } + }; + + var makeFields = function(descriptor) { + return pairs(descriptor).reduce(function(fields, pair) { + var name = pair[0], type = pair[1]; + fields[name] = makeField(name, type); + return fields; + }, {}); + } + + var DictionaryType = Class({}); + + var Dictionary = Class({ + extends: Type, + category: "dict", + get name() { return this.type; }, + constructor: function(descriptor) { + this.type = descriptor.typeName; + this.types = descriptor.specializations; + + var proto = Object.defineProperties({ + extends: DictionaryType, + constructor: function(state, context) { + Object.defineProperties(this, { + state: { + enumerable: false, + writable: true, + configurable: true, + value: state + }, + context: { + enumerable: false, + writable: false, + configurable: true, + value: context + } + }); + } + }, makeFields(this.types)); + + this.class = new Class(proto); + }, + read: function(input, context) { + return new this.class(input, context); + }, + write: function(input, context) { + var output = {}; + for (var key in input) { + output[key] = write(value, context, types[key]); + } + return output; + } + }); + + var makeMethods = function(descriptors) { + return descriptors.reduce(function(methods, descriptor) { + methods[descriptor.name] = { + enumerable: true, + configurable: true, + writable: false, + value: makeMethod(descriptor) + }; + return methods; + }, {}); + }; + + var makeEvents = function(descriptors) { + return pairs(descriptors).reduce(function(events, pair) { + var name = pair[0], descriptor = pair[1]; + var event = new Event(name, descriptor); + events[event.eventType] = event; + return events; + }, Object.create(null)); + }; + + var Actor = Class({ + extends: Type, + category: "actor", + get name() { return this.type; }, + constructor: function(descriptor) { + this.type = descriptor.typeName; + + var events = makeEvents(descriptor.events || {}); + var fields = makeFields(descriptor.fields || {}); + var methods = makeMethods(descriptor.methods || []); + + + var proto = { + extends: Front, + constructor: function() { + Front.apply(this, arguments); + }, + events: events + }; + Object.defineProperties(proto, fields); + Object.defineProperties(proto, methods); + + this.class = Class(proto); + }, + read: function(input, context, detail) { + var state = typeof(input) === "string" ? { actor: input } : input; + + var actor = client.get(state.actor) || new this.class(state, context); + actor.form(state, detail, context); + + return actor; + }, + write: function(input, context, detail) { + return input.id; + } + }); + exports.Actor = Actor; + + + var ActorDetail = Class({ + extends: Actor, + constructor: function(name) { + var parts = name.split("#") + this.actorType = parts[0] + this.detail = parts[1]; + }, + read: function(input, context) { + return typeFor(this.actorType).read(input, context, this.detail); + }, + write: function(input, context) { + return typeFor(this.actorType).write(input, context, this.detail); + } + }); + exports.ActorDetail = ActorDetail; + + var Method = Class({ + extends: Type, + constructor: function(descriptor) { + this.type = descriptor.name; + this.path = findPath(descriptor.response, "_retval"); + this.responseType = this.path && query(descriptor.response, this.path)._retval; + this.requestType = descriptor.request.type; + + var params = []; + for (var key in descriptor.request) { + if (key !== "type") { + var param = descriptor.request[key]; + var index = "_arg" in param ? param._arg : param._option; + var isParam = param._option === index; + var isArgument = param._arg === index; + params[index] = { + type: param.type, + key: key, + index: index, + isParam: isParam, + isArgument: isArgument + }; + } + } + this.params = params; + }, + read: function(input, context) { + return read(query(input, this.path), context, this.responseType); + }, + write: function(input, context) { + return this.params.reduce(function(result, param) { + result[param.key] = write(input[param.index], context, param.type); + return result; + }, {type: this.type}); + } + }); + exports.Method = Method; + + var profiler = function(method, id) { + return function() { + var start = new Date(); + return method.apply(this, arguments).then(function(result) { + var end = new Date(); + client.telemetry.add(id, +end - start); + return result; + }); + }; + }; + + var destructor = function(method) { + return function() { + return method.apply(this, arguments).then(function(result) { + client.release(this); + return result; + }); + }; + }; + + function makeMethod(descriptor) { + var type = new Method(descriptor); + var method = descriptor.oneway ? makeUnidirecationalMethod(descriptor, type) : + makeBidirectionalMethod(descriptor, type); + + if (descriptor.telemetry) + method = profiler(method); + if (descriptor.release) + method = destructor(method); + + return method; + } + + var makeUnidirecationalMethod = function(descriptor, type) { + return function() { + var packet = type.write(arguments, this); + packet.to = this.id; + client.send(packet); + return Promise.resolve(void(0)); + }; + }; + + var makeBidirectionalMethod = function(descriptor, type) { + return function() { + var context = this.context; + var packet = type.write(arguments, context); + var context = this.context; + packet.to = this.id; + return client.request(packet).then(function(packet) { + return type.read(packet, context); + }); + }; + }; + + var Event = Class({ + constructor: function(name, descriptor) { + this.name = descriptor.type || name; + this.eventType = descriptor.type || name; + this.types = Object.create(null); + + var types = this.types; + for (var key in descriptor) { + if (key === "type") { + types[key] = "string"; + } else { + types[key] = descriptor[key].type; + } + } + }, + read: function(input, context) { + var output = {}; + var types = this.types; + for (var key in input) { + output[key] = read(input[key], context, types[key]); + } + return output; + }, + write: function(input, context) { + var output = {}; + var types = this.types; + for (var key in this.types) { + output[key] = write(input[key], context, types[key]); + } + return output; + } + }); + + var Front = Class({ + extends: EventTarget, + EventTarget: EventTarget, + constructor: function(state) { + this.EventTarget(); + Object.defineProperties(this, { + state: { + enumerable: false, + writable: true, + configurable: true, + value: state + } + }); + + client.register(this); + }, + get id() { + return this.state.actor; + }, + get context() { + return this; + }, + form: function(state, detail, context) { + if (this.state !== state) { + if (detail) { + this.state[detail] = state[detail]; + } else { + pairs(state).forEach(function(pair) { + var key = pair[0], value = pair[1]; + this.state[key] = value; + }, this); + } + } + + if (context) { + client.supervise(context, this); + } + }, + requestTypes: function() { + return client.request({ + to: this.id, + type: "requestTypes" + }).then(function(packet) { + return packet.requestTypes; + }); + } + }); + types.primitive = new Primitve("primitive"); + types.string = new Primitve("string"); + types.number = new Primitve("number"); + types.boolean = new Primitve("boolean"); + types.json = new Primitve("json"); + types.array = new Primitve("array"); + }, + registerTypes: function(descriptor) { + var specification = this.specification; + values(descriptor.types).forEach(function(descriptor) { + specification[descriptor.typeName] = descriptor; + }); + } +}); +exports.TypeSystem = TypeSystem; + +},{"./class":3,"./event":5,"./util":26}],26:[function(_dereq_,module,exports){ +"use strict"; + +var keys = Object.keys; +exports.keys = keys; + +// Returns array of values for the given object. +var values = function(object) { + return keys(object).map(function(key) { + return object[key] + }); +}; +exports.values = values; + +// Returns [key, value] pairs for the given object. +var pairs = function(object) { + return keys(object).map(function(key) { + return [key, object[key]] + }); +}; +exports.pairs = pairs; + + +// Queries an object for the field nested with in it. +var query = function(object, path) { + return path.reduce(function(object, entry) { + return object && object[entry] + }, object); +}; +exports.query = query; + +var isObject = function(x) { + return x && typeof(x) === "object" +} + +var findPath = function(object, key) { + var path = void(0); + if (object && typeof(object) === "object") { + var names = keys(object); + if (names.indexOf(key) >= 0) { + path = []; + } else { + var index = 0; + var count = names.length; + while (index < count && !path){ + var head = names[index]; + var tail = findPath(object[head], key); + path = tail ? [head].concat(tail) : tail; + index = index + 1 + } + } + } + return path; +}; +exports.findPath = findPath; + +},{}]},{},[1]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["/Users/gozala/Projects/volcan/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/gozala/Projects/volcan/browser/index.js","/Users/gozala/Projects/volcan/browser/promise.js","/Users/gozala/Projects/volcan/class.js","/Users/gozala/Projects/volcan/client.js","/Users/gozala/Projects/volcan/event.js","/Users/gozala/Projects/volcan/node_modules/browserify/node_modules/events/events.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/d/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/is-callable.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/normalize-options.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/valid-value.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/polyfill.js","/Users/gozala/Projects/volcan/specification/core.json","/Users/gozala/Projects/volcan/specification/protocol.json","/Users/gozala/Projects/volcan/type-system.js","/Users/gozala/Projects/volcan/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/SA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3uEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\n\nvar Client = require(\"../client\").Client;\n\nfunction connect(port) {\n  var client = new Client();\n  return client.connect(port);\n}\nexports.connect = connect;\n","\"use strict\";\n\nexports.Promise = Promise;\n","\"use strict\";\n\nvar describe = Object.getOwnPropertyDescriptor;\nvar Class = function(fields) {\n  var names = Object.keys(fields);\n  var constructor = names.indexOf(\"constructor\") >= 0 ? fields.constructor :\n                    function() {};\n  var ancestor = fields.extends || Object;\n\n  var descriptor = names.reduce(function(descriptor, key) {\n    descriptor[key] = describe(fields, key);\n    return descriptor;\n  }, {});\n\n  var prototype = Object.create(ancestor.prototype, descriptor);\n\n  constructor.prototype = prototype;\n  prototype.constructor = constructor;\n\n  return constructor;\n};\nexports.Class = Class;\n","\"use strict\";\n\nvar Class = require(\"./class\").Class;\nvar TypeSystem = require(\"./type-system\").TypeSystem;\nvar values = require(\"./util\").values;\nvar Promise = require(\"es6-promise\").Promise;\nvar MessageEvent = require(\"./event\").MessageEvent;\n\nvar specification = require(\"./specification/core.json\");\n\nfunction recoverActorDescriptions(error) {\n  console.warn(\"Failed to fetch protocol specification (see reason below). \" +\n               \"Using a fallback protocal specification!\",\n               error);\n  return require(\"./specification/protocol.json\");\n}\n\n// Type to represent superviser actor relations to actors they supervise\n// in terms of lifetime management.\nvar Supervisor = Class({\n  constructor: function(id) {\n    this.id = id;\n    this.workers = [];\n  }\n});\n\nvar Telemetry = Class({\n  add: function(id, ms) {\n    console.log(\"telemetry::\", id, ms)\n  }\n});\n\n// Consider making client a root actor.\n\nvar Client = Class({\n  constructor: function() {\n    this.root = null;\n    this.telemetry = new Telemetry();\n\n    this.setupConnection();\n    this.setupLifeManagement();\n    this.setupTypeSystem();\n  },\n\n  setupConnection: function() {\n    this.requests = [];\n  },\n  setupLifeManagement: function() {\n    this.cache = Object.create(null);\n    this.graph = Object.create(null);\n    this.get = this.get.bind(this);\n    this.release = this.release.bind(this);\n  },\n  setupTypeSystem: function() {\n    this.typeSystem = new TypeSystem(this);\n    this.typeSystem.registerTypes(specification);\n  },\n\n  connect: function(port) {\n    var client = this;\n    return new Promise(function(resolve, reject) {\n      client.port = port;\n      port.onmessage = client.receive.bind(client);\n      client.onReady = resolve;\n      client.onFail = reject;\n\n      port.start();\n    });\n  },\n  send: function(packet) {\n    this.port.postMessage(packet);\n  },\n  request: function(packet) {\n    var client = this;\n    return new Promise(function(resolve, reject) {\n      client.requests.push(packet.to, { resolve: resolve, reject: reject });\n      client.send(packet);\n    });\n  },\n\n  receive: function(event) {\n    var packet = event.data;\n    if (!this.root) {\n      if (packet.from !== \"root\")\n        throw Error(\"Initial packet must be from root\");\n      if (!(\"applicationType\" in packet))\n        throw Error(\"Initial packet must contain applicationType field\");\n\n      this.root = this.typeSystem.read(\"root\", null, \"root\");\n      this.root\n          .protocolDescription()\n          .catch(recoverActorDescriptions)\n          .then(this.typeSystem.registerTypes.bind(this.typeSystem))\n          .then(this.onReady.bind(this, this.root), this.onFail);\n    } else {\n      var actor = this.get(packet.from) || this.root;\n      var event = actor.events[packet.type];\n      if (event) {\n        var message = new MessageEvent(packet.type, {\n          data: event.read(packet)\n        });\n        actor.dispatchEvent(message);\n      } else {\n        var index = this.requests.indexOf(actor.id);\n        if (index >= 0) {\n          var request = this.requests.splice(index, 2).pop();\n          if (packet.error)\n            request.reject(packet);\n          else\n            request.resolve(packet);\n        } else {\n          console.error(Error(\"Unexpected packet \" + JSON.stringify(packet, 2, 2)),\n                        packet,\n                        this.requests.slice(0));\n        }\n      }\n    }\n  },\n\n  get: function(id) {\n    return this.cache[id];\n  },\n  supervisorOf: function(actor) {\n    for (var id in this.graph) {\n      if (this.graph[id].indexOf(actor.id) >= 0) {\n        return id;\n      }\n    }\n  },\n  workersOf: function(actor) {\n    return this.graph[actor.id];\n  },\n  supervise: function(actor, worker) {\n    var workers = this.workersOf(actor)\n    if (workers.indexOf(worker.id) < 0) {\n      workers.push(worker.id);\n    }\n  },\n  unsupervise: function(actor, worker) {\n    var workers = this.workersOf(actor);\n    var index = workers.indexOf(worker.id)\n    if (index >= 0) {\n      workers.splice(index, 1)\n    }\n  },\n\n  register: function(actor) {\n    var registered = this.get(actor.id);\n    if (!registered) {\n      this.cache[actor.id] = actor;\n      this.graph[actor.id] = [];\n    } else if (registered !== actor) {\n      throw new Error(\"Different actor with same id is already registered\");\n    }\n  },\n  unregister: function(actor) {\n    if (this.get(actor.id)) {\n      delete this.cache[actor.id];\n      delete this.graph[actor.id];\n    }\n  },\n\n  release: function(actor) {\n    var supervisor = this.supervisorOf(actor);\n    if (supervisor)\n      this.unsupervise(supervisor, actor);\n\n    var workers = this.workersOf(actor)\n\n    if (workers) {\n      workers.map(this.get).forEach(this.release)\n    }\n    this.unregister(actor);\n  }\n});\nexports.Client = Client;\n","\"use strict\";\n\nvar Symbol = require(\"es6-symbol\")\nvar EventEmitter = require(\"events\").EventEmitter;\nvar Class = require(\"./class\").Class;\n\nvar $bound = Symbol(\"EventTarget/handleEvent\");\nvar $emitter = Symbol(\"EventTarget/emitter\");\n\nfunction makeHandler(handler) {\n  return function(event) {\n    handler.handleEvent(event);\n  }\n}\n\nvar EventTarget = Class({\n  constructor: function() {\n    Object.defineProperty(this, $emitter, {\n      enumerable: false,\n      configurable: true,\n      writable: true,\n      value: new EventEmitter()\n    });\n  },\n  addEventListener: function(type, handler) {\n    if (typeof(handler) === \"function\") {\n      this[$emitter].on(type, handler);\n    }\n    else if (handler && typeof(handler) === \"object\") {\n      if (!handler[$bound]) handler[$bound] = makeHandler(handler);\n      this[$emitter].on(type, handler[$bound]);\n    }\n  },\n  removeEventListener: function(type, handler) {\n    if (typeof(handler) === \"function\")\n      this[$emitter].removeListener(type, handler);\n    else if (handler && handler[$bound])\n      this[$emitter].removeListener(type, handler[$bound]);\n  },\n  dispatchEvent: function(event) {\n    event.target = this;\n    this[$emitter].emit(event.type, event);\n  }\n});\nexports.EventTarget = EventTarget;\n\nvar MessageEvent = Class({\n  constructor: function(type, options) {\n    options = options || {};\n    this.type = type;\n    this.data = options.data === void(0) ? null : options.data;\n\n    this.lastEventId = options.lastEventId || \"\";\n    this.origin = options.origin || \"\";\n    this.bubbles = options.bubbles || false;\n    this.cancelable = options.cancelable || false;\n  },\n  source: null,\n  ports: null,\n  preventDefault: function() {\n  },\n  stopPropagation: function() {\n  },\n  stopImmediatePropagation: function() {\n  }\n});\nexports.MessageEvent = MessageEvent;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        throw TypeError('Uncaught, unspecified \"error\" event.');\n      }\n      return false;\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        len = arguments.length;\n        args = new Array(len - 1);\n        for (i = 1; i < len; i++)\n          args[i - 1] = arguments[i];\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    len = arguments.length;\n    args = new Array(len - 1);\n    for (i = 1; i < len; i++)\n      args[i - 1] = arguments[i];\n\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    var m;\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  var ret;\n  if (!emitter._events || !emitter._events[type])\n    ret = 0;\n  else if (isFunction(emitter._events[type]))\n    ret = 1;\n  else\n    ret = emitter._events[type].length;\n  return ret;\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","'use strict';\n\nmodule.exports = require('./is-implemented')() ? Symbol : require('./polyfill');\n","'use strict';\n\nmodule.exports = function () {\n\tvar symbol;\n\tif (typeof Symbol !== 'function') return false;\n\tsymbol = Symbol('test symbol');\n\ttry {\n\t\tif (String(symbol) !== 'Symbol (test symbol)') return false;\n\t} catch (e) { return false; }\n\tif (typeof Symbol.iterator === 'symbol') return true;\n\n\t// Return 'true' for polyfills\n\tif (typeof Symbol.isConcatSpreadable !== 'object') return false;\n\tif (typeof Symbol.isRegExp !== 'object') return false;\n\tif (typeof Symbol.iterator !== 'object') return false;\n\tif (typeof Symbol.toPrimitive !== 'object') return false;\n\tif (typeof Symbol.toStringTag !== 'object') return false;\n\tif (typeof Symbol.unscopables !== 'object') return false;\n\n\treturn true;\n};\n","'use strict';\n\nvar assign        = require('es5-ext/object/assign')\n  , normalizeOpts = require('es5-ext/object/normalize-options')\n  , isCallable    = require('es5-ext/object/is-callable')\n  , contains      = require('es5-ext/string/#/contains')\n\n  , d;\n\nd = module.exports = function (dscr, value/*, options*/) {\n\tvar c, e, w, options, desc;\n\tif ((arguments.length < 2) || (typeof dscr !== 'string')) {\n\t\toptions = value;\n\t\tvalue = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[2];\n\t}\n\tif (dscr == null) {\n\t\tc = w = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t\tw = contains.call(dscr, 'w');\n\t}\n\n\tdesc = { value: value, configurable: c, enumerable: e, writable: w };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n\nd.gs = function (dscr, get, set/*, options*/) {\n\tvar c, e, options, desc;\n\tif (typeof dscr !== 'string') {\n\t\toptions = set;\n\t\tset = get;\n\t\tget = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[3];\n\t}\n\tif (get == null) {\n\t\tget = undefined;\n\t} else if (!isCallable(get)) {\n\t\toptions = get;\n\t\tget = set = undefined;\n\t} else if (set == null) {\n\t\tset = undefined;\n\t} else if (!isCallable(set)) {\n\t\toptions = set;\n\t\tset = undefined;\n\t}\n\tif (dscr == null) {\n\t\tc = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t}\n\n\tdesc = { get: get, set: set, configurable: c, enumerable: e };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? Object.assign\n\t: require('./shim');\n","'use strict';\n\nmodule.exports = function () {\n\tvar assign = Object.assign, obj;\n\tif (typeof assign !== 'function') return false;\n\tobj = { foo: 'raz' };\n\tassign(obj, { bar: 'dwa' }, { trzy: 'trzy' });\n\treturn (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy';\n};\n","'use strict';\n\nvar keys  = require('../keys')\n  , value = require('../valid-value')\n\n  , max = Math.max;\n\nmodule.exports = function (dest, src/*, …srcn*/) {\n\tvar error, i, l = max(arguments.length, 2), assign;\n\tdest = Object(value(dest));\n\tassign = function (key) {\n\t\ttry { dest[key] = src[key]; } catch (e) {\n\t\t\tif (!error) error = e;\n\t\t}\n\t};\n\tfor (i = 1; i < l; ++i) {\n\t\tsrc = arguments[i];\n\t\tkeys(src).forEach(assign);\n\t}\n\tif (error !== undefined) throw error;\n\treturn dest;\n};\n","// Deprecated\n\n'use strict';\n\nmodule.exports = function (obj) { return typeof obj === 'function'; };\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? Object.keys\n\t: require('./shim');\n","'use strict';\n\nmodule.exports = function () {\n\ttry {\n\t\tObject.keys('primitive');\n\t\treturn true;\n\t} catch (e) { return false; }\n};\n","'use strict';\n\nvar keys = Object.keys;\n\nmodule.exports = function (object) {\n\treturn keys(object == null ? object : Object(object));\n};\n","'use strict';\n\nvar assign = require('./assign')\n\n  , forEach = Array.prototype.forEach\n  , create = Object.create, getPrototypeOf = Object.getPrototypeOf\n\n  , process;\n\nprocess = function (src, obj) {\n\tvar proto = getPrototypeOf(src);\n\treturn assign(proto ? process(proto, obj) : obj, src);\n};\n\nmodule.exports = function (options/*, …options*/) {\n\tvar result = create(null);\n\tforEach.call(arguments, function (options) {\n\t\tif (options == null) return;\n\t\tprocess(Object(options), result);\n\t});\n\treturn result;\n};\n","'use strict';\n\nmodule.exports = function (value) {\n\tif (value == null) throw new TypeError(\"Cannot use null or undefined\");\n\treturn value;\n};\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? String.prototype.contains\n\t: require('./shim');\n","'use strict';\n\nvar str = 'razdwatrzy';\n\nmodule.exports = function () {\n\tif (typeof str.contains !== 'function') return false;\n\treturn ((str.contains('dwa') === true) && (str.contains('foo') === false));\n};\n","'use strict';\n\nvar indexOf = String.prototype.indexOf;\n\nmodule.exports = function (searchString/*, position*/) {\n\treturn indexOf.call(this, searchString, arguments[1]) > -1;\n};\n","'use strict';\n\nvar d = require('d')\n\n  , create = Object.create, defineProperties = Object.defineProperties\n  , generateName, Symbol;\n\ngenerateName = (function () {\n\tvar created = create(null);\n\treturn function (desc) {\n\t\tvar postfix = 0;\n\t\twhile (created[desc + (postfix || '')]) ++postfix;\n\t\tdesc += (postfix || '');\n\t\tcreated[desc] = true;\n\t\treturn '@@' + desc;\n\t};\n}());\n\nmodule.exports = Symbol = function (description) {\n\tvar symbol;\n\tif (this instanceof Symbol) {\n\t\tthrow new TypeError('TypeError: Symbol is not a constructor');\n\t}\n\tsymbol = create(Symbol.prototype);\n\tdescription = (description === undefined ? '' : String(description));\n\treturn defineProperties(symbol, {\n\t\t__description__: d('', description),\n\t\t__name__: d('', generateName(description))\n\t});\n};\n\nObject.defineProperties(Symbol, {\n\tcreate: d('', Symbol('create')),\n\thasInstance: d('', Symbol('hasInstance')),\n\tisConcatSpreadable: d('', Symbol('isConcatSpreadable')),\n\tisRegExp: d('', Symbol('isRegExp')),\n\titerator: d('', Symbol('iterator')),\n\ttoPrimitive: d('', Symbol('toPrimitive')),\n\ttoStringTag: d('', Symbol('toStringTag')),\n\tunscopables: d('', Symbol('unscopables'))\n});\n\ndefineProperties(Symbol.prototype, {\n\tproperToString: d(function () {\n\t\treturn 'Symbol (' + this.__description__ + ')';\n\t}),\n\ttoString: d('', function () { return this.__name__; })\n});\nObject.defineProperty(Symbol.prototype, Symbol.toPrimitive, d('',\n\tfunction (hint) {\n\t\tthrow new TypeError(\"Conversion of symbol objects is not allowed\");\n\t}));\nObject.defineProperty(Symbol.prototype, Symbol.toStringTag, d('c', 'Symbol'));\n","module.exports={\n  \"types\": {\n    \"root\": {\n      \"category\": \"actor\",\n      \"typeName\": \"root\",\n      \"methods\": [\n        {\n          \"name\": \"echo\",\n          \"request\": {\n            \"string\": { \"_arg\": 0, \"type\": \"string\" }\n          },\n          \"response\": {\n            \"string\": { \"_retval\": \"string\" }\n          }\n        },\n        {\n          \"name\": \"listTabs\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"tablist\" }\n        },\n        {\n          \"name\": \"protocolDescription\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"json\" }\n        }\n      ],\n      \"events\": {\n        \"tabListChanged\": {}\n      }\n    },\n    \"tablist\": {\n      \"category\": \"dict\",\n      \"typeName\": \"tablist\",\n      \"specializations\": {\n        \"selected\": \"number\",\n        \"tabs\": \"array:tab\",\n        \"url\": \"string\",\n        \"consoleActor\": \"console\",\n        \"inspectorActor\": \"inspector\",\n        \"styleSheetsActor\": \"stylesheets\",\n        \"styleEditorActor\": \"styleeditor\",\n        \"memoryActor\": \"memory\",\n        \"eventLoopLagActor\": \"eventLoopLag\",\n        \"preferenceActor\": \"preference\",\n        \"deviceActor\": \"device\",\n\n        \"profilerActor\": \"profiler\",\n        \"chromeDebugger\": \"chromeDebugger\",\n        \"webappsActor\": \"webapps\"\n      }\n    },\n    \"tab\": {\n      \"category\": \"actor\",\n      \"typeName\": \"tab\",\n      \"fields\": {\n        \"title\": \"string\",\n        \"url\": \"string\",\n        \"outerWindowID\": \"number\",\n        \"inspectorActor\": \"inspector\",\n        \"callWatcherActor\": \"call-watcher\",\n        \"canvasActor\": \"canvas\",\n        \"webglActor\": \"webgl\",\n        \"webaudioActor\": \"webaudio\",\n        \"storageActor\": \"storage\",\n        \"gcliActor\": \"gcli\",\n        \"memoryActor\": \"memory\",\n        \"eventLoopLag\": \"eventLoopLag\",\n        \"styleSheetsActor\": \"stylesheets\",\n        \"styleEditorActor\": \"styleeditor\",\n\n        \"consoleActor\": \"console\",\n        \"traceActor\": \"trace\"\n      },\n      \"methods\": [\n         {\n          \"name\": \"attach\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"json\" }\n         }\n      ],\n      \"events\": {\n        \"tabNavigated\": {\n           \"typeName\": \"tabNavigated\"\n        }\n      }\n    },\n    \"console\": {\n      \"category\": \"actor\",\n      \"typeName\": \"console\",\n      \"methods\": [\n        {\n          \"name\": \"evaluateJS\",\n          \"request\": {\n            \"text\": {\n              \"_option\": 0,\n              \"type\": \"string\"\n            },\n            \"url\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            },\n            \"bindObjectActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            },\n            \"frameActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            },\n            \"selectedNodeActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"evaluatejsresponse\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"evaluatejsresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"evaluatejsresponse\",\n      \"specializations\": {\n        \"result\": \"object\",\n        \"exception\": \"object\",\n        \"exceptionMessage\": \"string\",\n        \"input\": \"string\"\n      }\n    },\n    \"object\": {\n      \"category\": \"actor\",\n      \"typeName\": \"object\",\n      \"methods\": [\n         {\n           \"name\": \"property\",\n           \"request\": {\n              \"name\": {\n                \"_arg\": 0,\n                \"type\": \"string\"\n              }\n           },\n           \"response\": {\n              \"descriptor\": {\n                \"_retval\": \"json\"\n              }\n           }\n         }\n      ]\n    }\n  }\n}\n","module.exports={\n  \"types\": {\n    \"longstractor\": {\n      \"category\": \"actor\",\n      \"typeName\": \"longstractor\",\n      \"methods\": [\n        {\n          \"name\": \"substring\",\n          \"request\": {\n            \"type\": \"substring\",\n            \"start\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"end\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"substring\": {\n              \"_retval\": \"primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"stylesheet\": {\n      \"category\": \"actor\",\n      \"typeName\": \"stylesheet\",\n      \"methods\": [\n        {\n          \"name\": \"toggleDisabled\",\n          \"request\": {\n            \"type\": \"toggleDisabled\"\n          },\n          \"response\": {\n            \"disabled\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"getOriginalSources\",\n          \"request\": {\n            \"type\": \"getOriginalSources\"\n          },\n          \"response\": {\n            \"originalSources\": {\n              \"_retval\": \"nullable:array:originalsource\"\n            }\n          }\n        },\n        {\n          \"name\": \"getOriginalLocation\",\n          \"request\": {\n            \"type\": \"getOriginalLocation\",\n            \"line\": {\n              \"_arg\": 0,\n              \"type\": \"number\"\n            },\n            \"column\": {\n              \"_arg\": 1,\n              \"type\": \"number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"originallocationresponse\"\n          }\n        },\n        {\n          \"name\": \"update\",\n          \"request\": {\n            \"type\": \"update\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"transition\": {\n              \"_arg\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"property-change\": {\n          \"type\": \"propertyChange\",\n          \"property\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_arg\": 1,\n            \"type\": \"json\"\n          }\n        },\n        \"style-applied\": {\n          \"type\": \"styleApplied\"\n        }\n      }\n    },\n    \"originalsource\": {\n      \"category\": \"actor\",\n      \"typeName\": \"originalsource\",\n      \"methods\": [\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"stylesheets\": {\n      \"category\": \"actor\",\n      \"typeName\": \"stylesheets\",\n      \"methods\": [\n        {\n          \"name\": \"getStyleSheets\",\n          \"request\": {\n            \"type\": \"getStyleSheets\"\n          },\n          \"response\": {\n            \"styleSheets\": {\n              \"_retval\": \"array:stylesheet\"\n            }\n          }\n        },\n        {\n          \"name\": \"addStyleSheet\",\n          \"request\": {\n            \"type\": \"addStyleSheet\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"styleSheet\": {\n              \"_retval\": \"stylesheet\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"originallocationresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"originallocationresponse\",\n      \"specializations\": {\n        \"source\": \"string\",\n        \"line\": \"number\",\n        \"column\": \"number\"\n      }\n    },\n    \"domnode\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domnode\",\n      \"methods\": [\n        {\n          \"name\": \"getNodeValue\",\n          \"request\": {\n            \"type\": \"getNodeValue\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"setNodeValue\",\n          \"request\": {\n            \"type\": \"setNodeValue\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getImageData\",\n          \"request\": {\n            \"type\": \"getImageData\",\n            \"maxDim\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"imageData\"\n          }\n        },\n        {\n          \"name\": \"modifyAttributes\",\n          \"request\": {\n            \"type\": \"modifyAttributes\",\n            \"modifications\": {\n              \"_arg\": 0,\n              \"type\": \"array:json\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"appliedstyle\": {\n      \"category\": \"dict\",\n      \"typeName\": \"appliedstyle\",\n      \"specializations\": {\n        \"rule\": \"domstylerule#actorid\",\n        \"inherited\": \"nullable:domnode#actorid\"\n      }\n    },\n    \"matchedselector\": {\n      \"category\": \"dict\",\n      \"typeName\": \"matchedselector\",\n      \"specializations\": {\n        \"rule\": \"domstylerule#actorid\",\n        \"selector\": \"string\",\n        \"value\": \"string\",\n        \"status\": \"number\"\n      }\n    },\n    \"matchedselectorresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"matchedselectorresponse\",\n      \"specializations\": {\n        \"rules\": \"array:domstylerule\",\n        \"sheets\": \"array:stylesheet\",\n        \"matched\": \"array:matchedselector\"\n      }\n    },\n    \"appliedStylesReturn\": {\n      \"category\": \"dict\",\n      \"typeName\": \"appliedStylesReturn\",\n      \"specializations\": {\n        \"entries\": \"array:appliedstyle\",\n        \"rules\": \"array:domstylerule\",\n        \"sheets\": \"array:stylesheet\"\n      }\n    },\n    \"pagestyle\": {\n      \"category\": \"actor\",\n      \"typeName\": \"pagestyle\",\n      \"methods\": [\n        {\n          \"name\": \"getComputed\",\n          \"request\": {\n            \"type\": \"getComputed\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"markMatched\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"onlyMatched\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"filter\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"computed\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getMatchedSelectors\",\n          \"request\": {\n            \"type\": \"getMatchedSelectors\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"property\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            },\n            \"filter\": {\n              \"_option\": 2,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"matchedselectorresponse\"\n          }\n        },\n        {\n          \"name\": \"getApplied\",\n          \"request\": {\n            \"type\": \"getApplied\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"inherited\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"matchedSelectors\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"filter\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"appliedStylesReturn\"\n          }\n        },\n        {\n          \"name\": \"getLayout\",\n          \"request\": {\n            \"type\": \"getLayout\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"autoMargins\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"domstylerule\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domstylerule\",\n      \"methods\": [\n        {\n          \"name\": \"modifyProperties\",\n          \"request\": {\n            \"type\": \"modifyProperties\",\n            \"modifications\": {\n              \"_arg\": 0,\n              \"type\": \"array:json\"\n            }\n          },\n          \"response\": {\n            \"rule\": {\n              \"_retval\": \"domstylerule\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"highlighter\": {\n      \"category\": \"actor\",\n      \"typeName\": \"highlighter\",\n      \"methods\": [\n        {\n          \"name\": \"showBoxModel\",\n          \"request\": {\n            \"type\": \"showBoxModel\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"region\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"hideBoxModel\",\n          \"request\": {\n            \"type\": \"hideBoxModel\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pick\",\n          \"request\": {\n            \"type\": \"pick\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"cancelPick\",\n          \"request\": {\n            \"type\": \"cancelPick\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"imageData\": {\n      \"category\": \"dict\",\n      \"typeName\": \"imageData\",\n      \"specializations\": {\n        \"data\": \"nullable:longstring\",\n        \"size\": \"json\"\n      }\n    },\n    \"disconnectedNode\": {\n      \"category\": \"dict\",\n      \"typeName\": \"disconnectedNode\",\n      \"specializations\": {\n        \"node\": \"domnode\",\n        \"newParents\": \"array:domnode\"\n      }\n    },\n    \"disconnectedNodeArray\": {\n      \"category\": \"dict\",\n      \"typeName\": \"disconnectedNodeArray\",\n      \"specializations\": {\n        \"nodes\": \"array:domnode\",\n        \"newParents\": \"array:domnode\"\n      }\n    },\n    \"dommutation\": {\n      \"category\": \"dict\",\n      \"typeName\": \"dommutation\",\n      \"specializations\": {}\n    },\n    \"domnodelist\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domnodelist\",\n      \"methods\": [\n        {\n          \"name\": \"item\",\n          \"request\": {\n            \"type\": \"item\",\n            \"item\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"items\",\n          \"request\": {\n            \"type\": \"items\",\n            \"start\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:number\"\n            },\n            \"end\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNodeArray\"\n          }\n        },\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"domtraversalarray\": {\n      \"category\": \"dict\",\n      \"typeName\": \"domtraversalarray\",\n      \"specializations\": {\n        \"nodes\": \"array:domnode\"\n      }\n    },\n    \"domwalker\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domwalker\",\n      \"methods\": [\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pick\",\n          \"request\": {\n            \"type\": \"pick\"\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"cancelPick\",\n          \"request\": {\n            \"type\": \"cancelPick\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"highlight\",\n          \"request\": {\n            \"type\": \"highlight\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"document\",\n          \"request\": {\n            \"type\": \"document\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"documentElement\",\n          \"request\": {\n            \"type\": \"documentElement\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"parents\",\n          \"request\": {\n            \"type\": \"parents\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"sameDocument\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"nodes\": {\n              \"_retval\": \"array:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"retainNode\",\n          \"request\": {\n            \"type\": \"retainNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unretainNode\",\n          \"request\": {\n            \"type\": \"unretainNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"releaseNode\",\n          \"request\": {\n            \"type\": \"releaseNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"force\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"children\",\n          \"request\": {\n            \"type\": \"children\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"maxNodes\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            },\n            \"center\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"start\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"domtraversalarray\"\n          }\n        },\n        {\n          \"name\": \"siblings\",\n          \"request\": {\n            \"type\": \"siblings\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"maxNodes\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            },\n            \"center\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"start\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"domtraversalarray\"\n          }\n        },\n        {\n          \"name\": \"nextSibling\",\n          \"request\": {\n            \"type\": \"nextSibling\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"previousSibling\",\n          \"request\": {\n            \"type\": \"previousSibling\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"querySelector\",\n          \"request\": {\n            \"type\": \"querySelector\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"selector\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"querySelectorAll\",\n          \"request\": {\n            \"type\": \"querySelectorAll\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"selector\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"list\": {\n              \"_retval\": \"domnodelist\"\n            }\n          }\n        },\n        {\n          \"name\": \"getSuggestionsForQuery\",\n          \"request\": {\n            \"type\": \"getSuggestionsForQuery\",\n            \"query\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"completing\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"selectorState\": {\n              \"_arg\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"list\": {\n              \"_retval\": \"array:array:string\"\n            }\n          }\n        },\n        {\n          \"name\": \"addPseudoClassLock\",\n          \"request\": {\n            \"type\": \"addPseudoClassLock\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"pseudoClass\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"parents\": {\n              \"_option\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"hideNode\",\n          \"request\": {\n            \"type\": \"hideNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unhideNode\",\n          \"request\": {\n            \"type\": \"unhideNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"removePseudoClassLock\",\n          \"request\": {\n            \"type\": \"removePseudoClassLock\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"pseudoClass\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"parents\": {\n              \"_option\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"clearPseudoClassLocks\",\n          \"request\": {\n            \"type\": \"clearPseudoClassLocks\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"innerHTML\",\n          \"request\": {\n            \"type\": \"innerHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"outerHTML\",\n          \"request\": {\n            \"type\": \"outerHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"setOuterHTML\",\n          \"request\": {\n            \"type\": \"setOuterHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"removeNode\",\n          \"request\": {\n            \"type\": \"removeNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"nextSibling\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"insertBefore\",\n          \"request\": {\n            \"type\": \"insertBefore\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"parent\": {\n              \"_arg\": 1,\n              \"type\": \"domnode\"\n            },\n            \"sibling\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getMutations\",\n          \"request\": {\n            \"type\": \"getMutations\",\n            \"cleanup\": {\n              \"_option\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"mutations\": {\n              \"_retval\": \"array:dommutation\"\n            }\n          }\n        },\n        {\n          \"name\": \"isInDOMTree\",\n          \"request\": {\n            \"type\": \"isInDOMTree\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"attached\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getNodeActorFromObjectActor\",\n          \"request\": {\n            \"type\": \"getNodeActorFromObjectActor\",\n            \"objectActorID\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"nodeFront\": {\n              \"_retval\": \"nullable:disconnectedNode\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"new-mutations\": {\n          \"type\": \"newMutations\"\n        },\n        \"picker-node-picked\": {\n          \"type\": \"pickerNodePicked\",\n          \"node\": {\n            \"_arg\": 0,\n            \"type\": \"disconnectedNode\"\n          }\n        },\n        \"picker-node-hovered\": {\n          \"type\": \"pickerNodeHovered\",\n          \"node\": {\n            \"_arg\": 0,\n            \"type\": \"disconnectedNode\"\n          }\n        },\n        \"highlighter-ready\": {\n          \"type\": \"highlighter-ready\"\n        },\n        \"highlighter-hide\": {\n          \"type\": \"highlighter-hide\"\n        }\n      }\n    },\n    \"inspector\": {\n      \"category\": \"actor\",\n      \"typeName\": \"inspector\",\n      \"methods\": [\n        {\n          \"name\": \"getWalker\",\n          \"request\": {\n            \"type\": \"getWalker\"\n          },\n          \"response\": {\n            \"walker\": {\n              \"_retval\": \"domwalker\"\n            }\n          }\n        },\n        {\n          \"name\": \"getPageStyle\",\n          \"request\": {\n            \"type\": \"getPageStyle\"\n          },\n          \"response\": {\n            \"pageStyle\": {\n              \"_retval\": \"pagestyle\"\n            }\n          }\n        },\n        {\n          \"name\": \"getHighlighter\",\n          \"request\": {\n            \"type\": \"getHighlighter\",\n            \"autohide\": {\n              \"_arg\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {\n            \"highligter\": {\n              \"_retval\": \"highlighter\"\n            }\n          }\n        },\n        {\n          \"name\": \"getImageDataFromURL\",\n          \"request\": {\n            \"type\": \"getImageDataFromURL\",\n            \"url\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"maxDim\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"imageData\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"call-stack-item\": {\n      \"category\": \"dict\",\n      \"typeName\": \"call-stack-item\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"file\": \"string\",\n        \"line\": \"number\"\n      }\n    },\n    \"call-details\": {\n      \"category\": \"dict\",\n      \"typeName\": \"call-details\",\n      \"specializations\": {\n        \"type\": \"number\",\n        \"name\": \"string\",\n        \"stack\": \"array:call-stack-item\"\n      }\n    },\n    \"function-call\": {\n      \"category\": \"actor\",\n      \"typeName\": \"function-call\",\n      \"methods\": [\n        {\n          \"name\": \"getDetails\",\n          \"request\": {\n            \"type\": \"getDetails\"\n          },\n          \"response\": {\n            \"info\": {\n              \"_retval\": \"call-details\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"call-watcher\": {\n      \"category\": \"actor\",\n      \"typeName\": \"call-watcher\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"tracedGlobals\": {\n              \"_option\": 0,\n              \"type\": \"nullable:array:string\"\n            },\n            \"tracedFunctions\": {\n              \"_option\": 0,\n              \"type\": \"nullable:array:string\"\n            },\n            \"startRecording\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            },\n            \"performReload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"isRecording\",\n          \"request\": {\n            \"type\": \"isRecording\"\n          },\n          \"response\": {\n            \"_retval\": \"boolean\"\n          }\n        },\n        {\n          \"name\": \"resumeRecording\",\n          \"request\": {\n            \"type\": \"resumeRecording\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pauseRecording\",\n          \"request\": {\n            \"type\": \"pauseRecording\"\n          },\n          \"response\": {\n            \"calls\": {\n              \"_retval\": \"array:function-call\"\n            }\n          }\n        },\n        {\n          \"name\": \"eraseRecording\",\n          \"request\": {\n            \"type\": \"eraseRecording\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"snapshot-image\": {\n      \"category\": \"dict\",\n      \"typeName\": \"snapshot-image\",\n      \"specializations\": {\n        \"index\": \"number\",\n        \"width\": \"number\",\n        \"height\": \"number\",\n        \"flipped\": \"boolean\",\n        \"pixels\": \"uint32-array\"\n      }\n    },\n    \"snapshot-overview\": {\n      \"category\": \"dict\",\n      \"typeName\": \"snapshot-overview\",\n      \"specializations\": {\n        \"calls\": \"array:function-call\",\n        \"thumbnails\": \"array:snapshot-image\",\n        \"screenshot\": \"snapshot-image\"\n      }\n    },\n    \"frame-snapshot\": {\n      \"category\": \"actor\",\n      \"typeName\": \"frame-snapshot\",\n      \"methods\": [\n        {\n          \"name\": \"getOverview\",\n          \"request\": {\n            \"type\": \"getOverview\"\n          },\n          \"response\": {\n            \"overview\": {\n              \"_retval\": \"snapshot-overview\"\n            }\n          }\n        },\n        {\n          \"name\": \"generateScreenshotFor\",\n          \"request\": {\n            \"type\": \"generateScreenshotFor\",\n            \"call\": {\n              \"_arg\": 0,\n              \"type\": \"function-call\"\n            }\n          },\n          \"response\": {\n            \"screenshot\": {\n              \"_retval\": \"snapshot-image\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"canvas\": {\n      \"category\": \"actor\",\n      \"typeName\": \"canvas\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"isInitialized\",\n          \"request\": {\n            \"type\": \"isInitialized\"\n          },\n          \"response\": {\n            \"initialized\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"recordAnimationFrame\",\n          \"request\": {\n            \"type\": \"recordAnimationFrame\"\n          },\n          \"response\": {\n            \"snapshot\": {\n              \"_retval\": \"frame-snapshot\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"gl-shader\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gl-shader\",\n      \"methods\": [\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"compile\",\n          \"request\": {\n            \"type\": \"compile\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"error\": {\n              \"_retval\": \"nullable:json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"gl-program\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gl-program\",\n      \"methods\": [\n        {\n          \"name\": \"getVertexShader\",\n          \"request\": {\n            \"type\": \"getVertexShader\"\n          },\n          \"response\": {\n            \"shader\": {\n              \"_retval\": \"gl-shader\"\n            }\n          }\n        },\n        {\n          \"name\": \"getFragmentShader\",\n          \"request\": {\n            \"type\": \"getFragmentShader\"\n          },\n          \"response\": {\n            \"shader\": {\n              \"_retval\": \"gl-shader\"\n            }\n          }\n        },\n        {\n          \"name\": \"highlight\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"highlight\",\n            \"tint\": {\n              \"_arg\": 0,\n              \"type\": \"array:number\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unhighlight\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"unhighlight\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"blackbox\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"blackbox\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unblackbox\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"unblackbox\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"webgl\": {\n      \"category\": \"actor\",\n      \"typeName\": \"webgl\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getPrograms\",\n          \"request\": {\n            \"type\": \"getPrograms\"\n          },\n          \"response\": {\n            \"programs\": {\n              \"_retval\": \"array:gl-program\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"program-linked\": {\n          \"type\": \"programLinked\",\n          \"program\": {\n            \"_arg\": 0,\n            \"type\": \"gl-program\"\n          }\n        }\n      }\n    },\n    \"audionode\": {\n      \"category\": \"actor\",\n      \"typeName\": \"audionode\",\n      \"methods\": [\n        {\n          \"name\": \"getType\",\n          \"request\": {\n            \"type\": \"getType\"\n          },\n          \"response\": {\n            \"type\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"isSource\",\n          \"request\": {\n            \"type\": \"isSource\"\n          },\n          \"response\": {\n            \"source\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"setParam\",\n          \"request\": {\n            \"type\": \"setParam\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:primitive\"\n            }\n          },\n          \"response\": {\n            \"error\": {\n              \"_retval\": \"nullable:json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParam\",\n          \"request\": {\n            \"type\": \"getParam\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"nullable:primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParamFlags\",\n          \"request\": {\n            \"type\": \"getParamFlags\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"flags\": {\n              \"_retval\": \"nullable:primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParams\",\n          \"request\": {\n            \"type\": \"getParams\"\n          },\n          \"response\": {\n            \"params\": {\n              \"_retval\": \"json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"webaudio\": {\n      \"category\": \"actor\",\n      \"typeName\": \"webaudio\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"start-context\": {\n          \"type\": \"startContext\"\n        },\n        \"connect-node\": {\n          \"type\": \"connectNode\",\n          \"source\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          },\n          \"dest\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          }\n        },\n        \"disconnect-node\": {\n          \"type\": \"disconnectNode\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          }\n        },\n        \"connect-param\": {\n          \"type\": \"connectParam\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          },\n          \"param\": {\n            \"_arg\": 1,\n            \"type\": \"string\"\n          }\n        },\n        \"change-param\": {\n          \"type\": \"changeParam\",\n          \"source\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          },\n          \"param\": {\n            \"_option\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_option\": 0,\n            \"type\": \"string\"\n          }\n        },\n        \"create-node\": {\n          \"type\": \"createNode\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          }\n        }\n      }\n    },\n    \"old-stylesheet\": {\n      \"category\": \"actor\",\n      \"typeName\": \"old-stylesheet\",\n      \"methods\": [\n        {\n          \"name\": \"toggleDisabled\",\n          \"request\": {\n            \"type\": \"toggleDisabled\"\n          },\n          \"response\": {\n            \"disabled\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"fetchSource\",\n          \"request\": {\n            \"type\": \"fetchSource\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"update\",\n          \"request\": {\n            \"type\": \"update\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"transition\": {\n              \"_arg\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"property-change\": {\n          \"type\": \"propertyChange\",\n          \"property\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_arg\": 1,\n            \"type\": \"json\"\n          }\n        },\n        \"source-load\": {\n          \"type\": \"sourceLoad\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          }\n        },\n        \"style-applied\": {\n          \"type\": \"styleApplied\"\n        }\n      }\n    },\n    \"styleeditor\": {\n      \"category\": \"actor\",\n      \"typeName\": \"styleeditor\",\n      \"methods\": [\n        {\n          \"name\": \"newDocument\",\n          \"request\": {\n            \"type\": \"newDocument\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"newStyleSheet\",\n          \"request\": {\n            \"type\": \"newStyleSheet\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"styleSheet\": {\n              \"_retval\": \"old-stylesheet\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"document-load\": {\n          \"type\": \"documentLoad\",\n          \"styleSheets\": {\n            \"_arg\": 0,\n            \"type\": \"array:old-stylesheet\"\n          }\n        }\n      }\n    },\n    \"cookieobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"cookieobject\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"value\": \"longstring\",\n        \"path\": \"nullable:string\",\n        \"host\": \"string\",\n        \"isDomain\": \"boolean\",\n        \"isSecure\": \"boolean\",\n        \"isHttpOnly\": \"boolean\",\n        \"creationTime\": \"number\",\n        \"lastAccessed\": \"number\",\n        \"expires\": \"number\"\n      }\n    },\n    \"cookiestoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"cookiestoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:cookieobject\"\n      }\n    },\n    \"storageobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storageobject\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"value\": \"longstring\"\n      }\n    },\n    \"storagestoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storagestoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:storageobject\"\n      }\n    },\n    \"idbobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"idbobject\",\n      \"specializations\": {\n        \"name\": \"nullable:string\",\n        \"db\": \"nullable:string\",\n        \"objectStore\": \"nullable:string\",\n        \"origin\": \"nullable:string\",\n        \"version\": \"nullable:number\",\n        \"objectStores\": \"nullable:number\",\n        \"keyPath\": \"nullable:string\",\n        \"autoIncrement\": \"nullable:boolean\",\n        \"indexes\": \"nullable:string\",\n        \"value\": \"nullable:longstring\"\n      }\n    },\n    \"idbstoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"idbstoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:idbobject\"\n      }\n    },\n    \"storeUpdateObject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storeUpdateObject\",\n      \"specializations\": {\n        \"changed\": \"nullable:json\",\n        \"deleted\": \"nullable:json\",\n        \"added\": \"nullable:json\"\n      }\n    },\n    \"cookies\": {\n      \"category\": \"actor\",\n      \"typeName\": \"cookies\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"cookiestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"localStorage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"localStorage\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"storagestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"sessionStorage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"sessionStorage\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"storagestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"indexedDB\": {\n      \"category\": \"actor\",\n      \"typeName\": \"indexedDB\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"idbstoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"storelist\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storelist\",\n      \"specializations\": {\n        \"cookies\": \"cookies\",\n        \"localStorage\": \"localStorage\",\n        \"sessionStorage\": \"sessionStorage\",\n        \"indexedDB\": \"indexedDB\"\n      }\n    },\n    \"storage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"storage\",\n      \"methods\": [\n        {\n          \"name\": \"listStores\",\n          \"request\": {\n            \"type\": \"listStores\"\n          },\n          \"response\": {\n            \"_retval\": \"storelist\"\n          }\n        }\n      ],\n      \"events\": {\n        \"stores-update\": {\n          \"type\": \"storesUpdate\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"storeUpdateObject\"\n          }\n        },\n        \"stores-cleared\": {\n          \"type\": \"storesCleared\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"json\"\n          }\n        },\n        \"stores-reloaded\": {\n          \"type\": \"storesRelaoded\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"json\"\n          }\n        }\n      }\n    },\n    \"gcli\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gcli\",\n      \"methods\": [\n        {\n          \"name\": \"specs\",\n          \"request\": {\n            \"type\": \"specs\"\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"execute\",\n          \"request\": {\n            \"type\": \"execute\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"state\",\n          \"request\": {\n            \"type\": \"state\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"start\": {\n              \"_arg\": 1,\n              \"type\": \"number\"\n            },\n            \"rank\": {\n              \"_arg\": 2,\n              \"type\": \"number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"typeparse\",\n          \"request\": {\n            \"type\": \"typeparse\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"typeincrement\",\n          \"request\": {\n            \"type\": \"typeincrement\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"string\"\n          }\n        },\n        {\n          \"name\": \"typedecrement\",\n          \"request\": {\n            \"type\": \"typedecrement\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"string\"\n          }\n        },\n        {\n          \"name\": \"selectioninfo\",\n          \"request\": {\n            \"type\": \"selectioninfo\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            },\n            \"action\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"memory\": {\n      \"category\": \"actor\",\n      \"typeName\": \"memory\",\n      \"methods\": [\n        {\n          \"name\": \"measure\",\n          \"request\": {\n            \"type\": \"measure\"\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"eventLoopLag\": {\n      \"category\": \"actor\",\n      \"typeName\": \"eventLoopLag\",\n      \"methods\": [\n        {\n          \"name\": \"start\",\n          \"request\": {\n            \"type\": \"start\"\n          },\n          \"response\": {\n            \"success\": {\n              \"_retval\": \"number\"\n            }\n          }\n        },\n        {\n          \"name\": \"stop\",\n          \"request\": {\n            \"type\": \"stop\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"event-loop-lag\": {\n          \"type\": \"event-loop-lag\",\n          \"time\": {\n            \"_arg\": 0,\n            \"type\": \"number\"\n          }\n        }\n      }\n    },\n    \"preference\": {\n      \"category\": \"actor\",\n      \"typeName\": \"preference\",\n      \"methods\": [\n        {\n          \"name\": \"getBoolPref\",\n          \"request\": {\n            \"type\": \"getBoolPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getCharPref\",\n          \"request\": {\n            \"type\": \"getCharPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"getIntPref\",\n          \"request\": {\n            \"type\": \"getIntPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"number\"\n            }\n          }\n        },\n        {\n          \"name\": \"getAllPrefs\",\n          \"request\": {\n            \"type\": \"getAllPrefs\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"setBoolPref\",\n          \"request\": {\n            \"type\": \"setBoolPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"setCharPref\",\n          \"request\": {\n            \"type\": \"setCharPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"setIntPref\",\n          \"request\": {\n            \"type\": \"setIntPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"clearUserPref\",\n          \"request\": {\n            \"type\": \"clearUserPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"device\": {\n      \"category\": \"actor\",\n      \"typeName\": \"device\",\n      \"methods\": [\n        {\n          \"name\": \"getDescription\",\n          \"request\": {\n            \"type\": \"getDescription\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getWallpaper\",\n          \"request\": {\n            \"type\": \"getWallpaper\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"screenshotToDataURL\",\n          \"request\": {\n            \"type\": \"screenshotToDataURL\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"getRawPermissionsTable\",\n          \"request\": {\n            \"type\": \"getRawPermissionsTable\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    }\n  },\n  \"from\": \"root\"\n}\n","\"use strict\";\n\nvar Class = require(\"./class\").Class;\nvar util = require(\"./util\");\nvar keys = util.keys;\nvar values = util.values;\nvar pairs = util.pairs;\nvar query = util.query;\nvar findPath = util.findPath;\nvar EventTarget = require(\"./event\").EventTarget;\n\nvar TypeSystem = Class({\n  constructor: function(client) {\n    var types = Object.create(null);\n    var specification = Object.create(null);\n\n    this.specification = specification;\n    this.types = types;\n\n    var typeFor = function typeFor(typeName) {\n      typeName = typeName || \"primitive\";\n      if (!types[typeName]) {\n        defineType(typeName);\n      }\n\n      return types[typeName];\n    };\n    this.typeFor = typeFor;\n\n    var defineType = function(descriptor) {\n      var type = void(0);\n      if (typeof(descriptor) === \"string\") {\n        if (descriptor.indexOf(\":\") > 0)\n          type = makeCompoundType(descriptor);\n        else if (descriptor.indexOf(\"#\") > 0)\n          type = new ActorDetail(descriptor);\n          else if (specification[descriptor])\n            type = makeCategoryType(specification[descriptor]);\n      } else {\n        type = makeCategoryType(descriptor);\n      }\n\n      if (type)\n        types[type.name] = type;\n      else\n        throw TypeError(\"Invalid type: \" + descriptor);\n    };\n    this.defineType = defineType;\n\n\n    var makeCompoundType = function(name) {\n      var index = name.indexOf(\":\");\n      var baseType = name.slice(0, index);\n      var subType = name.slice(index + 1);\n\n      return baseType === \"array\" ? new ArrayOf(subType) :\n      baseType === \"nullable\" ? new Maybe(subType) :\n      null;\n    };\n\n    var makeCategoryType = function(descriptor) {\n      var category = descriptor.category;\n      return category === \"dict\" ? new Dictionary(descriptor) :\n      category === \"actor\" ? new Actor(descriptor) :\n      null;\n    };\n\n    var read = function(input, context, typeName) {\n      return typeFor(typeName).read(input, context);\n    }\n    this.read = read;\n\n    var write = function(input, context, typeName) {\n      return typeFor(typeName).write(input);\n    };\n    this.write = write;\n\n\n    var Type = Class({\n      constructor: function() {\n      },\n      get name() {\n        return this.category ? this.category + \":\" + this.type :\n        this.type;\n      },\n      read: function(input, context) {\n        throw new TypeError(\"`Type` subclass must implement `read`\");\n      },\n      write: function(input, context) {\n        throw new TypeError(\"`Type` subclass must implement `write`\");\n      }\n    });\n\n    var Primitve = Class({\n      extends: Type,\n      constuctor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        return input;\n      },\n      write: function(input, context) {\n        return input;\n      }\n    });\n\n    var Maybe = Class({\n      extends: Type,\n      category: \"nullable\",\n      constructor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        return input === null ? null :\n        input === void(0) ? void(0) :\n        read(input, context, this.type);\n      },\n      write: function(input, context) {\n        return input === null ? null :\n        input === void(0) ? void(0) :\n        write(input, context, this.type);\n      }\n    });\n\n    var ArrayOf = Class({\n      extends: Type,\n      category: \"array\",\n      constructor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        var type = this.type;\n        return input.map(function($) { return read($, context, type) });\n      },\n      write: function(input, context) {\n        var type = this.type;\n        return input.map(function($) { return write($, context, type) });\n      }\n    });\n\n    var makeField = function makeField(name, type) {\n      return {\n        enumerable: true,\n        configurable: true,\n        get: function() {\n          Object.defineProperty(this, name, {\n            configurable: false,\n            value: read(this.state[name], this.context, type)\n          });\n          return this[name];\n        }\n      }\n    };\n\n    var makeFields = function(descriptor) {\n      return pairs(descriptor).reduce(function(fields, pair) {\n        var name = pair[0], type = pair[1];\n        fields[name] = makeField(name, type);\n        return fields;\n      }, {});\n    }\n\n    var DictionaryType = Class({});\n\n    var Dictionary = Class({\n      extends: Type,\n      category: \"dict\",\n      get name() { return this.type; },\n      constructor: function(descriptor) {\n        this.type = descriptor.typeName;\n        this.types = descriptor.specializations;\n\n        var proto = Object.defineProperties({\n          extends: DictionaryType,\n          constructor: function(state, context) {\n            Object.defineProperties(this, {\n              state: {\n                enumerable: false,\n                writable: true,\n                configurable: true,\n                value: state\n              },\n              context: {\n                enumerable: false,\n                writable: false,\n                configurable: true,\n                value: context\n              }\n            });\n          }\n        }, makeFields(this.types));\n\n        this.class = new Class(proto);\n      },\n      read: function(input, context) {\n        return new this.class(input, context);\n      },\n      write: function(input, context) {\n        var output = {};\n        for (var key in input) {\n          output[key] = write(value, context, types[key]);\n        }\n        return output;\n      }\n    });\n\n    var makeMethods = function(descriptors) {\n      return descriptors.reduce(function(methods, descriptor) {\n        methods[descriptor.name] = {\n          enumerable: true,\n          configurable: true,\n          writable: false,\n          value: makeMethod(descriptor)\n        };\n        return methods;\n      }, {});\n    };\n\n    var makeEvents = function(descriptors) {\n      return pairs(descriptors).reduce(function(events, pair) {\n        var name = pair[0], descriptor = pair[1];\n        var event = new Event(name, descriptor);\n        events[event.eventType] = event;\n        return events;\n      }, Object.create(null));\n    };\n\n    var Actor = Class({\n      extends: Type,\n      category: \"actor\",\n      get name() { return this.type; },\n      constructor: function(descriptor) {\n        this.type = descriptor.typeName;\n\n        var events = makeEvents(descriptor.events || {});\n        var fields = makeFields(descriptor.fields || {});\n        var methods = makeMethods(descriptor.methods || []);\n\n\n        var proto = {\n          extends: Front,\n          constructor: function() {\n            Front.apply(this, arguments);\n          },\n          events: events\n        };\n        Object.defineProperties(proto, fields);\n        Object.defineProperties(proto, methods);\n\n        this.class = Class(proto);\n      },\n      read: function(input, context, detail) {\n        var state = typeof(input) === \"string\" ? { actor: input } : input;\n\n        var actor = client.get(state.actor) || new this.class(state, context);\n        actor.form(state, detail, context);\n\n        return actor;\n      },\n      write: function(input, context, detail) {\n        return input.id;\n      }\n    });\n    exports.Actor = Actor;\n\n\n    var ActorDetail = Class({\n      extends: Actor,\n      constructor: function(name) {\n        var parts = name.split(\"#\")\n        this.actorType = parts[0]\n        this.detail = parts[1];\n      },\n      read: function(input, context) {\n        return typeFor(this.actorType).read(input, context, this.detail);\n      },\n      write: function(input, context) {\n        return typeFor(this.actorType).write(input, context, this.detail);\n      }\n    });\n    exports.ActorDetail = ActorDetail;\n\n    var Method = Class({\n      extends: Type,\n      constructor: function(descriptor) {\n        this.type = descriptor.name;\n        this.path = findPath(descriptor.response, \"_retval\");\n        this.responseType = this.path && query(descriptor.response, this.path)._retval;\n        this.requestType = descriptor.request.type;\n\n        var params = [];\n        for (var key in descriptor.request) {\n          if (key !== \"type\") {\n            var param = descriptor.request[key];\n            var index = \"_arg\" in param ? param._arg : param._option;\n            var isParam = param._option === index;\n            var isArgument = param._arg === index;\n            params[index] = {\n              type: param.type,\n              key: key,\n              index: index,\n              isParam: isParam,\n              isArgument: isArgument\n            };\n          }\n        }\n        this.params = params;\n      },\n      read: function(input, context) {\n        return read(query(input, this.path), context, this.responseType);\n      },\n      write: function(input, context) {\n        return this.params.reduce(function(result, param) {\n          result[param.key] = write(input[param.index], context, param.type);\n          return result;\n        }, {type: this.type});\n      }\n    });\n    exports.Method = Method;\n\n    var profiler = function(method, id) {\n      return function() {\n        var start = new Date();\n        return method.apply(this, arguments).then(function(result) {\n          var end = new Date();\n          client.telemetry.add(id, +end - start);\n          return result;\n        });\n      };\n    };\n\n    var destructor = function(method) {\n      return function() {\n        return method.apply(this, arguments).then(function(result) {\n          client.release(this);\n          return result;\n        });\n      };\n    };\n\n    function makeMethod(descriptor) {\n      var type = new Method(descriptor);\n      var method = descriptor.oneway ? makeUnidirecationalMethod(descriptor, type) :\n                   makeBidirectionalMethod(descriptor, type);\n\n      if (descriptor.telemetry)\n        method = profiler(method);\n      if (descriptor.release)\n        method = destructor(method);\n\n      return method;\n    }\n\n    var makeUnidirecationalMethod = function(descriptor, type) {\n      return function() {\n        var packet = type.write(arguments, this);\n        packet.to = this.id;\n        client.send(packet);\n        return Promise.resolve(void(0));\n      };\n    };\n\n    var makeBidirectionalMethod = function(descriptor, type) {\n      return function() {\n        var context = this.context;\n        var packet = type.write(arguments, context);\n        var context = this.context;\n        packet.to = this.id;\n        return client.request(packet).then(function(packet) {\n          return type.read(packet, context);\n        });\n      };\n    };\n\n    var Event = Class({\n      constructor: function(name, descriptor) {\n        this.name = descriptor.type || name;\n        this.eventType = descriptor.type || name;\n        this.types = Object.create(null);\n\n        var types = this.types;\n        for (var key in descriptor) {\n          if (key === \"type\") {\n            types[key] = \"string\";\n          } else {\n            types[key] = descriptor[key].type;\n          }\n        }\n      },\n      read: function(input, context) {\n        var output = {};\n        var types = this.types;\n        for (var key in input) {\n          output[key] = read(input[key], context, types[key]);\n        }\n        return output;\n      },\n      write: function(input, context) {\n        var output = {};\n        var types = this.types;\n        for (var key in this.types) {\n          output[key] = write(input[key], context, types[key]);\n        }\n        return output;\n      }\n    });\n\n    var Front = Class({\n      extends: EventTarget,\n      EventTarget: EventTarget,\n      constructor: function(state) {\n        this.EventTarget();\n        Object.defineProperties(this,  {\n          state: {\n            enumerable: false,\n            writable: true,\n            configurable: true,\n            value: state\n          }\n        });\n\n        client.register(this);\n      },\n      get id() {\n        return this.state.actor;\n      },\n      get context() {\n        return this;\n      },\n      form: function(state, detail, context) {\n        if (this.state !== state) {\n          if (detail) {\n            this.state[detail] = state[detail];\n          } else {\n            pairs(state).forEach(function(pair) {\n              var key = pair[0], value = pair[1];\n              this.state[key] = value;\n            }, this);\n          }\n        }\n\n        if (context) {\n          client.supervise(context, this);\n        }\n      },\n      requestTypes: function() {\n        return client.request({\n          to: this.id,\n          type: \"requestTypes\"\n        }).then(function(packet) {\n          return packet.requestTypes;\n        });\n      }\n    });\n    types.primitive = new Primitve(\"primitive\");\n    types.string = new Primitve(\"string\");\n    types.number = new Primitve(\"number\");\n    types.boolean = new Primitve(\"boolean\");\n    types.json = new Primitve(\"json\");\n    types.array = new Primitve(\"array\");\n  },\n  registerTypes: function(descriptor) {\n    var specification = this.specification;\n    values(descriptor.types).forEach(function(descriptor) {\n      specification[descriptor.typeName] = descriptor;\n    });\n  }\n});\nexports.TypeSystem = TypeSystem;\n","\"use strict\";\n\nvar keys = Object.keys;\nexports.keys = keys;\n\n// Returns array of values for the given object.\nvar values = function(object) {\n  return keys(object).map(function(key) {\n    return object[key]\n  });\n};\nexports.values = values;\n\n// Returns [key, value] pairs for the given object.\nvar pairs = function(object) {\n  return keys(object).map(function(key) {\n    return [key, object[key]]\n  });\n};\nexports.pairs = pairs;\n\n\n// Queries an object for the field nested with in it.\nvar query = function(object, path) {\n  return path.reduce(function(object, entry) {\n    return object && object[entry]\n  }, object);\n};\nexports.query = query;\n\nvar isObject = function(x) {\n  return x && typeof(x) === \"object\"\n}\n\nvar findPath = function(object, key) {\n  var path = void(0);\n  if (object && typeof(object) === \"object\") {\n    var names = keys(object);\n    if (names.indexOf(key) >= 0) {\n      path = [];\n    } else {\n      var index = 0;\n      var count = names.length;\n      while (index < count && !path){\n        var head = names[index];\n        var tail = findPath(object[head], key);\n        path = tail ? [head].concat(tail) : tail;\n        index = index + 1\n      }\n    }\n  }\n  return path;\n};\nexports.findPath = findPath;\n"]} +(1) +}); |