ruby-wisp-source 0.7.0

data/vendor/interactivate/node_modules/interactivate/node_modules/dom-reduce/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "dom-reduce",
+  "id": "dom-reduce",
+  "version": "1.0.0",
+  "description": "Reducible DOM APIs",
+  "keywords": [
+    "dom",
+    "reduce",
+    "reducers",
+    "reducible",
+    "stream",
+    "FRP",
+    "functional",
+    "reactive",
+    "signal",
+    "event"
+  ],
+  "author": {
+    "name": "Irakli Gozalishvili",
+    "email": "rfobic@gmail.com",
+    "url": "http://jeditoolkit.com"
+  },
+  "homepage": "https://github.com/Gozala/dom-reduce",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/dom-reduce.git",
+    "web": "https://github.com/Gozala/dom-reduce"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/dom-reduce/issues/"
+  },
+  "dependencies": {
+    "reducible": "~1.0.1"
+  },
+  "devDependencies": {
+    "test": "~0.5.0",
+    "phantomify": "~0.x.0",
+    "reducers": "~2.0.0"
+  },
+  "main": "./index.js",
+  "scripts": {
+    "test": "node ./node_modules/phantomify/bin/cmd.js ./test/index.js",
+    "repl": "node node_modules/repl-utils",
+    "postinstall": "npm dedup"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/dom-reduce/License.md"
+    }
+  ],
+  "readme": "# dom-reduce\n\n[![Build Status](https://secure.travis-ci.org/Gozala/dom-reduce.png)](http://travis-ci.org/Gozala/dom-reduce)\n\nSmall library for dealing with browser DOM events in a [reducible][reducers]\nstyle. This lets operate on user events as with regular collection data\nstructures in composable manner.\n\n## Usage\n\n```js\nvar open = require(\"dom-reduce/event\")\nvar map = require(\"reducers/map\")\nvar filter = require(\"reducers/filter\")\nvar fold = require(\"reducers/fold\")\nvar takeWhile = require(\"reducers/take-while\")\n\n// Take stream of mouse move events.\nvar moves = open(document.documentElement, \"mousemove\")\n// Map it to the axis positions\nvar axis = map(moves, function(event) {\n  return { x: event.clientX, y: event.clientY }\n})\n// Filter down to the area we're interested in.\nvar lineAxis = filter(axis, function(value) {\n  return value.x > 190 && value.x < 200\n})\n\n// Take positions only until mouse reaches the edge.\n// Note that when this contidion is met event listeners\n// will automatically be removed.\nvar values = takeWhile(lineAxis, function(value) {\n  return value.y > 0\n})\n\n// Drow sowething in the given range.\nfold(lineAxis, function(position) {\n  draw(position)\n})\n```\n\n## Install\n\n    npm install dom-reduce\n\n## Develop\n\nLibrary is developed using awesome [browserify][]! [Phantomify][] is used\nfor running test in a [PhantomJS][].\n\n[reducers]:https://github.com/Gozala/reducers\n[browserify]:https://github.com/substack/node-browserify\n[phantomify]:https://github.com/Gozala/phantomify\n[phantomjs]:https://github.com/ariya/phantomjs\n",
+  "readmeFilename": "Readme.md",
+  "_id": "dom-reduce@1.0.0",
+  "_from": "dom-reduce"
+}

data/vendor/interactivate/node_modules/interactivate/node_modules/dom-reduce/test/index.js

