{"version":3,"file":"js/contributors-graph.xxxxxxxx.js","mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AAC8B;AAC+D;;AAE7F;AACA;AACA;;AAEA;AACA,WAAW,iBAAiB;AAC5B,WAAW,QAAQ;AACnB,WAAW,0BAA0B;AACrC,aAAa;AACb;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA,IAAI;AACJ,iBAAiB,MAAM;AACvB;;AAEA;AACA;;AAEA;AACA;AACA,iBAAiB,MAAM;AACvB;AACA;AACA,YAAY;AACZ;;AAEA,UAAU;AACV;;AAEA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,YAAY,uBAAuB;AACnC,WAAW,0BAA0B;AACrC,YAAY;AACZ;AACA,6BAA6B,KAAK;AAClC;AACA;AACA,kBAAkB,qBAAqB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY,uBAAuB;AACnC,WAAW,0BAA0B;AACrC,YAAY;AACZ;AACA;AACA,SAAS,uCAAuC;AAChD;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,EAAE,sDAAI;AACN;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,4BAA4B;AAC5B,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAY,gEAAc;AAC1B;AACA,SAAS,gEAAc;AACvB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6BAA6B,SAAS;AACtC;AACA,SAAS,8BAA8B;;AAEvC;AACA,SAAS,cAAc;AACvB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA,wCAAwC;;AAExC;AACA;AACA;;AAEA;AACA;AACA,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO,UAAU;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA,6BAA6B,SAAS;AACtC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,uCAAuC;AAChD;AACA;AACA;AACA;AACA,SAAS,qDAAqD;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,yBAAyB;AACtD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,cAAc,WAAW;AAClC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,EAAE,sDAAI;AACN;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA,SAAS,QAAQ;AACjB,SAAS,yCAAyC;;AAElD,EAAE,sDAAI;AACN;AACA;AACA,cAAc,6CAA6C;AAC3D,cAAc,6CAA6C;AAC3D;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAE,0DAAQ;AACV;;AAEA;AACA;AACA,EAAE,0DAAQ;AACV;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,UAAU,sCAAsC,wBAAwB;AACnF,WAAW,QAAQ;AACnB;AACA;AACA,SAAS,6CAA6C,gCAAgC,sBAAsB;AAC5G;AACA,SAAS,UAAU,4BAA4B;;AAE/C;;AAEA;AACA;AACA;;AAEA,EAAE,sDAAI;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,GAAG;;AAEH;;AAEA,EAAE,0DAAQ,uBAAuB,MAAM;AACvC;;AAEA;AACA;AACA,SAAS,UAAU,4BAA4B;AAC/C,SAAS,aAAa;;AAEtB;AACA;AACA;;AAEA,EAAE,sDAAI;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,GAAG;;AAEH;;AAEA,EAAE,0DAAQ,uBAAuB,MAAM;AACvC;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,EAAE,sDAAI;AACN;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,GAAG;AACH;AACA,EAAE,0DAAQ,sCAAsC,MAAM;AACtD;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS,UAAU;AACnB,SAAS,gEAAc,2BAA2B,gEAAc;AAChE;;AAEA;AACA;AACA;AACA;AACA,EAAE,sDAAI;AACN;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA,SAAS,UAAU;AACnB;AACA;AACA,MAAM,sDAAI,kBAAkB,sDAAI;AAChC;AACA;AACA;AACA,MAAM,0DAAQ;AACd;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;AACA,SAAS,cAAc,+BAA+B,oBAAoB;AAC1E;AACA,SAAS,UAAU,0BAA0B;AAC7C,SAAS,OAAO;;AAEhB;;AAEA;AACA;;AAEA,EAAE,sDAAI;AACN;AACA;AACA,MAAM;AACN;AACA;AACA,GAAG;;AAEH;;AAEA,EAAE,0DAAQ,UAAU,MAAM;AAC1B;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,UAAU,yCAAyC,OAAO;AACrE,4BAA4B;AAC5B;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,oCAAoC;;AAE/C;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,SAAS,UAAU;AACnB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,mBAAmB;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,6BAA6B;AACtC;AACA,kBAAkB,qEAAmB;AACrC,QAAQ,0DAAQ,gBAAgB,oBAAoB;AACpD,MAAM,0DAAQ,mBAAmB,aAAa;AAC9C;AACA;AACA;AACA;;AAEA;AACA;AACA,SAAS,yCAAyC;AAClD;AACA;AACA;AACA;AACA;AACA,WAAW,0DAAQ,+BAA+B,aAAa;AAC/D;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO,kEAAkE;;AAEzE,qBAAqB,qEAAmB;AACxC,mBAAmB,qEAAmB;;AAEtC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,6BAA6B,gBAAgB;AACtD;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,mBAAmB,0BAA0B,GAAG,8BAA8B;;AAE9E;AACA,EAAE,0DAAQ,mBAAmB,MAAM;AACnC;;AAEA;AACA;AACA;AACA,IAAI,0DAAQ,+BAA+B,aAAa;AACxD;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,SAAS,WAAW,eAAe,YAAY,oBAAoB;;AAEnE;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,oDAAoD,0DAAQ,YAAY,MAAM;AAC9E;AACA;;AAEA;AACA;AACA,SAAS,wDAAwD;;AAEjE;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,yCAAyC;AACpD;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA,MAAM,0DAAQ,6BAA6B,aAAa;AACxD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA,IAAI;AACJ;AACA;AACA,UAAU;AACV;;AAEA;AACA;AACA,WAAW,kBAAkB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAwB;AACxB,IAAI,0DAAQ,sCAAsC,MAAM;AACxD;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB,6CAA6C;AAC7D,mBAAmB;AACnB;AACA;;AAEA;AACA,SAAS,oCAAoC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,MAAM,0DAAQ,eAAe,oBAAoB;AACjD,WAAW,0DAAQ,kBAAkB,aAAa;AAClD;;AAEA;AACA,iBAAiB;AACjB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI,0DAAQ,oCAAoC,MAAM;AACtD;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS,oCAAoC;;AAE7C,iBAAiB,yDAAc;AAC/B;AACA,eAAe,uDAAY;AAC3B;AACA;AACA;AACA;;AAEA;AACA,eAAe,qDAAU;AACzB;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,SAAS,oBAAoB;;AAE7B;AACA;AACA;AACA,SAAS,0BAA0B;AACnC;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA,GAAG;;AAEH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ACA;AACA,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,UAAU;;AAE/D;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,WAAW;AACtB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B,0BAA0B;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;;AAEA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,kBAAkB;AAC7B,WAAW,OAAO;AAClB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,aAAa;AACxB,YAAY,SAAS;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,YAAY,gBAAgB;AAC5B;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO,MAAM,KAAK,EAAE,KAAK,EAAE,KAAK;AAC3C,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,OAAO,EAAE,KAAK,EAAE,KAAK;AAClC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,aAAa;AACb;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,kBAAkB;AAC/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,aAAa;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,UAAU;AACrB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,2BAA2B;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,YAAY,QAAQ;AACpB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ,IAAI;AACvB,WAAW,QAAQ,IAAI;AACvB,WAAW,OAAO;AAClB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,OAAO;AAClB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,YAAY,QAAQ;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0BAA0B;;AAE1B;AACA;;AAEA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,CAAC;;AAED;AACA,UAAU;AACV,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,iBAAiB;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,CAAC;;AAED;AACA,UAAU;AACV,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,iBAAiB;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;;AAEA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oBAAoB,6BAA6B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA;AACA,4BAA4B,8BAA8B;;AAE1D;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA,gBAAgB;;AAEhB;AACA;AACA,eAAe,QAAQ;AACvB,gBAAgB;AAChB;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB;AACjB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,kCAAkC;;AAElC,qCAAqC;AACrC;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA,sCAAsC;;AAEtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB,OAAO;AACxB;AACA,oCAAoC;;AAEpC;AACA;AACA;AACA,iBAAiB;AACjB;AACA,kCAAkC;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,OAAO;AAClB,aAAa;AACb;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,mBAAmB;AAC9B,WAAW,YAAY;AACvB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB,GAAG;AACpB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,aAAa;AACb,UAAU;AACV;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,WAAW,aAAa;AACxB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA,cAAc;AACd;AACA;AACA;;AAEA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C,2BAA2B,cAAc;AACzC,2BAA2B,gCAAgC;AAC3D,yBAAyB,gCAAgC;AACzD;AACA,yBAAyB,4BAA4B;AACrD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,aAAa;AACxB,WAAW,QAAQ;AACnB;AACA;AACA;AACA,4BAA4B,gCAAgC;;AAE5D;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,eAAe,QAAQ;AACvB,iBAAiB;AACjB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,mBAAmB;AAClC,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA,wBAAwB,wBAAwB;AAChD;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,eAAe,YAAY;AAC3B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,mBAAmB;AAClC,iBAAiB;AACjB;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,UAAU;AACzB,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,UAAU;AACzB,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL;AACA;AACA,eAAe,QAAQ;AACvB,eAAe,QAAQ;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,SAAS;AACpB,WAAW,SAAS;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,mGAAmG,IAAI;AACvG;;AAEA,IAAI,IAA0C;AAC9C,IAAI,mCAAO;AACX;AACA,KAAK;AAAA,kGAAC;AACN,EAAE,KAAK,EAIN;;AAED,CAAC;;;;;;;;;;;;;ACllFD;;;;;;;;;;;;;;;;;ACAyF;AACtB;AACL;;AAE9D,CAAuF;;AAEJ;AACnF,iCAAiC,yFAAe,CAAC,qFAAM,aAAa,mGAAM;AAC1E;AACA,IAAI,KAAU,EAAE,EAYf;;;AAGD,+DAAe;;;;;;;;;;;;;;;;ACxBmM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AGAlN;AACA;AACA;AACA;AACA;AACA;AACm3E;AAC51E;AACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACRmC","sources":["webpack:///./node_modules/chartjs-plugin-zoom/dist/chartjs-plugin-zoom.esm.js","webpack:///./web_src/js/components/RepoContributors.vue","webpack:///./node_modules/hammerjs/hammer.js","webpack:///./web_src/js/components/RepoContributors.vue?e06e","webpack:///./web_src/js/components/RepoContributors.vue?788b","webpack:///./web_src/js/components/RepoContributors.vue?b2f6","webpack:///./web_src/js/components/RepoContributors.vue?24a7","webpack:///./web_src/js/components/RepoContributors.vue?ea60","webpack:///./node_modules/chart.js/dist/helpers.js","webpack:///./node_modules/chart.js/helpers/helpers.js"],"sourcesContent":["/*!\n* chartjs-plugin-zoom v2.0.1\n* undefined\n * (c) 2016-2023 chartjs-plugin-zoom Contributors\n * Released under the MIT License\n */\nimport Hammer from 'hammerjs';\nimport { each, valueOrDefault, callback, sign, getRelativePosition } from 'chart.js/helpers';\n\nconst getModifierKey = opts => opts && opts.enabled && opts.modifierKey;\nconst keyPressed = (key, event) => key && event[key + 'Key'];\nconst keyNotPressed = (key, event) => key && !event[key + 'Key'];\n\n/**\n * @param {string|function} mode can be 'x', 'y' or 'xy'\n * @param {string} dir can be 'x' or 'y'\n * @param {import('chart.js').Chart} chart instance of the chart in question\n * @returns {boolean}\n */\nfunction directionEnabled(mode, dir, chart) {\n if (mode === undefined) {\n return true;\n } else if (typeof mode === 'string') {\n return mode.indexOf(dir) !== -1;\n } else if (typeof mode === 'function') {\n return mode({chart}).indexOf(dir) !== -1;\n }\n\n return false;\n}\n\nfunction directionsEnabled(mode, chart) {\n if (typeof mode === 'function') {\n mode = mode({chart});\n }\n if (typeof mode === 'string') {\n return {x: mode.indexOf('x') !== -1, y: mode.indexOf('y') !== -1};\n }\n\n return {x: false, y: false};\n}\n\n/**\n * Debounces calling `fn` for `delay` ms\n * @param {function} fn - Function to call. No arguments are passed.\n * @param {number} delay - Delay in ms. 0 = immediate invocation.\n * @returns {function}\n */\nfunction debounce(fn, delay) {\n let timeout;\n return function() {\n clearTimeout(timeout);\n timeout = setTimeout(fn, delay);\n return delay;\n };\n}\n\n/**\n * Checks which axis is under the mouse cursor.\n * @param {{x: number, y: number}} point - the mouse location\n * @param {import('chart.js').Chart} [chart] instance of the chart in question\n * @return {import('chart.js').Scale}\n */\nfunction getScaleUnderPoint({x, y}, chart) {\n const scales = chart.scales;\n const scaleIds = Object.keys(scales);\n for (let i = 0; i < scaleIds.length; i++) {\n const scale = scales[scaleIds[i]];\n if (y >= scale.top && y <= scale.bottom && x >= scale.left && x <= scale.right) {\n return scale;\n }\n }\n return null;\n}\n\n/**\n * Evaluate the chart's mode, scaleMode, and overScaleMode properties to\n * determine which axes are eligible for scaling.\n * options.overScaleMode can be a function if user want zoom only one scale of many for example.\n * @param options - Zoom or pan options\n * @param {{x: number, y: number}} point - the mouse location\n * @param {import('chart.js').Chart} [chart] instance of the chart in question\n * @return {import('chart.js').Scale[]}\n */\nfunction getEnabledScalesByPoint(options, point, chart) {\n const {mode = 'xy', scaleMode, overScaleMode} = options || {};\n const scale = getScaleUnderPoint(point, chart);\n\n const enabled = directionsEnabled(mode, chart);\n const scaleEnabled = directionsEnabled(scaleMode, chart);\n\n // Convert deprecated overScaleEnabled to new scaleEnabled.\n if (overScaleMode) {\n const overScaleEnabled = directionsEnabled(overScaleMode, chart);\n for (const axis of ['x', 'y']) {\n if (overScaleEnabled[axis]) {\n scaleEnabled[axis] = enabled[axis];\n enabled[axis] = false;\n }\n }\n }\n\n if (scale && scaleEnabled[scale.axis]) {\n return [scale];\n }\n\n const enabledScales = [];\n each(chart.scales, function(scaleItem) {\n if (enabled[scaleItem.axis]) {\n enabledScales.push(scaleItem);\n }\n });\n return enabledScales;\n}\n\nconst chartStates = new WeakMap();\n\nfunction getState(chart) {\n let state = chartStates.get(chart);\n if (!state) {\n state = {\n originalScaleLimits: {},\n updatedScaleLimits: {},\n handlers: {},\n panDelta: {}\n };\n chartStates.set(chart, state);\n }\n return state;\n}\n\nfunction removeState(chart) {\n chartStates.delete(chart);\n}\n\nfunction zoomDelta(scale, zoom, center) {\n const range = scale.max - scale.min;\n const newRange = range * (zoom - 1);\n\n const centerPoint = scale.isHorizontal() ? center.x : center.y;\n // `scale.getValueForPixel()` can return a value less than the `scale.min` or\n // greater than `scale.max` when `centerPoint` is outside chartArea.\n const minPercent = Math.max(0, Math.min(1,\n (scale.getValueForPixel(centerPoint) - scale.min) / range || 0\n ));\n\n const maxPercent = 1 - minPercent;\n\n return {\n min: newRange * minPercent,\n max: newRange * maxPercent\n };\n}\n\nfunction getLimit(state, scale, scaleLimits, prop, fallback) {\n let limit = scaleLimits[prop];\n if (limit === 'original') {\n const original = state.originalScaleLimits[scale.id][prop];\n limit = valueOrDefault(original.options, original.scale);\n }\n return valueOrDefault(limit, fallback);\n}\n\nfunction getRange(scale, pixel0, pixel1) {\n const v0 = scale.getValueForPixel(pixel0);\n const v1 = scale.getValueForPixel(pixel1);\n return {\n min: Math.min(v0, v1),\n max: Math.max(v0, v1)\n };\n}\n\nfunction updateRange(scale, {min, max}, limits, zoom = false) {\n const state = getState(scale.chart);\n const {id, axis, options: scaleOpts} = scale;\n\n const scaleLimits = limits && (limits[id] || limits[axis]) || {};\n const {minRange = 0} = scaleLimits;\n const minLimit = getLimit(state, scale, scaleLimits, 'min', -Infinity);\n const maxLimit = getLimit(state, scale, scaleLimits, 'max', Infinity);\n\n const range = zoom ? Math.max(max - min, minRange) : scale.max - scale.min;\n const offset = (range - max + min) / 2;\n min -= offset;\n max += offset;\n\n if (min < minLimit) {\n min = minLimit;\n max = Math.min(minLimit + range, maxLimit);\n } else if (max > maxLimit) {\n max = maxLimit;\n min = Math.max(maxLimit - range, minLimit);\n }\n scaleOpts.min = min;\n scaleOpts.max = max;\n\n state.updatedScaleLimits[scale.id] = {min, max};\n\n // return true if the scale range is changed\n return scale.parse(min) !== scale.min || scale.parse(max) !== scale.max;\n}\n\nfunction zoomNumericalScale(scale, zoom, center, limits) {\n const delta = zoomDelta(scale, zoom, center);\n const newRange = {min: scale.min + delta.min, max: scale.max - delta.max};\n return updateRange(scale, newRange, limits, true);\n}\n\nfunction zoomRectNumericalScale(scale, from, to, limits) {\n updateRange(scale, getRange(scale, from, to), limits, true);\n}\n\nconst integerChange = (v) => v === 0 || isNaN(v) ? 0 : v < 0 ? Math.min(Math.round(v), -1) : Math.max(Math.round(v), 1);\n\nfunction existCategoryFromMaxZoom(scale) {\n const labels = scale.getLabels();\n const maxIndex = labels.length - 1;\n\n if (scale.min > 0) {\n scale.min -= 1;\n }\n if (scale.max < maxIndex) {\n scale.max += 1;\n }\n}\n\nfunction zoomCategoryScale(scale, zoom, center, limits) {\n const delta = zoomDelta(scale, zoom, center);\n if (scale.min === scale.max && zoom < 1) {\n existCategoryFromMaxZoom(scale);\n }\n const newRange = {min: scale.min + integerChange(delta.min), max: scale.max - integerChange(delta.max)};\n return updateRange(scale, newRange, limits, true);\n}\n\nfunction scaleLength(scale) {\n return scale.isHorizontal() ? scale.width : scale.height;\n}\n\nfunction panCategoryScale(scale, delta, limits) {\n const labels = scale.getLabels();\n const lastLabelIndex = labels.length - 1;\n let {min, max} = scale;\n // The visible range. Ticks can be skipped, and thus not reliable.\n const range = Math.max(max - min, 1);\n // How many pixels of delta is required before making a step. stepSize, but limited to max 1/10 of the scale length.\n const stepDelta = Math.round(scaleLength(scale) / Math.max(range, 10));\n const stepSize = Math.round(Math.abs(delta / stepDelta));\n let applied;\n if (delta < -stepDelta) {\n max = Math.min(max + stepSize, lastLabelIndex);\n min = range === 1 ? max : max - range;\n applied = max === lastLabelIndex;\n } else if (delta > stepDelta) {\n min = Math.max(0, min - stepSize);\n max = range === 1 ? min : min + range;\n applied = min === 0;\n }\n\n return updateRange(scale, {min, max}, limits) || applied;\n}\n\nconst OFFSETS = {\n second: 500, // 500 ms\n minute: 30 * 1000, // 30 s\n hour: 30 * 60 * 1000, // 30 m\n day: 12 * 60 * 60 * 1000, // 12 h\n week: 3.5 * 24 * 60 * 60 * 1000, // 3.5 d\n month: 15 * 24 * 60 * 60 * 1000, // 15 d\n quarter: 60 * 24 * 60 * 60 * 1000, // 60 d\n year: 182 * 24 * 60 * 60 * 1000 // 182 d\n};\n\nfunction panNumericalScale(scale, delta, limits, canZoom = false) {\n const {min: prevStart, max: prevEnd, options} = scale;\n const round = options.time && options.time.round;\n const offset = OFFSETS[round] || 0;\n const newMin = scale.getValueForPixel(scale.getPixelForValue(prevStart + offset) - delta);\n const newMax = scale.getValueForPixel(scale.getPixelForValue(prevEnd + offset) - delta);\n const {min: minLimit = -Infinity, max: maxLimit = Infinity} = canZoom && limits && limits[scale.axis] || {};\n if (isNaN(newMin) || isNaN(newMax) || newMin < minLimit || newMax > maxLimit) {\n // At limit: No change but return true to indicate no need to store the delta.\n // NaN can happen for 0-dimension scales (either because they were configured\n // with min === max or because the chart has 0 plottable area).\n return true;\n }\n return updateRange(scale, {min: newMin, max: newMax}, limits, canZoom);\n}\n\nfunction panNonLinearScale(scale, delta, limits) {\n return panNumericalScale(scale, delta, limits, true);\n}\n\nconst zoomFunctions = {\n category: zoomCategoryScale,\n default: zoomNumericalScale,\n};\n\nconst zoomRectFunctions = {\n default: zoomRectNumericalScale,\n};\n\nconst panFunctions = {\n category: panCategoryScale,\n default: panNumericalScale,\n logarithmic: panNonLinearScale,\n timeseries: panNonLinearScale,\n};\n\nfunction shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits) {\n const {id, options: {min, max}} = scale;\n if (!originalScaleLimits[id] || !updatedScaleLimits[id]) {\n return true;\n }\n const previous = updatedScaleLimits[id];\n return previous.min !== min || previous.max !== max;\n}\n\nfunction removeMissingScales(limits, scales) {\n each(limits, (opt, key) => {\n if (!scales[key]) {\n delete limits[key];\n }\n });\n}\n\nfunction storeOriginalScaleLimits(chart, state) {\n const {scales} = chart;\n const {originalScaleLimits, updatedScaleLimits} = state;\n\n each(scales, function(scale) {\n if (shouldUpdateScaleLimits(scale, originalScaleLimits, updatedScaleLimits)) {\n originalScaleLimits[scale.id] = {\n min: {scale: scale.min, options: scale.options.min},\n max: {scale: scale.max, options: scale.options.max},\n };\n }\n });\n\n removeMissingScales(originalScaleLimits, scales);\n removeMissingScales(updatedScaleLimits, scales);\n return originalScaleLimits;\n}\n\nfunction doZoom(scale, amount, center, limits) {\n const fn = zoomFunctions[scale.type] || zoomFunctions.default;\n callback(fn, [scale, amount, center, limits]);\n}\n\nfunction doZoomRect(scale, amount, from, to, limits) {\n const fn = zoomRectFunctions[scale.type] || zoomRectFunctions.default;\n callback(fn, [scale, amount, from, to, limits]);\n}\n\nfunction getCenter(chart) {\n const ca = chart.chartArea;\n return {\n x: (ca.left + ca.right) / 2,\n y: (ca.top + ca.bottom) / 2,\n };\n}\n\n/**\n * @param chart The chart instance\n * @param {number | {x?: number, y?: number, focalPoint?: {x: number, y: number}}} amount The zoom percentage or percentages and focal point\n * @param {string} [transition] Which transition mode to use. Defaults to 'none'\n */\nfunction zoom(chart, amount, transition = 'none') {\n const {x = 1, y = 1, focalPoint = getCenter(chart)} = typeof amount === 'number' ? {x: amount, y: amount} : amount;\n const state = getState(chart);\n const {options: {limits, zoom: zoomOptions}} = state;\n\n storeOriginalScaleLimits(chart, state);\n\n const xEnabled = x !== 1;\n const yEnabled = y !== 1;\n const enabledScales = getEnabledScalesByPoint(zoomOptions, focalPoint, chart);\n\n each(enabledScales || chart.scales, function(scale) {\n if (scale.isHorizontal() && xEnabled) {\n doZoom(scale, x, focalPoint, limits);\n } else if (!scale.isHorizontal() && yEnabled) {\n doZoom(scale, y, focalPoint, limits);\n }\n });\n\n chart.update(transition);\n\n callback(zoomOptions.onZoom, [{chart}]);\n}\n\nfunction zoomRect(chart, p0, p1, transition = 'none') {\n const state = getState(chart);\n const {options: {limits, zoom: zoomOptions}} = state;\n const {mode = 'xy'} = zoomOptions;\n\n storeOriginalScaleLimits(chart, state);\n const xEnabled = directionEnabled(mode, 'x', chart);\n const yEnabled = directionEnabled(mode, 'y', chart);\n\n each(chart.scales, function(scale) {\n if (scale.isHorizontal() && xEnabled) {\n doZoomRect(scale, p0.x, p1.x, limits);\n } else if (!scale.isHorizontal() && yEnabled) {\n doZoomRect(scale, p0.y, p1.y, limits);\n }\n });\n\n chart.update(transition);\n\n callback(zoomOptions.onZoom, [{chart}]);\n}\n\nfunction zoomScale(chart, scaleId, range, transition = 'none') {\n storeOriginalScaleLimits(chart, getState(chart));\n const scale = chart.scales[scaleId];\n updateRange(scale, range, undefined, true);\n chart.update(transition);\n}\n\nfunction resetZoom(chart, transition = 'default') {\n const state = getState(chart);\n const originalScaleLimits = storeOriginalScaleLimits(chart, state);\n\n each(chart.scales, function(scale) {\n const scaleOptions = scale.options;\n if (originalScaleLimits[scale.id]) {\n scaleOptions.min = originalScaleLimits[scale.id].min.options;\n scaleOptions.max = originalScaleLimits[scale.id].max.options;\n } else {\n delete scaleOptions.min;\n delete scaleOptions.max;\n }\n });\n chart.update(transition);\n callback(state.options.zoom.onZoomComplete, [{chart}]);\n}\n\nfunction getOriginalRange(state, scaleId) {\n const original = state.originalScaleLimits[scaleId];\n if (!original) {\n return;\n }\n const {min, max} = original;\n return valueOrDefault(max.options, max.scale) - valueOrDefault(min.options, min.scale);\n}\n\nfunction getZoomLevel(chart) {\n const state = getState(chart);\n let min = 1;\n let max = 1;\n each(chart.scales, function(scale) {\n const origRange = getOriginalRange(state, scale.id);\n if (origRange) {\n const level = Math.round(origRange / (scale.max - scale.min) * 100) / 100;\n min = Math.min(min, level);\n max = Math.max(max, level);\n }\n });\n return min < 1 ? min : max;\n}\n\nfunction panScale(scale, delta, limits, state) {\n const {panDelta} = state;\n // Add possible cumulative delta from previous pan attempts where scale did not change\n const storedDelta = panDelta[scale.id] || 0;\n if (sign(storedDelta) === sign(delta)) {\n delta += storedDelta;\n }\n const fn = panFunctions[scale.type] || panFunctions.default;\n if (callback(fn, [scale, delta, limits])) {\n // The scale changed, reset cumulative delta\n panDelta[scale.id] = 0;\n } else {\n // The scale did not change, store cumulative delta\n panDelta[scale.id] = delta;\n }\n}\n\nfunction pan(chart, delta, enabledScales, transition = 'none') {\n const {x = 0, y = 0} = typeof delta === 'number' ? {x: delta, y: delta} : delta;\n const state = getState(chart);\n const {options: {pan: panOptions, limits}} = state;\n const {onPan} = panOptions || {};\n\n storeOriginalScaleLimits(chart, state);\n\n const xEnabled = x !== 0;\n const yEnabled = y !== 0;\n\n each(enabledScales || chart.scales, function(scale) {\n if (scale.isHorizontal() && xEnabled) {\n panScale(scale, x, limits, state);\n } else if (!scale.isHorizontal() && yEnabled) {\n panScale(scale, y, limits, state);\n }\n });\n\n chart.update(transition);\n\n callback(onPan, [{chart}]);\n}\n\nfunction getInitialScaleBounds(chart) {\n const state = getState(chart);\n storeOriginalScaleLimits(chart, state);\n const scaleBounds = {};\n for (const scaleId of Object.keys(chart.scales)) {\n const {min, max} = state.originalScaleLimits[scaleId] || {min: {}, max: {}};\n scaleBounds[scaleId] = {min: min.scale, max: max.scale};\n }\n\n return scaleBounds;\n}\n\nfunction isZoomedOrPanned(chart) {\n const scaleBounds = getInitialScaleBounds(chart);\n for (const scaleId of Object.keys(chart.scales)) {\n const {min: originalMin, max: originalMax} = scaleBounds[scaleId];\n\n if (originalMin !== undefined && chart.scales[scaleId].min !== originalMin) {\n return true;\n }\n\n if (originalMax !== undefined && chart.scales[scaleId].max !== originalMax) {\n return true;\n }\n }\n\n return false;\n}\n\nfunction removeHandler(chart, type) {\n const {handlers} = getState(chart);\n const handler = handlers[type];\n if (handler && handler.target) {\n handler.target.removeEventListener(type, handler);\n delete handlers[type];\n }\n}\n\nfunction addHandler(chart, target, type, handler) {\n const {handlers, options} = getState(chart);\n const oldHandler = handlers[type];\n if (oldHandler && oldHandler.target === target) {\n // already attached\n return;\n }\n removeHandler(chart, type);\n handlers[type] = (event) => handler(chart, event, options);\n handlers[type].target = target;\n target.addEventListener(type, handlers[type]);\n}\n\nfunction mouseMove(chart, event) {\n const state = getState(chart);\n if (state.dragStart) {\n state.dragging = true;\n state.dragEnd = event;\n chart.update('none');\n }\n}\n\nfunction keyDown(chart, event) {\n const state = getState(chart);\n if (!state.dragStart || event.key !== 'Escape') {\n return;\n }\n\n removeHandler(chart, 'keydown');\n state.dragging = false;\n state.dragStart = state.dragEnd = null;\n chart.update('none');\n}\n\nfunction zoomStart(chart, event, zoomOptions) {\n const {onZoomStart, onZoomRejected} = zoomOptions;\n if (onZoomStart) {\n const point = getRelativePosition(event, chart);\n if (callback(onZoomStart, [{chart, event, point}]) === false) {\n callback(onZoomRejected, [{chart, event}]);\n return false;\n }\n }\n}\n\nfunction mouseDown(chart, event) {\n const state = getState(chart);\n const {pan: panOptions, zoom: zoomOptions = {}} = state.options;\n if (\n event.button !== 0 ||\n keyPressed(getModifierKey(panOptions), event) ||\n keyNotPressed(getModifierKey(zoomOptions.drag), event)\n ) {\n return callback(zoomOptions.onZoomRejected, [{chart, event}]);\n }\n\n if (zoomStart(chart, event, zoomOptions) === false) {\n return;\n }\n state.dragStart = event;\n\n addHandler(chart, chart.canvas, 'mousemove', mouseMove);\n addHandler(chart, window.document, 'keydown', keyDown);\n}\n\nfunction computeDragRect(chart, mode, beginPointEvent, endPointEvent) {\n const xEnabled = directionEnabled(mode, 'x', chart);\n const yEnabled = directionEnabled(mode, 'y', chart);\n let {top, left, right, bottom, width: chartWidth, height: chartHeight} = chart.chartArea;\n\n const beginPoint = getRelativePosition(beginPointEvent, chart);\n const endPoint = getRelativePosition(endPointEvent, chart);\n\n if (xEnabled) {\n left = Math.min(beginPoint.x, endPoint.x);\n right = Math.max(beginPoint.x, endPoint.x);\n }\n\n if (yEnabled) {\n top = Math.min(beginPoint.y, endPoint.y);\n bottom = Math.max(beginPoint.y, endPoint.y);\n }\n const width = right - left;\n const height = bottom - top;\n\n return {\n left,\n top,\n right,\n bottom,\n width,\n height,\n zoomX: xEnabled && width ? 1 + ((chartWidth - width) / chartWidth) : 1,\n zoomY: yEnabled && height ? 1 + ((chartHeight - height) / chartHeight) : 1\n };\n}\n\nfunction mouseUp(chart, event) {\n const state = getState(chart);\n if (!state.dragStart) {\n return;\n }\n\n removeHandler(chart, 'mousemove');\n const {mode, onZoomComplete, drag: {threshold = 0}} = state.options.zoom;\n const rect = computeDragRect(chart, mode, state.dragStart, event);\n const distanceX = directionEnabled(mode, 'x', chart) ? rect.width : 0;\n const distanceY = directionEnabled(mode, 'y', chart) ? rect.height : 0;\n const distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY);\n\n // Remove drag start and end before chart update to stop drawing selected area\n state.dragStart = state.dragEnd = null;\n\n if (distance <= threshold) {\n state.dragging = false;\n chart.update('none');\n return;\n }\n\n zoomRect(chart, {x: rect.left, y: rect.top}, {x: rect.right, y: rect.bottom}, 'zoom');\n\n setTimeout(() => (state.dragging = false), 500);\n callback(onZoomComplete, [{chart}]);\n}\n\nfunction wheelPreconditions(chart, event, zoomOptions) {\n // Before preventDefault, check if the modifier key required and pressed\n if (keyNotPressed(getModifierKey(zoomOptions.wheel), event)) {\n callback(zoomOptions.onZoomRejected, [{chart, event}]);\n return;\n }\n\n if (zoomStart(chart, event, zoomOptions) === false) {\n return;\n }\n\n // Prevent the event from triggering the default behavior (e.g. content scrolling).\n if (event.cancelable) {\n event.preventDefault();\n }\n\n // Firefox always fires the wheel event twice:\n // First without the delta and right after that once with the delta properties.\n if (event.deltaY === undefined) {\n return;\n }\n return true;\n}\n\nfunction wheel(chart, event) {\n const {handlers: {onZoomComplete}, options: {zoom: zoomOptions}} = getState(chart);\n\n if (!wheelPreconditions(chart, event, zoomOptions)) {\n return;\n }\n\n const rect = event.target.getBoundingClientRect();\n const speed = 1 + (event.deltaY >= 0 ? -zoomOptions.wheel.speed : zoomOptions.wheel.speed);\n const amount = {\n x: speed,\n y: speed,\n focalPoint: {\n x: event.clientX - rect.left,\n y: event.clientY - rect.top\n }\n };\n\n zoom(chart, amount);\n\n if (onZoomComplete) {\n onZoomComplete();\n }\n}\n\nfunction addDebouncedHandler(chart, name, handler, delay) {\n if (handler) {\n getState(chart).handlers[name] = debounce(() => callback(handler, [{chart}]), delay);\n }\n}\n\nfunction addListeners(chart, options) {\n const canvas = chart.canvas;\n const {wheel: wheelOptions, drag: dragOptions, onZoomComplete} = options.zoom;\n\n // Install listeners. Do this dynamically based on options so that we can turn zoom on and off\n // We also want to make sure listeners aren't always on. E.g. if you're scrolling down a page\n // and the mouse goes over a chart you don't want it intercepted unless the plugin is enabled\n if (wheelOptions.enabled) {\n addHandler(chart, canvas, 'wheel', wheel);\n addDebouncedHandler(chart, 'onZoomComplete', onZoomComplete, 250);\n } else {\n removeHandler(chart, 'wheel');\n }\n if (dragOptions.enabled) {\n addHandler(chart, canvas, 'mousedown', mouseDown);\n addHandler(chart, canvas.ownerDocument, 'mouseup', mouseUp);\n } else {\n removeHandler(chart, 'mousedown');\n removeHandler(chart, 'mousemove');\n removeHandler(chart, 'mouseup');\n removeHandler(chart, 'keydown');\n }\n}\n\nfunction removeListeners(chart) {\n removeHandler(chart, 'mousedown');\n removeHandler(chart, 'mousemove');\n removeHandler(chart, 'mouseup');\n removeHandler(chart, 'wheel');\n removeHandler(chart, 'click');\n removeHandler(chart, 'keydown');\n}\n\nfunction createEnabler(chart, state) {\n return function(recognizer, event) {\n const {pan: panOptions, zoom: zoomOptions = {}} = state.options;\n if (!panOptions || !panOptions.enabled) {\n return false;\n }\n const srcEvent = event && event.srcEvent;\n if (!srcEvent) { // Sometimes Hammer queries this with a null event.\n return true;\n }\n if (!state.panning && event.pointerType === 'mouse' && (\n keyNotPressed(getModifierKey(panOptions), srcEvent) || keyPressed(getModifierKey(zoomOptions.drag), srcEvent))\n ) {\n callback(panOptions.onPanRejected, [{chart, event}]);\n return false;\n }\n return true;\n };\n}\n\nfunction pinchAxes(p0, p1) {\n // fingers position difference\n const pinchX = Math.abs(p0.clientX - p1.clientX);\n const pinchY = Math.abs(p0.clientY - p1.clientY);\n\n // diagonal fingers will change both (xy) axes\n const p = pinchX / pinchY;\n let x, y;\n if (p > 0.3 && p < 1.7) {\n x = y = true;\n } else if (pinchX > pinchY) {\n x = true;\n } else {\n y = true;\n }\n return {x, y};\n}\n\nfunction handlePinch(chart, state, e) {\n if (state.scale) {\n const {center, pointers} = e;\n // Hammer reports the total scaling. We need the incremental amount\n const zoomPercent = 1 / state.scale * e.scale;\n const rect = e.target.getBoundingClientRect();\n const pinch = pinchAxes(pointers[0], pointers[1]);\n const mode = state.options.zoom.mode;\n const amount = {\n x: pinch.x && directionEnabled(mode, 'x', chart) ? zoomPercent : 1,\n y: pinch.y && directionEnabled(mode, 'y', chart) ? zoomPercent : 1,\n focalPoint: {\n x: center.x - rect.left,\n y: center.y - rect.top\n }\n };\n\n zoom(chart, amount);\n\n // Keep track of overall scale\n state.scale = e.scale;\n }\n}\n\nfunction startPinch(chart, state) {\n if (state.options.zoom.pinch.enabled) {\n state.scale = 1;\n }\n}\n\nfunction endPinch(chart, state, e) {\n if (state.scale) {\n handlePinch(chart, state, e);\n state.scale = null; // reset\n callback(state.options.zoom.onZoomComplete, [{chart}]);\n }\n}\n\nfunction handlePan(chart, state, e) {\n const delta = state.delta;\n if (delta) {\n state.panning = true;\n pan(chart, {x: e.deltaX - delta.x, y: e.deltaY - delta.y}, state.panScales);\n state.delta = {x: e.deltaX, y: e.deltaY};\n }\n}\n\nfunction startPan(chart, state, event) {\n const {enabled, onPanStart, onPanRejected} = state.options.pan;\n if (!enabled) {\n return;\n }\n const rect = event.target.getBoundingClientRect();\n const point = {\n x: event.center.x - rect.left,\n y: event.center.y - rect.top\n };\n\n if (callback(onPanStart, [{chart, event, point}]) === false) {\n return callback(onPanRejected, [{chart, event}]);\n }\n\n state.panScales = getEnabledScalesByPoint(state.options.pan, point, chart);\n state.delta = {x: 0, y: 0};\n clearTimeout(state.panEndTimeout);\n handlePan(chart, state, event);\n}\n\nfunction endPan(chart, state) {\n state.delta = null;\n if (state.panning) {\n state.panEndTimeout = setTimeout(() => (state.panning = false), 500);\n callback(state.options.pan.onPanComplete, [{chart}]);\n }\n}\n\nconst hammers = new WeakMap();\nfunction startHammer(chart, options) {\n const state = getState(chart);\n const canvas = chart.canvas;\n const {pan: panOptions, zoom: zoomOptions} = options;\n\n const mc = new Hammer.Manager(canvas);\n if (zoomOptions && zoomOptions.pinch.enabled) {\n mc.add(new Hammer.Pinch());\n mc.on('pinchstart', () => startPinch(chart, state));\n mc.on('pinch', (e) => handlePinch(chart, state, e));\n mc.on('pinchend', (e) => endPinch(chart, state, e));\n }\n\n if (panOptions && panOptions.enabled) {\n mc.add(new Hammer.Pan({\n threshold: panOptions.threshold,\n enable: createEnabler(chart, state)\n }));\n mc.on('panstart', (e) => startPan(chart, state, e));\n mc.on('panmove', (e) => handlePan(chart, state, e));\n mc.on('panend', () => endPan(chart, state));\n }\n\n hammers.set(chart, mc);\n}\n\nfunction stopHammer(chart) {\n const mc = hammers.get(chart);\n if (mc) {\n mc.remove('pinchstart');\n mc.remove('pinch');\n mc.remove('pinchend');\n mc.remove('panstart');\n mc.remove('pan');\n mc.remove('panend');\n mc.destroy();\n hammers.delete(chart);\n }\n}\n\nvar version = \"2.0.1\";\n\nfunction draw(chart, caller, options) {\n const dragOptions = options.zoom.drag;\n const {dragStart, dragEnd} = getState(chart);\n\n if (dragOptions.drawTime !== caller || !dragEnd) {\n return;\n }\n const {left, top, width, height} = computeDragRect(chart, options.zoom.mode, dragStart, dragEnd);\n const ctx = chart.ctx;\n\n ctx.save();\n ctx.beginPath();\n ctx.fillStyle = dragOptions.backgroundColor || 'rgba(225,225,225,0.3)';\n ctx.fillRect(left, top, width, height);\n\n if (dragOptions.borderWidth > 0) {\n ctx.lineWidth = dragOptions.borderWidth;\n ctx.strokeStyle = dragOptions.borderColor || 'rgba(225,225,225)';\n ctx.strokeRect(left, top, width, height);\n }\n ctx.restore();\n}\n\nvar plugin = {\n id: 'zoom',\n\n version,\n\n defaults: {\n pan: {\n enabled: false,\n mode: 'xy',\n threshold: 10,\n modifierKey: null,\n },\n zoom: {\n wheel: {\n enabled: false,\n speed: 0.1,\n modifierKey: null\n },\n drag: {\n enabled: false,\n drawTime: 'beforeDatasetsDraw',\n modifierKey: null\n },\n pinch: {\n enabled: false\n },\n mode: 'xy',\n }\n },\n\n start: function(chart, _args, options) {\n const state = getState(chart);\n state.options = options;\n\n if (Object.prototype.hasOwnProperty.call(options.zoom, 'enabled')) {\n console.warn('The option `zoom.enabled` is no longer supported. Please use `zoom.wheel.enabled`, `zoom.drag.enabled`, or `zoom.pinch.enabled`.');\n }\n if (Object.prototype.hasOwnProperty.call(options.zoom, 'overScaleMode')\n || Object.prototype.hasOwnProperty.call(options.pan, 'overScaleMode')) {\n console.warn('The option `overScaleMode` is deprecated. Please use `scaleMode` instead (and update `mode` as desired).');\n }\n\n if (Hammer) {\n startHammer(chart, options);\n }\n\n chart.pan = (delta, panScales, transition) => pan(chart, delta, panScales, transition);\n chart.zoom = (args, transition) => zoom(chart, args, transition);\n chart.zoomRect = (p0, p1, transition) => zoomRect(chart, p0, p1, transition);\n chart.zoomScale = (id, range, transition) => zoomScale(chart, id, range, transition);\n chart.resetZoom = (transition) => resetZoom(chart, transition);\n chart.getZoomLevel = () => getZoomLevel(chart);\n chart.getInitialScaleBounds = () => getInitialScaleBounds(chart);\n chart.isZoomedOrPanned = () => isZoomedOrPanned(chart);\n },\n\n beforeEvent(chart) {\n const state = getState(chart);\n if (state.panning || state.dragging) {\n // cancel any event handling while panning or dragging\n return false;\n }\n },\n\n beforeUpdate: function(chart, args, options) {\n const state = getState(chart);\n state.options = options;\n addListeners(chart, options);\n },\n\n beforeDatasetsDraw(chart, _args, options) {\n draw(chart, 'beforeDatasetsDraw', options);\n },\n\n afterDatasetsDraw(chart, _args, options) {\n draw(chart, 'afterDatasetsDraw', options);\n },\n\n beforeDraw(chart, _args, options) {\n draw(chart, 'beforeDraw', options);\n },\n\n afterDraw(chart, _args, options) {\n draw(chart, 'afterDraw', options);\n },\n\n stop: function(chart) {\n removeListeners(chart);\n\n if (Hammer) {\n stopHammer(chart);\n }\n removeState(chart);\n },\n\n panFunctions,\n zoomFunctions,\n zoomRectFunctions,\n};\n\nexport { plugin as default, pan, resetZoom, zoom, zoomRect, zoomScale };\n","\nimport {SvgIcon} from '../svg.js';\nimport {\n Chart,\n Title,\n BarElement,\n LinearScale,\n TimeScale,\n PointElement,\n LineElement,\n Filler,\n} from 'chart.js';\nimport {GET} from '../modules/fetch.js';\nimport zoomPlugin from 'chartjs-plugin-zoom';\nimport {Line as ChartLine} from 'vue-chartjs';\nimport {\n startDaysBetween,\n firstStartDateAfterDate,\n fillEmptyStartDaysWithZeroes,\n} from '../utils/time.js';\nimport {chartJsColors} from '../utils/color.js';\nimport {sleep} from '../utils.js';\nimport 'chartjs-adapter-dayjs-4/dist/chartjs-adapter-dayjs-4.esm';\nimport $ from 'jquery';\n\nconst {pageData} = window.config;\n\nconst customEventListener = {\n id: 'customEventListener',\n afterEvent: (chart, args, opts) => {\n // event will be replayed from chart.update when reset zoom,\n // so we need to check whether args.replay is true to avoid call loops\n if (args.event.type === 'dblclick' && opts.chartType === 'main' && !args.replay) {\n chart.resetZoom();\n opts.instance.updateOtherCharts(args.event, true);\n }\n },\n};\n\nChart.defaults.color = chartJsColors.text;\nChart.defaults.borderColor = chartJsColors.border;\n\nChart.register(\n TimeScale,\n LinearScale,\n BarElement,\n Title,\n PointElement,\n LineElement,\n Filler,\n zoomPlugin,\n customEventListener,\n);\n\nexport default {\n components: {ChartLine, SvgIcon},\n props: {\n locale: {\n type: Object,\n required: true,\n },\n },\n data: () => ({\n isLoading: false,\n errorText: '',\n totalStats: {},\n sortedContributors: {},\n repoLink: pageData.repoLink || [],\n type: pageData.contributionType,\n contributorsStats: [],\n xAxisStart: null,\n xAxisEnd: null,\n xAxisMin: null,\n xAxisMax: null,\n }),\n mounted() {\n this.fetchGraphData();\n\n $('#repo-contributors').dropdown({\n onChange: (val) => {\n this.xAxisMin = this.xAxisStart;\n this.xAxisMax = this.xAxisEnd;\n this.type = val;\n this.sortContributors();\n },\n });\n },\n methods: {\n sortContributors() {\n const contributors = this.filterContributorWeeksByDateRange();\n const criteria = `total_${this.type}`;\n this.sortedContributors = Object.values(contributors)\n .filter((contributor) => contributor[criteria] !== 0)\n .sort((a, b) => a[criteria] > b[criteria] ? -1 : a[criteria] === b[criteria] ? 0 : 1)\n .slice(0, 100);\n },\n\n async fetchGraphData() {\n this.isLoading = true;\n try {\n let response;\n do {\n response = await GET(`${this.repoLink}/activity/contributors/data`);\n if (response.status === 202) {\n await sleep(1000); // wait for 1 second before retrying\n }\n } while (response.status === 202);\n if (response.ok) {\n const data = await response.json();\n const {total, ...rest} = data;\n // below line might be deleted if we are sure go produces map always sorted by keys\n total.weeks = Object.fromEntries(Object.entries(total.weeks).sort());\n\n const weekValues = Object.values(total.weeks);\n this.xAxisStart = weekValues[0].week;\n this.xAxisEnd = firstStartDateAfterDate(new Date());\n const startDays = startDaysBetween(new Date(this.xAxisStart), new Date(this.xAxisEnd));\n total.weeks = fillEmptyStartDaysWithZeroes(startDays, total.weeks);\n this.xAxisMin = this.xAxisStart;\n this.xAxisMax = this.xAxisEnd;\n this.contributorsStats = {};\n for (const [email, user] of Object.entries(rest)) {\n user.weeks = fillEmptyStartDaysWithZeroes(startDays, user.weeks);\n this.contributorsStats[email] = user;\n }\n this.sortContributors();\n this.totalStats = total;\n this.errorText = '';\n } else {\n this.errorText = response.statusText;\n }\n } catch (err) {\n this.errorText = err.message;\n } finally {\n this.isLoading = false;\n }\n },\n\n filterContributorWeeksByDateRange() {\n const filteredData = {};\n const data = this.contributorsStats;\n for (const key of Object.keys(data)) {\n const user = data[key];\n user.total_commits = 0;\n user.total_additions = 0;\n user.total_deletions = 0;\n user.max_contribution_type = 0;\n const filteredWeeks = user.weeks.filter((week) => {\n const oneWeek = 7 * 24 * 60 * 60 * 1000;\n if (week.week >= this.xAxisMin - oneWeek && week.week <= this.xAxisMax + oneWeek) {\n user.total_commits += week.commits;\n user.total_additions += week.additions;\n user.total_deletions += week.deletions;\n if (week[this.type] > user.max_contribution_type) {\n user.max_contribution_type = week[this.type];\n }\n return true;\n }\n return false;\n });\n // this line is required. See https://github.com/sahinakkaya/gitea/pull/3#discussion_r1396495722\n // for details.\n user.max_contribution_type += 1;\n\n filteredData[key] = {...user, weeks: filteredWeeks};\n }\n\n return filteredData;\n },\n\n maxMainGraph() {\n // This method calculates maximum value for Y value of the main graph. If the number\n // of maximum contributions for selected contribution type is 15.955 it is probably\n // better to round it up to 20.000.This method is responsible for doing that.\n // Normally, chartjs handles this automatically, but it will resize the graph when you\n // zoom, pan etc. I think resizing the graph makes it harder to compare things visually.\n const maxValue = Math.max(\n ...this.totalStats.weeks.map((o) => o[this.type]),\n );\n const [coefficient, exp] = maxValue.toExponential().split('e').map(Number);\n if (coefficient % 1 === 0) return maxValue;\n return (1 - (coefficient % 1)) * 10 ** exp + maxValue;\n },\n\n maxContributorGraph() {\n // Similar to maxMainGraph method this method calculates maximum value for Y value\n // for contributors' graph. If I let chartjs do this for me, it will choose different\n // maxY value for each contributors' graph which again makes it harder to compare.\n const maxValue = Math.max(\n ...this.sortedContributors.map((c) => c.max_contribution_type),\n );\n const [coefficient, exp] = maxValue.toExponential().split('e').map(Number);\n if (coefficient % 1 === 0) return maxValue;\n return (1 - (coefficient % 1)) * 10 ** exp + maxValue;\n },\n\n toGraphData(data) {\n return {\n datasets: [\n {\n data: data.map((i) => ({x: i.week, y: i[this.type]})),\n pointRadius: 0,\n pointHitRadius: 0,\n fill: 'start',\n backgroundColor: chartJsColors[this.type],\n borderWidth: 0,\n tension: 0.3,\n },\n ],\n };\n },\n\n updateOtherCharts(event, reset) {\n const minVal = event.chart.options.scales.x.min;\n const maxVal = event.chart.options.scales.x.max;\n if (reset) {\n this.xAxisMin = this.xAxisStart;\n this.xAxisMax = this.xAxisEnd;\n this.sortContributors();\n } else if (minVal) {\n this.xAxisMin = minVal;\n this.xAxisMax = maxVal;\n this.sortContributors();\n }\n },\n\n getOptions(type) {\n return {\n responsive: true,\n maintainAspectRatio: false,\n animation: false,\n events: ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove', 'dblclick'],\n plugins: {\n title: {\n display: type === 'main',\n text: 'drag: zoom, shift+drag: pan, double click: reset zoom',\n position: 'top',\n align: 'center',\n },\n customEventListener: {\n chartType: type,\n instance: this,\n },\n zoom: {\n pan: {\n enabled: true,\n modifierKey: 'shift',\n mode: 'x',\n threshold: 20,\n onPanComplete: this.updateOtherCharts,\n },\n limits: {\n x: {\n // Check https://www.chartjs.org/chartjs-plugin-zoom/latest/guide/options.html#scale-limits\n // to know what each option means\n min: 'original',\n max: 'original',\n\n // number of milliseconds in 2 weeks. Minimum x range will be 2 weeks when you zoom on the graph\n minRange: 2 * 7 * 24 * 60 * 60 * 1000,\n },\n },\n zoom: {\n drag: {\n enabled: type === 'main',\n },\n pinch: {\n enabled: type === 'main',\n },\n mode: 'x',\n onZoomComplete: this.updateOtherCharts,\n },\n },\n },\n scales: {\n x: {\n min: this.xAxisMin,\n max: this.xAxisMax,\n type: 'time',\n grid: {\n display: false,\n },\n time: {\n minUnit: 'month',\n },\n ticks: {\n maxRotation: 0,\n maxTicksLimit: type === 'main' ? 12 : 6,\n },\n },\n y: {\n min: 0,\n max: type === 'main' ? this.maxMainGraph() : this.maxContributorGraph(),\n ticks: {\n maxTicksLimit: type === 'main' ? 6 : 4,\n },\n },\n },\n };\n },\n },\n};\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n 'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n if (Array.isArray(arg)) {\n each(arg, context[fn], context);\n return true;\n }\n return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n var i;\n\n if (!obj) {\n return;\n }\n\n if (obj.forEach) {\n obj.forEach(iterator, context);\n } else if (obj.length !== undefined) {\n i = 0;\n while (i < obj.length) {\n iterator.call(context, obj[i], i, obj);\n i++;\n }\n } else {\n for (i in obj) {\n obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n }\n }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n return function() {\n var e = new Error('get-stack-trace');\n var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n .replace(/^\\s+at\\s+/gm, '')\n .replace(/^Object.\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n var log = window.console && (window.console.warn || window.console.log);\n if (log) {\n log.call(window.console, deprecationMessage, stack);\n }\n return method.apply(this, arguments);\n };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n assign = function assign(target) {\n if (target === undefined || target === null) {\n throw new TypeError('Cannot convert undefined or null to object');\n }\n\n var output = Object(target);\n for (var index = 1; index < arguments.length; index++) {\n var source = arguments[index];\n if (source !== undefined && source !== null) {\n for (var nextKey in source) {\n if (source.hasOwnProperty(nextKey)) {\n output[nextKey] = source[nextKey];\n }\n }\n }\n }\n return output;\n };\n} else {\n assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n var keys = Object.keys(src);\n var i = 0;\n while (i < keys.length) {\n if (!merge || (merge && dest[keys[i]] === undefined)) {\n dest[keys[i]] = src[keys[i]];\n }\n i++;\n }\n return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n var baseP = base.prototype,\n childP;\n\n childP = child.prototype = Object.create(baseP);\n childP.constructor = child;\n childP._super = baseP;\n\n if (properties) {\n assign(childP, properties);\n }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n return function boundFn() {\n return fn.apply(context, arguments);\n };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n if (typeof val == TYPE_FUNCTION) {\n return val.apply(args ? args[0] || undefined : undefined, args);\n }\n return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n each(splitStr(types), function(type) {\n target.addEventListener(type, handler, false);\n });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n each(splitStr(types), function(type) {\n target.removeEventListener(type, handler, false);\n });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n while (node) {\n if (node == parent) {\n return true;\n }\n node = node.parentNode;\n }\n return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n if (src.indexOf && !findByKey) {\n return src.indexOf(find);\n } else {\n var i = 0;\n while (i < src.length) {\n if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n return i;\n }\n i++;\n }\n return -1;\n }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n var results = [];\n var values = [];\n var i = 0;\n\n while (i < src.length) {\n var val = key ? src[i][key] : src[i];\n if (inArray(values, val) < 0) {\n results.push(src[i]);\n }\n values[i] = val;\n i++;\n }\n\n if (sort) {\n if (!key) {\n results = results.sort();\n } else {\n results = results.sort(function sortUniqueArray(a, b) {\n return a[key] > b[key];\n });\n }\n }\n\n return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n var prefix, prop;\n var camelProp = property[0].toUpperCase() + property.slice(1);\n\n var i = 0;\n while (i < VENDOR_PREFIXES.length) {\n prefix = VENDOR_PREFIXES[i];\n prop = (prefix) ? prefix + camelProp : property;\n\n if (prop in obj) {\n return prop;\n }\n i++;\n }\n return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n var doc = element.ownerDocument || element;\n return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n var self = this;\n this.manager = manager;\n this.callback = callback;\n this.element = manager.element;\n this.target = manager.options.inputTarget;\n\n // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n // so when disabled the input events are completely bypassed.\n this.domHandler = function(ev) {\n if (boolOrFn(manager.options.enable, [manager])) {\n self.handler(ev);\n }\n };\n\n this.init();\n\n}\n\nInput.prototype = {\n /**\n * should handle the inputEvent data and trigger the callback\n * @virtual\n */\n handler: function() { },\n\n /**\n * bind the events\n */\n init: function() {\n this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n },\n\n /**\n * unbind the events\n */\n destroy: function() {\n this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n var Type;\n var inputClass = manager.options.inputClass;\n\n if (inputClass) {\n Type = inputClass;\n } else if (SUPPORT_POINTER_EVENTS) {\n Type = PointerEventInput;\n } else if (SUPPORT_ONLY_TOUCH) {\n Type = TouchInput;\n } else if (!SUPPORT_TOUCH) {\n Type = MouseInput;\n } else {\n Type = TouchMouseInput;\n }\n return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n var pointersLen = input.pointers.length;\n var changedPointersLen = input.changedPointers.length;\n var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n input.isFirst = !!isFirst;\n input.isFinal = !!isFinal;\n\n if (isFirst) {\n manager.session = {};\n }\n\n // source event is the normalized value of the domEvents\n // like 'touchstart, mouseup, pointerdown'\n input.eventType = eventType;\n\n // compute scale, rotation etc\n computeInputData(manager, input);\n\n // emit secret event\n manager.emit('hammer.input', input);\n\n manager.recognize(input);\n manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n var session = manager.session;\n var pointers = input.pointers;\n var pointersLength = pointers.length;\n\n // store the first input to calculate the distance and direction\n if (!session.firstInput) {\n session.firstInput = simpleCloneInputData(input);\n }\n\n // to compute scale and rotation we need to store the multiple touches\n if (pointersLength > 1 && !session.firstMultiple) {\n session.firstMultiple = simpleCloneInputData(input);\n } else if (pointersLength === 1) {\n session.firstMultiple = false;\n }\n\n var firstInput = session.firstInput;\n var firstMultiple = session.firstMultiple;\n var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n var center = input.center = getCenter(pointers);\n input.timeStamp = now();\n input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n input.angle = getAngle(offsetCenter, center);\n input.distance = getDistance(offsetCenter, center);\n\n computeDeltaXY(session, input);\n input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n input.overallVelocityX = overallVelocity.x;\n input.overallVelocityY = overallVelocity.y;\n input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n computeIntervalInputData(session, input);\n\n // find the correct target\n var target = manager.element;\n if (hasParent(input.srcEvent.target, target)) {\n target = input.srcEvent.target;\n }\n input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n var center = input.center;\n var offset = session.offsetDelta || {};\n var prevDelta = session.prevDelta || {};\n var prevInput = session.prevInput || {};\n\n if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n prevDelta = session.prevDelta = {\n x: prevInput.deltaX || 0,\n y: prevInput.deltaY || 0\n };\n\n offset = session.offsetDelta = {\n x: center.x,\n y: center.y\n };\n }\n\n input.deltaX = prevDelta.x + (center.x - offset.x);\n input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n var last = session.lastInterval || input,\n deltaTime = input.timeStamp - last.timeStamp,\n velocity, velocityX, velocityY, direction;\n\n if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n var deltaX = input.deltaX - last.deltaX;\n var deltaY = input.deltaY - last.deltaY;\n\n var v = getVelocity(deltaTime, deltaX, deltaY);\n velocityX = v.x;\n velocityY = v.y;\n velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n direction = getDirection(deltaX, deltaY);\n\n session.lastInterval = input;\n } else {\n // use latest velocity info if it doesn't overtake a minimum period\n velocity = last.velocity;\n velocityX = last.velocityX;\n velocityY = last.velocityY;\n direction = last.direction;\n }\n\n input.velocity = velocity;\n input.velocityX = velocityX;\n input.velocityY = velocityY;\n input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n // make a simple copy of the pointers because we will get a reference if we don't\n // we only need clientXY for the calculations\n var pointers = [];\n var i = 0;\n while (i < input.pointers.length) {\n pointers[i] = {\n clientX: round(input.pointers[i].clientX),\n clientY: round(input.pointers[i].clientY)\n };\n i++;\n }\n\n return {\n timeStamp: now(),\n pointers: pointers,\n center: getCenter(pointers),\n deltaX: input.deltaX,\n deltaY: input.deltaY\n };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n var pointersLength = pointers.length;\n\n // no need to loop when only one touch\n if (pointersLength === 1) {\n return {\n x: round(pointers[0].clientX),\n y: round(pointers[0].clientY)\n };\n }\n\n var x = 0, y = 0, i = 0;\n while (i < pointersLength) {\n x += pointers[i].clientX;\n y += pointers[i].clientY;\n i++;\n }\n\n return {\n x: round(x / pointersLength),\n y: round(y / pointersLength)\n };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n return {\n x: x / deltaTime || 0,\n y: y / deltaTime || 0\n };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n if (x === y) {\n return DIRECTION_NONE;\n }\n\n if (abs(x) >= abs(y)) {\n return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n }\n return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n if (!props) {\n props = PROPS_XY;\n }\n var x = p2[props[0]] - p1[props[0]],\n y = p2[props[1]] - p1[props[1]];\n\n return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n if (!props) {\n props = PROPS_XY;\n }\n var x = p2[props[0]] - p1[props[0]],\n y = p2[props[1]] - p1[props[1]];\n return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n mousedown: INPUT_START,\n mousemove: INPUT_MOVE,\n mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n this.evEl = MOUSE_ELEMENT_EVENTS;\n this.evWin = MOUSE_WINDOW_EVENTS;\n\n this.pressed = false; // mousedown state\n\n Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n /**\n * handle mouse events\n * @param {Object} ev\n */\n handler: function MEhandler(ev) {\n var eventType = MOUSE_INPUT_MAP[ev.type];\n\n // on start we want to have the left mouse button down\n if (eventType & INPUT_START && ev.button === 0) {\n this.pressed = true;\n }\n\n if (eventType & INPUT_MOVE && ev.which !== 1) {\n eventType = INPUT_END;\n }\n\n // mouse must be down\n if (!this.pressed) {\n return;\n }\n\n if (eventType & INPUT_END) {\n this.pressed = false;\n }\n\n this.callback(this.manager, eventType, {\n pointers: [ev],\n changedPointers: [ev],\n pointerType: INPUT_TYPE_MOUSE,\n srcEvent: ev\n });\n }\n});\n\nvar POINTER_INPUT_MAP = {\n pointerdown: INPUT_START,\n pointermove: INPUT_MOVE,\n pointerup: INPUT_END,\n pointercancel: INPUT_CANCEL,\n pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n 2: INPUT_TYPE_TOUCH,\n 3: INPUT_TYPE_PEN,\n 4: INPUT_TYPE_MOUSE,\n 5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n this.evEl = POINTER_ELEMENT_EVENTS;\n this.evWin = POINTER_WINDOW_EVENTS;\n\n Input.apply(this, arguments);\n\n this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n /**\n * handle mouse events\n * @param {Object} ev\n */\n handler: function PEhandler(ev) {\n var store = this.store;\n var removePointer = false;\n\n var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n // get index of the event in the store\n var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n // start and mouse must be down\n if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n if (storeIndex < 0) {\n store.push(ev);\n storeIndex = store.length - 1;\n }\n } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n removePointer = true;\n }\n\n // it not found, so the pointer hasn't been down (so it's probably a hover)\n if (storeIndex < 0) {\n return;\n }\n\n // update the event in the store\n store[storeIndex] = ev;\n\n this.callback(this.manager, eventType, {\n pointers: store,\n changedPointers: [ev],\n pointerType: pointerType,\n srcEvent: ev\n });\n\n if (removePointer) {\n // remove from the store\n store.splice(storeIndex, 1);\n }\n }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n touchstart: INPUT_START,\n touchmove: INPUT_MOVE,\n touchend: INPUT_END,\n touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n this.started = false;\n\n Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n handler: function TEhandler(ev) {\n var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n // should we handle the touch events?\n if (type === INPUT_START) {\n this.started = true;\n }\n\n if (!this.started) {\n return;\n }\n\n var touches = normalizeSingleTouches.call(this, ev, type);\n\n // when done, reset the started state\n if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n this.started = false;\n }\n\n this.callback(this.manager, type, {\n pointers: touches[0],\n changedPointers: touches[1],\n pointerType: INPUT_TYPE_TOUCH,\n srcEvent: ev\n });\n }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n var all = toArray(ev.touches);\n var changed = toArray(ev.changedTouches);\n\n if (type & (INPUT_END | INPUT_CANCEL)) {\n all = uniqueArray(all.concat(changed), 'identifier', true);\n }\n\n return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n touchstart: INPUT_START,\n touchmove: INPUT_MOVE,\n touchend: INPUT_END,\n touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n this.evTarget = TOUCH_TARGET_EVENTS;\n this.targetIds = {};\n\n Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n handler: function MTEhandler(ev) {\n var type = TOUCH_INPUT_MAP[ev.type];\n var touches = getTouches.call(this, ev, type);\n if (!touches) {\n return;\n }\n\n this.callback(this.manager, type, {\n pointers: touches[0],\n changedPointers: touches[1],\n pointerType: INPUT_TYPE_TOUCH,\n srcEvent: ev\n });\n }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n var allTouches = toArray(ev.touches);\n var targetIds = this.targetIds;\n\n // when there is only one touch, the process can be simplified\n if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n targetIds[allTouches[0].identifier] = true;\n return [allTouches, allTouches];\n }\n\n var i,\n targetTouches,\n changedTouches = toArray(ev.changedTouches),\n changedTargetTouches = [],\n target = this.target;\n\n // get target touches from touches\n targetTouches = allTouches.filter(function(touch) {\n return hasParent(touch.target, target);\n });\n\n // collect touches\n if (type === INPUT_START) {\n i = 0;\n while (i < targetTouches.length) {\n targetIds[targetTouches[i].identifier] = true;\n i++;\n }\n }\n\n // filter changed touches to only contain touches that exist in the collected target ids\n i = 0;\n while (i < changedTouches.length) {\n if (targetIds[changedTouches[i].identifier]) {\n changedTargetTouches.push(changedTouches[i]);\n }\n\n // cleanup removed touches\n if (type & (INPUT_END | INPUT_CANCEL)) {\n delete targetIds[changedTouches[i].identifier];\n }\n i++;\n }\n\n if (!changedTargetTouches.length) {\n return;\n }\n\n return [\n // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n changedTargetTouches\n ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n Input.apply(this, arguments);\n\n var handler = bindFn(this.handler, this);\n this.touch = new TouchInput(this.manager, handler);\n this.mouse = new MouseInput(this.manager, handler);\n\n this.primaryTouch = null;\n this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n /**\n * handle mouse and touch events\n * @param {Hammer} manager\n * @param {String} inputEvent\n * @param {Object} inputData\n */\n handler: function TMEhandler(manager, inputEvent, inputData) {\n var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n return;\n }\n\n // when we're in a touch event, record touches to de-dupe synthetic mouse event\n if (isTouch) {\n recordTouches.call(this, inputEvent, inputData);\n } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n return;\n }\n\n this.callback(manager, inputEvent, inputData);\n },\n\n /**\n * remove the event listeners\n */\n destroy: function destroy() {\n this.touch.destroy();\n this.mouse.destroy();\n }\n});\n\nfunction recordTouches(eventType, eventData) {\n if (eventType & INPUT_START) {\n this.primaryTouch = eventData.changedPointers[0].identifier;\n setLastTouch.call(this, eventData);\n } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n setLastTouch.call(this, eventData);\n }\n}\n\nfunction setLastTouch(eventData) {\n var touch = eventData.changedPointers[0];\n\n if (touch.identifier === this.primaryTouch) {\n var lastTouch = {x: touch.clientX, y: touch.clientY};\n this.lastTouches.push(lastTouch);\n var lts = this.lastTouches;\n var removeLastTouch = function() {\n var i = lts.indexOf(lastTouch);\n if (i > -1) {\n lts.splice(i, 1);\n }\n };\n setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n }\n}\n\nfunction isSyntheticEvent(eventData) {\n var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n for (var i = 0; i < this.lastTouches.length; i++) {\n var t = this.lastTouches[i];\n var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n return true;\n }\n }\n return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n this.manager = manager;\n this.set(value);\n}\n\nTouchAction.prototype = {\n /**\n * set the touchAction value on the element or enable the polyfill\n * @param {String} value\n */\n set: function(value) {\n // find out the touch-action by the event handlers\n if (value == TOUCH_ACTION_COMPUTE) {\n value = this.compute();\n }\n\n if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n }\n this.actions = value.toLowerCase().trim();\n },\n\n /**\n * just re-set the touchAction value\n */\n update: function() {\n this.set(this.manager.options.touchAction);\n },\n\n /**\n * compute the value for the touchAction property based on the recognizer's settings\n * @returns {String} value\n */\n compute: function() {\n var actions = [];\n each(this.manager.recognizers, function(recognizer) {\n if (boolOrFn(recognizer.options.enable, [recognizer])) {\n actions = actions.concat(recognizer.getTouchAction());\n }\n });\n return cleanTouchActions(actions.join(' '));\n },\n\n /**\n * this method is called on each input cycle and provides the preventing of the browser behavior\n * @param {Object} input\n */\n preventDefaults: function(input) {\n var srcEvent = input.srcEvent;\n var direction = input.offsetDirection;\n\n // if the touch action did prevented once this session\n if (this.manager.session.prevented) {\n srcEvent.preventDefault();\n return;\n }\n\n var actions = this.actions;\n var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n if (hasNone) {\n //do not prevent defaults if this is a tap gesture\n\n var isTapPointer = input.pointers.length === 1;\n var isTapMovement = input.distance < 2;\n var isTapTouchTime = input.deltaTime < 250;\n\n if (isTapPointer && isTapMovement && isTapTouchTime) {\n return;\n }\n }\n\n if (hasPanX && hasPanY) {\n // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n return;\n }\n\n if (hasNone ||\n (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n (hasPanX && direction & DIRECTION_VERTICAL)) {\n return this.preventSrc(srcEvent);\n }\n },\n\n /**\n * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n * @param {Object} srcEvent\n */\n preventSrc: function(srcEvent) {\n this.manager.session.prevented = true;\n srcEvent.preventDefault();\n }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n // none\n if (inStr(actions, TOUCH_ACTION_NONE)) {\n return TOUCH_ACTION_NONE;\n }\n\n var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n // if both pan-x and pan-y are set (different recognizers\n // for different directions, e.g. horizontal pan but vertical swipe?)\n // we need none (as otherwise with pan-x pan-y combined none of these\n // recognizers will work, since the browser would handle all panning\n if (hasPanX && hasPanY) {\n return TOUCH_ACTION_NONE;\n }\n\n // pan-x OR pan-y\n if (hasPanX || hasPanY) {\n return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n }\n\n // manipulation\n if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n return TOUCH_ACTION_MANIPULATION;\n }\n\n return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n if (!NATIVE_TOUCH_ACTION) {\n return false;\n }\n var touchMap = {};\n var cssSupports = window.CSS && window.CSS.supports;\n ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n // If css.supports is not supported but there is native touch-action assume it supports\n // all values. This is the case for IE 10 and 11.\n touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n });\n return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n * Possible\n * |\n * +-----+---------------+\n * | |\n * +-----+-----+ |\n * | | |\n * Failed Cancelled |\n * +-------+------+\n * | |\n * Recognized Began\n * |\n * Changed\n * |\n * Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n this.options = assign({}, this.defaults, options || {});\n\n this.id = uniqueId();\n\n this.manager = null;\n\n // default is enable true\n this.options.enable = ifUndefined(this.options.enable, true);\n\n this.state = STATE_POSSIBLE;\n\n this.simultaneous = {};\n this.requireFail = [];\n}\n\nRecognizer.prototype = {\n /**\n * @virtual\n * @type {Object}\n */\n defaults: {},\n\n /**\n * set options\n * @param {Object} options\n * @return {Recognizer}\n */\n set: function(options) {\n assign(this.options, options);\n\n // also update the touchAction, in case something changed about the directions/enabled state\n this.manager && this.manager.touchAction.update();\n return this;\n },\n\n /**\n * recognize simultaneous with an other recognizer.\n * @param {Recognizer} otherRecognizer\n * @returns {Recognizer} this\n */\n recognizeWith: function(otherRecognizer) {\n if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n return this;\n }\n\n var simultaneous = this.simultaneous;\n otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n if (!simultaneous[otherRecognizer.id]) {\n simultaneous[otherRecognizer.id] = otherRecognizer;\n otherRecognizer.recognizeWith(this);\n }\n return this;\n },\n\n /**\n * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n * @param {Recognizer} otherRecognizer\n * @returns {Recognizer} this\n */\n dropRecognizeWith: function(otherRecognizer) {\n if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n return this;\n }\n\n otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n delete this.simultaneous[otherRecognizer.id];\n return this;\n },\n\n /**\n * recognizer can only run when an other is failing\n * @param {Recognizer} otherRecognizer\n * @returns {Recognizer} this\n */\n requireFailure: function(otherRecognizer) {\n if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n return this;\n }\n\n var requireFail = this.requireFail;\n otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n if (inArray(requireFail, otherRecognizer) === -1) {\n requireFail.push(otherRecognizer);\n otherRecognizer.requireFailure(this);\n }\n return this;\n },\n\n /**\n * drop the requireFailure link. it does not remove the link on the other recognizer.\n * @param {Recognizer} otherRecognizer\n * @returns {Recognizer} this\n */\n dropRequireFailure: function(otherRecognizer) {\n if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n return this;\n }\n\n otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n var index = inArray(this.requireFail, otherRecognizer);\n if (index > -1) {\n this.requireFail.splice(index, 1);\n }\n return this;\n },\n\n /**\n * has require failures boolean\n * @returns {boolean}\n */\n hasRequireFailures: function() {\n return this.requireFail.length > 0;\n },\n\n /**\n * if the recognizer can recognize simultaneous with an other recognizer\n * @param {Recognizer} otherRecognizer\n * @returns {Boolean}\n */\n canRecognizeWith: function(otherRecognizer) {\n return !!this.simultaneous[otherRecognizer.id];\n },\n\n /**\n * You should use `tryEmit` instead of `emit` directly to check\n * that all the needed recognizers has failed before emitting.\n * @param {Object} input\n */\n emit: function(input) {\n var self = this;\n var state = this.state;\n\n function emit(event) {\n self.manager.emit(event, input);\n }\n\n // 'panstart' and 'panmove'\n if (state < STATE_ENDED) {\n emit(self.options.event + stateStr(state));\n }\n\n emit(self.options.event); // simple 'eventName' events\n\n if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n emit(input.additionalEvent);\n }\n\n // panend and pancancel\n if (state >= STATE_ENDED) {\n emit(self.options.event + stateStr(state));\n }\n },\n\n /**\n * Check that all the require failure recognizers has failed,\n * if true, it emits a gesture event,\n * otherwise, setup the state to FAILED.\n * @param {Object} input\n */\n tryEmit: function(input) {\n if (this.canEmit()) {\n return this.emit(input);\n }\n // it's failing anyway\n this.state = STATE_FAILED;\n },\n\n /**\n * can we emit?\n * @returns {boolean}\n */\n canEmit: function() {\n var i = 0;\n while (i < this.requireFail.length) {\n if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n return false;\n }\n i++;\n }\n return true;\n },\n\n /**\n * update the recognizer\n * @param {Object} inputData\n */\n recognize: function(inputData) {\n // make a new copy of the inputData\n // so we can change the inputData without messing up the other recognizers\n var inputDataClone = assign({}, inputData);\n\n // is is enabled and allow recognizing?\n if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n this.reset();\n this.state = STATE_FAILED;\n return;\n }\n\n // reset when we've reached the end\n if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n this.state = STATE_POSSIBLE;\n }\n\n this.state = this.process(inputDataClone);\n\n // the recognizer has recognized a gesture\n // so trigger an event\n if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n this.tryEmit(inputDataClone);\n }\n },\n\n /**\n * return the state of the recognizer\n * the actual recognizing happens in this method\n * @virtual\n * @param {Object} inputData\n * @returns {Const} STATE\n */\n process: function(inputData) { }, // jshint ignore:line\n\n /**\n * return the preferred touch-action\n * @virtual\n * @returns {Array}\n */\n getTouchAction: function() { },\n\n /**\n * called when the gesture isn't allowed to recognize\n * like when another is being recognized or it is disabled\n * @virtual\n */\n reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n if (state & STATE_CANCELLED) {\n return 'cancel';\n } else if (state & STATE_ENDED) {\n return 'end';\n } else if (state & STATE_CHANGED) {\n return 'move';\n } else if (state & STATE_BEGAN) {\n return 'start';\n }\n return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n if (direction == DIRECTION_DOWN) {\n return 'down';\n } else if (direction == DIRECTION_UP) {\n return 'up';\n } else if (direction == DIRECTION_LEFT) {\n return 'left';\n } else if (direction == DIRECTION_RIGHT) {\n return 'right';\n }\n return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n var manager = recognizer.manager;\n if (manager) {\n return manager.get(otherRecognizer);\n }\n return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n /**\n * @namespace\n * @memberof AttrRecognizer\n */\n defaults: {\n /**\n * @type {Number}\n * @default 1\n */\n pointers: 1\n },\n\n /**\n * Used to check if it the recognizer receives valid input, like input.distance > 10.\n * @memberof AttrRecognizer\n * @param {Object} input\n * @returns {Boolean} recognized\n */\n attrTest: function(input) {\n var optionPointers = this.options.pointers;\n return optionPointers === 0 || input.pointers.length === optionPointers;\n },\n\n /**\n * Process the input and return the state for the recognizer\n * @memberof AttrRecognizer\n * @param {Object} input\n * @returns {*} State\n */\n process: function(input) {\n var state = this.state;\n var eventType = input.eventType;\n\n var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n var isValid = this.attrTest(input);\n\n // on cancel input and we've recognized before, return STATE_CANCELLED\n if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n return state | STATE_CANCELLED;\n } else if (isRecognized || isValid) {\n if (eventType & INPUT_END) {\n return state | STATE_ENDED;\n } else if (!(state & STATE_BEGAN)) {\n return STATE_BEGAN;\n }\n return state | STATE_CHANGED;\n }\n return STATE_FAILED;\n }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n AttrRecognizer.apply(this, arguments);\n\n this.pX = null;\n this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n /**\n * @namespace\n * @memberof PanRecognizer\n */\n defaults: {\n event: 'pan',\n threshold: 10,\n pointers: 1,\n direction: DIRECTION_ALL\n },\n\n getTouchAction: function() {\n var direction = this.options.direction;\n var actions = [];\n if (direction & DIRECTION_HORIZONTAL) {\n actions.push(TOUCH_ACTION_PAN_Y);\n }\n if (direction & DIRECTION_VERTICAL) {\n actions.push(TOUCH_ACTION_PAN_X);\n }\n return actions;\n },\n\n directionTest: function(input) {\n var options = this.options;\n var hasMoved = true;\n var distance = input.distance;\n var direction = input.direction;\n var x = input.deltaX;\n var y = input.deltaY;\n\n // lock to axis?\n if (!(direction & options.direction)) {\n if (options.direction & DIRECTION_HORIZONTAL) {\n direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n hasMoved = x != this.pX;\n distance = Math.abs(input.deltaX);\n } else {\n direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n hasMoved = y != this.pY;\n distance = Math.abs(input.deltaY);\n }\n }\n input.direction = direction;\n return hasMoved && distance > options.threshold && direction & options.direction;\n },\n\n attrTest: function(input) {\n return AttrRecognizer.prototype.attrTest.call(this, input) &&\n (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n },\n\n emit: function(input) {\n\n this.pX = input.deltaX;\n this.pY = input.deltaY;\n\n var direction = directionStr(input.direction);\n\n if (direction) {\n input.additionalEvent = this.options.event + direction;\n }\n this._super.emit.call(this, input);\n }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n /**\n * @namespace\n * @memberof PinchRecognizer\n */\n defaults: {\n event: 'pinch',\n threshold: 0,\n pointers: 2\n },\n\n getTouchAction: function() {\n return [TOUCH_ACTION_NONE];\n },\n\n attrTest: function(input) {\n return this._super.attrTest.call(this, input) &&\n (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n },\n\n emit: function(input) {\n if (input.scale !== 1) {\n var inOut = input.scale < 1 ? 'in' : 'out';\n input.additionalEvent = this.options.event + inOut;\n }\n this._super.emit.call(this, input);\n }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n Recognizer.apply(this, arguments);\n\n this._timer = null;\n this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n /**\n * @namespace\n * @memberof PressRecognizer\n */\n defaults: {\n event: 'press',\n pointers: 1,\n time: 251, // minimal time of the pointer to be pressed\n threshold: 9 // a minimal movement is ok, but keep it low\n },\n\n getTouchAction: function() {\n return [TOUCH_ACTION_AUTO];\n },\n\n process: function(input) {\n var options = this.options;\n var validPointers = input.pointers.length === options.pointers;\n var validMovement = input.distance < options.threshold;\n var validTime = input.deltaTime > options.time;\n\n this._input = input;\n\n // we only allow little movement\n // and we've reached an end event, so a tap is possible\n if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n this.reset();\n } else if (input.eventType & INPUT_START) {\n this.reset();\n this._timer = setTimeoutContext(function() {\n this.state = STATE_RECOGNIZED;\n this.tryEmit();\n }, options.time, this);\n } else if (input.eventType & INPUT_END) {\n return STATE_RECOGNIZED;\n }\n return STATE_FAILED;\n },\n\n reset: function() {\n clearTimeout(this._timer);\n },\n\n emit: function(input) {\n if (this.state !== STATE_RECOGNIZED) {\n return;\n }\n\n if (input && (input.eventType & INPUT_END)) {\n this.manager.emit(this.options.event + 'up', input);\n } else {\n this._input.timeStamp = now();\n this.manager.emit(this.options.event, this._input);\n }\n }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n /**\n * @namespace\n * @memberof RotateRecognizer\n */\n defaults: {\n event: 'rotate',\n threshold: 0,\n pointers: 2\n },\n\n getTouchAction: function() {\n return [TOUCH_ACTION_NONE];\n },\n\n attrTest: function(input) {\n return this._super.attrTest.call(this, input) &&\n (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n /**\n * @namespace\n * @memberof SwipeRecognizer\n */\n defaults: {\n event: 'swipe',\n threshold: 10,\n velocity: 0.3,\n direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n pointers: 1\n },\n\n getTouchAction: function() {\n return PanRecognizer.prototype.getTouchAction.call(this);\n },\n\n attrTest: function(input) {\n var direction = this.options.direction;\n var velocity;\n\n if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n velocity = input.overallVelocity;\n } else if (direction & DIRECTION_HORIZONTAL) {\n velocity = input.overallVelocityX;\n } else if (direction & DIRECTION_VERTICAL) {\n velocity = input.overallVelocityY;\n }\n\n return this._super.attrTest.call(this, input) &&\n direction & input.offsetDirection &&\n input.distance > this.options.threshold &&\n input.maxPointers == this.options.pointers &&\n abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n },\n\n emit: function(input) {\n var direction = directionStr(input.offsetDirection);\n if (direction) {\n this.manager.emit(this.options.event + direction, input);\n }\n\n this.manager.emit(this.options.event, input);\n }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n Recognizer.apply(this, arguments);\n\n // previous time and center,\n // used for tap counting\n this.pTime = false;\n this.pCenter = false;\n\n this._timer = null;\n this._input = null;\n this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n /**\n * @namespace\n * @memberof PinchRecognizer\n */\n defaults: {\n event: 'tap',\n pointers: 1,\n taps: 1,\n interval: 300, // max time between the multi-tap taps\n time: 250, // max time of the pointer to be down (like finger on the screen)\n threshold: 9, // a minimal movement is ok, but keep it low\n posThreshold: 10 // a multi-tap can be a bit off the initial position\n },\n\n getTouchAction: function() {\n return [TOUCH_ACTION_MANIPULATION];\n },\n\n process: function(input) {\n var options = this.options;\n\n var validPointers = input.pointers.length === options.pointers;\n var validMovement = input.distance < options.threshold;\n var validTouchTime = input.deltaTime < options.time;\n\n this.reset();\n\n if ((input.eventType & INPUT_START) && (this.count === 0)) {\n return this.failTimeout();\n }\n\n // we only allow little movement\n // and we've reached an end event, so a tap is possible\n if (validMovement && validTouchTime && validPointers) {\n if (input.eventType != INPUT_END) {\n return this.failTimeout();\n }\n\n var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n this.pTime = input.timeStamp;\n this.pCenter = input.center;\n\n if (!validMultiTap || !validInterval) {\n this.count = 1;\n } else {\n this.count += 1;\n }\n\n this._input = input;\n\n // if tap count matches we have recognized it,\n // else it has began recognizing...\n var tapCount = this.count % options.taps;\n if (tapCount === 0) {\n // no failing requirements, immediately trigger the tap event\n // or wait as long as the multitap interval to trigger\n if (!this.hasRequireFailures()) {\n return STATE_RECOGNIZED;\n } else {\n this._timer = setTimeoutContext(function() {\n this.state = STATE_RECOGNIZED;\n this.tryEmit();\n }, options.interval, this);\n return STATE_BEGAN;\n }\n }\n }\n return STATE_FAILED;\n },\n\n failTimeout: function() {\n this._timer = setTimeoutContext(function() {\n this.state = STATE_FAILED;\n }, this.options.interval, this);\n return STATE_FAILED;\n },\n\n reset: function() {\n clearTimeout(this._timer);\n },\n\n emit: function() {\n if (this.state == STATE_RECOGNIZED) {\n this._input.tapCount = this.count;\n this.manager.emit(this.options.event, this._input);\n }\n }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n options = options || {};\n options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n /**\n * set if DOM events are being triggered.\n * But this is slower and unused by simple implementations, so disabled by default.\n * @type {Boolean}\n * @default false\n */\n domEvents: false,\n\n /**\n * The value for the touchAction property/fallback.\n * When set to `compute` it will magically set the correct value based on the added recognizers.\n * @type {String}\n * @default compute\n */\n touchAction: TOUCH_ACTION_COMPUTE,\n\n /**\n * @type {Boolean}\n * @default true\n */\n enable: true,\n\n /**\n * EXPERIMENTAL FEATURE -- can be removed/changed\n * Change the parent input target element.\n * If Null, then it is being set the to main element.\n * @type {Null|EventTarget}\n * @default null\n */\n inputTarget: null,\n\n /**\n * force an input class\n * @type {Null|Function}\n * @default null\n */\n inputClass: null,\n\n /**\n * Default recognizer setup when calling `Hammer()`\n * When creating a new Manager these will be skipped.\n * @type {Array}\n */\n preset: [\n // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n [RotateRecognizer, {enable: false}],\n [PinchRecognizer, {enable: false}, ['rotate']],\n [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n [TapRecognizer],\n [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n [PressRecognizer]\n ],\n\n /**\n * Some CSS properties can be used to improve the working of Hammer.\n * Add them to this method and they will be set when creating a new Manager.\n * @namespace\n */\n cssProps: {\n /**\n * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n * @type {String}\n * @default 'none'\n */\n userSelect: 'none',\n\n /**\n * Disable the Windows Phone grippers when pressing an element.\n * @type {String}\n * @default 'none'\n */\n touchSelect: 'none',\n\n /**\n * Disables the default callout shown when you touch and hold a touch target.\n * On iOS, when you touch and hold a touch target such as a link, Safari displays\n * a callout containing information about the link. This property allows you to disable that callout.\n * @type {String}\n * @default 'none'\n */\n touchCallout: 'none',\n\n /**\n * Specifies whether zooming is enabled. Used by IE10>\n * @type {String}\n * @default 'none'\n */\n contentZooming: 'none',\n\n /**\n * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n * @type {String}\n * @default 'none'\n */\n userDrag: 'none',\n\n /**\n * Overrides the highlight color shown when the user taps a link or a JavaScript\n * clickable element in iOS. This property obeys the alpha value, if specified.\n * @type {String}\n * @default 'rgba(0,0,0,0)'\n */\n tapHighlightColor: 'rgba(0,0,0,0)'\n }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n this.options = assign({}, Hammer.defaults, options || {});\n\n this.options.inputTarget = this.options.inputTarget || element;\n\n this.handlers = {};\n this.session = {};\n this.recognizers = [];\n this.oldCssProps = {};\n\n this.element = element;\n this.input = createInputInstance(this);\n this.touchAction = new TouchAction(this, this.options.touchAction);\n\n toggleCssProps(this, true);\n\n each(this.options.recognizers, function(item) {\n var recognizer = this.add(new (item[0])(item[1]));\n item[2] && recognizer.recognizeWith(item[2]);\n item[3] && recognizer.requireFailure(item[3]);\n }, this);\n}\n\nManager.prototype = {\n /**\n * set options\n * @param {Object} options\n * @returns {Manager}\n */\n set: function(options) {\n assign(this.options, options);\n\n // Options that need a little more setup\n if (options.touchAction) {\n this.touchAction.update();\n }\n if (options.inputTarget) {\n // Clean up existing event listeners and reinitialize\n this.input.destroy();\n this.input.target = options.inputTarget;\n this.input.init();\n }\n return this;\n },\n\n /**\n * stop recognizing for this session.\n * This session will be discarded, when a new [input]start event is fired.\n * When forced, the recognizer cycle is stopped immediately.\n * @param {Boolean} [force]\n */\n stop: function(force) {\n this.session.stopped = force ? FORCED_STOP : STOP;\n },\n\n /**\n * run the recognizers!\n * called by the inputHandler function on every movement of the pointers (touches)\n * it walks through all the recognizers and tries to detect the gesture that is being made\n * @param {Object} inputData\n */\n recognize: function(inputData) {\n var session = this.session;\n if (session.stopped) {\n return;\n }\n\n // run the touch-action polyfill\n this.touchAction.preventDefaults(inputData);\n\n var recognizer;\n var recognizers = this.recognizers;\n\n // this holds the recognizer that is being recognized.\n // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n // if no recognizer is detecting a thing, it is set to `null`\n var curRecognizer = session.curRecognizer;\n\n // reset when the last recognizer is recognized\n // or when we're in a new session\n if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n curRecognizer = session.curRecognizer = null;\n }\n\n var i = 0;\n while (i < recognizers.length) {\n recognizer = recognizers[i];\n\n // find out if we are allowed try to recognize the input for this one.\n // 1. allow if the session is NOT forced stopped (see the .stop() method)\n // 2. allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n // that is being recognized.\n // 3. allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n // this can be setup with the `recognizeWith()` method on the recognizer.\n if (session.stopped !== FORCED_STOP && ( // 1\n !curRecognizer || recognizer == curRecognizer || // 2\n recognizer.canRecognizeWith(curRecognizer))) { // 3\n recognizer.recognize(inputData);\n } else {\n recognizer.reset();\n }\n\n // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n // current active recognizer. but only if we don't already have an active recognizer\n if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n curRecognizer = session.curRecognizer = recognizer;\n }\n i++;\n }\n },\n\n /**\n * get a recognizer by its event name.\n * @param {Recognizer|String} recognizer\n * @returns {Recognizer|Null}\n */\n get: function(recognizer) {\n if (recognizer instanceof Recognizer) {\n return recognizer;\n }\n\n var recognizers = this.recognizers;\n for (var i = 0; i < recognizers.length; i++) {\n if (recognizers[i].options.event == recognizer) {\n return recognizers[i];\n }\n }\n return null;\n },\n\n /**\n * add a recognizer to the manager\n * existing recognizers with the same event name will be removed\n * @param {Recognizer} recognizer\n * @returns {Recognizer|Manager}\n */\n add: function(recognizer) {\n if (invokeArrayArg(recognizer, 'add', this)) {\n return this;\n }\n\n // remove existing\n var existing = this.get(recognizer.options.event);\n if (existing) {\n this.remove(existing);\n }\n\n this.recognizers.push(recognizer);\n recognizer.manager = this;\n\n this.touchAction.update();\n return recognizer;\n },\n\n /**\n * remove a recognizer by name or instance\n * @param {Recognizer|String} recognizer\n * @returns {Manager}\n */\n remove: function(recognizer) {\n if (invokeArrayArg(recognizer, 'remove', this)) {\n return this;\n }\n\n recognizer = this.get(recognizer);\n\n // let's make sure this recognizer exists\n if (recognizer) {\n var recognizers = this.recognizers;\n var index = inArray(recognizers, recognizer);\n\n if (index !== -1) {\n recognizers.splice(index, 1);\n this.touchAction.update();\n }\n }\n\n return this;\n },\n\n /**\n * bind event\n * @param {String} events\n * @param {Function} handler\n * @returns {EventEmitter} this\n */\n on: function(events, handler) {\n if (events === undefined) {\n return;\n }\n if (handler === undefined) {\n return;\n }\n\n var handlers = this.handlers;\n each(splitStr(events), function(event) {\n handlers[event] = handlers[event] || [];\n handlers[event].push(handler);\n });\n return this;\n },\n\n /**\n * unbind event, leave emit blank to remove all handlers\n * @param {String} events\n * @param {Function} [handler]\n * @returns {EventEmitter} this\n */\n off: function(events, handler) {\n if (events === undefined) {\n return;\n }\n\n var handlers = this.handlers;\n each(splitStr(events), function(event) {\n if (!handler) {\n delete handlers[event];\n } else {\n handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n }\n });\n return this;\n },\n\n /**\n * emit event to the listeners\n * @param {String} event\n * @param {Object} data\n */\n emit: function(event, data) {\n // we also want to trigger dom events\n if (this.options.domEvents) {\n triggerDomEvent(event, data);\n }\n\n // no handlers, so skip it all\n var handlers = this.handlers[event] && this.handlers[event].slice();\n if (!handlers || !handlers.length) {\n return;\n }\n\n data.type = event;\n data.preventDefault = function() {\n data.srcEvent.preventDefault();\n };\n\n var i = 0;\n while (i < handlers.length) {\n handlers[i](data);\n i++;\n }\n },\n\n /**\n * destroy the manager and unbinds all events\n * it doesn't unbind dom events, that is the user own responsibility\n */\n destroy: function() {\n this.element && toggleCssProps(this, false);\n\n this.handlers = {};\n this.session = {};\n this.input.destroy();\n this.element = null;\n }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n var element = manager.element;\n if (!element.style) {\n return;\n }\n var prop;\n each(manager.options.cssProps, function(value, name) {\n prop = prefixed(element.style, name);\n if (add) {\n manager.oldCssProps[prop] = element.style[prop];\n element.style[prop] = value;\n } else {\n element.style[prop] = manager.oldCssProps[prop] || '';\n }\n });\n if (!add) {\n manager.oldCssProps = {};\n }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n var gestureEvent = document.createEvent('Event');\n gestureEvent.initEvent(event, true, true);\n gestureEvent.gesture = data;\n data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n INPUT_START: INPUT_START,\n INPUT_MOVE: INPUT_MOVE,\n INPUT_END: INPUT_END,\n INPUT_CANCEL: INPUT_CANCEL,\n\n STATE_POSSIBLE: STATE_POSSIBLE,\n STATE_BEGAN: STATE_BEGAN,\n STATE_CHANGED: STATE_CHANGED,\n STATE_ENDED: STATE_ENDED,\n STATE_RECOGNIZED: STATE_RECOGNIZED,\n STATE_CANCELLED: STATE_CANCELLED,\n STATE_FAILED: STATE_FAILED,\n\n DIRECTION_NONE: DIRECTION_NONE,\n DIRECTION_LEFT: DIRECTION_LEFT,\n DIRECTION_RIGHT: DIRECTION_RIGHT,\n DIRECTION_UP: DIRECTION_UP,\n DIRECTION_DOWN: DIRECTION_DOWN,\n DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n DIRECTION_ALL: DIRECTION_ALL,\n\n Manager: Manager,\n Input: Input,\n TouchAction: TouchAction,\n\n TouchInput: TouchInput,\n MouseInput: MouseInput,\n PointerEventInput: PointerEventInput,\n TouchMouseInput: TouchMouseInput,\n SingleTouchInput: SingleTouchInput,\n\n Recognizer: Recognizer,\n AttrRecognizer: AttrRecognizer,\n Tap: TapRecognizer,\n Pan: PanRecognizer,\n Swipe: SwipeRecognizer,\n Pinch: PinchRecognizer,\n Rotate: RotateRecognizer,\n Press: PressRecognizer,\n\n on: addEventListeners,\n off: removeEventListeners,\n each: each,\n merge: merge,\n extend: extend,\n assign: assign,\n inherit: inherit,\n bindFn: bindFn,\n prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n// style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n define(function() {\n return Hammer;\n });\n} else if (typeof module != 'undefined' && module.exports) {\n module.exports = Hammer;\n} else {\n window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","// extracted by mini-css-extract-plugin\nexport {};","import { render } from \"./RepoContributors.vue?vue&type=template&id=691b21a1&scoped=true\"\nimport script from \"./RepoContributors.vue?vue&type=script&lang=js\"\nexport * from \"./RepoContributors.vue?vue&type=script&lang=js\"\n\nimport \"./RepoContributors.vue?vue&type=style&index=0&id=691b21a1&scoped=true&lang=css\"\n\nimport exportComponent from \"../../../node_modules/vue-loader/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render],['__scopeId',\"data-v-691b21a1\"],['__file',\"web_src/js/components/RepoContributors.vue\"]])\n/* hot reload */\nif (module.hot) {\n __exports__.__hmrId = \"691b21a1\"\n const api = __VUE_HMR_RUNTIME__\n module.hot.accept()\n if (!api.createRecord('691b21a1', __exports__)) {\n api.reload('691b21a1', __exports__)\n }\n \n module.hot.accept(\"./RepoContributors.vue?vue&type=template&id=691b21a1&scoped=true\", () => {\n api.rerender('691b21a1', render)\n })\n\n}\n\n\nexport default __exports__","export { default } from \"-!../../../node_modules/esbuild-loader/dist/index.cjs??clonedRuleSet-1.use[0]!../../../node_modules/vue-loader/dist/index.js??ruleSet[0]!./RepoContributors.vue?vue&type=script&lang=js\"; export * from \"-!../../../node_modules/esbuild-loader/dist/index.cjs??clonedRuleSet-1.use[0]!../../../node_modules/vue-loader/dist/index.js??ruleSet[0]!./RepoContributors.vue?vue&type=script&lang=js\"","export * from \"-!../../../node_modules/esbuild-loader/dist/index.cjs??clonedRuleSet-1.use[0]!../../../node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!../../../node_modules/vue-loader/dist/index.js??ruleSet[0]!./RepoContributors.vue?vue&type=template&id=691b21a1&scoped=true\"","export * from \"-!../../../node_modules/mini-css-extract-plugin/dist/loader.js!../../../node_modules/css-loader/dist/cjs.js??clonedRuleSet-2.use[1]!../../../node_modules/vue-loader/dist/stylePostLoader.js!../../../node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-2.use[2]!../../../node_modules/vue-loader/dist/index.js??ruleSet[0]!./RepoContributors.vue?vue&type=style&index=0&id=691b21a1&scoped=true&lang=css\"","/*!\n * Chart.js v4.4.2\n * https://www.chartjs.org\n * (c) 2024 Chart.js Contributors\n * Released under the MIT License\n */\nexport { H as HALF_PI, b2 as INFINITY, P as PI, b1 as PITAU, b4 as QUARTER_PI, b3 as RAD_PER_DEG, T as TAU, b5 as TWO_THIRDS_PI, R as _addGrace, X as _alignPixel, a2 as _alignStartEnd, p as _angleBetween, b6 as _angleDiff, _ as _arrayUnique, a8 as _attachContext, as as _bezierCurveTo, ap as _bezierInterpolation, ax as _boundSegment, an as _boundSegments, a5 as _capitalize, am as _computeSegments, a9 as _createResolver, aK as _decimalPlaces, aV as _deprecated, aa as _descriptors, ah as _elementsEqual, N as _factorize, aO as _filterBetween, I as _getParentNode, q as _getStartAndCountOfVisiblePoints, W as _int16Range, aj as _isBetween, ai as _isClickEvent, M as _isDomSupported, C as _isPointInArea, S as _limitValue, aN as _longestText, aP as _lookup, B as _lookupByKey, V as _measureText, aT as _merger, aU as _mergerIf, ay as _normalizeAngle, y as _parseObjectDataRadialScale, aq as _pointInLine, ak as _readValueToProps, A as _rlookupByKey, w as _scaleRangesChanged, aG as _setMinAndMaxByKey, aW as _splitKey, ao as _steppedInterpolation, ar as _steppedLineTo, aB as _textX, a1 as _toLeftRightCenter, al as _updateBezierControlPoints, au as addRoundedRectPath, aJ as almostEquals, aI as almostWhole, Q as callback, af as clearCanvas, Y as clipArea, aS as clone, c as color, j as createContext, ad as debounce, h as defined, aE as distanceBetweenPoints, at as drawPoint, aD as drawPointLegend, F as each, e as easingEffects, O as finiteOrDefault, a$ as fontString, o as formatNumber, D as getAngleFromPoint, aR as getHoverColor, G as getMaximumSize, z as getRelativePosition, az as getRtlAdapter, a_ as getStyle, b as isArray, g as isFinite, a7 as isFunction, k as isNullOrUndef, x as isNumber, i as isObject, aQ as isPatternOrGradient, l as listenArrayEvents, aM as log10, a4 as merge, ab as mergeIf, aH as niceNum, aF as noop, aA as overrideTextDirection, J as readUsedSize, Z as renderText, r as requestAnimFrame, a as resolve, f as resolveObjectKey, aC as restoreTextDirection, ae as retinaScale, ag as setsEqual, s as sign, aY as splineCurve, aZ as splineCurveMonotone, K as supportsEventListenerOptions, L as throttled, U as toDegrees, n as toDimension, a0 as toFont, aX as toFontString, b0 as toLineHeight, E as toPadding, m as toPercentage, t as toRadians, av as toTRBL, aw as toTRBLCorners, ac as uid, $ as unclipArea, u as unlistenArrayEvents, v as valueOrDefault } from './chunks/helpers.segment.js';\nimport '@kurkle/color';\n//# sourceMappingURL=helpers.js.map\n","export * from '../dist/helpers.js';\n"],"names":[],"sourceRoot":""}