)<[^<]*)*<\/script>/gi,
1146 | scriptTypeRE = /^(?:text|application)\/javascript/i,
1147 | xmlTypeRE = /^(?:text|application)\/xml/i,
1148 | jsonType = 'application/json',
1149 | htmlType = 'text/html',
1150 | blankRE = /^\s*$/
1151 |
1152 | // trigger a custom event and return false if it was cancelled
1153 | function triggerAndReturn(context, eventName, data) {
1154 | var event = $.Event(eventName)
1155 | $(context).trigger(event, data)
1156 | return !event.isDefaultPrevented()
1157 | }
1158 |
1159 | // trigger an Ajax "global" event
1160 | function triggerGlobal(settings, context, eventName, data) {
1161 | if (settings.global) return triggerAndReturn(context || document, eventName, data)
1162 | }
1163 |
1164 | // Number of active Ajax requests
1165 | $.active = 0
1166 |
1167 | function ajaxStart(settings) {
1168 | if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
1169 | }
1170 | function ajaxStop(settings) {
1171 | if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
1172 | }
1173 |
1174 | // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
1175 | function ajaxBeforeSend(xhr, settings) {
1176 | var context = settings.context
1177 | if (settings.beforeSend.call(context, xhr, settings) === false ||
1178 | triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
1179 | return false
1180 |
1181 | triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
1182 | }
1183 | function ajaxSuccess(data, xhr, settings, deferred) {
1184 | var context = settings.context, status = 'success'
1185 | settings.success.call(context, data, status, xhr)
1186 | if (deferred) deferred.resolveWith(context, [data, status, xhr])
1187 | triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
1188 | ajaxComplete(status, xhr, settings)
1189 | }
1190 | // type: "timeout", "error", "abort", "parsererror"
1191 | function ajaxError(error, type, xhr, settings, deferred) {
1192 | var context = settings.context
1193 | settings.error.call(context, xhr, type, error)
1194 | if (deferred) deferred.rejectWith(context, [xhr, type, error])
1195 | triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
1196 | ajaxComplete(type, xhr, settings)
1197 | }
1198 | // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
1199 | function ajaxComplete(status, xhr, settings) {
1200 | var context = settings.context
1201 | settings.complete.call(context, xhr, status)
1202 | triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
1203 | ajaxStop(settings)
1204 | }
1205 |
1206 | // Empty function, used as default callback
1207 | function empty() {}
1208 |
1209 | $.ajaxJSONP = function(options, deferred){
1210 | if (!('type' in options)) return $.ajax(options)
1211 |
1212 | var _callbackName = options.jsonpCallback,
1213 | callbackName = ($.isFunction(_callbackName) ?
1214 | _callbackName() : _callbackName) || ('jsonp' + (++jsonpID)),
1215 | script = document.createElement('script'),
1216 | originalCallback = window[callbackName],
1217 | responseData,
1218 | abort = function(errorType) {
1219 | $(script).triggerHandler('error', errorType || 'abort')
1220 | },
1221 | xhr = { abort: abort }, abortTimeout
1222 |
1223 | if (deferred) deferred.promise(xhr)
1224 |
1225 | $(script).on('load error', function(e, errorType){
1226 | clearTimeout(abortTimeout)
1227 | $(script).off().remove()
1228 |
1229 | if (e.type == 'error' || !responseData) {
1230 | ajaxError(null, errorType || 'error', xhr, options, deferred)
1231 | } else {
1232 | ajaxSuccess(responseData[0], xhr, options, deferred)
1233 | }
1234 |
1235 | window[callbackName] = originalCallback
1236 | if (responseData && $.isFunction(originalCallback))
1237 | originalCallback(responseData[0])
1238 |
1239 | originalCallback = responseData = undefined
1240 | })
1241 |
1242 | if (ajaxBeforeSend(xhr, options) === false) {
1243 | abort('abort')
1244 | return xhr
1245 | }
1246 |
1247 | window[callbackName] = function(){
1248 | responseData = arguments
1249 | }
1250 |
1251 | script.src = options.url.replace(/=\?/, '=' + callbackName)
1252 | document.head.appendChild(script)
1253 |
1254 | if (options.timeout > 0) abortTimeout = setTimeout(function(){
1255 | abort('timeout')
1256 | }, options.timeout)
1257 |
1258 | return xhr
1259 | }
1260 |
1261 | $.ajaxSettings = {
1262 | // Default type of request
1263 | type: 'GET',
1264 | // Callback that is executed before request
1265 | beforeSend: empty,
1266 | // Callback that is executed if the request succeeds
1267 | success: empty,
1268 | // Callback that is executed the the server drops error
1269 | error: empty,
1270 | // Callback that is executed on request complete (both: error and success)
1271 | complete: empty,
1272 | // The context for the callbacks
1273 | context: null,
1274 | // Whether to trigger "global" Ajax events
1275 | global: true,
1276 | // Transport
1277 | xhr: function () {
1278 | return new window.XMLHttpRequest()
1279 | },
1280 | // MIME types mapping
1281 | // IIS returns Javascript as "application/x-javascript"
1282 | accepts: {
1283 | script: 'text/javascript, application/javascript, application/x-javascript',
1284 | json: jsonType,
1285 | xml: 'application/xml, text/xml',
1286 | html: htmlType,
1287 | text: 'text/plain'
1288 | },
1289 | // Whether the request is to another domain
1290 | crossDomain: false,
1291 | // Default timeout
1292 | timeout: 0,
1293 | // Whether data should be serialized to string
1294 | processData: true,
1295 | // Whether the browser should be allowed to cache GET responses
1296 | cache: true
1297 | }
1298 |
1299 | function mimeToDataType(mime) {
1300 | if (mime) mime = mime.split(';', 2)[0]
1301 | return mime && ( mime == htmlType ? 'html' :
1302 | mime == jsonType ? 'json' :
1303 | scriptTypeRE.test(mime) ? 'script' :
1304 | xmlTypeRE.test(mime) && 'xml' ) || 'text'
1305 | }
1306 |
1307 | function appendQuery(url, query) {
1308 | if (query == '') return url
1309 | return (url + '&' + query).replace(/[&?]{1,2}/, '?')
1310 | }
1311 |
1312 | // serialize payload and append it to the URL for GET requests
1313 | function serializeData(options) {
1314 | if (options.processData && options.data && $.type(options.data) != "string")
1315 | options.data = $.param(options.data, options.traditional)
1316 | if (options.data && (!options.type || options.type.toUpperCase() == 'GET'))
1317 | options.url = appendQuery(options.url, options.data), options.data = undefined
1318 | }
1319 |
1320 | $.ajax = function(options){
1321 | var settings = $.extend({}, options || {}),
1322 | deferred = $.Deferred && $.Deferred()
1323 | for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]
1324 |
1325 | ajaxStart(settings)
1326 |
1327 | if (!settings.crossDomain) settings.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(settings.url) &&
1328 | RegExp.$2 != window.location.host
1329 |
1330 | if (!settings.url) settings.url = window.location.toString()
1331 | serializeData(settings)
1332 | if (settings.cache === false) settings.url = appendQuery(settings.url, '_=' + Date.now())
1333 |
1334 | var dataType = settings.dataType, hasPlaceholder = /=\?/.test(settings.url)
1335 | if (dataType == 'jsonp' || hasPlaceholder) {
1336 | if (!hasPlaceholder)
1337 | settings.url = appendQuery(settings.url,
1338 | settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
1339 | return $.ajaxJSONP(settings, deferred)
1340 | }
1341 |
1342 | var mime = settings.accepts[dataType],
1343 | headers = { },
1344 | setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
1345 | protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
1346 | xhr = settings.xhr(),
1347 | nativeSetHeader = xhr.setRequestHeader,
1348 | abortTimeout
1349 |
1350 | if (deferred) deferred.promise(xhr)
1351 |
1352 | if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
1353 | setHeader('Accept', mime || '*/*')
1354 | if (mime = settings.mimeType || mime) {
1355 | if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
1356 | xhr.overrideMimeType && xhr.overrideMimeType(mime)
1357 | }
1358 | if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
1359 | setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')
1360 |
1361 | if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
1362 | xhr.setRequestHeader = setHeader
1363 |
1364 | xhr.onreadystatechange = function(){
1365 | if (xhr.readyState == 4) {
1366 | xhr.onreadystatechange = empty
1367 | clearTimeout(abortTimeout)
1368 | var result, error = false
1369 | if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
1370 | dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))
1371 | result = xhr.responseText
1372 |
1373 | try {
1374 | // http://perfectionkills.com/global-eval-what-are-the-options/
1375 | if (dataType == 'script') (1,eval)(result)
1376 | else if (dataType == 'xml') result = xhr.responseXML
1377 | else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
1378 | } catch (e) { error = e }
1379 |
1380 | if (error) ajaxError(error, 'parsererror', xhr, settings, deferred)
1381 | else ajaxSuccess(result, xhr, settings, deferred)
1382 | } else {
1383 | ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
1384 | }
1385 | }
1386 | }
1387 |
1388 | if (ajaxBeforeSend(xhr, settings) === false) {
1389 | xhr.abort()
1390 | ajaxError(null, 'abort', xhr, settings, deferred)
1391 | return xhr
1392 | }
1393 |
1394 | if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]
1395 |
1396 | var async = 'async' in settings ? settings.async : true
1397 | xhr.open(settings.type, settings.url, async, settings.username, settings.password)
1398 |
1399 | for (name in headers) nativeSetHeader.apply(xhr, headers[name])
1400 |
1401 | if (settings.timeout > 0) abortTimeout = setTimeout(function(){
1402 | xhr.onreadystatechange = empty
1403 | xhr.abort()
1404 | ajaxError(null, 'timeout', xhr, settings, deferred)
1405 | }, settings.timeout)
1406 |
1407 | // avoid sending empty string (#319)
1408 | xhr.send(settings.data ? settings.data : null)
1409 | return xhr
1410 | }
1411 |
1412 | // handle optional data/success arguments
1413 | function parseArguments(url, data, success, dataType) {
1414 | var hasData = !$.isFunction(data)
1415 | return {
1416 | url: url,
1417 | data: hasData ? data : undefined,
1418 | success: !hasData ? data : $.isFunction(success) ? success : undefined,
1419 | dataType: hasData ? dataType || success : success
1420 | }
1421 | }
1422 |
1423 | $.get = function(url, data, success, dataType){
1424 | return $.ajax(parseArguments.apply(null, arguments))
1425 | }
1426 |
1427 | $.post = function(url, data, success, dataType){
1428 | var options = parseArguments.apply(null, arguments)
1429 | options.type = 'POST'
1430 | return $.ajax(options)
1431 | }
1432 |
1433 | $.getJSON = function(url, data, success){
1434 | var options = parseArguments.apply(null, arguments)
1435 | options.dataType = 'json'
1436 | return $.ajax(options)
1437 | }
1438 |
1439 | $.fn.load = function(url, data, success){
1440 | if (!this.length) return this
1441 | var self = this, parts = url.split(/\s/), selector,
1442 | options = parseArguments(url, data, success),
1443 | callback = options.success
1444 | if (parts.length > 1) options.url = parts[0], selector = parts[1]
1445 | options.success = function(response){
1446 | self.html(selector ?
1447 | $('').html(response.replace(rscript, "")).find(selector)
1448 | : response)
1449 | callback && callback.apply(self, arguments)
1450 | }
1451 | $.ajax(options)
1452 | return this
1453 | }
1454 |
1455 | var escape = encodeURIComponent
1456 |
1457 | function serialize(params, obj, traditional, scope){
1458 | var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
1459 | $.each(obj, function(key, value) {
1460 | type = $.type(value)
1461 | if (scope) key = traditional ? scope :
1462 | scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
1463 | // handle data in serializeArray() format
1464 | if (!scope && array) params.add(value.name, value.value)
1465 | // recurse into nested objects
1466 | else if (type == "array" || (!traditional && type == "object"))
1467 | serialize(params, value, traditional, key)
1468 | else params.add(key, value)
1469 | })
1470 | }
1471 |
1472 | $.param = function(obj, traditional){
1473 | var params = []
1474 | params.add = function(k, v){ this.push(escape(k) + '=' + escape(v)) }
1475 | serialize(params, obj, traditional)
1476 | return params.join('&').replace(/%20/g, '+')
1477 | }
1478 | })(Zepto)
1479 |
1480 | ;(function($){
1481 | $.fn.serializeArray = function() {
1482 | var result = [], el
1483 | $([].slice.call(this.get(0).elements)).each(function(){
1484 | el = $(this)
1485 | var type = el.attr('type')
1486 | if (this.nodeName.toLowerCase() != 'fieldset' &&
1487 | !this.disabled && type != 'submit' && type != 'reset' && type != 'button' &&
1488 | ((type != 'radio' && type != 'checkbox') || this.checked))
1489 | result.push({
1490 | name: el.attr('name'),
1491 | value: el.val()
1492 | })
1493 | })
1494 | return result
1495 | }
1496 |
1497 | $.fn.serialize = function(){
1498 | var result = []
1499 | this.serializeArray().forEach(function(elm){
1500 | result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
1501 | })
1502 | return result.join('&')
1503 | }
1504 |
1505 | $.fn.submit = function(callback) {
1506 | if (callback) this.bind('submit', callback)
1507 | else if (this.length) {
1508 | var event = $.Event('submit')
1509 | this.eq(0).trigger(event)
1510 | if (!event.isDefaultPrevented()) this.get(0).submit()
1511 | }
1512 | return this
1513 | }
1514 |
1515 | })(Zepto)
1516 |
1517 | ;(function($){
1518 | // __proto__ doesn't exist on IE<11, so redefine
1519 | // the Z function to use object extension instead
1520 | if (!('__proto__' in {})) {
1521 | $.extend($.zepto, {
1522 | Z: function(dom, selector){
1523 | dom = dom || []
1524 | $.extend(dom, $.fn)
1525 | dom.selector = selector || ''
1526 | dom.__Z = true
1527 | return dom
1528 | },
1529 | // this is a kludge but works
1530 | isZ: function(object){
1531 | return $.type(object) === 'array' && '__Z' in object
1532 | }
1533 | })
1534 | }
1535 |
1536 | // getComputedStyle shouldn't freak out when called
1537 | // without a valid element as argument
1538 | try {
1539 | getComputedStyle(undefined)
1540 | } catch(e) {
1541 | var nativeGetComputedStyle = getComputedStyle;
1542 | window.getComputedStyle = function(element){
1543 | try {
1544 | return nativeGetComputedStyle(element)
1545 | } catch(e) {
1546 | return null
1547 | }
1548 | }
1549 | }
1550 | })(Zepto)
--------------------------------------------------------------------------------