@@ -0,0 +1,91 @@
+/*jshint browser:true */
+"use strict";
+
+var open = require("../event")
+var reduced = require("reducible/reduced")
+var fold = require("reducers/fold")
+var filter = require("reducers/filter")
+var into = require("reducers/into")
+
+function click(target) {
+  var event = document.createEvent("MouseEvents")
+  event.initMouseEvent("click", true, true, window, 0, 0, 0, 0, 0,
+                       false, false, false, false, 0, null)
+  target.dispatchEvent(event)
+}
+
+exports["test the dom events are reduced"] = function(assert) {
+  var element = document.createElement("div")
+  document.body.appendChild(element)
+
+
+  var clicks = open(element, "click")
+  var count = 0
+  var result = fold(clicks, function(event, state) {
+    assert.equal(event.target, element, "event target is element")
+    count = count + 1
+  }, 0)
+
+  click(element)
+  click(element)
+
+  assert.equal(count, 2, "reducer was called twice")
+  document.body.removeChild(element)
+}
+
+exports["test listeners removal"] = function(assert) {
+  var element = document.createElement("div")
+  document.body.appendChild(element)
+
+
+  var clicks = open(element, "click")
+  var count = 0
+  var result = fold(clicks, function(event, state) {
+    count = count + 1
+    assert.equal(event.target, element, "event target is element")
+    return reduced("stop!")
+  }, 0)
+
+  click(element)
+  click(element)
+  click(element)
+
+  assert.equal(count, 1, "reducer stopped reduction early")
+  assert.deepEqual(into(result), ["stop!"], "reducer accumulates value")
+  document.body.removeChild(element)
+}
+
+
+exports["test multiple reducers"] = function(assert) {
+  var element = document.createElement("div")
+  document.body.appendChild(element)
+
+
+  var clicks = open(element, "click")
+  var profile = []
+
+  var r1 = fold(clicks, function(event, state) {
+    profile.push(1)
+    assert.equal(event.target, element, "event target is element #1")
+    if (profile.length === 3) return reduced("stop!")
+  }, 0)
+
+  var r2 = fold(clicks, function(event, state) {
+    profile.push(2)
+    assert.equal(event.target, element, "event target is element #2")
+  })
+
+  click(element)
+  click(element)
+  click(element)
+  click(element)
+  click(element)
+  click(element)
+
+  assert.deepEqual(profile, [1, 2, 1, 2, 2, 2, 2, 2],
+                   "events were delivered in expected order")
+  assert.deepEqual(into(r1), ["stop!"], "first reduce was stopped early")
+  document.body.removeChild(element)
+}
+
+require("test").run(exports)

data/vendor/interactivate/node_modules/interactivate/node_modules/method/History.md

@@ -0,0 +1,60 @@
+# Changes
+
+## 2.0.0 / 2013-03-12
+
+  - Make naming methods with unique `id` users responsibility.
+  - Fix `npm dedup` issue by making unique `id`'s users responsibility.
+
+## 1.0.2 / 2012-12-26
+
+  - Delegate to polymorphic methods from `.define` and `.implement` so, they
+    can be overidden.
+
+## 1.0.1 / 2012-11-11
+
+  - Fix issues with different `Error` types as they all inherit from
+    `Error`.
+
+## 1.0.0 / 2012-11-09
+
+  - Add browser test integration.
+  - Fix cross-browser incompatibilities & test failures.
+  - Add support for host objects.
+  - Add optional `hint` argument for method to ease debugging.
+  - Remove default implementation at definition time.
+
+## 0.1.1 / 2012-10-15
+
+ - Fix regression causing custom type implementation to be stored on objects.
+
+## 0.1.0 / 2012-10-15
+
+ - Remove dependency on name module.
+ - Implement fallback for engines that do not support ES5.
+ - Add support for built-in type extensions without extending their prototypes.
+ - Make API for default definitions more intuitive.
+   Skipping type argument now defines default:
+
+      isFoo.define(function(value) {
+        return false
+      })
+
+ - Make exposed `define` and `implement` polymorphic.
+ - Removed dev dependency on swank-js.
+ - Primitive types `string, number, boolean` no longer inherit method
+   implementations from `Object`.
+
+## 0.0.3 / 2012-07-17
+
+  - Remove module boilerplate
+
+## 0.0.2 / 2012-06-26
+
+  - Name changes to make it less conflicting with other library conventions.
+  - Expose function version of `define` & `implement` methods.
+  - Expose `Null` and `Undefined` object holding implementations for an
+    associated types.
+
+## 0.0.1 / 2012-06-25
+
+  - Initial release

data/vendor/interactivate/node_modules/interactivate/node_modules/method/License.md

@@ -0,0 +1,18 @@
+Copyright 2012 Irakli Gozalishvili. All rights reserved.
+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.

data/vendor/interactivate/node_modules/interactivate/node_modules/method/Readme.md

