ToB企服应用市场:ToB评测及商务社交产业平台

标题: SignalR实战：在.NET Framework和.NET Core中如何使用SignalR？ [打印本页]

---

作者: 张春    时间: 2023-8-31 04:16
标题: SignalR实战：在.NET Framework和.NET Core中如何使用SignalR？

官网文档：https://learn.microsoft.com/zh-cn/aspnet/core/tutorials/signalr?view=aspnetcore-6.0&tabs=visual-studio
SignalR开源代码：https://github.com/signalr

很多小伙伴问：在前后端分离项目中，后端是.NET Core前端是Vue如何使用SignalR？在前后端不分离项目中，.NET Framework MVC项目中又如何使用SignalR技术呢？那就来看看下面这篇文章吧！本文主要介绍SignalR在实际项目中的应用，以及.NET Framework和.NET Core中如何去使用SignalR。

一、SignalR介绍

1.1-SignalR介绍

ASP.NET Core SignalR是一个开放源代码库，可用于简化向应用添加实时Web功能，实时Web功能使服务器端代码能够将内容推送到客户端。

1.2-SignalR的应用

• 需要从服务器进行高频更新的应用：包括游戏、社交网络、投票、拍卖、地图和GPS引用。
  
• 仪表盘和监视应用：包括公司仪表板、即时销售更新或旅行报警
  
• 协作应用：包括白板应用和团队会议软件。
  
• 通知应用：社交网络、电子邮件、聊天、游戏、旅行报警和其他应用都需要使用的通知。
  

二、.NET Framework使用SignalR

参考文献：
Owin介绍：https://www.cnblogs.com/Pinapple/p/6721361.html
Owin相关案例：https://blog.csdn.net/bifan546/article/details/77098896/

2.1-服务端（.NET Framework MVC）

（1）选择要使用Signalr的项目，点击【管理NuGet程序包】。

（2）搜索【SignalR】包，找到这个后然后点击下载。

会自动安装四个，注意他们之间有依赖关系：

（3）.NET Framework平台需要添加Owin相关的包。
OWIN 是一种定义 Web 服务器和应用程序组件之间的交互的规范 。这一规范的目的是发展一个广阔且充满活力的、基于 Microsoft .NET Framework 的 Web 服务器和应用程序组件生态系统。

Microsoft.Owin.Hosting
Microsoft.Owin.Cors
Microsoft.Owin.Host.HttpListener

（4）在Web项目（要使用的Signal）中创建一个【Startup.cs】文件。

1. using JiCai.Admin.Hubs;
2. using Microsoft.Owin;
3. using Owin;
5. [assembly: OwinStartup(typeof(JiCai.Admin.Startup))]
6. namespace JiCai.Admin
7. {
8.     public class Startup
9.     {
10.         /// <summary>
11.         /// 应用程序配置
12.         /// </summary>
13.         /// <param name="app"></param>
14.         public void Configuration(IAppBuilder app)
15.         {
16.             //启用SignalR
17.             app.MapSignalR();
18.             //绑定多个Hub
19.             app.MapSignalR<DemoHub>("/demoHub");
20.         }
21.     }
22. }

复制代码

例如：

（5）可以创建一个【Hubs】文件夹，专门放置Hub相关文件。[西瓜程序猿]这边是创建一个Hub文件，名为【DemoHub.cs】。

