API tools faq
paste
Shadrach

Spatial Navigation Extension (Vivaldi)

Shadrach
Mar 14th, 2019
648
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 114.51 KB | None | 0 0
raw download clone embed print report
  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 'ｑ':
  2481.             return 'q';
  2482.         case 'Ｑ':
  2483.             return 'Q';
  2484.         case 'ｗ':
  2485.             return 'w';
  2486.         case 'Ｗ':
  2487.             return 'W';
  2488.         case 'え':
  2489.             return 'e';
  2490.         case 'Ｅ':
  2491.             return 'E';
  2492.         case 'ｒ':
  2493.             return 'r';
  2494.         case 'Ｒ':
  2495.             return 'R';
  2496.         case 'ｔ':
  2497.             return 't';
  2498.         case 'Ｔ':
  2499.             return 'T';
  2500.         case 'ｙ':
  2501.             return 'y';
  2502.         case 'Ｙ':
  2503.             return 'Y';
  2504.         case 'う':
  2505.             return 'u';
  2506.         case 'Ｕ':
  2507.             return 'U';
  2508.         case 'い':
  2509.             return 'i';
  2510.         case 'Ｉ':
  2511.             return 'I';
  2512.         case 'お':
  2513.             return 'o';
  2514.         case 'Ｏ':
  2515.             return 'O';
  2516.         case 'ｐ':
  2517.             return 'p';
  2518.         case 'Ｐ':
  2519.             return 'P';
  2520.         case 'あ':
  2521.             return 'a';
  2522.         case 'Ａ':
  2523.             return 'A';
  2524.         case 'ｓ':
  2525.             return 's';
  2526.         case 'Ｓ':
  2527.             return 'S';
  2528.         case 'ｄ':
  2529.             return 'd';
  2530.         case 'Ｄ':
  2531.             return 'D';
  2532.         case 'ｆ':
  2533.             return 'f';
  2534.         case 'Ｆ':
  2535.             return 'F';
  2536.         case 'ｇ':
  2537.             return 'g';
  2538.         case 'Ｇ':
  2539.             return 'G';
  2540.         case 'ｈ':
  2541.             return 'h';
  2542.         case 'Ｈ':
  2543.             return 'H';
  2544.         case 'ｊ':
  2545.             return 'j';
  2546.         case 'Ｊ':
  2547.             return 'J';
  2548.         case 'ｋ':
  2549.             return 'k';
  2550.         case 'Ｋ':
  2551.             return 'K';
  2552.         case 'ｌ':
  2553.             return 'l';
  2554.         case 'Ｌ':
  2555.             return 'L';
  2556.         case 'ｚ':
  2557.             return 'z';
  2558.         case 'Ｚ':
  2559.             return 'Z';
  2560.         case 'ｘ':
  2561.             return 'x';
  2562.         case 'Ｘ':
  2563.             return 'X';
  2564.         case 'ｃ':
  2565.             return 'c';
  2566.         case 'Ｃ':
  2567.             return 'C';
  2568.         case 'ｖ':
  2569.             return 'v';
  2570.         case 'Ｖ':
  2571.             return 'V';
  2572.         case 'ｂ':
  2573.             return 'b';
  2574.         case 'Ｂ':
  2575.             return 'B';
  2576.         case 'ｎ':
  2577.             return 'n';
  2578.         case 'Ｎ':
  2579.             return 'N';
  2580.         case 'ｍ':
  2581.             return 'm';
  2582.         case 'Ｍ':
  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");
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!