Shadrach

Spatial Navigation Extension (Vivaldi)

Mar 14th, 2019
196
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /**
  2.  *
  3.  * spatial-navigation
  4.  *
  5.  * @name spatial-navigation
  6.  * @version 0.4.7
  7.  * ---
  8.  * @author falsandtru https://github.com/falsandtru/spatial-navigation
  9.  * @copyright 2015, falsandtru
  10.  * @license MIT
  11.  *
  12.  */
  13.  
  14. !new function(NAME, VERSION) {
  15. "use strict";
  16. (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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.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(require,module,exports){
  17. /**
  18.  *
  19.  * lazychain
  20.  *
  21.  * @name lazychain
  22.  * @version 0.3.0-alpha.23
  23.  * ---
  24.  * @author falsandtru https://github.com/falsandtru/lazychain
  25.  * @copyright 2015, falsandtru
  26.  * @license MIT
  27.  *
  28.  */
  29.  
  30. !new function(NAME, VERSION) {
  31. "use strict";
  32. var LIBRALY;
  33. (function (LIBRALY) {
  34.     var FUNCTION;
  35.     (function (FUNCTION) {
  36.         FUNCTION.args2array = function (args) {
  37.             var len = args.length;
  38.             var array = Array(len);
  39.             for (var i = 0; i < len; i++) {
  40.                 array[i] = args[i];
  41.             }
  42.             return array;
  43.         };
  44.     })(FUNCTION = LIBRALY.FUNCTION || (LIBRALY.FUNCTION = {}));
  45. })(LIBRALY || (LIBRALY = {}));
  46. var LIBRALY;
  47. (function (LIBRALY) {
  48.     var FUNCTION;
  49.     (function (FUNCTION) {
  50.         function apply(f, c, ps) {
  51.             var functional = c === void 0;
  52.             switch (ps.length) {
  53.                 case 0:
  54.                     return functional
  55.                         ? f()
  56.                         : f.call(c);
  57.                 case 1:
  58.                     return functional
  59.                         ? f(ps[0])
  60.                         : f.call(c, ps[0]);
  61.                 case 2:
  62.                     return functional
  63.                         ? f(ps[0], ps[1])
  64.                         : f.call(c, ps[0], ps[1]);
  65.                 case 3:
  66.                     return functional
  67.                         ? f(ps[0], ps[1], ps[2])
  68.                         : f.call(c, ps[0], ps[1], ps[2]);
  69.                 case 4:
  70.                     return functional
  71.                         ? f(ps[0], ps[1], ps[2], ps[3])
  72.                         : f.call(c, ps[0], ps[1], ps[2], ps[3]);
  73.                 case 5:
  74.                     return functional
  75.                         ? f(ps[0], ps[1], ps[2], ps[3], ps[4])
  76.                         : f.call(c, ps[0], ps[1], ps[2], ps[3], ps[4]);
  77.                 case 6:
  78.                     return functional
  79.                         ? f(ps[0], ps[1], ps[2], ps[3], ps[4], ps[5])
  80.                         : f.call(c, ps[0], ps[1], ps[2], ps[3], ps[4], ps[5]);
  81.                 case 7:
  82.                     return functional
  83.                         ? f(ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6])
  84.                         : f.call(c, ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6]);
  85.                 case 8:
  86.                     return functional
  87.                         ? f(ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6], ps[7])
  88.                         : f.call(c, ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6], ps[7]);
  89.                 case 9:
  90.                     return functional
  91.                         ? f(ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6], ps[7], ps[8])
  92.                         : f.call(c, ps[0], ps[1], ps[2], ps[3], ps[4], ps[5], ps[6], ps[7], ps[8]);
  93.                 default:
  94.                     return f.apply(c, ps);
  95.             }
  96.         }
  97.         FUNCTION.apply = apply;
  98.         ;
  99.     })(FUNCTION = LIBRALY.FUNCTION || (LIBRALY.FUNCTION = {}));
  100. })(LIBRALY || (LIBRALY = {}));
  101. var LIBRALY;
  102. (function (LIBRALY) {
  103.     var UTILITY;
  104.     (function (UTILITY) {
  105.         function duff(loop, proc) {
  106.             /* tslint:disable:no-duplicate-variable */
  107.             if (loop < 0) {
  108.                 var i = -loop, r = i % 8;
  109.                 while (r--) {
  110.                     proc(--i);
  111.                 }
  112.                 while (i) {
  113.                     proc(--i);
  114.                     proc(--i);
  115.                     proc(--i);
  116.                     proc(--i);
  117.                     proc(--i);
  118.                     proc(--i);
  119.                     proc(--i);
  120.                     proc(--i);
  121.                 }
  122.             }
  123.             else {
  124.                 var l = loop, i = 0, r = l % 8, q = l / 8 ^ 0;
  125.                 while (r--) {
  126.                     proc(i++);
  127.                 }
  128.                 while (q--) {
  129.                     proc(i++);
  130.                     proc(i++);
  131.                     proc(i++);
  132.                     proc(i++);
  133.                     proc(i++);
  134.                     proc(i++);
  135.                     proc(i++);
  136.                     proc(i++);
  137.                 }
  138.             }
  139.         }
  140.         UTILITY.duff = duff;
  141.         function duffbk(loop, proc) {
  142.             /* tslint:disable:no-duplicate-variable */
  143.             if (loop < 0) {
  144.                 var i = -loop, r = i % 8;
  145.                 while (r--) {
  146.                     if (false === proc(--i)) {
  147.                         return;
  148.                     }
  149.                 }
  150.                 while (i) {
  151.                     if (false === proc(--i)) {
  152.                         return;
  153.                     }
  154.                     if (false === proc(--i)) {
  155.                         return;
  156.                     }
  157.                     if (false === proc(--i)) {
  158.                         return;
  159.                     }
  160.                     if (false === proc(--i)) {
  161.                         return;
  162.                     }
  163.                     if (false === proc(--i)) {
  164.                         return;
  165.                     }
  166.                     if (false === proc(--i)) {
  167.                         return;
  168.                     }
  169.                     if (false === proc(--i)) {
  170.                         return;
  171.                     }
  172.                     if (false === proc(--i)) {
  173.                         return;
  174.                     }
  175.                 }
  176.             }
  177.             else {
  178.                 var l = loop, i = 0, r = l % 8, q = l / 8 ^ 0;
  179.                 while (r--) {
  180.                     if (false === proc(i++)) {
  181.                         return;
  182.                     }
  183.                 }
  184.                 while (q--) {
  185.                     if (false === proc(i++)) {
  186.                         return;
  187.                     }
  188.                     if (false === proc(i++)) {
  189.                         return;
  190.                     }
  191.                     if (false === proc(i++)) {
  192.                         return;
  193.                     }
  194.                     if (false === proc(i++)) {
  195.                         return;
  196.                     }
  197.                     if (false === proc(i++)) {
  198.                         return;
  199.                     }
  200.                     if (false === proc(i++)) {
  201.                         return;
  202.                     }
  203.                     if (false === proc(i++)) {
  204.                         return;
  205.                     }
  206.                     if (false === proc(i++)) {
  207.                         return;
  208.                     }
  209.                 }
  210.             }
  211.         }
  212.         UTILITY.duffbk = duffbk;
  213.     })(UTILITY = LIBRALY.UTILITY || (LIBRALY.UTILITY = {}));
  214. })(LIBRALY || (LIBRALY = {}));
  215. /// <reference path="duff.ts"/>
  216. var LIBRALY;
  217. (function (LIBRALY) {
  218.     var UTILITY;
  219.     (function (UTILITY) {
  220.         var duff = UTILITY.duff;
  221.         function repeat(arg, size) {
  222.             /* tslint:disable:no-duplicate-variable */
  223.             switch (true) {
  224.                 case typeof arg === 'string':
  225.                     var text = arg;
  226.                     return Array(size + 1).join(text);
  227.                 case arg instanceof Array:
  228.                     var len = arg.length;
  229.                     if (size < 300) {
  230.                         var arr = Array(size);
  231.                         duff(-size, function (i) { return arr[i] = arg[i % len]; });
  232.                     }
  233.                     else {
  234.                         var arr = arg.slice();
  235.                         while (arr.length * 2 <= size) {
  236.                             arr = arr.concat(arr);
  237.                         }
  238.                         arr = arr.concat(arr.slice(0, size - arr.length));
  239.                     }
  240.                     return arr;
  241.             }
  242.         }
  243.         UTILITY.repeat = repeat;
  244.     })(UTILITY = LIBRALY.UTILITY || (LIBRALY.UTILITY = {}));
  245. })(LIBRALY || (LIBRALY = {}));
  246. /// <reference path="repeat.ts"/>
  247. var LIBRALY;
  248. (function (LIBRALY) {
  249.     var TYPE;
  250.     (function (TYPE) {
  251.         var REPEAT = LIBRALY.UTILITY.repeat;
  252.         TYPE.id = (function () {
  253.             var id = {};
  254.             return {
  255.                 rest: function () { return id; }
  256.             };
  257.         })();
  258.         TYPE.type = (function () {
  259.             var TYPES = {}, toString = TYPES.toString;
  260.             'Boolean Number String Function Array Date RegExp Object Error'.split(/\s+/)
  261.                 .forEach(function (v, i) { return TYPES['[object ' + v + ']'] = v.toLowerCase(); });
  262.             return type;
  263.             function type(target, pattern, cut, depth) {
  264.                 switch (typeof pattern) {
  265.                     case 'undefined':
  266.                         if (target === null) {
  267.                             return null + '';
  268.                         }
  269.                         var tgttypeof = typeof target;
  270.                         switch (tgttypeof) {
  271.                             case 'object':
  272.                                 return target instanceof Array
  273.                                     ? 'array'
  274.                                     : TYPES[toString.call(target)] || 'object';
  275.                             case 'function':
  276.                                 switch (target) {
  277.                                     case Boolean:
  278.                                     case Number:
  279.                                     case String:
  280.                                     case Function:
  281.                                     case Array:
  282.                                     case Date:
  283.                                     case RegExp:
  284.                                     case Object:
  285.                                     case Error:
  286.                                         return 'function';
  287.                                 }
  288.                                 return TYPES[toString.call(target)] || 'object';
  289.                         }
  290.                         return tgttypeof;
  291.                     case 'string':
  292.                         var tgttype = type(target);
  293.                         return pattern === tgttype || pattern.length > tgttype.length + 5 && pattern.indexOf(tgttype) > -1;
  294.                     default:
  295.                         return compare(target, pattern, cut, depth);
  296.                 }
  297.             }
  298.         })();
  299.         var compare = (function () {
  300.             var MAX_DEPTH = 9;
  301.             var rfname = /function\s*([^(]*)/;
  302.             return pattern;
  303.             function pattern(args, patterns, cut, depth, rest, acc) {
  304.                 if (cut === void 0) { cut = 0; }
  305.                 if (depth === void 0) { depth = MAX_DEPTH; }
  306.                 if (rest === void 0) { rest = false; }
  307.                 if (acc === void 0) { acc = []; }
  308.                 if (0 > depth) {
  309.                     return false;
  310.                 }
  311.                 if (patterns.length > 1 && patterns[patterns.length - 1] === TYPE.id.rest()) {
  312.                     return compare(args, clone(patterns, 0, -1), cut, depth, true, acc);
  313.                 }
  314.                 if (acc.length === 0) {
  315.                     // 末尾のundefinedを削除
  316.                     args = compact(args, patterns);
  317.                 }
  318.                 if (rest && patterns.length < args.length) {
  319.                     patterns = expand(args, patterns);
  320.                 }
  321.                 if (args.length !== patterns.length) {
  322.                     return false;
  323.                 }
  324.                 for (var i = args.length; i--;) {
  325.                     var arg = args[i], pat = patterns[i];
  326.                     switch (TYPE.type(pat)) {
  327.                         case 'undefined':
  328.                             // すべてに一致
  329.                             continue;
  330.                         case 'null':
  331.                             // nullまたはundefined
  332.                             if (null === arg || void 0 === arg) {
  333.                                 continue;
  334.                             }
  335.                             return false;
  336.                         case 'boolean':
  337.                         case 'string':
  338.                             // 値を比較
  339.                             if (pat === arg) {
  340.                                 continue;
  341.                             }
  342.                             return false;
  343.                         case 'number':
  344.                             // 値を比較
  345.                             if (pat === arg || TYPE.type(arg, 'number') && isNaN(arg) && isNaN(pat)) {
  346.                                 continue;
  347.                             }
  348.                             return false;
  349.                         case 'date':
  350.                             // 値を比較
  351.                             if (TYPE.type(arg, 'date') && arg.getUTCMilliseconds() === pat.getUTCMilliseconds()) {
  352.                                 continue;
  353.                             }
  354.                             return false;
  355.                         case 'array':
  356.                             // パターン値が1要素のときは1要素以上の配列としてパターンマッチ
  357.                             // それ以外の場合はタプルとしてパターンマッチ
  358.                             if (acc.length && ~acc.indexOf(arg)) {
  359.                                 if (arg === pat) {
  360.                                     continue;
  361.                                 }
  362.                                 else {
  363.                                     return false;
  364.                                 }
  365.                             }
  366.                             else if (arg === pat
  367.                                 || TYPE.type(arg, 'array') && compareArray(arg, pat, cut, depth - 1, acc.length === 0 ? [arg] : acc.concat([arg]))) {
  368.                                 continue;
  369.                             }
  370.                             return false;
  371.                         case 'object':
  372.                             // 列挙可能な値を比較
  373.                             if (acc.length && ~acc.indexOf(arg)) {
  374.                                 if (arg === pat) {
  375.                                     continue;
  376.                                 }
  377.                                 else {
  378.                                     return false;
  379.                                 }
  380.                             }
  381.                             else if (arg === pat
  382.                                 || TYPE.type(arg, 'object') && compareObject(arg, pat, cut, depth - 1, acc.length === 0 ? [arg] : acc.concat([arg]))) {
  383.                                 continue;
  384.                             }
  385.                             return false;
  386.                         case 'function':
  387.                             // 型または値を比較
  388.                             if (arg === void 0 || arg === null || TYPE.type(arg, 'number') && isNaN(arg)) {
  389.                                 return false;
  390.                             }
  391.                             switch (pat) {
  392.                                 case Boolean:
  393.                                     if (TYPE.type(arg, 'boolean')) {
  394.                                         continue;
  395.                                     }
  396.                                     return false;
  397.                                 case Number:
  398.                                     if (TYPE.type(arg, 'number')) {
  399.                                         continue;
  400.                                     }
  401.                                     return false;
  402.                                 case String:
  403.                                     if (TYPE.type(arg, 'string')) {
  404.                                         continue;
  405.                                     }
  406.                                     return false;
  407.                                 case Date:
  408.                                     if (TYPE.type(arg, 'date')) {
  409.                                         continue;
  410.                                     }
  411.                                     return false;
  412.                                 case Array:
  413.                                     if (TYPE.type(arg, 'array')) {
  414.                                         continue;
  415.                                     }
  416.                                     return false;
  417.                                 case Object:
  418.                                     if (TYPE.type(arg, 'object')) {
  419.                                         continue;
  420.                                     }
  421.                                     return false;
  422.                                 case RegExp:
  423.                                     if (TYPE.type(arg, 'regexp')) {
  424.                                         continue;
  425.                                     }
  426.                                     return false;
  427.                                 case Function:
  428.                                     if (TYPE.type(arg, 'function')) {
  429.                                         continue;
  430.                                     }
  431.                                     return false;
  432.                                 default:
  433.                                     if (arg instanceof pat) {
  434.                                         continue;
  435.                                     }
  436.                                     return false;
  437.                             }
  438.                         case 'error':
  439.                             // 型とメッセージを比較
  440.                             if (void 0 !== arg && null !== arg && pat.constructor === arg.constructor && pat.name === arg.name && pat.message === arg.message) {
  441.                                 continue;
  442.                             }
  443.                             return false;
  444.                         case 'regexp':
  445.                             // 値を比較
  446.                             if (void 0 !== arg && null !== arg && pat.constructor === arg.constructor && pat.source === arg.source &&
  447.                                 pat.global === arg.global && pat.ignoreCase === arg.ignoreCase && pat.multiline === arg.multiline) {
  448.                                 continue;
  449.                             }
  450.                             return false;
  451.                         default:
  452.                             throw new Error('Undefined pattern.');
  453.                     }
  454.                 }
  455.                 return true;
  456.             }
  457.             function clone(arr, begin, end) {
  458.                 if (begin === void 0) { begin = 0; }
  459.                 if (end === void 0) { end = Infinity; }
  460.                 if (end < 0) {
  461.                     return clone(arr, begin, arr.length + end);
  462.                 }
  463.                 if (begin < 0) {
  464.                     return clone(arr, arr.length + begin, end);
  465.                 }
  466.                 var args_ = [];
  467.                 for (var _i = end > arr.length ? arr.length - 1 : end - 1; _i >= begin; _i--) {
  468.                     args_[_i - begin] = arr[_i];
  469.                 }
  470.                 return args_;
  471.             }
  472.             function compact(args, patterns) {
  473.                 if (args.length <= patterns.length) {
  474.                     return args;
  475.                 }
  476.                 for (var i = args.length; i-- && i + 1 > patterns.length && void 0 === args[i];) {
  477.                     continue;
  478.                 }
  479.                 return i + 1 === args.length ? args : clone(args, 0, i + 1);
  480.             }
  481.             function expand(args, patterns) {
  482.                 if (args.length <= patterns.length) {
  483.                     return patterns;
  484.                 }
  485.                 return patterns.concat(REPEAT(clone(patterns, -1), args.length - patterns.length));
  486.             }
  487.             function isConstructor(F) {
  488.                 /* tslint:disable:no-string-literal */
  489.                 var fname = typeof F['name'] === 'string' ? F['name'] : F.toString().match(rfname).pop() + '  ';
  490.                 var fst = fname.charAt(0), snd = fname.charAt(1);
  491.                 return 'A' <= fst && fst <= 'Z' && !('A' <= snd && snd <= 'Z');
  492.             }
  493.             function compareArray(arg, pattern, cut, depth, acc) {
  494.                 if (arg.length < pattern.length - 1) {
  495.                     return false;
  496.                 }
  497.                 if (pattern.length === 1 && cut > 0 && arg.length > cut * 2) {
  498.                     arg = clone(arg, 0, cut).concat(clone(arg, -cut));
  499.                 }
  500.                 return compare(arg, pattern, cut, depth, pattern.length === 1, acc);
  501.             }
  502.             function compareObject(arg, pattern, cut, depth, acc) {
  503.                 /* tslint:disable:forin */
  504.                 var empty = true;
  505.                 for (var i in pattern) {
  506.                     empty = false;
  507.                     if (!(i in arg) || !compare([arg[i]], [pattern[i]], cut, depth, false, acc)) {
  508.                         return false;
  509.                     }
  510.                 }
  511.                 if (!empty) {
  512.                     return true;
  513.                 }
  514.                 else {
  515.                     for (var i in arg) {
  516.                         return false;
  517.                     }
  518.                     return true;
  519.                 }
  520.             }
  521.         })();
  522.     })(TYPE = LIBRALY.TYPE || (LIBRALY.TYPE = {}));
  523. })(LIBRALY || (LIBRALY = {}));
  524. /// <reference path="apply.ts"/>
  525. /// <reference path="type.ts"/>
  526. var LIBRALY;
  527. (function (LIBRALY) {
  528.     var PROMISE;
  529.     (function (PROMISE) {
  530.         var APPLY = LIBRALY.FUNCTION.apply;
  531.         var TYPE = LIBRALY.TYPE.type;
  532.         function isThenable(target) {
  533.             return TYPE(target, 'object') && 'then' in target;
  534.         }
  535.         PROMISE.isThenable = isThenable;
  536.         PROMISE.resolve = typeof Promise === 'function' ? Promise.resolve.bind(Promise)
  537.             : function (value) { return PROMISE.deferred().resolve(value); };
  538.         // ネイティブメソッドと異なり同期処理されなくともエラーとならず非同期に伝達される
  539.         PROMISE.reject = function (value) { return PROMISE.deferred().reject(value); };
  540.         // notifyサポートのためネイティブメソッドは使用しない
  541.         PROMISE.when = function (promises) {
  542.             if (promises.length === 0) {
  543.                 return PROMISE.deferred().resolve([]);
  544.             }
  545.             var dfd = PROMISE.deferred(), count = promises.length, waits = Array(count);
  546.             for (var i = 0, len = promises.length; i < len; i++) {
  547.                 register(i, promises[i]);
  548.             }
  549.             return dfd.promise();
  550.             function register(index, arg) {
  551.                 if (isThenable(arg)) {
  552.                     arg
  553.                         .then(function () {
  554.                         var args = [];
  555.                         for (var _i = 0; _i < arguments.length; _i++) {
  556.                             args[_i - 0] = arguments[_i];
  557.                         }
  558.                         return done(index, args);
  559.                     }, dfd.reject, dfd.notify);
  560.                 }
  561.                 else {
  562.                     done(index, [arg]);
  563.                 }
  564.             }
  565.             function done(index, args) {
  566.                 if (count === 0 || dfd.state() !== 'pending') {
  567.                     return;
  568.                 }
  569.                 count -= 1;
  570.                 waits[index] = args;
  571.                 if (count === 0) {
  572.                     APPLY(dfd.resolve, void 0, waits);
  573.                 }
  574.             }
  575.         };
  576.         PROMISE.deferred = (function () {
  577.             return function (callback) {
  578.                 var statePending = 'pending', stateResolved = 'resolved', stateRejected = 'rejected', state = statePending, memoryNotify, memoryResolve, memoryReject, memoryAlways, listenerProgressCallbacks = [], listenerDoneCallbacks = [], listenerFailCallbacks = [], listenerAlwaysCallbacks = [], dfd = {
  579.                     state: function () {
  580.                         return state;
  581.                     },
  582.                     progress: function () {
  583.                         var args = [];
  584.                         for (var _i = 0; _i < arguments.length; _i++) {
  585.                             args[_i - 0] = arguments[_i];
  586.                         }
  587.                         if (state === statePending) {
  588.                             registerWithCall(memoryNotify, flatten(args), listenerProgressCallbacks);
  589.                         }
  590.                         return this;
  591.                     },
  592.                     done: function () {
  593.                         var args = [];
  594.                         for (var _i = 0; _i < arguments.length; _i++) {
  595.                             args[_i - 0] = arguments[_i];
  596.                         }
  597.                         if (state === statePending || state === stateResolved) {
  598.                             registerWithCall(memoryResolve, flatten(args), listenerDoneCallbacks);
  599.                         }
  600.                         return this;
  601.                     },
  602.                     fail: function () {
  603.                         var args = [];
  604.                         for (var _i = 0; _i < arguments.length; _i++) {
  605.                             args[_i - 0] = arguments[_i];
  606.                         }
  607.                         if (state === statePending || state === stateRejected) {
  608.                             registerWithCall(memoryReject, flatten(args), listenerFailCallbacks);
  609.                         }
  610.                         return this;
  611.                     },
  612.                     always: function () {
  613.                         var args = [];
  614.                         for (var _i = 0; _i < arguments.length; _i++) {
  615.                             args[_i - 0] = arguments[_i];
  616.                         }
  617.                         registerWithCall(memoryAlways, flatten(args), listenerAlwaysCallbacks);
  618.                         return this;
  619.                     },
  620.                     then: function (doneCallbacks, failCallbacks, progressCallbacks) {
  621.                         var nextDfd = PROMISE.deferred();
  622.                         // progress
  623.                         if (state === statePending) {
  624.                             cascade(memoryNotify, progressCallbacks, listenerProgressCallbacks, nextDfd.notify);
  625.                         }
  626.                         // done
  627.                         if (state === statePending || state === stateResolved) {
  628.                             cascade(memoryResolve, doneCallbacks, listenerDoneCallbacks, nextDfd.resolve);
  629.                         }
  630.                         // fail
  631.                         if (state === statePending || state === stateRejected) {
  632.                             cascade(memoryReject, failCallbacks, listenerFailCallbacks, nextDfd.reject);
  633.                         }
  634.                         return nextDfd.promise();
  635.                         function cascade(memory, callbacks, listenerCallbacks, callback) {
  636.                             callbacks &&
  637.                                 registerWithCall(memory, [function () {
  638.                                         var args = [];
  639.                                         for (var _i = 0; _i < arguments.length; _i++) {
  640.                                             args[_i - 0] = arguments[_i];
  641.                                         }
  642.                                         var result;
  643.                                         if (typeof callbacks === 'function') {
  644.                                             result = APPLY(callbacks, void 0, args);
  645.                                             if (TYPE(result, 'object') && TYPE(result.then, 'function')) {
  646.                                                 result
  647.                                                     .then(nextDfd.notify, nextDfd.notify, nextDfd.notify);
  648.                                             }
  649.                                             else {
  650.                                                 callback(result);
  651.                                             }
  652.                                         }
  653.                                         else {
  654.                                             callbacks
  655.                                                 .forEach(function (f) { return APPLY(f, void 0, args); });
  656.                                             callback();
  657.                                         }
  658.                                     }], listenerCallbacks);
  659.                         }
  660.                     },
  661.                     promise: function () {
  662.                         return {
  663.                             state: dfd.state,
  664.                             progress: dfd.progress,
  665.                             done: dfd.done,
  666.                             fail: dfd.fail,
  667.                             always: dfd.always,
  668.                             then: dfd.then
  669.                         };
  670.                     },
  671.                     notify: function () {
  672.                         var args = [];
  673.                         for (var _i = 0; _i < arguments.length; _i++) {
  674.                             args[_i - 0] = arguments[_i];
  675.                         }
  676.                         if (state === statePending) {
  677.                             memoryNotify = args;
  678.                             call(memoryNotify, listenerProgressCallbacks);
  679.                         }
  680.                         return this;
  681.                     },
  682.                     resolve: function () {
  683.                         var args = [];
  684.                         for (var _i = 0; _i < arguments.length; _i++) {
  685.                             args[_i - 0] = arguments[_i];
  686.                         }
  687.                         if (state === statePending) {
  688.                             memoryResolve = args;
  689.                             memoryAlways = args;
  690.                             call(args, listenerDoneCallbacks.concat(listenerAlwaysCallbacks));
  691.                             listenerProgressCallbacks = [];
  692.                             listenerDoneCallbacks = [];
  693.                             listenerAlwaysCallbacks = [];
  694.                             state = stateResolved;
  695.                         }
  696.                         return this;
  697.                     },
  698.                     reject: function () {
  699.                         var args = [];
  700.                         for (var _i = 0; _i < arguments.length; _i++) {
  701.                             args[_i - 0] = arguments[_i];
  702.                         }
  703.                         if (state === statePending) {
  704.                             memoryReject = args;
  705.                             memoryAlways = args;
  706.                             call(args, listenerFailCallbacks.concat(listenerAlwaysCallbacks));
  707.                             listenerProgressCallbacks = [];
  708.                             listenerFailCallbacks = [];
  709.                             listenerAlwaysCallbacks = [];
  710.                             state = stateRejected;
  711.                         }
  712.                         return this;
  713.                     }
  714.                 };
  715.                 if (callback) {
  716.                     callback(dfd.resolve, dfd.reject, dfd.notify);
  717.                 }
  718.                 return dfd;
  719.                 function registerWithCall(memory, callbacks, listenerCallbacks) {
  720.                     var result;
  721.                     for (var i = 0, len = callbacks.length; i < len; i++) {
  722.                         var callback = callbacks[i];
  723.                         listenerCallbacks.push(callback);
  724.                         result = call(memory, [callback]);
  725.                     }
  726.                     if (state !== statePending) {
  727.                         listenerCallbacks.splice(0, listenerCallbacks.length);
  728.                     }
  729.                     return result;
  730.                 }
  731.                 function call(memory, callbacks) {
  732.                     var result;
  733.                     for (var i = 0, len = memory ? callbacks.length : 0; i < len; i++) {
  734.                         result = APPLY(callbacks[i], void 0, memory);
  735.                     }
  736.                     return result;
  737.                 }
  738.                 function flatten(arr) {
  739.                     var acc = [];
  740.                     if (arr instanceof Array) {
  741.                         for (var i = arr.length; i--;) {
  742.                             var elem = arr[i];
  743.                             if (elem instanceof Array) {
  744.                                 acc = acc.concat(flatten(elem));
  745.                             }
  746.                             else {
  747.                                 acc.push(elem);
  748.                             }
  749.                         }
  750.                     }
  751.                     return acc;
  752.                 }
  753.             };
  754.         })();
  755.     })(PROMISE = LIBRALY.PROMISE || (LIBRALY.PROMISE = {}));
  756. })(LIBRALY || (LIBRALY = {}));
  757. /// <reference path="apply.ts"/>
  758. var LIBRALY;
  759. (function (LIBRALY) {
  760.     var FUNCTION;
  761.     (function (FUNCTION) {
  762.         FUNCTION.memoize = function (func) {
  763.             var noarg;
  764.             return function () {
  765.                 if (noarg === void 0) {
  766.                     noarg = func();
  767.                 }
  768.                 return noarg;
  769.             };
  770.         };
  771.     })(FUNCTION = LIBRALY.FUNCTION || (LIBRALY.FUNCTION = {}));
  772. })(LIBRALY || (LIBRALY = {}));
  773. var LIBRALY;
  774. (function (LIBRALY) {
  775.     var UUID;
  776.     (function (UUID) {
  777.         UUID.v4 = function () {
  778.             // version 4
  779.             return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
  780.                 var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
  781.                 return v.toString(16).toUpperCase();
  782.             });
  783.         };
  784.     })(UUID = LIBRALY.UUID || (LIBRALY.UUID = {}));
  785. })(LIBRALY || (LIBRALY = {}));
  786. /// <reference path=".d/lazychain.d.ts"/>
  787. /// <reference path="library/args2array.ts"/>
  788. /// <reference path="library/apply.ts"/>
  789. /// <reference path="library/type.ts"/>
  790. /// <reference path="library/promise.ts"/>
  791. /// <reference path="library/memoize.ts"/>
  792. /// <reference path="library/uuid.ts"/>
  793. var undefined;
  794. var MODULE;
  795. (function (MODULE) {
  796.     MODULE.APPLY = LIBRALY.FUNCTION.apply;
  797.     MODULE.TYPE = LIBRALY.TYPE.type;
  798.     MODULE.PROMISE = LIBRALY.PROMISE;
  799.     MODULE.MEMOIZE = LIBRALY.FUNCTION.memoize;
  800.     MODULE.UUID = LIBRALY.UUID.v4;
  801.     var ID;
  802.     (function (ID) {
  803.         ID.rest = LIBRALY.TYPE.id.rest;
  804.     })(ID = MODULE.ID || (MODULE.ID = {}));
  805.     ;
  806. })(MODULE || (MODULE = {}));
  807. /// <reference path="../define.ts"/>
  808. /// <reference path="main.ts"/>
  809. /// <reference path="../model/main.ts"/>
  810. /* CONTROLLER */
  811. var MODULE;
  812. (function (MODULE) {
  813.     var CONTROLLER;
  814.     (function (CONTROLLER) {
  815.         var Stream = (function () {
  816.             function Stream(message, extensions, parent) {
  817.                 var _this = this;
  818.                 if (extensions === void 0) { extensions = []; }
  819.                 if (parent === void 0) { parent = null; }
  820.                 this.NAME = NAME;
  821.                 this.VERSION = VERSION;
  822.                 this.__LazyChain__ = {
  823.                     extensions: null,
  824.                     parent: null,
  825.                     child: null,
  826.                     deferred: null,
  827.                     command: null,
  828.                     monad: null,
  829.                     transfer: function (method, args) {
  830.                         _this.__LazyChain__.command = [method, args];
  831.                         return _this.__LazyChain__.child = MODULE.APPLY(CONTROLLER[method], void 0, [_this].concat(args));
  832.                     }
  833.                 };
  834.                 this.lazy = (function () {
  835.                     var self = _this;
  836.                     return function () {
  837.                         var args = [];
  838.                         for (var _i = 0; _i < arguments.length; _i++) {
  839.                             args[_i - 0] = arguments[_i];
  840.                         }
  841.                         return self.__LazyChain__.transfer('lazy', args);
  842.                     };
  843.                 })();
  844.                 this.stream = (function () {
  845.                     var self = _this;
  846.                     return function () {
  847.                         var args = [];
  848.                         for (var _i = 0; _i < arguments.length; _i++) {
  849.                             args[_i - 0] = arguments[_i];
  850.                         }
  851.                         return self.__LazyChain__.transfer('stream', args);
  852.                     };
  853.                 })();
  854.                 this.pattern = (function () {
  855.                     var self = _this;
  856.                     return function () {
  857.                         var args = [];
  858.                         for (var _i = 0; _i < arguments.length; _i++) {
  859.                             args[_i - 0] = arguments[_i];
  860.                         }
  861.                         return self.__LazyChain__.transfer('pattern', args);
  862.                     };
  863.                 })();
  864.                 this.monad = (function () {
  865.                     var self = _this;
  866.                     return function () {
  867.                         var args = [];
  868.                         for (var _i = 0; _i < arguments.length; _i++) {
  869.                             args[_i - 0] = arguments[_i];
  870.                         }
  871.                         return self.__LazyChain__.transfer('monad', args);
  872.                     };
  873.                 })();
  874.                 this.monadic = (function () {
  875.                     var self = _this;
  876.                     return function () {
  877.                         var args = [];
  878.                         for (var _i = 0; _i < arguments.length; _i++) {
  879.                             args[_i - 0] = arguments[_i];
  880.                         }
  881.                         return self.__LazyChain__.transfer('monadic', args);
  882.                     };
  883.                 })();
  884.                 this.array = (function () {
  885.                     var self = _this;
  886.                     return function () {
  887.                         var result;
  888.                         self.some(function (v, i, a) { return result = a; });
  889.                         return result || [];
  890.                     };
  891.                 })();
  892.                 this.prevChain = (function () {
  893.                     var self = _this;
  894.                     return function () {
  895.                         return self.__LazyChain__.parent;
  896.                     };
  897.                 })();
  898.                 this.nextChain = (function () {
  899.                     var self = _this;
  900.                     return function () {
  901.                         return self.__LazyChain__.child;
  902.                     };
  903.                 })();
  904.                 this.firstChain = (function () {
  905.                     var self = _this;
  906.                     return function () {
  907.                         return self.prevChain() && self.prevChain().firstChain() || self;
  908.                     };
  909.                 })();
  910.                 this.lastChain = (function () {
  911.                     var self = _this;
  912.                     return function () {
  913.                         return self.nextChain() && self.nextChain().lastChain() || self;
  914.                     };
  915.                 })();
  916.                 if (parent) {
  917.                     parent.__LazyChain__.child = this;
  918.                     this.__LazyChain__.monad = parent.__LazyChain__.monad;
  919.                     this.__LazyChain__.extensions = parent.__LazyChain__.extensions;
  920.                 }
  921.                 this.__LazyChain__.parent = parent;
  922.                 Stream.map ||
  923.                     CONTROLLER.extendStream_(true, Array.prototype, 0, [
  924.                         'reverse',
  925.                         'slice',
  926.                         'sort',
  927.                         'every',
  928.                         'some',
  929.                         'forEach',
  930.                         'filter',
  931.                         'map',
  932.                         'reduce',
  933.                         'reduceRight'
  934.                     ]);
  935.                 CONTROLLER.mixin(this, this.__LazyChain__.deferred = MODULE.PROMISE.deferred());
  936.                 this.__LazyChain__.extensions = this.__LazyChain__.extensions || extensions;
  937.                 this.__LazyChain__.extensions
  938.                     .forEach(function (v) { return CONTROLLER.emulate(_this, v); });
  939.                 var deferred = this.__LazyChain__.deferred;
  940.                 if (message instanceof Array) {
  941.                     message.length && MODULE.APPLY(deferred.notify, void 0, message);
  942.                 }
  943.                 else if (message instanceof Stream) {
  944.                     message
  945.                         .progress(deferred.notify)
  946.                         .done(deferred.resolve)
  947.                         .fail(deferred.reject);
  948.                 }
  949.                 else if (MODULE.PROMISE.isThenable(message)) {
  950.                     message
  951.                         .then(deferred.notify, deferred.notify, deferred.notify);
  952.                 }
  953.             }
  954.             return Stream;
  955.         })();
  956.         CONTROLLER.Stream = Stream;
  957.     })(CONTROLLER = MODULE.CONTROLLER || (MODULE.CONTROLLER = {}));
  958. })(MODULE || (MODULE = {}));
  959. /// <reference path="../define.ts"/>
  960. /// <reference path="../controller/stream.ts"/>
  961. /* MODEL */
  962. var MODULE;
  963. (function (MODULE) {
  964.     var MODEL;
  965.     (function (MODEL) {
  966.         var Stream = MODULE.CONTROLLER.Stream;
  967.         function connect(inbound, outbound) {
  968.             if ('progress' in inbound && 'always' in inbound && 'notify' in outbound) {
  969.                 inbound
  970.                     .progress(outbound.notify)
  971.                     .always(outbound.resolve);
  972.             }
  973.             else {
  974.                 inbound.then(outbound.resolve, outbound.reject);
  975.             }
  976.             return outbound;
  977.         }
  978.         function cascade(stream, message) {
  979.             if (message === void 0) { message = stream; }
  980.             return new Stream(message, stream.__LazyChain__.extensions, stream);
  981.         }
  982.         MODEL.cascade = cascade;
  983.         function clone(source, target) {
  984.             if (!source.nextChain()) {
  985.                 return target;
  986.             }
  987.             target = target || new Stream(null, source.__LazyChain__.extensions);
  988.             return clone(source.nextChain(), MODULE.APPLY(target[source.__LazyChain__.command[0]], target, source.__LazyChain__.command[1]));
  989.         }
  990.         function environment(env) {
  991.             if (!MODULE.TYPE(env, 'object')) {
  992.                 return env;
  993.             }
  994.             return Object.create(env);
  995.         }
  996.         function immediate(inbound) {
  997.             var reserve = typeof setImmediate === 'function' ? setImmediate : function (f) { return setTimeout(f, 1); };
  998.             return inbound
  999.                 .lazy(function (_, i, a) {
  1000.                 if (i > 0) {
  1001.                     return;
  1002.                 }
  1003.                 var dfd = LazyChain.deferred();
  1004.                 reserve(function (_) { return MODULE.APPLY(dfd.resolve, void 0, a); });
  1005.                 return dfd;
  1006.             });
  1007.         }
  1008.         MODEL.immediate = immediate;
  1009.         function lazy(inbound, callback, env, sequential) {
  1010.             if (typeof env === 'boolean' && sequential === void 0) {
  1011.                 sequential = env;
  1012.                 env = {};
  1013.             }
  1014.             env = environment(env);
  1015.             var outbound = cascade(inbound, null);
  1016.             var gendefer = callback.length === 5;
  1017.             callback && inbound.progress(proxy).always(proxy);
  1018.             return outbound;
  1019.             function proxy() {
  1020.                 var args = [];
  1021.                 for (var _i = 0; _i < arguments.length; _i++) {
  1022.                     args[_i - 0] = arguments[_i];
  1023.                 }
  1024.                 return args.reduce(conv, []);
  1025.             }
  1026.             function conv(r, v, i, a) {
  1027.                 var deferred;
  1028.                 var result = gendefer ? callback(v, i, a, env, deferred = MODULE.PROMISE.deferred()) : callback(v, i, a, env);
  1029.                 deferred = MODULE.PROMISE.isThenable(result) ? result : deferred;
  1030.                 if (!deferred) {
  1031.                     return r;
  1032.                 }
  1033.                 else if (sequential) {
  1034.                     r.push(deferred);
  1035.                     if (i + 1 === a.length) {
  1036.                         MODULE.PROMISE.when(r)
  1037.                             .then(function () {
  1038.                             var args = [];
  1039.                             for (var _i = 0; _i < arguments.length; _i++) {
  1040.                                 args[_i - 0] = arguments[_i];
  1041.                             }
  1042.                             return MODULE.APPLY(outbound.notify, void 0, args.reduce(function (r, v) { return r.concat(v); }, []));
  1043.                         }, outbound.notify, outbound.notify);
  1044.                     }
  1045.                 }
  1046.                 else {
  1047.                     if ('progress' in deferred && 'always' in deferred) {
  1048.                         deferred.progress(outbound.notify).always(outbound.notify);
  1049.                     }
  1050.                     else {
  1051.                         deferred.then(outbound.notify, outbound.notify, outbound.notify);
  1052.                     }
  1053.                 }
  1054.                 return r;
  1055.             }
  1056.         }
  1057.         MODEL.lazy = lazy;
  1058.         function buffer(inbound, clearance) {
  1059.             var scope = cascade(inbound), env = {
  1060.                 prototype: true,
  1061.                 buffer: [],
  1062.                 sentinel: {},
  1063.                 timer: 0,
  1064.                 last: 0
  1065.             }, delay = clearance < 0;
  1066.             clearance = Math.abs(clearance);
  1067.             return scope.lazy(function (v, i, a, e) {
  1068.                 if (!isSentinel(v)) {
  1069.                     e.buffer.push(v);
  1070.                 }
  1071.                 if (e.timer === 0) {
  1072.                     e.timer = setTimeout(fire, clearance);
  1073.                     e.last = Date.now();
  1074.                 }
  1075.                 else if (delay && !isSentinel(v)) {
  1076.                     clearTimeout(e.timer);
  1077.                     e.timer = setTimeout(fire, clearance);
  1078.                 }
  1079.                 else if (isElapsed(e.last) || isSentinel(v)) {
  1080.                     clearTimeout(e.timer);
  1081.                     e.timer = 0;
  1082.                     e.last = Date.now();
  1083.                     var dfd = LazyChain.deferred();
  1084.                     return MODULE.APPLY(dfd.resolve, dfd, e.buffer.splice(0, e.buffer.length));
  1085.                 }
  1086.             }, env);
  1087.             function fire() {
  1088.                 return scope.notify(env.sentinel);
  1089.             }
  1090.             function isElapsed(time) {
  1091.                 return Date.now() - time > clearance;
  1092.             }
  1093.             function isSentinel(value) {
  1094.                 return value === env.sentinel;
  1095.             }
  1096.         }
  1097.         MODEL.buffer = buffer;
  1098.         function stream(inbound, callback, env) {
  1099.             if (env === void 0) { env = {}; }
  1100.             env = environment(env);
  1101.             callback && inbound.progress(proxy).always(proxy);
  1102.             return cascade(inbound);
  1103.             function proxy() {
  1104.                 var args = [];
  1105.                 for (var _i = 0; _i < arguments.length; _i++) {
  1106.                     args[_i - 0] = arguments[_i];
  1107.                 }
  1108.                 return args.forEach(function (v, i, a) { return callback(v, i, a, env); });
  1109.             }
  1110.         }
  1111.         MODEL.stream = stream;
  1112.         function branch(inbound, branches, cascade) {
  1113.             if (cascade === void 0) { cascade = true; }
  1114.             branches
  1115.                 .filter(function (branch) { return MODULE.PROMISE.isThenable(branch); })
  1116.                 .forEach(function (branch) { return connect(inbound, branch); });
  1117.             return cascade ? MODEL.cascade(inbound) : inbound;
  1118.         }
  1119.         MODEL.branch = branch;
  1120.         function merge(outbound, branches, cascade) {
  1121.             if (cascade === void 0) { cascade = true; }
  1122.             branches
  1123.                 .filter(function (branch) { return MODULE.PROMISE.isThenable(branch); })
  1124.                 .forEach(function (branch) { return connect(branch, outbound); });
  1125.             return cascade ? MODEL.cascade(outbound) : outbound;
  1126.         }
  1127.         MODEL.merge = merge;
  1128.         function compose(inbound, streams) {
  1129.             return streams.reduceRight(function (r, v) { return merge(clone(v.firstChain()).firstChain(), [r], false).lastChain(); }, inbound);
  1130.         }
  1131.         MODEL.compose = compose;
  1132.         function split(inbound, splitter, branches, env) {
  1133.             if (env === void 0) { env = {}; }
  1134.             env = environment(env);
  1135.             var outbound = cascade(inbound, null);
  1136.             var scope = cascade(inbound);
  1137.             branches = format(branches, outbound);
  1138.             scope
  1139.                 .reduce(function (r, v, i, a) {
  1140.                 r = i ? r : Object.create(null);
  1141.                 var index = splitter.call(void 0, v, i, a, env);
  1142.                 index = 'boolean' === typeof index ? +!index : index;
  1143.                 if (!(index in r)) {
  1144.                     r[index] = [];
  1145.                 }
  1146.                 r[index].push(v);
  1147.                 return r;
  1148.             }, null)
  1149.                 .forEach(function (params) {
  1150.                 Object.keys(params)
  1151.                     .filter(function (index) { return !!params[index].length; })
  1152.                     .forEach(function (index) {
  1153.                     var action = index in branches ? branches[index] || (function (_) { return void 0; }) : null;
  1154.                     if (typeof action === 'function') {
  1155.                         MODULE.APPLY(action, void 0, params[index]);
  1156.                     }
  1157.                     else {
  1158.                         MODULE.APPLY(action.notify, void 0, params[index]);
  1159.                     }
  1160.                 });
  1161.             });
  1162.             return outbound;
  1163.             function format(branches, outbound) {
  1164.                 switch (true) {
  1165.                     case !branches:
  1166.                         return [outbound, null];
  1167.                     case MODULE.PROMISE.isThenable(branches):
  1168.                         return [outbound, branches];
  1169.                     case branches instanceof Array && 1 === branches.length && !MODULE.PROMISE.isThenable(branches[0]):
  1170.                         branches[0][''] = outbound;
  1171.                         return branches[0];
  1172.                     case branches instanceof Array:
  1173.                         branches.unshift(outbound);
  1174.                         branches[1] = branches[1] || null;
  1175.                         return branches;
  1176.                 }
  1177.             }
  1178.         }
  1179.         MODEL.split = split;
  1180.         function pattern(inbound, patterns) {
  1181.             var outbound = cascade(inbound, null);
  1182.             inbound
  1183.                 .progress(function () {
  1184.                 var params = [];
  1185.                 for (var _i = 0; _i < arguments.length; _i++) {
  1186.                     params[_i - 0] = arguments[_i];
  1187.                 }
  1188.                 return MODULE.APPLY(outbound.notify, void 0, conv(params));
  1189.             })
  1190.                 .done(function () {
  1191.                 var params = [];
  1192.                 for (var _i = 0; _i < arguments.length; _i++) {
  1193.                     params[_i - 0] = arguments[_i];
  1194.                 }
  1195.                 return MODULE.APPLY(outbound.resolve, void 0, conv(params));
  1196.             })
  1197.                 .fail(function () {
  1198.                 var params = [];
  1199.                 for (var _i = 0; _i < arguments.length; _i++) {
  1200.                     params[_i - 0] = arguments[_i];
  1201.                 }
  1202.                 return MODULE.APPLY(outbound.reject, void 0, conv(params));
  1203.             });
  1204.             return outbound;
  1205.             function conv(params) {
  1206.                 return params
  1207.                     .reduce(function (r, param, index) {
  1208.                     var match;
  1209.                     for (var i = 0, len = patterns.length; i < len; i++) {
  1210.                         var exp = patterns[i], etype = exp.length;
  1211.                         match = i > 0 && patterns[i][0] === patterns[i - 1][0] ? match : MODULE.TYPE([param], [exp[0]], 1);
  1212.                         if (!match) {
  1213.                             continue;
  1214.                         }
  1215.                         else if (etype === 1) {
  1216.                             r[r.length] = param;
  1217.                             return r;
  1218.                         }
  1219.                         else if (etype === 2) {
  1220.                             r[r.length] = exp[1](param);
  1221.                             return r;
  1222.                         }
  1223.                         else if (etype === 3 && exp[1](param)) {
  1224.                             r[r.length] = exp[2](param);
  1225.                             return r;
  1226.                         }
  1227.                     }
  1228.                     return r;
  1229.                 }, []);
  1230.             }
  1231.         }
  1232.         MODEL.pattern = pattern;
  1233.         function castStream2Monad(s) {
  1234.             return s;
  1235.         }
  1236.         function castMonad2Stream(m) {
  1237.             return m;
  1238.         }
  1239.         function monad(inbound, monad, convert) {
  1240.             if (convert === void 0) { convert = true; }
  1241.             inbound.__LazyChain__.monad = monad;
  1242.             switch (convert) {
  1243.                 case true:
  1244.                     return castStream2Monad(cascade(inbound.map(function (v) { return monad.return.call(void 0, v); })));
  1245.                 case false:
  1246.                     return castStream2Monad(cascade(inbound));
  1247.                 default:
  1248.                     return castStream2Monad(cascade(inbound.map(function (v) { return MODULE.TYPE([v], [convert], 1) ? monad.return.call(void 0, v) : v; })));
  1249.             }
  1250.         }
  1251.         MODEL.monad = monad;
  1252.         function monadic(inbound, patterns) {
  1253.             var outbound = castStream2Monad(cascade(castMonad2Stream(inbound), null));
  1254.             castMonad2Stream(inbound)
  1255.                 .progress(function () {
  1256.                 var params = [];
  1257.                 for (var _i = 0; _i < arguments.length; _i++) {
  1258.                     params[_i - 0] = arguments[_i];
  1259.                 }
  1260.                 return MODULE.APPLY(outbound.notify, void 0, conv(params));
  1261.             })
  1262.                 .done(function () {
  1263.                 var params = [];
  1264.                 for (var _i = 0; _i < arguments.length; _i++) {
  1265.                     params[_i - 0] = arguments[_i];
  1266.                 }
  1267.                 return MODULE.APPLY(outbound.resolve, void 0, conv(params));
  1268.             })
  1269.                 .fail(function () {
  1270.                 var params = [];
  1271.                 for (var _i = 0; _i < arguments.length; _i++) {
  1272.                     params[_i - 0] = arguments[_i];
  1273.                 }
  1274.                 return MODULE.APPLY(outbound.reject, void 0, conv(params));
  1275.             });
  1276.             return outbound;
  1277.             function conv(params) {
  1278.                 return params
  1279.                     .reduce(function (r, param, index) {
  1280.                     var match;
  1281.                     for (var i = 0, len = patterns.length; i < len; i++) {
  1282.                         var exp = patterns[i], etype = exp.length;
  1283.                         match = i > 0 && patterns[i - 1][0] === patterns[i][0] ? match : MODULE.TYPE([param], [exp[0]], 1);
  1284.                         var monad = inbound.__LazyChain__.monad;
  1285.                         if (!match) {
  1286.                             continue;
  1287.                         }
  1288.                         else if (etype === 1) {
  1289.                             r[r.length] = param;
  1290.                             return r;
  1291.                         }
  1292.                         else if (etype === 2) {
  1293.                             r[r.length] = monad.bind(param, exp[1]);
  1294.                             return r;
  1295.                         }
  1296.                         else if (etype === 3 && monad.bind(param, exp[1])) {
  1297.                             r[r.length] = monad.bind(param, exp[2]);
  1298.                             return r;
  1299.                         }
  1300.                     }
  1301.                     r[r.length] = monad.fail(param);
  1302.                     return r;
  1303.                 }, []);
  1304.             }
  1305.         }
  1306.         MODEL.monadic = monadic;
  1307.         function emulator(inbound, options, method, provider, offset) {
  1308.             var outbound = inbound.__LazyChain__.child = cascade(inbound, null);
  1309.             inbound
  1310.                 .progress(function () {
  1311.                 var params = [];
  1312.                 for (var _i = 0; _i < arguments.length; _i++) {
  1313.                     params[_i - 0] = arguments[_i];
  1314.                 }
  1315.                 return MODULE.APPLY(outbound.notify, void 0, conv(params));
  1316.             })
  1317.                 .done(function () {
  1318.                 var params = [];
  1319.                 for (var _i = 0; _i < arguments.length; _i++) {
  1320.                     params[_i - 0] = arguments[_i];
  1321.                 }
  1322.                 return MODULE.APPLY(outbound.resolve, void 0, conv(params));
  1323.             })
  1324.                 .fail(function () {
  1325.                 var params = [];
  1326.                 for (var _i = 0; _i < arguments.length; _i++) {
  1327.                     params[_i - 0] = arguments[_i];
  1328.                 }
  1329.                 return MODULE.APPLY(outbound.reject, void 0, conv(params));
  1330.             });
  1331.             return outbound;
  1332.             function conv(params) {
  1333.                 var result = offset ? MODULE.APPLY(provider[method], provider, [params].concat(options))
  1334.                     : MODULE.APPLY(provider[method], params, options);
  1335.                 var messages;
  1336.                 switch (method) {
  1337.                     case 'every':
  1338.                     case 'some':
  1339.                         messages = result ? params : [];
  1340.                         break;
  1341.                     case 'reduce':
  1342.                     case 'reduceRight':
  1343.                         messages = [result];
  1344.                         break;
  1345.                     case 'forEach':
  1346.                         messages = [];
  1347.                         break;
  1348.                     default:
  1349.                         messages = result instanceof Array ? result : [];
  1350.                 }
  1351.                 return messages;
  1352.             }
  1353.         }
  1354.         MODEL.emulator = emulator;
  1355.     })(MODEL = MODULE.MODEL || (MODULE.MODEL = {}));
  1356. })(MODULE || (MODULE = {}));
  1357. /// <reference path="apply.ts"/>
  1358. var LIBRALY;
  1359. (function (LIBRALY) {
  1360.     var FUNCTION;
  1361.     (function (FUNCTION) {
  1362.         var APPLY = LIBRALY.FUNCTION.apply;
  1363.         FUNCTION.cache = function (func, size) {
  1364.             if (size === void 0) { size = 5; }
  1365.             var cache, margin, noarg;
  1366.             var map = typeof Map === 'function' ? new Map() : null, res = [];
  1367.             return function () {
  1368.                 var args = [];
  1369.                 for (var _i = 0; _i < arguments.length; _i++) {
  1370.                     args[_i - 0] = arguments[_i];
  1371.                 }
  1372.                 var len = arguments.length;
  1373.                 if (len === 0) {
  1374.                     if (noarg === void 0) {
  1375.                         noarg = func();
  1376.                     }
  1377.                     return noarg;
  1378.                 }
  1379.                 else if (map) {
  1380.                     var m = map;
  1381.                     for (var i = 0; i < len; i++) {
  1382.                         var id = args[i];
  1383.                         var n = m.get(id);
  1384.                         if (n === void 0) {
  1385.                             n = new Map();
  1386.                             m.set(id, n);
  1387.                         }
  1388.                         m = n;
  1389.                     }
  1390.                     var result = m.get(res);
  1391.                     if (result === void 0) {
  1392.                         result = APPLY(func, void 0, args);
  1393.                         if (result !== void 0) {
  1394.                             m.set(res, result);
  1395.                         }
  1396.                     }
  1397.                     return result;
  1398.                 }
  1399.                 else {
  1400.                     margin = margin === void 0 ? size > 20 && 10 || Math.floor(size / 2) : margin;
  1401.                     var node = cache = cache || Object.create(null), result;
  1402.                     for (var i = 0; i < len; i++) {
  1403.                         node = i ? result[2] : node;
  1404.                         var id = args[i];
  1405.                         // try-catch文が存在するとIEで大幅な速度低下が発生するので隔離
  1406.                         var index = id && typeof id === 'object' ? stringify(id) : id + '';
  1407.                         // argumentsオブジェクトをパラメータにする関数が存在するだけで
  1408.                         // 実行されなくともFirefoxとIEで大幅な速度低下が発生するので要注意
  1409.                         result = update(sort(node, index, id), id, func, args, size, margin);
  1410.                     }
  1411.                     return result[1];
  1412.                 }
  1413.             };
  1414.         };
  1415.         function stringify(id) {
  1416.             try {
  1417.                 return id && typeof id === 'object' ? JSON.stringify(id) : id + '';
  1418.             }
  1419.             catch (e) {
  1420.                 return id + '';
  1421.             }
  1422.         }
  1423.         function sort(node, index, id) {
  1424.             var results;
  1425.             if (!(index in node)) {
  1426.                 results = node[index] = [[id, void 0, Object.create(null)]];
  1427.             }
  1428.             else {
  1429.                 results = node[index];
  1430.                 if (results[0][0] !== id) {
  1431.                     for (var i = 1, len = results.length; i < len; i++) {
  1432.                         if (results[i][0] === id) {
  1433.                             results.unshift(results.splice(i, 1).pop());
  1434.                             break;
  1435.                         }
  1436.                     }
  1437.                 }
  1438.             }
  1439.             return results;
  1440.         }
  1441.         function update(results, id, func, args, size, margin) {
  1442.             var result = results[0];
  1443.             if (results.length === 0 || result[0] !== id) {
  1444.                 result = [id, APPLY(func, void 0, args), Object.create(null)];
  1445.                 results.unshift(result);
  1446.             }
  1447.             else if (result[1] === void 0) {
  1448.                 result[1] = APPLY(func, void 0, args);
  1449.             }
  1450.             if (results.length > size + margin) {
  1451.                 results.splice(size, size + margin);
  1452.             }
  1453.             return result;
  1454.         }
  1455.     })(FUNCTION = LIBRALY.FUNCTION || (LIBRALY.FUNCTION = {}));
  1456. })(LIBRALY || (LIBRALY = {}));
  1457. /// <reference path="cache.ts"/>
  1458. var LIBRALY;
  1459. (function (LIBRALY) {
  1460.     var UTILITY;
  1461.     (function (UTILITY) {
  1462.         var cache = LIBRALY.FUNCTION.cache;
  1463.         UTILITY.store = function (size) {
  1464.             if (size === void 0) { size = 10; }
  1465.             var k2v = cache(function (key) { return value; }, size), value, store = function (key, val) {
  1466.                 value = val;
  1467.                 return k2v(key);
  1468.             };
  1469.             return function (key, value) {
  1470.                 if (value === void 0) {
  1471.                     return store(key);
  1472.                 }
  1473.                 else {
  1474.                     if (value === store(key, value)) {
  1475.                         return value;
  1476.                     }
  1477.                     else {
  1478.                         throw Error(key);
  1479.                     }
  1480.                 }
  1481.             };
  1482.         };
  1483.     })(UTILITY = LIBRALY.UTILITY || (LIBRALY.UTILITY = {}));
  1484. })(LIBRALY || (LIBRALY = {}));
  1485. /// <reference path="type.ts"/>
  1486. /// <reference path="apply.ts"/>
  1487. var LIBRALY;
  1488. (function (LIBRALY) {
  1489.     var FUNCTION;
  1490.     (function (FUNCTION) {
  1491.         var TYPE = LIBRALY.TYPE;
  1492.         var APPLY = LIBRALY.FUNCTION.apply;
  1493.         function dispatcher() {
  1494.             var patterns = [];
  1495.             for (var _i = 0; _i < arguments.length; _i++) {
  1496.                 patterns[_i - 0] = arguments[_i];
  1497.             }
  1498.             return function () {
  1499.                 var params = [];
  1500.                 for (var _i = 0; _i < arguments.length; _i++) {
  1501.                     params[_i - 0] = arguments[_i];
  1502.                 }
  1503.                 return dispatch(patterns, params);
  1504.             };
  1505.         }
  1506.         FUNCTION.dispatcher = dispatcher;
  1507.         function dispatch(patterns, params) {
  1508.             for (var i = 0; i < patterns.length; i++) {
  1509.                 var pattern = patterns[i], types = pattern[0], guard = pattern.length >= 2 ? pattern[2] : null, fn = pattern.length === 1 ? null
  1510.                     : !guard ? pattern[1]
  1511.                         : pattern[2];
  1512.                 if (!TYPE.type(params, types)) {
  1513.                     continue;
  1514.                 }
  1515.                 if (!fn) {
  1516.                     continue;
  1517.                 }
  1518.                 if (guard && !APPLY(guard, void 0, params)) {
  1519.                     continue;
  1520.                 }
  1521.                 switch (params.length) {
  1522.                     case 0:
  1523.                         return fn();
  1524.                     case 1:
  1525.                         return fn(params[0]);
  1526.                     case 2:
  1527.                         return fn(params[0], params[1]);
  1528.                     case 3:
  1529.                         return fn(params[0], params[1], params[2]);
  1530.                     case 4:
  1531.                         return fn(params[0], params[1], params[2], params[3]);
  1532.                 }
  1533.                 return APPLY(fn, void 0, params);
  1534.             }
  1535.             throw new Error('non-exhaustive dispatch');
  1536.         }
  1537.     })(FUNCTION = LIBRALY.FUNCTION || (LIBRALY.FUNCTION = {}));
  1538. })(LIBRALY || (LIBRALY = {}));
  1539. /// <reference path="../define.ts"/>
  1540. /// <reference path="../model/main.ts"/>
  1541. /// <reference path="stream.ts"/>
  1542. /// <reference path="../library/cache.ts"/>
  1543. /// <reference path="../library/store.ts"/>
  1544. /// <reference path="../library/dispatcher.ts"/>
  1545. /* CONTROLLER */
  1546. var MODULE;
  1547. (function (MODULE) {
  1548.     var CONTROLLER;
  1549.     (function (CONTROLLER) {
  1550.         function handle() {
  1551.             var lazychain;
  1552.             lazychain = (function () {
  1553.                 var args = [];
  1554.                 for (var _i = 0; _i < arguments.length; _i++) {
  1555.                     args[_i - 0] = arguments[_i];
  1556.                 }
  1557.                 return MODULE.APPLY(CONTROLLER.core, void 0, args);
  1558.             });
  1559.             lazychain.id = MODULE.ID;
  1560.             lazychain.uuid = MODULE.UUID;
  1561.             lazychain.args2array = LIBRALY.FUNCTION.args2array;
  1562.             lazychain.type = MODULE.TYPE;
  1563.             lazychain.memoize = LIBRALY.FUNCTION.memoize;
  1564.             lazychain.cache = LIBRALY.FUNCTION.cache;
  1565.             lazychain.store = LIBRALY.UTILITY.store;
  1566.             lazychain.resolve = MODULE.PROMISE.resolve;
  1567.             lazychain.reject = MODULE.PROMISE.reject;
  1568.             lazychain.deferred = MODULE.PROMISE.deferred;
  1569.             lazychain.when = MODULE.PROMISE.when;
  1570.             lazychain.dispatcher = LIBRALY.FUNCTION.dispatcher;
  1571.             lazychain.repeat = LIBRALY.UTILITY.repeat;
  1572.             lazychain.duff = LIBRALY.UTILITY.duff;
  1573.             lazychain.duffbk = LIBRALY.UTILITY.duffbk;
  1574.             return lazychain;
  1575.         }
  1576.         CONTROLLER.handle = handle;
  1577.         function core() {
  1578.             var args = [];
  1579.             for (var _i = 0; _i < arguments.length; _i++) {
  1580.                 args[_i - 0] = arguments[_i];
  1581.             }
  1582.             switch (true) {
  1583.                 case MODULE.TYPE(args, [true]):
  1584.                     return void extendArray_(true, false);
  1585.                 case MODULE.TYPE(args, [false]):
  1586.                     return void extendArray_(false, false);
  1587.                 case MODULE.TYPE(args, [true, Array.prototype]):
  1588.                     return void extendArray_(true, true);
  1589.                 case MODULE.TYPE(args, [false, Array.prototype]):
  1590.                     return void extendArray_(false, true);
  1591.                 case MODULE.TYPE(args, [true, Function]):
  1592.                     return void extendStream_(true, args[1], 1);
  1593.                 case MODULE.TYPE(args, [false, Function]):
  1594.                     return void extendStream_(false, args[1], 1);
  1595.                 case MODULE.TYPE(args, []):
  1596.                     return new CONTROLLER.Stream();
  1597.                 case MODULE.TYPE(args, [Function]):
  1598.                     return new CONTROLLER.Stream(void 0, [args[0]]);
  1599.                 case MODULE.TYPE(args, [Array]):
  1600.                     return new CONTROLLER.Stream(args[0]);
  1601.                 case MODULE.TYPE(args, [Array, Function]):
  1602.                     return new CONTROLLER.Stream(args[0], [args[1]]);
  1603.                 case MODULE.TYPE(args, [Object, Function]):
  1604.                     return new CONTROLLER.Stream(args[0], [args[1]]);
  1605.                 case MODULE.TYPE(args, [Object, MODULE.ID.rest()]):
  1606.                     return new CONTROLLER.Stream().stream(args);
  1607.             }
  1608.         }
  1609.         CONTROLLER.core = core;
  1610.         function extendArray_(state, enumerable) {
  1611.             [
  1612.                 'lazy',
  1613.                 'stream'
  1614.             ]
  1615.                 .forEach(function (v) {
  1616.                 if (state) {
  1617.                     Object.defineProperty(Array.prototype, v, {
  1618.                         configurable: true,
  1619.                         writable: true,
  1620.                         enumerable: enumerable,
  1621.                         value: function () {
  1622.                             var args = [];
  1623.                             for (var _i = 0; _i < arguments.length; _i++) {
  1624.                                 args[_i - 0] = arguments[_i];
  1625.                             }
  1626.                             return MODULE.APPLY(CONTROLLER[v], void 0, [LazyChain(this)].concat(args));
  1627.                         }
  1628.                     });
  1629.                 }
  1630.                 else {
  1631.                     delete Array.prototype[v];
  1632.                 }
  1633.             });
  1634.         }
  1635.         CONTROLLER.extendArray_ = extendArray_;
  1636.         function extendStream_(state, extension, offset, method) {
  1637.             if (method === void 0) { method = []; }
  1638.             if (state) {
  1639.                 Object.keys(extension)
  1640.                     .concat(method)
  1641.                     .filter(function (v) { return !CONTROLLER.Stream.prototype[v] && 'function' === typeof extension[v]; })
  1642.                     .forEach(function (v) {
  1643.                     CONTROLLER.Stream.prototype[v] = function () {
  1644.                         var args = [];
  1645.                         for (var _i = 0; _i < arguments.length; _i++) {
  1646.                             args[_i - 0] = arguments[_i];
  1647.                         }
  1648.                         this.__LazyChain__.command = [v, args];
  1649.                         return MODULE.MODEL.emulator(this, args, v, extension, offset);
  1650.                     };
  1651.                     Object.defineProperty(CONTROLLER.Stream.prototype[v], 'provider', {
  1652.                         configurable: false,
  1653.                         writable: false,
  1654.                         enumerable: false,
  1655.                         value: extension
  1656.                     });
  1657.                 });
  1658.             }
  1659.             else {
  1660.                 Object.keys(extension)
  1661.                     .concat(method)
  1662.                     .filter(function (v) { return !!CONTROLLER.Stream.prototype[v] && CONTROLLER.Stream.prototype[v].provider === extension; })
  1663.                     .forEach(function (v) { return delete CONTROLLER.Stream.prototype[v]; });
  1664.             }
  1665.         }
  1666.         CONTROLLER.extendStream_ = extendStream_;
  1667.         function lazy() {
  1668.             var args = [];
  1669.             for (var _i = 0; _i < arguments.length; _i++) {
  1670.                 args[_i - 0] = arguments[_i];
  1671.             }
  1672.             var context = args[0];
  1673.             switch (true) {
  1674.                 // basic
  1675.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function]):
  1676.                     return MODULE.MODEL.lazy(context, args[1]);
  1677.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, Boolean]):
  1678.                     return MODULE.MODEL.lazy(context, args[1], args[2]);
  1679.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, void 0]):
  1680.                     return MODULE.MODEL.lazy(context, args[1], args[2]);
  1681.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, void 0, Boolean]):
  1682.                     return MODULE.MODEL.lazy(context, args[1], args[2], args[3]);
  1683.                 // immediate
  1684.                 case MODULE.TYPE(args, [CONTROLLER.Stream]):
  1685.                     return MODULE.MODEL.immediate(context);
  1686.                 // buffer
  1687.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Number]):
  1688.                     return MODULE.MODEL.buffer(context, args[1]);
  1689.                 default:
  1690.                     return MODULE.MODEL.stream(context, void 0);
  1691.             }
  1692.         }
  1693.         CONTROLLER.lazy = lazy;
  1694.         function stream() {
  1695.             var args = [];
  1696.             for (var _i = 0; _i < arguments.length; _i++) {
  1697.                 args[_i - 0] = arguments[_i];
  1698.             }
  1699.             var context = args[0];
  1700.             switch (true) {
  1701.                 // basic
  1702.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function]):
  1703.                     return MODULE.MODEL.stream(context, args[1]);
  1704.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, void 0]):
  1705.                     return MODULE.MODEL.stream(context, args[1], args[2]);
  1706.                 // compose
  1707.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Object, MODULE.ID.rest()]):
  1708.                     return MODULE.MODEL.compose(context, args.slice(1));
  1709.                 // branch
  1710.                 case MODULE.TYPE(args, [CONTROLLER.Stream]):
  1711.                     return context;
  1712.                 case MODULE.TYPE(args, [CONTROLLER.Stream, true, [Object]]):
  1713.                     return MODULE.MODEL.branch(context, args[2]);
  1714.                 case MODULE.TYPE(args, [CONTROLLER.Stream, false, [Object]]):
  1715.                     return MODULE.MODEL.branch(context, args[2]), MODULE.MODEL.cascade(context, null);
  1716.                 // split
  1717.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Array, Object]):
  1718.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Array, null]):
  1719.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Array, Object]):
  1720.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Array, null]):
  1721.                     return MODULE.MODEL.split(context, function (v) { return MODULE.TYPE([v], args[1]); }, args[2]);
  1722.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, Object, void 0]):
  1723.                 case MODULE.TYPE(args, [CONTROLLER.Stream, Function, [Object], void 0]):
  1724.                     return MODULE.MODEL.split(context, args[1], args[2], args[3]);
  1725.                 case MODULE.TYPE(args, [CONTROLLER.Stream, String, Object]):
  1726.                 case MODULE.TYPE(args, [CONTROLLER.Stream, String, null]):
  1727.                     return MODULE.MODEL.split(context, function (v) { return MODULE.TYPE(v) === args[1]; }, args[2]);
  1728.                 // merge
  1729.                 case MODULE.TYPE(args, [CONTROLLER.Stream, [Object]]):
  1730.                     return MODULE.MODEL.merge(context, args[1]);
  1731.                 default:
  1732.                     return MODULE.MODEL.stream(context, void 0);
  1733.             }
  1734.         }
  1735.         CONTROLLER.stream = stream;
  1736.         function pattern(context) {
  1737.             var patterns = [];
  1738.             for (var _i = 1; _i < arguments.length; _i++) {
  1739.                 patterns[_i - 1] = arguments[_i];
  1740.             }
  1741.             return MODULE.MODEL.pattern(context, patterns);
  1742.         }
  1743.         CONTROLLER.pattern = pattern;
  1744.         function monad(context, monad, convert) {
  1745.             return MODULE.MODEL.monad(context, monad, convert);
  1746.         }
  1747.         CONTROLLER.monad = monad;
  1748.         function monadic(context) {
  1749.             var patterns = [];
  1750.             for (var _i = 1; _i < arguments.length; _i++) {
  1751.                 patterns[_i - 1] = arguments[_i];
  1752.             }
  1753.             return MODULE.MODEL.monadic(context, patterns);
  1754.         }
  1755.         CONTROLLER.monadic = monadic;
  1756.         function mixin(context, source, method, offset) {
  1757.             if (method === void 0) { method = []; }
  1758.             if (offset === void 0) { offset = 1; }
  1759.             // deferred
  1760.             Object.keys(source)
  1761.                 .concat(method)
  1762.                 .filter(function (method) { return !context[method] && 'function' === typeof source[method]; })
  1763.                 .forEach(function (method) { return context[method] = source[method]; });
  1764.             return context;
  1765.         }
  1766.         CONTROLLER.mixin = mixin;
  1767.         function emulate(context, source, method, offset, overwrite) {
  1768.             if (method === void 0) { method = []; }
  1769.             if (offset === void 0) { offset = 1; }
  1770.             if (overwrite === void 0) { overwrite = false; }
  1771.             // array, extension
  1772.             Object.keys(source)
  1773.                 .concat(method)
  1774.                 .filter(function (method) { return overwrite || !context[method] && 'function' === typeof source[method]; })
  1775.                 .forEach(function (method) { return context[method] = function () {
  1776.                 var args = [];
  1777.                 for (var _i = 0; _i < arguments.length; _i++) {
  1778.                     args[_i - 0] = arguments[_i];
  1779.                 }
  1780.                 context.__LazyChain__.command = [method, args];
  1781.                 return MODULE.MODEL.emulator(context, args, method, source, offset);
  1782.             }; });
  1783.             return context;
  1784.         }
  1785.         CONTROLLER.emulate = emulate;
  1786.     })(CONTROLLER = MODULE.CONTROLLER || (MODULE.CONTROLLER = {}));
  1787. })(MODULE || (MODULE = {}));
  1788. /// <reference path="model/main.ts"/>
  1789. var LazyChain;
  1790. var MODULE;
  1791. (function (MODULE) {
  1792.     LazyChain = LazyChain || MODULE.CONTROLLER.handle();
  1793.     switch (true) {
  1794.         case typeof module === 'object' && !!module && module.exports instanceof Object:
  1795.             module.exports = LazyChain;
  1796.             break;
  1797.         case typeof window === 'object' && !!window && window.window === window:
  1798.             window.LazyChain = LazyChain;
  1799.             break;
  1800.     }
  1801. })(MODULE || (MODULE = {}));
  1802. }("lazychain", "0.3.0-alpha.23");
  1803.  
  1804. },{}],2:[function(require,module,exports){
  1805. "use strict";
  1806. exports.CURSOR_ID = 'spatialnavigation-cursor';
  1807. exports.URLDISPLAY_ID = 'spatialnavigation-urldisplay';
  1808. exports.MARKER_TAG = 'spatialnavigation-marker';
  1809. function attribute(event, cursor) {
  1810.     return {
  1811.         command: key2command(event),
  1812.         cursor: cursor
  1813.     };
  1814. }
  1815. exports.attribute = attribute;
  1816. function key2command(event) {
  1817.     if (event.altKey || event.metaKey) {
  1818.         return 11 /* INVALID */;
  1819.     }
  1820.  
  1821.     if (event.shiftKey) {
  1822.         switch (event.keyCode) {
  1823.             case 13: // Enter
  1824.             case 70: // F
  1825.                 return 9; // SHIFT+ENTER
  1826.             default:
  1827.                 return 11;
  1828.         }
  1829.     }
  1830.     else if (event.ctrlKey) {
  1831.         switch (event.keyCode) {
  1832.             case 13: // Enter
  1833.             case 70: // F
  1834.                 return 7; // CTRL+ENTER
  1835.             default:
  1836.                 return 11;
  1837.         }
  1838.     }
  1839.     else {
  1840.         switch (event.keyCode) {
  1841.             case 81: // Q
  1842.                 return 10; // QUIT
  1843.             case 69: // E
  1844.                 return 6; // EXPAND
  1845.             case 87: // W
  1846.                 return 0; // UP
  1847.             case 83: // S
  1848.                 return 2; // DOWN
  1849.             case 65: // A
  1850.                 return 4; // LEFT
  1851.             case 68: // D
  1852.                 return 5; // RIGHT
  1853.             case 13: // Enter
  1854.             case 70: // F
  1855.                 return 8; // ENTER
  1856.             default:
  1857.                 return 11 /* INVALID */;
  1858.         }
  1859.     }
  1860. }
  1861. exports.key2command = key2command;
  1862.  
  1863. },{}],3:[function(require,module,exports){
  1864. "use strict";
  1865. var MODEL = require('../model/model');
  1866. var VIEW = require('../view/view');
  1867. function Controller(targets) {
  1868.     return targets.map(function (target) { return new VIEW.View(target); });
  1869. }
  1870. exports.Controller = Controller;
  1871. function command(entity, attribute) {
  1872.     MODEL.input(entity, attribute);
  1873. }
  1874. exports.command = command;
  1875.  
  1876. },{"../model/model":8,"../view/view":12}],4:[function(require,module,exports){
  1877.  
  1878. },{}],5:[function(require,module,exports){
  1879. "use strict";
  1880. var Entity = (function () {
  1881.     function Entity(viewId) {
  1882.         this.viewId_ = viewId;
  1883.     }
  1884.     Object.defineProperty(Entity.prototype, "viewId", {
  1885.         get: function () {
  1886.             return this.viewId_;
  1887.         },
  1888.         set: function (_) {
  1889.             return;
  1890.         },
  1891.         enumerable: true,
  1892.         configurable: true
  1893.     });
  1894.     return Entity;
  1895. })();
  1896. exports.Entity = Entity;
  1897.  
  1898. },{}],6:[function(require,module,exports){
  1899. "use strict";
  1900. var model = require('./model/model');
  1901. model.main();
  1902.  
  1903. },{"./model/model":8}],7:[function(require,module,exports){
  1904. "use strict";
  1905. var ATTRIBUTE = require('../attribute/attribute');
  1906. var SELECTOR = [
  1907.     'a',
  1908.     'input',
  1909.     'select',
  1910.     'option',
  1911.     'datalist',
  1912.     'textarea',
  1913.     'button',
  1914.     'audio',
  1915.     'video',
  1916.     'embed',
  1917.     '[onclick]',
  1918.     '[tabindex]:not([role="tablist"]):not(ul):not(#hdtb):not(#hdtbMenus)',
  1919.     //'[role="link"]',
  1920.     '[role="button"]',
  1921.     '[role="checkbox"]',
  1922.     '[role="option"]',
  1923.     '[role="tab"]',
  1924.     '[role="menuitem"]'
  1925. ]
  1926.     .join(',');
  1927. var queried, linkcount = 0;
  1928. function analyze(data) {
  1929.     if (!queried || !data.attribute.cursor || linkcount !== document.links.length) {
  1930.         queried = Array.apply(null, document.querySelectorAll(SELECTOR));
  1931.         linkcount = document.links.length;
  1932.     }
  1933.     var winWidth = window.innerWidth, winHeight = window.innerHeight, winTop = window.scrollY, winLeft = window.scrollX;
  1934.     var targets = findTargets(queried.filter(function (target) { return isVisible(shiftVisibleImg(target)); }), data.attribute.command, data.attribute.cursor);
  1935.     queried = isInWindow(targets[0]) ? queried : null;
  1936.     return {
  1937.         entity: data.entity,
  1938.         attribute: data.attribute,
  1939.         result: {
  1940.             targets: targets
  1941.         }
  1942.     };
  1943.     function findTargets(targets, command, cursor) {
  1944.         cursor = isCursorActive(cursor) ? cursor : null;
  1945.         switch (command) {
  1946.             case 0 /* UP */:
  1947.                 return !cursor
  1948.                     ? findLeftTops(targets)
  1949.                     : findCursorTops(targets, cursor);
  1950.             case 1 /* UP_S */:
  1951.                 return !cursor
  1952.                     ? findLeftTops(targets)
  1953.                     : findCursorColumn(findCursorTops(targets, cursor), cursor);
  1954.             case 2 /* DOWN */:
  1955.                 return !cursor
  1956.                     ? findMainColumn(targets)
  1957.                     : findCursorBottoms(targets, cursor);
  1958.             case 3 /* DOWN_S */:
  1959.                 return !cursor
  1960.                     ? findMainColumn(targets)
  1961.                     : findCursorColumn(findCursorBottoms(targets, cursor), cursor);
  1962.             case 4 /* LEFT */:
  1963.                 return !cursor
  1964.                     ? findLeftColumn(targets)
  1965.                     : findCursorLefts(targets, cursor);
  1966.             case 5 /* RIGHT */:
  1967.                 return !cursor
  1968.                     ? findRightColumn(targets)
  1969.                     : findCursorRights(targets, cursor);
  1970.             case 6 /* EXPAND */:
  1971.                 return findCursorNeerTargets(targets, cursor || findMainColumn(targets)[0] || document.body)
  1972.                     .filter(isInWindow);
  1973.             case 7 /* CONTRACT */:
  1974.                 return findCursorNeerTargets(targets, cursor || findMainColumn(targets)[0] || document.body)
  1975.                     .filter(isInWindow)
  1976.                     .reverse();
  1977.             default:
  1978.                 return [];
  1979.         }
  1980.         function findLeftTops(targets) {
  1981.             return targets
  1982.                 .filter(isInWindow)
  1983.                 .map(shiftVisibleImg)
  1984.                 .sort(compareLeftTopDistance);
  1985.         }
  1986.         function findMainColumn(targets) {
  1987.             return columns(targets.filter(function (target) { return target.getBoundingClientRect().left < (winWidth / 2); }).filter(hasVisibleTextNode))
  1988.                 .sort(compareGroupsByTextWeightAverage)
  1989.                 .map(function (group) { return group.filter(isInWindow); })
  1990.                 .filter(function (group) { return group.length > 0; })
  1991.                 .reduce(function (_, group) { return group; }, findLeftTops(targets))
  1992.                 .map(shiftVisibleImg)
  1993.                 .sort(compareLeftTopDistance);
  1994.         }
  1995.         function findLeftColumn(targets) {
  1996.             var mainColumn = findMainColumn(targets);
  1997.             var left = mainColumn.length > 0 ? mainColumn[0].parentElement.getBoundingClientRect().left : Infinity;
  1998.             return columns(targets.filter(function (target) { return target.getBoundingClientRect().right < left; }))
  1999.                 .map(function (group) { return group.filter(isInWindow); })
  2000.                 .filter(function (group) { return group.length > 0; })
  2001.                 .sort(compareGroupsByTextWeightAverage)
  2002.                 .reduce(function (_, group) { return group; }, mainColumn)
  2003.                 .map(shiftVisibleImg)
  2004.                 .sort(compareLeftTopDistance);
  2005.         }
  2006.         function findRightColumn(targets) {
  2007.             var mainColumn = findMainColumn(targets);
  2008.             var right = mainColumn.length > 0 ? mainColumn[0].parentElement.getBoundingClientRect().right : -Infinity;
  2009.             return columns(targets.filter(function (target) { return target.getBoundingClientRect().left > right; }))
  2010.                 .map(function (group) { return group.filter(isInWindow); })
  2011.                 .filter(function (group) { return group.length > 0; })
  2012.                 .sort(compareGroupsByTextWeightAverage)
  2013.                 .reduce(function (_, group) { return group; }, mainColumn)
  2014.                 .map(shiftVisibleImg)
  2015.                 .sort(compareLeftTopDistance);
  2016.         }
  2017.         function findCursorTops(targets, cursor) {
  2018.             var margin = 3;
  2019.             return targets
  2020.                 .map(shiftVisibleImg)
  2021.                 .filter(isInRange(Math.max(winTop - (winHeight * 3), 0), winLeft, winLeft + winWidth, Offset(cursor).top + margin))
  2022.                 .sort(compareCursorVerticalDistance(cursor));
  2023.         }
  2024.         function findCursorBottoms(targets, cursor) {
  2025.             var margin = 3;
  2026.             return targets
  2027.                 .map(shiftVisibleImg)
  2028.                 .filter(isInRange(Offset(cursor).bottom - margin, winLeft, winLeft + winWidth, winTop + (winHeight * 4)))
  2029.                 .sort(compareCursorVerticalDistance(cursor));
  2030.         }
  2031.         function findCursorLefts(targets, cursor) {
  2032.             var margin = 3;
  2033.             return targets
  2034.                 .map(shiftVisibleImg)
  2035.                 .filter(isInRange(winTop, 0, Offset(cursor).left + margin, winTop + winHeight))
  2036.                 .sort(compareCursorLeftDistance(cursor));
  2037.         }
  2038.         function findCursorRights(targets, cursor) {
  2039.             var margin = 3;
  2040.             return targets
  2041.                 .map(shiftVisibleImg)
  2042.                 .filter(isInRange(winTop, Offset(cursor).right - margin, Infinity, winTop + winHeight))
  2043.                 .sort(compareCursorRightDistance(cursor));
  2044.         }
  2045.         function findCursorNeerTargets(targets, cursor) {
  2046.             return targets
  2047.                 .map(shiftVisibleImg)
  2048.                 .filter(isInWindow)
  2049.                 .sort(compareCursorDistance(cursor));
  2050.         }
  2051.         function findCursorColumn(targets, cursor) {
  2052.             var left = cursor.getBoundingClientRect().left;
  2053.             return columns(targets.filter(isCursorColumn).filter(hasVisibleTextNode))
  2054.                 .reduce(function (_, group) { return group; }, targets)
  2055.                 .map(shiftVisibleImg)
  2056.                 .sort(function (a, b) { return compareGroupsByTextWeightAverage([b], [a]) || compareLeftTopDistance(a, b); });
  2057.             function isCursorColumn(elem) {
  2058.                 return elem.getBoundingClientRect().left === left;
  2059.             }
  2060.         }
  2061.         function isCursorActive(cursor) {
  2062.             var rect = cursor && cursor.getBoundingClientRect();
  2063.             return !(!rect ||
  2064.                 rect.bottom < 0 ||
  2065.                 rect.top > winHeight ||
  2066.                 rect.right < 0 ||
  2067.                 rect.left > winWidth);
  2068.         }
  2069.         function columns(targets) {
  2070.             return targets
  2071.                 .sort(compareLeftDistance)
  2072.                 .reduce(groupsByLeftDistance, [])
  2073.                 .map(filterFewNodesGroup)
  2074.                 .filter(function (group) { return group.length > 1; });
  2075.         }
  2076.         function groupsByLeftDistance(groups, elem) {
  2077.             if (groups.length === 0) {
  2078.                 return [[elem]];
  2079.             }
  2080.             var group = groups.slice(-1)[0];
  2081.             return isSameGroup(group, elem) ? groups.slice(0, -1).concat([group.concat(elem)]) : groups.concat([[elem]]);
  2082.             function isSameGroup(group, elem) {
  2083.                 return Math.floor(group[0].getBoundingClientRect().left) === Math.floor(elem.getBoundingClientRect().left);
  2084.             }
  2085.         }
  2086.         function compareGroupsByTextWeightAverage(a, b) {
  2087.             return calWeightAverage(a.filter(hasText).slice(0, 10)) - calWeightAverage(b.filter(hasText).slice(0, 10))
  2088.                 || -compareLeftDistance(a[0], b[0]);
  2089.             function calWeightAverage(elems) {
  2090.                 return calTextWeightAverage(elems);
  2091.             }
  2092.             function calTextWeightAverage(elems) {
  2093.                 return elems.length === 0
  2094.                     ? 0
  2095.                     : elems.reduce(function (r, elem) { return r + calTextWeight(elem); }, 0) / elems.length * (Math.min(elems.length, 10) / 10 + 0.5);
  2096.             }
  2097.             function calTextWeight(elem) {
  2098.                 var fontSize = parseInt(window.getComputedStyle(elem).fontSize, 10)
  2099.                     || parseInt(window.getComputedStyle(document.documentElement).fontSize, 10)
  2100.                     || 16, fullTextNodeParents = findVisibleTextNodes(elem)
  2101.                     .map(function (text) { return text.parentElement; }), fontWeightAverage = calFontWeightRateAverage(fullTextNodeParents), length = fullTextNodeParents
  2102.                     .reduce(function (r, elem) { return r + elem.textContent.trim().length; }, 0);
  2103.                 return fontSize * fontWeightAverage * +(length > 3);
  2104.             }
  2105.             function calFontWeightRateAverage(textNodeParents) {
  2106.                 //const sum = textNodeParents.reduce((r, elem) => r + elem.textContent.trim().length * calFontWeightRate(elem), 0),
  2107.                 //      len = textNodeParents.reduce((r, elem) => r + elem.textContent.trim().length, 0);
  2108.                 //return len === 0 ? 0 : sum / len;
  2109.                 return textNodeParents
  2110.                     .sort(function (a, b) { return a.textContent.trim().length - b.textContent.trim().length; })
  2111.                     .slice(-1)
  2112.                     .map(function (elem) { return calFontWeightRate(elem); })
  2113.                     .pop();
  2114.             }
  2115.             function calFontWeightRate(elem) {
  2116.                 var fontWeight = window.getComputedStyle(elem).fontWeight;
  2117.                 var weight;
  2118.                 switch (fontWeight) {
  2119.                     case 'normal':
  2120.                         weight = 400;
  2121.                         break;
  2122.                     case 'bold':
  2123.                         weight = 700;
  2124.                         break;
  2125.                     default:
  2126.                         weight = parseInt(fontWeight, 10);
  2127.                 }
  2128.                 return 1 + ((weight / 400 - 1) / 3);
  2129.             }
  2130.         }
  2131.         function filterFewNodesGroup(group) {
  2132.             return groupsByNodeDistanceFromRoot(group)
  2133.                 .filter(function (group) { return group.length > 1; })
  2134.                 .reduce(function (r, group) { return r.concat(group); }, []);
  2135.         }
  2136.         function groupsByNodeDistanceFromRoot(group) {
  2137.             return group
  2138.                 .sort(compareByNodeDistanceFromRoot)
  2139.                 .reduce(function (r, elem) { return r.length === 0 ? [[elem]]
  2140.                 : compareByNodeDistanceFromRoot(r[0][0], elem) === 0 ? [[elem].concat(r[0])].concat(r.slice(1))
  2141.                     : [[elem]].concat(r); }, []);
  2142.         }
  2143.         function compareByNodeDistanceFromRoot(a, b) {
  2144.             return countNodeDistanceFromRoot(a) - countNodeDistanceFromRoot(b);
  2145.             function countNodeDistanceFromRoot(elem) {
  2146.                 var count = 0, parent = elem;
  2147.                 while (parent = parent.parentElement) {
  2148.                     ++count;
  2149.                 }
  2150.                 return count;
  2151.             }
  2152.         }
  2153.         function compareLeftDistance(a, b) {
  2154.             return Math.floor(a.getBoundingClientRect().left) - Math.floor(b.getBoundingClientRect().left);
  2155.         }
  2156.         function compareLeftTopDistance(a, b) {
  2157.             return distance(a) - distance(b);
  2158.             function distance(elem) {
  2159.                 var rect = elem.getBoundingClientRect();
  2160.                 return Math.floor(rect.left
  2161.                     + rect.top * 5);
  2162.             }
  2163.         }
  2164.         function compareCursorDistance(cursor) {
  2165.             var weight = 10;
  2166.             var cursorOffset = Offset(cursor);
  2167.             return function (a, b) {
  2168.                 return distance(a) - distance(b);
  2169.             };
  2170.             function distance(elem) {
  2171.                 var targetOffset = Offset(elem);
  2172.                 return Math.floor(Math.abs(targetOffset.left - cursorOffset.left)
  2173.                     + Math.abs(targetOffset.top - cursorOffset.top) * weight);
  2174.             }
  2175.         }
  2176.         function compareCursorVerticalDistance(cursor) {
  2177.             var weight = 3;
  2178.             var cursorOffset = Offset(cursor);
  2179.             return function (a, b) {
  2180.                 return distance(a) - distance(b);
  2181.             };
  2182.             function distance(elem) {
  2183.                 var targetOffset = Offset(elem), hdistance = targetOffset.left <= cursorOffset.left && cursorOffset.left <= targetOffset.right
  2184.                     ? 0
  2185.                     : targetOffset.left - cursorOffset.left;
  2186.                 return Math.floor(Math.abs(hdistance) * weight
  2187.                     + Math.abs(targetOffset.top - cursorOffset.top));
  2188.             }
  2189.         }
  2190.         function compareCursorLeftDistance(cursor) {
  2191.             var weight = 5;
  2192.             var cursorOffset = Offset(cursor);
  2193.             return function (a, b) {
  2194.                 return distance(a) - distance(b);
  2195.             };
  2196.             function distance(elem) {
  2197.                 var targetOffset = Offset(elem);
  2198.                 return Math.floor(Math.abs(targetOffset.right - cursorOffset.left)
  2199.                     + Math.abs(targetOffset.top - cursorOffset.top) * weight);
  2200.             }
  2201.         }
  2202.         function compareCursorRightDistance(cursor) {
  2203.             var weight = 5;
  2204.             var cursorOffset = Offset(cursor);
  2205.             return function (a, b) {
  2206.                 return distance(a) - distance(b);
  2207.             };
  2208.             function distance(elem) {
  2209.                 var targetOffset = Offset(elem);
  2210.                 return Math.floor(Math.abs(targetOffset.left - cursorOffset.right)
  2211.                     + Math.abs(targetOffset.top - cursorOffset.top) * weight);
  2212.             }
  2213.         }
  2214.     }
  2215.     function isInWindow(elem) {
  2216.         return !!elem && isInRange(winTop, winLeft, winLeft + winWidth, winTop + winHeight)(elem);
  2217.     }
  2218.     function isInRange(top, left, right, bottom) {
  2219.         return function (elem) {
  2220.             var offset = Offset(elem);
  2221.             return top <= offset.top && offset.top <= bottom - 10
  2222.                 && left <= offset.left && offset.left <= right - 10;
  2223.         };
  2224.     }
  2225.     function hasVisibleTextNode(elem) {
  2226.         return findVisibleTextNodes(elem).length > 0;
  2227.     }
  2228.     function findVisibleTextNodes(elem) {
  2229.         return findTextNodes(elem)
  2230.             .filter(hasText)
  2231.             .filter(function (text) { return isVisible(text.parentElement); });
  2232.     }
  2233.     function findTextNodes(elem) {
  2234.         return Array.apply(null, elem.childNodes)
  2235.             .map(function (elem) { return isTextNode(elem) ? [elem] : findTextNodes(elem); })
  2236.             .reduce(function (r, elems) { return r.concat(elems); }, []);
  2237.     }
  2238.     function isTextNode(elem) {
  2239.         return elem.nodeName === '#text';
  2240.     }
  2241.     function hasText(elem) {
  2242.         return elem.textContent.trim().length > 0;
  2243.     }
  2244.     function shiftVisibleImg(elem) {
  2245.         return Array.apply(null, elem.querySelectorAll('img'))
  2246.             .filter(isVisible)
  2247.             .shift() || elem;
  2248.     }
  2249.     function isVisible(elem) {
  2250.         var rect = elem.getBoundingClientRect(), point = document.elementFromPoint(Math.ceil(rect.left + (rect.width / 2)), Math.ceil(rect.top + Math.min(rect.height / 2, 10)));
  2251.         return point
  2252.             ? isVisibleSize(elem) && (point === elem || isChild(elem, point))
  2253.             : isVisibleSize(elem) && isVisibleStyle(elem);
  2254.         function isChild(parent, child) {
  2255.             return child ? child.parentElement === parent || isChild(parent, child.parentElement) : false;
  2256.         }
  2257.         function isVisibleSize(elem) {
  2258.             return elem.offsetWidth > 9 && elem.offsetHeight > 9;
  2259.         }
  2260.         function isVisibleStyle(elem) {
  2261.             var style = window.getComputedStyle(elem);
  2262.             return (style.display.split(' ')[0] !== 'none' ||
  2263.                 style.visibility.split(' ')[0] !== 'hidden' ||
  2264.                 !(parseInt(style.zIndex.split(' ')[0], 10) < 0));
  2265.         }
  2266.     }
  2267.     function Offset(elem) {
  2268.         var offset = elem.getBoundingClientRect();
  2269.         return {
  2270.             top: winTop + offset.top,
  2271.             left: winLeft + offset.left,
  2272.             right: winLeft + offset.right,
  2273.             bottom: winTop + offset.bottom,
  2274.             width: offset.right - offset.left,
  2275.             height: offset.bottom - offset.top
  2276.         };
  2277.     }
  2278. }
  2279. exports.analyze = analyze;
  2280.  
  2281. },{"../attribute/attribute":2}],8:[function(require,module,exports){
  2282. "use strict";
  2283. /// <reference path="../.d/lazychain.d.ts" />
  2284. var VIEW = require('../view/view');
  2285. var CONTROLLER = require('../controller/controller');
  2286. var STORE = require('../store/store');
  2287. exports.store = STORE.create();
  2288. var ANALYSIS = require('./analysis');
  2289. //import MAP = require('./map');
  2290. var LazyChain = require('lazychain');
  2291. var views = [];
  2292. function main() {
  2293.     if (document.readyState === "loading") {
  2294.         return window.addEventListener("DOMContentLoaded", register);
  2295.     }
  2296.     else {
  2297.         return register();
  2298.     }
  2299.     function register() {
  2300.         window.removeEventListener("DOMContentLoaded", register);
  2301.         CONTROLLER.Controller([window])
  2302.             .forEach(function (view) { return views.unshift(view); });
  2303.     }
  2304. }
  2305. exports.main = main;
  2306. var stream = LazyChain();
  2307. stream
  2308.     .lazy(10)
  2309.     .reduceRight(function (v) { return v; })
  2310.     .map(ANALYSIS.analyze)
  2311.     .stream(output);
  2312. function input(entity, attribute) {
  2313.     stream.notify({ entity: entity, attribute: attribute, result: null });
  2314. }
  2315. exports.input = input;
  2316. function output(data) {
  2317.     exports.store.update(data.entity.viewId, data.result);
  2318.     VIEW.emit(data.entity, data.attribute);
  2319. }
  2320.  
  2321. },{"../controller/controller":3,"../store/store":10,"../view/view":12,"./analysis":7,"lazychain":1}],9:[function(require,module,exports){
  2322. "use strict";
  2323. var state_ = 0 /* ENABLE */;
  2324. function state(enable) {
  2325.     switch (enable) {
  2326.         case true:
  2327.             state_ = 0 /* ENABLE */;
  2328.             break;
  2329.         case false:
  2330.             state_ = 1 /* DISABLE */;
  2331.             break;
  2332.     }
  2333.     return state_ === 0 /* ENABLE */;
  2334. }
  2335. exports.state = state;
  2336.  
  2337. },{}],10:[function(require,module,exports){
  2338. "use strict";
  2339. function create() {
  2340.     return new Store();
  2341. }
  2342. exports.create = create;
  2343. var Store = (function () {
  2344.     function Store() {
  2345.         this.state_ = {};
  2346.         this.diff_ = {};
  2347.     }
  2348.     Store.prototype.update = function (id, diff) {
  2349.         var curState = this.state_[id] = this.state_[id] || {}, curDiff = this.diff_[id] = this.diff_[id] || [];
  2350.         Object.keys(diff)
  2351.             .forEach(function (v) {
  2352.             var key = v, val = diff[key];
  2353.             if (val === curState[key]) {
  2354.                 return;
  2355.             }
  2356.             curState[key] = val;
  2357.             curDiff.push(key);
  2358.         });
  2359.     };
  2360.     Store.prototype.state = function (id) {
  2361.         return this.state_[id] = this.state_[id] || {};
  2362.     };
  2363.     Store.prototype.diff = function (id) {
  2364.         var diff = this.diff_[id] = this.diff_[id] || [], uniq = diff.sort().reduce(function (r, v, i) { return i === 0 ? [v] : r[0] === v ? r : [v].concat(r); }, []).reverse();
  2365.         [].splice.apply(diff, [0, diff.length].concat(uniq));
  2366.         return diff;
  2367.     };
  2368.     return Store;
  2369. })();
  2370.  
  2371. },{}],11:[function(require,module,exports){
  2372. "use strict";
  2373. var ATTRIBUTE = require('../attribute/attribute');
  2374. function map(targets, callback, reverse, stack) {
  2375.     if (stack === void 0) { stack = []; }
  2376.     if (targets.length === 0) {
  2377.         return [];
  2378.     }
  2379.     var scrollTop = window.scrollY, scrollLeft = window.scrollX;
  2380.     var keys = 'dsawgvcxlohnmzbptuy'.split(''), container = document.createElement('div'), observer = document.createElement('input'), table = {};
  2381.     observer.style.cssText = [
  2382.         'position: fixed;',
  2383.         'width: 0px;',
  2384.         'height: 0px;',
  2385.         'bottom: 0px;',
  2386.         'right: 0px;',
  2387.         'margin: 0px;',
  2388.         'border-width: 0px;',
  2389.         'padding: 0px;',
  2390.         'z-index: -1;'
  2391.     ]
  2392.         .map(function (str) { return str.split(';')[0] + ' !important;'; })
  2393.         .join('');
  2394.     observer.addEventListener('input', handler);
  2395.     observer.addEventListener('blur', handler);
  2396.     document.body.appendChild(observer);
  2397.     observer.focus();
  2398.     setTimeout(function () { return observer.focus(); }, 1000);
  2399.     var markers = targets.slice(0, keys.length)
  2400.         .map(function (target, i) {
  2401.         var marker = document.createElement('span'), key = keys[i], offset = calOffset(target);
  2402.         marker.classList.add(ATTRIBUTE.MARKER_TAG);
  2403.         marker.classList.add(ATTRIBUTE.MARKER_TAG + '-' + key);
  2404.         marker.style.cssText = [
  2405.             'position: absolute;',
  2406.             'overflow: visible;',
  2407.             'z-index: 9999;',
  2408.             'top: ' + (offset.top - 3) + 'px;',
  2409.             'left: ' + (offset.left - 12) + 'px;',
  2410.             'min-width: 5px;',
  2411.             'margin: 0px;',
  2412.             'border: 0px;',
  2413.             'padding: 1px 3px;',
  2414.             'border-radius: 3px;',
  2415.             'box-shadow: 1px 1px 1px 0px;',
  2416.             'background-color: gold;',
  2417.             'font-family: Helvetica, Arial, sans-serif;',
  2418.             'font-size: 13px;',
  2419.             'font-weight: bold;',
  2420.             'line-height: normal;',
  2421.             'color: black;'
  2422.         ]
  2423.             .map(function (str) { return str.split(';')[0] + ' !important;'; })
  2424.             .join('');
  2425.         marker.textContent = key;
  2426.         table[key] = target;
  2427.         container.appendChild(marker);
  2428.         return target;
  2429.     });
  2430.     document.body.appendChild(container);
  2431.     return markers;
  2432.     function handler(event) {
  2433.         event.preventDefault();
  2434.         event.stopImmediatePropagation();
  2435.         var key = ja2en(event.target.value), shiftKey = key === key.toUpperCase(), target = table[key.toLowerCase()];
  2436.         observer.removeEventListener('keydown', handler);
  2437.         observer.removeEventListener('blur', handler);
  2438.         container.remove();
  2439.         if (key && target) {
  2440.             callback(target, shiftKey);
  2441.         }
  2442.         observer.blur();
  2443.         observer.remove();
  2444.         switch (key) {
  2445.             case !reverse ? 'e' : 'E':
  2446.                 if (targets.length > keys.length) {
  2447.                     map(targets.slice(keys.length), callback, reverse, stack.concat(targets.slice(0, keys.length)));
  2448.                 }
  2449.                 else {
  2450.                     map(stack.concat(targets), callback, reverse);
  2451.                 }
  2452.                 break;
  2453.             case !reverse ? 'E' : 'e':
  2454.                 if (stack.length === 0) {
  2455.                     stack = targets;
  2456.                     targets = [];
  2457.                 }
  2458.                 if (stack.length > keys.length) {
  2459.                     map(stack.slice(-keys.length).concat(targets), callback, reverse, stack.slice(0, Math.max(stack.length - keys.length, 0)));
  2460.                 }
  2461.                 else {
  2462.                     map(stack.concat(targets), callback, reverse);
  2463.                 }
  2464.                 break;
  2465.         }
  2466.     }
  2467.     function calOffset(elem) {
  2468.         var offset = elem.getBoundingClientRect();
  2469.         return {
  2470.             top: scrollTop + offset.top,
  2471.             left: scrollLeft + offset.left,
  2472.             right: scrollLeft + offset.right,
  2473.             bottom: scrollTop + offset.bottom
  2474.         };
  2475.     }
  2476. }
  2477. exports.map = map;
  2478. function ja2en(char) {
  2479.     switch (char) {
  2480.         case 'q':
  2481.             return 'q';
  2482.         case 'Q':
  2483.             return 'Q';
  2484.         case 'w':
  2485.             return 'w';
  2486.         case 'W':
  2487.             return 'W';
  2488.         case 'え':
  2489.             return 'e';
  2490.         case 'E':
  2491.             return 'E';
  2492.         case 'r':
  2493.             return 'r';
  2494.         case 'R':
  2495.             return 'R';
  2496.         case 't':
  2497.             return 't';
  2498.         case 'T':
  2499.             return 'T';
  2500.         case 'y':
  2501.             return 'y';
  2502.         case 'Y':
  2503.             return 'Y';
  2504.         case 'う':
  2505.             return 'u';
  2506.         case 'U':
  2507.             return 'U';
  2508.         case 'い':
  2509.             return 'i';
  2510.         case 'I':
  2511.             return 'I';
  2512.         case 'お':
  2513.             return 'o';
  2514.         case 'O':
  2515.             return 'O';
  2516.         case 'p':
  2517.             return 'p';
  2518.         case 'P':
  2519.             return 'P';
  2520.         case 'あ':
  2521.             return 'a';
  2522.         case 'A':
  2523.             return 'A';
  2524.         case 's':
  2525.             return 's';
  2526.         case 'S':
  2527.             return 'S';
  2528.         case 'd':
  2529.             return 'd';
  2530.         case 'D':
  2531.             return 'D';
  2532.         case 'f':
  2533.             return 'f';
  2534.         case 'F':
  2535.             return 'F';
  2536.         case 'g':
  2537.             return 'g';
  2538.         case 'G':
  2539.             return 'G';
  2540.         case 'h':
  2541.             return 'h';
  2542.         case 'H':
  2543.             return 'H';
  2544.         case 'j':
  2545.             return 'j';
  2546.         case 'J':
  2547.             return 'J';
  2548.         case 'k':
  2549.             return 'k';
  2550.         case 'K':
  2551.             return 'K';
  2552.         case 'l':
  2553.             return 'l';
  2554.         case 'L':
  2555.             return 'L';
  2556.         case 'z':
  2557.             return 'z';
  2558.         case 'Z':
  2559.             return 'Z';
  2560.         case 'x':
  2561.             return 'x';
  2562.         case 'X':
  2563.             return 'X';
  2564.         case 'c':
  2565.             return 'c';
  2566.         case 'C':
  2567.             return 'C';
  2568.         case 'v':
  2569.             return 'v';
  2570.         case 'V':
  2571.             return 'V';
  2572.         case 'b':
  2573.             return 'b';
  2574.         case 'B':
  2575.             return 'B';
  2576.         case 'n':
  2577.             return 'n';
  2578.         case 'N':
  2579.             return 'N';
  2580.         case 'm':
  2581.             return 'm';
  2582.         case 'M':
  2583.             return 'M';
  2584.         default:
  2585.             return char;
  2586.     }
  2587. }
  2588.  
  2589. },{"../attribute/attribute":2}],12:[function(require,module,exports){
  2590. "use strict";
  2591. var ENTITY = require('../entity/entity');
  2592. var ATTRIBUTE = require('../attribute/attribute');
  2593. var MODEL = require('../model/model');
  2594. var CONTROLLER = require('../controller/controller');
  2595. var STATE = require('../state/module');
  2596. var MAP = require('./map');
  2597. var id = 0;
  2598. var views = {};
  2599. exports.state = STATE.state;
  2600. var View = (function () {
  2601.     function View(target) {
  2602.         this.id_ = ++id;
  2603.         this.style = document.createElement('style');
  2604.         views[this.id_] = this;
  2605.         this.target_ = target;
  2606.         this.handler_ = this.handler_.bind(this);
  2607.         this.observe_();
  2608.         this.style.innerHTML = [
  2609.             '.' + ATTRIBUTE.CURSOR_ID + ' {',
  2610.             '  outline: 3px solid gold !important;',
  2611.             '  outline-offset: -2px !important;',
  2612.             '  background-color: rgba(255, 255, 0, 0.4) !important;',
  2613.             '}',
  2614.             'img.' + ATTRIBUTE.CURSOR_ID + ' {',
  2615.             '  outline-offset: -2px !important;',
  2616.             '}'
  2617.         ].join('\n');
  2618.     }
  2619.     View.prototype.handler_ = function (event) {
  2620.         undisplayUrl();
  2621.         if (!exports.state()) {
  2622.             return;
  2623.         }
  2624.         if (event.defaultPrevented) {
  2625.             return;
  2626.         }
  2627.         if (isInserting(event.srcElement)) {
  2628.             return;
  2629.         }
  2630.         var cursor = document.querySelector('.' + ATTRIBUTE.CURSOR_ID), entity = new ENTITY.Entity(this.id_), attribute = ATTRIBUTE.attribute(event, cursor);
  2631.         if (attribute.command === 11 /* INVALID */) {
  2632.             return;
  2633.         }
  2634.         if (!cursor && attribute.command === 8 /* ENTER */) {
  2635.             return;
  2636.         }
  2637.         if (!cursor && attribute.command === 9 /* ENTER_S */) {
  2638.             return;
  2639.         }
  2640.         event.preventDefault();
  2641.         event.stopImmediatePropagation();
  2642.         CONTROLLER.command(entity, attribute);
  2643.         return;
  2644.         function isInserting(elem) {
  2645.             switch (elem.tagName.toLowerCase()) {
  2646.                 case 'input':
  2647.                     switch (elem.getAttribute('type')) {
  2648.                         case 'checkbox':
  2649.                         case 'radio':
  2650.                         case 'file':
  2651.                         case 'submit':
  2652.                         case 'reset':
  2653.                         case 'button':
  2654.                         case 'image':
  2655.                         case 'range':
  2656.                         case 'color':
  2657.                             return false;
  2658.                     }
  2659.                     return true;
  2660.                 case 'select':
  2661.                     return false;
  2662.                 case 'datalist':
  2663.                 case 'option':
  2664.                 case 'textarea':
  2665.                     return true;
  2666.             }
  2667.             switch (elem.getAttribute('role')) {
  2668.                 case 'textbox':
  2669.                     return true;
  2670.             }
  2671.             do {
  2672.                 if (elem.contentEditable === 'true') {
  2673.                     return true;
  2674.                 }
  2675.             } while (elem = elem.parentElement);
  2676.             return false;
  2677.         }
  2678.     };
  2679.     View.prototype.observe_ = function () {
  2680.         this.target_.addEventListener('keydown', this.handler_, true);
  2681.     };
  2682.     View.prototype.release_ = function () {
  2683.         this.target_.removeEventListener('keydown', this.handler_, true);
  2684.     };
  2685.     View.prototype.destructor = function () {
  2686.         this.release_();
  2687.         delete views[this.id_];
  2688.     };
  2689.     View.prototype.update = function (command) {
  2690.         if (!this.style.parentElement) {
  2691.             document.head.appendChild(this.style);
  2692.         }
  2693.         var state = MODEL.store.state(this.id_), diff = MODEL.store.diff(this.id_);
  2694.         var key;
  2695.         while (key = diff.shift()) {
  2696.             switch (key) {
  2697.                 case 'targets':
  2698.                     markTarget(state.targets);
  2699.             }
  2700.         }
  2701.         function markTarget(targets) {
  2702.             switch (command) {
  2703.                 case 0 /* UP */:
  2704.                 case 1 /* UP_S */:
  2705.                 case 2 /* DOWN */:
  2706.                 case 3 /* DOWN_S */:
  2707.                 case 4 /* LEFT */:
  2708.                 case 5 /* RIGHT */:
  2709.                     var target = targets[0];
  2710.                     if (!target) {
  2711.                         break;
  2712.                     }
  2713.                     select(target);
  2714.                     target.scrollIntoViewIfNeeded();
  2715.                     break;
  2716.                 case 6 /* EXPAND */:
  2717.                     MAP.map(targets, trigger, false);
  2718.                     break;
  2719.                 case 7 /* ENTER_C */:
  2720.                     trigger(document.querySelector('.' + ATTRIBUTE.CURSOR_ID), false, true);
  2721.                     break;
  2722.                 case 8 /* ENTER */:
  2723.                     trigger(document.querySelector('.' + ATTRIBUTE.CURSOR_ID), false, false);
  2724.                     break;
  2725.                 case 9 /* ENTER_S */:
  2726.                     trigger(document.querySelector('.' + ATTRIBUTE.CURSOR_ID), true, false);
  2727.                     break;
  2728.                 default:
  2729.                     unselect();
  2730.             }
  2731.             return;
  2732.             function select(elem) {
  2733.                 unselect();
  2734.                 displayUrl(elem);
  2735.                 elem.classList.add(ATTRIBUTE.CURSOR_ID);
  2736.             }
  2737.             function unselect() {
  2738.                 var selector = document.querySelector('.' + ATTRIBUTE.CURSOR_ID);
  2739.                 if (!selector) {
  2740.                     return;
  2741.                 }
  2742.                 selector.classList.remove(ATTRIBUTE.CURSOR_ID);
  2743.                 undisplayUrl();
  2744.             }
  2745.             function trigger(cursor, shiftKey, ctrlKey) {
  2746.                 if (!cursor) {
  2747.                     return;
  2748.                 }
  2749.                 if (!document.elementFromPoint(cursor.getBoundingClientRect().left, cursor.getBoundingClientRect().top)) {
  2750.                     return;
  2751.                 }
  2752.                 if (cursor.tagName.toLowerCase() === 'a'
  2753.                     || cursor.parentElement.tagName.toLowerCase() === 'a'
  2754.                     || cursor.onclick
  2755.                     || cursor.tagName.toLowerCase() === 'option'
  2756.                     || -1 < ['button'].indexOf(cursor.getAttribute('role'))) {
  2757.                     select(cursor);
  2758.                 }
  2759.                 else {
  2760.                     unselect();
  2761.                 }
  2762.                 cursor.focus();
  2763.                 click(cursor, shiftKey, ctrlKey);
  2764.             }
  2765.         }
  2766.     };
  2767.     View.prototype.destroy = function () {
  2768.         this.destructor();
  2769.     };
  2770.     return View;
  2771. })();
  2772. exports.View = View;
  2773. function emit(entity, attribute) {
  2774.     var viewId = entity.viewId;
  2775.     if (viewId in views) {
  2776.         views[viewId].update(attribute.command);
  2777.         return true;
  2778.     }
  2779.     else {
  2780.         return false;
  2781.     }
  2782. }
  2783. exports.emit = emit;
  2784. function displayUrl(cursor) {
  2785.     if (!cursor) {
  2786.         return;
  2787.     }
  2788.     if (cursor.tagName.toLowerCase() !== 'a') {
  2789.         return displayUrl(cursor.parentElement);
  2790.     }
  2791.     var display = document.createElement('span');
  2792.     display.id = ATTRIBUTE.URLDISPLAY_ID;
  2793.     display.style.cssText = [
  2794.         'position: fixed;',
  2795.         'z-index: 9999;',
  2796.         'left: 0px;',
  2797.         'bottom: 0px;',
  2798.         'min-width: 35%;',
  2799.         'padding: 3px 3px 0 3px;',
  2800.         'color: #ececec;',
  2801.         'background-color: #26272A;',
  2802.         'border-radius: 0;',
  2803.         'font-family: Meiryo, Helvetica, sans-serif;',
  2804.         'font-size: 11.5px;',
  2805.         'text-align: left;'
  2806.     ]
  2807.         .map(function (str) { return str.split(';')[0] + ' !important;'; })
  2808.         .join('');
  2809.     display.textContent = cursor.href;
  2810.     document.body.appendChild(display);
  2811. }
  2812. function undisplayUrl() {
  2813.     var display = document.querySelector('#' + ATTRIBUTE.URLDISPLAY_ID);
  2814.     if (!display) {
  2815.         return;
  2816.     }
  2817.     display.remove();
  2818. }
  2819. function click(elem, shiftKey, ctrlKey) {
  2820.     var target = elem.hasAttribute('target') && elem.getAttribute('target');
  2821.     if (elem.tagName.toLowerCase() === 'a') {
  2822.         elem.removeAttribute('target');
  2823.     }
  2824.     ["mouseover", "mousedown", "mouseup", "click"]
  2825.         .forEach(function (sequence) {
  2826.         var mouseEvent = document.createEvent("MouseEvents");
  2827.         mouseEvent.initMouseEvent(sequence, true, true, window, 1, 0, 0, 0, 0, ctrlKey, false, shiftKey, false, 0, null);
  2828.         elem.dispatchEvent(mouseEvent);
  2829.     });
  2830.     if (elem.tagName.toLowerCase() === 'a') {
  2831.         typeof target === 'boolean' ? elem.removeAttribute('target') : elem.setAttribute('target', target);
  2832.     }
  2833. }
  2834.  
  2835. },{"../attribute/attribute":2,"../controller/controller":3,"../entity/entity":5,"../model/model":8,"../state/module":9,"./map":11}]},{},[2,3,4,5,6,7,8,9,10,11,12]);
  2836. }("spatial-navigation", "0.4.7");
RAW Paste Data