1. using Fenqibao.DTO;
2. using JiCai.Admin.Hubs.ConectionOperate;
3. using JiCai.Admin.Hubs.Models;
4. using log4net;
5. using Microsoft.AspNet.SignalR;
6. using Microsoft.AspNet.SignalR.Json;
7. using Newtonsoft.Json;
8. using System;
9. using System.Collections.Generic;
10. using System.Linq;
11. using System.Threading.Tasks;
13. namespace JiCai.Admin.Hubs
14. {
15.     /// <summary>
16.     /// 报表管理-总表Hub
17.     /// </summary>
18.     public class SummaryTableHub :  PersistentConnection
19.     {
20.         public readonly BaseService _base = new BaseService();
21.         private readonly ILog logger = LogManager.GetLogger(typeof(SummaryTableHub));
22.         private ConnectionManagement summaryTableCon = new ConnectionManagement();
23.         public CookieUserData LoginUserData
24.         {
25.             get
26.             {
27.                 IOperator oper = ContainerManager.Resolve<IOperator>();
28.                 LoginUser loginUser = oper as LoginUser;
29.                 if (loginUser != null && loginUser.UserData != null)
30.                 {
31.                     return loginUser.UserData;
32.                 }
33.                 return null;
34.             }
35.         }
37.         /// <summary>
38.         /// 连接成功后调用
39.         /// </summary>
40.         /// <param name="request"></param>
41.         /// <param name="connectionId"></param>
42.         /// <returns></returns>
43.         protected override Task OnConnected(IRequest request, string connectionId)
44.         {
45.             //获得SignalR的连接id
46.             var connid = connectionId;
47.             //获得用户id
48.             var userid = LoginUserData.Id.ToString();
49.             Console.Write($"【{connid}】：已建立连接！");
51.             //判断一下用户是不是已经链接了
52.             var checkUserConn = summaryTableCon.IsConn(connid, userid);
53.             if (!checkUserConn)
54.             {
55.                 //添加一个新的连接
56.                 summaryTableCon.AddConnInfo(new SignalRConn()
57.                 {
58.                     UserId = userid,
59.                     ConnectionId = connid
60.                 });
61.             }
62.             //更新连接
63.             else
64.             {
65.                 summaryTableCon.UpdateConnInfo(userid, connid);
66.             }
68.             return Connection.Send(connectionId, $"【用户：{connectionId}】真正连接成功！");
69.             //return base.OnConnected(request, connectionId);
70.         }
72.         /// <summary>
73.         /// 接收到请求的时候调用
74.         /// </summary>
75.         /// <param name="request"></param>
76.         /// <param name="connectionId"></param>
77.         /// <param name="data"></param>
78.         /// <returns></returns>
79.         protected override async Task OnReceived(IRequest request, string connectionId, string data)
80.         {
81.             //获得用户id
82.             var userid = LoginUserData.Id.ToString();
83.             await Task.Factory.StartNew(async () =>
84.             {
85.                 while (true)
86.                 {
87.                                         var list = GetSummaryTableList(userid);
88.                     string json_jieshou_mes = "";
89.                     if (list != null && list.Count > 0)
90.                     {
91.                                                 json_jieshou_mes = JsonConvert.SerializeObject(list);
92.                     }
95.                     await Connection.Send(connectionId, json_jieshou_mes);
97.                     //每5秒同步一次
98.                     await Task.Delay(5000);
99.                 }
100.             }, TaskCreationOptions.LongRunning);
102.             //return base.OnReceived(request, connectionId, data);
103.         }
105.         /// <summary>
106.         /// 连接中断的时候调用
107.         /// </summary>
108.         /// <param name="request"></param>
109.         /// <param name="connectionId"></param>
110.         /// <param name="stopCalled"></param>
111.         /// <returns></returns>
112.         protected override Task OnDisconnected(IRequest request, string connectionId, bool stopCalled)
113.         {
114.             Console.Write($"【{connectionId}】：已断开连接！");
115.             //获得SignalR的连接id
116.             var connid = connectionId;
117.             //关闭连接
118.             summaryTableCon.DelConnInfo(connid);
119.             return base.OnDisconnected(request, connectionId, stopCalled);
120.         }
122.         /// <summary>
123.         /// 连接超时重新连接的时候调用
124.         /// </summary>
125.         /// <param name="request"></param>
126.         /// <param name="connectionId"></param>
127.         /// <returns></returns>
128.         protected override Task OnReconnected(IRequest request, string connectionId)
129.         {
130.             return base.OnReconnected(request, connectionId);
131.         }
134.                 /// <summary>
135.                 /// 查询数据
136.                 /// </summary>
137.                 /// <param name="userId"></param>
138.                 /// <returns></returns>
139.                 private List<SummaryTableDataModel> GetSummaryTableList(string userId)
140.         {
141.             var result = _base.Query<SummaryTableDataModel>($@"
142.                             select * from demo-data
143.                                         ;
144.             ").ToList();
145.                         return result;
146.         }
147.     }
148. }

复制代码

（6）在Hubs/ConectionOperate文件夹中，[西瓜程序猿]这边创建【ConnectionManagement】文件，用来管理所有连接。

1. using System.Collections.Generic;
2. using System.Linq;
4. namespace JiCai.Admin.Hubs.ConectionOperate
5. {
6.     /// <summary>
7.     /// 连接管理
8.     /// </summary>
9.     public class ConnectionManagement
10.     {
11.         /// <summary>
12.         /// 用户连接集合
13.         /// </summary>
14.         public static  List<SignalRConn> SignalRConns { get; set; } = new List<SignalRConn>();
16.         /// <summary>
17.         /// 添加连接
18.         /// </summary>
19.         /// <param name="conn"></param>
20.         public  void AddConnInfo(SignalRConn conn)
21.         {
22.             SignalRConns.Add(conn);
23.         }
25.         /// <summary>
26.         /// 删除连接
27.         /// </summary>
28.         /// <param name="connid"></param>
29.         public  void DelConnInfo(string connid)
30.         {
31.             var signalRConns = SignalRConns.FirstOrDefault(u => u.ConnectionId == connid);
32.             if (signalRConns != null)
33.             {
34.                 SignalRConns.Remove(signalRConns);
35.             }
36.         }
38.         /// <summary>
39.         /// 更新链接（老的链接不起作用了）
40.         /// 场景：客户端重连了，userid没变，但是connid变了
41.         /// </summary>
42.         /// <param name="userId">用户id</param>
43.         /// <param name="newConnsId">新的链接id</param>
44.         public  void UpdateConnInfo(string userId, string newConnsId)
45.         {
46.             var signalRConns = SignalRConns.FirstOrDefault(u => u.UserId.ToLower() == userId.ToLower());
47.             if (signalRConns != null)
48.             {
49.                 signalRConns.ConnectionId = newConnsId;
50.             }
51.         }
53.         /// <summary>
54.         /// 判断用户是否已经链接
55.         /// </summary>
56.         /// <param name="connid">连接id</param>
57.         /// <param name="userid">用户id</param>
58.         /// <returns></returns>
59.         public bool IsConn(string connid,string userid)
60.         {
61.             var userConn = SignalRConns.FirstOrDefault(u => u.ConnectionId.ToLower() == connid.ToLower() && u.UserId.ToLower() == userid.ToLower());
62.             return userConn == null ? false : true;
63.         }
64.     }
65. }

复制代码

（7）在Hubs/ConectionOperate文件夹中，创建【SignalRConn.cs】文件用来作为SignalR和系统用户的连接实体。

1. namespace JiCai.Admin.Hubs.ConectionOperate
2. {
3.     /// <summary>
4.     /// 连接
5.     /// </summary>
6.     public class SignalRConn
7.     {
8.         /// <summary>
9.         /// 系统用户id
10.         /// </summary>
11.         public string UserId { get; set; }
13.         /// <summary>
14.         /// SignleR链接Id（每次链接SignalR都会分配一个id）
15.         /// </summary>
16.         public string ConnectionId { get; set; }
17.     }
18. }

复制代码

2.2-客户端（JS）

（1）下载相关jq/signalr相关包，可以自行找CDN直接访问。也可以自行新建这2个文件，然后复制一下内容。
【jquery.signalR-2.4.3.js】：

1. /* jquery.signalR.core.js */
2. /*global window:false */
3. /*!
4. * ASP.NET SignalR JavaScript Library 2.4.3
5. * http://signalr.net/
6. *
7. * Copyright (c) .NET Foundation. All rights reserved.
8. * Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
9. *
10. */
12. /// <reference path="Scripts/jquery-1.6.4.js" />
13. /// <reference path="jquery.signalR.version.js" />
14. (function ($, window, undefined) {
16.     var resources = {
17.         nojQuery: "jQuery was not found. Please ensure jQuery is referenced before the SignalR client JavaScript file.",
18.         noTransportOnInit: "No transport could be initialized successfully. Try specifying a different transport or none at all for auto initialization.",
19.         errorOnNegotiate: "Error during negotiation request.",
20.         stoppedWhileLoading: "The connection was stopped during page load.",
21.         stoppedWhileNegotiating: "The connection was stopped during the negotiate request.",
22.         errorParsingNegotiateResponse: "Error parsing negotiate response.",
23.         errorRedirectionExceedsLimit: "Negotiate redirection limit exceeded.",
24.         errorDuringStartRequest: "Error during start request. Stopping the connection.",
25.         errorFromServer: "Error message received from the server: '{0}'.",
26.         stoppedDuringStartRequest: "The connection was stopped during the start request.",
27.         errorParsingStartResponse: "Error parsing start response: '{0}'. Stopping the connection.",
28.         invalidStartResponse: "Invalid start response: '{0}'. Stopping the connection.",
29.         protocolIncompatible: "You are using a version of the client that isn't compatible with the server. Client version {0}, server version {1}.",
30.         aspnetCoreSignalrServer: "Detected a connection attempt to an ASP.NET Core SignalR Server. This client only supports connecting to an ASP.NET SignalR Server. See https://aka.ms/signalr-core-differences for details.",
31.         sendFailed: "Send failed.",
32.         parseFailed: "Failed at parsing response: {0}",
33.         longPollFailed: "Long polling request failed.",
34.         eventSourceFailedToConnect: "EventSource failed to connect.",
35.         eventSourceError: "Error raised by EventSource",
36.         webSocketClosed: "WebSocket closed.",
37.         pingServerFailedInvalidResponse: "Invalid ping response when pinging server: '{0}'.",
38.         pingServerFailed: "Failed to ping server.",
39.         pingServerFailedStatusCode: "Failed to ping server.  Server responded with status code {0}, stopping the connection.",
40.         pingServerFailedParse: "Failed to parse ping server response, stopping the connection.",
41.         noConnectionTransport: "Connection is in an invalid state, there is no transport active.",
42.         webSocketsInvalidState: "The Web Socket transport is in an invalid state, transitioning into reconnecting.",
43.         reconnectTimeout: "Couldn't reconnect within the configured timeout of {0} ms, disconnecting.",
44.         reconnectWindowTimeout: "The client has been inactive since {0} and it has exceeded the inactivity timeout of {1} ms. Stopping the connection.",
45.         jsonpNotSupportedWithAccessToken: "The JSONP protocol does not support connections that require a Bearer token to connect, such as the Azure SignalR Service."
46.     };
48.     if (typeof ($) !== "function") {
49.         // no jQuery!
50.         throw new Error(resources.nojQuery);
51.     }
53.     var signalR,
54.         _connection,
55.         _pageLoaded = (window.document.readyState === "complete"),
56.         _pageWindow = $(window),
57.         _negotiateAbortText = "__Negotiate Aborted__",
58.         events = {
59.             onStart: "onStart",
60.             onStarting: "onStarting",
61.             onReceived: "onReceived",
62.             onError: "onError",
63.             onConnectionSlow: "onConnectionSlow",
64.             onReconnecting: "onReconnecting",
65.             onReconnect: "onReconnect",
66.             onStateChanged: "onStateChanged",
67.             onDisconnect: "onDisconnect"
68.         },
69.         ajaxDefaults = {
70.             processData: true,
71.             timeout: null,
72.             async: true,
73.             global: false,
74.             cache: false
75.         },
76.         log = function (msg, logging) {
77.             if (logging === false) {
78.                 return;
79.             }
80.             var m;
81.             if (typeof (window.console) === "undefined") {
82.                 return;
83.             }
84.             m = "[" + new Date().toTimeString() + "] SignalR: " + msg;
85.             if (window.console.debug) {
86.                 window.console.debug(m);
87.             } else if (window.console.log) {
88.                 window.console.log(m);
89.             }
90.         },
92.         changeState = function (connection, expectedState, newState) {
93.             if (expectedState === connection.state) {
94.                 connection.state = newState;
96.                 $(connection).triggerHandler(events.onStateChanged, [{ oldState: expectedState, newState: newState }]);
97.                 return true;
98.             }
100.             return false;
101.         },
103.         isDisconnecting = function (connection) {
104.             return connection.state === signalR.connectionState.disconnected;
105.         },
107.         supportsKeepAlive = function (connection) {
108.             return connection._.keepAliveData.activated &&
109.                 connection.transport.supportsKeepAlive(connection);
110.         },
112.         configureStopReconnectingTimeout = function (connection) {
113.             var stopReconnectingTimeout,
114.                 onReconnectTimeout;
116.             // Check if this connection has already been configured to stop reconnecting after a specified timeout.
117.             // Without this check if a connection is stopped then started events will be bound multiple times.
118.             if (!connection._.configuredStopReconnectingTimeout) {
119.                 onReconnectTimeout = function (connection) {
120.                     var message = signalR._.format(signalR.resources.reconnectTimeout, connection.disconnectTimeout);
121.                     connection.log(message);
122.                     $(connection).triggerHandler(events.onError, [signalR._.error(message, /* source */ "TimeoutException")]);
123.                     connection.stop(/* async */ false, /* notifyServer */ false);
124.                 };
126.                 connection.reconnecting(function () {
127.                     var connection = this;
129.                     // Guard against state changing in a previous user defined even handler
130.                     if (connection.state === signalR.connectionState.reconnecting) {
131.                         stopReconnectingTimeout = window.setTimeout(function () { onReconnectTimeout(connection); }, connection.disconnectTimeout);
132.                     }
133.                 });
135.                 connection.stateChanged(function (data) {
136.                     if (data.oldState === signalR.connectionState.reconnecting) {
137.                         // Clear the pending reconnect timeout check
138.                         window.clearTimeout(stopReconnectingTimeout);
139.                     }
140.                 });
142.                 connection._.configuredStopReconnectingTimeout = true;
143.             }
144.         };
146.     signalR = function (url, qs, logging) {
147.         /// <summary>Creates a new SignalR connection for the given url</summary>
148.         /// <param name="url" type="String">The URL of the long polling endpoint</param>
149.         /// <param name="qs" type="Object">
150.         ///     [Optional] Custom querystring parameters to add to the connection URL.
151.         ///     If an object, every non-function member will be added to the querystring.
152.         ///     If a string, it's added to the QS as specified.
153.         /// </param>
154.         /// <param name="logging" type="Boolean">
155.         ///     [Optional] A flag indicating whether connection logging is enabled to the browser
156.         ///     console/log. Defaults to false.
157.         /// </param>
159.         return new signalR.fn.init(url, qs, logging);
160.     };
162.     signalR._ = {
163.         defaultContentType: "application/x-www-form-urlencoded; charset=UTF-8",
165.         ieVersion: (function () {
166.             var version,
167.                 matches;
169.             if (window.navigator.appName === 'Microsoft Internet Explorer') {
170.                 // Check if the user agent has the pattern "MSIE (one or more numbers).(one or more numbers)";
171.                 matches = /MSIE ([0-9]+\.[0-9]+)/.exec(window.navigator.userAgent);
173.                 if (matches) {
174.                     version = window.parseFloat(matches[1]);
175.                 }
176.             }
178.             // undefined value means not IE
179.             return version;
180.         })(),
182.         error: function (message, source, context) {
183.             var e = new Error(message);
184.             e.source = source;
186.             if (typeof context !== "undefined") {
187.                 e.context = context;
188.             }
190.             return e;
191.         },
193.         transportError: function (message, transport, source, context) {
194.             var e = this.error(message, source, context);
195.             e.transport = transport ? transport.name : undefined;
196.             return e;
197.         },
199.         format: function () {
200.             /// <summary>Usage: format("Hi {0}, you are {1}!", "Foo", 100) </summary>
201.             var s = arguments[0];
202.             for (var i = 0; i < arguments.length - 1; i++) {
203.                 s = s.replace("{" + i + "}", arguments[i + 1]);
204.             }
205.             return s;
206.         },
208.         firefoxMajorVersion: function (userAgent) {
209.             // Firefox user agents: http://useragentstring.com/pages/Firefox/
210.             var matches = userAgent.match(/Firefox\/(\d+)/);
211.             if (!matches || !matches.length || matches.length < 2) {
212.                 return 0;
213.             }
214.             return parseInt(matches[1], 10 /* radix */);
215.         },
217.         configurePingInterval: function (connection) {
218.             var config = connection._.config,
219.                 onFail = function (error) {
220.                     $(connection).triggerHandler(events.onError, [error]);
221.                 };
223.             if (config && !connection._.pingIntervalId && config.pingInterval) {
224.                 connection._.pingIntervalId = window.setInterval(function () {
225.                     signalR.transports._logic.pingServer(connection).fail(onFail);
226.                 }, config.pingInterval);
227.             }
228.         }
229.     };
231.     signalR.events = events;
233.     signalR.resources = resources;
235.     signalR.ajaxDefaults = ajaxDefaults;
237.     signalR.changeState = changeState;
239.     signalR.isDisconnecting = isDisconnecting;
241.     signalR.connectionState = {
242.         connecting: 0,
243.         connected: 1,
244.         reconnecting: 2,
245.         disconnected: 4
246.     };
248.     signalR.hub = {
249.         start: function () {
250.             // This will get replaced with the real hub connection start method when hubs is referenced correctly
251.             throw new Error("SignalR: Error loading hubs. Ensure your hubs reference is correct, e.g. .");
252.         }
253.     };
255.     // .on() was added in version 1.7.0, .load() was removed in version 3.0.0 so we fallback to .load() if .on() does
256.     // not exist to not break existing applications
257.     if (typeof _pageWindow.on === "function") {
258.         _pageWindow.on("load", function () { _pageLoaded = true; });
259.     }
260.     else {
261.         _pageWindow.load(function () { _pageLoaded = true; });
262.     }
264.     function validateTransport(requestedTransport, connection) {
265.         /// <summary>Validates the requested transport by cross checking it with the pre-defined signalR.transports</summary>
266.         /// <param name="requestedTransport" type="Object">The designated transports that the user has specified.</param>
267.         /// <param name="connection" type="signalR">The connection that will be using the requested transports.  Used for logging purposes.</param>
268.         /// <returns type="Object" />
270.         if ($.isArray(requestedTransport)) {
271.             // Go through transport array and remove an "invalid" tranports
272.             for (var i = requestedTransport.length - 1; i >= 0; i--) {
273.                 var transport = requestedTransport[i];
274.                 if ($.type(transport) !== "string" || !signalR.transports[transport]) {
275.                     connection.log("Invalid transport: " + transport + ", removing it from the transports list.");
276.                     requestedTransport.splice(i, 1);
277.                 }
278.             }
280.             // Verify we still have transports left, if we dont then we have invalid transports
281.             if (requestedTransport.length === 0) {
282.                 connection.log("No transports remain within the specified transport array.");
283.                 requestedTransport = null;
284.             }
285.         } else if (!signalR.transports[requestedTransport] && requestedTransport !== "auto") {
286.             connection.log("Invalid transport: " + requestedTransport.toString() + ".");
287.             requestedTransport = null;
288.         } else if (requestedTransport === "auto" && signalR._.ieVersion <= 8) {
289.             // If we're doing an auto transport and we're IE8 then force longPolling, #1764
290.             return ["longPolling"];
292.         }
294.         return requestedTransport;
295.     }
297.     function getDefaultPort(protocol) {
298.         if (protocol === "http:") {
299.             return 80;
300.         } else if (protocol === "https:") {
301.             return 443;
302.         }
303.     }
305.     function addDefaultPort(protocol, url) {
306.         // Remove ports  from url.  We have to check if there's a / or end of line
307.         // following the port in order to avoid removing ports such as 8080.
308.         if (url.match(/:\d+$/)) {
309.             return url;
310.         } else {
311.             return url + ":" + getDefaultPort(protocol);
312.         }
313.     }
315.     function ConnectingMessageBuffer(connection, drainCallback) {
316.         var that = this,
317.             buffer = [];
319.         that.tryBuffer = function (message) {
320.             if (connection.state === $.signalR.connectionState.connecting) {
321.                 buffer.push(message);
323.                 return true;
324.             }
326.             return false;
327.         };
329.         that.drain = function () {
330.             // Ensure that the connection is connected when we drain (do not want to drain while a connection is not active)
331.             if (connection.state === $.signalR.connectionState.connected) {
332.                 while (buffer.length > 0) {
333.                     drainCallback(buffer.shift());
334.                 }
335.             }
336.         };
338.         that.clear = function () {
339.             buffer = [];
340.         };
341.     }
343.     signalR.fn = signalR.prototype = {
344.         init: function (url, qs, logging) {
345.             var $connection = $(this);
347.             this.url = url;
348.             this.qs = qs;
349.             this.lastError = null;
350.             this._ = {
351.                 keepAliveData: {},
352.                 connectingMessageBuffer: new ConnectingMessageBuffer(this, function (message) {
353.                     $connection.triggerHandler(events.onReceived, [message]);
354.                 }),
355.                 lastMessageAt: new Date().getTime(),
356.                 lastActiveAt: new Date().getTime(),
357.                 beatInterval: 5000, // Default value, will only be overridden if keep alive is enabled,
358.                 beatHandle: null,
359.                 totalTransportConnectTimeout: 0, // This will be the sum of the TransportConnectTimeout sent in response to negotiate and connection.transportConnectTimeout
360.                 redirectQs: null
361.             };
362.             if (typeof (logging) === "boolean") {
363.                 this.logging = logging;
364.             }
365.         },
367.         _parseResponse: function (response) {
368.             var that = this;
370.             if (!response) {
371.                 return response;
372.             } else if (typeof response === "string") {
373.                 return that.json.parse(response);
374.             } else {
375.                 return response;
376.             }
377.         },
379.         _originalJson: window.JSON,
381.         json: window.JSON,
383.         isCrossDomain: function (url, against) {
384.             /// <summary>Checks if url is cross domain</summary>
385.             /// <param name="url" type="String">The base URL</param>
386.             /// <param name="against" type="Object">
387.             ///     An optional argument to compare the URL against, if not specified it will be set to window.location.
388.             ///     If specified it must contain a protocol and a host property.
389.             /// </param>
390.             var link;
392.             url = $.trim(url);
394.             against = against || window.location;
396.             if (url.indexOf("http") !== 0) {
397.                 return false;
398.             }
400.             // Create an anchor tag.
401.             link = window.document.createElement("a");
402.             link.href = url;
404.             // When checking for cross domain we have to special case port 80 because the window.location will remove the
405.             return link.protocol + addDefaultPort(link.protocol, link.host) !== against.protocol + addDefaultPort(against.protocol, against.host);
406.         },
408.         ajaxDataType: "text",
410.         contentType: "application/json; charset=UTF-8",
412.         logging: false,
414.         state: signalR.connectionState.disconnected,
416.         clientProtocol: "2.1",
418.         // We want to support older servers since the 2.0 change is to support redirection results, which isn't
419.         // really breaking in the protocol. So if a user updates their client to 2.0 protocol version there's
420.         // no reason they can't still connect to a 1.5 server. The 2.1 protocol is sent by the client so the SignalR
421.         // service knows the client will use they query string returned via the RedirectUrl for subsequent requests.
422.         // It doesn't matter whether the server reflects back 2.1 or continues using 2.0 as the protocol version.
423.         supportedProtocols: ["1.5", "2.0", "2.1"],
425.         negotiateRedirectSupportedProtocols: ["2.0", "2.1"],
427.         reconnectDelay: 2000,
429.         transportConnectTimeout: 0,
431.         disconnectTimeout: 30000, // This should be set by the server in response to the negotiate request (30s default)
433.         reconnectWindow: 30000, // This should be set by the server in response to the negotiate request
435.         keepAliveWarnAt: 2 / 3, // Warn user of slow connection if we breach the X% mark of the keep alive timeout
437.         start: function (options, callback) {
438.             /// <summary>Starts the connection</summary>
439.             /// <param name="options" type="Object">Options map</param>
440.             /// <param name="callback" type="Function">A callback function to execute when the connection has started</param>
441.             var connection = this,
442.                 config = {
443.                     pingInterval: 300000,
444.                     waitForPageLoad: true,
445.                     transport: "auto",
446.                     jsonp: false
447.                 },
448.                 initialize,
449.                 deferred = connection._deferral || $.Deferred(), // Check to see if there is a pre-existing deferral that's being built on, if so we want to keep using it
450.                 parser = window.document.createElement("a"),
451.                 setConnectionUrl = function (connection, url) {
452.                     if (connection.url === url && connection.baseUrl) {
453.                         // when the url related properties are already set
454.                         return;
455.                     }
457.                     connection.url = url;
459.                     // Resolve the full url
460.                     parser.href = connection.url;
461.                     if (!parser.protocol || parser.protocol === ":") {
462.                         connection.protocol = window.document.location.protocol;
463.                         connection.host = parser.host || window.document.location.host;
464.                     } else {
465.                         connection.protocol = parser.protocol;
466.                         connection.host = parser.host;
467.                     }
469.                     connection.baseUrl = connection.protocol + "//" + connection.host;
471.                     // Set the websocket protocol
472.                     connection.wsProtocol = connection.protocol === "https:" ? "wss://" : "ws://";
474.                     // If the url is protocol relative, prepend the current windows protocol to the url.
475.                     if (connection.url.indexOf("//") === 0) {
476.                         connection.url = window.location.protocol + connection.url;
477.                         connection.log("Protocol relative URL detected, normalizing it to '" + connection.url + "'.");
478.                     }
480.                     if (connection.isCrossDomain(connection.url)) {
481.                         connection.log("Auto detected cross domain url.");
483.                         if (config.transport === "auto") {
484.                             // Cross-domain does not support foreverFrame
485.                             config.transport = ["webSockets", "serverSentEvents", "longPolling"];
486.                         }
488.                         if (typeof connection.withCredentials === "undefined") {
489.                             connection.withCredentials = true;
490.                         }
492.                         // Determine if jsonp is the only choice for negotiation, ajaxSend and ajaxAbort.
493.                         // i.e. if the browser doesn't supports CORS
494.                         // If it is, ignore any preference to the contrary, and switch to jsonp.
495.                         if (!$.support.cors) {
496.                             connection.ajaxDataType = "jsonp";
497.                             connection.log("Using jsonp because this browser doesn't support CORS.");
498.                         }
500.                         connection.contentType = signalR._.defaultContentType;
501.                     }
502.                 };
504.             connection.lastError = null;
506.             // Persist the deferral so that if start is called multiple times the same deferral is used.
507.             connection._deferral = deferred;
509.             if (!connection.json) {
510.                 // no JSON!
511.                 throw new Error("SignalR: No JSON parser found. Please ensure json2.js is referenced before the SignalR.js file if you need to support clients without native JSON parsing support, e.g. IE<8.");
512.             }
514.             if ($.type(options) === "function") {
515.                 // Support calling with single callback parameter
516.                 callback = options;
517.             } else if ($.type(options) === "object") {
518.                 $.extend(config, options);
519.                 if ($.type(config.callback) === "function") {
520.                     callback = config.callback;
521.                 }
522.             }
524.             config.transport = validateTransport(config.transport, connection);
526.             // If the transport is invalid throw an error and abort start
527.             if (!config.transport) {
528.                 throw new Error("SignalR: Invalid transport(s) specified, aborting start.");
529.             }
531.             connection._.config = config;
533.             // Check to see if start is being called prior to page load
534.             // If waitForPageLoad is true we then want to re-direct function call to the window load event
535.             if (!_pageLoaded && config.waitForPageLoad === true) {
536.                 connection._.deferredStartHandler = function () {
537.                     connection.start(options, callback);
538.                 };
539.                 _pageWindow.bind("load", connection._.deferredStartHandler);
541.                 return deferred.promise();
542.             }
544.             // If we're already connecting just return the same deferral as the original connection start
545.             if (connection.state === signalR.connectionState.connecting) {
546.                 return deferred.promise();
547.             } else if (changeState(connection,
548.                 signalR.connectionState.disconnected,
549.                 signalR.connectionState.connecting) === false) {
550.                 // We're not connecting so try and transition into connecting.
551.                 // If we fail to transition then we're either in connected or reconnecting.
553.                 deferred.resolve(connection);
554.                 return deferred.promise();
555.             }
557.             configureStopReconnectingTimeout(connection);
559.             // If jsonp with no/auto transport is specified, then set the transport to long polling
560.             // since that is the only transport for which jsonp really makes sense.
561.             // Some developers might actually choose to specify jsonp for same origin requests
562.             // as demonstrated by Issue #623.
563.             if (config.transport === "auto" && config.jsonp === true) {
564.                 config.transport = "longPolling";
565.             }
567.             connection.withCredentials = config.withCredentials;
569.             // Save the original url so that we can reset it when we stop and restart the connection
570.             connection._originalUrl = connection.url;
572.             connection.ajaxDataType = config.jsonp ? "jsonp" : "text";
574.             setConnectionUrl(connection, connection.url);
576.             $(connection).bind(events.onStart, function (e, data) {
577.                 if ($.type(callback) === "function") {
578.                     callback.call(connection);
579.                 }
580.                 deferred.resolve(connection);
581.             });
583.             connection._.initHandler = signalR.transports._logic.initHandler(connection);
585.             initialize = function (transports, index) {
586.                 var noTransportError = signalR._.error(resources.noTransportOnInit);
588.                 index = index || 0;
589.                 if (index >= transports.length) {
590.                     if (index === 0) {
591.                         connection.log("No transports supported by the server were selected.");
592.                     } else if (index === 1) {
593.                         connection.log("No fallback transports were selected.");
594.                     } else {
595.                         connection.log("Fallback transports exhausted.");
596.                     }
598.                     // No transport initialized successfully
599.                     $(connection).triggerHandler(events.onError, [noTransportError]);
600.                     deferred.reject(noTransportError);
601.                     // Stop the connection if it has connected and move it into the disconnected state
602.                     connection.stop();
603.                     return;
604.                 }
606.                 // The connection was aborted
607.                 if (connection.state === signalR.connectionState.disconnected) {
608.                     return;
609.                 }
611.                 var transportName = transports[index],
612.                     transport = signalR.transports[transportName],
613.                     onFallback = function () {
614.                         initialize(transports, index + 1);
615.                     };
617.                 connection.transport = transport;
619.                 try {
620.                     connection._.initHandler.start(transport, function () { // success
621.                         // Firefox 11+ doesn't allow sync XHR withCredentials: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#withCredentials
622.                         var isFirefox11OrGreater = signalR._.firefoxMajorVersion(window.navigator.userAgent) >= 11,
623.                             asyncAbort = true;
625.                         connection.log("The start request succeeded. Transitioning to the connected state.");
627.                         if (supportsKeepAlive(connection)) {
628.                             signalR.transports._logic.monitorKeepAlive(connection);
629.                         }
631.                         if (connection._.keepAliveData.activated) {
632.                             signalR.transports._logic.startHeartbeat(connection);
633.                         }
635.                         // Used to ensure low activity clients maintain their authentication.
636.                         // Must be configured once a transport has been decided to perform valid ping requests.
637.                         signalR._.configurePingInterval(connection);
639.                         if (!changeState(connection,
640.                             signalR.connectionState.connecting,
641.                             signalR.connectionState.connected)) {
642.                             connection.log("WARNING! The connection was not in the connecting state.");
643.                         }
645.                         // Drain any incoming buffered messages (messages that came in prior to connect)
646.                         connection._.connectingMessageBuffer.drain();
648.                         $(connection).triggerHandler(events.onStart);
650.                         // wire the stop handler for when the user leaves the page
651.                         _pageWindow.bind("unload", function () {
652.                             connection.log("Window unloading, stopping the connection.");
654.                             connection.stop(asyncAbort);
655.                         });
657.                         if (isFirefox11OrGreater) {
658.                             // Firefox does not fire cross-domain XHRs in the normal unload handler on tab close.
659.                             // #2400
660.                             _pageWindow.bind("beforeunload", function () {
661.                                 // If connection.stop() runs runs in beforeunload and fails, it will also fail
662.                                 // in unload unless connection.stop() runs after a timeout.
663.                                 window.setTimeout(function () {
664.                                     connection.stop(asyncAbort);
665.                                 }, 0);
666.                             });
667.                         }
668.                     }, onFallback);
669.                 }
670.                 catch (error) {
671.                     connection.log(transport.name + " transport threw '" + error.message + "' when attempting to start.");
672.                     onFallback();
673.                 }
674.             };
676.             var url = connection.url + "/negotiate",
677.                 onFailed = function (error, connection) {
678.                     var err = signalR._.error(resources.errorOnNegotiate, error, connection._.negotiateRequest);
680.                     $(connection).triggerHandler(events.onError, err);
681.                     deferred.reject(err);
682.                     // Stop the connection if negotiate failed
683.                     connection.stop();
684.                 };
686.             $(connection).triggerHandler(events.onStarting);
688.             url = signalR.transports._logic.prepareQueryString(connection, url);
690.             connection.log("Negotiating with '" + url + "'.");
692.             // Save the ajax negotiate request object so we can abort it if stop is called while the request is in flight.
693.             connection._.negotiateRequest = function () {
694.                 var res,
695.                     redirects = 0,
696.                     MAX_REDIRECTS = 100,
697.                     keepAliveData,
698.                     protocolError,
699.                     transports = [],
700.                     supportedTransports = [],
701.                     negotiate = function (connection, onSuccess) {
702.                         var url = signalR.transports._logic.prepareQueryString(connection, connection.url + "/negotiate");
703.                         connection.log("Negotiating with '" + url + "'.");
704.                         var options = {
705.                             url: url,
706.                             error: function (error, statusText) {
707.                                 // We don't want to cause any errors if we're aborting our own negotiate request.
708.                                 if (statusText !== _negotiateAbortText) {
709.                                     onFailed(error, connection);
710.                                 } else {
711.                                     // This rejection will noop if the deferred has already been resolved or rejected.
712.                                     deferred.reject(signalR._.error(resources.stoppedWhileNegotiating, null /* error */, connection._.negotiateRequest));
713.                                 }
714.                             },
715.                             success: onSuccess
716.                         };
718.                         if (connection.accessToken) {
719.                             options.headers = { "Authorization": "Bearer " + connection.accessToken };
720.                         }
722.                         return signalR.transports._logic.ajax(connection, options);
723.                     },
724.                     callback = function (result) {
725.                         try {
726.                             res = connection._parseResponse(result);
727.                         } catch (error) {
728.                             onFailed(signalR._.error(resources.errorParsingNegotiateResponse, error), connection);
729.                             return;
730.                         }
732.                         // Check if the server is an ASP.NET Core app
733.                         if (res.availableTransports) {
734.                             protocolError = signalR._.error(resources.aspnetCoreSignalrServer);
735.                             $(connection).triggerHandler(events.onError, [protocolError]);
736.                             deferred.reject(protocolError);
737.                             return;
738.                         }
740.                         if (!res.ProtocolVersion || (connection.supportedProtocols.indexOf(res.ProtocolVersion) === -1)) {
741.                             protocolError = signalR._.error(signalR._.format(resources.protocolIncompatible, connection.clientProtocol, res.ProtocolVersion));
742.                             $(connection).triggerHandler(events.onError, [protocolError]);
743.                             deferred.reject(protocolError);
745.                             return;
746.                         }
748.                         // Check for a redirect response (which must have a ProtocolVersion of 2.0 or greater)
749.                         // ProtocolVersion 2.1 is the highest supported by the client, so we can just check for 2.0 or 2.1 for now
750.                         // instead of trying to do proper version string comparison in JavaScript.
751.                         if (connection.negotiateRedirectSupportedProtocols.indexOf(res.ProtocolVersion) !== -1) {
752.                             if (res.Error) {
753.                                 protocolError = signalR._.error(signalR._.format(resources.errorFromServer, res.Error));
754.                                 $(connection).triggerHandler(events.onError, [protocolError]);
755.                                 deferred.reject(protocolError);
756.                                 return;
757.                             }
758.                             else if (res.RedirectUrl) {
759.                                 if (redirects === MAX_REDIRECTS) {
760.                                     onFailed(signalR._.error(resources.errorRedirectionExceedsLimit), connection);
761.                                     return;
762.                                 }
764.                                 if (config.transport === "auto") {
765.                                     // Redirected connections do not support foreverFrame
766.                                     config.transport = ["webSockets", "serverSentEvents", "longPolling"];
767.                                 }
769.                                 connection.log("Received redirect to: " + res.RedirectUrl);
770.                                 connection.accessToken = res.AccessToken;
772.                                 var splitUrlAndQs = res.RedirectUrl.split("?", 2);
773.                                 setConnectionUrl(connection, splitUrlAndQs[0]);
775.                                 // Update redirectQs with query string from only the most recent RedirectUrl.
776.                                 connection._.redirectQs = splitUrlAndQs.length === 2 ? splitUrlAndQs[1] : null;
778.                                 if (connection.ajaxDataType === "jsonp" && connection.accessToken) {
779.                                     onFailed(signalR._.error(resources.jsonpNotSupportedWithAccessToken), connection);
780.                                     return;
781.                                 }
783.                                 redirects++;
784.                                 negotiate(connection, callback);
785.                                 return;
786.                             }
787.                         }
789.                         keepAliveData = connection._.keepAliveData;
790.                         connection.appRelativeUrl = res.Url;
791.                         connection.id = res.ConnectionId;
792.                         connection.token = res.ConnectionToken;
793.                         connection.webSocketServerUrl = res.WebSocketServerUrl;
795.                         // The long poll timeout is the ConnectionTimeout plus 10 seconds
796.                         connection._.pollTimeout = res.ConnectionTimeout * 1000 + 10000; // in ms
798.                         // Once the server has labeled the PersistentConnection as Disconnected, we should stop attempting to reconnect
799.                         // after res.DisconnectTimeout seconds.
800.                         connection.disconnectTimeout = res.DisconnectTimeout * 1000; // in ms
802.                         // Add the TransportConnectTimeout from the response to the transportConnectTimeout from the client to calculate the total timeout
803.                         connection._.totalTransportConnectTimeout = connection.transportConnectTimeout + res.TransportConnectTimeout * 1000;
805.                         // If we have a keep alive
806.                         if (res.KeepAliveTimeout) {
807.                             // Register the keep alive data as activated
808.                             keepAliveData.activated = true;
810.                             // Timeout to designate when to force the connection into reconnecting converted to milliseconds
811.                             keepAliveData.timeout = res.KeepAliveTimeout * 1000;
813.                             // Timeout to designate when to warn the developer that the connection may be dead or is not responding.
814.                             keepAliveData.timeoutWarning = keepAliveData.timeout * connection.keepAliveWarnAt;
816.                             // Instantiate the frequency in which we check the keep alive.  It must be short in order to not miss/pick up any changes
817.                             connection._.beatInterval = (keepAliveData.timeout - keepAliveData.timeoutWarning) / 3;
818.                         } else {
819.                             keepAliveData.activated = false;
820.                         }
822.                         connection.reconnectWindow = connection.disconnectTimeout + (keepAliveData.timeout || 0);
824.                         $.each(signalR.transports, function (key) {
825.                             if ((key.indexOf("_") === 0) || (key === "webSockets" && !res.TryWebSockets)) {
826.                                 return true;
827.                             }
828.                             supportedTransports.push(key);
829.                         });
831.                         if ($.isArray(config.transport)) {
832.                             $.each(config.transport, function (_, transport) {
833.                                 if ($.inArray(transport, supportedTransports) >= 0) {
834.                                     transports.push(transport);
835.                                 }
836.                             });
837.                         } else if (config.transport === "auto") {
838.                             transports = supportedTransports;
839.                         } else if ($.inArray(config.transport, supportedTransports) >= 0) {
840.                             transports.push(config.transport);
841.                         }
843.                         initialize(transports);
844.                     };
846.                 return negotiate(connection, callback);
847.             }();
849.             return deferred.promise();
850.         },
852.         starting: function (callback) {
853.             /// <summary>Adds a callback that will be invoked before anything is sent over the connection</summary>
854.             /// <param name="callback" type="Function">A callback function to execute before the connection is fully instantiated.</param>
855.             /// <returns type="signalR" />
856.             var connection = this;
857.             $(connection).bind(events.onStarting, function (e, data) {
858.                 callback.call(connection);
859.             });
860.             return connection;
861.         },
863.         send: function (data) {
864.             /// <summary>Sends data over the connection</summary>
865.             /// <param name="data" type="String">The data to send over the connection</param>
866.             /// <returns type="signalR" />
867.             var connection = this;
869.             if (connection.state === signalR.connectionState.disconnected) {
870.                 // Connection hasn't been started yet
871.                 throw new Error("SignalR: Connection must be started before data can be sent. Call .start() before .send()");
872.             }
874.             if (connection.state === signalR.connectionState.connecting) {
875.                 // Connection hasn't been started yet
876.                 throw new Error("SignalR: Connection has not been fully initialized. Use .start().done() or .start().fail() to run logic after the connection has started.");
877.             }
879.             connection.transport.send(connection, data);
880.             // REVIEW: Should we return deferred here?
881.             return connection;
882.         },
884.         received: function (callback) {
885.             /// <summary>Adds a callback that will be invoked after anything is received over the connection</summary>
886.             /// <param name="callback" type="Function">A callback function to execute when any data is received on the connection</param>
887.             /// <returns type="signalR" />
888.             var connection = this;
889.             $(connection).bind(events.onReceived, function (e, data) {
890.                 callback.call(connection, data);
891.             });
892.             return connection;
893.         },
895.         stateChanged: function (callback) {
896.             /// <summary>Adds a callback that will be invoked when the connection state changes</summary>
897.             /// <param name="callback" type="Function">A callback function to execute when the connection state changes</param>
898.             /// <returns type="signalR" />
899.             var connection = this;
900.             $(connection).bind(events.onStateChanged, function (e, data) {
901.                 callback.call(connection, data);
902.             });
903.             return connection;
904.         },
906.         error: function (callback) {
907.             /// <summary>Adds a callback that will be invoked after an error occurs with the connection</summary>
908.             /// <param name="callback" type="Function">A callback function to execute when an error occurs on the connection</param>
909.             /// <returns type="signalR" />
910.             var connection = this;
911.             $(connection).bind(events.onError, function (e, errorData, sendData) {
912.                 connection.lastError = errorData;
913.                 // In practice 'errorData' is the SignalR built error object.
914.                 // In practice 'sendData' is undefined for all error events except those triggered by
915.                 // 'ajaxSend' and 'webSockets.send'.'sendData' is the original send payload.
916.                 callback.call(connection, errorData, sendData);
917.             });
918.             return connection;
919.         },
921.         disconnected: function (callback) {
922.             /// <summary>Adds a callback that will be invoked when the client disconnects</summary>
923.             /// <param name="callback" type="Function">A callback function to execute when the connection is broken</param>
924.             /// <returns type="signalR" />
925.             var connection = this;
926.             $(connection).bind(events.onDisconnect, function (e, data) {
927.                 callback.call(connection);
928.             });
929.             return connection;
930.         },
932.         connectionSlow: function (callback) {
933.             /// <summary>Adds a callback that will be invoked when the client detects a slow connection</summary>
934.             /// <param name="callback" type="Function">A callback function to execute when the connection is slow</param>
935.             /// <returns type="signalR" />
936.             var connection = this;
937.             $(connection).bind(events.onConnectionSlow, function (e, data) {
938.                 callback.call(connection);
939.             });
941.             return connection;
942.         },
944.         reconnecting: function (callback) {
945.             /// <summary>Adds a callback that will be invoked when the underlying transport begins reconnecting</summary>
946.             /// <param name="callback" type="Function">A callback function to execute when the connection enters a reconnecting state</param>
947.             /// <returns type="signalR" />
948.             var connection = this;
949.             $(connection).bind(events.onReconnecting, function (e, data) {
950.                 callback.call(connection);
951.             });
952.             return connection;
953.         },
955.         reconnected: function (callback) {
956.             /// <summary>Adds a callback that will be invoked when the underlying transport reconnects</summary>
957.             /// <param name="callback" type="Function">A callback function to execute when the connection is restored</param>
958.             /// <returns type="signalR" />
959.             var connection = this;
960.             $(connection).bind(events.onReconnect, function (e, data) {
961.                 callback.call(connection);
962.             });
963.             return connection;
964.         },
966.         stop: function (async, notifyServer) {
967.             /// <summary>Stops listening</summary>
968.             /// <param name="async" type="Boolean">Whether or not to asynchronously abort the connection</param>
969.             /// <param name="notifyServer" type="Boolean">Whether we want to notify the server that we are aborting the connection</param>
970.             /// <returns type="signalR" />
971.             var connection = this,
972.                 // Save deferral because this is always cleaned up
973.                 deferral = connection._deferral;
975.             // Verify that we've bound a load event.
976.             if (connection._.deferredStartHandler) {
977.                 // Unbind the event.
978.                 _pageWindow.unbind("load", connection._.deferredStartHandler);
979.             }
981.             // Always clean up private non-timeout based state.
982.             delete connection._.config;
983.             delete connection._.deferredStartHandler;
985.             // This needs to be checked despite the connection state because a connection start can be deferred until page load.
986.             // If we've deferred the start due to a page load we need to unbind the "onLoad" -> start event.
987.             if (!_pageLoaded && (!connection._.config || connection._.config.waitForPageLoad === true)) {
988.                 connection.log("Stopping connection prior to negotiate.");
990.                 // If we have a deferral we should reject it
991.                 if (deferral) {
992.                     deferral.reject(signalR._.error(resources.stoppedWhileLoading));
993.                 }
995.                 // Short-circuit because the start has not been fully started.
996.                 return;
997.             }
999.             if (connection.state === signalR.connectionState.disconnected) {
1000.                 return;
1001.             }
1003.             connection.log("Stopping connection.");
1005.             // Clear this no matter what
1006.             window.clearTimeout(connection._.beatHandle);
1007.             window.clearInterval(connection._.pingIntervalId);
1009.             if (connection.transport) {
1010.                 connection.transport.stop(connection);
1012.                 if (notifyServer !== false) {
1013.                     connection.transport.abort(connection, async);
1014.                 }
1016.                 if (supportsKeepAlive(connection)) {
1017.                     signalR.transports._logic.stopMonitoringKeepAlive(connection);
1018.                 }
1020.                 connection.transport = null;
1021.             }
1023.             if (connection._.negotiateRequest) {
1024.                 // If the negotiation request has already completed this will noop.
1025.                 connection._.negotiateRequest.abort(_negotiateAbortText);
1026.                 delete connection._.negotiateRequest;
1027.             }
1029.             // Ensure that initHandler.stop() is called before connection._deferral is deleted
1030.             if (connection._.initHandler) {
1031.                 connection._.initHandler.stop();
1032.             }
1034.             delete connection._deferral;
1035.             delete connection.messageId;
1036.             delete connection.groupsToken;
1037.             delete connection.id;
1038.             delete connection._.pingIntervalId;
1039.             delete connection._.lastMessageAt;
1040.             delete connection._.lastActiveAt;
1042.             // Clear out our message buffer
1043.             connection._.connectingMessageBuffer.clear();
1045.             // Clean up this event
1046.             $(connection).unbind(events.onStart);
1048.             // Reset the URL and clear the access token
1049.             delete connection.accessToken;
1050.             delete connection.protocol;
1051.             delete connection.host;
1052.             delete connection.baseUrl;
1053.             delete connection.wsProtocol;
1054.             delete connection.contentType;
1055.             connection.url = connection._originalUrl;
1056.             connection._.redirectQs = null;
1058.             // Trigger the disconnect event
1059.             changeState(connection, connection.state, signalR.connectionState.disconnected);
1060.             $(connection).triggerHandler(events.onDisconnect);
1062.             return connection;
1063.         },
1065.         log: function (msg) {
1066.             log(msg, this.logging);
1067.         }
1068.     };
1070.     signalR.fn.init.prototype = signalR.fn;
1072.     signalR.noConflict = function () {
1073.         /// <summary>Reinstates the original value of $.connection and returns the signalR object for manual assignment</summary>
1074.         /// <returns type="signalR" />
1075.         if ($.connection === signalR) {
1076.             $.connection = _connection;
1077.         }
1078.         return signalR;
1079.     };
1081.     if ($.connection) {
1082.         _connection = $.connection;
1083.     }
1085.     $.connection = $.signalR = signalR;
1087. }(window.jQuery, window));
1088. /* jquery.signalR.transports.common.js */
1089. // Copyright (c) .NET Foundation. All rights reserved.
1090. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1092. /*global window:false */
1093. /// <reference path="jquery.signalR.core.js" />
1095. (function ($, window, undefined) {
1097.     var signalR = $.signalR,
1098.         events = $.signalR.events,
1099.         changeState = $.signalR.changeState,
1100.         startAbortText = "__Start Aborted__",
1101.         transportLogic;
1103.     signalR.transports = {};
1105.     function beat(connection) {
1106.         if (connection._.keepAliveData.monitoring) {
1107.             checkIfAlive(connection);
1108.         }
1110.         // Ensure that we successfully marked active before continuing the heartbeat.
1111.         if (transportLogic.markActive(connection)) {
1112.             connection._.beatHandle = window.setTimeout(function () {
1113.                 beat(connection);
1114.             }, connection._.beatInterval);
1115.         }
1116.     }
1118.     function checkIfAlive(connection) {
1119.         var keepAliveData = connection._.keepAliveData,
1120.             timeElapsed;
1122.         // Only check if we're connected
1123.         if (connection.state === signalR.connectionState.connected) {
1124.             timeElapsed = new Date().getTime() - connection._.lastMessageAt;
1126.             // Check if the keep alive has completely timed out
1127.             if (timeElapsed >= keepAliveData.timeout) {
1128.                 connection.log("Keep alive timed out.  Notifying transport that connection has been lost.");
1130.                 // Notify transport that the connection has been lost
1131.                 connection.transport.lostConnection(connection);
1132.             } else if (timeElapsed >= keepAliveData.timeoutWarning) {
1133.                 // This is to assure that the user only gets a single warning
1134.                 if (!keepAliveData.userNotified) {
1135.                     connection.log("Keep alive has been missed, connection may be dead/slow.");
1136.                     $(connection).triggerHandler(events.onConnectionSlow);
1137.                     keepAliveData.userNotified = true;
1138.                 }
1139.             } else {
1140.                 keepAliveData.userNotified = false;
1141.             }
1142.         }
1143.     }
1145.     function getAjaxUrl(connection, path) {
1146.         var url = connection.url + path;
1148.         if (connection.transport) {
1149.             url += "?transport=" + connection.transport.name;
1150.         }
1152.         return transportLogic.prepareQueryString(connection, url);
1153.     }
1155.     function InitHandler(connection) {
1156.         this.connection = connection;
1158.         this.startRequested = false;
1159.         this.startCompleted = false;
1160.         this.connectionStopped = false;
1161.     }
1163.     InitHandler.prototype = {
1164.         start: function (transport, onSuccess, onFallback) {
1165.             var that = this,
1166.                 connection = that.connection,
1167.                 failCalled = false;
1169.             if (that.startRequested || that.connectionStopped) {
1170.                 connection.log("WARNING! " + transport.name + " transport cannot be started. Initialization ongoing or completed.");
1171.                 return;
1172.             }
1174.             connection.log(transport.name + " transport starting.");
1176.             transport.start(connection, function () {
1177.                 if (!failCalled) {
1178.                     that.initReceived(transport, onSuccess);
1179.                 }
1180.             }, function (error) {
1181.                 // Don't allow the same transport to cause onFallback to be called twice
1182.                 if (!failCalled) {
1183.                     failCalled = true;
1184.                     that.transportFailed(transport, error, onFallback);
1185.                 }
1187.                 // Returns true if the transport should stop;
1188.                 // false if it should attempt to reconnect
1189.                 return !that.startCompleted || that.connectionStopped;
1190.             });
1192.             that.transportTimeoutHandle = window.setTimeout(function () {
1193.                 if (!failCalled) {
1194.                     failCalled = true;
1195.                     connection.log(transport.name + " transport timed out when trying to connect.");
1196.                     that.transportFailed(transport, undefined, onFallback);
1197.                 }
1198.             }, connection._.totalTransportConnectTimeout);
1199.         },
1201.         stop: function () {
1202.             this.connectionStopped = true;
1203.             window.clearTimeout(this.transportTimeoutHandle);
1204.             signalR.transports._logic.tryAbortStartRequest(this.connection);
1205.         },
1207.         initReceived: function (transport, onSuccess) {
1208.             var that = this,
1209.                 connection = that.connection;
1211.             if (that.startRequested) {
1212.                 connection.log("WARNING! The client received multiple init messages.");
1213.                 return;
1214.             }
1216.             if (that.connectionStopped) {
1217.                 return;
1218.             }
1220.             that.startRequested = true;
1221.             window.clearTimeout(that.transportTimeoutHandle);
1223.             connection.log(transport.name + " transport connected. Initiating start request.");
1224.             signalR.transports._logic.ajaxStart(connection, function () {
1225.                 that.startCompleted = true;
1226.                 onSuccess();
1227.             });
1228.         },
1230.         transportFailed: function (transport, error, onFallback) {
1231.             var connection = this.connection,
1232.                 deferred = connection._deferral,
1233.                 wrappedError;
1235.             if (this.connectionStopped) {
1236.                 return;
1237.             }
1239.             window.clearTimeout(this.transportTimeoutHandle);
1241.             if (!this.startRequested) {
1242.                 transport.stop(connection);
1244.                 connection.log(transport.name + " transport failed to connect. Attempting to fall back.");
1245.                 onFallback();
1246.             } else if (!this.startCompleted) {
1247.                 // Do not attempt to fall back if a start request is ongoing during a transport failure.
1248.                 // Instead, trigger an error and stop the connection.
1249.                 wrappedError = signalR._.error(signalR.resources.errorDuringStartRequest, error);
1251.                 connection.log(transport.name + " transport failed during the start request. Stopping the connection.");
1252.                 $(connection).triggerHandler(events.onError, [wrappedError]);
1253.                 if (deferred) {
1254.                     deferred.reject(wrappedError);
1255.                 }
1257.                 connection.stop();
1258.             } else {
1259.                 // The start request has completed, but the connection has not stopped.
1260.                 // No need to do anything here. The transport should attempt its normal reconnect logic.
1261.             }
1262.         }
1263.     };
1265.     transportLogic = signalR.transports._logic = {
1266.         ajax: function (connection, options) {
1267.             return $.ajax(
1268.                 $.extend(/*deep copy*/ true, {}, $.signalR.ajaxDefaults, {
1269.                     type: "GET",
1270.                     data: {},
1271.                     xhrFields: { withCredentials: connection.withCredentials },
1272.                     contentType: connection.contentType,
1273.                     dataType: connection.ajaxDataType
1274.                 }, options));
1275.         },
1277.         pingServer: function (connection) {
1278.             /// <summary>Pings the server</summary>
1279.             /// <param name="connection" type="signalr">Connection associated with the server ping</param>
1280.             /// <returns type="signalR" />
1281.             var url,
1282.                 xhr,
1283.                 deferral = $.Deferred();
1285.             if (connection.transport) {
1286.                 url = connection.url + "/ping";
1288.                 url = transportLogic.addQs(url, connection.qs);
1290.                 xhr = transportLogic.ajax(connection, {
1291.                     url: url,
1292.                     headers: connection.accessToken ? { "Authorization": "Bearer " + connection.accessToken } : {},
1293.                     success: function (result) {
1294.                         var data;
1296.                         try {
1297.                             data = connection._parseResponse(result);
1298.                         }
1299.                         catch (error) {
1300.                             deferral.reject(
1301.                                 signalR._.transportError(
1302.                                     signalR.resources.pingServerFailedParse,
1303.                                     connection.transport,
1304.                                     error,
1305.                                     xhr
1306.                                 )
1307.                             );
1308.                             connection.stop();
1309.                             return;
1310.                         }
1312.                         if (data.Response === "pong") {
1313.                             deferral.resolve();
1314.                         }
1315.                         else {
1316.                             deferral.reject(
1317.                                 signalR._.transportError(
1318.                                     signalR._.format(signalR.resources.pingServerFailedInvalidResponse, result),
1319.                                     connection.transport,
1320.                                     null /* error */,
1321.                                     xhr
1322.                                 )
1323.                             );
1324.                         }
1325.                     },
1326.                     error: function (error) {
1327.                         if (error.status === 401 || error.status === 403) {
1328.                             deferral.reject(
1329.                                 signalR._.transportError(
1330.                                     signalR._.format(signalR.resources.pingServerFailedStatusCode, error.status),
1331.                                     connection.transport,
1332.                                     error,
1333.                                     xhr
1334.                                 )
1335.                             );
1336.                             connection.stop();
1337.                         }
1338.                         else {
1339.                             deferral.reject(
1340.                                 signalR._.transportError(
1341.                                     signalR.resources.pingServerFailed,
1342.                                     connection.transport,
1343.                                     error,
1344.                                     xhr
1345.                                 )
1346.                             );
1347.                         }
1348.                     }
1349.                 });
1350.             }
1351.             else {
1352.                 deferral.reject(
1353.                     signalR._.transportError(
1354.                         signalR.resources.noConnectionTransport,
1355.                         connection.transport
1356.                     )
1357.                 );
1358.             }
1360.             return deferral.promise();
1361.         },
1363.         prepareQueryString: function (connection, url) {
1364.             var preparedUrl;
1366.             // Use addQs to start since it handles the ?/& prefix for us
1367.             preparedUrl = transportLogic.addQs(url, "clientProtocol=" + connection.clientProtocol);
1369.             if (typeof (connection._.redirectQs) === "string") {
1370.                 // Add the redirect-specified query string params if any
1371.                 preparedUrl = transportLogic.addQs(preparedUrl, connection._.redirectQs);
1372.             } else {
1373.                 // Otherwise, add the user-specified query string params if any
1374.                 preparedUrl = transportLogic.addQs(preparedUrl, connection.qs);
1375.             }
1377.             if (connection.token) {
1378.                 preparedUrl += "&connectionToken=" + window.encodeURIComponent(connection.token);
1379.             }
1381.             if (connection.data) {
1382.                 preparedUrl += "&connectionData=" + window.encodeURIComponent(connection.data);
1383.             }
1385.             return preparedUrl;
1386.         },
1388.         addQs: function (url, qs) {
1389.             var appender = url.indexOf("?") !== -1 ? "&" : "?",
1390.                 firstChar;
1392.             if (!qs) {
1393.                 return url;
1394.             }
1396.             if (typeof (qs) === "object") {
1397.                 return url + appender + $.param(qs);
1398.             }
1400.             if (typeof (qs) === "string") {
1401.                 firstChar = qs.charAt(0);
1403.                 if (firstChar === "?" || firstChar === "&") {
1404.                     appender = "";
1405.                 }
1407.                 return url + appender + qs;
1408.             }
1410.             throw new Error("Query string property must be either a string or object.");
1411.         },
1413.         // BUG #2953: The url needs to be same otherwise it will cause a memory leak
1414.         getUrl: function (connection, transport, reconnecting, poll, ajaxPost) {
1415.             /// <summary>Gets the url for making a GET based connect request</summary>
1416.             var baseUrl = transport === "webSockets" ? "" : connection.baseUrl,
1417.                 url = baseUrl + connection.appRelativeUrl,
1418.                 qs = "transport=" + transport;
1420.             if (!ajaxPost && connection.groupsToken) {
1421.                 qs += "&groupsToken=" + window.encodeURIComponent(connection.groupsToken);
1422.             }
1424.             if (!reconnecting) {
1425.                 url += "/connect";
1426.             } else {
1427.                 if (poll) {
1428.                     // longPolling transport specific
1429.                     url += "/poll";
1430.                 } else {
1431.                     url += "/reconnect";
1432.                 }
1434.                 if (!ajaxPost && connection.messageId) {
1435.                     qs += "&messageId=" + window.encodeURIComponent(connection.messageId);
1436.                 }
1437.             }
1438.             url += "?" + qs;
1439.             url = transportLogic.prepareQueryString(connection, url);
1441.             // With sse or ws, access_token in request header is not supported
1442.             if (connection.transport && connection.accessToken) {
1443.                 if (connection.transport.name === "serverSentEvents" || connection.transport.name === "webSockets") {
1444.                     url += "&access_token=" + window.encodeURIComponent(connection.accessToken);
1445.                 }
1446.             }
1448.             if (!ajaxPost) {
1449.                 url += "&tid=" + Math.floor(Math.random() * 11);
1450.             }
1452.             return url;
1453.         },
1455.         maximizePersistentResponse: function (minPersistentResponse) {
1456.             return {
1457.                 MessageId: minPersistentResponse.C,
1458.                 Messages: minPersistentResponse.M,
1459.                 Initialized: typeof (minPersistentResponse.S) !== "undefined" ? true : false,
1460.                 ShouldReconnect: typeof (minPersistentResponse.T) !== "undefined" ? true : false,
1461.                 LongPollDelay: minPersistentResponse.L,
1462.                 GroupsToken: minPersistentResponse.G,
1463.                 Error: minPersistentResponse.E
1464.             };
1465.         },
1467.         updateGroups: function (connection, groupsToken) {
1468.             if (groupsToken) {
1469.                 connection.groupsToken = groupsToken;
1470.             }
1471.         },
1473.         stringifySend: function (connection, message) {
1474.             if (typeof (message) === "string" || typeof (message) === "undefined" || message === null) {
1475.                 return message;
1476.             }
1477.             return connection.json.stringify(message);
1478.         },
1480.         ajaxSend: function (connection, data) {
1481.             var payload = transportLogic.stringifySend(connection, data),
1482.                 url = getAjaxUrl(connection, "/send"),
1483.                 xhr,
1484.                 onFail = function (error, connection) {
1485.                     $(connection).triggerHandler(events.onError, [signalR._.transportError(signalR.resources.sendFailed, connection.transport, error, xhr), data]);
1486.                 };
1489.             xhr = transportLogic.ajax(connection, {
1490.                 url: url,
1491.                 type: connection.ajaxDataType === "jsonp" ? "GET" : "POST",
1492.                 contentType: signalR._.defaultContentType,
1493.                 headers: connection.accessToken ? { "Authorization": "Bearer " + connection.accessToken } : {},
1494.                 data: {
1495.                     data: payload
1496.                 },
1497.                 success: function (result) {
1498.                     var res;
1500.                     if (result) {
1501.                         try {
1502.                             res = connection._parseResponse(result);
1503.                         }
1504.                         catch (error) {
1505.                             onFail(error, connection);
1506.                             connection.stop();
1507.                             return;
1508.                         }
1510.                         transportLogic.triggerReceived(connection, res);
1511.                     }
1512.                 },
1513.                 error: function (error, textStatus) {
1514.                     if (textStatus === "abort" || textStatus === "parsererror") {
1515.                         // The parsererror happens for sends that don't return any data, and hence
1516.                         // don't write the jsonp callback to the response. This is harder to fix on the server
1517.                         // so just hack around it on the client for now.
1518.                         return;
1519.                     }
1521.                     onFail(error, connection);
1522.                 }
1523.             });
1525.             return xhr;
1526.         },
1528.         ajaxAbort: function (connection, async) {
1529.             if (typeof (connection.transport) === "undefined") {
1530.                 return;
1531.             }
1533.             // Async by default unless explicitly overidden
1534.             async = typeof async === "undefined" ? true : async;
1536.             var url = getAjaxUrl(connection, "/abort");
1538.             var requestHeaders = connection.accessToken ? { "Authorization": "Bearer " + connection.accessToken } : {};
1540.             //option #1 - send "fetch" with keepalive
1541.             if (window.fetch) {
1542.                 // use the fetch API with keepalive
1543.                 window.fetch(url, {
1544.                     method: "POST",
1545.                     keepalive: true,
1546.                     headers: requestHeaders,
1547.                     credentials: connection.withCredentials === true ? "include" : "same-origin"
1548.                 });
1549.             }
1550.             else {
1551.                 // fetch is not available - fallback to $.ajax
1552.                 transportLogic.ajax(connection, {
1553.                     url: url,
1554.                     async: async,
1555.                     timeout: 1000,
1556.                     type: "POST",
1557.                     headers: requestHeaders,
1558.                     dataType: "text" // We don't want to use JSONP here even when JSONP is enabled
1559.                 });
1560.             }
1562.             connection.log("Fired ajax abort async = " + async + ".");
1563.         },
1565.         ajaxStart: function (connection, onSuccess) {
1566.             var rejectDeferred = function (error) {
1567.                     var deferred = connection._deferral;
1568.                     if (deferred) {
1569.                         deferred.reject(error);
1570.                     }
1571.                 },
1572.                 triggerStartError = function (error) {
1573.                     connection.log("The start request failed. Stopping the connection.");
1574.                     $(connection).triggerHandler(events.onError, [error]);
1575.                     rejectDeferred(error);
1576.                     connection.stop();
1577.                 };
1579.             connection._.startRequest = transportLogic.ajax(connection, {
1580.                 url: getAjaxUrl(connection, "/start"),
1581.                 headers: connection.accessToken ? { "Authorization": "Bearer " + connection.accessToken } : {},
1582.                 success: function (result, statusText, xhr) {
1583.                     var data;
1585.                     try {
1586.                         data = connection._parseResponse(result);
1587.                     } catch (error) {
1588.                         triggerStartError(signalR._.error(
1589.                             signalR._.format(signalR.resources.errorParsingStartResponse, result),
1590.                             error, xhr));
1591.                         return;
1592.                     }
1594.                     if (data.Response === "started") {
1595.                         onSuccess();
1596.                     } else {
1597.                         triggerStartError(signalR._.error(
1598.                             signalR._.format(signalR.resources.invalidStartResponse, result),
1599.                             null /* error */, xhr));
1600.                     }
1601.                 },
1602.                 error: function (xhr, statusText, error) {
1603.                     if (statusText !== startAbortText) {
1604.                         triggerStartError(signalR._.error(
1605.                             signalR.resources.errorDuringStartRequest,
1606.                             error, xhr));
1607.                     } else {
1608.                         // Stop has been called, no need to trigger the error handler
1609.                         // or stop the connection again with onStartError
1610.                         connection.log("The start request aborted because connection.stop() was called.");
1611.                         rejectDeferred(signalR._.error(
1612.                             signalR.resources.stoppedDuringStartRequest,
1613.                             null /* error */, xhr));
1614.                     }
1615.                 }
1616.             });
1617.         },
1619.         tryAbortStartRequest: function (connection) {
1620.             if (connection._.startRequest) {
1621.                 // If the start request has already completed this will noop.
1622.                 connection._.startRequest.abort(startAbortText);
1623.                 delete connection._.startRequest;
1624.             }
1625.         },
1627.         tryInitialize: function (connection, persistentResponse, onInitialized) {
1628.             if (persistentResponse.Initialized && onInitialized) {
1629.                 onInitialized();
1630.             } else if (persistentResponse.Initialized) {
1631.                 connection.log("WARNING! The client received an init message after reconnecting.");
1632.             }
1634.         },
1636.         triggerReceived: function (connection, data) {
1637.             if (!connection._.connectingMessageBuffer.tryBuffer(data)) {
1638.                 $(connection).triggerHandler(events.onReceived, [data]);
1639.             }
1640.         },
1642.         processMessages: function (connection, minData, onInitialized) {
1643.             var data;
1645.             if(minData && (typeof minData.I !== "undefined")) {
1646.                 // This is a response to a message the client sent
1647.                 transportLogic.triggerReceived(connection, minData);
1648.                 return;
1649.             }
1651.             // Update the last message time stamp
1652.             transportLogic.markLastMessage(connection);
1654.             if (minData) {
1655.                 // This is a message send directly to the client
1656.                 data = transportLogic.maximizePersistentResponse(minData);
1658.                 if (data.Error) {
1659.                     // This is a global error, stop the connection.
1660.                     connection.log("Received an error message from the server: " + minData.E);
1661.                     $(connection).triggerHandler(signalR.events.onError, [signalR._.error(minData.E, /* source */ "ServerError")]);
1662.                     connection.stop(/* async */ false, /* notifyServer */ false);
1663.                     return;
1664.                 }
1666.                 transportLogic.updateGroups(connection, data.GroupsToken);
1668.                 if (data.MessageId) {
1669.                     connection.messageId = data.MessageId;
1670.                 }
1672.                 if (data.Messages) {
1673.                     $.each(data.Messages, function (index, message) {
1674.                         transportLogic.triggerReceived(connection, message);
1675.                     });
1677.                     transportLogic.tryInitialize(connection, data, onInitialized);
1678.                 }
1679.             }
1680.         },
1682.         monitorKeepAlive: function (connection) {
1683.             var keepAliveData = connection._.keepAliveData;
1685.             // If we haven't initiated the keep alive timeouts then we need to
1686.             if (!keepAliveData.monitoring) {
1687.                 keepAliveData.monitoring = true;
1689.                 transportLogic.markLastMessage(connection);
1691.                 // Save the function so we can unbind it on stop
1692.                 connection._.keepAliveData.reconnectKeepAliveUpdate = function () {
1693.                     // Mark a new message so that keep alive doesn't time out connections
1694.                     transportLogic.markLastMessage(connection);
1695.                 };
1697.                 // Update Keep alive on reconnect
1698.                 $(connection).bind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);
1700.                 connection.log("Now monitoring keep alive with a warning timeout of " + keepAliveData.timeoutWarning + ", keep alive timeout of " + keepAliveData.timeout + " and disconnecting timeout of " + connection.disconnectTimeout);
1701.             } else {
1702.                 connection.log("Tried to monitor keep alive but it's already being monitored.");
1703.             }
1704.         },
1706.         stopMonitoringKeepAlive: function (connection) {
1707.             var keepAliveData = connection._.keepAliveData;
1709.             // Only attempt to stop the keep alive monitoring if its being monitored
1710.             if (keepAliveData.monitoring) {
1711.                 // Stop monitoring
1712.                 keepAliveData.monitoring = false;
1714.                 // Remove the updateKeepAlive function from the reconnect event
1715.                 $(connection).unbind(events.onReconnect, connection._.keepAliveData.reconnectKeepAliveUpdate);
1717.                 // Clear all the keep alive data
1718.                 connection._.keepAliveData = {};
1719.                 connection.log("Stopping the monitoring of the keep alive.");
1720.             }
1721.         },
1723.         startHeartbeat: function (connection) {
1724.             connection._.lastActiveAt = new Date().getTime();
1725.             beat(connection);
1726.         },
1728.         markLastMessage: function (connection) {
1729.             connection._.lastMessageAt = new Date().getTime();
1730.             connection._.lastActiveAt = connection._.lastMessageAt;
1731.         },
1733.         markActive: function (connection) {
1734.             if (transportLogic.verifyLastActive(connection)) {
1735.                 connection._.lastActiveAt = new Date().getTime();
1736.                 return true;
1737.             }
1739.             return false;
1740.         },
1742.         isConnectedOrReconnecting: function (connection) {
1743.             return connection.state === signalR.connectionState.connected ||
1744.                    connection.state === signalR.connectionState.reconnecting;
1745.         },
1747.         ensureReconnectingState: function (connection) {
1748.             if (changeState(connection,
1749.                         signalR.connectionState.connected,
1750.                         signalR.connectionState.reconnecting) === true) {
1751.                 $(connection).triggerHandler(events.onReconnecting);
1752.             }
1753.             return connection.state === signalR.connectionState.reconnecting;
1754.         },
1756.         clearReconnectTimeout: function (connection) {
1757.             if (connection && connection._.reconnectTimeout) {
1758.                 window.clearTimeout(connection._.reconnectTimeout);
1759.                 delete connection._.reconnectTimeout;
1760.             }
1761.         },
1763.         verifyLastActive: function (connection) {
1764.             // If there is no keep alive configured, we cannot assume that timer callbacks will
1765.             // run frequently enough to keep lastActiveAt updated.
1766.             // https://github.com/SignalR/SignalR/issues/4536
1767.             if (!connection._.keepAliveData.activated ||
1768.                 new Date().getTime() - connection._.lastActiveAt < connection.reconnectWindow) {
1769.                 return true;
1770.             }
1772.             var message = signalR._.format(signalR.resources.reconnectWindowTimeout, new Date(connection._.lastActiveAt), connection.reconnectWindow);
1773.             connection.log(message);
1774.             $(connection).triggerHandler(events.onError, [signalR._.error(message, /* source */ "TimeoutException")]);
1775.             connection.stop(/* async */ false, /* notifyServer */ false);
1776.             return false;
1777.         },
1779.         reconnect: function (connection, transportName) {
1780.             var transport = signalR.transports[transportName];
1782.             // We should only set a reconnectTimeout if we are currently connected
1783.             // and a reconnectTimeout isn't already set.
1784.             if (transportLogic.isConnectedOrReconnecting(connection) && !connection._.reconnectTimeout) {
1785.                 // Need to verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.
1786.                 if (!transportLogic.verifyLastActive(connection)) {
1787.                     return;
1788.                 }
1790.                 connection._.reconnectTimeout = window.setTimeout(function () {
1791.                     if (!transportLogic.verifyLastActive(connection)) {
1792.                         return;
1793.                     }
1795.                     transport.stop(connection);
1797.                     if (transportLogic.ensureReconnectingState(connection)) {
1798.                         connection.log(transportName + " reconnecting.");
1799.                         transport.start(connection);
1800.                     }
1801.                 }, connection.reconnectDelay);
1802.             }
1803.         },
1805.         handleParseFailure: function (connection, result, error, onFailed, context) {
1806.             var wrappedError = signalR._.transportError(
1807.                 signalR._.format(signalR.resources.parseFailed, result),
1808.                 connection.transport,
1809.                 error,
1810.                 context);
1812.             // If we're in the initialization phase trigger onFailed, otherwise stop the connection.
1813.             if (onFailed && onFailed(wrappedError)) {
1814.                 connection.log("Failed to parse server response while attempting to connect.");
1815.             } else {
1816.                 $(connection).triggerHandler(events.onError, [wrappedError]);
1817.                 connection.stop();
1818.             }
1819.         },
1821.         initHandler: function (connection) {
1822.             return new InitHandler(connection);
1823.         },
1825.         foreverFrame: {
1826.             count: 0,
1827.             connections: {}
1828.         }
1829.     };
1831. }(window.jQuery, window));
1832. /* jquery.signalR.transports.webSockets.js */
1833. // Copyright (c) .NET Foundation. All rights reserved.
1834. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1837. /*global window:false */
1838. /// <reference path="jquery.signalR.transports.common.js" />
1840. (function ($, window, undefined) {
1842.     var signalR = $.signalR,
1843.         events = $.signalR.events,
1844.         changeState = $.signalR.changeState,
1845.         transportLogic = signalR.transports._logic;
1847.     signalR.transports.webSockets = {
1848.         name: "webSockets",
1850.         supportsKeepAlive: function () {
1851.             return true;
1852.         },
1854.         send: function (connection, data) {
1855.             var payload = transportLogic.stringifySend(connection, data);
1857.             try {
1858.                 connection.socket.send(payload);
1859.             } catch (ex) {
1860.                 $(connection).triggerHandler(events.onError,
1861.                     [signalR._.transportError(
1862.                         signalR.resources.webSocketsInvalidState,
1863.                         connection.transport,
1864.                         ex,
1865.                         connection.socket
1866.                     ),
1867.                     data]);
1868.             }
1869.         },
1871.         start: function (connection, onSuccess, onFailed) {
1872.             var url,
1873.                 opened = false,
1874.                 that = this,
1875.                 reconnecting = !onSuccess,
1876.                 $connection = $(connection);
1878.             if (!window.WebSocket) {
1879.                 onFailed();
1880.                 return;
1881.             }
1883.             if (!connection.socket) {
1884.                 if (connection.webSocketServerUrl) {
1885.                     url = connection.webSocketServerUrl;
1886.                 } else {
1887.                     url = connection.wsProtocol + connection.host;
1888.                 }
1890.                 url += transportLogic.getUrl(connection, this.name, reconnecting);
1892.                 connection.log("Connecting to websocket endpoint '" + url + "'.");
1893.                 connection.socket = new window.WebSocket(url);
1895.                 connection.socket.onopen = function () {
1896.                     opened = true;
1897.                     connection.log("Websocket opened.");
1899.                     transportLogic.clearReconnectTimeout(connection);
1901.                     if (changeState(connection,
1902.                                     signalR.connectionState.reconnecting,
1903.                                     signalR.connectionState.connected) === true) {
1904.                         $connection.triggerHandler(events.onReconnect);
1905.                     }
1906.                 };
1908.                 connection.socket.onclose = function (event) {
1909.                     var error;
1911.                     // Only handle a socket close if the close is from the current socket.
1912.                     // Sometimes on disconnect the server will push down an onclose event
1913.                     // to an expired socket.
1915.                     if (this === connection.socket) {
1916.                         if (opened && typeof event.wasClean !== "undefined" && event.wasClean === false) {
1917.                             // Ideally this would use the websocket.onerror handler (rather than checking wasClean in onclose) but
1918.                             // I found in some circumstances Chrome won't call onerror. This implementation seems to work on all browsers.
1919.                             error = signalR._.transportError(
1920.                                 signalR.resources.webSocketClosed,
1921.                                 connection.transport,
1922.                                 event);
1924.                             connection.log("Unclean disconnect from websocket: " + (event.reason || "[no reason given]."));
1925.                         } else {
1926.                             connection.log("Websocket closed.");
1927.                         }
1929.                         if (!onFailed || !onFailed(error)) {
1930.                             if (error) {
1931.                                 $(connection).triggerHandler(events.onError, [error]);
1932.                             }
1934.                             that.reconnect(connection);
1935.                         }
1936.                     }
1937.                 };
1939.                 connection.socket.onmessage = function (event) {
1940.                     var data;
1942.                     try {
1943.                         data = connection._parseResponse(event.data);
1944.                     }
1945.                     catch (error) {
1946.                         transportLogic.handleParseFailure(connection, event.data, error, onFailed, event);
1947.                         return;
1948.                     }
1950.                     if (data) {
1951.                         transportLogic.processMessages(connection, data, onSuccess);
1952.                     }
1953.                 };
1954.             }
1955.         },
1957.         reconnect: function (connection) {
1958.             transportLogic.reconnect(connection, this.name);
1959.         },
1961.         lostConnection: function (connection) {
1962.             this.reconnect(connection);
1963.         },
1965.         stop: function (connection) {
1966.             // Don't trigger a reconnect after stopping
1967.             transportLogic.clearReconnectTimeout(connection);
1969.             if (connection.socket) {
1970.                 connection.log("Closing the Websocket.");
1971.                 connection.socket.close();
1972.                 connection.socket = null;
1973.             }
1974.         },
1976.         abort: function (connection, async) {
1977.             transportLogic.ajaxAbort(connection, async);
1978.         }
1979.     };
1981. }(window.jQuery, window));
1982. /* jquery.signalR.transports.serverSentEvents.js */
1983. // Copyright (c) .NET Foundation. All rights reserved.
1984. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
1987. /*global window:false */
1988. /// <reference path="jquery.signalR.transports.common.js" />
1990. (function ($, window, undefined) {
1992.     var signalR = $.signalR,
1993.         events = $.signalR.events,
1994.         changeState = $.signalR.changeState,
1995.         transportLogic = signalR.transports._logic,
1996.         clearReconnectAttemptTimeout = function (connection) {
1997.             window.clearTimeout(connection._.reconnectAttemptTimeoutHandle);
1998.             delete connection._.reconnectAttemptTimeoutHandle;
1999.         };
2001.     signalR.transports.serverSentEvents = {
2002.         name: "serverSentEvents",
2004.         supportsKeepAlive: function () {
2005.             return true;
2006.         },
2008.         timeOut: 3000,
2010.         start: function (connection, onSuccess, onFailed) {
2011.             var that = this,
2012.                 opened = false,
2013.                 $connection = $(connection),
2014.                 reconnecting = !onSuccess,
2015.                 url;
2017.             if (connection.eventSource) {
2018.                 connection.log("The connection already has an event source. Stopping it.");
2019.                 connection.stop();
2020.             }
2022.             if (!window.EventSource) {
2023.                 if (onFailed) {
2024.                     connection.log("This browser doesn't support SSE.");
2025.                     onFailed();
2026.                 }
2027.                 return;
2028.             }
2030.             url = transportLogic.getUrl(connection, this.name, reconnecting);
2032.             try {
2033.                 connection.log("Attempting to connect to SSE endpoint '" + url + "'.");
2034.                 connection.eventSource = new window.EventSource(url, { withCredentials: connection.withCredentials });
2035.             }
2036.             catch (e) {
2037.                 connection.log("EventSource failed trying to connect with error " + e.Message + ".");
2038.                 if (onFailed) {
2039.                     // The connection failed, call the failed callback
2040.                     onFailed();
2041.                 } else {
2042.                     $connection.triggerHandler(events.onError, [signalR._.transportError(signalR.resources.eventSourceFailedToConnect, connection.transport, e)]);
2043.                     if (reconnecting) {
2044.                         // If we were reconnecting, rather than doing initial connect, then try reconnect again
2045.                         that.reconnect(connection);
2046.                     }
2047.                 }
2048.                 return;
2049.             }
2051.             if (reconnecting) {
2052.                 connection._.reconnectAttemptTimeoutHandle = window.setTimeout(function () {
2053.                     if (opened === false) {
2054.                         // If we're reconnecting and the event source is attempting to connect,
2055.                         // don't keep retrying. This causes duplicate connections to spawn.
2056.                         if (connection.eventSource.readyState !== window.EventSource.OPEN) {
2057.                             // If we were reconnecting, rather than doing initial connect, then try reconnect again
2058.                             that.reconnect(connection);
2059.                         }
2060.                     }
2061.                 },
2062.                 that.timeOut);
2063.             }
2065.             connection.eventSource.addEventListener("open", function (e) {
2066.                 connection.log("EventSource connected.");
2068.                 clearReconnectAttemptTimeout(connection);
2069.                 transportLogic.clearReconnectTimeout(connection);
2071.                 if (opened === false) {
2072.                     opened = true;
2074.                     if (changeState(connection,
2075.                                          signalR.connectionState.reconnecting,
2076.                                          signalR.connectionState.connected) === true) {
2077.                         $connection.triggerHandler(events.onReconnect);
2078.                     }
2079.                 }
2080.             }, false);
2082.             connection.eventSource.addEventListener("message", function (e) {
2083.                 var res;
2085.                 // process messages
2086.                 if (e.data === "initialized") {
2087.                     return;
2088.                 }
2090.                 try {
2091.                     res = connection._parseResponse(e.data);
2092.                 }
2093.                 catch (error) {
2094.                     transportLogic.handleParseFailure(connection, e.data, error, onFailed, e);
2095.                     return;
2096.                 }
2098.                 transportLogic.processMessages(connection, res, onSuccess);
2099.             }, false);
2101.             connection.eventSource.addEventListener("error", function (e) {
2102.                 var error = signalR._.transportError(
2103.                     signalR.resources.eventSourceError,
2104.                     connection.transport,
2105.                     e);
2107.                 // Only handle an error if the error is from the current Event Source.
2108.                 // Sometimes on disconnect the server will push down an error event
2109.                 // to an expired Event Source.
2110.                 if (this !== connection.eventSource) {
2111.                     return;
2112.                 }
2114.                 if (onFailed && onFailed(error)) {
2115.                     return;
2116.                 }
2118.                 connection.log("EventSource readyState: " + connection.eventSource.readyState + ".");
2120.                 if (e.eventPhase === window.EventSource.CLOSED) {
2121.                     // We don't use the EventSource's native reconnect function as it
2122.                     // doesn't allow us to change the URL when reconnecting. We need
2123.                     // to change the URL to not include the /connect suffix, and pass
2124.                     // the last message id we received.
2125.                     connection.log("EventSource reconnecting due to the server connection ending.");
2126.                     that.reconnect(connection);
2127.                 } else {
2128.                     // connection error
2129.                     connection.log("EventSource error.");
2130.                     $connection.triggerHandler(events.onError, [error]);
2131.                 }
2132.             }, false);
2133.         },
2135.         reconnect: function (connection) {
2136.             transportLogic.reconnect(connection, this.name);
2137.         },
2139.         lostConnection: function (connection) {
2140.             this.reconnect(connection);
2141.         },
2143.         send: function (connection, data) {
2144.             transportLogic.ajaxSend(connection, data);
2145.         },
2147.         stop: function (connection) {
2148.             // Don't trigger a reconnect after stopping
2149.             clearReconnectAttemptTimeout(connection);
2150.             transportLogic.clearReconnectTimeout(connection);
2152.             if (connection && connection.eventSource) {
2153.                 connection.log("EventSource calling close().");
2154.                 connection.eventSource.close();
2155.                 connection.eventSource = null;
2156.                 delete connection.eventSource;
2157.             }
2158.         },
2160.         abort: function (connection, async) {
2161.             transportLogic.ajaxAbort(connection, async);
2162.         }
2163.     };
2165. }(window.jQuery, window));
2166. /* jquery.signalR.transports.foreverFrame.js */
2167. // Copyright (c) .NET Foundation. All rights reserved.
2168. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
2171. /*global window:false */
2172. /// <reference path="jquery.signalR.transports.common.js" />
2174. (function ($, window, undefined) {
2176.     var signalR = $.signalR,
2177.         events = $.signalR.events,
2178.         changeState = $.signalR.changeState,
2179.         transportLogic = signalR.transports._logic,
2180.         createFrame = function () {
2181.             var frame = window.document.createElement("iframe");
2182.             frame.setAttribute("style", "position:absolute;top:0;left:0;width:0;height:0;visibility:hidden;");
2183.             return frame;
2184.         },
2185.         // Used to prevent infinite loading icon spins in older versions of ie
2186.         // We build this object inside a closure so we don't pollute the rest of
2187.         // the foreverFrame transport with unnecessary functions/utilities.
2188.         loadPreventer = (function () {
2189.             var loadingFixIntervalId = null,
2190.                 loadingFixInterval = 1000,
2191.                 attachedTo = 0;
2193.             return {
2194.                 prevent: function () {
2195.                     // Prevent additional iframe removal procedures from newer browsers
2196.                     if (signalR._.ieVersion <= 8) {
2197.                         // We only ever want to set the interval one time, so on the first attachedTo
2198.                         if (attachedTo === 0) {
2199.                             // Create and destroy iframe every 3 seconds to prevent loading icon, super hacky
2200.                             loadingFixIntervalId = window.setInterval(function () {
2201.                                 var tempFrame = createFrame();
2203.                                 window.document.body.appendChild(tempFrame);
2204.                                 window.document.body.removeChild(tempFrame);
2206.                                 tempFrame = null;
2207.                             }, loadingFixInterval);
2208.                         }
2210.                         attachedTo++;
2211.                     }
2212.                 },
2213.                 cancel: function () {
2214.                     // Only clear the interval if there's only one more object that the loadPreventer is attachedTo
2215.                     if (attachedTo === 1) {
2216.                         window.clearInterval(loadingFixIntervalId);
2217.                     }
2219.                     if (attachedTo > 0) {
2220.                         attachedTo--;
2221.                     }
2222.                 }
2223.             };
2224.         })();
2226.     signalR.transports.foreverFrame = {
2227.         name: "foreverFrame",
2229.         supportsKeepAlive: function () {
2230.             return true;
2231.         },
2233.         // Added as a value here so we can create tests to verify functionality
2234.         iframeClearThreshold: 50,
2236.         start: function (connection, onSuccess, onFailed) {
2237.             if (connection.accessToken) {
2238.                 if (onFailed) {
2239.                     connection.log("Forever Frame does not support connections that require a Bearer token to connect, such as the Azure SignalR Service.");
2240.                     onFailed();
2241.                 }
2242.                 return;
2243.             }
2245.             var that = this,
2246.                 frameId = (transportLogic.foreverFrame.count += 1),
2247.                 url,
2248.                 frame = createFrame(),
2249.                 frameLoadHandler = function () {
2250.                     connection.log("Forever frame iframe finished loading and is no longer receiving messages.");
2251.                     if (!onFailed || !onFailed()) {
2252.                         that.reconnect(connection);
2253.                     }
2254.                 };
2256.             if (window.EventSource) {
2257.                 // If the browser supports SSE, don't use Forever Frame
2258.                 if (onFailed) {
2259.                     connection.log("Forever Frame is not supported by SignalR on browsers with SSE support.");
2260.                     onFailed();
2261.                 }
2262.                 return;
2263.             }
2265.             frame.setAttribute("data-signalr-connection-id", connection.id);
2267.             // Start preventing loading icon
2268.             // This will only perform work if the loadPreventer is not attached to another connection.
2269.             loadPreventer.prevent();
2271.             // Build the url
2272.             url = transportLogic.getUrl(connection, this.name);
2273.             url += "&frameId=" + frameId;
2275.             // add frame to the document prior to setting URL to avoid caching issues.
2276.             window.document.documentElement.appendChild(frame);
2278.             connection.log("Binding to iframe's load event.");
2280.             if (frame.addEventListener) {
2281.                 frame.addEventListener("load", frameLoadHandler, false);
2282.             } else if (frame.attachEvent) {
2283.                 frame.attachEvent("onload", frameLoadHandler);
2284.             }
2286.             frame.src = url;
2287.             transportLogic.foreverFrame.connections[frameId] = connection;
2289.             connection.frame = frame;
2290.             connection.frameId = frameId;
2292.             if (onSuccess) {
2293.                 connection.onSuccess = function () {
2294.                     connection.log("Iframe transport started.");
2295.                     onSuccess();
2296.                 };
2297.             }
2298.         },
2300.         reconnect: function (connection) {
2301.             var that = this;
2303.             // Need to verify connection state and verify before the setTimeout occurs because an application sleep could occur during the setTimeout duration.
2304.             if (transportLogic.isConnectedOrReconnecting(connection) && transportLogic.verifyLastActive(connection)) {
2305.                 window.setTimeout(function () {
2306.                     // Verify that we're ok to reconnect.
2307.                     if (!transportLogic.verifyLastActive(connection)) {
2308.                         return;
2309.                     }
2311.                     if (connection.frame && transportLogic.ensureReconnectingState(connection)) {
2312.                         var frame = connection.frame,
2313.                             src = transportLogic.getUrl(connection, that.name, true) + "&frameId=" + connection.frameId;
2314.                         connection.log("Updating iframe src to '" + src + "'.");
2315.                         frame.src = src;
2316.                     }
2317.                 }, connection.reconnectDelay);
2318.             }
2319.         },
2321.         lostConnection: function (connection) {
2322.             this.reconnect(connection);
2323.         },
2325.         send: function (connection, data) {
2326.             transportLogic.ajaxSend(connection, data);
2327.         },
2329.         receive: function (connection, data) {
2330.             var cw,
2331.                 body,
2332.                 response;
2334.             if (connection.json !== connection._originalJson) {
2335.                 // If there's a custom JSON parser configured then serialize the object
2336.                 // using the original (browser) JSON parser and then deserialize it using
2337.                 // the custom parser (connection._parseResponse does that). This is so we
2338.                 // can easily send the response from the server as "raw" JSON but still
2339.                 // support custom JSON deserialization in the browser.
2340.                 data = connection._originalJson.stringify(data);
2341.             }
2343.             response = connection._parseResponse(data);
2345.             transportLogic.processMessages(connection, response, connection.onSuccess);
2347.             // Protect against connection stopping from a callback trigger within the processMessages above.
2348.             if (connection.state === $.signalR.connectionState.connected) {
2349.                 // Delete the script & div elements
2350.                 connection.frameMessageCount = (connection.frameMessageCount || 0) + 1;
2351.                 if (connection.frameMessageCount > signalR.transports.foreverFrame.iframeClearThreshold) {
2352.                     connection.frameMessageCount = 0;
2353.                     cw = connection.frame.contentWindow || connection.frame.contentDocument;
2354.                     if (cw && cw.document && cw.document.body) {
2355.                         body = cw.document.body;
2357.                         // Remove all the child elements from the iframe's body to conserver memory
2358.                         while (body.firstChild) {
2359.                             body.removeChild(body.firstChild);
2360.                         }
2361.                     }
2362.                 }
2363.             }
2364.         },
2366.         stop: function (connection) {
2367.             var cw = null;
2369.             // Stop attempting to prevent loading icon
2370.             loadPreventer.cancel();
2372.             if (connection.frame) {
2373.                 if (connection.frame.stop) {
2374.                     connection.frame.stop();
2375.                 } else {
2376.                     try {
2377.                         cw = connection.frame.contentWindow || connection.frame.contentDocument;
2378.                         if (cw.document && cw.document.execCommand) {
2379.                             cw.document.execCommand("Stop");
2380.                         }
2381.                     }
2382.                     catch (e) {
2383.                         connection.log("Error occurred when stopping foreverFrame transport. Message = " + e.message + ".");
2384.                     }
2385.                 }
2387.                 // Ensure the iframe is where we left it
2388.                 if (connection.frame.parentNode === window.document.documentElement) {
2389.                     window.document.documentElement.removeChild(connection.frame);
2390.                 }
2392.                 delete transportLogic.foreverFrame.connections[connection.frameId];
2393.                 connection.frame = null;
2394.                 connection.frameId = null;
2395.                 delete connection.frame;
2396.                 delete connection.frameId;
2397.                 delete connection.onSuccess;
2398.                 delete connection.frameMessageCount;
2399.                 connection.log("Stopping forever frame.");
2400.             }
2401.         },
2403.         abort: function (connection, async) {
2404.             transportLogic.ajaxAbort(connection, async);
2405.         },
2407.         getConnection: function (id) {
2408.             return transportLogic.foreverFrame.connections[id];
2409.         },
2411.         started: function (connection) {
2412.             if (changeState(connection,
2413.                 signalR.connectionState.reconnecting,
2414.                 signalR.connectionState.connected) === true) {
2416.                 $(connection).triggerHandler(events.onReconnect);
2417.             }
2418.         }
2419.     };
2421. }(window.jQuery, window));
2422. /* jquery.signalR.transports.longPolling.js */
2423. // Copyright (c) .NET Foundation. All rights reserved.
2424. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
2427. /*global window:false */
2428. /// <reference path="jquery.signalR.transports.common.js" />
2430. (function ($, window, undefined) {
2432.     var signalR = $.signalR,
2433.         events = $.signalR.events,
2434.         changeState = $.signalR.changeState,
2435.         isDisconnecting = $.signalR.isDisconnecting,
2436.         transportLogic = signalR.transports._logic;
2438.     signalR.transports.longPolling = {
2439.         name: "longPolling",
2441.         supportsKeepAlive: function () {
2442.             return false;
2443.         },
2445.         reconnectDelay: 3000,
2447.         start: function (connection, onSuccess, onFailed) {
2448.             /// <summary>Starts the long polling connection</summary>
2449.             /// <param name="connection" type="signalR">The SignalR connection to start</param>
2450.             var that = this,
2451.                 fireConnect = function () {
2452.                     fireConnect = $.noop;
2454.                     connection.log("LongPolling connected.");
2456.                     if (onSuccess) {
2457.                         onSuccess();
2458.                     } else {
2459.                         connection.log("WARNING! The client received an init message after reconnecting.");
2460.                     }
2461.                 },
2462.                 tryFailConnect = function (error) {
2463.                     if (onFailed(error)) {
2464.                         connection.log("LongPolling failed to connect.");
2465.                         return true;
2466.                     }
2468.                     return false;
2469.                 },
2470.                 privateData = connection._,
2471.                 reconnectErrors = 0,
2472.                 fireReconnected = function (instance) {
2473.                     window.clearTimeout(privateData.reconnectTimeoutId);
2474.                     privateData.reconnectTimeoutId = null;
2476.                     if (changeState(instance,
2477.                                     signalR.connectionState.reconnecting,
2478.                                     signalR.connectionState.connected) === true) {
2479.                         // Successfully reconnected!
2480.                         instance.log("Raising the reconnect event");
2481.                         $(instance).triggerHandler(events.onReconnect);
2482.                     }
2483.                 },
2484.                 // 1 hour
2485.                 maxFireReconnectedTimeout = 3600000;
2487.             if (connection.pollXhr) {
2488.                 connection.log("Polling xhr requests already exists, aborting.");
2489.                 connection.stop();
2490.             }
2492.             connection.messageId = null;
2494.             privateData.reconnectTimeoutId = null;
2496.             privateData.pollTimeoutId = window.setTimeout(function () {
2497.                 (function poll(instance, raiseReconnect) {
2498.                     var messageId = instance.messageId,
2499.                         connect = (messageId === null),
2500.                         reconnecting = !connect,
2501.                         polling = !raiseReconnect,
2502.                         url = transportLogic.getUrl(instance, that.name, reconnecting, polling, true /* use Post for longPolling */),
2503.                         postData = {};
2505.                     if (instance.messageId) {
2506.                         postData.messageId = instance.messageId;
2507.                     }
2509.                     if (instance.groupsToken) {
2510.                         postData.groupsToken = instance.groupsToken;
2511.                     }
2513.                     // If we've disconnected during the time we've tried to re-instantiate the poll then stop.
2514.                     if (isDisconnecting(instance) === true) {
2515.                         return;
2516.                     }
2518.                     connection.log("Opening long polling request to '" + url + "'.");
2519.                     instance.pollXhr = transportLogic.ajax(connection, {
2520.                         xhrFields: {
2521.                             onprogress: function () {
2522.                                 transportLogic.markLastMessage(connection);
2523.                             }
2524.                         },
2525.                         url: url,
2526.                         type: "POST",
2527.                         contentType: signalR._.defaultContentType,
2528.                         data: postData,
2529.                         timeout: connection._.pollTimeout,
2530.                         headers: connection.accessToken ? { "Authorization": "Bearer " + connection.accessToken } : {},
2531.                         success: function (result) {
2532.                             var minData,
2533.                                 delay = 0,
2534.                                 data,
2535.                                 shouldReconnect;
2537.                             connection.log("Long poll complete.");
2539.                             // Reset our reconnect errors so if we transition into a reconnecting state again we trigger
2540.                             // reconnected quickly
2541.                             reconnectErrors = 0;
2543.                             try {
2544.                                 // Remove any keep-alives from the beginning of the result
2545.                                 minData = connection._parseResponse(result);
2546.                             }
2547.                             catch (error) {
2548.                                 transportLogic.handleParseFailure(instance, result, error, tryFailConnect, instance.pollXhr);
2549.                                 return;
2550.                             }
2552.                             // If there's currently a timeout to trigger reconnect, fire it now before processing messages
2553.                             if (privateData.reconnectTimeoutId !== null) {
2554.                                 fireReconnected(instance);
2555.                             }
2557.                             if (minData) {
2558.                                 data = transportLogic.maximizePersistentResponse(minData);
2559.                             }
2561.                             transportLogic.processMessages(instance, minData, fireConnect);
2563.                             if (data &&
2564.                                 $.type(data.LongPollDelay) === "number") {
2565.                                 delay = data.LongPollDelay;
2566.                             }
2568.                             if (isDisconnecting(instance) === true) {
2569.                                 return;
2570.                             }
2572.                             shouldReconnect = data && data.ShouldReconnect;
2573.                             if (shouldReconnect) {
2574.                                 // Transition into the reconnecting state
2575.                                 // If this fails then that means that the user transitioned the connection into a invalid state in processMessages.
2576.                                 if (!transportLogic.ensureReconnectingState(instance)) {
2577.                                     return;
2578.                                 }
2579.                             }
2581.                             // We never want to pass a raiseReconnect flag after a successful poll.  This is handled via the error function
2582.                             if (delay > 0) {
2583.                                 privateData.pollTimeoutId = window.setTimeout(function () {
2584.                                     poll(instance, shouldReconnect);
2585.                                 }, delay);
2586.                             } else {
2587.                                 poll(instance, shouldReconnect);
2588.                             }
2589.                         },
2591.                         error: function (data, textStatus) {
2592.                             var error = signalR._.transportError(signalR.resources.longPollFailed, connection.transport, data, instance.pollXhr);
2594.                             // Stop trying to trigger reconnect, connection is in an error state
2595.                             // If we're not in the reconnect state this will noop
2596.                             window.clearTimeout(privateData.reconnectTimeoutId);
2597.                             privateData.reconnectTimeoutId = null;
2599.                             if (textStatus === "abort") {
2600.                                 connection.log("Aborted xhr request.");
2601.                                 return;
2602.                             }
2604.                             if (!tryFailConnect(error)) {
2606.                                 // Increment our reconnect errors, we assume all errors to be reconnect errors
2607.                                 // In the case that it's our first error this will cause Reconnect to be fired
2608.                                 // after 1 second due to reconnectErrors being = 1.
2609.                                 reconnectErrors++;
2611.                                 if (connection.state !== signalR.connectionState.reconnecting) {
2612.                                     connection.log("An error occurred using longPolling. Status = " + textStatus + ".  Response = " + data.responseText + ".");
2613.                                     $(instance).triggerHandler(events.onError, [error]);
2614.                                 }
2616.                                 // We check the state here to verify that we're not in an invalid state prior to verifying Reconnect.
2617.                                 // If we're not in connected or reconnecting then the next ensureReconnectingState check will fail and will return.
2618.                                 // Therefore we don't want to change that failure code path.
2619.                                 if ((connection.state === signalR.connectionState.connected ||
2620.                                     connection.state === signalR.connectionState.reconnecting) &&
2621.                                     !transportLogic.verifyLastActive(connection)) {
2622.                                     return;
2623.                                 }
2625.                                 // Transition into the reconnecting state
2626.                                 // If this fails then that means that the user transitioned the connection into the disconnected or connecting state within the above error handler trigger.
2627.                                 if (!transportLogic.ensureReconnectingState(instance)) {
2628.                                     return;
2629.                                 }
2631.                                 // Call poll with the raiseReconnect flag as true after the reconnect delay
2632.                                 privateData.pollTimeoutId = window.setTimeout(function () {
2633.                                     poll(instance, true);
2634.                                 }, that.reconnectDelay);
2635.                             }
2636.                         }
2637.                     });
2639.                     // This will only ever pass after an error has occurred via the poll ajax procedure.
2640.                     if (reconnecting && raiseReconnect === true) {
2641.                         // We wait to reconnect depending on how many times we've failed to reconnect.
2642.                         // This is essentially a heuristic that will exponentially increase in wait time before
2643.                         // triggering reconnected.  This depends on the "error" handler of Poll to cancel this
2644.                         // timeout if it triggers before the Reconnected event fires.
2645.                         // The Math.min at the end is to ensure that the reconnect timeout does not overflow.
2646.                         privateData.reconnectTimeoutId = window.setTimeout(function () { fireReconnected(instance); }, Math.min(1000 * (Math.pow(2, reconnectErrors) - 1), maxFireReconnectedTimeout));
2647.                     }
2648.                 }(connection));
2649.             }, 250); // Have to delay initial poll so Chrome doesn't show loader spinner in tab
2650.         },
2652.         lostConnection: function (connection) {
2653.             if (connection.pollXhr) {
2654.                 connection.pollXhr.abort("lostConnection");
2655.             }
2656.         },
2658.         send: function (connection, data) {
2659.             transportLogic.ajaxSend(connection, data);
2660.         },
2662.         stop: function (connection) {
2663.             /// <summary>Stops the long polling connection</summary>
2664.             /// <param name="connection" type="signalR">The SignalR connection to stop</param>
2666.             window.clearTimeout(connection._.pollTimeoutId);
2667.             window.clearTimeout(connection._.reconnectTimeoutId);
2669.             delete connection._.pollTimeoutId;
2670.             delete connection._.reconnectTimeoutId;
2672.             if (connection.pollXhr) {
2673.                 connection.pollXhr.abort();
2674.                 connection.pollXhr = null;
2675.                 delete connection.pollXhr;
2676.             }
2677.         },
2679.         abort: function (connection, async) {
2680.             transportLogic.ajaxAbort(connection, async);
2681.         }
2682.     };
2684. }(window.jQuery, window));
2685. /* jquery.signalR.hubs.js */
2686. // Copyright (c) .NET Foundation. All rights reserved.
2687. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
2689. /*global window:false */
2690. /// <reference path="jquery.signalR.core.js" />
2692. (function ($, window, undefined) {
2694.     var nextGuid = 0;
2695.     var eventNamespace = ".hubProxy",
2696.         signalR = $.signalR;
2698.     function makeEventName(event) {
2699.         return event + eventNamespace;
2700.     }
2702.     // Equivalent to Array.prototype.map
2703.     function map(arr, fun, thisp) {
2704.         var i,
2705.             length = arr.length,
2706.             result = [];
2707.         for (i = 0; i < length; i += 1) {
2708.             if (arr.hasOwnProperty(i)) {
2709.                 result[i] = fun.call(thisp, arr[i], i, arr);
2710.             }
2711.         }
2712.         return result;
2713.     }
2715.     function getArgValue(a) {
2716.         return $.isFunction(a) ? null : ($.type(a) === "undefined" ? null : a);
2717.     }
2719.     function hasMembers(obj) {
2720.         for (var key in obj) {
2721.             // If we have any properties in our callback map then we have callbacks and can exit the loop via return
2722.             if (obj.hasOwnProperty(key)) {
2723.                 return true;
2724.             }
2725.         }
2727.         return false;
2728.     }
2730.     function clearInvocationCallbacks(connection, error) {
2731.         /// <param name="connection" type="hubConnection" />
2732.         var callbacks = connection._.invocationCallbacks,
2733.             callback;
2735.         if (hasMembers(callbacks)) {
2736.             connection.log("Clearing hub invocation callbacks with error: " + error + ".");
2737.         }
2739.         // Reset the callback cache now as we have a local var referencing it
2740.         connection._.invocationCallbackId = 0;
2741.         delete connection._.invocationCallbacks;
2742.         connection._.invocationCallbacks = {};
2744.         // Loop over the callbacks and invoke them.
2745.         // We do this using a local var reference and *after* we've cleared the cache
2746.         // so that if a fail callback itself tries to invoke another method we don't
2747.         // end up with its callback in the list we're looping over.
2748.         for (var callbackId in callbacks) {
2749.             callback = callbacks[callbackId];
2750.             callback.method.call(callback.scope, { E: error });
2751.         }
2752.     }
2754.     function isCallbackFromGeneratedHubProxy(callback) {
2755.         // https://github.com/SignalR/SignalR/issues/4310
2756.         // The stringified callback from the old generated hub proxy is 137 characters in Edge, Firefox and Chrome.
2757.         // We slice to avoid wasting too many cycles searching through the text of a long large function.
2758.         return $.isFunction(callback) && callback.toString().slice(0, 256).indexOf("// Call the client hub method") >= 0;
2759.     }
2761.     // hubProxy
2762.     function hubProxy(hubConnection, hubName) {
2763.         /// <summary>
2764.         ///     Creates a new proxy object for the given hub connection that can be used to invoke
2765.         ///     methods on server hubs and handle client method invocation requests from the server.
2766.         /// </summary>
2767.         return new hubProxy.fn.init(hubConnection, hubName);
2768.     }
2770.     hubProxy.fn = hubProxy.prototype = {
2771.         init: function (connection, hubName) {
2772.             this.state = {};
2773.             this.connection = connection;
2774.             this.hubName = hubName;
2775.             this._ = {
2776.                 callbackMap: {}
2777.             };
2778.         },
2780.         constructor: hubProxy,
2782.         hasSubscriptions: function () {
2783.             return hasMembers(this._.callbackMap);
2784.         },
2786.         on: function (eventName, callback, callbackIdentity) {
2787.             /// <summary>Wires up a callback to be invoked when a invocation request is received from the server hub.</summary>
2788.             /// <param name="eventName" type="String">The name of the hub event to register the callback for.</param>
2789.             /// <param name="callback" type="Function">The callback to be invoked.</param>
2790.             /// <param name="callbackIdentity" type="Object">An optional object to use as the "identity" for the callback when checking if the handler has already been registered. Defaults to the value of 'callback' if not provided.</param>
2791.             var that = this,
2792.                 callbackMap = that._.callbackMap,
2793.                 isFromOldGeneratedHubProxy = !callbackIdentity && isCallbackFromGeneratedHubProxy(callback);
2795.             // We need the third "identity" argument because the registerHubProxies call made by signalr/js wraps the user-provided callback in a custom wrapper which breaks the identity comparison.
2796.             // callbackIdentity allows the caller of `on` to provide a separate object to use as the "identity". `registerHubProxies` uses the original user callback as this identity object.
2797.             callbackIdentity = callbackIdentity || callback;
2799.             // Assign a global ID to the identity object. This tags the object so we can detect the same object when it comes back.
2800.             if(!callbackIdentity._signalRGuid) {
2801.                 callbackIdentity._signalRGuid = nextGuid++;
2802.             }
2804.             // Normalize the event name to lowercase
2805.             eventName = eventName.toLowerCase();
2807.             // If there is not an event registered for this callback yet we want to create its event space in the callback map.
2808.             var callbackSpace = callbackMap[eventName];
2809.             if (!callbackSpace) {
2810.                 callbackSpace = [];
2811.                 callbackMap[eventName] = callbackSpace;
2812.             }
2814.             // Check if there's already a registration
2815.             var registration;
2816.             for (var i = 0; i < callbackSpace.length; i++) {
2817.                 if (callbackSpace[i].guid === callbackIdentity._signalRGuid || (isFromOldGeneratedHubProxy && callbackSpace[i].isFromOldGeneratedHubProxy)) {
2818.                     registration = callbackSpace[i];
2819.                 }
2820.             }
2822.             // Create a registration if there isn't one already
2823.             if (!registration) {
2824.                 registration = {
2825.                     guid: callbackIdentity._signalRGuid,
2826.                     eventHandlers: [],
2827.                     isFromOldGeneratedHubProxy: isFromOldGeneratedHubProxy
2828.                 };
2829.                 callbackMap[eventName].push(registration);
2830.             }
2832.             var handler = function (e, data) {
2833.                 callback.apply(that, data);
2834.             };
2835.             registration.eventHandlers.push(handler);
2837.             $(that).bind(makeEventName(eventName), handler);
2839.             return that;
2840.         },
2842.         off: function (eventName, callback, callbackIdentity) {
2843.             /// <summary>Removes the callback invocation request from the server hub for the given event name.</summary>
2844.             /// <param name="eventName" type="String">The name of the hub event to unregister the callback for.</param>
2845.             /// <param name="callback" type="Function">The callback to be removed.</param>
2846.             /// <param name="callbackIdentity" type="Object">An optional object to use as the "identity" when looking up the callback. Corresponds to the same parameter provided to 'on'. Defaults to the value of 'callback' if not provided.</param>
2847.             var that = this,
2848.                 callbackMap = that._.callbackMap,
2849.                 callbackSpace,
2850.                 isFromOldGeneratedHubProxy = !callbackIdentity && isCallbackFromGeneratedHubProxy(callback);
2852.             callbackIdentity = callbackIdentity || callback;
2854.             // Normalize the event name to lowercase
2855.             eventName = eventName.toLowerCase();
2857.             callbackSpace = callbackMap[eventName];
2859.             // Verify that there is an event space to unbind
2860.             if (callbackSpace) {
2862.                 if (callback) {
2863.                     // Find the callback registration
2864.                     var callbackRegistration;
2865.                     var callbackIndex;
2866.                     for (var i = 0; i < callbackSpace.length; i++) {
2867.                         if (callbackSpace[i].guid === callbackIdentity._signalRGuid || (isFromOldGeneratedHubProxy && callbackSpace[i].isFromOldGeneratedHubProxy)) {
2868.                             callbackIndex = i;
2869.                             callbackRegistration = callbackSpace[i];
2870.                         }
2871.                     }
2873.                     // Only unbind if there's an event bound with eventName and a callback with the specified callback
2874.                     if (callbackRegistration) {
2875.                         // Unbind all event handlers associated with the registration.
2876.                         for (var j = 0; j < callbackRegistration.eventHandlers.length; j++) {
2877.                             $(that).unbind(makeEventName(eventName), callbackRegistration.eventHandlers[j]);
2878.                         }
2880.                         // Remove the registration from the list
2881.                         callbackSpace.splice(i, 1);
2883.                         // Check if there are any registrations left, if not we need to destroy it.
2884.                         if (callbackSpace.length === 0) {
2885.                             delete callbackMap[eventName];
2886.                         }
2887.                     }
2888.                 } else if (!callback) { // Check if we're removing the whole event and we didn't error because of an invalid callback
2889.                     $(that).unbind(makeEventName(eventName));
2891.                     delete callbackMap[eventName];
2892.                 }
2893.             }
2895.             return that;
2896.         },
2898.         invoke: function (methodName) {
2899.             /// <summary>Invokes a server hub method with the given arguments.</summary>
2900.             /// <param name="methodName" type="String">The name of the server hub method.</param>
2902.             var that = this,
2903.                 connection = that.connection,
2904.                 args = $.makeArray(arguments).slice(1),
2905.                 argValues = map(args, getArgValue),
2906.                 data = { H: that.hubName, M: methodName, A: argValues, I: connection._.invocationCallbackId },
2907.                 d = $.Deferred(),
2908.                 callback = function (minResult) {
2909.                     var result = that._maximizeHubResponse(minResult),
2910.                         source,
2911.                         error;
2913.                     // Update the hub state
2914.                     $.extend(that.state, result.State);
2916.                     if (result.Progress) {
2917.                         if (d.notifyWith) {
2918.                             // Progress is only supported in jQuery 1.7+
2919.                             d.notifyWith(that, [result.Progress.Data]);
2920.                         } else if (!connection._.progressjQueryVersionLogged) {
2921.                             connection.log("A hub method invocation progress update was received but the version of jQuery in use (" + $.prototype.jquery + ") does not support progress updates. Upgrade to jQuery 1.7+ to receive progress notifications.");
2922.                             connection._.progressjQueryVersionLogged = true;
2923.                         }
2924.                     } else if (result.Error) {
2925.                         // Server hub method threw an exception, log it & reject the deferred
2926.                         if (result.StackTrace) {
2927.                             connection.log(result.Error + "\n" + result.StackTrace + ".");
2928.                         }
2930.                         // result.ErrorData is only set if a HubException was thrown
2931.                         source = result.IsHubException ? "HubException" : "Exception";
2932.                         error = signalR._.error(result.Error, source);
2933.                         error.data = result.ErrorData;
2935.                         connection.log(that.hubName + "." + methodName + " failed to execute. Error: " + error.message);
2936.                         d.rejectWith(that, [error]);
2937.                     } else {
2938.                         // Server invocation succeeded, resolve the deferred
2939.                         connection.log("Invoked " + that.hubName + "." + methodName);
2940.                         d.resolveWith(that, [result.Result]);
2941.                     }
2942.                 };
2944.             connection._.invocationCallbacks[connection._.invocationCallbackId.toString()] = { scope: that, method: callback };
2945.             connection._.invocationCallbackId += 1;
2947.             if (!$.isEmptyObject(that.state)) {
2948.                 data.S = that.state;
2949.             }
2951.             connection.log("Invoking " + that.hubName + "." + methodName);
2952.             connection.send(data);
2954.             return d.promise();
2955.         },
2957.         _maximizeHubResponse: function (minHubResponse) {
2958.             return {
2959.                 State: minHubResponse.S,
2960.                 Result: minHubResponse.R,
2961.                 Progress: minHubResponse.P ? {
2962.                     Id: minHubResponse.P.I,
2963.                     Data: minHubResponse.P.D
2964.                 } : null,
2965.                 Id: minHubResponse.I,
2966.                 IsHubException: minHubResponse.H,
2967.                 Error: minHubResponse.E,
2968.                 StackTrace: minHubResponse.T,
2969.                 ErrorData: minHubResponse.D
2970.             };
2971.         }
2972.     };
2974.     hubProxy.fn.init.prototype = hubProxy.fn;
2976.     // hubConnection
2977.     function hubConnection(url, options) {
2978.         /// <summary>Creates a new hub connection.</summary>
2979.         /// <param name="url" type="String">[Optional] The hub route url, defaults to "/signalr".</param>
2980.         /// <param name="options" type="Object">[Optional] Settings to use when creating the hubConnection.</param>
2981.         var settings = {
2982.             qs: null,
2983.             logging: false,
2984.             useDefaultPath: true
2985.         };
2987.         $.extend(settings, options);
2989.         if (!url || settings.useDefaultPath) {
2990.             url = (url || "") + "/signalr";
2991.         }
2992.         return new hubConnection.fn.init(url, settings);
2993.     }
2995.     hubConnection.fn = hubConnection.prototype = $.connection();
2997.     hubConnection.fn.init = function (url, options) {
2998.         var settings = {
2999.             qs: null,
3000.             logging: false,
3001.             useDefaultPath: true
3002.         },
3003.             connection = this;
3005.         $.extend(settings, options);
3007.         // Call the base constructor
3008.         $.signalR.fn.init.call(connection, url, settings.qs, settings.logging);
3010.         // Object to store hub proxies for this connection
3011.         connection.proxies = {};
3013.         connection._.invocationCallbackId = 0;
3014.         connection._.invocationCallbacks = {};
3016.         // Wire up the received handler
3017.         connection.received(function (minData) {
3018.             var data, proxy, dataCallbackId, callback, hubName, eventName;
3019.             if (!minData) {
3020.                 return;
3021.             }
3023.             // We have to handle progress updates first in order to ensure old clients that receive
3024.             // progress updates enter the return value branch and then no-op when they can't find
3025.             // the callback in the map (because the minData.I value will not be a valid callback ID)
3026.             // Process progress notification
3027.             if (typeof (minData.P) !== "undefined") {
3028.                 dataCallbackId = minData.P.I.toString();
3029.                 callback = connection._.invocationCallbacks[dataCallbackId];
3030.                 if (callback) {
3031.                     callback.method.call(callback.scope, minData);
3032.                 }
3033.             } else if (typeof (minData.I) !== "undefined") {
3034.                 // We received the return value from a server method invocation, look up callback by id and call it
3035.                 dataCallbackId = minData.I.toString();
3036.                 callback = connection._.invocationCallbacks[dataCallbackId];
3037.                 if (callback) {
3038.                     // Delete the callback from the proxy
3039.                     connection._.invocationCallbacks[dataCallbackId] = null;
3040.                     delete connection._.invocationCallbacks[dataCallbackId];
3042.                     // Invoke the callback
3043.                     callback.method.call(callback.scope, minData);
3044.                 }
3045.             } else {
3046.                 data = this._maximizeClientHubInvocation(minData);
3048.                 // We received a client invocation request, i.e. broadcast from server hub
3049.                 connection.log("Triggering client hub event '" + data.Method + "' on hub '" + data.Hub + "'.");
3051.                 // Normalize the names to lowercase
3052.                 hubName = data.Hub.toLowerCase();
3053.                 eventName = data.Method.toLowerCase();
3055.                 // Trigger the local invocation event
3056.                 proxy = this.proxies[hubName];
3058.                 // Update the hub state
3059.                 $.extend(proxy.state, data.State);
3060.                 $(proxy).triggerHandler(makeEventName(eventName), [data.Args]);
3061.             }
3062.         });
3064.         connection.error(function (errData, origData) {
3065.             var callbackId, callback;
3067.             if (!origData) {
3068.                 // No original data passed so this is not a send error
3069.                 return;
3070.             }
3072.             callbackId = origData.I;
3073.             callback = connection._.invocationCallbacks[callbackId];
3075.             // Verify that there is a callback bound (could have been cleared)
3076.             if (callback) {
3077.                 // Delete the callback
3078.                 connection._.invocationCallbacks[callbackId] = null;
3079.                 delete connection._.invocationCallbacks[callbackId];
3081.                 // Invoke the callback with an error to reject the promise
3082.                 callback.method.call(callback.scope, { E: errData });
3083.             }
3084.         });
3086.         connection.reconnecting(function () {
3087.             if (connection.transport && connection.transport.name === "webSockets") {
3088.                 clearInvocationCallbacks(connection, "Connection started reconnecting before invocation result was received.");
3089.             }
3090.         });
3092.         connection.disconnected(function () {
3093.             clearInvocationCallbacks(connection, "Connection was disconnected before invocation result was received.");
3094.         });
3095.     };
3097.     hubConnection.fn._maximizeClientHubInvocation = function (minClientHubInvocation) {
3098.         return {
3099.             Hub: minClientHubInvocation.H,
3100.             Method: minClientHubInvocation.M,
3101.             Args: minClientHubInvocation.A,
3102.             State: minClientHubInvocation.S
3103.         };
3104.     };
3106.     hubConnection.fn._registerSubscribedHubs = function () {
3107.         /// <summary>
3108.         ///     Sets the starting event to loop through the known hubs and register any new hubs
3109.         ///     that have been added to the proxy.
3110.         /// </summary>
3111.         var connection = this;
3113.         if (!connection._subscribedToHubs) {
3114.             connection._subscribedToHubs = true;
3115.             connection.starting(function () {
3116.                 // Set the connection's data object with all the hub proxies with active subscriptions.
3117.                 // These proxies will receive notifications from the server.
3118.                 var subscribedHubs = [];
3120.                 $.each(connection.proxies, function (key) {
3121.                     if (this.hasSubscriptions()) {
3122.                         subscribedHubs.push({ name: key });
3123.                         connection.log("Client subscribed to hub '" + key + "'.");
3124.                     }
3125.                 });
3127.                 if (subscribedHubs.length === 0) {
3128.                     connection.log("No hubs have been subscribed to.  The client will not receive data from hubs.  To fix, declare at least one client side function prior to connection start for each hub you wish to subscribe to.");
3129.                 }
3131.                 connection.data = connection.json.stringify(subscribedHubs);
3132.             });
3133.         }
3134.     };
3136.     hubConnection.fn.createHubProxy = function (hubName) {
3137.         /// <summary>
3138.         ///     Creates a new proxy object for the given hub connection that can be used to invoke
3139.         ///     methods on server hubs and handle client method invocation requests from the server.
3140.         /// </summary>
3141.         /// <param name="hubName" type="String">
3142.         ///     The name of the hub on the server to create the proxy for.
3143.         /// </param>
3145.         // Normalize the name to lowercase
3146.         hubName = hubName.toLowerCase();
3148.         var proxy = this.proxies[hubName];
3149.         if (!proxy) {
3150.             proxy = hubProxy(this, hubName);
3151.             this.proxies[hubName] = proxy;
3152.         }
3154.         this._registerSubscribedHubs();
3156.         return proxy;
3157.     };
3159.     hubConnection.fn.init.prototype = hubConnection.fn;
3161.     $.hubConnection = hubConnection;
3163. }(window.jQuery, window));
3164. /* jquery.signalR.version.js */
3165. // Copyright (c) .NET Foundation. All rights reserved.
3166. // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
3169. /*global window:false */
3170. /// <reference path="jquery.signalR.core.js" />
3171. (function ($, undefined) {
3172.     // This will be modified by the build script
3173.     $.signalR.version = "2.4.3";
3174. }(window.jQuery));