@@ -0,0 +1,125 @@
+# method
+
+[![Build Status](https://secure.travis-ci.org/Gozala/method.png)](http://travis-ci.org/Gozala/method)
+
+
+[![Browser support](http://ci.testling.com/Gozala/method.png)](http://ci.testling.com/Gozala/method)
+
+
+Library provides an API for defining polymorphic methods that dispatch on the
+first argument type. This provides a powerful way for decouple abstraction
+interface definition from an actual implementations per type / instance,
+without risks of interference with other libraries.
+
+### Motivation
+
+  - Provide a high-performance, dynamic polymorphism construct as an
+    alternative to existing object methods that does not provides any
+    mechanics for guarding against name conflicts.
+  - Allow independent extension of types, and implementations of methods
+    on types, by different parties.
+
+## Install
+
+    npm install method
+
+## Use
+
+```js
+var method = require("method")
+
+// Define `isWatchable` method that can be implemented for any type.
+// Use some UNIQUE identifer for the method to avoid any naming collisions.
+// If not provided one will be generate but with npm it's easy to end up
+// with copies of same library and there for copies of the same function
+// leading to surprises. So just really pick a name that is unique!
+var isWatchable = method("isWatchable@watchables")
+
+// If you call it on any object it will
+// throw as nothing implements that method yet.
+//isWatchable({}) // => Exception: method is not implemented
+
+// If you define private method on `Object.prototype`
+// all objects will inherit it.
+Object.prototype[isWatchable] = function() {
+  return false;
+}
+
+isWatchable({}) // => false
+
+
+// Although `isWatchable` property above will be enumerable and there for
+// may damage some assumbtions made by other libraries. There for it"s
+// recomended to use built-in helpers methods that will define extension
+// without breaking assumbtions made by other libraries:
+
+isWatchable.define(Object, function() { return false })
+
+
+// There are primitive types in JS that won"t inherit methods from Object:
+isWatchable(null) // => Exception: method is not implemented
+
+// One could either implement methods for such types:
+isWatchable.define(null, function() { return false })
+isWatchable.define(undefined, function() { return false })
+
+// Or simply define default implementation:
+isWatchable.define(function() { return false })
+
+// Alternatively default implementation may be provided at creation:
+isWatchable = method(function() { return false })
+
+// Method dispatches on an first argument type. That allows us to create
+// new types with an alternative implementations:
+function Watchable() {}
+isWatchable.define(Watchable, function() { return true })
+
+// This will make all `Watchable` instances watchable!
+isWatchable(new Watchable()) // => true
+
+// Arbitrary objects can also be extended to implement given method. For example
+// any object can simply made watchable:
+function watchable(object) {
+  return isWatchable.implement(objct, function() { return true })
+}
+
+isWatchable(watchable({})) // => true
+
+// Full protocols can be defined with such methods:
+var observers = "observers@" + module.filename
+var watchers = method("watchers@watchables")
+var watch = method("watch@watchables")
+var unwatch = method("unwatch@watchables")
+
+watchers.define(Watchable, function(target) {
+  return target[observers] || (target[observers] = [])
+})
+
+watch.define(Watchable, function(target, watcher) {
+  var observers = watchers(target)
+  if (observers.indexOf(watcher) < 0) observers.push(watcher)
+  return target
+})
+unwatch.define(Watchable, function(target, watcher) {
+  var observers = watchers(target)
+  var index = observers.indexOf(watcher)
+  if (observers.indexOf(watcher) >= 0) observers.unshift(watcher)
+  return target
+})
+
+// Define type Port that inherits form Watchable
+
+function Port() {}
+Port.prototype = Object.create(Watchable.prototype)
+
+var emit = method("emit")
+emit.define(Port, function(port, message) {
+  watchers(port).slice().forEach(function(watcher) {
+    watcher(message)
+  })
+})
+
+var p = new Port()
+watch(p, console.log)
+emit(p, "hello world") // => info: "hello world"
+```

data/vendor/interactivate/node_modules/interactivate/node_modules/method/core.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var defineProperty = Object.defineProperty || function(object, name, property) {
+  object[name] = property.value
+  return object
+}
+
+// Shortcut for `Object.prototype.toString` for faster access.
+var typefy = Object.prototype.toString
+
+// Map to for jumping from typeof(value) to associated type prefix used
+// as a hash in the map of builtin implementations.
+var types = { "function": "Object", "object": "Object" }
+
+// Array is used to save method implementations for the host objects in order
+// to avoid extending them with non-primitive values that could cause leaks.
+var host = []
+// Hash map is used to save method implementations for builtin types in order
+// to avoid extending their prototypes. This also allows to share method
+// implementations for types across diff contexts / frames / compartments.
+var builtin = {}
+
+function Primitive() {}
+function ObjectType() {}
+ObjectType.prototype = new Primitive()
+function ErrorType() {}
+ErrorType.prototype = new ObjectType()
+
+var Default = builtin.Default = Primitive.prototype
+var Null = builtin.Null = new Primitive()
+var Void = builtin.Void = new Primitive()
+builtin.String = new Primitive()
+builtin.Number = new Primitive()
+builtin.Boolean = new Primitive()
+
+builtin.Object = ObjectType.prototype
+builtin.Error = ErrorType.prototype
+
+builtin.EvalError = new ErrorType()
+builtin.InternalError = new ErrorType()
+builtin.RangeError = new ErrorType()
+builtin.ReferenceError = new ErrorType()
+builtin.StopIteration = new ErrorType()
+builtin.SyntaxError = new ErrorType()
+builtin.TypeError = new ErrorType()
+builtin.URIError = new ErrorType()
+
+
+function Method(id) {
+  /**
+  Private Method is a callable private name that dispatches on the first
+  arguments same named Method:
+
+      method(object, ...rest) => object[method](...rest)
+
+  It is supposed to be given **unique** `id` preferably in `"jump@package"`
+  like form so it won't collide with `id's` other users create. If no argument
+  is passed unique id is generated, but it's proved to be problematic with
+  npm where it's easy to end up with a copies of same module where each copy
+  will have a different name.
+
+  ## Example
+
+      var foo = Method("foo@awesomeness")
+
+      // Implementation for any types
+      foo.define(function(value, arg1, arg2) {
+        // ...
+      })
+
+      // Implementation for a specific type
+      foo.define(BarType, function(bar, arg1, arg2) {
+        // ...
+      })
+  **/
+
+  // Create an internal unique name if one is not provided, also prefix it
+  // to avoid collision with regular method names.
+  var name = "λ:" + String(id || Math.random().toString(32).substr(2))
+
+  function dispatch(value) {
+    // Method dispatches on type of the first argument.
+    // If first argument is `null` or `void` associated implementation is
+    // looked up in the `builtin` hash where implementations for built-ins
+    // are stored.
+    var type = null
+    var method = value === null ? Null[name] :
+                 value === void(0) ? Void[name] :
+                 // Otherwise attempt to use method with a generated private
+                 // `name` that is supposedly in the prototype chain of the
+                 // `target`.
+                 value[name] ||
+                 // Otherwise assume it's one of the built-in type instances,
+                 // in which case implementation is stored in a `builtin` hash.
+                 // Attempt to find a implementation for the given built-in
+                 // via constructor name and method name.
+                 ((type = builtin[(value.constructor || "").name]) &&
+                  type[name]) ||
+                 // Otherwise assume it's a host object. For host objects
+                 // actual method implementations are stored in the `host`
+                 // array and only index for the implementation is stored
+                 // in the host object's prototype chain. This avoids memory
+                 // leaks that otherwise could happen when saving JS objects
+                 // on host object.
+                 host[value["!" + name]] ||
+                 // Otherwise attempt to lookup implementation for builtins by
+                 // a type of the value. This basically makes sure that all
+                 // non primitive values will delegate to an `Object`.
+                 ((type = builtin[types[typeof(value)]]) && type[name])
+
+
+    // If method implementation for the type is still not found then
+    // just fallback for default implementation.
+    method = method || Default[name]
+
+    // If implementation is still not found (which also means there is no
+    // default) just throw an error with a descriptive message.
+    if (!method) throw TypeError("Type does not implements method: " + name)
+
+    // If implementation was found then just delegate.
+    return method.apply(method, arguments)
+  }
+
+  // Make `toString` of the dispatch return a private name, this enables
+  // method definition without sugar:
+  //
+  //    var method = Method()
+  //    object[method] = function() { /***/ }
+  dispatch.toString = function toString() { return name }
+
+  // Copy utility methods for convenient API.
+  dispatch.implement = implementMethod
+  dispatch.define = defineMethod
+
+  return dispatch
+}
+
+// Create method shortcuts form functions.
+var defineMethod = function defineMethod(Type, lambda) {
+  return define(this, Type, lambda)
+}
+var implementMethod = function implementMethod(object, lambda) {
+  return implement(this, object, lambda)
+}
+
+// Define `implement` and `define` polymorphic methods to allow definitions
+// and implementations through them.
+var implement = Method("implement@method")
+var define = Method("define@method")
+
+
+function _implement(method, object, lambda) {
+  /**
+  Implements `Method` for the given `object` with a provided `implementation`.
+  Calling `Method` with `object` as a first argument will dispatch on provided
+  implementation.
+  **/
+  return defineProperty(object, method.toString(), {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: lambda
+  })
+}
+
+function _define(method, Type, lambda) {
+  /**
+  Defines `Method` for the given `Type` with a provided `implementation`.
+  Calling `Method` with a first argument of this `Type` will dispatch on
+  provided `implementation`. If `Type` is a `Method` default implementation
+  is defined. If `Type` is a `null` or `undefined` `Method` is implemented
+  for that value type.
+  **/
+
+  // Attempt to guess a type via `Object.prototype.toString.call` hack.
+  var type = Type && typefy.call(Type.prototype)
+
+  // If only two arguments are passed then `Type` is actually an implementation
+  // for a default type.
+  if (!lambda) Default[method] = Type
+  // If `Type` is `null` or `void` store implementation accordingly.
+  else if (Type === null) Null[method] = lambda
+  else if (Type === void(0)) Void[method] = lambda
+  // If `type` hack indicates built-in type and type has a name us it to
+  // store a implementation into associated hash. If hash for this type does
+  // not exists yet create one.
+  else if (type !== "[object Object]" && Type.name) {
+    var Bulitin = builtin[Type.name] || (builtin[Type.name] = new ObjectType())
+    Bulitin[method] = lambda
+  }
+  // If `type` hack indicates an object, that may be either object or any
+  // JS defined "Class". If name of the constructor is `Object`, assume it's
+  // built-in `Object` and store implementation accordingly.
+  else if (Type.name === "Object")
+    builtin.Object[method] = lambda
+  // Host objects are pain!!! Every browser does some crazy stuff for them
+  // So far all browser seem to not implement `call` method for host object
+  // constructors. If that is a case here, assume it's a host object and
+  // store implementation in a `host` array and store `index` in the array
+  // in a `Type.prototype` itself. This avoids memory leaks that could be
+  // caused by storing JS objects on a host objects.
+  else if (Type.call === void(0)) {
+    var index = host.indexOf(lambda)
+    if (index < 0) index = host.push(lambda) - 1
+    // Prefix private name with `!` so it can be dispatched from the method
+    // without type checks.
+    implement("!" + method, Type.prototype, index)
+  }
+  // If Got that far `Type` is user defined JS `Class`. Define private name
+  // as hidden property on it's prototype.
+  else
+    implement(method, Type.prototype, lambda)
+}
+
+// And provided implementations for a polymorphic equivalents.
+_define(define, _define)
+_define(implement, _implement)
+
+// Define exports on `Method` as it's only thing being exported.
+Method.implement = implement
+Method.define = define
+Method.Method = Method
+Method.method = Method
+Method.builtin = builtin
+Method.host = host
+
+module.exports = Method

data/vendor/interactivate/node_modules/interactivate/node_modules/method/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "method",
+  "id": "method",
+  "version": "2.0.0",
+  "description": "Functional polymorphic method dispatch",
+  "keywords": [
+    "method",
+    "dispatch",
+    "protocol",
+    "polymorphism",
+    "type dispatch"
+  ],
+  "author": {
+    "name": "Irakli Gozalishvili",
+    "email": "rfobic@gmail.com",
+    "url": "http://jeditoolkit.com"
+  },
+  "homepage": "https://github.com/Gozala/method",
+  "main": "./core.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/method.git",
+    "web": "https://github.com/Gozala/method"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/method/issues/"
+  },
+  "devDependencies": {
+    "test": "~0.x.0",
+    "phantomify": "~0.x.0",
+    "retape": "~0.x.0",
+    "tape": "~0.1.5"
+  },
+  "scripts": {
+    "test": "npm run test-node && npm run test-browser && npm run test-tap",
+    "test-browser": "node ./node_modules/phantomify/bin/cmd.js ./test/phantom-index.js",
+    "test-node": "node ./test/common-index.js",
+    "test-tap": "node ./test/tap-index.js"
+  },
+  "testling": {
+    "files": "test/testling-index.js",
+    "browsers": {
+      "iexplore": [
+        6,
+        7,
+        8,
+        9,
+        10
+      ],
+      "chrome": [
+        16,
+        20,
+        25,
+        "canary"
+      ],
+      "firefox": [
+        10,
+        15,
+        16,
+        17,
+        18,
+        19,
+        "nightly"
+      ],
+      "safari": [
+        5,
+        6
+      ],
+      "opera": [
+        10,
+        11,
+        12,
+        "next"
+      ],
+      "iphone": [
+        6
+      ],
+      "ipad": [
+        6
+      ]
+    }
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/method/License.md"
+    }
+  ],
+  "readme": "# method\n\n[![Build Status](https://secure.travis-ci.org/Gozala/method.png)](http://travis-ci.org/Gozala/method)\n\n\n[![Browser support](http://ci.testling.com/Gozala/method.png)](http://ci.testling.com/Gozala/method)\n\n\nLibrary provides an API for defining polymorphic methods that dispatch on the\nfirst argument type. This provides a powerful way for decouple abstraction\ninterface definition from an actual implementations per type / instance,\nwithout risks of interference with other libraries.\n\n### Motivation\n\n  - Provide a high-performance, dynamic polymorphism construct as an\n    alternative to existing object methods that does not provides any\n    mechanics for guarding against name conflicts.\n  - Allow independent extension of types, and implementations of methods\n    on types, by different parties.\n\n## Install\n\n    npm install method\n\n## Use\n\n```js\nvar method = require(\"method\")\n\n// Define `isWatchable` method that can be implemented for any type.\n// Use some UNIQUE identifer for the method to avoid any naming collisions.\n// If not provided one will be generate but with npm it's easy to end up\n// with copies of same library and there for copies of the same function\n// leading to surprises. So just really pick a name that is unique!\nvar isWatchable = method(\"isWatchable@watchables\")\n\n// If you call it on any object it will\n// throw as nothing implements that method yet.\n//isWatchable({}) // => Exception: method is not implemented\n\n// If you define private method on `Object.prototype`\n// all objects will inherit it.\nObject.prototype[isWatchable] = function() {\n  return false;\n}\n\nisWatchable({}) // => false\n\n\n// Although `isWatchable` property above will be enumerable and there for\n// may damage some assumbtions made by other libraries. There for it\"s\n// recomended to use built-in helpers methods that will define extension\n// without breaking assumbtions made by other libraries:\n\nisWatchable.define(Object, function() { return false })\n\n\n// There are primitive types in JS that won\"t inherit methods from Object:\nisWatchable(null) // => Exception: method is not implemented\n\n// One could either implement methods for such types:\nisWatchable.define(null, function() { return false })\nisWatchable.define(undefined, function() { return false })\n\n// Or simply define default implementation:\nisWatchable.define(function() { return false })\n\n// Alternatively default implementation may be provided at creation:\nisWatchable = method(function() { return false })\n\n// Method dispatches on an first argument type. That allows us to create\n// new types with an alternative implementations:\nfunction Watchable() {}\nisWatchable.define(Watchable, function() { return true })\n\n// This will make all `Watchable` instances watchable!\nisWatchable(new Watchable()) // => true\n\n// Arbitrary objects can also be extended to implement given method. For example\n// any object can simply made watchable:\nfunction watchable(object) {\n  return isWatchable.implement(objct, function() { return true })\n}\n\nisWatchable(watchable({})) // => true\n\n// Full protocols can be defined with such methods:\nvar observers = \"observers@\" + module.filename\nvar watchers = method(\"watchers@watchables\")\nvar watch = method(\"watch@watchables\")\nvar unwatch = method(\"unwatch@watchables\")\n\nwatchers.define(Watchable, function(target) {\n  return target[observers] || (target[observers] = [])\n})\n\nwatch.define(Watchable, function(target, watcher) {\n  var observers = watchers(target)\n  if (observers.indexOf(watcher) < 0) observers.push(watcher)\n  return target\n})\nunwatch.define(Watchable, function(target, watcher) {\n  var observers = watchers(target)\n  var index = observers.indexOf(watcher)\n  if (observers.indexOf(watcher) >= 0) observers.unshift(watcher)\n  return target\n})\n\n// Define type Port that inherits form Watchable\n\nfunction Port() {}\nPort.prototype = Object.create(Watchable.prototype)\n\nvar emit = method(\"emit\")\nemit.define(Port, function(port, message) {\n  watchers(port).slice().forEach(function(watcher) {\n    watcher(message)\n  })\n})\n\nvar p = new Port()\nwatch(p, console.log)\nemit(p, \"hello world\") // => info: \"hello world\"\n```\n",
+  "readmeFilename": "Readme.md",
+  "_id": "method@2.0.0",
+  "_from": "method@2"
+}