复制代码

（4）效果展示：


三、.NET Core WebAPI使用SignalR

场景：项目中需要服务端主动向客户端发送通知消息，后端是使用.NETCore实现的，前端是使用Vue3全家桶项目，前后端分离模式。本次主要讲使用SignalR如何来实现的。

3.1-服务端（.NET Core WebAPI）

1、右击项目，点击【管理NuGet程序包】安装SignalR。

2、搜索【SignalR】，点击【安装】。


3、如果是.NET6以前的版本，在【Startup.cs】中配置：

如果是.NET6以后得版本，在【Program.cs】配置：

1. /*! jQuery v1.6.4 http://jquery.com/ | http://jquery.org/license */
2. (function(a,b){function cu(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cr(a){if(!cg[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){ch||(ch=c.createElement("iframe"),ch.frameBorder=ch.width=ch.height=0),b.appendChild(ch);if(!ci||!ch.createElement)ci=(ch.contentWindow||ch.contentDocument).document,ci.write((c.compatMode==="CSS1Compat"?"<!doctype html>":"")+"<html><body>"),ci.close();d=ci.createElement(a),ci.body.appendChild(d),e=f.css(d,"display"),b.removeChild(ch)}cg[a]=e}return cg[a]}function cq(a,b){var c={};f.each(cm.concat.apply([],cm.slice(0,b)),function(){c[this]=a});return c}function cp(){cn=b}function co(){setTimeout(cp,0);return cn=f.now()}function cf(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ce(){try{return new a.XMLHttpRequest}catch(b){}}function b$(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g<i;g++){if(g===1)for(h in a.converters)typeof h=="string"&&(e[h.toLowerCase()]=a.converters[h]);l=k,k=d[g];if(k==="*")k=l;else if(l!=="*"&&l!==k){m=l+" "+k,n=e[m]||e["* "+k];if(!n){p=b;for(o in e){j=o.split(" ");if(j[0]===l||j[0]==="*"){p=e[j[1]+" "+k];if(p){o=e[o],o===!0?n=p:p===!0&&(n=o);break}}}}!n&&!p&&f.error("No conversion from "+m.replace(" "," to ")),n!==!0&&(c=n?n(c):p(o(c)))}}return c}function bZ(a,c,d){var e=a.contents,f=a.dataTypes,g=a.responseFields,h,i,j,k;for(i in g)i in d&&(c[g[i]]=d[i]);while(f[0]==="*")f.shift(),h===b&&(h=a.mimeType||c.getResponseHeader("content-type"));if(h)for(i in e)if(e[i]&&e[i].test(h)){f.unshift(i);break}if(f[0]in d)j=f[0];else{for(i in d){if(!f[0]||a.converters[i+" "+f[0]]){j=i;break}k||(k=i)}j=j||k}if(j){j!==f[0]&&f.unshift(j);return d[j]}}function bY(a,b,c,d){if(f.isArray(b))f.each(b,function(b,e){c||bA.test(a)?d(a,e):bY(a+"["+(typeof e=="object"||f.isArray(e)?b:"")+"]",e,c,d)});else if(!c&&b!=null&&typeof b=="object")for(var e in b)bY(a+"["+e+"]",b[e],c,d);else d(a,b)}function bX(a,c){var d,e,g=f.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((g[d]?a:e||(e={}))[d]=c[d]);e&&f.extend(!0,a,e)}function bW(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h=a[f],i=0,j=h?h.length:0,k=a===bP,l;for(;i<j&&(k||!l);i++)l=h[i](c,d,e),typeof l=="string"&&(!k||g[l]?l=b:(c.dataTypes.unshift(l),l=bW(a,c,d,e,l,g)));(k||!l)&&!g["*"]&&(l=bW(a,c,d,e,"*",g));return l}function bV(a){return function(b,c){typeof b!="string"&&(c=b,b="*");if(f.isFunction(c)){var d=b.toLowerCase().split(bL),e=0,g=d.length,h,i,j;for(;e<g;e++)h=d[e],j=/^\+/.test(h),j&&(h=h.substr(1)||"*"),i=a[h]=a[h]||[],i[j?"unshift":"push"](c)}}}function by(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=b==="width"?bt:bu;if(d>0){c!=="border"&&f.each(e,function(){c||(d-=parseFloat(f.css(a,"padding"+this))||0),c==="margin"?d+=parseFloat(f.css(a,c+this))||0:d-=parseFloat(f.css(a,"border"+this+"Width"))||0});return d+"px"}d=bv(a,b,b);if(d<0||d==null)d=a.style[b]||0;d=parseFloat(d)||0,c&&f.each(e,function(){d+=parseFloat(f.css(a,"padding"+this))||0,c!=="padding"&&(d+=parseFloat(f.css(a,"border"+this+"Width"))||0),c==="margin"&&(d+=parseFloat(f.css(a,c+this))||0)});return d+"px"}function bl(a,b){b.src?f.ajax({url:b.src,async:!1,dataType:"script"}):f.globalEval((b.text||b.textContent||b.innerHTML||"").replace(bd,"/*$0*/")),b.parentNode&&b.parentNode.removeChild(b)}function bk(a){f.nodeName(a,"input")?bj(a):"getElementsByTagName"in a&&f.grep(a.getElementsByTagName("input"),bj)}function bj(a){if(a.type==="checkbox"||a.type==="radio")a.defaultChecked=a.checked}function bi(a){return"getElementsByTagName"in a?a.getElementsByTagName("*"):"querySelectorAll"in a?a.querySelectorAll("*"):[]}function bh(a,b){var c;if(b.nodeType===1){b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase();if(c==="object")b.outerHTML=a.outerHTML;else if(c!=="input"||a.type!=="checkbox"&&a.type!=="radio"){if(c==="option")b.selected=a.defaultSelected;else if(c==="input"||c==="textarea")b.defaultValue=a.defaultValue}else a.checked&&(b.defaultChecked=b.checked=a.checked),b.value!==a.value&&(b.value=a.value);b.removeAttribute(f.expando)}}function bg(a,b){if(b.nodeType===1&&!!f.hasData(a)){var c=f.expando,d=f.data(a),e=f.data(b,d);if(d=d[c]){var g=d.events;e=e[c]=f.extend({},d);if(g){delete e.handle,e.events={};for(var h in g)for(var i=0,j=g[h].length;i<j;i++)f.event.add(b,h+(g[h][i].namespace?".":"")+g[h][i].namespace,g[h][i],g[h][i].data)}}}}function bf(a,b){return f.nodeName(a,"table")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function V(a,b,c){b=b||0;if(f.isFunction(b))return f.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return f.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=f.grep(a,function(a){return a.nodeType===1});if(Q.test(b))return f.filter(b,d,!c);b=f.filter(b,d)}return f.grep(a,function(a,d){return f.inArray(a,b)>=0===c})}function U(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function M(a,b){return(a&&a!=="*"?a+".":"")+b.replace(y,"`").replace(z,"&")}function L(a){var b,c,d,e,g,h,i,j,k,l,m,n,o,p=[],q=[],r=f._data(this,"events");if(!(a.liveFired===this||!r||!r.live||a.target.disabled||a.button&&a.type==="click")){a.namespace&&(n=new RegExp("(^|\\.)"+a.namespace.split(".").join("\\.(?:.*\\.)?")+"(\\.|$)")),a.liveFired=this;var s=r.live.slice(0);for(i=0;i<s.length;i++)g=s[i],g.origType.replace(w,"")===a.type?q.push(g.selector):s.splice(i--,1);e=f(a.target).closest(q,a.currentTarget);for(j=0,k=e.length;j<k;j++){m=e[j];for(i=0;i<s.length;i++){g=s[i];if(m.selector===g.selector&&(!n||n.test(g.namespace))&&!m.elem.disabled){h=m.elem,d=null;if(g.preType==="mouseenter"||g.preType==="mouseleave")a.type=g.preType,d=f(a.relatedTarget).closest(g.selector)[0],d&&f.contains(h,d)&&(d=h);(!d||d!==h)&&p.push({elem:h,handleObj:g,level:m.level})}}}for(j=0,k=p.length;j<k;j++){e=p[j];if(c&&e.level>c)break;a.currentTarget=e.elem,a.data=e.handleObj.data,a.handleObj=e.handleObj,o=e.handleObj.origHandler.apply(e.elem,arguments);if(o===!1||a.isPropagationStopped()){c=e.level,o===!1&&(b=!1);if(a.isImmediatePropagationStopped())break}}return b}}function J(a,c,d){var e=f.extend({},d[0]);e.type=a,e.originalEvent={},e.liveFired=b,f.event.handle.call(c,e),e.isDefaultPrevented()&&d[0].preventDefault()}function D(){return!0}function C(){return!1}function m(a,c,d){var e=c+"defer",g=c+"queue",h=c+"mark",i=f.data(a,e,b,!0);i&&(d==="queue"||!f.data(a,g,b,!0))&&(d==="mark"||!f.data(a,h,b,!0))&&setTimeout(function(){!f.data(a,g,b,!0)&&!f.data(a,h,b,!0)&&(f.removeData(a,e,!0),i.resolve())},0)}function l(a){for(var b in a)if(b!=="toJSON")return!1;return!0}function k(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(j,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNaN(d)?i.test(d)?f.parseJSON(d):d:parseFloat(d)}catch(g){}f.data(a,c,d)}else d=b}return d}var c=a.document,d=a.navigator,e=a.location,f=function(){function K(){if(!e.isReady){try{c.documentElement.doScroll("left")}catch(a){setTimeout(K,1);return}e.ready()}}var e=function(a,b){return new e.fn.init(a,b,h)},f=a.jQuery,g=a.$,h,i=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/\d/,n=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,o=/^[\],:{}\s]*$/,p=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,q=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,r=/(?:^|:|,)(?:\s*\[)+/g,s=/(webkit)[ \/]([\w.]+)/,t=/(opera)(?:.*version)?[ \/]([\w.]+)/,u=/(msie) ([\w.]+)/,v=/(mozilla)(?:.*? rv:([\w.]+))?/,w=/-([a-z]|[0-9])/ig,x=/^-ms-/,y=function(a,b){return(b+"").toUpperCase()},z=d.userAgent,A,B,C,D=Object.prototype.toString,E=Object.prototype.hasOwnProperty,F=Array.prototype.push,G=Array.prototype.slice,H=String.prototype.trim,I=Array.prototype.indexOf,J={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=n.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.6.4",length:0,size:function(){return this.length},toArray:function(){return G.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?F.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),B.done(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(G.apply(this,arguments),"slice",G.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:F,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j<k;j++)if((a=arguments[j])!=null)for(c in a){d=i[c],f=a[c];if(i===f)continue;l&&f&&(e.isPlainObject(f)||(g=e.isArray(f)))?(g?(g=!1,h=d&&e.isArray(d)?d:[]):h=d&&e.isPlainObject(d)?d:{},i[c]=e.extend(l,h,f)):f!==b&&(i[c]=f)}return i},e.extend({noConflict:function(b){a.$===e&&(a.$=g),b&&a.jQuery===e&&(a.jQuery=f);return e},isReady:!1,readyWait:1,holdReady:function(a){a?e.readyWait++:e.ready(!0)},ready:function(a){if(a===!0&&!--e.readyWait||a!==!0&&!e.isReady){if(!c.body)return setTimeout(e.ready,1);e.isReady=!0;if(a!==!0&&--e.readyWait>0)return;B.resolveWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").unbind("ready")}},bindReady:function(){if(!B){B=e._Deferred();if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",C,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",C),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&K()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a&&typeof a=="object"&&"setInterval"in a},isNaN:function(a){return a==null||!m.test(a)||isNaN(a)},type:function(a){return a==null?String(a):J[D.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!E.call(a,"constructor")&&!E.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||E.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw a},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(o.test(b.replace(p,"@").replace(q,"]").replace(r,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(x,"ms-").replace(w,y)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g<h;)if(c.apply(a[g++],d)===!1)break}else if(i){for(f in a)if(c.call(a[f],f,a[f])===!1)break}else for(;g<h;)if(c.call(a[g],g,a[g++])===!1)break;return a},trim:H?function(a){return a==null?"":H.call(a)}:function(a){return a==null?"":(a+"").replace(k,"").replace(l,"")},makeArray:function(a,b){var c=b||[];if(a!=null){var d=e.type(a);a.length==null||d==="string"||d==="function"||d==="regexp"||e.isWindow(a)?F.call(c,a):e.merge(c,a)}return c},inArray:function(a,b){if(!b)return-1;if(I)return I.call(b,a);for(var c=0,d=b.length;c<d;c++)if(b[c]===a)return c;return-1},merge:function(a,c){var d=a.length,e=0;if(typeof c.length=="number")for(var f=c.length;e<f;e++)a[d++]=c[e];else while(c[e]!==b)a[d++]=c[e++];a.length=d;return a},grep:function(a,b,c){var d=[],e;c=!!c;for(var f=0,g=a.length;f<g;f++)e=!!b(a[f],f),c!==e&&d.push(a[f]);return d},map:function(a,c,d){var f,g,h=[],i=0,j=a.length,k=a instanceof e||j!==b&&typeof j=="number"&&(j>0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i<j;i++)f=c(a[i],i,d),f!=null&&(h[h.length]=f);else for(g in a)f=c(a[g],g,d),f!=null&&(h[h.length]=f);return h.concat.apply([],h)},guid:1,proxy:function(a,c){if(typeof c=="string"){var d=a[c];c=a,a=d}if(!e.isFunction(a))return b;var f=G.call(arguments,2),g=function(){return a.apply(c,f.concat(G.call(arguments)))};g.guid=a.guid=a.guid||g.guid||e.guid++;return g},access:function(a,c,d,f,g,h){var i=a.length;if(typeof c=="object"){for(var j in c)e.access(a,j,c[j],f,g,d);return a}if(d!==b){f=!h&&f&&e.isFunction(d);for(var k=0;k<i;k++)g(a[k],c,f?d.call(a[k],k,g(a[k],c)):d,h);return a}return i?g(a[0],c):b},now:function(){return(new Date).getTime()},uaMatch:function(a){a=a.toLowerCase();var b=s.exec(a)||t.exec(a)||u.exec(a)||a.indexOf("compatible")<0&&v.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},sub:function(){function a(b,c){return new a.fn.init(b,c)}e.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function(d,f){f&&f instanceof e&&!(f instanceof a)&&(f=a(f));return e.fn.init.call(this,d,f,b)},a.fn.init.prototype=a.fn;var b=a(c);return a},browser:{}}),e.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){J["[object "+b+"]"]=b.toLowerCase()}),A=e.uaMatch(z),A.browser&&(e.browser[A.browser]=!0,e.browser.version=A.version),e.browser.webkit&&(e.browser.safari=!0),j.test(" ")&&(k=/^[\s\xA0]+/,l=/[\s\xA0]+$/),h=e(c),c.addEventListener?C=function(){c.removeEventListener("DOMContentLoaded",C,!1),e.ready()}:c.attachEvent&&(C=function(){c.readyState==="complete"&&(c.detachEvent("onreadystatechange",C),e.ready())});return e}(),g="done fail isResolved isRejected promise then always pipe".split(" "),h=[].slice;f.extend({_Deferred:function(){var a=[],b,c,d,e={done:function(){if(!d){var c=arguments,g,h,i,j,k;b&&(k=b,b=0);for(g=0,h=c.length;g<h;g++)i=c[g],j=f.type(i),j==="array"?e.done.apply(e,i):j==="function"&&a.push(i);k&&e.resolveWith(k[0],k[1])}return this},resolveWith:function(e,f){if(!d&&!b&&!c){f=f||[],c=1;try{while(a[0])a.shift().apply(e,f)}finally{b=[e,f],c=0}}return this},resolve:function(){e.resolveWith(this,arguments);return this},isResolved:function(){return!!c||!!b},cancel:function(){d=1,a=[];return this}};return e},Deferred:function(a){var b=f._Deferred(),c=f._Deferred(),d;f.extend(b,{then:function(a,c){b.done(a).fail(c);return this},always:function(){return b.done.apply(b,arguments).fail.apply(this,arguments)},fail:c.done,rejectWith:c.resolveWith,reject:c.resolve,isRejected:c.isResolved,pipe:function(a,c){return f.Deferred(function(d){f.each({done:[a,"resolve"],fail:[c,"reject"]},function(a,c){var e=c[0],g=c[1],h;f.isFunction(e)?b[a](function(){h=e.apply(this,arguments),h&&f.isFunction(h.promise)?h.promise().then(d.resolve,d.reject):d[g+"With"](this===b?d:this,[h])}):b[a](d[g])})}).promise()},promise:function(a){if(a==null){if(d)return d;d=a={}}var c=g.length;while(c--)a[g[c]]=b[g[c]];return a}}),b.done(c.cancel).fail(b.cancel),delete b.cancel,a&&a.call(b,b);return b},when:function(a){function i(a){return function(c){b[a]=arguments.length>1?h.call(arguments,0):c,--e||g.resolveWith(g,h.call(b,0))}}var b=arguments,c=0,d=b.length,e=d,g=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred();if(d>1){for(;c<d;c++)b[c]&&f.isFunction(b[c].promise)?b[c].promise().then(i(c),g.reject):--e;e||g.resolveWith(g,b)}else g!==a&&g.resolveWith(g,d?[a]:[]);return g.promise()}}),f.support=function(){var a=c.createElement("div"),b=c.documentElement,d,e,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;a.setAttribute("className","t"),a.innerHTML="   <link/><table></table><a target="_blank" href='https://www.cnblogs.com/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>",d=a.getElementsByTagName("*"),e=a.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=a.getElementsByTagName("input")[0],k={leadingWhitespace:a.firstChild.nodeType===3,tbody:!a.getElementsByTagName("tbody").length,htmlSerialize:!!a.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55$/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:a.className!=="t",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0},i.checked=!0,k.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,k.optDisabled=!h.disabled;try{delete a.test}catch(v){k.deleteExpando=!1}!a.addEventListener&&a.attachEvent&&a.fireEvent&&(a.attachEvent("onclick",function(){k.noCloneEvent=!1}),a.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),k.radioValue=i.value==="t",i.setAttribute("checked","checked"),a.appendChild(i),l=c.createDocumentFragment(),l.appendChild(a.firstChild),k.checkClone=l.cloneNode(!0).cloneNode(!0).lastChild.checked,a.innerHTML="",a.style.width=a.style.paddingLeft="1px",m=c.getElementsByTagName("body")[0],o=c.createElement(m?"div":"body"),p={visibility:"hidden",width:0,height:0,border:0,margin:0,background:"none"},m&&f.extend(p,{position:"absolute",left:"-1000px",top:"-1000px"});for(t in p)o.style[t]=p[t];o.appendChild(a),n=m||b,n.insertBefore(o,n.firstChild),k.appendChecked=i.checked,k.boxModel=a.offsetWidth===2,"zoom"in a.style&&(a.style.display="inline",a.style.zoom=1,k.inlineBlockNeedsLayout=a.offsetWidth===2,a.style.display="",a.innerHTML="",k.shrinkWrapBlocks=a.offsetWidth!==2),a.innerHTML="<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>",q=a.getElementsByTagName("td"),u=q[0].offsetHeight===0,q[0].style.display="",q[1].style.display="none",k.reliableHiddenOffsets=u&&q[0].offsetHeight===0,a.innerHTML="",c.defaultView&&c.defaultView.getComputedStyle&&(j=c.createElement("div"),j.style.width="0",j.style.marginRight="0",a.appendChild(j),k.reliableMarginRight=(parseInt((c.defaultView.getComputedStyle(j,null)||{marginRight:0}).marginRight,10)||0)===0),o.innerHTML="",n.removeChild(o);if(a.attachEvent)for(t in{submit:1,change:1,focusin:1})s="on"+t,u=s in a,u||(a.setAttribute(s,"return;"),u=typeof a[s]=="function"),k[t+"Bubbles"]=u;o=l=g=h=m=j=a=i=null;return k}(),f.boxModel=f.support.boxModel;var i=/^(?:\{.*\}|\[.*\])$/,j=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!l(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i=f.expando,j=typeof c=="string",k=a.nodeType,l=k?f.cache:a,m=k?a[f.expando]:a[f.expando]&&f.expando;if((!m||e&&m&&l[m]&&!l[m][i])&&j&&d===b)return;m||(k?a[f.expando]=m=++f.uuid:m=f.expando),l[m]||(l[m]={},k||(l[m].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?l[m][i]=f.extend(l[m][i],c):l[m]=f.extend(l[m],c);g=l[m],e&&(g[i]||(g[i]={}),g=g[i]),d!==b&&(g[f.camelCase(c)]=d);if(c==="events"&&!g[c])return g[i]&&g[i].events;j?(h=g[c],h==null&&(h=g[f.camelCase(c)])):h=g;return h}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e=f.expando,g=a.nodeType,h=g?f.cache:a,i=g?a[f.expando]:f.expando;if(!h[i])return;if(b){d=c?h[i][e]:h[i];if(d){d[b]||(b=f.camelCase(b)),delete d[b];if(!l(d))return}}if(c){delete h[i][e];if(!l(h[i]))return}var j=h[i][e];f.support.deleteExpando||!h.setInterval?delete h[i]:h[i]=null,j?(h[i]={},g||(h[i].toJSON=f.noop),h[i][e]=j):g&&(f.support.deleteExpando?delete a[f.expando]:a.removeAttribute?a.removeAttribute(f.expando):a[f.expando]=null)}},_data:function(a,b,c){return f.data(a,b,c,!0)},acceptData:function(a){if(a.nodeName){var b=f.noData[a.nodeName.toLowerCase()];if(b)return b!==!0&&a.getAttribute("classid")===b}return!0}}),f.fn.extend({data:function(a,c){var d=null;if(typeof a=="undefined"){if(this.length){d=f.data(this[0]);if(this[0].nodeType===1){var e=this[0].attributes,g;for(var h=0,i=e.length;h<i;h++)g=e[h].name,g.indexOf("data-")===0&&(g=f.camelCase(g.substring(5)),k(this[0],g,d[g]))}}return d}if(typeof a=="object")return this.each(function(){f.data(this,a)});var j=a.split(".");j[1]=j[1]?"."+j[1]:"";if(c===b){d=this.triggerHandler("getData"+j[1]+"!",[j[0]]),d===b&&this.length&&(d=f.data(this[0],a),d=k(this[0],a,d));return d===b&&j[1]?this.data(j[0]):d}return this.each(function(){var b=f(this),d=[j[0],c];b.triggerHandler("setData"+j[1]+"!",d),f.data(this,a,c),b.triggerHandler("changeData"+j[1]+"!",d)})},removeData:function(a){return this.each(function(){f.removeData(this,a)})}}),f.extend({_mark:function(a,c){a&&(c=(c||"fx")+"mark",f.data(a,c,(f.data(a,c,b,!0)||0)+1,!0))},_unmark:function(a,c,d){a!==!0&&(d=c,c=a,a=!1);if(c){d=d||"fx";var e=d+"mark",g=a?0:(f.data(c,e,b,!0)||1)-1;g?f.data(c,e,g,!0):(f.removeData(c,e,!0),m(c,d,"mark"))}},queue:function(a,c,d){if(a){c=(c||"fx")+"queue";var e=f.data(a,c,b,!0);d&&(!e||f.isArray(d)?e=f.data(a,c,f.makeArray(d),!0):e.push(d));return e||[]}},dequeue:function(a,b){b=b||"fx";var c=f.queue(a,b),d=c.shift(),e;d==="inprogress"&&(d=c.shift()),d&&(b==="fx"&&c.unshift("inprogress"),d.call(a,function(){f.dequeue(a,b)})),c.length||(f.removeData(a,b+"queue",!0),m(a,b,"queue"))}}),f.fn.extend({queue:function(a,c){typeof a!="string"&&(c=a,a="fx");if(c===b)return f.queue(this[0],a);return this.each(function(){var b=f.queue(this,a,c);a==="fx"&&b[0]!=="inprogress"&&f.dequeue(this,a)})},dequeue:function(a){return this.each(function(){f.dequeue(this,a)})},delay:function(a,b){a=f.fx?f.fx.speeds[a]||a:a,b=b||"fx";return this.queue(b,function(){var c=this;setTimeout(function(){f.dequeue(c,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){function m(){--h||d.resolveWith(e,[e])}typeof a!="string"&&(c=a,a=b),a=a||"fx";var d=f.Deferred(),e=this,g=e.length,h=1,i=a+"defer",j=a+"queue",k=a+"mark",l;while(g--)if(l=f.data(e[g],i,b,!0)||(f.data(e[g],j,b,!0)||f.data(e[g],k,b,!0))&&f.data(e[g],i,f._Deferred(),!0))h++,l.done(m);m();return d.promise()}});var n=/[\n\t\r]/g,o=/\s+/,p=/\r/g,q=/^(?:button|input)$/i,r=/^(?:button|input|object|select|textarea)$/i,s=/^a(?:rea)?$/i,t=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,u,v;f.fn.extend({attr:function(a,b){return f.access(this,a,b,!0,f.attr)},removeAttr:function(a){return this.each(function(){f.removeAttr(this,a)})},prop:function(a,b){return f.access(this,a,b,!0,f.prop)},removeProp:function(a){a=f.propFix[a]||a;return this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,g,h,i;if(f.isFunction(a))return this.each(function(b){f(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(o);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{g=" "+e.className+" ";for(h=0,i=b.length;h<i;h++)~g.indexOf(" "+b[h]+" ")||(g+=b[h]+" ");e.className=f.trim(g)}}}return this},removeClass:function(a){var c,d,e,g,h,i,j;if(f.isFunction(a))return this.each(function(b){f(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(o);for(d=0,e=this.length;d<e;d++){g=this[d];if(g.nodeType===1&&g.className)if(a){h=(" "+g.className+" ").replace(n," ");for(i=0,j=c.length;i<j;i++)h=h.replace(" "+c[i]+" "," ");g.className=f.trim(h)}else g.className=""}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";if(f.isFunction(a))return this.each(function(c){f(this).toggleClass(a.call(this,c,this.className,b),b)});return this.each(function(){if(c==="string"){var e,g=0,h=f(this),i=b,j=a.split(o);while(e=j[g++])i=d?i:!h.hasClass(e),h[i?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&f._data(this,"__className__",this.className),this.className=this.className||a===!1?"":f._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ";for(var c=0,d=this.length;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(n," ").indexOf(b)>-1)return!0;return!1},val:function(a){var c,d,e=this[0];if(!arguments.length){if(e){c=f.valHooks[e.nodeName.toLowerCase()]||f.valHooks[e.type];if(c&&"get"in c&&(d=c.get(e,"value"))!==b)return d;d=e.value;return typeof d=="string"?d.replace(p,""):d==null?"":d}return b}var g=f.isFunction(a);return this.each(function(d){var e=f(this),h;if(this.nodeType===1){g?h=a.call(this,d,e.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.nodeName.toLowerCase()]||f.valHooks[this.type];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c=a.selectedIndex,d=[],e=a.options,g=a.type==="select-one";if(c<0)return null;for(var h=g?c:0,i=g?c+1:e.length;h<i;h++){var j=e[h];if(j.selected&&(f.support.optDisabled?!j.disabled:j.getAttribute("disabled")===null)&&(!j.parentNode.disabled||!f.nodeName(j.parentNode,"optgroup"))){b=f(j).val();if(g)return b;d.push(b)}}if(g&&!d.length&&e.length)return f(e[c]).val();return d},set:function(a,b){var c=f.makeArray(b);f(a).find("option").each(function(){this.selected=f.inArray(f(this).val(),c)>=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attrFix:{tabindex:"tabIndex"},attr:function(a,c,d,e){var g=a.nodeType;if(!a||g===3||g===8||g===2)return b;if(e&&c in f.attrFn)return f(a)[c](d);if(!("getAttribute"in a))return f.prop(a,c,d);var h,i,j=g!==1||!f.isXMLDoc(a);j&&(c=f.attrFix[c]||c,i=f.attrHooks[c],i||(t.test(c)?i=v:u&&(i=u)));if(d!==b){if(d===null){f.removeAttr(a,c);return b}if(i&&"set"in i&&j&&(h=i.set(a,d,c))!==b)return h;a.setAttribute(c,""+d);return d}if(i&&"get"in i&&j&&(h=i.get(a,c))!==null)return h;h=a.getAttribute(c);return h===null?b:h},removeAttr:function(a,b){var c;a.nodeType===1&&(b=f.attrFix[b]||b,f.attr(a,b,""),a.removeAttribute(b),t.test(b)&&(c=f.propFix[b]||b)in a&&(a[c]=!1))},attrHooks:{type:{set:function(a,b){if(q.test(a.nodeName)&&a.parentNode)f.error("type property can't be changed");else if(!f.support.radioValue&&b==="radio"&&f.nodeName(a,"input")){var c=a.value;a.setAttribute("type",b),c&&(a.value=c);return b}}},value:{get:function(a,b){if(u&&f.nodeName(a,"button"))return u.get(a,b);return b in a?a.value:null},set:function(a,b,c){if(u&&f.nodeName(a,"button"))return u.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e=a.nodeType;if(!a||e===3||e===8||e===2)return b;var g,h,i=e!==1||!f.isXMLDoc(a);i&&(c=f.propFix[c]||c,h=f.propHooks[c]);return d!==b?h&&"set"in h&&(g=h.set(a,d,c))!==b?g:a[c]=d:h&&"get"in h&&(g=h.get(a,c))!==null?g:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):r.test(a.nodeName)||s.test(a.nodeName)&&a.href?0:b}}}}),f.attrHooks.tabIndex=f.propHooks.tabIndex,v={get:function(a,c){var d;return f.prop(a,c)===!0||(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;b===!1?f.removeAttr(a,c):(d=f.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase()));return c}},f.support.getSetAttribute||(u=f.valHooks.button={get:function(a,c){var d;d=a.getAttributeNode(c);return d&&d.nodeValue!==""?d.nodeValue:b},set:function(a,b,d){var e=a.getAttributeNode(d);e||(e=c.createAttribute(d),a.setAttributeNode(e));return e.nodeValue=b+""}},f.each(["width","height"],function(a,b){f.attrHooks[b]=f.extend(f.attrHooks[b],{set:function(a,c){if(c===""){a.setAttribute(b,"auto");return c}}})})),f.support.hrefNormalized||f.each(["href","src","width","height"],function(a,c){f.attrHooks[c]=f.extend(f.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),f.support.style||(f.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=""+b}}),f.support.optSelected||(f.propHooks.selected=f.extend(f.propHooks.selected,{get:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex);return null}})),f.support.checkOn||f.each(["radio","checkbox"],function(){f.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),f.each(["radio","checkbox"],function(){f.valHooks[this]=f.extend(f.valHooks[this],{set:function(a,b){if(f.isArray(b))return a.checked=f.inArray(f(a).val(),b)>=0}})});var w=/\.(.*)$/,x=/^(?:textarea|input|select)$/i,y=/\./g,z=/ /g,A=/[^\w\s.|`]/g,B=function(a){return a.replace(A,"\\$&")};f.event={add:function(a,c,d,e){if(a.nodeType!==3&&a.nodeType!==8){if(d===!1)d=C;else if(!d)return;var g,h;d.handler&&(g=d,d=g.handler),d.guid||(d.guid=f.guid++);var i=f._data(a);if(!i)return;var j=i.events,k=i.handle;j||(i.events=j={}),k||(i.handle=k=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.handle.apply(k.elem,arguments):b}),k.elem=a,c=c.split(" ");var l,m=0,n;while(l=c[m++]){h=g?f.extend({},g):{handler:d,data:e},l.indexOf(".")>-1?(n=l.split("."),l=n.shift(),h.namespace=n.slice(0).sort().join(".")):(n=[],h.namespace=""),h.type=l,h.guid||(h.guid=d.guid);var o=j[l],p=f.event.special[l]||{};if(!o){o=j[l]=[];if(!p.setup||p.setup.call(a,e,n,k)===!1)a.addEventListener?a.addEventListener(l,k,!1):a.attachEvent&&a.attachEvent("on"+l,k)}p.add&&(p.add.call(a,h),h.handler.guid||(h.handler.guid=d.guid)),o.push(h),f.event.global[l]=!0}a=null}},global:{},remove:function(a,c,d,e){if(a.nodeType!==3&&a.nodeType!==8){d===!1&&(d=C);var g,h,i,j,k=0,l,m,n,o,p,q,r,s=f.hasData(a)&&f._data(a),t=s&&s.events;if(!s||!t)return;c&&c.type&&(d=c.handler,c=c.type);if(!c||typeof c=="string"&&c.charAt(0)==="."){c=c||"";for(h in t)f.event.remove(a,h+c);return}c=c.split(" ");while(h=c[k++]){r=h,q=null,l=h.indexOf(".")<0,m=[],l||(m=h.split("."),h=m.shift(),n=new RegExp("(^|\\.)"+f.map(m.slice(0).sort(),B).join("\\.(?:.*\\.)?")+"(\\.|$)")),p=t[h];if(!p)continue;if(!d){for(j=0;j<p.length;j++){q=p[j];if(l||n.test(q.namespace))f.event.remove(a,r,q.handler,j),p.splice(j--,1)}continue}o=f.event.special[h]||{};for(j=e||0;j<p.length;j++){q=p[j];if(d.guid===q.guid){if(l||n.test(q.namespace))e==null&&p.splice(j--,1),o.remove&&o.remove.call(a,q);if(e!=null)break}}if(p.length===0||e!=null&&p.length===1)(!o.teardown||o.teardown.call(a,m)===!1)&&f.removeEvent(a,h,s.handle),g=null,delete
3. t[h]}if(f.isEmptyObject(t)){var u=s.handle;u&&(u.elem=null),delete s.events,delete s.handle,f.isEmptyObject(s)&&f.removeData(a,b,!0)}}},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,e,g){var h=c.type||c,i=[],j;h.indexOf("!")>=0&&(h=h.slice(0,-1),j=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if(!!e&&!f.event.customEvent[h]||!!f.event.global[h]){c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.exclusive=j,c.namespace=i.join("."),c.namespace_re=new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)");if(g||!e)c.preventDefault(),c.stopPropagation();if(!e){f.each(f.cache,function(){var a=f.expando,b=this[a];b&&b.events&&b.events[h]&&f.event.trigger(c,d,b.handle.elem)});return}if(e.nodeType===3||e.nodeType===8)return;c.result=b,c.target=e,d=d!=null?f.makeArray(d):[],d.unshift(c);var k=e,l=h.indexOf(":")<0?"on"+h:"";do{var m=f._data(k,"handle");c.currentTarget=k,m&&m.apply(k,d),l&&f.acceptData(k)&&k[l]&&k[l].apply(k,d)===!1&&(c.result=!1,c.preventDefault()),k=k.parentNode||k.ownerDocument||k===c.target.ownerDocument&&a}while(k&&!c.isPropagationStopped());if(!c.isDefaultPrevented()){var n,o=f.event.special[h]||{};if((!o._default||o._default.call(e.ownerDocument,c)===!1)&&(h!=="click"||!f.nodeName(e,"a"))&&f.acceptData(e)){try{l&&e[h]&&(n=e[l],n&&(e[l]=null),f.event.triggered=h,e[h]())}catch(p){}n&&(e[l]=n),f.event.triggered=b}}return c.result}},handle:function(c){c=f.event.fix(c||a.event);var d=((f._data(this,"events")||{})[c.type]||[]).slice(0),e=!c.exclusive&&!c.namespace,g=Array.prototype.slice.call(arguments,0);g[0]=c,c.currentTarget=this;for(var h=0,i=d.length;h<i;h++){var j=d[h];if(e||c.namespace_re.test(j.namespace)){c.handler=j.handler,c.data=j.data,c.handleObj=j;var k=j.handler.apply(this,g);k!==b&&(c.result=k,k===!1&&(c.preventDefault(),c.stopPropagation()));if(c.isImmediatePropagationStopped())break}}return c.result},props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),fix:function(a){if(a[f.expando])return a;var d=a;a=f.Event(d);for(var e=this.props.length,g;e;)g=this.props[--e],a[g]=d[g];a.target||(a.target=a.srcElement||c),a.target.nodeType===3&&(a.target=a.target.parentNode),!a.relatedTarget&&a.fromElement&&(a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement);if(a.pageX==null&&a.clientX!=null){var h=a.target.ownerDocument||c,i=h.documentElement,j=h.body;a.pageX=a.clientX+(i&&i.scrollLeft||j&&j.scrollLeft||0)-(i&&i.clientLeft||j&&j.clientLeft||0),a.pageY=a.clientY+(i&&i.scrollTop||j&&j.scrollTop||0)-(i&&i.clientTop||j&&j.clientTop||0)}a.which==null&&(a.charCode!=null||a.keyCode!=null)&&(a.which=a.charCode!=null?a.charCode:a.keyCode),!a.metaKey&&a.ctrlKey&&(a.metaKey=a.ctrlKey),!a.which&&a.button!==b&&(a.which=a.button&1?1:a.button&2?3:a.button&4?2:0);return a},guid:1e8,proxy:f.proxy,special:{ready:{setup:f.bindReady,teardown:f.noop},live:{add:function(a){f.event.add(this,M(a.origType,a.selector),f.extend({},a,{handler:L,guid:a.handler.guid}))},remove:function(a){f.event.remove(this,M(a.origType,a.selector),a)}},beforeunload:{setup:function(a,b,c){f.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}}},f.removeEvent=c.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){a.detachEvent&&a.detachEvent("on"+b,c)},f.Event=function(a,b){if(!this.preventDefault)return new f.Event(a,b);a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?D:C):this.type=a,b&&f.extend(this,b),this.timeStamp=f.now(),this[f.expando]=!0},f.Event.prototype={preventDefault:function(){this.isDefaultPrevented=D;var a=this.originalEvent;!a||(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){this.isPropagationStopped=D;var a=this.originalEvent;!a||(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=D,this.stopPropagation()},isDefaultPrevented:C,isPropagationStopped:C,isImmediatePropagationStopped:C};var E=function(a){var b=a.relatedTarget,c=!1,d=a.type;a.type=a.data,b!==this&&(b&&(c=f.contains(this,b)),c||(f.event.handle.apply(this,arguments),a.type=d))},F=function(a){a.type=a.data,f.event.handle.apply(this,arguments)};f.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){f.event.special[a]={setup:function(c){f.event.add(this,b,c&&c.selector?F:E,a)},teardown:function(a){f.event.remove(this,b,a&&a.selector?F:E)}}}),f.support.submitBubbles||(f.event.special.submit={setup:function(a,b){if(!f.nodeName(this,"form"))f.event.add(this,"click.specialSubmit",function(a){var b=a.target,c=f.nodeName(b,"input")||f.nodeName(b,"button")?b.type:"";(c==="submit"||c==="image")&&f(b).closest("form").length&&J("submit",this,arguments)}),f.event.add(this,"keypress.specialSubmit",function(a){var b=a.target,c=f.nodeName(b,"input")||f.nodeName(b,"button")?b.type:"";(c==="text"||c==="password")&&f(b).closest("form").length&&a.keyCode===13&&J("submit",this,arguments)});else return!1},teardown:function(a){f.event.remove(this,".specialSubmit")}});if(!f.support.changeBubbles){var G,H=function(a){var b=f.nodeName(a,"input")?a.type:"",c=a.value;b==="radio"||b==="checkbox"?c=a.checked:b==="select-multiple"?c=a.selectedIndex>-1?f.map(a.options,function(a){return a.selected}).join("-"):"":f.nodeName(a,"select")&&(c=a.selectedIndex);return c},I=function(c){var d=c.target,e,g;if(!!x.test(d.nodeName)&&!d.readOnly){e=f._data(d,"_change_data"),g=H(d),(c.type!=="focusout"||d.type!=="radio")&&f._data(d,"_change_data",g);if(e===b||g===e)return;if(e!=null||g)c.type="change",c.liveFired=b,f.event.trigger(c,arguments[1],d)}};f.event.special.change={filters:{focusout:I,beforedeactivate:I,click:function(a){var b=a.target,c=f.nodeName(b,"input")?b.type:"";(c==="radio"||c==="checkbox"||f.nodeName(b,"select"))&&I.call(this,a)},keydown:function(a){var b=a.target,c=f.nodeName(b,"input")?b.type:"";(a.keyCode===13&&!f.nodeName(b,"textarea")||a.keyCode===32&&(c==="checkbox"||c==="radio")||c==="select-multiple")&&I.call(this,a)},beforeactivate:function(a){var b=a.target;f._data(b,"_change_data",H(b))}},setup:function(a,b){if(this.type==="file")return!1;for(var c in G)f.event.add(this,c+".specialChange",G[c]);return x.test(this.nodeName)},teardown:function(a){f.event.remove(this,".specialChange");return x.test(this.nodeName)}},G=f.event.special.change.filters,G.focus=G.beforeactivate}f.support.focusinBubbles||f.each({focus:"focusin",blur:"focusout"},function(a,b){function e(a){var c=f.event.fix(a);c.type=b,c.originalEvent={},f.event.trigger(c,null,c.target),c.isDefaultPrevented()&&a.preventDefault()}var d=0;f.event.special[b]={setup:function(){d++===0&&c.addEventListener(a,e,!0)},teardown:function(){--d===0&&c.removeEventListener(a,e,!0)}}}),f.each(["bind","one"],function(a,c){f.fn[c]=function(a,d,e){var g;if(typeof a=="object"){for(var h in a)this[c](h,d,a[h],e);return this}if(arguments.length===2||d===!1)e=d,d=b;c==="one"?(g=function(a){f(this).unbind(a,g);return e.apply(this,arguments)},g.guid=e.guid||f.guid++):g=e;if(a==="unload"&&c!=="one")this.one(a,d,e);else for(var i=0,j=this.length;i<j;i++)f.event.add(this[i],a,g,d);return this}}),f.fn.extend({unbind:function(a,b){if(typeof a=="object"&&!a.preventDefault)for(var c in a)this.unbind(c,a[c]);else for(var d=0,e=this.length;d<e;d++)f.event.remove(this[d],a,b);return this},delegate:function(a,b,c,d){return this.live(b,c,d,a)},undelegate:function(a,b,c){return arguments.length===0?this.unbind("live"):this.die(b,null,c,a)},trigger:function(a,b){return this.each(function(){f.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return f.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||f.guid++,d=0,e=function(c){var e=(f.data(this,"lastToggle"+a.guid)||0)%d;f.data(this,"lastToggle"+a.guid,e+1),c.preventDefault();return b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var K={focus:"focusin",blur:"focusout",mouseenter:"mouseover",mouseleave:"mouseout"};f.each(["live","die"],function(a,c){f.fn[c]=function(a,d,e,g){var h,i=0,j,k,l,m=g||this.selector,n=g?this:f(this.context);if(typeof a=="object"&&!a.preventDefault){for(var o in a)n[c](o,d,a[o],m);return this}if(c==="die"&&!a&&g&&g.charAt(0)==="."){n.unbind(g);return this}if(d===!1||f.isFunction(d))e=d||C,d=b;a=(a||"").split(" ");while((h=a[i++])!=null){j=w.exec(h),k="",j&&(k=j[0],h=h.replace(w,""));if(h==="hover"){a.push("mouseenter"+k,"mouseleave"+k);continue}l=h,K[h]?(a.push(K[h]+k),h=h+k):h=(K[h]||h)+k;if(c==="live")for(var p=0,q=n.length;p<q;p++)f.event.add(n[p],"live."+M(h,m),{data:d,selector:m,handler:e,origType:h,origHandler:e,preType:l});else n.unbind("live."+M(h,m),e)}return this}}),f.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),function(a,b){f.fn[b]=function(a,c){c==null&&(c=a,a=null);return arguments.length>0?this.bind(b,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0)}),function(){function u(a,b,c,d,e,f){for(var g=0,h=d.length;g<h;g++){var i=d[g];if(i){var j=!1;i=i[a];while(i){if(i.sizcache===c){j=d[i.sizset];break}if(i.nodeType===1){f||(i.sizcache=c,i.sizset=g);if(typeof b!="string"){if(i===b){j=!0;break}}else if(k.filter(b,[i]).length>0){j=i;break}}i=i[a]}d[g]=j}}}function t(a,b,c,d,e,f){for(var g=0,h=d.length;g<h;g++){var i=d[g];if(i){var j=!1;i=i[a];while(i){if(i.sizcache===c){j=d[i.sizset];break}i.nodeType===1&&!f&&(i.sizcache=c,i.sizset=g);if(i.nodeName.toLowerCase()===b){j=i;break}i=i[a]}d[g]=j}}}var a=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d=0,e=Object.prototype.toString,g=!1,h=!0,i=/\\/g,j=/\W/;[0,0].sort(function(){h=!1;return 0});var k=function(b,d,f,g){f=f||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return f;var i,j,n,o,q,r,s,t,u=!0,w=k.isXML(d),x=[],y=b;do{a.exec(""),i=a.exec(y);if(i){y=i[3],x.push(i[1]);if(i[2]){o=i[3];break}}}while(i);if(x.length>1&&m.exec(b))if(x.length===2&&l.relative[x[0]])j=v(x[0]+x[1],d);else{j=l.relative[x[0]]?[d]:k(x.shift(),d);while(x.length)b=x.shift(),l.relative[b]&&(b+=x.shift()),j=v(b,j)}else{!g&&x.length>1&&d.nodeType===9&&!w&&l.match.ID.test(x[0])&&!l.match.ID.test(x[x.length-1])&&(q=k.find(x.shift(),d,w),d=q.expr?k.filter(q.expr,q.set)[0]:q.set[0]);if(d){q=g?{expr:x.pop(),set:p(g)}:k.find(x.pop(),x.length===1&&(x[0]==="~"||x[0]==="+")&&d.parentNode?d.parentNode:d,w),j=q.expr?k.filter(q.expr,q.set):q.set,x.length>0?n=p(j):u=!1;while(x.length)r=x.pop(),s=r,l.relative[r]?s=x.pop():r="",s==null&&(s=d),l.relative[r](n,s,w)}else n=x=[]}n||(n=j),n||k.error(r||b);if(e.call(n)==="[object Array]")if(!u)f.push.apply(f,n);else if(d&&d.nodeType===1)for(t=0;n[t]!=null;t++)n[t]&&(n[t]===!0||n[t].nodeType===1&&k.contains(d,n[t]))&&f.push(j[t]);else for(t=0;n[t]!=null;t++)n[t]&&n[t].nodeType===1&&f.push(j[t]);else p(n,f);o&&(k(o,h,f,g),k.uniqueSort(f));return f};k.uniqueSort=function(a){if(r){g=h,a.sort(r);if(g)for(var b=1;b<a.length;b++)a[b]===a[b-1]&&a.splice(b--,1)}return a},k.matches=function(a,b){return k(a,null,null,b)},k.matchesSelector=function(a,b){return k(b,null,null,[a]).length>0},k.find=function(a,b,c){var d;if(!a)return[];for(var e=0,f=l.order.length;e<f;e++){var g,h=l.order[e];if(g=l.leftMatch[h].exec(a)){var j=g[1];g.splice(1,1);if(j.substr(j.length-1)!=="\"){g[1]=(g[1]||"").replace(i,""),d=l.find[h](g,b,c);if(d!=null){a=a.replace(l.match[h],"");break}}}}d||(d=typeof b.getElementsByTagName!="undefined"?b.getElementsByTagName("*"):[]);return{set:d,expr:a}},k.filter=function(a,c,d,e){var f,g,h=a,i=[],j=c,m=c&&c[0]&&k.isXML(c[0]);while(a&&c.length){for(var n in l.filter)if((f=l.leftMatch[n].exec(a))!=null&&f[2]){var o,p,q=l.filter[n],r=f[1];g=!1,f.splice(1,1);if(r.substr(r.length-1)==="\")continue;j===i&&(i=[]);if(l.preFilter[n]){f=l.preFilter[n](f,j,d,i,e,m);if(!f)g=o=!0;else if(f===!0)continue}if(f)for(var s=0;(p=j[s])!=null;s++)if(p){o=q(p,f,s,j);var t=e^!!o;d&&o!=null?t?g=!0:j[s]=!1:t&&(i.push(p),g=!0)}if(o!==b){d||(j=i),a=a.replace(l.match[n],"");if(!g)return[];break}}if(a===h)if(g==null)k.error(a);else break;h=a}return j},k.error=function(a){throw"Syntax error, unrecognized expression: "+a};var l=k.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,CLASS:/\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(a){return a.getAttribute("href")},type:function(a){return a.getAttribute("type")}},relative:{"+":function(a,b){var c=typeof b=="string",d=c&&!j.test(b),e=c&&!d;d&&(b=b.toLowerCase());for(var f=0,g=a.length,h;f<g;f++)if(h=a[f]){while((h=h.previousSibling)&&h.nodeType!==1);a[f]=e||h&&h.nodeName.toLowerCase()===b?h||!1:h===b}e&&k.filter(b,a,!0)},">":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!j.test(b)){b=b.toLowerCase();for(;e<f;e++){c=a[e];if(c){var g=c.parentNode;a[e]=g.nodeName.toLowerCase()===b?g:!1}}}else{for(;e<f;e++)c=a[e],c&&(a[e]=d?c.parentNode:c.parentNode===b);d&&k.filter(b,a,!0)}},"":function(a,b,c){var e,f=d++,g=u;typeof b=="string"&&!j.test(b)&&(b=b.toLowerCase(),e=b,g=t),g("parentNode",b,f,a,e,c)},"~":function(a,b,c){var e,f=d++,g=u;typeof b=="string"&&!j.test(b)&&(b=b.toLowerCase(),e=b,g=t),g("previousSibling",b,f,a,e,c)}},find:{ID:function(a,b,c){if(typeof b.getElementById!="undefined"&&!c){var d=b.getElementById(a[1]);return d&&d.parentNode?[d]:[]}},NAME:function(a,b){if(typeof b.getElementsByName!="undefined"){var c=[],d=b.getElementsByName(a[1]);for(var e=0,f=d.length;e<f;e++)d[e].getAttribute("name")===a[1]&&c.push(d[e]);return c.length===0?null:c}},TAG:function(a,b){if(typeof b.getElementsByTagName!="undefined")return b.getElementsByTagName(a[1])}},preFilter:{CLASS:function(a,b,c,d,e,f){a=" "+a[1].replace(i,"")+" ";if(f)return a;for(var g=0,h;(h=b[g])!=null;g++)h&&(e^(h.className&&(" "+h.className+" ").replace(/[\t\n\r]/g," ").indexOf(a)>=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(i,"")},TAG:function(a,b){return a[1].replace(i,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||k.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&k.error(a[0]);a[0]=d++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(i,"");!f&&l.attrMap[g]&&(a[1]=l.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(i,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=k(b[3],null,null,c);else{var g=k.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(l.match.POS.test(b[0])||l.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!k(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return b<c[3]-0},gt:function(a,b,c){return b>c[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=l.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||k.getText([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h<i;h++)if(g[h]===a)return!1;return!0}k.error(e)},CHILD:function(a,b){var c=b[1],d=a;switch(c){case"only":case"first":while(d=d.previousSibling)if(d.nodeType===1)return!1;if(c==="first")return!0;d=a;case"last":while(d=d.nextSibling)if(d.nodeType===1)return!1;return!0;case"nth":var e=b[2],f=b[3];if(e===1&&f===0)return!0;var g=b[0],h=a.parentNode;if(h&&(h.sizcache!==g||!a.nodeIndex)){var i=0;for(d=h.firstChild;d;d=d.nextSibling)d.nodeType===1&&(d.nodeIndex=++i);h.sizcache=g}var j=a.nodeIndex-f;return e===0?j===0:j%e===0&&j/e>=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=l.attrHandle[c]?l.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=l.setFilters[e];if(f)return f(a,c,b,d)}}},m=l.match.POS,n=function(a,b){return"\"+(b-0+1)};for(var o in l.match)l.match[o]=new RegExp(l.match[o].source+/(?![^\[]*\])(?![^\(]*\))/.source),l.leftMatch[o]=new RegExp(/(^(?:.|\r|\n)*?)/.source+l.match[o].source.replace(/\\(\d+)/g,n));var p=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(q){p=function(a,b){var c=0,d=b||[];if(e.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var f=a.length;c<f;c++)d.push(a[c]);else for(;a[c];c++)d.push(a[c]);return d}}var r,s;c.documentElement.compareDocumentPosition?r=function(a,b){if(a===b){g=!0;return 0}if(!a.compareDocumentPosition||!b.compareDocumentPosition)return a.compareDocumentPosition?-1:1;return a.compareDocumentPosition(b)&4?-1:1}:(r=function(a,b){if(a===b){g=!0;return 0}if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],h=a.parentNode,i=b.parentNode,j=h;if(h===i)return s(a,b);if(!h)return-1;if(!i)return 1;while(j)e.unshift(j),j=j.parentNode;j=i;while(j)f.unshift(j),j=j.parentNode;c=e.length,d=f.length;for(var k=0;k<c&&k<d;k++)if(e[k]!==f[k])return s(e[k],f[k]);return k===c?s(a,f[k],-1):s(e[k],b,1)},s=function(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}),k.getText=function(a){var b="",c;for(var d=0;a[d];d++)c=a[d],c.nodeType===3||c.nodeType===4?b+=c.nodeValue:c.nodeType!==8&&(b+=k.getText(c.childNodes));return b},function(){var a=c.createElement("div"),d="script"+(new Date).getTime(),e=c.documentElement;a.innerHTML="<a name='"+d+"'/>",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(l.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},l.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(l.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="<a target="_blank" href='https://www.cnblogs.com/#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(l.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=k,b=c.createElement("div"),d="__sizzle__";b.innerHTML="<p class='TEST'></p>";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){k=function(b,e,f,g){e=e||c;if(!g&&!k.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return p(e.getElementsByTagName(b),f);if(h[2]&&l.find.CLASS&&e.getElementsByClassName)return p(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return p([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return p([],f);if(i.id===h[3])return p([i],f)}try{return p(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var m=e,n=e.getAttribute("id"),o=n||d,q=e.parentNode,r=/^\s*[+~]/.test(b);n?o=o.replace(/'/g,"\\$&"):e.setAttribute("id",o),r&&q&&(e=e.parentNode);try{if(!r||q)return p(e.querySelectorAll("[id='"+o+"'] "+b),f)}catch(s){}finally{n||m.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)k[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}k.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!k.isXML(a))try{if(e||!l.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return k(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;l.order.splice(1,0,"CLASS"),l.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?k.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?k.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:k.contains=function(){return!1},k.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var v=function(a,b){var c,d=[],e="",f=b.nodeType?[b]:b;while(c=l.match.PSEUDO.exec(a))e+=c[0],a=a.replace(l.match.PSEUDO,"");a=l.relative[a]?a+"*":a;for(var g=0,h=f.length;g<h;g++)k(a,f[g],d);return k.filter(e,d)};f.find=k,f.expr=k.selectors,f.expr[":"]=f.expr.filters,f.unique=k.uniqueSort,f.text=k.getText,f.isXMLDoc=k.isXML,f.contains=k.contains}();var N=/Until$/,O=/^(?:parents|prevUntil|prevAll)/,P=/,/,Q=/^.[^:#\[\.,]*$/,R=Array.prototype.slice,S=f.expr.match.POS,T={children:!0,contents:!0,next:!0,prev:!0};f.fn.extend({find:function(a){var b=this,c,d;if(typeof a!="string")return f(a).filter(function(){for(c=0,d=b.length;c<d;c++)if(f.contains(b[c],this))return!0});var e=this.pushStack("","find",a),g,h,i;for(c=0,d=this.length;c<d;c++){g=e.length,f.find(a,this[c],e);if(c>0)for(h=g;h<e.length;h++)for(i=0;i<g;i++)if(e[i]===e[h]){e.splice(h--,1);break}}return e},has:function(a){var b=f(a);return this.filter(function(){for(var a=0,c=b.length;a<c;a++)if(f.contains(this,b[a]))return!0})},not:function(a){return this.pushStack(V(this,a,!1),"not",a)},filter:function(a){return this.pushStack(V(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h,i,j={},k=1;if(g&&a.length){for(d=0,e=a.length;d<e;d++)i=a[d],j[i]||(j[i]=S.test(i)?f(i,b||this.context):i);while(g&&g.ownerDocument&&g!==b){for(i in j)h=j[i],(h.jquery?h.index(g)>-1:f(g).is(h))&&c.push({selector:i,elem:g,level:k});g=g.parentNode,k++}}return c}var l=S.test(a)||typeof a!="string"?f(a,b||this.context):0;for(d=0,e=this.length;d<e;d++){g=this[d];while(g){if(l?l.index(g)>-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(U(c[0])||U(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling(a.parentNode.firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c),g=R.call(arguments);N.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!T[a]?f.unique(e):e,(this.length>1||P.test(d))&&O.test(a)&&(e=e.reverse());return this.pushStack(e,a,g.join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var W=/ jQuery\d+="(?:\d+|null)"/g,X=/^\s+/,Y=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,Z=/<([\w:]+)/,$=/<tbody/i,_=/<|&#?\w+;/,ba=/<(?:script|object|embed|option|style)/i,bb=/checked\s*(?:[^=]|=\s*.checked.)/i,bc=/\/(java|ecma)script/i,bd=/^\s*<!(?:\[CDATA\[|\-\-)/,be={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};be.optgroup=be.option,be.tbody=be.tfoot=be.colgroup=be.caption=be.thead,be.th=be.td,f.support.htmlSerialize||(be._default=[1,"div",""]),f.fn.extend({text:function(a){if(f.isFunction(a))return this.each(function(b){var c=f(this);c.text(a.call(this,b,c.text()))});if(typeof a!="object"&&a!==b)return this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a));return f.text(this)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){f(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,f(arguments[0]).toArray());return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")),f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){if(a===b)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(W,""):null;if(typeof a=="string"&&!ba.test(a)&&(f.support.leadingWhitespace||!X.test(a))&&!be[(Z.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Y,"<$1></$2>");try{for(var c=0,d=this.length;c<d;c++)this[c].nodeType===1&&(f.cleanData(this[c].getElementsByTagName("*")),this[c].innerHTML=a)}catch(e){this.empty().append(a)}}else f.isFunction(a)?this.each(function(b){var c=f(this);c.html(a.call(this,b,c.html()))}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&this[0].parentNode){if(f.isFunction(a))return this.each(function(b){var c=f(this),d=c.html();c.replaceWith(a.call(this,b,d))});typeof a!="string"&&(a=f(a).detach());return this.each(function(){var b=this.nextSibling,c=this.parentNode;f(this).remove(),b?f(b).before(a):f(c).append(a)})}return this.length?this.pushStack(f(f.isFunction(a)?a():a),"replaceWith",a):this},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){var e,g,h,i,j=a[0],k=[];if(!f.support.checkClone&&arguments.length===3&&typeof j=="string"&&bb.test(j))return this.each(function(){f(this).domManip(a,c,d,!0)});if(f.isFunction(j))return this.each(function(e){var g=f(this);a[0]=j.call(this,e,c?g.html():b),g.domManip(a,c,d)});if(this[0]){i=j&&j.parentNode,f.support.parentNode&&i&&i.nodeType===11&&i.childNodes.length===this.length?e={fragment:i}:e=f.buildFragment(a,this,k),h=e.fragment,h.childNodes.length===1?g=h=h.firstChild:g=h.firstChild;if(g){c=c&&f.nodeName(g,"tr");for(var l=0,m=this.length,n=m-1;l<m;l++)d.call(c?bf(this[l],g):this[l],e.cacheable||m>1&&l<n?f.clone(h,!0,!0):h)}k.length&&f.each(k,bl)}return this}}),f.buildFragment=function(a,b,d){var e,g,h,i;b&&b[0]&&(i=b[0].ownerDocument||b[0]),i.createDocumentFragment||(i=c),a.length===1&&typeof a[0]=="string"&&a[0].length<512&&i===c&&a[0].charAt(0)==="<"&&!ba.test(a[0])&&(f.support.checkClone||!bb.test(a[0]))&&(g=!0,h=f.fragments[a[0]],h&&h!==1&&(e=h)),e||(e=i.createDocumentFragment(),f.clean
4. (a,i,e,d)),g&&(f.fragments[a[0]]=h?e:1);return{fragment:e,cacheable:g}},f.fragments={},f.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){f.fn[a]=function(c){var d=[],e=f(c),g=this.length===1&&this[0].parentNode;if(g&&g.nodeType===11&&g.childNodes.length===1&&e.length===1){e[b](this[0]);return this}for(var h=0,i=e.length;h<i;h++){var j=(h>0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d=a.cloneNode(!0),e,g,h;if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bh(a,d),e=bi(a),g=bi(d);for(h=0;e[h];++h)g[h]&&bh(e[h],g[h])}if(b){bg(a,d);if(c){e=bi(a),g=bi(d);for(h=0;e[h];++h)bg(e[h],g[h])}}e=g=null;return d},clean:function(a,b,d,e){var g;b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);var h=[],i;for(var j=0,k;(k=a[j])!=null;j++){typeof k=="number"&&(k+="");if(!k)continue;if(typeof k=="string")if(!_.test(k))k=b.createTextNode(k);else{k=k.replace(Y,"<$1></$2>");var l=(Z.exec(k)||["",""])[1].toLowerCase(),m=be[l]||be._default,n=m[0],o=b.createElement("div");o.innerHTML=m[1]+k+m[2];while(n--)o=o.lastChild;if(!f.support.tbody){var p=$.test(k),q=l==="table"&&!p?o.firstChild&&o.firstChild.childNodes:m[1]==="<table>"&&!p?o.childNodes:[];for(i=q.length-1;i>=0;--i)f.nodeName(q[i],"tbody")&&!q[i].childNodes.length&&q[i].parentNode.removeChild(q[i])}!f.support.leadingWhitespace&&X.test(k)&&o.insertBefore(b.createTextNode(X.exec(k)[0]),o.firstChild),k=o.childNodes}var r;if(!f.support.appendChecked)if(k[0]&&typeof (r=k.length)=="number")for(i=0;i<r;i++)bk(k[i]);else bk(k);k.nodeType?h.push(k):h=f.merge(h,k)}if(d){g=function(a){return!a.type||bc.test(a.type)};for(j=0;h[j];j++)if(e&&f.nodeName(h[j],"script")&&(!h[j].type||h[j].type.toLowerCase()==="text/javascript"))e.push(h[j].parentNode?h[j].parentNode.removeChild(h[j]):h[j]);else{if(h[j].nodeType===1){var s=f.grep(h[j].getElementsByTagName("script"),g);h.splice.apply(h,[j+1,0].concat(s))}d.appendChild(h[j])}}return h},cleanData:function(a){var b,c,d=f.cache,e=f.expando,g=f.event.special,h=f.support.deleteExpando;for(var i=0,j;(j=a[i])!=null;i++){if(j.nodeName&&f.noData[j.nodeName.toLowerCase()])continue;c=j[f.expando];if(c){b=d[c]&&d[c][e];if(b&&b.events){for(var k in b.events)g[k]?f.event.remove(j,k):f.removeEvent(j,k,b.handle);b.handle&&(b.handle.elem=null)}h?delete j[f.expando]:j.removeAttribute&&j.removeAttribute(f.expando),delete d[c]}}}});var bm=/alpha\([^)]*\)/i,bn=/opacity=([^)]*)/,bo=/([A-Z]|^ms)/g,bp=/^-?\d+(?:px)?$/i,bq=/^-?\d/,br=/^([\-+])=([\-+.\de]+)/,bs={position:"absolute",visibility:"hidden",display:"block"},bt=["Left","Right"],bu=["Top","Bottom"],bv,bw,bx;f.fn.css=function(a,c){if(arguments.length===2&&c===b)return this;return f.access(this,a,c,!0,function(a,c,d){return d!==b?f.style(a,c,d):f.css(a,c)})},f.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bv(a,"opacity","opacity");return c===""?"1":c}return a.style.opacity}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":f.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!!a&&a.nodeType!==3&&a.nodeType!==8&&!!a.style){var g,h,i=f.camelCase(c),j=a.style,k=f.cssHooks[i];c=f.cssProps[i]||i;if(d===b){if(k&&"get"in k&&(g=k.get(a,!1,e))!==b)return g;return j[c]}h=typeof d,h==="string"&&(g=br.exec(d))&&(d=+(g[1]+1)*+g[2]+parseFloat(f.css(a,c)),h="number");if(d==null||h==="number"&&isNaN(d))return;h==="number"&&!f.cssNumber[i]&&(d+="px");if(!k||!("set"in k)||(d=k.set(a,d))!==b)try{j[c]=d}catch(l){}}},css:function(a,c,d){var e,g;c=f.camelCase(c),g=f.cssHooks[c],c=f.cssProps[c]||c,c==="cssFloat"&&(c="float");if(g&&"get"in g&&(e=g.get(a,!0,d))!==b)return e;if(bv)return bv(a,c)},swap:function(a,b,c){var d={};for(var e in b)d[e]=a.style[e],a.style[e]=b[e];c.call(a);for(e in b)a.style[e]=d[e]}}),f.curCSS=f.css,f.each(["height","width"],function(a,b){f.cssHooks[b]={get:function(a,c,d){var e;if(c){if(a.offsetWidth!==0)return by(a,b,d);f.swap(a,bs,function(){e=by(a,b,d)});return e}},set:function(a,b){if(!bp.test(b))return b;b=parseFloat(b);if(b>=0)return b+"px"}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return bn.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNaN(b)?"":"alpha(opacity="+b*100+")",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bm,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bm.test(g)?g.replace(bm,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){var c;f.swap(a,{display:"inline-block"},function(){b?c=bv(a,"margin-right","marginRight"):c=a.style.marginRight});return c}})}),c.defaultView&&c.defaultView.getComputedStyle&&(bw=function(a,c){var d,e,g;c=c.replace(bo,"-$1").toLowerCase();if(!(e=a.ownerDocument.defaultView))return b;if(g=e.getComputedStyle(a,null))d=g.getPropertyValue(c),d===""&&!f.contains(a.ownerDocument.documentElement,a)&&(d=f.style(a,c));return d}),c.documentElement.currentStyle&&(bx=function(a,b){var c,d=a.currentStyle&&a.currentStyle[b],e=a.runtimeStyle&&a.runtimeStyle[b],f=a.style;!bp.test(d)&&bq.test(d)&&(c=f.left,e&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":d||0,d=f.pixelLeft+"px",f.left=c,e&&(a.runtimeStyle.left=e));return d===""?"auto":d}),bv=bw||bx,f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)});var bz=/%20/g,bA=/\[\]$/,bB=/\r?\n/g,bC=/#.*$/,bD=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bE=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bF=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bG=/^(?:GET|HEAD)$/,bH=/^\/\//,bI=/\?/,bJ=/
5.    
6.    
7. }
10.    
11.    
12.    
13.         
14.             报表最新同步时间：
15.         
16.         
17.             <table >
18.                 <colgroup>
19.                     <col>
20.                     <col>
21.                     <col>
22.                     <col>
23.                     <col>
24.                     <col>
25.                     <col>
26.                     <col>
27.                     <col>
28.                     <col>
29.                     <col>
30.                     <col>
31.                     <col>
32.                 </colgroup>
33.                 <thead>
34.                     <tr>
35.                         <th colspan="2" >项目信息</th>
36.                         <th colspan="5" >销售情况</th>
37.                         <th colspan="6" >款项情况</th>
38.                     </tr>
39.                     <tr>
40.                         <th >项目名称</th>
41.                         <th >服务商名称</th>
42.                         <th >昨天订单总额</th>
43.                         <th >今天订单总额</th>
44.                         <th >去年订单总额</th>
45.                         <th >今年订单总额</th>
46.                         <th >订单总额</th>
48.                         <th >客户应回款总额</th>
49.                         <th >客户已回款总额</th>
50.                         <th >客户未回款总额</th>
51.                         <th >服务商应付款总额</th>
52.                         <th >服务商已付款总额</th>
53.                         <th >服务商未付款总额</th>
54.                     </tr>
55.                 </thead>
56.                 <tbody id="table_body">
57.                 </tbody>
58.             </table>
59.         
60.    

复制代码

4、创建SignalR中心

中心是一个类，用于处理客户端服务器通信的高级管道。在SignalR_Demo项目文件夹中，创建Hubs文件夹。在Hubs文件夹中，使用已下代码创建ChatHub类。

1. var builder = WebApplication.CreateBuilder(args);
2. //添加SignalR服务
3. builder.Services.AddSignalR();
6. app.UseEndpoints(endpoints =>
7. {
8.     endpoints.MapControllerRoute(
9.         name: "default",
10.         pattern: "{controller=Home}/{action=Index}/{id?}"
11.     );
13.     //添加SignalR端点
14.     endpoints.MapHub<ServerMonitorHub>("/serverMonitorHub");
15. });

复制代码

3.2-客户端（Vue3+Vite+TS）

（1）安装SugbalR

1.     public class ChatHub:Hub
2.     {
3.         /// <summary>
4.         /// 发送消息
5.         /// </summary>
6.         /// <param name="user">用户名</param>
7.         /// <param name="message">发送信息</param>
8.         /// <returns></returns>
9.         public async Task SendMessage(string user,string message)
10.         {
11.             await Clients.All.SendAsync("ReceiveMessage", user, message);
12.         }
13.     }

复制代码

版本截图：

（2）然后新建一个文件，用来封装业务逻辑相关代码。[西瓜程序猿]是在【src/utils】目录下，创建了一个名为【signalr.ts】的文件，也可以是js文件，根据自己项目的需要去新建。

代码：

1. npm install @latelier/vue-signalr

复制代码

（3）然后再页面进行使用。[西瓜程序猿]这里以Echarts图表展示为例子，首先先安装Echarts包。

npm install echarts --save

版本截图：

（4）然后再页面写入如下代码，具体页面样式根据需要进行修改调整哦。

1. import * as signalR  from '@microsoft/signalr';
3. //如果需要身份验证
4. //.withUrl('/messageHub', {accessTokenFactory: () => sessionStorage.getItem('token')})
5. let connection;
7. // 建立连接
8. async function start(url) {
9.   try {
10.     connection = new signalR.HubConnectionBuilder()
11.       .withUrl(url)//跨域需要使用绝对地址
12.       .configureLogging(signalR.LogLevel.Information)
13.       .withAutomaticReconnect() // 设置自动重连机制
14.       .build();
15.   } catch(err) {
16.     console.log(err);
17.     setTimeout(start, 10000);//错误重连
18.   }
19. }
21. // 开始signalr连接
22. const connect = async (url) => {
23.   await start(url);
24.   console.log(`【西瓜程序猿-${new Date().toLocaleString()}：SignalR已连接成功!`);
25. };
27. // 调用服务端方法
28. async function send(methodName, param){
29.   try {
30.     await connection.invoke(methodName, param);
31.   } catch (err) {
32.     console.error(err);
33.   }
34. }
36. //断开连接
37. const disconnect = async ()=>{
38.   await connection.stop();
39.   console.log(`【西瓜程序猿-${new Date().toLocaleString()}：SignalR已断开连接!`);
40. };
42. export {
43.   connection,
44.   connect,
45.   send,
46.   disconnect
47. };

复制代码

（5）效果展示：



原文链接：https://www.cnblogs.com/kimiliucn/p/17648543.html

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4