code stringlengths 2 1.05M |
|---|
var assert = require('chai').assert;
var ROOT_PATH = './../../';
describe('CategoryService', function () {
var _CategoryService = require(ROOT_PATH + 'services/CategoryService');
var categoryService = _CategoryService.CategoryService;
it('should choose a category', function () {
var category = categoryService.choose();
assert.isString(category.category, 'is a string');
assert.isAbove(category.category.length, 0, 'is non-empty');
});
it ('should exclude a specific category', function () {
var excluded = 'If you were President?'; // This is the first one in the object
var notExcluded = true;
// Not the best test, but, todo
for (var i = 0; i < 100; i++) {
var c = categoryService.choose([0]);
if (c.category === excluded) {
notExcluded = false;
break;
}
}
assert.isTrue(notExcluded);
});
}); |
// Main eduCrud Module
//Declare app level module which depends on filters, and services
var eduGridServices = angular.module('edu-grid.services', []);
var eduGridDirectives = angular.module('edu-grid.directives', []);
var eduGridFilters = angular.module('edu-grid.filters', []);
var eduGridTpl=angular.module('edu-grid.tpl',[]);
// initialization of services into the main module
angular.module('eduGrid', ['edu-grid.services', 'edu-grid.directives', 'edu-grid.filters','edu-grid.tpl','ngResource','ui.bootstrap','eduField']); |
// Load Plugins
var pkg = require('./package.json'),
gulp = require("gulp"),
uglify = require("gulp-uglify"),
rename = require("gulp-rename"),
jshint = require("gulp-jshint"),
merge = require("merge-stream"),
header = require("gulp-header"),
autoprefixer = require("gulp-autoprefixer"),
ghpages = require("gulp-gh-pages"),
less = require('gulp-less'),
browserSync = require('browser-sync'),
reload = browserSync.reload;
// Used for copyright headers
var banner = "/*! <%= pkg.title %> <%= pkg.version %> | <%= pkg.homepage %> | (c) 2015 BoomTown | MIT License */\n";
// Styles
gulp.task('styles', function() {
return gulp.src(["src/less/app.less"])
.pipe(less({ compress: true }))
.pipe(autoprefixer({ browsers: ['last 2 versions','ie 9'], cascade: false }))
.pipe(gulp.dest("dist/css/"))
.pipe(reload({stream:true}));
});
// JS Hint
gulp.task("jshint", function() {
return gulp.src("src/*.js")
.pipe(jshint({
"boss": true,
"sub": true,
"evil": true,
"browser": true,
"multistr": true,
"globals": {
"module": false,
"require": true
}
}))
.pipe(jshint.reporter("jshint-stylish"));
});
// Scripts
gulp.task("scripts", function() {
var uncompressed = gulp.src("src/js/*.js")
.pipe(header(banner, { pkg : pkg }))
.pipe(gulp.dest("dist/js/"))
.pipe(reload({stream:true}));
var compressed = gulp.src("src/js/*.js")
.pipe(uglify())
.pipe(header(banner, { pkg : pkg }))
.pipe(rename({
suffix: ".min"
}))
.pipe(gulp.dest("dist/js/"))
.pipe(reload({stream:true}));
return merge(uncompressed, compressed);
});
// Watch
gulp.task("watch", function () {
gulp.watch("src/less/*.less", ["styles"]);
gulp.watch("src/js/*.js", ["jshint", "scripts"]);
});
// Browser Sync
gulp.task('browser-sync', function() {
browserSync({
server: {
baseDir: 'dist/'
}
});
});
// Website
gulp.task('website', function () {
return gulp.src('./dist/**/*')
.pipe(ghpages());
});
// Server
gulp.task('server', ['watch', 'browser-sync'], function () {
gulp.watch("dist/*.html", reload);
});
// Default task
gulp.task("default", ["styles", "jshint", "scripts"]); |
export function createAction(type, payload = null) {
const action = {
type,
}
if (payload) {
action.payload = payload
}
return action
}
|
// const symbols = {
// '~': 'tilde',
// '`': 'backtick',
// '!': 'exclamation',
// '@': 'at',
// '#': 'pound',
// $: 'dollar',
// '%': 'percent',
// '^': 'carat',
// '&': 'ampersand',
// '*': 'asterisk',
// '(': 'paren-open',
// ')': 'paren-close',
// '-': 'hyphen',
// _: 'underscore',
// '=': 'equals',
// '+': 'plus',
// '[': 'square-open',
// ']': 'square-close',
// '{': 'curly-open',
// '}': 'curly-close',
// '\\': 'backslash',
// '|': 'pipe',
// ';': 'semicolon',
// ':': 'colon',
// "'": 'single-quote',
// '"': 'double-quote',
// ',': 'comma',
// '.': 'period',
// '<': 'less',
// '>': 'greater',
// '/': 'slash',
// '?': 'question-mark',
// }
export const matchers = {
word: {
name: 'word',
match: /[a-zA-Z]+/,
},
whitespace: {
name: 'whitespace',
match: /\s+/,
},
sentence: {
name: 'sentence',
match: /[\w\s'",-]+\./,
},
paragraph: {
name: 'paragraph',
match: /^.*$/m,
},
newline: {
name: 'newline',
match: /\n/,
},
integer: {
name: 'integer',
match: /\d+/,
},
float: {
name: 'float',
match: /\d*\.\d+/,
},
number: {
name: 'number',
match: /\d*\.\d+|\d+/,
},
// call: {
// name: 'call',
// match: /([\w.]+)\((.*)\)/,
// },
// comment: {
// name: 'comment',
// match: /(?:(?:\/\/|#).*$|\/\*(.|\n)*?\*\/)/,
// },
symbol: {
name: 'symbol',
match: /[^\w\s]/,
},
// 'symbol-map': {
// name: 'symbol',
// match: /^[^\w\s]/,
// handler: context => {
// const symbol = symbols[context.token[1]]
// if (symbol) context.tokens.push([symbol, context.token[1]])
// },
// },
string: {
name: 'string',
match: /(?:"[^"\n]*"|'[^'\n]*')/,
},
unknown: {
name: 'unknown',
match: /[\s\S]/,
},
terminator: {
name: 'terminator',
match: /[\n;]+/,
},
}
|
// app/pods/components/comment-form/component.js
import CommentForm from 'ember-osf/components/comment-form/component';
import layout from './template';
export default CommentForm.extend({
layout,
tagName: ['comment-form'],
classNames: ['comment', 'form']
});
|
import React, { Component, PropTypes } from 'react';
var _ = require("lodash");
import AddFriend from './AddFriend';
import Friend from './Friend';
export default class FriendList extends Component {
static propTypes = {
actions: PropTypes.object.isRequired,
friends: PropTypes.object.isRequired,
};
render() {
const { friends, actions, active, startTime } = this.props;
let sortedFriends = _.sortBy(friends, friend => friend.username);
let friendList = _.map(sortedFriends, friend => {
let isActive = friend.username === active;
return (
<Friend startTime={startTime} key={friend.username} friend={friend} actions={actions} active={isActive} />
);
});
return (
<div>
<h3>ChatterBox Friends</h3>
<ul className="nav">
{friendList}
</ul>
</div>
);
}
}
|
/*
* grunt-contrib-copy
* http://gruntjs.com/
*
* Copyright (c) 2012 Chris Talkington, contributors
* Licensed under the MIT license.
* https://github.com/gruntjs/grunt-contrib-copy/blob/master/LICENSE-MIT
*/
module.exports = function(grunt) {
'use strict';
var path = require('path');
grunt.registerMultiTask('copy', 'Copy files.', function() {
var kindOf = grunt.util.kindOf;
var options = this.options({
processContent: false,
processContentExclude: []
});
var copyOptions = {
process: options.processContent,
noProcess: options.processContentExclude
};
grunt.verbose.writeflags(options, 'Options');
var dest;
var isExpandedPair;
var tally = {
dirs: 0,
files: 0
};
this.files.forEach(function(filePair) {
isExpandedPair = filePair.orig.expand || false;
filePair.src.forEach(function(src) {
if (detectDestType(filePair.dest) === 'directory') {
dest = (isExpandedPair) ? filePair.dest : unixifyPath(path.join(filePair.dest, src));
} else {
dest = filePair.dest;
}
if (grunt.file.isDir(src)) {
grunt.verbose.writeln('Creating ' + dest.cyan);
grunt.file.mkdir(dest);
tally.dirs++;
} else {
grunt.verbose.writeln('Copying ' + src.cyan + ' -> ' + dest.cyan);
grunt.file.copy(src, dest, copyOptions);
tally.files++;
}
});
});
if (tally.dirs) {
grunt.log.write('Created ' + tally.dirs.toString().cyan + ' directories');
}
if (tally.files) {
grunt.log.write((tally.dirs ? ', copied ' : 'Copied ') + tally.files.toString().cyan + ' files');
}
grunt.log.writeln();
});
var detectDestType = function(dest) {
if (grunt.util._.endsWith(dest, '/')) {
return 'directory';
} else {
return 'file';
}
};
var unixifyPath = function(filepath) {
if (process.platform === 'win32') {
return filepath.replace(/\\/g, '/');
} else {
return filepath;
}
};
}; |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.defaultStyles = exports.defaultColors = undefined;
var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
exports.reduce = reduce;
exports.createValueGenerator = createValueGenerator;
exports.createCircularTicks = createCircularTicks;
exports.getAxisStyles = getAxisStyles;
exports.createUniqueID = createUniqueID;
exports.calculateMargin = calculateMargin;
exports.textDomainRange = textDomainRange;
exports.calculateExtent = calculateExtent;
exports.calculateDomainRange = calculateDomainRange;
exports.createDomainRangeGenerator = createDomainRangeGenerator;
var _d3Array = require('d3-array');
var _d3Scale = require('d3-scale');
var _d = require('d3');
var _objectHash = require('object-hash');
var _objectHash2 = _interopRequireDefault(_objectHash);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var defaultColors = exports.defaultColors = ['#3F4C55', '#E3A51A', '#F4E956', '#AAAC84'];
var defaultStyles = exports.defaultStyles = {
'.pie-chart-slice': {
stroke: '#fff',
strokeWidth: 1,
opacity: '1'
},
'.pie-chart-slice:hover': {
opacity: '0.8'
},
'.pie-chart-label': {
fontFamily: 'sans-serif',
fontSize: '12px',
textAnchor: 'middle',
fill: '#000'
},
'.bar': {
fill: 'blue',
transition: 'x 0.35s ease-in, y 0.35s ease-in, height 0.5s ease-in, width 0.5s ease-in',
opacity: 1
},
'.bar:hover': {
opacity: 0.8
},
'.line': {
fill: 'none',
strokeWidth: 1.5,
opacity: 0.7
},
'.line:hover': {
opacity: 1
},
'.area': {
opacity: 0.7
},
'.area:hover': {
opacity: 1
},
'.dot': {
strokeWidth: 0,
opacity: 0.85,
transition: 'cx 0.35s ease-in, cy 0.35s ease-in, r 0.5s ease-in'
},
'.dot:hover': {
opacity: 1
},
'circle.data-point': {
r: 4,
opacity: 0.7,
transition: 'cx 0.35s ease-in, cy 0.35s ease-in'
},
'circle.data-point:hover': {
r: 6,
opacity: 1
},
'circle.tick-circle': {
r: 2,
fill: 'lightgrey'
},
'.x circle.tick-circle': {
cy: '8px'
},
'.axis': {
'font-family': 'dobra-light,Arial,sans-serif',
'font-size': '9px'
},
'.axis .label': {
font: '14px arial'
},
'.axis path, .axis line': {
fill: 'none',
strokeWidth: 1,
'shape-rendering': 'crispEdges'
},
'x.axis path': {
display: 'none',
stroke: 'lightgrey'
},
'.tick line': {
stroke: 'lightgrey',
strokeWidth: 1,
opacity: '0.7'
}
};
function reduce() {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var rVal = args[0];
for (var i = 1; i < args.length; i++) {
rVal -= args[i];
}
return rVal;
}
function createValueGenerator(scale, type, parseDate) {
var dataIndex = scale === 'x' ? 'x' : 'y';
return type === 'time' ? function (d) {
return parseDate(d[dataIndex]);
} : function (d) {
return d[dataIndex];
};
}
function createCircularTicks(containerElement) {
(0, _d.select)(containerElement).select('svg').selectAll('.tick-circle').remove();
var ticks = (0, _d.select)(containerElement).select('svg').selectAll('.tick');
function circleAppender() {
(0, _d.select)(this).append('circle').attr('class', 'tick-circle');
}
ticks.each(circleAppender);
}
function getAxisStyles(grid, verticalGrid, yAxisOrientRight) {
return {
'.x circle.tick-circle ': {
fill: verticalGrid ? 'none' : 'lightgrey'
},
'.y circle.tick-circle': {
cx: yAxisOrientRight ? '+5px' : '-8px',
fill: grid ? 'none' : 'lightgrey'
},
'.y.axis line': {
display: grid ? 'inline' : 'none',
stroke: 'lightgrey'
}
};
}
function createUniqueID(o) {
return (0, _objectHash2.default)(o);
}
function calculateMargin(axes, margin, yAxisOrientRight, y2) {
if (margin) return margin;
if (yAxisOrientRight) {
return axes ? { top: 20, right: 50, bottom: 50, left: y2 ? 50 : 20 } : { top: 0, right: 0, bottom: 0, left: 0 };
}
return axes ? { top: 20, right: y2 ? 50 : 20, bottom: 50, left: 50 } : { top: 0, right: 0, bottom: 0, left: 0 };
}
/* eslint no-shadow: 0 */
function textDomainRange(d, s) {
var a = [];
d.forEach(function (d) {
d.forEach(function (d, i) {
var v = d[s];
if (!a.includes(v)) a.splice(i, 0, v);
});
});
return a;
}
function calculateExtent(data, accessor) {
var lo = void 0; // Low
var hi = void 0; // High
data.forEach(function (item) {
var _extent = (0, _d3Array.extent)(item, accessor);
var _extent2 = (0, _slicedToArray3.default)(_extent, 2);
var LO = _extent2[0];
var HI = _extent2[1];
lo = lo < LO ? lo : LO;
hi = hi > HI ? hi : HI;
});
return [lo, hi];
}
function timeDomainRange(domainRange, parseDate) {
var _domainRange = (0, _slicedToArray3.default)(domainRange, 2);
var LO = _domainRange[0];
var HI = _domainRange[1];
var lo = parseDate(LO);
var hi = parseDate(HI);
return [lo, hi];
}
function calculateDomainRange(domainRange, type, parseDate) {
if (!Array.isArray(domainRange)) return null;
return type === 'time' ? timeDomainRange(domainRange, parseDate) : domainRange;
}
function createDomainRangeGenerator(scale, domainRange, data, type, length, parseDate) {
/*
const dataIndex =
(scale === 'x')
? 'x'
: 'y';
*/
var axis = void 0;
switch (type) {
case 'text':
axis = (0, _d3Scale.scalePoint)();
axis.domain(Array.isArray(domainRange) ? domainRange // calculateDomainRange(domainRange, type, parseDate)
: textDomainRange(data, scale)).range([0, length]).padding(0);
break;
case 'linear':
axis = (0, _d3Scale.scaleLinear)();
axis.domain(Array.isArray(domainRange) ? domainRange // calculateDomainRange(domainRange, type, parseDate)
: calculateExtent(data, createValueGenerator(scale, type, parseDate))).range(scale === 'x' ? [0, length] : [length, 0]);
break;
case 'time':
axis = _d.time.scale();
axis.domain(Array.isArray(domainRange) ? timeDomainRange(domainRange, parseDate) : calculateExtent(data, createValueGenerator(scale, type, parseDate))).range(scale === 'x' ? [0, length] : [length, 0]);
break;
default:
break;
}
return axis;
}
//# sourceMappingURL=shared.js.map |
// Page profile
var _page_profile = undefined;
updatePageProfile();
// Render menus and search box on the left side
renderEnvironmentMenuItems();
renderPartnerMenuItems();
renderSearchBoxWithAutoComplete();
// Events binding
window.onhashchange = _handlerUpdatePage;
// Force the first refresh
_handlerUpdatePage();
|
/*********************************************
* app-src/js/ycfgdb.js
* YeAPF 0.8.52-107 built on 2016-12-01 07:30 (-2 DST)
* Copyright (C) 2004-2016 Esteban Daniel Dortta - dortta@yahoo.com
* 2016-01-23 22:00:19 (-2 DST)
* First Version (C) 2014 - esteban daniel dortta - dortta@yahoo.com
**********************************************/
//# sourceURL=app-src/js/ycfgdb.js
var cfgDBbase = function () {
that = {};
that.getConnParams = function () {
var ret = [];
ret['server'] = ystorage.getItem('server');
ret['user'] = ystorage.getItem('user');
ret['password'] = ystorage.getItem('password');
ret['token'] = ystorage.getItem('token');
return ret;
}
that.setConnParams = function (aParams) {
ystorage.setItem('server' , aParams['server']);
ystorage.setItem('user' , aParams['user']);
ystorage.setItem('password', aParams['password']);
ystorage.setItem('token' , aParams['token']);
}
return that;
}
var cfgDB = cfgDBbase();
|
const EventEmitter = require('events').EventEmitter;
const instance = new EventEmitter();
/**
* Node EventEmitter facade
*/
module.exports = {
on() {
return instance.on.apply(instance, arguments);
},
once() {
return instance.once.apply(instance, arguments);
},
emit() {
return instance.emit.apply(instance, arguments);
},
listenerCount(eventName) {
return instance.listenerCount(eventName);
}
}
|
/*
* Copyright (c) 2012 Adobe Systems Incorporated. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
/*jslint vars: true, plusplus: true, devel: true, nomen: true, indent: 4, maxerr: 50 */
/*global require, define, brackets: true, $, PathUtils, window, navigator, Mustache */
require.config({
paths: {
"text" : "thirdparty/text",
"i18n" : "thirdparty/i18n"
},
// Use custom brackets property until CEF sets the correct navigator.language
// NOTE: When we change to navigator.language here, we also should change to
// navigator.language in ExtensionLoader (when making require contexts for each
// extension).
locale: window.localStorage.getItem("locale") || (typeof (brackets) !== "undefined" ? brackets.app.language : navigator.language)
});
/**
* brackets is the root of the Brackets codebase. This file pulls in all other modules as
* dependencies (or dependencies thereof), initializes the UI, and binds global menus & keyboard
* shortcuts to their Commands.
*
* TODO: (issue #264) break out the definition of brackets into a separate module from the application controller logic
*
* Unlike other modules, this one can be accessed without an explicit require() because it exposes
* a global object, window.brackets.
*/
define(function (require, exports, module) {
"use strict";
// Load dependent non-module scripts
require("widgets/bootstrap-dropdown");
require("widgets/bootstrap-modal");
require("thirdparty/path-utils/path-utils.min");
require("thirdparty/smart-auto-complete/jquery.smart_autocomplete");
// Load LiveDeveopment
require("LiveDevelopment/main");
// Load dependent modules
var Global = require("utils/Global"),
AppInit = require("utils/AppInit"),
ProjectManager = require("project/ProjectManager"),
DocumentManager = require("document/DocumentManager"),
EditorManager = require("editor/EditorManager"),
CSSInlineEditor = require("editor/CSSInlineEditor"),
JSUtils = require("language/JSUtils"),
WorkingSetView = require("project/WorkingSetView"),
WorkingSetSort = require("project/WorkingSetSort"),
DocumentCommandHandlers = require("document/DocumentCommandHandlers"),
FileViewController = require("project/FileViewController"),
FileSyncManager = require("project/FileSyncManager"),
KeyBindingManager = require("command/KeyBindingManager"),
Commands = require("command/Commands"),
CommandManager = require("command/CommandManager"),
CodeHintManager = require("editor/CodeHintManager"),
JSLintUtils = require("language/JSLintUtils"),
PerfUtils = require("utils/PerfUtils"),
FileIndexManager = require("project/FileIndexManager"),
QuickOpen = require("search/QuickOpen"),
Menus = require("command/Menus"),
FileUtils = require("file/FileUtils"),
MainViewHTML = require("text!htmlContent/main-view.html"),
Strings = require("strings"),
Dialogs = require("widgets/Dialogs"),
ExtensionLoader = require("utils/ExtensionLoader"),
SidebarView = require("project/SidebarView"),
Async = require("utils/Async"),
UpdateNotification = require("utils/UpdateNotification"),
UrlParams = require("utils/UrlParams").UrlParams,
NativeFileSystem = require("file/NativeFileSystem").NativeFileSystem,
PreferencesManager = require("preferences/PreferencesManager"),
Resizer = require("utils/Resizer");
// Local variables
var params = new UrlParams(),
PREFERENCES_CLIENT_ID = "com.adobe.brackets.startup";
// read URL params
params.parse();
//Load modules that self-register and just need to get included in the main project
require("document/ChangedDocumentTracker");
require("editor/EditorCommandHandlers");
require("view/ViewCommandHandlers");
require("debug/DebugCommandHandlers");
require("help/HelpCommandHandlers");
require("search/FindInFiles");
require("search/FindReplace");
require("utils/ExtensionUtils");
function _initExtensions() {
// allow unit tests to override which plugin folder(s) to load
var paths = params.get("extensions");
if (!paths) {
paths = "default,dev," + ExtensionLoader.getUserExtensionPath();
}
return Async.doInParallel(paths.split(","), function (item) {
var extensionPath = item;
// If the item has "/" in it, assume it is a full path. Otherwise, load
// from our source path + "/extensions/".
if (item.indexOf("/") === -1) {
extensionPath = FileUtils.getNativeBracketsDirectoryPath() + "/extensions/" + item;
}
return ExtensionLoader.loadAllExtensionsInNativeDirectory(extensionPath);
});
}
function _initTest() {
// TODO: (issue #265) Make sure the "test" object is not included in final builds
// All modules that need to be tested from the context of the application
// must to be added to this object. The unit tests cannot just pull
// in the modules since they would run in context of the unit test window,
// and would not have access to the app html/css.
brackets.test = {
PreferencesManager : require("preferences/PreferencesManager"),
ProjectManager : ProjectManager,
DocumentCommandHandlers : DocumentCommandHandlers,
FileViewController : FileViewController,
DocumentManager : DocumentManager,
EditorManager : EditorManager,
Commands : Commands,
WorkingSetView : WorkingSetView,
JSLintUtils : JSLintUtils,
PerfUtils : PerfUtils,
JSUtils : JSUtils,
CommandManager : require("command/CommandManager"),
FileSyncManager : FileSyncManager,
FileIndexManager : FileIndexManager,
Menus : Menus,
KeyBindingManager : KeyBindingManager,
CodeHintManager : CodeHintManager,
CSSUtils : require("language/CSSUtils"),
LiveDevelopment : require("LiveDevelopment/LiveDevelopment"),
DOMAgent : require("LiveDevelopment/Agents/DOMAgent"),
Inspector : require("LiveDevelopment/Inspector/Inspector"),
NativeApp : require("utils/NativeApp"),
ExtensionUtils : require("utils/ExtensionUtils"),
UpdateNotification : require("utils/UpdateNotification"),
doneLoading : false
};
AppInit.appReady(function () {
brackets.test.doneLoading = true;
});
}
function _initDragAndDropListeners() {
// Prevent unhandled drag and drop of files into the browser from replacing
// the entire Brackets app. This doesn't prevent children from choosing to
// handle drops.
$(window.document.body)
.on("dragover", function (event) {
if (event.originalEvent.dataTransfer.files) {
event.stopPropagation();
event.preventDefault();
event.originalEvent.dataTransfer.dropEffect = "none";
}
})
.on("drop", function (event) {
if (event.originalEvent.dataTransfer.files) {
event.stopPropagation();
event.preventDefault();
}
});
}
function _initCommandHandlers() {
// Most command handlers are automatically registered when their module is loaded (see "modules
// that self-register" above for some). A few commands need an extra kick here though:
DocumentCommandHandlers.init($("#main-toolbar"));
}
function _initWindowListeners() {
// TODO: (issue 269) to support IE, need to listen to document instead (and even then it may not work when focus is in an input field?)
$(window).focus(function () {
FileSyncManager.syncOpenDocuments();
FileIndexManager.markDirty();
});
}
function _onReady() {
// Add the platform (mac or win) to the body tag so we can have platform-specific CSS rules
$("body").addClass("platform-" + brackets.platform);
EditorManager.setEditorHolder($("#editor-holder"));
// Let the user know Brackets doesn't run in a web browser yet
if (brackets.inBrowser) {
Dialogs.showModalDialog(
Dialogs.DIALOG_ID_ERROR,
Strings.ERROR_IN_BROWSER_TITLE,
Strings.ERROR_IN_BROWSER
);
}
_initDragAndDropListeners();
_initCommandHandlers();
KeyBindingManager.init();
Menus.init(); // key bindings should be initialized first
_initWindowListeners();
// Use quiet scrollbars if we aren't on Lion. If we're on Lion, only
// use native scroll bars when the mouse is not plugged in or when
// using the "Always" scroll bar setting.
var osxMatch = /Mac OS X 10\D([\d+])\D/.exec(navigator.userAgent);
if (osxMatch && osxMatch[1] && Number(osxMatch[1]) >= 7) {
// test a scrolling div for scrollbars
var $testDiv = $("<div style='position:fixed;left:-50px;width:50px;height:50px;overflow:auto;'><div style='width:100px;height:100px;'/></div>").appendTo(window.document.body);
if ($testDiv.outerWidth() === $testDiv.get(0).clientWidth) {
$(".sidebar").removeClass("quiet-scrollbars");
}
$testDiv.remove();
}
PerfUtils.addMeasurement("Application Startup");
// finish UI initialization before loading extensions
var initialProjectPath = ProjectManager.getInitialProjectPath();
ProjectManager.openProject(initialProjectPath).always(function () {
_initTest();
// Create a new DirectoryEntry and call getDirectory() on the user extension
// directory. If the directory doesn't exist, it will be created.
// Note that this is an async call and there are no success or failure functions passed
// in. If the directory *doesn't* exist, it will be created. Extension loading may happen
// before the directory is finished being created, but that is okay, since the extension
// loading will work correctly without this directory.
// If the directory *does* exist, nothing else needs to be done. It will be scanned normally
// during extension loading.
var extensionPath = ExtensionLoader.getUserExtensionPath();
new NativeFileSystem.DirectoryEntry().getDirectory(extensionPath,
{create: true});
// Create the extensions/disabled directory, too.
var disabledExtensionPath = extensionPath.replace(/\/user$/, "/disabled");
new NativeFileSystem.DirectoryEntry().getDirectory(disabledExtensionPath,
{create: true});
// Load all extensions, and when done fire APP_READY (even if some extensions failed
// to load or initialize)
_initExtensions().always(function () {
AppInit._dispatchReady(AppInit.APP_READY);
});
// If this is the first launch, and we have an index.html file in the project folder (which should be
// the samples folder on first launch), open it automatically. (We explicitly check for the
// samples folder in case this is the first time we're launching Brackets after upgrading from
// an old version that might not have set the "afterFirstLaunch" pref.)
var prefs = PreferencesManager.getPreferenceStorage(PREFERENCES_CLIENT_ID);
if (!params.get("skipSampleProjectLoad") && !prefs.getValue("afterFirstLaunch")) {
prefs.setValue("afterFirstLaunch", "true");
if (ProjectManager.isWelcomeProjectPath(initialProjectPath)) {
var dirEntry = new NativeFileSystem.DirectoryEntry(initialProjectPath);
dirEntry.getFile("index.html", {}, function (fileEntry) {
CommandManager.execute(Commands.FILE_ADD_TO_WORKING_SET, { fullPath: fileEntry.fullPath });
});
}
}
});
// Check for updates
if (!params.get("skipUpdateCheck") && !brackets.inBrowser) {
UpdateNotification.checkForUpdate();
}
}
// Prevent unhandled middle button clicks from triggering native behavior
// Example: activating AutoScroll (see #510)
$("html").on("mousedown", ".inline-widget", function (e) {
if (e.button === 1) {
e.preventDefault();
}
});
// Localize MainViewHTML and inject into <BODY> tag
var templateVars = $.extend({
ABOUT_ICON : brackets.config.about_icon,
APP_NAME_ABOUT_BOX : brackets.config.app_name_about,
VERSION : brackets.metadata.version
}, Strings);
$("body").html(Mustache.render(MainViewHTML, templateVars));
// Update title
$("title").text(brackets.config.app_title);
// Dispatch htmlReady callbacks
AppInit._dispatchReady(AppInit.HTML_READY);
$(window.document).ready(_onReady);
});
|
'use strict'
/**
* pem module
*
* @module pem
*/
var Buffer = require('safe-buffer').Buffer
var net = require('net')
var helper = require('./helper.js')
var openssl = require('./openssl.js')
module.exports.createPrivateKey = createPrivateKey
module.exports.createDhparam = createDhparam
module.exports.createEcparam = createEcparam
module.exports.createCSR = createCSR
module.exports.createCertificate = createCertificate
module.exports.readCertificateInfo = readCertificateInfo
module.exports.getPublicKey = getPublicKey
module.exports.getFingerprint = getFingerprint
module.exports.getModulus = getModulus
module.exports.getDhparamInfo = getDhparamInfo
module.exports.createPkcs12 = createPkcs12
module.exports.readPkcs12 = readPkcs12
module.exports.verifySigningChain = verifySigningChain
module.exports.checkCertificate = checkCertificate
module.exports.checkPkcs12 = checkPkcs12
module.exports.config = config
/**
* quick access the convert module
* @type {module:convert}
*/
module.exports.convert = require('./convert.js')
var KEY_START = '-----BEGIN PRIVATE KEY-----'
var KEY_END = '-----END PRIVATE KEY-----'
var RSA_KEY_START = '-----BEGIN RSA PRIVATE KEY-----'
var RSA_KEY_END = '-----END RSA PRIVATE KEY-----'
var ENCRYPTED_KEY_START = '-----BEGIN ENCRYPTED PRIVATE KEY-----'
var ENCRYPTED_KEY_END = '-----END ENCRYPTED PRIVATE KEY-----'
var CERT_START = '-----BEGIN CERTIFICATE-----'
var CERT_END = '-----END CERTIFICATE-----'
/**
* Creates a private key
*
* @static
* @param {Number} [keyBitsize=2048] Size of the key, defaults to 2048bit
* @param {Object} [options] object of cipher and password {cipher:'aes128',password:'xxx'}, defaults empty object
* @param {Function} callback Callback function with an error object and {key}
*/
function createPrivateKey (keyBitsize, options, callback) {
if (!callback && !options && typeof keyBitsize === 'function') {
callback = keyBitsize
keyBitsize = undefined
options = {}
} else if (!callback && keyBitsize && typeof options === 'function') {
callback = options
options = {}
}
keyBitsize = Number(keyBitsize) || 2048
var params = ['genrsa']
var delTempPWFiles = []
if (options && options.cipher && (Number(helper.ciphers.indexOf(options.cipher)) !== -1) && options.password) {
helper.createPasswordFile({'cipher': options.cipher, 'password': options.password, 'passType': 'out'}, params, delTempPWFiles[delTempPWFiles.length])
}
params.push(keyBitsize)
openssl.exec(params, 'RSA PRIVATE KEY', function (sslErr, key) {
function done (err) {
if (err) {
return callback(err)
}
callback(null, {
key: key
})
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* Creates a dhparam key
*
* @static
* @param {Number} [keyBitsize=512] Size of the key, defaults to 512bit
* @param {Function} callback Callback function with an error object and {dhparam}
*/
function createDhparam (keyBitsize, callback) {
if (!callback && typeof keyBitsize === 'function') {
callback = keyBitsize
keyBitsize = undefined
}
keyBitsize = Number(keyBitsize) || 512
var params = ['dhparam',
'-outform',
'PEM',
keyBitsize
]
openssl.exec(params, 'DH PARAMETERS', function (error, dhparam) {
if (error) {
return callback(error)
}
return callback(null, {
dhparam: dhparam
})
})
}
/**
* Creates a ecparam key
* @static
* @param {String} [keyName=secp256k1] Name of the key, defaults to secp256k1
* @param {Function} callback Callback function with an error object and {ecparam}
*/
function createEcparam (keyName, callback) {
if (!callback && typeof keyName === 'function') {
callback = keyName
keyName = undefined
}
keyName = keyName || 'secp256k1'
var params = ['ecparam',
'-name',
keyName,
'-genkey',
'-param_enc',
'explicit'
]
openssl.exec(params, 'EC PARAMETERS', function (error, ecparam) {
if (error) {
return callback(error)
}
return callback(null, {
ecparam: ecparam
})
})
}
/**
* Creates a Certificate Signing Request
* If client key is undefined, a new key is created automatically. The used key is included
* in the callback return as clientKey
* @static
* @param {Object} [options] Optional options object
* @param {String} [options.clientKey] Optional client key to use
* @param {Number} [options.keyBitsize] If clientKey is undefined, bit size to use for generating a new key (defaults to 2048)
* @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
* @param {String} [options.country] CSR country field
* @param {String} [options.state] CSR state field
* @param {String} [options.locality] CSR locality field
* @param {String} [options.organization] CSR organization field
* @param {String} [options.organizationUnit] CSR organizational unit field
* @param {String} [options.commonName='localhost'] CSR common name field
* @param {String} [options.emailAddress] CSR email address field
* @param {String} [options.csrConfigFile] CSR config file
* @param {Array} [options.altNames] is a list of subjectAltNames in the subjectAltName field
* @param {Function} callback Callback function with an error object and {csr, clientKey}
*/
function createCSR (options, callback) {
if (!callback && typeof options === 'function') {
callback = options
options = undefined
}
options = options || {}
// http://stackoverflow.com/questions/14089872/why-does-node-js-accept-ip-addresses-in-certificates-only-for-san-not-for-cn
if (options.commonName && (net.isIPv4(options.commonName) || net.isIPv6(options.commonName))) {
if (!options.altNames) {
options.altNames = [options.commonName]
} else if (options.altNames.indexOf(options.commonName) === -1) {
options.altNames = options.altNames.concat([options.commonName])
}
}
if (!options.clientKey) {
createPrivateKey(options.keyBitsize || 2048, function (error, keyData) {
if (error) {
return callback(error)
}
options.clientKey = keyData.key
createCSR(options, callback)
})
return
}
var params = ['req',
'-new',
'-' + (options.hash || 'sha256')
]
if (options.csrConfigFile) {
params.push('-config')
params.push(options.csrConfigFile)
} else {
params.push('-subj')
params.push(generateCSRSubject(options))
}
params.push('-key')
params.push('--TMPFILE--')
var tmpfiles = [options.clientKey]
var config = null
if (options.altNames && Array.isArray(options.altNames) && options.altNames.length) {
params.push('-extensions')
params.push('v3_req')
params.push('-config')
params.push('--TMPFILE--')
var altNamesRep = []
for (var i = 0; i < options.altNames.length; i++) {
altNamesRep.push((net.isIP(options.altNames[i]) ? 'IP' : 'DNS') + '.' + (i + 1) + ' = ' + options.altNames[i])
}
tmpfiles.push(config = [
'[req]',
'req_extensions = v3_req',
'distinguished_name = req_distinguished_name',
'[v3_req]',
'subjectAltName = @alt_names',
'[alt_names]',
altNamesRep.join('\n'),
'[req_distinguished_name]',
'commonName = Common Name',
'commonName_max = 64'
].join('\n'))
} else if (options.config) {
config = options.config
}
var delTempPWFiles = []
if (options.clientKeyPassword) {
helper.createPasswordFile({'cipher': '', 'password': options.clientKeyPassword, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
openssl.exec(params, 'CERTIFICATE REQUEST', tmpfiles, function (sslErr, data) {
function done (err) {
if (err) {
return callback(err)
}
callback(null, {
csr: data,
config: config,
clientKey: options.clientKey
})
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* Creates a certificate based on a CSR. If CSR is not defined, a new one
* will be generated automatically. For CSR generation all the options values
* can be used as with createCSR.
* @static
* @param {Object} [options] Optional options object
* @param {String} [options.serviceKey] Private key for signing the certificate, if not defined a new one is generated
* @param {String} [options.serviceKeyPassword] Password of the service key
* @param {Boolean} [options.selfSigned] If set to true and serviceKey is not defined, use clientKey for signing
* @param {String|Number} [options.serial] Set a serial max. 20 octets - only together with options.serviceCertificate
* @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
* @param {String} [options.csr] CSR for the certificate, if not defined a new one is generated
* @param {Number} [options.days] Certificate expire time in days
* @param {String} [options.clientKeyPassword] Password of the client key
* @param {String} [options.extFile] extension config file - without '-extensions v3_req'
* @param {String} [options.config] extension config file - with '-extensions v3_req'
* @param {Function} callback Callback function with an error object and {certificate, csr, clientKey, serviceKey}
*/
function createCertificate (options, callback) {
if (!callback && typeof options === 'function') {
callback = options
options = undefined
}
options = options || {}
if (!options.csr) {
createCSR(options, function (error, keyData) {
if (error) {
return callback(error)
}
options.csr = keyData.csr
options.config = keyData.config
options.clientKey = keyData.clientKey
createCertificate(options, callback)
})
return
}
if (!options.serviceKey) {
if (options.selfSigned) {
options.serviceKey = options.clientKey
} else {
createPrivateKey(options.keyBitsize || 2048, function (error, keyData) {
if (error) {
return callback(error)
}
options.serviceKey = keyData.key
createCertificate(options, callback)
})
return
}
}
var params = ['x509',
'-req',
'-' + (options.hash || 'sha256'),
'-days',
Number(options.days) || '365',
'-in',
'--TMPFILE--'
]
var tmpfiles = [options.csr]
var delTempPWFiles = []
if (options.serviceCertificate) {
params.push('-CA')
params.push('--TMPFILE--')
params.push('-CAkey')
params.push('--TMPFILE--')
if (options.serial) {
params.push('-set_serial')
if (helper.isNumber(options.serial)) {
// set the serial to the max lenth of 20 octets ()
// A certificate serial number is not decimal conforming. That is the
// bytes in a serial number do not necessarily map to a printable ASCII
// character.
// eg: 0x00 is a valid serial number and can not be represented in a
// human readable format (atleast one that can be directly mapped to
// the ACSII table).
params.push('0x' + ('0000000000000000000000000000000000000000' + options.serial.toString(16)).slice(-40))
} else {
if (helper.isHex(options.serial)) {
if (options.serial.startsWith('0x')) {
options.serial = options.serial.substring(2, options.serial.length)
}
params.push('0x' + ('0000000000000000000000000000000000000000' + options.serial).slice(-40))
} else {
params.push('0x' + ('0000000000000000000000000000000000000000' + helper.toHex(options.serial)).slice(-40))
}
}
} else {
params.push('-CAcreateserial')
}
if (options.serviceKeyPassword) {
helper.createPasswordFile({'cipher': '', 'password': options.serviceKeyPassword, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
tmpfiles.push(options.serviceCertificate)
tmpfiles.push(options.serviceKey)
} else {
params.push('-signkey')
params.push('--TMPFILE--')
if (options.serviceKeyPassword) {
helper.createPasswordFile({'cipher': '', 'password': options.serviceKeyPassword, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
tmpfiles.push(options.serviceKey)
}
if (options.config) {
params.push('-extensions')
params.push('v3_req')
params.push('-extfile')
params.push('--TMPFILE--')
tmpfiles.push(options.config)
} else if (options.extFile) {
params.push('-extfile')
params.push(options.extFile)
}
if (options.clientKeyPassword) {
helper.createPasswordFile({'cipher': '', 'password': options.clientKeyPassword, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
openssl.exec(params, 'CERTIFICATE', tmpfiles, function (sslErr, data) {
function done (err) {
if (err) {
return callback(err)
}
var response = {
csr: options.csr,
clientKey: options.clientKey,
certificate: data,
serviceKey: options.serviceKey
}
return callback(null, response)
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* Exports a public key from a private key, CSR or certificate
* @static
* @param {String} certificate PEM encoded private key, CSR or certificate
* @param {Function} callback Callback function with an error object and {publicKey}
*/
function getPublicKey (certificate, callback) {
if (!callback && typeof certificate === 'function') {
callback = certificate
certificate = undefined
}
certificate = (certificate || '').toString()
var params
if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
params = ['req',
'-in',
'--TMPFILE--',
'-pubkey',
'-noout'
]
} else if (certificate.match(/BEGIN RSA PRIVATE KEY/)) {
params = ['rsa',
'-in',
'--TMPFILE--',
'-pubout'
]
} else {
params = ['x509',
'-in',
'--TMPFILE--',
'-pubkey',
'-noout'
]
}
openssl.exec(params, 'PUBLIC KEY', certificate, function (error, key) {
if (error) {
return callback(error)
}
return callback(null, {
publicKey: key
})
})
}
/**
* Reads subject data from a certificate or a CSR
* @static
* @param {String} certificate PEM encoded CSR or certificate
* @param {Function} callback Callback function with an error object and {country, state, locality, organization, organizationUnit, commonName, emailAddress}
*/
function readCertificateInfo (certificate, callback) {
if (!callback && typeof certificate === 'function') {
callback = certificate
certificate = undefined
}
certificate = (certificate || '').toString()
var isMatch = certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)
var type = isMatch ? 'req' : 'x509'
var params = [type,
'-noout',
'-nameopt',
'RFC2253,sep_multiline,space_eq',
'-text',
'-in',
'--TMPFILE--'
]
openssl.spawnWrapper(params, certificate, function (err, code, stdout) {
if (err) {
return callback(err)
}
return fetchCertificateData(stdout, callback)
})
}
/**
* get the modulus from a certificate, a CSR or a private key
* @static
* @param {String} certificate PEM encoded, CSR PEM encoded, or private key
* @param {String} [password] password for the certificate
* @param {String} [hash] hash function to use (up to now `md5` supported) (default: none)
* @param {Function} callback Callback function with an error object and {modulus}
*/
function getModulus (certificate, password, hash, callback) {
if (!callback && !hash && typeof password === 'function') {
callback = password
password = undefined
hash = false
} else if (!callback && hash && typeof hash === 'function') {
callback = hash
hash = false
// password will be falsy if not provided
}
// adding hash function to params, is not supported by openssl.
// process piping would be the right way (... | openssl md5)
// No idea how this can be achieved in easy with the current build in methods
// of pem.
if (hash && hash !== 'md5') {
hash = false
}
certificate = (Buffer.isBuffer(certificate) && certificate.toString()) || certificate
var type = ''
if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
type = 'req'
} else if (certificate.match(/BEGIN RSA PRIVATE KEY/) || certificate.match(/BEGIN PRIVATE KEY/)) {
type = 'rsa'
} else {
type = 'x509'
}
var params = [
type,
'-noout',
'-modulus',
'-in',
'--TMPFILE--'
]
var delTempPWFiles = []
if (password) {
helper.createPasswordFile({'cipher': '', 'password': password, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
openssl.spawnWrapper(params, certificate, function (sslErr, code, stdout) {
function done (err) {
if (err) {
return callback(err)
}
var match = stdout.match(/Modulus=([0-9a-fA-F]+)$/m)
if (match) {
return callback(null, {
modulus: hash ? require(hash)(match[1]) : match[1]
})
} else {
return callback(new Error('No modulus'))
}
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* get the size and prime of DH parameters
* @static
* @param {String} DH parameters PEM encoded
* @param {Function} callback Callback function with an error object and {size, prime}
*/
function getDhparamInfo (dh, callback) {
dh = (Buffer.isBuffer(dh) && dh.toString()) || dh
var params = [
'dhparam',
'-text',
'-in',
'--TMPFILE--'
]
openssl.spawnWrapper(params, dh, function (err, code, stdout) {
if (err) {
return callback(err)
}
var result = {}
var match = stdout.match(/Parameters: \((\d+) bit\)/)
if (match) {
result.size = Number(match[1])
}
var prime = ''
stdout.split('\n').forEach(function (line) {
if (/\s+([0-9a-f][0-9a-f]:)+[0-9a-f]?[0-9a-f]?/g.test(line)) {
prime += line.trim()
}
})
if (prime) {
result.prime = prime
}
if (!match && !prime) {
return callback(new Error('No DH info found'))
}
return callback(null, result)
})
}
/**
* config the pem module
* @static
* @param {Object} options
*/
function config (options) {
Object.keys(options).forEach(function (k) {
openssl.set(k, options[k])
})
}
/**
* Gets the fingerprint for a certificate
* @static
* @param {String} PEM encoded certificate
* @param {String} [hash] hash function to use (either `md5`, `sha1` or `sha256`, defaults to `sha1`)
* @param {Function} callback Callback function with an error object and {fingerprint}
*/
function getFingerprint (certificate, hash, callback) {
if (!callback && typeof hash === 'function') {
callback = hash
hash = undefined
}
hash = hash || 'sha1'
var params = ['x509',
'-in',
'--TMPFILE--',
'-fingerprint',
'-noout',
'-' + hash
]
openssl.spawnWrapper(params, certificate, function (err, code, stdout) {
if (err) {
return callback(err)
}
var match = stdout.match(/Fingerprint=([0-9a-fA-F:]+)$/m)
if (match) {
return callback(null, {
fingerprint: match[1]
})
} else {
return callback(new Error('No fingerprint'))
}
})
}
/**
* Export private key and certificate to a PKCS12 keystore
* @static
* @param {String} PEM encoded private key
* @param {String} PEM encoded certificate
* @param {String} Password of the result PKCS12 file
* @param {Object} [options] object of cipher and optional client key password {cipher:'aes128', clientKeyPassword: 'xxxx', certFiles: ['file1','file2']}
* @param {Function} callback Callback function with an error object and {pkcs12}
*/
function createPkcs12 (key, certificate, password, options, callback) {
if (!callback && typeof options === 'function') {
callback = options
options = {}
}
var params = ['pkcs12', '-export']
var delTempPWFiles = []
if (options.cipher && options.clientKeyPassword) {
// NOTICE: The password field is needed! self if it is empty.
// create password file for the import "-passin"
helper.createPasswordFile({'cipher': options.cipher, 'password': options.clientKeyPassword, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
// NOTICE: The password field is needed! self if it is empty.
// create password file for the password "-password"
helper.createPasswordFile({'cipher': '', 'password': password, 'passType': 'word'}, params, delTempPWFiles[delTempPWFiles.length])
params.push('-in')
params.push('--TMPFILE--')
params.push('-inkey')
params.push('--TMPFILE--')
var tmpfiles = [certificate, key]
if (options.certFiles) {
tmpfiles.push(options.certFiles.join(''))
params.push('-certfile')
params.push('--TMPFILE--')
}
openssl.execBinary(params, tmpfiles, function (sslErr, pkcs12) {
function done (err) {
if (err) {
return callback(err)
}
return callback(null, {
pkcs12: pkcs12
})
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* read sslcert data from Pkcs12 file. Results are provided in callback response in object notation ({cert: .., ca:..., key:...})
* @static
* @param {Buffer|String} bufferOrPath Buffer or path to file
* @param {Object} [options] openssl options
* @param {Function} callback Called with error object and sslcert bundle object
*/
function readPkcs12 (bufferOrPath, options, callback) {
if (!callback && typeof options === 'function') {
callback = options
options = {}
}
options.p12Password = options.p12Password || ''
var tmpfiles = []
var delTempPWFiles = []
var args = ['pkcs12', '-in', bufferOrPath]
helper.createPasswordFile({'cipher': '', 'password': options.p12Password, 'passType': 'in'}, args, delTempPWFiles[delTempPWFiles.length])
if (Buffer.isBuffer(bufferOrPath)) {
tmpfiles = [bufferOrPath]
args[2] = '--TMPFILE--'
}
if (options.clientKeyPassword) {
helper.createPasswordFile({'cipher': '', 'password': options.clientKeyPassword, 'passType': 'out'}, args, delTempPWFiles[delTempPWFiles.length])
} else {
args.push('-nodes')
}
openssl.execBinary(args, tmpfiles, function (sslErr, stdout) {
function done (err) {
var keybundle = {}
if (err && err.message.indexOf('No such file or directory') !== -1) {
err.code = 'ENOENT'
}
if (!err) {
var certs = readFromString(stdout, CERT_START, CERT_END)
keybundle.cert = certs.shift()
keybundle.ca = certs
keybundle.key = readFromString(stdout, KEY_START, KEY_END).pop()
if (keybundle.key) {
// convert to RSA key
return openssl.exec(['rsa', '-in', '--TMPFILE--'], 'RSA PRIVATE KEY', [keybundle.key], function (err, key) {
keybundle.key = key
return callback(err, keybundle)
})
}
if (options.clientKeyPassword) {
keybundle.key = readFromString(stdout, ENCRYPTED_KEY_START, ENCRYPTED_KEY_END).pop()
} else {
keybundle.key = readFromString(stdout, RSA_KEY_START, RSA_KEY_END).pop()
}
}
return callback(err, keybundle)
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* Check a certificate
* @static
* @param {String} PEM encoded certificate
* @param {String} [passphrase] password for the certificate
* @param {Function} callback Callback function with an error object and a boolean valid
*/
function checkCertificate (certificate, passphrase, callback) {
var params
var delTempPWFiles = []
if (!callback && typeof passphrase === 'function') {
callback = passphrase
passphrase = undefined
}
certificate = (certificate || '').toString()
if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
params = ['req', '-text', '-noout', '-verify', '-in', '--TMPFILE--']
} else if (certificate.match(/BEGIN RSA PRIVATE KEY/) || certificate.match(/BEGIN PRIVATE KEY/)) {
params = ['rsa', '-noout', '-check', '-in', '--TMPFILE--']
} else {
params = ['x509', '-text', '-noout', '-in', '--TMPFILE--']
}
if (passphrase) {
helper.createPasswordFile({'cipher': '', 'password': passphrase, 'passType': 'in'}, params, delTempPWFiles[delTempPWFiles.length])
}
openssl.spawnWrapper(params, certificate, function (sslErr, code, stdout) {
function done (err) {
if (err) {
return callback(err)
}
var result
switch (params[0]) {
case 'rsa':
result = /^Rsa key ok$/i.test(stdout.trim())
break
default:
result = /Signature Algorithm/im.test(stdout)
break
}
callback(null, result)
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* check a PKCS#12 file (.pfx or.p12)
* @static
* @param {Buffer|String} bufferOrPath PKCS#12 certificate
* @param {String} [passphrase] optional passphrase which will be used to open the keystore
* @param {Function} callback Callback function with an error object and a boolean valid
*/
function checkPkcs12 (bufferOrPath, passphrase, callback) {
if (!callback && typeof passphrase === 'function') {
callback = passphrase
passphrase = ''
}
var tmpfiles = []
var delTempPWFiles = []
var args = ['pkcs12', '-info', '-in', bufferOrPath, '-noout', '-maciter', '-nodes']
helper.createPasswordFile({'cipher': '', 'password': passphrase, 'passType': 'in'}, args, delTempPWFiles[delTempPWFiles.length])
if (Buffer.isBuffer(bufferOrPath)) {
tmpfiles = [bufferOrPath]
args[3] = '--TMPFILE--'
}
openssl.spawnWrapper(args, tmpfiles, function (sslErr, code, stdout, stderr) {
function done (err) {
if (err) {
return callback(err)
}
callback(null, (/MAC verified OK/im.test(stderr) || (!(/MAC verified OK/im.test(stderr)) && !(/Mac verify error/im.test(stderr)))))
}
helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
done(sslErr || fsErr)
})
})
}
/**
* Verifies the signing chain of the passed certificate
* @static
* @param {String|Array} PEM encoded certificate include intermediate certificates
* @param {String|Array} [List] of CA certificates
* @param {Function} callback Callback function with an error object and a boolean valid
*/
function verifySigningChain (certificate, ca, callback) {
if (!callback && typeof ca === 'function') {
callback = ca
ca = undefined
}
if (!Array.isArray(certificate)) {
certificate = [certificate]
}
if (!Array.isArray(ca) && ca !== undefined) {
if (ca !== '') {
ca = [ca]
}
}
var files = []
if (ca !== undefined) {
// ca certificates
files.push(ca.join('\n'))
}
// certificate incl. intermediate certificates
files.push(certificate.join('\n'))
var params = ['verify']
if (ca !== undefined) {
// ca certificates
params.push('-CAfile')
params.push('--TMPFILE--')
}
// certificate incl. intermediate certificates
params.push('--TMPFILE--')
openssl.spawnWrapper(params, files, function (err, code, stdout) {
if (err) {
return callback(err)
}
callback(null, stdout.trim().slice(-4) === ': OK')
})
}
// HELPER FUNCTIONS
function fetchCertificateData (certData, callback) {
certData = (certData || '').toString()
var serial, subject, tmp, issuer
var certValues = {
issuer: {}
}
var validity = {}
var san
// serial
if ((serial = certData.match(/\s*Serial Number:\r?\n?\s*([^\r\n]*)\r?\n\s*\b/)) && serial.length > 1) {
certValues.serial = serial[1]
}
if ((subject = certData.match(/\s*Subject:\r?\n(\s*((C|L|O|OU|ST|CN|DC|emailAddress)\s=\s[^\r\n]+\r?\n))*\s*\b/)) && subject.length > 1) {
subject = subject[0]
// country
tmp = subject.match(/\sC\s=\s([^\r\n].*?)[\r\n]/)
certValues.country = (tmp && tmp[1]) || ''
// state
tmp = subject.match(/\sST\s=\s([^\r\n].*?)[\r\n]/)
certValues.state = (tmp && tmp[1]) || ''
// locality
tmp = subject.match(/\sL\s=\s([^\r\n].*?)[\r\n]/)
certValues.locality = (tmp && tmp[1]) || ''
// organization
tmp = matchAll(subject, /\sO\s=\s([^\r\n].*)/g)
certValues.organization = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// unit
tmp = matchAll(subject, /\sOU\s=\s([^\r\n].*)/g)
certValues.organizationUnit = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// common name
tmp = matchAll(subject, /\sCN\s=\s([^\r\n].*)/g)
certValues.commonName = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// email
tmp = matchAll(subject, /emailAddress\s=\s([^\r\n].*)/g)
certValues.emailAddress = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// DC name
tmp = matchAll(subject, /\sDC\s=\s([^\r\n].*)/g)
certValues.dc = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
}
if ((issuer = certData.match(/\s*Issuer:\r?\n(\s*(C|L|O|OU|ST|CN|DC|emailAddress)\s=\s[^\r\n].*\r?\n)*\s*\b/)) && issuer.length > 1) {
issuer = issuer[0]
// country
tmp = issuer.match(/\sC\s=\s([^\r\n].*?)[\r\n]/)
certValues.issuer.country = (tmp && tmp[1]) || ''
// state
tmp = issuer.match(/\sST\s=\s([^\r\n].*?)[\r\n]/)
certValues.issuer.state = (tmp && tmp[1]) || ''
// locality
tmp = issuer.match(/\sL\s=\s([^\r\n].*?)[\r\n]/)
certValues.issuer.locality = (tmp && tmp[1]) || ''
// organization
tmp = matchAll(issuer, /\sO\s=\s([^\r\n].*)/g)
certValues.issuer.organization = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// unit
tmp = matchAll(issuer, /\sOU\s=\s([^\r\n].*)/g)
certValues.issuer.organizationUnit = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var
r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// common name
tmp = matchAll(issuer, /\sCN\s=\s([^\r\n].*)/g)
certValues.issuer.commonName = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var
r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
// DC name
tmp = matchAll(issuer, /\sDC\s=\s([^\r\n].*)/g)
certValues.issuer.dc = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
var e = t[1].toUpperCase()
var
r = n[1].toUpperCase()
return r > e ? -1 : e > r ? 1 : 0
}).sort(function (t, n) {
return t[1].length - n[1].length
}).map(function (t) {
return t[1]
}) : tmp[0][1]) : ''
}
// SAN
if ((san = certData.match(/X509v3 Subject Alternative Name: \r?\n([^\r\n]*)\r?\n/)) && san.length > 1) {
san = san[1].trim() + '\n'
certValues.san = {}
// hostnames
tmp = pregMatchAll('DNS:([^,\\r\\n].*?)[,\\r\\n]', san)
certValues.san.dns = tmp || ''
// IP-Addresses IPv4 & IPv6
tmp = pregMatchAll('IP Address:([^,\\r\\n].*?)[,\\r\\n\\s]', san)
certValues.san.ip = tmp || ''
}
// Validity
if ((tmp = certData.match(/Not Before\s?:\s?([^\r\n]*)\r?\n/)) && tmp.length > 1) {
validity.start = Date.parse((tmp && tmp[1]) || '')
}
if ((tmp = certData.match(/Not After\s?:\s?([^\r\n]*)\r?\n/)) && tmp.length > 1) {
validity.end = Date.parse((tmp && tmp[1]) || '')
}
if (validity.start && validity.end) {
certValues.validity = validity
}
// Validity end
// Signature Algorithm
if ((tmp = certData.match(/Signature Algorithm: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
certValues.signatureAlgorithm = (tmp && tmp[1]) || ''
}
// Public Key
if ((tmp = certData.match(/Public[ -]Key: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
certValues.publicKeySize = ((tmp && tmp[1]) || '').replace(/[()]/g, '')
}
// Public Key Algorithm
if ((tmp = certData.match(/Public Key Algorithm: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
certValues.publicKeyAlgorithm = (tmp && tmp[1]) || ''
}
callback(null, certValues)
}
function matchAll (str, regexp) {
var matches = []
str.replace(regexp, function () {
var arr = ([]).slice.call(arguments, 0)
var extras = arr.splice(-2)
arr.index = extras[0]
arr.input = extras[1]
matches.push(arr)
})
return matches.length ? matches : null
}
function pregMatchAll (regex, haystack) {
var globalRegex = new RegExp(regex, 'g')
var globalMatch = haystack.match(globalRegex) || []
var matchArray = []
var nonGlobalRegex, nonGlobalMatch
for (var i = 0; i < globalMatch.length; i++) {
nonGlobalRegex = new RegExp(regex)
nonGlobalMatch = globalMatch[i].match(nonGlobalRegex)
matchArray.push(nonGlobalMatch[1])
}
return matchArray
}
function generateCSRSubject (options) {
options = options || {}
var csrData = {
C: options.country || options.C,
ST: options.state || options.ST,
L: options.locality || options.L,
O: options.organization || options.O,
OU: options.organizationUnit || options.OU,
CN: options.commonName || options.CN || 'localhost',
DC: options.dc || options.DC || '',
emailAddress: options.emailAddress
}
var csrBuilder = Object.keys(csrData).map(function (key) {
if (csrData[key]) {
if (typeof csrData[key] === 'object' && csrData[key].length >= 1) {
var tmpStr = ''
csrData[key].map(function (o) {
tmpStr += '/' + key + '=' + o.replace(/[^\w .*\-,@']+/g, ' ').trim()
})
return tmpStr
} else {
return '/' + key + '=' + csrData[key].replace(/[^\w .*\-,@']+/g, ' ').trim()
}
}
})
return csrBuilder.join('')
}
function readFromString (string, start, end) {
if (Buffer.isBuffer(string)) {
string = string.toString('utf8')
}
var output = []
if (!string) {
return output
}
var offset = string.indexOf(start)
while (offset !== -1) {
string = string.substring(offset)
var endOffset = string.indexOf(end)
if (endOffset === -1) {
break
}
endOffset += end.length
output.push(string.substring(0, endOffset))
offset = string.indexOf(start, endOffset)
}
return output
}
|
gameProjectionCurrentGame = null;
function gameProjection(){
this.arrayWorldInformation = null;
this.canvasCanvas = document.getElementById("gameBoard");
this.contextContext = this.canvasCanvas.getContext("2d");
this.intSelection = new point(0, 0);
this.pointHover = new point(0, 0);
this.pointSelection = new point(-1, -1);//a negative value means no selection
this.intGameStartedAt = new Date().getTime();// to measure the time since the game has started
//a proximity the time since this gameProjection was created, but the real time is coming from the Server
this.humanCivilization = new humanCivilization();// from both/civilization
//at the moment just one civilization
this.intAnimationTime = 333;
//load the needed images
this.arrayImages = new Array();
//planets
this.arrayImages["planet00"] = new Image();
this.arrayImages["planet00"].src = "../Images/planet00.png"
this.arrayImages["planet01"] = new Image();
this.arrayImages["planet01"].src = "../Images/planet01.png"
this.arrayImages["planet02"] = new Image();
this.arrayImages["planet02"].src = "../Images/planet02.png"
this.arrayImages["planet03"] = new Image();
this.arrayImages["planet03"].src = "../Images/planet03.png"
this.arrayImages["explosion0"] = new Image();
this.arrayImages["explosion0"].src = "../Images/explosion0.png"
this.arrayImages["explosion1"] = new Image();
this.arrayImages["explosion1"].src = "../Images/explosion1.png"
this.arrayImages["explosion2"] = new Image();
this.arrayImages["explosion2"].src = "../Images/explosion2.png"
this.arrayImages["explosion3"] = new Image();
this.arrayImages["explosion3"].src = "../Images/explosion3.png"
this.arrayImages["explosion4"] = new Image();
this.arrayImages["explosion4"].src = "../Images/explosion4.png"
this.arrayImages["explosion5"] = new Image();
this.arrayImages["explosion5"].src = "../Images/explosion5.png"
this.arrayImages["explosion6"] = new Image();
this.arrayImages["explosion6"].src = "../Images/explosion6.png"
this.arrayImages["explosion7"] = new Image();
this.arrayImages["explosion7"].src = "../Images/explosion7.png"
this.arrayImages["explosion8"] = new Image();
this.arrayImages["explosion8"].src = "../Images/explosion8.png"
intTestDistance = 2;
//for the bord
this.contextContext.fillHexagon = function(intX, intY, intWidth, intHeight){
this.beginPath();
//order:
// 1
//6 2
//5 3
// 4
//1
this.moveTo(intX + intWidth/2, intY);
//2
this.lineTo(intX + intWidth, intY + intHeight*(1/4))
//3
this.lineTo(intX + intWidth, intY + intHeight*(3/4))
//4
this.lineTo(intX + intWidth/2, intY + intHeight)
//5
this.lineTo(intX, intY + intHeight*(3/4))
//6
this.lineTo(intX, intY + intHeight*(1/4))
//1
this.lineTo(intX + intWidth/2, intY);
this.closePath();
this.fill()
this.stroke()
}
document.getElementById("lobbyUi").style.visibility = "hidden"
document.getElementById("game").style.visibility = "visible"
this.getTroopIdByPosition = function(pointPosition){
arrayTroops = this.arrayWorldInformation["troops"]
for (var i = 0; i < arrayTroops.length; i++) {//check all troops if the position machetes
if(arrayTroops[i]["positionX"] == pointPosition.intX && arrayTroops[i]["positionY"] == pointPosition.intY){
//if the troop match return the id
return i;
}
}
return null;
}
this.getPlanetIdByPosition = function(pointPosition){
arrayPlanets = this.arrayWorldInformation["planets"]
for (var i = 0; i < arrayPlanets.length; i++) {//check all troops if the position machetes
if(arrayPlanets[i]["positionX"] == pointPosition.intX && arrayPlanets[i]["positionY"] == pointPosition.intY){
//if the troop match return the id
return i;
}
}
return null;
}
//mousemove Event
this.onMouseMove = function(eventE){
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
//mouse position
var intX = eventE.clientX;
var intY = eventE.clientY;
var pointMouse = new point(intX, intY);
//check all hexagons if the mouse collide
for (var intX = 0; intX < intMapWidth; intX++) {
for (var intY = 0; intY < intMapHeight; intY++) {
var hexagonCurrent = new hexagon(
intX*intHexWidth + (intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
if(hexagonCurrent.collisionWithPoint(pointMouse)){
this.pointHover = new point(intX, intY);
}
};
};
strInfoHTML = "";
//set the info about the troop if there is one
if(this.getTroopIdByPosition(this.pointHover) != null){
intTroopId = this.getTroopIdByPosition(this.pointHover)
strInfoHTML+= "-- Troop --<br>";
strInfoHTML+= "size: " + this.arrayWorldInformation["troops"][intTroopId]["size"] + "<br>";
strInfoHTML+= "technology: " + this.arrayWorldInformation["troops"][intTroopId]["technicLevel"] + "<br>";
strInfoHTML+= "morale: " + this.arrayWorldInformation["troops"][intTroopId]["morale"] + "<br>";
}
//set the planet Info if there is one
if(this.getPlanetIdByPosition(this.pointHover) != null){
intPlanetId = this.getPlanetIdByPosition(this.pointHover)
strInfoHTML += "<br>-- Planet --<br>" ;
strInfoHTML += "population: " + this.arrayWorldInformation["planets"][intPlanetId]["population"] + " billion <br>";
strInfoHTML += "knowledge: ";
intKnowledge = this.arrayWorldInformation["planets"][intPlanetId]["knowledge"]
//schow ++ + o - -- instead of number
if(intKnowledge == 10 || intKnowledge == 9 ){
strInfoHTML += "++<br>" ;
}else if(intKnowledge == 8 || intKnowledge == 7 ){
strInfoHTML += "+<br>" ;
}else if(intKnowledge == 6 || intKnowledge == 5 ){
strInfoHTML += "o<br>" ;
}else if(intKnowledge == 4 || intKnowledge == 3 ){
strInfoHTML += "-<br>" ;
}else{
strInfoHTML += "--<br>" ;
}
strInfoHTML += "recovery factor: " + this.arrayWorldInformation["planets"][intPlanetId]["recoveryFactor"];
}
if(strInfoHTML == ""){
//if there is no info
document.getElementById("HoverInfo").innerHTML = " hover over a troop or planet";
}else{
document.getElementById("HoverInfo").innerHTML = strInfoHTML;
}
}
//if the player clicks on end Turn
this.endTurn = function(){
strJson = '{ "type": "GAMECOMMAND", "command": "ENDTURN" }'
sendToServer(strJson)
}
//to leave the game
this.leaveGame = function(){
//send command to Server
strJson = '{ "type": "GAMECOMMAND", "command": "LEAVEGAME" }'
sendToServer(strJson);
// make Lobby visible
document.getElementById("lobbyUi").style.visibility = "visible"
document.getElementById("game").style.visibility = "hidden"
//delete this game
gameProjectionCurrentGame = null;
}
//to surrender
this.surrender = function(){
strJson = '{ "type": "GAMECOMMAND", "command": "SURRENDER" }'
sendToServer(strJson);//send command to Server
}
this.onMouseDown = function(eventE){//the click event
//console.log("click");
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
//mouse position
var intX = eventE.clientX;
var intY = eventE.clientY;
var pointMouse = new point(intX, intY);
//check all hexagons if the mouse collide
for (var intX = 0; intX < intMapWidth; intX++) {
for (var intY = 0; intY < intMapHeight; intY++) {
var hexagonCurrent = new hexagon(
intX*intHexWidth + (intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
if(hexagonCurrent.collisionWithPoint(pointMouse)){
//if it collide check if there is a troop
console.log("click at: " + intX + "|" + intY);
//all conditions that have to be complied to select a troop
if(this.getTroopIdByPosition(new point(intX, intY)) != null){//for anti error
var arrayTroop = this.arrayWorldInformation["troops"][this.getTroopIdByPosition(new point(intX, intY))];
//all conditions that have to be complied to select a troop
var boolHasTroopOnIt = true;
var boolIsYours = arrayTroop["player"] == this.arrayWorldInformation["youAre"];
var boolMoveAble = arrayTroop["moveAble"];
var boolYourTurn = this.arrayWorldInformation["moveOf"] == this.arrayWorldInformation["youAre"];
var boolTroopIsSelected = this.getTroopIdByPosition(this.pointSelection) != null;
}else{
var boolHasTroopOnIt = false;
var boolIsYours = false;
var boolMoveAble = false;
var boolYourTurn = false;
var boolTroopIsSelected = false;
}
console.log(boolHasTroopOnIt + " " +boolIsYours + " " +boolMoveAble + " " +boolYourTurn);
if(this.pointSelection.equal(new point(intX, intY))){//if you click twice on the same location
this.pointSelection = new point(-1, -1);
}else if(boolHasTroopOnIt && boolIsYours && boolMoveAble && boolYourTurn && !boolTroopIsSelected){
this.pointSelection = new point(intX, intY);
}else if(this.getTroopIdByPosition(this.pointSelection) != null){//if the player don't click on a troop and there is a selection
//get the id of the current selected troop
intTroopId = this.getTroopIdByPosition(this.pointSelection);
//send a Move command to the Server
console.log("moveto: " + intX + "|" + intY);
strJson = '{ "type": "GAMECOMMAND", "command": "MOVE", "troopId": ' + intTroopId + ', "newX" : ' + intX + ', "newY" : ' + intY + '}'
sendToServer(strJson)
this.pointSelection = new point(-1, -1);
}
}
};
};
}
floatTimer = 0;
this.draw = function(){
//calculate the time
var intPastTime = this.arrayWorldInformation["pastTime"];
//calculate back the starting time
var intStartTime = (new Date().getTime()) - intPastTime;
//if the time is older than the a proximate start time: replace it because you have a better connection now.
if(this.intGameStartedAt >= intStartTime){
this.intGameStartedAt = intStartTime;
}
//fit the canvas size (width)
this.canvasCanvas.width = this.canvasCanvas.offsetWidth;
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
//fit the canvas size (height)
this.canvasCanvas.height = (intMapHeight*0.75) * intHexHeight + intHexHeight*0.25;
this.canvasCanvas.style.height = ((intMapHeight*0.75) * intHexHeight + intHexHeight*0.25) + "px";
this.contextContext.fillStyle = "black"
this.contextContext.fillRect(0, 0, this.canvasCanvas.width, this.canvasCanvas.height)
this.contextContext.fillStyle = "rgba(255, 255, 255, 0)"
this.contextContext.strokeStyle = "rgba(0, 255, 0, 0.1)"
//draw all Hexagons
for (var intX = 0; intX < intMapWidth; intX++) {
for (var intY = 0; intY < intMapHeight; intY++) {
var pointCurrentHexagon = new point(intX, intY);//the position as point
var floatAlphaValue = 0;//how much nontransparent is the current Hexagon. Depends on hover, selection and co.
if(this.pointHover.equal(pointCurrentHexagon)){
//hover
floatAlphaValue+=0.3;
}
if(this.getTroopIdByPosition(this.pointSelection) != null){
//only if the selection effects a troop.
var intTroopId = this.getTroopIdByPosition(this.pointSelection);
//find out which technicLevel the troop has because it says how many fields the Troop can move.
intTechnicLevel = Math.floor(this.arrayWorldInformation["troops"][intTroopId]["technicLevel"]);
if(this.pointSelection.equal(pointCurrentHexagon) || (new hexagonalGrid().areXAwayNeighbor(this.pointSelection, pointCurrentHexagon, intTechnicLevel)) ){
//selection
floatAlphaValue+=0.3;
}
}
this.contextContext.fillStyle = "rgba(0, 255, 0, " + floatAlphaValue + ")"
this.contextContext.fillHexagon(
intX*intHexWidth + (intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
};
};
//draw the planets
var arrayPlanets = this.arrayWorldInformation["planets"]
for (var i = 0; i < arrayPlanets.length; i++) {
//fit the image
if(arrayPlanets[i]["player"] == 0){//player1 is blue and player2 is red
this.contextContext.fillStyle = "rgb(255, 100, 100)"
}else if(arrayPlanets[i]["player"] == 1){
this.contextContext.fillStyle = "rgb(100, 100, 255)"
}else{
this.contextContext.fillStyle = "gray"
}
var intX = arrayPlanets[i]["positionX"];
var intY = arrayPlanets[i]["positionY"];
//select the Image for the plant
arrayPlanetImageNames = new Array("planet00", "planet01", "planet02", "planet03");
strPlanetImageName = arrayPlanetImageNames[i%4];
//draw the planet
this.contextContext.drawImage(
this.arrayImages[strPlanetImageName],
intX*intHexWidth + (intY%2)*intHexWidth/2 +intHexWidth/4,//every 2ed line has to be a bit more to the right, make the Rect a bit smaller.
intY*intHexHeight*(3/4) +intHexHeight/4,//make the Rect a bit smaller.
intHexWidth - 2 * intHexWidth/4,//make the Rect a bit smaller.
intHexHeight- 2 * intHexHeight/4)//make the Rect a bit smaller.
};
//draw the troops
var arrayTroops = this.arrayWorldInformation["troops"]
for (var i = 0; i < arrayTroops.length; i++) {
//check if this ship has an animation
boolHasAnimation = false;
for (var a = 0; a < this.arrayWorldInformation["animation"].length; a++) {
intAnimationRuntime = ((new Date().getTime()) - this.intGameStartedAt ) - (this.arrayWorldInformation["animation"][a]["startTime"]);
//if the ship has an animation that is less than 1 sec old
if(this.arrayWorldInformation["animation"][a]["shipId"] == i && intAnimationRuntime <= 1000){
boolHasAnimation = true;
}
};
var intX = arrayTroops[i]["positionX"];
var intY = arrayTroops[i]["positionY"];
if(!boolHasAnimation){//only if there is no animation
//draw the Image
this.contextContext.drawImage(
this.humanCivilization.getTroopImage(arrayTroops[i]),
intX*intHexWidth + (intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
}
};
//draw all jump animations
for (var a = 0; a < this.arrayWorldInformation["animation"].length; a++) {
var objCurrentAnimation = this.arrayWorldInformation["animation"][a];
//calculate oldness
intAnimationRuntime = ((new Date().getTime()) - this.intGameStartedAt ) - (objCurrentAnimation["startTime"]);
//if an animation that is less than 1 sec old
if(intAnimationRuntime <= 1000 && objCurrentAnimation["type"] == "JUMP"){// --- a jumping ship
//draw the jump
var floatTimer = intAnimationRuntime; //get time for animation
var pointFrom = new point(objCurrentAnimation["startPositionX"], objCurrentAnimation["startPositionY"])//get Start position
var pointTo = new point(objCurrentAnimation["troop"]["positionX"], objCurrentAnimation["troop"]["positionY"]);// get the end position
var imageTroop = this.humanCivilization.getTroopImage(objCurrentAnimation["troop"]);
if(objCurrentAnimation["troop"]["player"] == 0){
//red faced to the right
this.drawRightJump(pointFrom, pointTo, imageTroop, floatTimer)
}else{
//red faced to the left
this.drawLeftJump(pointFrom, pointTo, imageTroop, floatTimer)
}
}
}
//draw all dummys
for (var a = 0; a < this.arrayWorldInformation["animation"].length; a++) {
var objCurrentAnimation = this.arrayWorldInformation["animation"][a];
//calculate oldness
intAnimationRuntime = ((new Date().getTime()) - this.intGameStartedAt ) - (objCurrentAnimation["startTime"]);
//if an animation that is less than 1 sec old
if(intAnimationRuntime <= 2*this.intAnimationTime && objCurrentAnimation["type"] == "DUMMY"){ // draw a fake ship
//the ship
var imageTroop = this.humanCivilization.getTroopImage(objCurrentAnimation["troop"]);
var pointPosition = new point(objCurrentAnimation["positionX"], objCurrentAnimation["positionY"])
//draw the Image
this.contextContext.drawImage(
imageTroop,
pointPosition.intX*intHexWidth + (pointPosition.intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
pointPosition.intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
}
}
console.log("end Dummy");
//draw all fight animations
for (var a = 0; a < this.arrayWorldInformation["animation"].length; a++) {
var objCurrentAnimation = this.arrayWorldInformation["animation"][a];
//calculate oldness
intAnimationRuntime = ((new Date().getTime()) - this.intGameStartedAt ) - (objCurrentAnimation["startTime"]);
//if an animation that is less than 1 sec old
if(intAnimationRuntime <= 1000 && objCurrentAnimation["type"] == "FIGHT"){//draw a fight
//draw the jump
//console.log("fight");
var floatTimer = Math.max(intAnimationRuntime - this.intAnimationTime*2, -0.1); //get time for animation
var pointPosition = new point(objCurrentAnimation["positionX"], objCurrentAnimation["positionY"]);
this.drawFight(pointPosition, floatTimer);
}
}
//this.drawFight(new point(5, 5), ((new Date().getTime()) - this.intGameStartedAt )%3000);
//make other update stuff
//test for winner
if(this.arrayWorldInformation["winner"] != null){
if(this.arrayWorldInformation["winner"] == this.arrayWorldInformation["youAre"]){
document.getElementById("winOrLoose").innerHTML = "You are the winner"
document.getElementById("GameEndScreen").style.visibility = "visible"
}else{
document.getElementById("winOrLoose").innerHTML = "You are the looser"
document.getElementById("GameEndScreen").style.visibility = "visible"
}
}
//show the time to the next move
document.getElementById("gameInfo").innerHTML = Math.floor(this.arrayWorldInformation["timeToNextTurn"]) + "s"
if(this.arrayWorldInformation["moveOf"] == 1){//player1 is blue and player2 is red
document.getElementById("gameInfo").style.color = "blue";
}else{
document.getElementById("gameInfo").style.color = "red";
}
//show or hide end Turn button
if(this.arrayWorldInformation["moveOf"] == this.arrayWorldInformation["youAre"]){//player1 is blue and player2 is red
document.getElementById("endTurn").style.visibility = "visible";
}else{
document.getElementById("endTurn").style.visibility = "hidden";
}
}
this.drawLeftJump = function(pointJumpOffPosition, pointJumpInPosition, imageShip, floatTimer){ //beam the ship
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
//jumping out
var floatDimensionFactor = new point(0, 0);
floatDimensionFactor.intY = 1;
floatDimensionFactor.intX = Math.max(0, 1 - ((floatTimer/this.intAnimationTime)));
//the speeding up Spaceship
this.contextContext.drawImage(
imageShip,
(pointJumpOffPosition.intX*intHexWidth + (pointJumpOffPosition.intY%2)*intHexWidth/2) - ((1-floatDimensionFactor.intX)*intHexWidth),//every 2ed line has to be a bit more to the right
pointJumpOffPosition.intY*intHexHeight*(3/4) + (intHexHeight * (1-floatDimensionFactor.intY))*0.5,
intHexWidth * floatDimensionFactor.intX,
intHexHeight * floatDimensionFactor.intY)
//the "flash"
if(floatTimer/this.intAnimationTime >= 1.2 && floatTimer/this.intAnimationTime <= 1.5){
this.contextContext.fillStyle = "white";
this.contextContext.fillRect(
((pointJumpOffPosition.intX-1)*intHexWidth + (pointJumpOffPosition.intY%2)*intHexWidth/2),
pointJumpOffPosition.intY*intHexHeight*(3/4) + intHexHeight*0.25,
1,
intHexHeight*0.5
)
}
//jumping in
var strImageId = "troopBlueSmall";
var floatDimensionFactor = new point(0, 0);
floatDimensionFactor.intY = 1;
floatDimensionFactor.intX = Math.min(1, Math.max((floatTimer/this.intAnimationTime)-1, 0));
//the speeding up Spaceship
this.contextContext.drawImage(
imageShip,
(pointJumpInPosition.intX*intHexWidth + (pointJumpInPosition.intY%2)*intHexWidth/2) + ((1-floatDimensionFactor.intX)*intHexWidth)*2,//every 2ed line has to be a bit more to the right
pointJumpInPosition.intY*intHexHeight*(3/4) + (intHexHeight * (1-floatDimensionFactor.intY))*0.5,
intHexWidth * floatDimensionFactor.intX,
intHexHeight * floatDimensionFactor.intY)
//the "flash"
if(floatTimer/this.intAnimationTime >= 1.2 && floatTimer/this.intAnimationTime <= 1.5){
this.contextContext.fillStyle = "white";
this.contextContext.fillRect(
((pointJumpInPosition.intX+2)*intHexWidth + (pointJumpInPosition.intY%2)*intHexWidth/2),
pointJumpInPosition.intY*intHexHeight*(3/4) + intHexHeight*0.25,
1,
intHexHeight*0.5
)
}
}
this.drawRightJump = function(pointJumpOffPosition, pointJumpInPosition, imageShip, floatTimer){ //beam the ship
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
//jumping out
var floatDimensionFactor = new point(0, 0);
floatDimensionFactor.intY = 1;
floatDimensionFactor.intX = Math.max(0, 1 - (floatTimer/this.intAnimationTime));
//the speeding up Spaceship
this.contextContext.drawImage(
imageShip,
(pointJumpOffPosition.intX*intHexWidth + (pointJumpOffPosition.intY%2)*intHexWidth/2) + ((1-floatDimensionFactor.intX)*intHexWidth)*2,//every 2ed line has to be a bit more to the right
pointJumpOffPosition.intY*intHexHeight*(3/4) + (intHexHeight * (1-floatDimensionFactor.intY))*0.5,
intHexWidth * floatDimensionFactor.intX,
intHexHeight * floatDimensionFactor.intY)
//the "flash"
if(floatTimer/this.intAnimationTime >= 1.2 && floatTimer/this.intAnimationTime <= 1.5){
this.contextContext.fillStyle = "white";
this.contextContext.fillRect(
((pointJumpOffPosition.intX+2)*intHexWidth + (pointJumpOffPosition.intY%2)*intHexWidth/2),
pointJumpOffPosition.intY*intHexHeight*(3/4) + intHexHeight*0.25,
1,
intHexHeight*0.5
)
}
//jumping in
var strImageId = "troopBlueSmall";
var floatDimensionFactor = new point(0, 0);
floatDimensionFactor.intY = 1;
floatDimensionFactor.intX = Math.min(1, Math.max((floatTimer/this.intAnimationTime)-1, 0));
//the speeding up Spaceship
this.contextContext.drawImage(
imageShip,
(pointJumpInPosition.intX*intHexWidth + (pointJumpInPosition.intY%2)*intHexWidth/2) - ((1-floatDimensionFactor.intX)*intHexWidth),//every 2ed line has to be a bit more to the right
pointJumpInPosition.intY*intHexHeight*(3/4) + (intHexHeight * (1-floatDimensionFactor.intY))*0.5,
intHexWidth * floatDimensionFactor.intX,
intHexHeight * floatDimensionFactor.intY)
//the "flash"
if(floatTimer/this.intAnimationTime >= 1.2 && floatTimer/this.intAnimationTime <= 1.5){
this.contextContext.fillStyle = "white";
this.contextContext.fillRect(
((pointJumpInPosition.intX-1)*intHexWidth + (pointJumpInPosition.intY%2)*intHexWidth/2),
pointJumpInPosition.intY*intHexHeight*(3/4) + intHexHeight*0.25,
1,
intHexHeight*0.5
)
}
}
this.drawFight = function(pointPosition, floatTimer){
//calculate the Hexagon Size
var intMapHeight = this.arrayWorldInformation["mapHeight"]
var intMapWidth = this.arrayWorldInformation["mapWidth"]
var intHexWidth = this.canvasCanvas.width/(intMapWidth+(1/2));
var intHexHeight = intHexWidth;
this.contextContext.fillStyle = "rgba(0,0,0,0)";
this.contextContext.strokeStyle = "rgba(0,0,0,0)";
if(floatTimer <= this.intAnimationTime/2 && floatTimer >= 0){ //first draw flashes form laserguns
var intResolution = 10;//draw 4 circles on top of each other
/*
//draw a screen wide flash
if(Math.random() >= 0.9){
this.contextContext.fillStyle = "white";
this.contextContext.strokeStyle = "red";
this.contextContext.fillRect(0, 0, this.canvasCanvas.width, this.canvasCanvas.height);
}
*/
var r = 0;
var g = 0;
var b = 0;
var a = 0;
if(Math.random() >= 0.6){
var r = 255;
var g = 255;
var b = 255;
var a = 1;
}
for (var c = 0; c < intResolution; c++) {
this.contextContext.fillStyle = "rgba(" + r+ ", " + g +"," + b + "," + (a/intResolution) + ")";
this.contextContext.strokeStyle = "rgba(" + r+ ", " + g +"," + b + "," + (a/intResolution) + ")";;
this.contextContext.beginPath()
this.contextContext.arc(
pointPosition.intX*intHexWidth + intHexWidth/2 + (pointPosition.intY%2)*intHexWidth/2,
pointPosition.intY*intHexHeight*(3/4) + intHexHeight/2,
intHexWidth*3 * (c/intResolution),
0*Math.PI,2*Math.PI)
this.contextContext.stroke()
this.contextContext.fill()
}
}else if(floatTimer <= this.intAnimationTime && floatTimer >= this.intAnimationTime/2){//draw the explosion
arrayExplosionImagesIds = ["explosion0", "explosion1", "explosion2", "explosion3", "explosion4", "explosion5", "explosion6", "explosion7", "explosion8"];
var intTotalTime = this.intAnimationTime/2;
var intTimePerImage = intTotalTime/arrayExplosionImagesIds.length;
var intCurrentTime = floatTimer - this.intAnimationTime/2;
var intImageId = Math.floor(intCurrentTime/intTimePerImage);
var strImageId = arrayExplosionImagesIds[intImageId];
console.log(strImageId);
try{
this.contextContext.drawImage(
this.arrayImages[strImageId],
pointPosition.intX*intHexWidth + (pointPosition.intY%2)*intHexWidth/2,//every 2ed line has to be a bit more to the right
pointPosition.intY*intHexHeight*(3/4),
intHexWidth,
intHexHeight)
}catch(error){
}
}
}
}
window.setInterval(function(){
if(gameProjectionCurrentGame != null){
gameProjectionCurrentGame.draw()
}
}, 20);
function connectToServer(){
//read the name and Ip from the inputs
strIp = document.getElementById("serverIp").value;
strName = document.getElementById("name").value;
createClient(strIp, '{ "type": "REGISTER", "name": "' + strName + '" }')
document.getElementById("Serverselector").style.visibility = "hidden"
document.getElementById("lobbyUi").style.visibility = "visible"
//get the Lobby info after one minute
window.setTimeout(function(){sendToServer('{ "type": "GETLOBBYINFO"}');}, 1000);
}
function joinGame(intId){
sendToServer('{ "type": "JOINGAME", "id": ' + intId + ' }')
}
function createGame(){
var strGameName = document.getElementById("gameName").value;
strJson = '{ "type": "CREATEGAME", "name": "' + strGameName + '" }'
sendToServer(strJson)
}
function interpretMessage(strMessage){
//console.log(strMessage);
var arrayCommand = JSON.parse(strMessage);
if(arrayCommand["type"] == "LOBBYINFO"){
//if you get Lobby Info
//create the Lobby HTML
var strLobbyHTML = "";
//write the amount of Player that are online
strLobbyHTML += arrayCommand["online"] + " player online<br><br>"
//wirte all games
for (var i = 0; i < arrayCommand["games"].length; i++) {
strLobbyHTML += "<div onClick='joinGame(" + i + ")'>" + arrayCommand["games"][i] + "</div>"
};
//display all elements to the user.
document.getElementById("lobbyInfo").innerHTML = strLobbyHTML;
return;
}
else if(arrayCommand["type"] == "WORLDINFO"){
if(gameProjectionCurrentGame == null){//Create the new game
gameProjectionCurrentGame = new gameProjection()
}
//change the worldinfos
gameProjectionCurrentGame.arrayWorldInformation = arrayCommand;
return;
}
console.error("get an unknown Command");
console.log(arrayCommand);
}
functionOnMessage = interpretMessage;
//override the default "OnMessage"-function
//set the version
document.getElementById("versionInfo").innerHTML = getVersion();
// auto connect (for test environment)
//to read information form the URL
function parseURLParams() {
url = window.location.href;
var queryStart = url.indexOf("?") + 1,
queryEnd = url.indexOf("#") + 1 || url.length + 1,
query = url.slice(queryStart, queryEnd - 1),
pairs = query.replace(/\+/g, " ").split("&"),
parms = {}, i, n, v, nv;
if (query === url || query === "") return;
for (i = 0; i < pairs.length; i++) {
nv = pairs[i].split("=", 2);
n = decodeURIComponent(nv[0]);
v = decodeURIComponent(nv[1]);
if (!parms.hasOwnProperty(n)) parms[n] = [];
parms[n].push(nv.length === 2 ? v : null);
}
return parms;
}
if(parseURLParams() != null){
if(parseURLParams()["auto"] == "true"){
strId = parseURLParams()["id"];
//set the parameters into the inputs (Yes I know that is dirty)
document.getElementById("serverIp").value = "localhost";
document.getElementById("name").value = "Player" + strId;
if(strId == "0"){
window.moveBy(-window.outerWidth, -window.outerHeight)
}else{
window.moveBy(-window.outerWidth, window.outerHeight)
}
window.setTimeout(function(){connectToServer()}, 100);
}
}
window.onload = function(){
// set the move and click event
document.getElementById("gameBoard").addEventListener("mousemove", function(e){gameProjectionCurrentGame.onMouseMove(e)}, false);
document.getElementById("gameBoard").addEventListener("click", function(e){gameProjectionCurrentGame.onMouseDown(e)}, false);
}
|
function sender_button(e){var t=document.getElementById("message_receiver_id"),n=document.getElementById("form_message");n.hidden=!1,t.value=e,document.getElementById("text_comment").focus()}function cancel_message(){var e=document.getElementById("form_message");e.hidden=!0} |
var transformComps = require('./transform-composed-nodes'),
async = require('async'),
_ = require('underscore'),
compositionRelationCypherList = require('./composition-relation-cypher-list'),
sortComps = require('./sort-compositions'),
getId = require('./get-id');
function stripComposedObjects(object) {
var compStripped = _.clone(object);
Object.keys(this.compositions).forEach(function(comp) {
delete compStripped[comp]
});
return compStripped;
}
function makeName(names) {
var count = -1, name;
do {
name = this.type + ++count;
} while (~names.indexOf(name))
names.push(name);
return name;
}
function createNodeGraph(node, names, allNodes) {
names = names || [];
var root = stripComposedObjects.call(this, node);
var graph = {
name: makeName.call(this, names),
props: root,
model: this,
children: []
};
if (!allNodes) allNodes = graph.allNodes = [graph];
for (var compName in this.compositions) {
var comp = this.compositions[compName];
if (!node[comp.name] || comp.transient) continue;
var subnodes = node[comp.name];
if (!Array.isArray(subnodes)) subnodes = [subnodes];
for (var i in subnodes) {
var subgraph = createNodeGraph.call(comp.model, subnodes[i], names, allNodes);
subgraph.comp = comp;
graph.children.push(subgraph);
allNodes.push(subgraph);
}
}
return graph;
}
function reassembleFromGraph(graph, data) {
function _reassembleFromGraph(node, object) {
node.children.forEach(function(child) {
var node = _reassembleFromGraph(child, data[child.name]);
if (data['__rel_' + child.name]) node._rel = data['__rel_' + child.name].properties;
if (!object[child.comp.name])
object[child.comp.name] = child.comp.many ? [node] : node;
else if (!Array.isArray(object[child.comp.name]))
object[child.comp.name] = [object[child.comp.name], node];
else
object[child.comp.name].push(node);
});
return object;
}
return _reassembleFromGraph(graph, data[graph.name] || data);
}
function getSetCreatedTimestampStatement(node) {
var prop = node.name + '.' + node.model.createdField;
return prop + '= CASE WHEN EXISTS(' + prop + ') THEN ' + prop + ' ELSE timestamp() END';
};
var compose = {
// get the START statement of a write query
// this will start with all the pre-existing nodes
start: function (graph, opts, params) {
var self = this;
var savedNodes = graph.allNodes.filter(function(node) {
return node.props[self.db.options.id] != null
&& !(node.model.uniqueness && node.model.uniqueness.returnOld);
});
if (!savedNodes.length) return '';
var statements = savedNodes.map(function(node) {
params[node.name + 'id'] = getId(self.db, node.props);
return node.name + '=node({' + node.name + 'id})';
});
return 'START ' + statements.join(',');
},
match: function (graph, opts, params) {
// starting with match is currently unsafe because if you want to change
// the key of an object, the object you're saving will already have a different
// key, and seraph-model has no reference to the old one. hopefully this code
// can come back into use at some time, but as it is now it is not possible.
return '';
var self = this;
var savedUniqueNodes = graph.allNodes.filter(function(node) {
return node.props[self.db.options.id] != null
&& node.model.uniqueness
&& !node.model.uniqueness.returnOld;
});
if (!savedUniqueNodes.length) return '';
var statements = savedUniqueNodes.map(function(node) {
var uniqueKey = node.model.uniqueness.key;
params[node.name + 'key'] = node.props[uniqueKey];
return '(' + node.name + ':' + node.model.type + ' {' + uniqueKey + ': {' + node.name + 'key}})';
});
return 'MATCH ' + statements.join(',');
},
merge: function (graph, opts, params) {
var self = this;
var savedUniqueNodes = graph.allNodes.filter(function(node) {
return node.model.uniqueness
&& node.model.uniqueness.returnOld;
});
if (!savedUniqueNodes.length) return '';
var statements = savedUniqueNodes.map(function(node) {
var uniqueKey = node.model.uniqueness.key;
params[node.name + 'key'] = node.props[uniqueKey];
return 'MERGE (' + node.name + ':' + node.model.type +
' {' + uniqueKey + ': {' + node.name + 'key}})';
});
return statements.join(' ');
},
// get the CREATE statement of a write query
// this will create non-existant nodes
create: function (graph, opts, params) {
var self = this;
var newNodes = graph.allNodes.filter(function(node) {
return node.props[self.db.options.id] == null
&& !(node.model.uniqueness && node.model.uniqueness.returnOld);
});
if (!newNodes.length) return '';
var statements = newNodes.map(function(node) {
var label = node.model.type;
return '(' + node.name + ':' + label + ')';
});
return 'CREATE ' + statements.join(',');
},
// get the SET statement of a write query
// this will set the properties on all nodes
set: function (graph, opts, params) {
var self = this;
var updatedNodes = graph.allNodes;
if (opts.restrictToComp) {
updatedNodes = graph.allNodes.filter(function(node) {
return node.comp && node.comp.name == opts.restrictToComp;
});
}
function assign(statements, varName, hash) {
params[varName] = hash;
if (opts.additive) {
_.forEach(hash, function(val, key) {
statements.push(varName + '.`' + key + '`={' + varName + '}.`' + key + '`');
});
} else {
statements.push(varName + '={' + varName + '}');
}
}
return 'SET ' + updatedNodes.reduce(function(statements, node) {
// set props
var props = node.props;
if (props[self.db.options.id]) props = _.omit(props, self.db.options.id);
if (node.comp) assign(statements, '__rel_' + node.name, props._rel || {});
props = _.omit(props, '_rel');
assign(statements, node.name, props);
// set timestamps
if (!node.model.usingTimestamps) return statements;
statements.push(getSetCreatedTimestampStatement(node));
statements.push(node.name + '.' + node.model.updatedField + ' = timestamp()');
return statements;
}, []).join(',');
},
// get the CREATE UNIQUE statement of a write query
// this will create the required relationships
createUnique: function (graph, opts, params) {
if (graph.children.length == 0) return '';
function getRels(node) {
var rels = [];
node.children.forEach(function(childNode) {
rels.push('(' + node.name + ')-[__rel_' + childNode.name + ':' + childNode.comp.rel + ']->(' + childNode.name + ')');
rels.push.apply(rels, getRels(childNode));
});
return rels;
}
return 'CREATE UNIQUE ' + getRels(graph).join(',');
},
// creates a WITH clause that carries over all of the the current relevant
// variables
continuation: function (graph) {
return 'WITH ' + _.map(graph.allNodes, function (node) {
return node.name + (node.comp ? ',__rel_' + node.name : '');
});
},
stripRedundantCompositions: function (graph, opts) {
if (_.isEmpty(this.compositions) || opts.keepRedundancy) return '';
var compositions = opts.restrictToComp
? [ this.compositions[opts.restrictToComp] ]
: _.values(this.compositions);
compositions = _.reject(compositions, function(comp) { return comp.transient });
if (compositions.length == 0) return '';
var compRels = compositionRelationCypherList(compositions);
return [
compose.continuation(graph),
'OPTIONAL MATCH (' + graph.name + ')-[rel:' + compRels + ']->(target)',
'WHERE not (target IN [' + _.pluck(graph.allNodes, 'name').join(',') + '])',
'DELETE rel'
].join(' ');
},
return: function (graph, opts) {
return 'RETURN ' + _.map(graph.allNodes, function (node) {
return node.name + (node.comp ? ',__rel_' + node.name : '');
});
}
};
// prepare, validate, beforeSave
function beforeCommit(object, callback) {
var self = this;
async.waterfall([
this.triggerTransformEvent.bind(this, 'prepare', object),
this.triggerProgressionEvent.bind(this, 'validate'),
this.triggerEvent.bind(this, 'beforeSave')
], function(err, object) {
if (err) return callback(err);
// run beforeCommit on all composed objects as well.
transformComps.call(self, object, object, function(comp, object, i, cb) {
if (comp.transient) return cb();
beforeCommit.call(comp.model, object, cb);
}, callback);
});
};
var COLLISION_EXCS = [
'UniqueConstraintViolationKernelException',
'Neo.ClientError.Schema.ConstraintViolation',
'Neo.ClientError.Schema.ConstraintValidationFailed'
];
function cypherCommit(node, opts, callback) {
var graph = createNodeGraph.call(this, node);
var self = this;
var params = {};
var start = compose.start.call(this, graph, opts, params);
var match = compose.match.call(this, graph, opts, params);
var merge = compose.merge.call(this, graph, opts, params);
var create = compose.create.call(this, graph, opts, params);
var rels = compose.createUnique.call(this, graph, opts, params);
var set = compose.set.call(this, graph, opts, params);
var deleteRedundancies = compose.stripRedundantCompositions.call(this, graph, opts);
var finish = compose.return.call(this, graph, opts)
var query = [
start,
match,
merge,
create,
rels,
set,
opts.excludeComps ? '' : deleteRedundancies,
finish
].join(' ')
this.db.query(query, params, function(err, result) {
if (err) {
if ((err.neo4jCause && COLLISION_EXCS.indexOf(err.neo4jCause.exception) != -1)
|| (err.code && COLLISION_EXCS.indexOf(err.code) != -1))
err.statusCode = 409;
callback(err)
}
else callback(null, reassembleFromGraph.call(self, graph, result[0]));
});
}
function afterCommit(object, callback) {
var self = this;
sortComps.call(this, object);
this.triggerEvent('afterSave', object);
transformComps.call(self, object, object, function(opts, object, i, cb) {
afterCommit.call(opts.model, object, cb);
}, function(err, comps) {
if (err) return callback(err);
self.compute(object, callback);
});
}
module.exports = {
_save: function saveModel(object, opts, callback) {
var self = this;
if (typeof opts == 'function') {
callback = opts;
opts = {};
}
if (opts.excludeComps)
object = _.omit(object, _.pluck(self.compositions, 'name'));
async.waterfall([
beforeCommit.bind(this, object),
function (object, callback) {
cypherCommit.call(self, object, opts, callback);
},
afterCommit.bind(this)
], callback);
},
save: function saveModel(object, excludeComps, callback) {
if (typeof excludeComps == 'function') {
callback = excludeComps;
excludeComps = false;
}
return module.exports._save.call(this, object, {excludeComps: excludeComps}, callback);
},
update: function updateModel(object, excludeComps, callback) {
if (typeof excludeComps == 'function') {
callback = excludeComps;
excludeComps = false;
}
return module.exports._save.call(this, object, {
excludeComps: excludeComps,
additive: true,
keepRedundancy: true
}, callback);
},
saveComposition: function saveComposition(root, compName, objects, opts, callback) {
var comp = this.compositions[compName]
if (typeof opts == 'function') {
callback = opts;
opts = {};
}
opts.restrictToComp = compName;
if (!comp) return callback(new Error("Invalid composition name - "+compName));
if (!Array.isArray(objects)) objects = [objects];
var rootId = getId(this.db, root);
if (rootId == null) return callback(new Error("Invalid root node - " + root));
var self = this;
var shell = {};
shell[self.db.options.id] = rootId;
shell[comp.name] = objects;
async.waterfall([
function runBeforeCommit(cb) {
self.triggerEvent('beforeSave', shell);
async.map(objects, beforeCommit.bind(comp.model), cb);
},
function runCommitAndIndex(objects, cb) {
cypherCommit.call(self, shell, opts, cb);
},
function runAfterCommit(shell, cb) {
var objects = shell[comp.name];
if (!Array.isArray(objects)) objects = [objects];
self.triggerEvent('afterSave', shell);
async.map(objects, afterCommit.bind(comp.model), cb);
}
], function(err, objects) {
if (err) return callback(err);
if (objects.length == 1 && !comp.many) objects = objects[0];
callback(null, objects);
});
},
pushComposition: function pushComposition(root, compName, object, callback) {
module.exports.saveComposition.call(this, root, compName, object,
{ keepRedundancy: true }, function(err, saved) {
if (err) return callback(err);
else if (!Array.isArray(object) && Array.isArray(saved)) callback(null, saved[0]);
else callback(null, saved);
});
}
};
|
var group___p_w_r___exported___macro =
[
[ "__HAL_PWR_CLEAR_FLAG", "group___p_w_r___exported___macro.html#ga96f24bf4b16c9f944cd829100bf746e5", null ],
[ "__HAL_PWR_GET_FLAG", "group___p_w_r___exported___macro.html#ga2977135bbea35b786805eea640d1c884", null ],
[ "__HAL_PWR_PVD_EXTI_CLEAR_FLAG", "group___p_w_r___exported___macro.html#gac0fb2218bc050f5d8fdb1a3f28590352", null ],
[ "__HAL_PWR_PVD_EXTI_DISABLE_EVENT", "group___p_w_r___exported___macro.html#ga8bd379e960497722450c7cea474a7e7a", null ],
[ "__HAL_PWR_PVD_EXTI_DISABLE_FALLING_EDGE", "group___p_w_r___exported___macro.html#ga1ca57168205f8cd8d1014e6eb9465f2d", null ],
[ "__HAL_PWR_PVD_EXTI_DISABLE_IT", "group___p_w_r___exported___macro.html#gad240d7bf8f15191b068497b9aead1f1f", null ],
[ "__HAL_PWR_PVD_EXTI_DISABLE_RISING_EDGE", "group___p_w_r___exported___macro.html#ga1ca8fd7f3286a176f6be540c75a004c6", null ],
[ "__HAL_PWR_PVD_EXTI_DISABLE_RISING_FALLING_EDGE", "group___p_w_r___exported___macro.html#ga3f66c9c0c214cd08c24674904dcdc4e0", null ],
[ "__HAL_PWR_PVD_EXTI_ENABLE_EVENT", "group___p_w_r___exported___macro.html#gae5ba5672fe8cb7c1686c7f2cc211b128", null ],
[ "__HAL_PWR_PVD_EXTI_ENABLE_FALLING_EDGE", "group___p_w_r___exported___macro.html#ga5b971478563a00e1ee1a9d8ca8054e08", null ],
[ "__HAL_PWR_PVD_EXTI_ENABLE_IT", "group___p_w_r___exported___macro.html#ga3180f039cf14ef78a64089f387f8f9c2", null ],
[ "__HAL_PWR_PVD_EXTI_ENABLE_RISING_EDGE", "group___p_w_r___exported___macro.html#ga7bef3f30c9fe267c99d5240fbf3f878c", null ],
[ "__HAL_PWR_PVD_EXTI_ENABLE_RISING_FALLING_EDGE", "group___p_w_r___exported___macro.html#ga638033d236eb78c1e5ecb9b49c4e7f36", null ],
[ "__HAL_PWR_PVD_EXTI_GENERATE_SWIT", "group___p_w_r___exported___macro.html#gaba4a7968f5c4c4ca6a7047b147ba18d4", null ],
[ "__HAL_PWR_PVD_EXTI_GET_FLAG", "group___p_w_r___exported___macro.html#ga5e66fa75359b51066e0731ac1e5ae438", null ]
]; |
'use strict';
/**
* logger adapter
*/
class LoggerShim {
constructor(loggerImpl) {
this._impl = loggerImpl;
}
info(msg) {
if (this._impl) this._impl.info(msg);
}
warning(msg) {
if (this._impl) this._impl.warning(msg);
}
error(msg) {
if (this._impl) this._impl.error(msg);
}
debug(msg) {
if (this._impl) this._impl.debug(msg);
}
trace(msg) {
if (this._impl) this._impl.trace(msg);
}
}
exports = module.exports = LoggerShim; |
import createHistory from 'history/createBrowserHistory';
import { queryToJson } from './utils';
import { PATH, QUERY, HASH } from './RouterModes';
export function createHistoryFromLocation(location, mode = PATH) {
const { pathname, hash, search } = location;
let route = pathname;
switch (mode) {
case PATH:
route = pathname;
break;
case QUERY:
route = `${route}${search}`;
break;
case HASH:
route = `${route}${search}${hash}`;
break;
}
return {
route,
path: pathname,
pathname,
hash,
search,
query: queryToJson(search.slice(search.indexOf('?') + 1))
};
}
export const history = createHistory();
export default history; |
define([], function() {
return {
"Title": "Paramètre de requête de l'URL",
"QQueryStringParameter": "Valeur du paramètre 'q'"
}
}); |
/*! jQuery UI - v1.9.2 - 2015-05-31
* http://jqueryui.com
* Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
jQuery(function(e){e.datepicker.regional.id={closeText:"Tutup",prevText:"<mundur",nextText:"maju>",currentText:"hari ini",monthNames:["Januari","Februari","Maret","April","Mei","Juni","Juli","Agustus","September","Oktober","Nopember","Desember"],monthNamesShort:["Jan","Feb","Mar","Apr","Mei","Jun","Jul","Agus","Sep","Okt","Nop","Des"],dayNames:["Minggu","Senin","Selasa","Rabu","Kamis","Jumat","Sabtu"],dayNamesShort:["Min","Sen","Sel","Rab","kam","Jum","Sab"],dayNamesMin:["Mg","Sn","Sl","Rb","Km","jm","Sb"],weekHeader:"Mg",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""},e.datepicker.setDefaults(e.datepicker.regional.id)}); |
/* jslint node: true */
'use strict';
var assert = require('assert'),
jshint = require('../../lib/js/jshint');
describe('JSHint', function () {
it('should report errors for bad code', function (done) {
var file = __dirname + '/data/jshint/bad.js';
jshint.run([file], function(err, output) {
assert.equal(2, output[file].length);
assert.equal(' Missing "use strict" statement.', output[file][0].msg);
done();
});
});
it('should not report errors for good code', function (done) {
var file = __dirname + '/data/jshint/good.js';
jshint.run([file], function(err, output) {
assert.equal(undefined, output[file]);
done();
});
});
});
|
import React from 'react';
let GithubButton = ({
href,
size,
countAriaLabel,
ariaLabel,
showCount,
children,
...rest
}) => (
<a
className="github-button"
href={href}
data-size={size}
data-count-aria-label={countAriaLabel}
aria-label={ariaLabel}
data-show-count={showCount}
{...rest}
>
{children}
</a>
);
GithubButton.defaultProps = {
size: 'large',
countAriaLabel: '# stargazers on GitHub',
showCount: true,
};
export default GithubButton;
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _base = require('./base');
var _base2 = _interopRequireDefault(_base);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Service = function (_Base) {
_inherits(Service, _Base);
function Service() {
_classCallCheck(this, Service);
return _possibleConstructorReturn(this, (Service.__proto__ || Object.getPrototypeOf(Service)).apply(this, arguments));
}
_createClass(Service, [{
key: 'request',
value: function request(options) {
var http = this.connection;
var Headers = this.options.Headers;
if (!http || !Headers) {
throw new Error('Please pass angular\'s \'http\' (instance) and and object with \'Headers\' (class) to feathers-rest');
}
var url = options.url;
var requestOptions = {
method: options.method,
body: options.body,
headers: new Headers(_extends({ Accept: 'application/json' }, this.options.headers, options.headers))
};
return new Promise(function (resolve, reject) {
http.request(url, requestOptions).subscribe(resolve, reject);
}).then(function (res) {
return res.json();
}).catch(function (error) {
var response = error.response || error;
throw response instanceof Error ? response : response.json() || response;
});
}
}]);
return Service;
}(_base2.default);
exports.default = Service;
module.exports = exports['default']; |
angular.module('BwafTM.pages.charts.amCharts').
factory('RouteQuery', ['$http', '$q', function($http, $q) {
return {
get: function(route) {
var data = {};
var defer = $q.defer();
var service = {};
$http.get(route).
success(function(response) {
defer.resolve(response);
}).
error(function(response) {
defer.reject(response);
});
return defer.promise;
},
post: function(req) {
$http(req).
success(function(response) {
return response;
}).
error(function(response) {
return null;
});
}
}
}]); |
/* */
"format amd";
//! moment.js locale configuration
//! locale : Latvian [lv]
//! author : Kristaps Karlsons : https://github.com/skakri
//! author : Jānis Elmeris : https://github.com/JanisE
;(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined'
&& typeof require === 'function' ? factory(require('../moment')) :
typeof define === 'function' && define.amd ? define(["../moment"], factory) :
factory(global.moment)
}(this, (function (moment) { 'use strict';
var units = {
'm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
'mm': 'minūtes_minūtēm_minūte_minūtes'.split('_'),
'h': 'stundas_stundām_stunda_stundas'.split('_'),
'hh': 'stundas_stundām_stunda_stundas'.split('_'),
'd': 'dienas_dienām_diena_dienas'.split('_'),
'dd': 'dienas_dienām_diena_dienas'.split('_'),
'M': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
'MM': 'mēneša_mēnešiem_mēnesis_mēneši'.split('_'),
'y': 'gada_gadiem_gads_gadi'.split('_'),
'yy': 'gada_gadiem_gads_gadi'.split('_')
};
/**
* @param withoutSuffix boolean true = a length of time; false = before/after a period of time.
*/
function format(forms, number, withoutSuffix) {
if (withoutSuffix) {
// E.g. "21 minūte", "3 minūtes".
return number % 10 === 1 && number % 100 !== 11 ? forms[2] : forms[3];
} else {
// E.g. "21 minūtes" as in "pēc 21 minūtes".
// E.g. "3 minūtēm" as in "pēc 3 minūtēm".
return number % 10 === 1 && number % 100 !== 11 ? forms[0] : forms[1];
}
}
function relativeTimeWithPlural(number, withoutSuffix, key) {
return number + ' ' + format(units[key], number, withoutSuffix);
}
function relativeTimeWithSingular(number, withoutSuffix, key) {
return format(units[key], number, withoutSuffix);
}
function relativeSeconds(number, withoutSuffix) {
return withoutSuffix ? 'dažas sekundes' : 'dažām sekundēm';
}
var lv = moment.defineLocale('lv', {
months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
weekdaysParseExact : true,
longDateFormat : {
LT : 'HH:mm',
LTS : 'HH:mm:ss',
L : 'DD.MM.YYYY.',
LL : 'YYYY. [gada] D. MMMM',
LLL : 'YYYY. [gada] D. MMMM, HH:mm',
LLLL : 'YYYY. [gada] D. MMMM, dddd, HH:mm'
},
calendar : {
sameDay : '[Šodien pulksten] LT',
nextDay : '[Rīt pulksten] LT',
nextWeek : 'dddd [pulksten] LT',
lastDay : '[Vakar pulksten] LT',
lastWeek : '[Pagājušā] dddd [pulksten] LT',
sameElse : 'L'
},
relativeTime : {
future : 'pēc %s',
past : 'pirms %s',
s : relativeSeconds,
m : relativeTimeWithSingular,
mm : relativeTimeWithPlural,
h : relativeTimeWithSingular,
hh : relativeTimeWithPlural,
d : relativeTimeWithSingular,
dd : relativeTimeWithPlural,
M : relativeTimeWithSingular,
MM : relativeTimeWithPlural,
y : relativeTimeWithSingular,
yy : relativeTimeWithPlural
},
dayOfMonthOrdinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
dow : 1, // Monday is the first day of the week.
doy : 4 // The week that contains Jan 4th is the first week of the year.
}
});
return lv;
})));
|
/*!
* jQuery JavaScript Library v1.9.1
* http://jquery.com/
*
* Includes Sizzle.js
* http://sizzlejs.com/
*
* Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2013-2-4
*/
(function( window, undefined ) {
// Can't do this because several apps including ASP.NET trace
// the stack via arguments.caller.callee and Firefox dies if
// you try to trace through "use strict" call chains. (#13335)
// Support: Firefox 18+
//"use strict";
var
// The deferred used on DOM ready
readyList,
// A central reference to the root jQuery(document)
rootjQuery,
// Support: IE<9
// For `typeof node.method` instead of `node.method !== undefined`
core_strundefined = typeof undefined,
// Use the correct document accordingly with window argument (sandbox)
document = window.document,
location = window.location,
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
// Map over the $ in case of overwrite
_$ = window.$,
// [[Class]] -> type pairs
class2type = {},
// List of deleted data cache ids, so we can reuse them
core_deletedIds = [],
core_version = "1.9.1",
// Save a reference to some core methods
core_concat = core_deletedIds.concat,
core_push = core_deletedIds.push,
core_slice = core_deletedIds.slice,
core_indexOf = core_deletedIds.indexOf,
core_toString = class2type.toString,
core_hasOwn = class2type.hasOwnProperty,
core_trim = core_version.trim,
// Define a local copy of jQuery
jQuery = function( selector, context ) {
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init( selector, context, rootjQuery );
},
// Used for matching numbers
core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
// Used for splitting on whitespace
core_rnotwhite = /\S+/g,
// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
// A simple way to check for HTML strings
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
// Strict HTML recognition (#11290: must start with <)
rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
// Match a standalone tag
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
// JSON RegExp
rvalidchars = /^[\],:{}\s]*$/,
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
// Matches dashed string for camelizing
rmsPrefix = /^-ms-/,
rdashAlpha = /-([\da-z])/gi,
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
},
// The ready event handler
completed = function( event ) {
// readyState === "complete" is good enough for us to call the dom ready in oldIE
if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
detach();
jQuery.ready();
}
},
// Clean-up method for dom ready events
detach = function() {
if ( document.addEventListener ) {
document.removeEventListener( "DOMContentLoaded", completed, false );
window.removeEventListener( "load", completed, false );
} else {
document.detachEvent( "onreadystatechange", completed );
window.detachEvent( "onload", completed );
}
};
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
jquery: core_version,
constructor: jQuery,
init: function( selector, context, rootjQuery ) {
var match, elem;
// HANDLE: $(""), $(null), $(undefined), $(false)
if ( !selector ) {
return this;
}
// Handle HTML strings
if ( typeof selector === "string" ) {
if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
// Assume that strings that start and end with <> are HTML and skip the regex check
match = [ null, selector, null ];
} else {
match = rquickExpr.exec( selector );
}
// Match html or make sure no context is specified for #id
if ( match && (match[1] || !context) ) {
// HANDLE: $(html) -> $(array)
if ( match[1] ) {
context = context instanceof jQuery ? context[0] : context;
// scripts is true for back-compat
jQuery.merge( this, jQuery.parseHTML(
match[1],
context && context.nodeType ? context.ownerDocument || context : document,
true
) );
// HANDLE: $(html, props)
if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
for ( match in context ) {
// Properties of context are called as methods if possible
if ( jQuery.isFunction( this[ match ] ) ) {
this[ match ]( context[ match ] );
// ...and otherwise set as attributes
} else {
this.attr( match, context[ match ] );
}
}
}
return this;
// HANDLE: $(#id)
} else {
elem = document.getElementById( match[2] );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if ( elem && elem.parentNode ) {
// Handle the case where IE and Opera return items
// by name instead of ID
if ( elem.id !== match[2] ) {
return rootjQuery.find( selector );
}
// Otherwise, we inject the element directly into the jQuery object
this.length = 1;
this[0] = elem;
}
this.context = document;
this.selector = selector;
return this;
}
// HANDLE: $(expr, $(...))
} else if ( !context || context.jquery ) {
return ( context || rootjQuery ).find( selector );
// HANDLE: $(expr, context)
// (which is just equivalent to: $(context).find(expr)
} else {
return this.constructor( context ).find( selector );
}
// HANDLE: $(DOMElement)
} else if ( selector.nodeType ) {
this.context = this[0] = selector;
this.length = 1;
return this;
// HANDLE: $(function)
// Shortcut for document ready
} else if ( jQuery.isFunction( selector ) ) {
return rootjQuery.ready( selector );
}
if ( selector.selector !== undefined ) {
this.selector = selector.selector;
this.context = selector.context;
}
return jQuery.makeArray( selector, this );
},
// Start with an empty selector
selector: "",
// The default length of a jQuery object is 0
length: 0,
// The number of elements contained in the matched element set
size: function() {
return this.length;
},
toArray: function() {
return core_slice.call( this );
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
return num == null ?
// Return a 'clean' array
this.toArray() :
// Return just the object
( num < 0 ? this[ this.length + num ] : this[ num ] );
},
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems ) {
// Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
// Return the newly-formed element set
return ret;
},
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
return jQuery.each( this, callback, args );
},
ready: function( fn ) {
// Add the callback
jQuery.ready.promise().done( fn );
return this;
},
slice: function() {
return this.pushStack( core_slice.apply( this, arguments ) );
},
first: function() {
return this.eq( 0 );
},
last: function() {
return this.eq( -1 );
},
eq: function( i ) {
var len = this.length,
j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
},
map: function( callback ) {
return this.pushStack( jQuery.map(this, function( elem, i ) {
return callback.call( elem, i, elem );
}));
},
end: function() {
return this.prevObject || this.constructor(null);
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: core_push,
sort: [].sort,
splice: [].splice
};
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;
jQuery.extend = jQuery.fn.extend = function() {
var src, copyIsArray, copy, name, options, clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false;
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
target = arguments[1] || {};
// skip the boolean and the target
i = 2;
}
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
}
// extend jQuery itself if only one argument is passed
if ( length === i ) {
target = this;
--i;
}
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// Prevent never-ending loop
if ( target === copy ) {
continue;
}
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : [];
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}
// Return the modified object
return target;
};
jQuery.extend({
noConflict: function( deep ) {
if ( window.$ === jQuery ) {
window.$ = _$;
}
if ( deep && window.jQuery === jQuery ) {
window.jQuery = _jQuery;
}
return jQuery;
},
// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,
// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,
// Hold (or release) the ready event
holdReady: function( hold ) {
if ( hold ) {
jQuery.readyWait++;
} else {
jQuery.ready( true );
}
},
// Handle when the DOM is ready
ready: function( wait ) {
// Abort if there are pending holds or we're already ready
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
return;
}
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
if ( !document.body ) {
return setTimeout( jQuery.ready );
}
// Remember that the DOM is ready
jQuery.isReady = true;
// If a normal DOM Ready event fired, decrement, and wait if need be
if ( wait !== true && --jQuery.readyWait > 0 ) {
return;
}
// If there are functions bound, to execute
readyList.resolveWith( document, [ jQuery ] );
// Trigger any bound ready events
if ( jQuery.fn.trigger ) {
jQuery( document ).trigger("ready").off("ready");
}
},
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
return jQuery.type(obj) === "function";
},
isArray: Array.isArray || function( obj ) {
return jQuery.type(obj) === "array";
},
isWindow: function( obj ) {
return obj != null && obj == obj.window;
},
isNumeric: function( obj ) {
return !isNaN( parseFloat(obj) ) && isFinite( obj );
},
type: function( obj ) {
if ( obj == null ) {
return String( obj );
}
return typeof obj === "object" || typeof obj === "function" ?
class2type[ core_toString.call(obj) ] || "object" :
typeof obj;
},
isPlainObject: function( obj ) {
// Must be an Object.
// Because of IE, we also have to check the presence of the constructor property.
// Make sure that DOM nodes and window objects don't pass through, as well
if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
return false;
}
try {
// Not own constructor property must be Object
if ( obj.constructor &&
!core_hasOwn.call(obj, "constructor") &&
!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
return false;
}
} catch ( e ) {
// IE8,9 Will throw exceptions on certain host objects #9897
return false;
}
// Own properties are enumerated firstly, so to speed up,
// if last one is own, then all properties are own.
var key;
for ( key in obj ) {}
return key === undefined || core_hasOwn.call( obj, key );
},
isEmptyObject: function( obj ) {
var name;
for ( name in obj ) {
return false;
}
return true;
},
error: function( msg ) {
throw new Error( msg );
},
// data: string of html
// context (optional): If specified, the fragment will be created in this context, defaults to document
// keepScripts (optional): If true, will include scripts passed in the html string
parseHTML: function( data, context, keepScripts ) {
if ( !data || typeof data !== "string" ) {
return null;
}
if ( typeof context === "boolean" ) {
keepScripts = context;
context = false;
}
context = context || document;
var parsed = rsingleTag.exec( data ),
scripts = !keepScripts && [];
// Single tag
if ( parsed ) {
return [ context.createElement( parsed[1] ) ];
}
parsed = jQuery.buildFragment( [ data ], context, scripts );
if ( scripts ) {
jQuery( scripts ).remove();
}
return jQuery.merge( [], parsed.childNodes );
},
parseJSON: function( data ) {
// Attempt to parse using the native JSON parser first
if ( window.JSON && window.JSON.parse ) {
return window.JSON.parse( data );
}
if ( data === null ) {
return data;
}
if ( typeof data === "string" ) {
// Make sure leading/trailing whitespace is removed (IE can't handle it)
data = jQuery.trim( data );
if ( data ) {
// Make sure the incoming data is actual JSON
// Logic borrowed from http://json.org/json2.js
if ( rvalidchars.test( data.replace( rvalidescape, "@" )
.replace( rvalidtokens, "]" )
.replace( rvalidbraces, "")) ) {
return ( new Function( "return " + data ) )();
}
}
}
jQuery.error( "Invalid JSON: " + data );
},
// Cross-browser xml parsing
parseXML: function( data ) {
var xml, tmp;
if ( !data || typeof data !== "string" ) {
return null;
}
try {
if ( window.DOMParser ) { // Standard
tmp = new DOMParser();
xml = tmp.parseFromString( data , "text/xml" );
} else { // IE
xml = new ActiveXObject( "Microsoft.XMLDOM" );
xml.async = "false";
xml.loadXML( data );
}
} catch( e ) {
xml = undefined;
}
if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
jQuery.error( "Invalid XML: " + data );
}
return xml;
},
noop: function() {},
// Evaluates a script in a global context
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
globalEval: function( data ) {
if ( data && jQuery.trim( data ) ) {
// We use execScript on Internet Explorer
// We use an anonymous function so that context is window
// rather than jQuery in Firefox
( window.execScript || function( data ) {
window[ "eval" ].call( window, data );
} )( data );
}
},
// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function( string ) {
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
},
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
},
// args is for internal usage only
each: function( obj, callback, args ) {
var value,
i = 0,
length = obj.length,
isArray = isArraylike( obj );
if ( args ) {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
}
// A special, fast, case for the most common use of each
} else {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
}
}
return obj;
},
// Use native String.trim function wherever possible
trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
function( text ) {
return text == null ?
"" :
core_trim.call( text );
} :
// Otherwise use our own trimming functionality
function( text ) {
return text == null ?
"" :
( text + "" ).replace( rtrim, "" );
},
// results is for internal usage only
makeArray: function( arr, results ) {
var ret = results || [];
if ( arr != null ) {
if ( isArraylike( Object(arr) ) ) {
jQuery.merge( ret,
typeof arr === "string" ?
[ arr ] : arr
);
} else {
core_push.call( ret, arr );
}
}
return ret;
},
inArray: function( elem, arr, i ) {
var len;
if ( arr ) {
if ( core_indexOf ) {
return core_indexOf.call( arr, elem, i );
}
len = arr.length;
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
for ( ; i < len; i++ ) {
// Skip accessing in sparse arrays
if ( i in arr && arr[ i ] === elem ) {
return i;
}
}
}
return -1;
},
merge: function( first, second ) {
var l = second.length,
i = first.length,
j = 0;
if ( typeof l === "number" ) {
for ( ; j < l; j++ ) {
first[ i++ ] = second[ j ];
}
} else {
while ( second[j] !== undefined ) {
first[ i++ ] = second[ j++ ];
}
}
first.length = i;
return first;
},
grep: function( elems, callback, inv ) {
var retVal,
ret = [],
i = 0,
length = elems.length;
inv = !!inv;
// Go through the array, only saving the items
// that pass the validator function
for ( ; i < length; i++ ) {
retVal = !!callback( elems[ i ], i );
if ( inv !== retVal ) {
ret.push( elems[ i ] );
}
}
return ret;
},
// arg is for internal usage only
map: function( elems, callback, arg ) {
var value,
i = 0,
length = elems.length,
isArray = isArraylike( elems ),
ret = [];
// Go through the array, translating each of the items to their
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
// Go through every key on the object,
} else {
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret[ ret.length ] = value;
}
}
}
// Flatten any nested arrays
return core_concat.apply( [], ret );
},
// A global GUID counter for objects
guid: 1,
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function( fn, context ) {
var args, proxy, tmp;
if ( typeof context === "string" ) {
tmp = fn[ context ];
context = fn;
fn = tmp;
}
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !jQuery.isFunction( fn ) ) {
return undefined;
}
// Simulated bind
args = core_slice.call( arguments, 2 );
proxy = function() {
return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
};
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
return proxy;
},
// Multifunctional method to get and set values of a collection
// The value/s can optionally be executed if it's a function
access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
var i = 0,
length = elems.length,
bulk = key == null;
// Sets many values
if ( jQuery.type( key ) === "object" ) {
chainable = true;
for ( i in key ) {
jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
}
// Sets one value
} else if ( value !== undefined ) {
chainable = true;
if ( !jQuery.isFunction( value ) ) {
raw = true;
}
if ( bulk ) {
// Bulk operations run against the entire set
if ( raw ) {
fn.call( elems, value );
fn = null;
// ...except when executing function values
} else {
bulk = fn;
fn = function( elem, key, value ) {
return bulk.call( jQuery( elem ), value );
};
}
}
if ( fn ) {
for ( ; i < length; i++ ) {
fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
}
}
}
return chainable ?
elems :
// Gets
bulk ?
fn.call( elems ) :
length ? fn( elems[0], key ) : emptyGet;
},
now: function() {
return ( new Date() ).getTime();
}
});
jQuery.ready.promise = function( obj ) {
if ( !readyList ) {
readyList = jQuery.Deferred();
// Catch cases where $(document).ready() is called after the browser event has already occurred.
// we once tried to use readyState "interactive" here, but it caused issues like the one
// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
if ( document.readyState === "complete" ) {
// Handle it asynchronously to allow scripts the opportunity to delay ready
setTimeout( jQuery.ready );
// Standards-based browsers support DOMContentLoaded
} else if ( document.addEventListener ) {
// Use the handy event callback
document.addEventListener( "DOMContentLoaded", completed, false );
// A fallback to window.onload, that will always work
window.addEventListener( "load", completed, false );
// If IE event model is used
} else {
// Ensure firing before onload, maybe late but safe also for iframes
document.attachEvent( "onreadystatechange", completed );
// A fallback to window.onload, that will always work
window.attachEvent( "onload", completed );
// If IE and not a frame
// continually check to see if the document is ready
var top = false;
try {
top = window.frameElement == null && document.documentElement;
} catch(e) {}
if ( top && top.doScroll ) {
(function doScrollCheck() {
if ( !jQuery.isReady ) {
try {
// Use the trick by Diego Perini
// http://javascript.nwbox.com/IEContentLoaded/
top.doScroll("left");
} catch(e) {
return setTimeout( doScrollCheck, 50 );
}
// detach all dom ready events
detach();
// and execute any waiting functions
jQuery.ready();
}
})();
}
}
}
return readyList.promise( obj );
};
// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
});
function isArraylike( obj ) {
var length = obj.length,
type = jQuery.type( obj );
if ( jQuery.isWindow( obj ) ) {
return false;
}
if ( obj.nodeType === 1 && length ) {
return true;
}
return type === "array" || type !== "function" &&
( length === 0 ||
typeof length === "number" && length > 0 && ( length - 1 ) in obj );
}
// All jQuery objects should point back to these
rootjQuery = jQuery(document);
// String to Object options format cache
var optionsCache = {};
// Convert String-formatted options into Object-formatted ones and store in cache
function createOptions( options ) {
var object = optionsCache[ options ] = {};
jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
object[ flag ] = true;
});
return object;
}
/*
* Create a callback list using the following parameters:
*
* options: an optional list of space-separated options that will change how
* the callback list behaves or a more traditional option object
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible options:
*
* once: will ensure the callback list can only be fired once (like a Deferred)
*
* memory: will keep track of previous values and will call any callback added
* after the list has been fired right away with the latest "memorized"
* values (like a Deferred)
*
* unique: will ensure a callback can only be added once (no duplicate in the list)
*
* stopOnFalse: interrupt callings when a callback returns false
*
*/
jQuery.Callbacks = function( options ) {
// Convert options from String-formatted to Object-formatted if needed
// (we check in cache first)
options = typeof options === "string" ?
( optionsCache[ options ] || createOptions( options ) ) :
jQuery.extend( {}, options );
var // Flag to know if list is currently firing
firing,
// Last fire value (for non-forgettable lists)
memory,
// Flag to know if list was already fired
fired,
// End of the loop when firing
firingLength,
// Index of currently firing callback (modified by remove if needed)
firingIndex,
// First callback to fire (used internally by add and fireWith)
firingStart,
// Actual callback list
list = [],
// Stack of fire calls for repeatable lists
stack = !options.once && [],
// Fire callbacks
fire = function( data ) {
memory = options.memory && data;
fired = true;
firingIndex = firingStart || 0;
firingStart = 0;
firingLength = list.length;
firing = true;
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
memory = false; // To prevent further calls using add
break;
}
}
firing = false;
if ( list ) {
if ( stack ) {
if ( stack.length ) {
fire( stack.shift() );
}
} else if ( memory ) {
list = [];
} else {
self.disable();
}
}
},
// Actual Callbacks object
self = {
// Add a callback or a collection of callbacks to the list
add: function() {
if ( list ) {
// First, we save the current length
var start = list.length;
(function add( args ) {
jQuery.each( args, function( _, arg ) {
var type = jQuery.type( arg );
if ( type === "function" ) {
if ( !options.unique || !self.has( arg ) ) {
list.push( arg );
}
} else if ( arg && arg.length && type !== "string" ) {
// Inspect recursively
add( arg );
}
});
})( arguments );
// Do we need to add the callbacks to the
// current firing batch?
if ( firing ) {
firingLength = list.length;
// With memory, if we're not firing then
// we should call right away
} else if ( memory ) {
firingStart = start;
fire( memory );
}
}
return this;
},
// Remove a callback from the list
remove: function() {
if ( list ) {
jQuery.each( arguments, function( _, arg ) {
var index;
while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
list.splice( index, 1 );
// Handle firing indexes
if ( firing ) {
if ( index <= firingLength ) {
firingLength--;
}
if ( index <= firingIndex ) {
firingIndex--;
}
}
}
});
}
return this;
},
// Check if a given callback is in the list.
// If no argument is given, return whether or not list has callbacks attached.
has: function( fn ) {
return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
},
// Remove all callbacks from the list
empty: function() {
list = [];
return this;
},
// Have the list do nothing anymore
disable: function() {
list = stack = memory = undefined;
return this;
},
// Is it disabled?
disabled: function() {
return !list;
},
// Lock the list in its current state
lock: function() {
stack = undefined;
if ( !memory ) {
self.disable();
}
return this;
},
// Is it locked?
locked: function() {
return !stack;
},
// Call all callbacks with the given context and arguments
fireWith: function( context, args ) {
args = args || [];
args = [ context, args.slice ? args.slice() : args ];
if ( list && ( !fired || stack ) ) {
if ( firing ) {
stack.push( args );
} else {
fire( args );
}
}
return this;
},
// Call all the callbacks with the given arguments
fire: function() {
self.fireWith( this, arguments );
return this;
},
// To know if the callbacks have already been called at least once
fired: function() {
return !!fired;
}
};
return self;
};
jQuery.extend({
Deferred: function( func ) {
var tuples = [
// action, add listener, listener list, final state
[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
[ "notify", "progress", jQuery.Callbacks("memory") ]
],
state = "pending",
promise = {
state: function() {
return state;
},
always: function() {
deferred.done( arguments ).fail( arguments );
return this;
},
then: function( /* fnDone, fnFail, fnProgress */ ) {
var fns = arguments;
return jQuery.Deferred(function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
var action = tuple[ 0 ],
fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
deferred[ tuple[1] ](function() {
var returned = fn && fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
} else {
newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
}
});
});
fns = null;
}).promise();
},
// Get a promise for this deferred
// If obj is provided, the promise aspect is added to the object
promise: function( obj ) {
return obj != null ? jQuery.extend( obj, promise ) : promise;
}
},
deferred = {};
// Keep pipe for back-compat
promise.pipe = promise.then;
// Add list-specific methods
jQuery.each( tuples, function( i, tuple ) {
var list = tuple[ 2 ],
stateString = tuple[ 3 ];
// promise[ done | fail | progress ] = list.add
promise[ tuple[1] ] = list.add;
// Handle state
if ( stateString ) {
list.add(function() {
// state = [ resolved | rejected ]
state = stateString;
// [ reject_list | resolve_list ].disable; progress_list.lock
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
}
// deferred[ resolve | reject | notify ]
deferred[ tuple[0] ] = function() {
deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
return this;
};
deferred[ tuple[0] + "With" ] = list.fireWith;
});
// Make the deferred a promise
promise.promise( deferred );
// Call given func if any
if ( func ) {
func.call( deferred, deferred );
}
// All done!
return deferred;
},
// Deferred helper
when: function( subordinate /* , ..., subordinateN */ ) {
var i = 0,
resolveValues = core_slice.call( arguments ),
length = resolveValues.length,
// the count of uncompleted subordinates
remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
// Update function for both resolve and progress values
updateFunc = function( i, contexts, values ) {
return function( value ) {
contexts[ i ] = this;
values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
if( values === progressValues ) {
deferred.notifyWith( contexts, values );
} else if ( !( --remaining ) ) {
deferred.resolveWith( contexts, values );
}
};
},
progressValues, progressContexts, resolveContexts;
// add listeners to Deferred subordinates; treat others as resolved
if ( length > 1 ) {
progressValues = new Array( length );
progressContexts = new Array( length );
resolveContexts = new Array( length );
for ( ; i < length; i++ ) {
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
resolveValues[ i ].promise()
.done( updateFunc( i, resolveContexts, resolveValues ) )
.fail( deferred.reject )
.progress( updateFunc( i, progressContexts, progressValues ) );
} else {
--remaining;
}
}
}
// if we're not waiting on anything, resolve the master
if ( !remaining ) {
deferred.resolveWith( resolveContexts, resolveValues );
}
return deferred.promise();
}
});
jQuery.support = (function() {
var support, all, a,
input, select, fragment,
opt, eventName, isSupported, i,
div = document.createElement("div");
// Setup
div.setAttribute( "className", "t" );
div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
// Support tests won't run in some limited or non-browser environments
all = div.getElementsByTagName("*");
a = div.getElementsByTagName("a")[ 0 ];
if ( !all || !a || !all.length ) {
return {};
}
// First batch of tests
select = document.createElement("select");
opt = select.appendChild( document.createElement("option") );
input = div.getElementsByTagName("input")[ 0 ];
a.style.cssText = "top:1px;float:left;opacity:.5";
support = {
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
getSetAttribute: div.className !== "t",
// IE strips leading whitespace when .innerHTML is used
leadingWhitespace: div.firstChild.nodeType === 3,
// Make sure that tbody elements aren't automatically inserted
// IE will insert them into empty tables
tbody: !div.getElementsByTagName("tbody").length,
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
htmlSerialize: !!div.getElementsByTagName("link").length,
// Get the style information from getAttribute
// (IE uses .cssText instead)
style: /top/.test( a.getAttribute("style") ),
// Make sure that URLs aren't manipulated
// (IE normalizes it by default)
hrefNormalized: a.getAttribute("href") === "/a",
// Make sure that element opacity exists
// (IE uses filter instead)
// Use a regex to work around a WebKit issue. See #5145
opacity: /^0.5/.test( a.style.opacity ),
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
cssFloat: !!a.style.cssFloat,
// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
checkOn: !!input.value,
// Make sure that a selected-by-default option has a working selected property.
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
optSelected: opt.selected,
// Tests for enctype support on a form (#6743)
enctype: !!document.createElement("form").enctype,
// Makes sure cloning an html5 element does not cause problems
// Where outerHTML is undefined, this still works
html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
boxModel: document.compatMode === "CSS1Compat",
// Will be defined later
deleteExpando: true,
noCloneEvent: true,
inlineBlockNeedsLayout: false,
shrinkWrapBlocks: false,
reliableMarginRight: true,
boxSizingReliable: true,
pixelPosition: false
};
// Make sure checked status is properly cloned
input.checked = true;
support.noCloneChecked = input.cloneNode( true ).checked;
// Make sure that the options inside disabled selects aren't marked as disabled
// (WebKit marks them as disabled)
select.disabled = true;
support.optDisabled = !opt.disabled;
// Support: IE<9
try {
delete div.test;
} catch( e ) {
support.deleteExpando = false;
}
// Check if we can trust getAttribute("value")
input = document.createElement("input");
input.setAttribute( "value", "" );
support.input = input.getAttribute( "value" ) === "";
// Check if an input maintains its value after becoming a radio
input.value = "t";
input.setAttribute( "type", "radio" );
support.radioValue = input.value === "t";
// #11217 - WebKit loses check when the name is after the checked attribute
input.setAttribute( "checked", "t" );
input.setAttribute( "name", "t" );
fragment = document.createDocumentFragment();
fragment.appendChild( input );
// Check if a disconnected checkbox will retain its checked
// value of true after appended to the DOM (IE6/7)
support.appendChecked = input.checked;
// WebKit doesn't clone checked state correctly in fragments
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
// Support: IE<9
// Opera does not clone events (and typeof div.attachEvent === undefined).
// IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
if ( div.attachEvent ) {
div.attachEvent( "onclick", function() {
support.noCloneEvent = false;
});
div.cloneNode( true ).click();
}
// Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
for ( i in { submit: true, change: true, focusin: true }) {
div.setAttribute( eventName = "on" + i, "t" );
support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
}
div.style.backgroundClip = "content-box";
div.cloneNode( true ).style.backgroundClip = "";
support.clearCloneStyle = div.style.backgroundClip === "content-box";
// Run tests that need a body at doc ready
jQuery(function() {
var container, marginDiv, tds,
divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
body = document.getElementsByTagName("body")[0];
if ( !body ) {
// Return for frameset docs that don't have a body
return;
}
container = document.createElement("div");
container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
body.appendChild( container ).appendChild( div );
// Support: IE8
// Check if table cells still have offsetWidth/Height when they are set
// to display:none and there are still other visible table cells in a
// table row; if so, offsetWidth/Height are not reliable for use when
// determining if an element has been hidden directly using
// display:none (it is still safe to use offsets if a parent element is
// hidden; don safety goggles and see bug #4512 for more information).
div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
tds = div.getElementsByTagName("td");
tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
isSupported = ( tds[ 0 ].offsetHeight === 0 );
tds[ 0 ].style.display = "";
tds[ 1 ].style.display = "none";
// Support: IE8
// Check if empty table cells still have offsetWidth/Height
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
// Check box-sizing and margin behavior
div.innerHTML = "";
div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
support.boxSizing = ( div.offsetWidth === 4 );
support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
// Use window.getComputedStyle because jsdom on node.js will break without it.
if ( window.getComputedStyle ) {
support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
// Check if div with explicit width and no margin-right incorrectly
// gets computed margin-right based on width of container. (#3333)
// Fails in WebKit before Feb 2011 nightlies
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
marginDiv = div.appendChild( document.createElement("div") );
marginDiv.style.cssText = div.style.cssText = divReset;
marginDiv.style.marginRight = marginDiv.style.width = "0";
div.style.width = "1px";
support.reliableMarginRight =
!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
}
if ( typeof div.style.zoom !== core_strundefined ) {
// Support: IE<8
// Check if natively block-level elements act like inline-block
// elements when setting their display to 'inline' and giving
// them layout
div.innerHTML = "";
div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
// Support: IE6
// Check if elements with layout shrink-wrap their children
div.style.display = "block";
div.innerHTML = "<div></div>";
div.firstChild.style.width = "5px";
support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
if ( support.inlineBlockNeedsLayout ) {
// Prevent IE 6 from affecting layout for positioned elements #11048
// Prevent IE from shrinking the body in IE 7 mode #12869
// Support: IE<8
body.style.zoom = 1;
}
}
body.removeChild( container );
// Null elements to avoid leaks in IE
container = div = tds = marginDiv = null;
});
// Null elements to avoid leaks in IE
all = select = fragment = opt = a = input = null;
return support;
})();
var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
rmultiDash = /([A-Z])/g;
function internalData( elem, name, data, pvt /* Internal Use Only */ ){
if ( !jQuery.acceptData( elem ) ) {
return;
}
var thisCache, ret,
internalKey = jQuery.expando,
getByName = typeof name === "string",
// We have to handle DOM nodes and JS objects differently because IE6-7
// can't GC object references properly across the DOM-JS boundary
isNode = elem.nodeType,
// Only DOM nodes need the global jQuery cache; JS object data is
// attached directly to the object so GC can occur automatically
cache = isNode ? jQuery.cache : elem,
// Only defining an ID for JS objects if its cache already exists allows
// the code to shortcut on the same path as a DOM node with no cache
id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
// Avoid doing any more work than we need to when trying to get data on an
// object that has no data at all
if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
return;
}
if ( !id ) {
// Only DOM nodes need a new unique ID for each element since their data
// ends up in the global cache
if ( isNode ) {
elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
} else {
id = internalKey;
}
}
if ( !cache[ id ] ) {
cache[ id ] = {};
// Avoids exposing jQuery metadata on plain JS objects when the object
// is serialized using JSON.stringify
if ( !isNode ) {
cache[ id ].toJSON = jQuery.noop;
}
}
// An object can be passed to jQuery.data instead of a key/value pair; this gets
// shallow copied over onto the existing cache
if ( typeof name === "object" || typeof name === "function" ) {
if ( pvt ) {
cache[ id ] = jQuery.extend( cache[ id ], name );
} else {
cache[ id ].data = jQuery.extend( cache[ id ].data, name );
}
}
thisCache = cache[ id ];
// jQuery data() is stored in a separate object inside the object's internal data
// cache in order to avoid key collisions between internal data and user-defined
// data.
if ( !pvt ) {
if ( !thisCache.data ) {
thisCache.data = {};
}
thisCache = thisCache.data;
}
if ( data !== undefined ) {
thisCache[ jQuery.camelCase( name ) ] = data;
}
// Check for both converted-to-camel and non-converted data property names
// If a data property was specified
if ( getByName ) {
// First Try to find as-is property data
ret = thisCache[ name ];
// Test for null|undefined property data
if ( ret == null ) {
// Try to find the camelCased property
ret = thisCache[ jQuery.camelCase( name ) ];
}
} else {
ret = thisCache;
}
return ret;
}
function internalRemoveData( elem, name, pvt ) {
if ( !jQuery.acceptData( elem ) ) {
return;
}
var i, l, thisCache,
isNode = elem.nodeType,
// See jQuery.data for more information
cache = isNode ? jQuery.cache : elem,
id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
// If there is already no cache entry for this object, there is no
// purpose in continuing
if ( !cache[ id ] ) {
return;
}
if ( name ) {
thisCache = pvt ? cache[ id ] : cache[ id ].data;
if ( thisCache ) {
// Support array or space separated string names for data keys
if ( !jQuery.isArray( name ) ) {
// try the string as a key before any manipulation
if ( name in thisCache ) {
name = [ name ];
} else {
// split the camel cased version by spaces unless a key with the spaces exists
name = jQuery.camelCase( name );
if ( name in thisCache ) {
name = [ name ];
} else {
name = name.split(" ");
}
}
} else {
// If "name" is an array of keys...
// When data is initially created, via ("key", "val") signature,
// keys will be converted to camelCase.
// Since there is no way to tell _how_ a key was added, remove
// both plain key and camelCase key. #12786
// This will only penalize the array argument path.
name = name.concat( jQuery.map( name, jQuery.camelCase ) );
}
for ( i = 0, l = name.length; i < l; i++ ) {
delete thisCache[ name[i] ];
}
// If there is no data left in the cache, we want to continue
// and let the cache object itself get destroyed
if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
return;
}
}
}
// See jQuery.data for more information
if ( !pvt ) {
delete cache[ id ].data;
// Don't destroy the parent cache unless the internal data object
// had been the only thing left in it
if ( !isEmptyDataObject( cache[ id ] ) ) {
return;
}
}
// Destroy the cache
if ( isNode ) {
jQuery.cleanData( [ elem ], true );
// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
delete cache[ id ];
// When all else fails, null
} else {
cache[ id ] = null;
}
}
jQuery.extend({
cache: {},
// Unique for each copy of jQuery on the page
// Non-digits removed to match rinlinejQuery
expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
noData: {
"embed": true,
// Ban all objects except for Flash (which handle expandos)
"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
"applet": true
},
hasData: function( elem ) {
elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
return !!elem && !isEmptyDataObject( elem );
},
data: function( elem, name, data ) {
return internalData( elem, name, data );
},
removeData: function( elem, name ) {
return internalRemoveData( elem, name );
},
// For internal use only.
_data: function( elem, name, data ) {
return internalData( elem, name, data, true );
},
_removeData: function( elem, name ) {
return internalRemoveData( elem, name, true );
},
// A method for determining if a DOM node can handle the data expando
acceptData: function( elem ) {
// Do not set data on non-element because it will not be cleared (#8335).
if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
return false;
}
var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
// nodes accept data unless otherwise specified; rejection can be conditional
return !noData || noData !== true && elem.getAttribute("classid") === noData;
}
});
jQuery.fn.extend({
data: function( key, value ) {
var attrs, name,
elem = this[0],
i = 0,
data = null;
// Gets all values
if ( key === undefined ) {
if ( this.length ) {
data = jQuery.data( elem );
if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
attrs = elem.attributes;
for ( ; i < attrs.length; i++ ) {
name = attrs[i].name;
if ( !name.indexOf( "data-" ) ) {
name = jQuery.camelCase( name.slice(5) );
dataAttr( elem, name, data[ name ] );
}
}
jQuery._data( elem, "parsedAttrs", true );
}
}
return data;
}
// Sets multiple values
if ( typeof key === "object" ) {
return this.each(function() {
jQuery.data( this, key );
});
}
return jQuery.access( this, function( value ) {
if ( value === undefined ) {
// Try to fetch any internally stored data first
return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
}
this.each(function() {
jQuery.data( this, key, value );
});
}, null, value, arguments.length > 1, null, true );
},
removeData: function( key ) {
return this.each(function() {
jQuery.removeData( this, key );
});
}
});
function dataAttr( elem, key, data ) {
// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if ( data === undefined && elem.nodeType === 1 ) {
var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
data = elem.getAttribute( name );
if ( typeof data === "string" ) {
try {
data = data === "true" ? true :
data === "false" ? false :
data === "null" ? null :
// Only convert to a number if it doesn't change the string
+data + "" === data ? +data :
rbrace.test( data ) ? jQuery.parseJSON( data ) :
data;
} catch( e ) {}
// Make sure we set the data so it isn't changed later
jQuery.data( elem, key, data );
} else {
data = undefined;
}
}
return data;
}
// checks a cache object for emptiness
function isEmptyDataObject( obj ) {
var name;
for ( name in obj ) {
// if the public data object is empty, the private is still empty
if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
continue;
}
if ( name !== "toJSON" ) {
return false;
}
}
return true;
}
jQuery.extend({
queue: function( elem, type, data ) {
var queue;
if ( elem ) {
type = ( type || "fx" ) + "queue";
queue = jQuery._data( elem, type );
// Speed up dequeue by getting out quickly if this is just a lookup
if ( data ) {
if ( !queue || jQuery.isArray(data) ) {
queue = jQuery._data( elem, type, jQuery.makeArray(data) );
} else {
queue.push( data );
}
}
return queue || [];
}
},
dequeue: function( elem, type ) {
type = type || "fx";
var queue = jQuery.queue( elem, type ),
startLength = queue.length,
fn = queue.shift(),
hooks = jQuery._queueHooks( elem, type ),
next = function() {
jQuery.dequeue( elem, type );
};
// If the fx queue is dequeued, always remove the progress sentinel
if ( fn === "inprogress" ) {
fn = queue.shift();
startLength--;
}
hooks.cur = fn;
if ( fn ) {
// Add a progress sentinel to prevent the fx queue from being
// automatically dequeued
if ( type === "fx" ) {
queue.unshift( "inprogress" );
}
// clear up the last queue stop function
delete hooks.stop;
fn.call( elem, next, hooks );
}
if ( !startLength && hooks ) {
hooks.empty.fire();
}
},
// not intended for public consumption - generates a queueHooks object, or returns the current one
_queueHooks: function( elem, type ) {
var key = type + "queueHooks";
return jQuery._data( elem, key ) || jQuery._data( elem, key, {
empty: jQuery.Callbacks("once memory").add(function() {
jQuery._removeData( elem, type + "queue" );
jQuery._removeData( elem, key );
})
});
}
});
jQuery.fn.extend({
queue: function( type, data ) {
var setter = 2;
if ( typeof type !== "string" ) {
data = type;
type = "fx";
setter--;
}
if ( arguments.length < setter ) {
return jQuery.queue( this[0], type );
}
return data === undefined ?
this :
this.each(function() {
var queue = jQuery.queue( this, type, data );
// ensure a hooks for this queue
jQuery._queueHooks( this, type );
if ( type === "fx" && queue[0] !== "inprogress" ) {
jQuery.dequeue( this, type );
}
});
},
dequeue: function( type ) {
return this.each(function() {
jQuery.dequeue( this, type );
});
},
// Based off of the plugin by Clint Helfers, with permission.
// http://blindsignals.com/index.php/2009/07/jquery-delay/
delay: function( time, type ) {
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
type = type || "fx";
return this.queue( type, function( next, hooks ) {
var timeout = setTimeout( next, time );
hooks.stop = function() {
clearTimeout( timeout );
};
});
},
clearQueue: function( type ) {
return this.queue( type || "fx", [] );
},
// Get a promise resolved when queues of a certain type
// are emptied (fx is the type by default)
promise: function( type, obj ) {
var tmp,
count = 1,
defer = jQuery.Deferred(),
elements = this,
i = this.length,
resolve = function() {
if ( !( --count ) ) {
defer.resolveWith( elements, [ elements ] );
}
};
if ( typeof type !== "string" ) {
obj = type;
type = undefined;
}
type = type || "fx";
while( i-- ) {
tmp = jQuery._data( elements[ i ], type + "queueHooks" );
if ( tmp && tmp.empty ) {
count++;
tmp.empty.add( resolve );
}
}
resolve();
return defer.promise( obj );
}
});
var nodeHook, boolHook,
rclass = /[\t\r\n]/g,
rreturn = /\r/g,
rfocusable = /^(?:input|select|textarea|button|object)$/i,
rclickable = /^(?:a|area)$/i,
rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
ruseDefault = /^(?:checked|selected)$/i,
getSetAttribute = jQuery.support.getSetAttribute,
getSetInput = jQuery.support.input;
jQuery.fn.extend({
attr: function( name, value ) {
return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
},
removeAttr: function( name ) {
return this.each(function() {
jQuery.removeAttr( this, name );
});
},
prop: function( name, value ) {
return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
},
removeProp: function( name ) {
name = jQuery.propFix[ name ] || name;
return this.each(function() {
// try/catch handles cases where IE balks (such as removing a property on window)
try {
this[ name ] = undefined;
delete this[ name ];
} catch( e ) {}
});
},
addClass: function( value ) {
var classes, elem, cur, clazz, j,
i = 0,
len = this.length,
proceed = typeof value === "string" && value;
if ( jQuery.isFunction( value ) ) {
return this.each(function( j ) {
jQuery( this ).addClass( value.call( this, j, this.className ) );
});
}
if ( proceed ) {
// The disjunction here is for better compressibility (see removeClass)
classes = ( value || "" ).match( core_rnotwhite ) || [];
for ( ; i < len; i++ ) {
elem = this[ i ];
cur = elem.nodeType === 1 && ( elem.className ?
( " " + elem.className + " " ).replace( rclass, " " ) :
" "
);
if ( cur ) {
j = 0;
while ( (clazz = classes[j++]) ) {
if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
cur += clazz + " ";
}
}
elem.className = jQuery.trim( cur );
}
}
}
return this;
},
removeClass: function( value ) {
var classes, elem, cur, clazz, j,
i = 0,
len = this.length,
proceed = arguments.length === 0 || typeof value === "string" && value;
if ( jQuery.isFunction( value ) ) {
return this.each(function( j ) {
jQuery( this ).removeClass( value.call( this, j, this.className ) );
});
}
if ( proceed ) {
classes = ( value || "" ).match( core_rnotwhite ) || [];
for ( ; i < len; i++ ) {
elem = this[ i ];
// This expression is here for better compressibility (see addClass)
cur = elem.nodeType === 1 && ( elem.className ?
( " " + elem.className + " " ).replace( rclass, " " ) :
""
);
if ( cur ) {
j = 0;
while ( (clazz = classes[j++]) ) {
// Remove *all* instances
while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
cur = cur.replace( " " + clazz + " ", " " );
}
}
elem.className = value ? jQuery.trim( cur ) : "";
}
}
}
return this;
},
toggleClass: function( value, stateVal ) {
var type = typeof value,
isBool = typeof stateVal === "boolean";
if ( jQuery.isFunction( value ) ) {
return this.each(function( i ) {
jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
});
}
return this.each(function() {
if ( type === "string" ) {
// toggle individual class names
var className,
i = 0,
self = jQuery( this ),
state = stateVal,
classNames = value.match( core_rnotwhite ) || [];
while ( (className = classNames[ i++ ]) ) {
// check each className given, space separated list
state = isBool ? state : !self.hasClass( className );
self[ state ? "addClass" : "removeClass" ]( className );
}
// Toggle whole class name
} else if ( type === core_strundefined || type === "boolean" ) {
if ( this.className ) {
// store className if set
jQuery._data( this, "__className__", this.className );
}
// If the element has a class name or if we're passed "false",
// then remove the whole classname (if there was one, the above saved it).
// Otherwise bring back whatever was previously saved (if anything),
// falling back to the empty string if nothing was stored.
this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
}
});
},
hasClass: function( selector ) {
var className = " " + selector + " ",
i = 0,
l = this.length;
for ( ; i < l; i++ ) {
if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
return true;
}
}
return false;
},
val: function( value ) {
var ret, hooks, isFunction,
elem = this[0];
if ( !arguments.length ) {
if ( elem ) {
hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
return ret;
}
ret = elem.value;
return typeof ret === "string" ?
// handle most common string cases
ret.replace(rreturn, "") :
// handle cases where value is null/undef or number
ret == null ? "" : ret;
}
return;
}
isFunction = jQuery.isFunction( value );
return this.each(function( i ) {
var val,
self = jQuery(this);
if ( this.nodeType !== 1 ) {
return;
}
if ( isFunction ) {
val = value.call( this, i, self.val() );
} else {
val = value;
}
// Treat null/undefined as ""; convert numbers to string
if ( val == null ) {
val = "";
} else if ( typeof val === "number" ) {
val += "";
} else if ( jQuery.isArray( val ) ) {
val = jQuery.map(val, function ( value ) {
return value == null ? "" : value + "";
});
}
hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
// If set returns undefined, fall back to normal setting
if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
this.value = val;
}
});
}
});
jQuery.extend({
valHooks: {
option: {
get: function( elem ) {
// attributes.value is undefined in Blackberry 4.7 but
// uses .value. See #6932
var val = elem.attributes.value;
return !val || val.specified ? elem.value : elem.text;
}
},
select: {
get: function( elem ) {
var value, option,
options = elem.options,
index = elem.selectedIndex,
one = elem.type === "select-one" || index < 0,
values = one ? null : [],
max = one ? index + 1 : options.length,
i = index < 0 ?
max :
one ? index : 0;
// Loop through all the selected options
for ( ; i < max; i++ ) {
option = options[ i ];
// oldIE doesn't update selected after form reset (#2551)
if ( ( option.selected || i === index ) &&
// Don't return options that are disabled or in a disabled optgroup
( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
// Get the specific value for the option
value = jQuery( option ).val();
// We don't need an array for one selects
if ( one ) {
return value;
}
// Multi-Selects return an array
values.push( value );
}
}
return values;
},
set: function( elem, value ) {
var values = jQuery.makeArray( value );
jQuery(elem).find("option").each(function() {
this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
});
if ( !values.length ) {
elem.selectedIndex = -1;
}
return values;
}
}
},
attr: function( elem, name, value ) {
var hooks, notxml, ret,
nType = elem.nodeType;
// don't get/set attributes on text, comment and attribute nodes
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
return;
}
// Fallback to prop when attributes are not supported
if ( typeof elem.getAttribute === core_strundefined ) {
return jQuery.prop( elem, name, value );
}
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
// All attributes are lowercase
// Grab necessary hook if one is defined
if ( notxml ) {
name = name.toLowerCase();
hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
}
if ( value !== undefined ) {
if ( value === null ) {
jQuery.removeAttr( elem, name );
} else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
return ret;
} else {
elem.setAttribute( name, value + "" );
return value;
}
} else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
return ret;
} else {
// In IE9+, Flash objects don't have .getAttribute (#12945)
// Support: IE9+
if ( typeof elem.getAttribute !== core_strundefined ) {
ret = elem.getAttribute( name );
}
// Non-existent attributes return null, we normalize to undefined
return ret == null ?
undefined :
ret;
}
},
removeAttr: function( elem, value ) {
var name, propName,
i = 0,
attrNames = value && value.match( core_rnotwhite );
if ( attrNames && elem.nodeType === 1 ) {
while ( (name = attrNames[i++]) ) {
propName = jQuery.propFix[ name ] || name;
// Boolean attributes get special treatment (#10870)
if ( rboolean.test( name ) ) {
// Set corresponding property to false for boolean attributes
// Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
if ( !getSetAttribute && ruseDefault.test( name ) ) {
elem[ jQuery.camelCase( "default-" + name ) ] =
elem[ propName ] = false;
} else {
elem[ propName ] = false;
}
// See #9699 for explanation of this approach (setting first, then removal)
} else {
jQuery.attr( elem, name, "" );
}
elem.removeAttribute( getSetAttribute ? name : propName );
}
}
},
attrHooks: {
type: {
set: function( elem, value ) {
if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
// Setting the type on a radio button after the value resets the value in IE6-9
// Reset value to default in case type is set after value during creation
var val = elem.value;
elem.setAttribute( "type", value );
if ( val ) {
elem.value = val;
}
return value;
}
}
}
},
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( elem, name, value ) {
var ret, hooks, notxml,
nType = elem.nodeType;
// don't get/set properties on text, comment and attribute nodes
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
return;
}
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
if ( notxml ) {
// Fix name and attach hooks
name = jQuery.propFix[ name ] || name;
hooks = jQuery.propHooks[ name ];
}
if ( value !== undefined ) {
if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
return ret;
} else {
return ( elem[ name ] = value );
}
} else {
if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
return ret;
} else {
return elem[ name ];
}
}
},
propHooks: {
tabIndex: {
get: function( elem ) {
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
var attributeNode = elem.getAttributeNode("tabindex");
return attributeNode && attributeNode.specified ?
parseInt( attributeNode.value, 10 ) :
rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
0 :
undefined;
}
}
}
});
// Hook for boolean attributes
boolHook = {
get: function( elem, name ) {
var
// Use .prop to determine if this attribute is understood as boolean
prop = jQuery.prop( elem, name ),
// Fetch it accordingly
attr = typeof prop === "boolean" && elem.getAttribute( name ),
detail = typeof prop === "boolean" ?
getSetInput && getSetAttribute ?
attr != null :
// oldIE fabricates an empty string for missing boolean attributes
// and conflates checked/selected into attroperties
ruseDefault.test( name ) ?
elem[ jQuery.camelCase( "default-" + name ) ] :
!!attr :
// fetch an attribute node for properties not recognized as boolean
elem.getAttributeNode( name );
return detail && detail.value !== false ?
name.toLowerCase() :
undefined;
},
set: function( elem, value, name ) {
if ( value === false ) {
// Remove boolean attributes when set to false
jQuery.removeAttr( elem, name );
} else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
// IE<8 needs the *property* name
elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
// Use defaultChecked and defaultSelected for oldIE
} else {
elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
}
return name;
}
};
// fix oldIE value attroperty
if ( !getSetInput || !getSetAttribute ) {
jQuery.attrHooks.value = {
get: function( elem, name ) {
var ret = elem.getAttributeNode( name );
return jQuery.nodeName( elem, "input" ) ?
// Ignore the value *property* by using defaultValue
elem.defaultValue :
ret && ret.specified ? ret.value : undefined;
},
set: function( elem, value, name ) {
if ( jQuery.nodeName( elem, "input" ) ) {
// Does not return so that setAttribute is also used
elem.defaultValue = value;
} else {
// Use nodeHook if defined (#1954); otherwise setAttribute is fine
return nodeHook && nodeHook.set( elem, value, name );
}
}
};
}
// IE6/7 do not support getting/setting some attributes with get/setAttribute
if ( !getSetAttribute ) {
// Use this for any attribute in IE6/7
// This fixes almost every IE6/7 issue
nodeHook = jQuery.valHooks.button = {
get: function( elem, name ) {
var ret = elem.getAttributeNode( name );
return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
ret.value :
undefined;
},
set: function( elem, value, name ) {
// Set the existing or create a new attribute node
var ret = elem.getAttributeNode( name );
if ( !ret ) {
elem.setAttributeNode(
(ret = elem.ownerDocument.createAttribute( name ))
);
}
ret.value = value += "";
// Break association with cloned elements by also using setAttribute (#9646)
return name === "value" || value === elem.getAttribute( name ) ?
value :
undefined;
}
};
// Set contenteditable to false on removals(#10429)
// Setting to empty string throws an error as an invalid value
jQuery.attrHooks.contenteditable = {
get: nodeHook.get,
set: function( elem, value, name ) {
nodeHook.set( elem, value === "" ? false : value, name );
}
};
// Set width and height to auto instead of 0 on empty string( Bug #8150 )
// This is for removals
jQuery.each([ "width", "height" ], function( i, name ) {
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
set: function( elem, value ) {
if ( value === "" ) {
elem.setAttribute( name, "auto" );
return value;
}
}
});
});
}
// Some attributes require a special call on IE
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
if ( !jQuery.support.hrefNormalized ) {
jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
get: function( elem ) {
var ret = elem.getAttribute( name, 2 );
return ret == null ? undefined : ret;
}
});
});
// href/src property should get the full normalized URL (#10299/#12915)
jQuery.each([ "href", "src" ], function( i, name ) {
jQuery.propHooks[ name ] = {
get: function( elem ) {
return elem.getAttribute( name, 4 );
}
};
});
}
if ( !jQuery.support.style ) {
jQuery.attrHooks.style = {
get: function( elem ) {
// Return undefined in the case of empty string
// Note: IE uppercases css property names, but if we were to .toLowerCase()
// .cssText, that would destroy case senstitivity in URL's, like in "background"
return elem.style.cssText || undefined;
},
set: function( elem, value ) {
return ( elem.style.cssText = value + "" );
}
};
}
// Safari mis-reports the default selected property of an option
// Accessing the parent's selectedIndex property fixes it
if ( !jQuery.support.optSelected ) {
jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
get: function( elem ) {
var parent = elem.parentNode;
if ( parent ) {
parent.selectedIndex;
// Make sure that it also works with optgroups, see #5701
if ( parent.parentNode ) {
parent.parentNode.selectedIndex;
}
}
return null;
}
});
}
// IE6/7 call enctype encoding
if ( !jQuery.support.enctype ) {
jQuery.propFix.enctype = "encoding";
}
// Radios and checkboxes getter/setter
if ( !jQuery.support.checkOn ) {
jQuery.each([ "radio", "checkbox" ], function() {
jQuery.valHooks[ this ] = {
get: function( elem ) {
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
return elem.getAttribute("value") === null ? "on" : elem.value;
}
};
});
}
jQuery.each([ "radio", "checkbox" ], function() {
jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
set: function( elem, value ) {
if ( jQuery.isArray( value ) ) {
return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
}
}
});
});
var rformElems = /^(?:input|select|textarea)$/i,
rkeyEvent = /^key/,
rmouseEvent = /^(?:mouse|contextmenu)|click/,
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
function returnTrue() {
return true;
}
function returnFalse() {
return false;
}
/*
* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/
jQuery.event = {
global: {},
add: function( elem, types, handler, data, selector ) {
var tmp, events, t, handleObjIn,
special, eventHandle, handleObj,
handlers, type, namespaces, origType,
elemData = jQuery._data( elem );
// Don't attach events to noData or text/comment nodes (but allow plain objects)
if ( !elemData ) {
return;
}
// Caller can pass in an object of custom data in lieu of the handler
if ( handler.handler ) {
handleObjIn = handler;
handler = handleObjIn.handler;
selector = handleObjIn.selector;
}
// Make sure that the handler has a unique ID, used to find/remove it later
if ( !handler.guid ) {
handler.guid = jQuery.guid++;
}
// Init the element's event structure and main handler, if this is the first
if ( !(events = elemData.events) ) {
events = elemData.events = {};
}
if ( !(eventHandle = elemData.handle) ) {
eventHandle = elemData.handle = function( e ) {
// Discard the second event of a jQuery.event.trigger() and
// when an event is called after a page has unloaded
return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
undefined;
};
// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
eventHandle.elem = elem;
}
// Handle multiple events separated by a space
// jQuery(...).bind("mouseover mouseout", fn);
types = ( types || "" ).match( core_rnotwhite ) || [""];
t = types.length;
while ( t-- ) {
tmp = rtypenamespace.exec( types[t] ) || [];
type = origType = tmp[1];
namespaces = ( tmp[2] || "" ).split( "." ).sort();
// If event changes its type, use the special event handlers for the changed type
special = jQuery.event.special[ type ] || {};
// If selector defined, determine special event api type, otherwise given type
type = ( selector ? special.delegateType : special.bindType ) || type;
// Update special based on newly reset type
special = jQuery.event.special[ type ] || {};
// handleObj is passed to all event handlers
handleObj = jQuery.extend({
type: type,
origType: origType,
data: data,
handler: handler,
guid: handler.guid,
selector: selector,
needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
namespace: namespaces.join(".")
}, handleObjIn );
// Init the event handler queue if we're the first
if ( !(handlers = events[ type ]) ) {
handlers = events[ type ] = [];
handlers.delegateCount = 0;
// Only use addEventListener/attachEvent if the special events handler returns false
if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
// Bind the global event handler to the element
if ( elem.addEventListener ) {
elem.addEventListener( type, eventHandle, false );
} else if ( elem.attachEvent ) {
elem.attachEvent( "on" + type, eventHandle );
}
}
}
if ( special.add ) {
special.add.call( elem, handleObj );
if ( !handleObj.handler.guid ) {
handleObj.handler.guid = handler.guid;
}
}
// Add to the element's handler list, delegates in front
if ( selector ) {
handlers.splice( handlers.delegateCount++, 0, handleObj );
} else {
handlers.push( handleObj );
}
// Keep track of which events have ever been used, for event optimization
jQuery.event.global[ type ] = true;
}
// Nullify elem to prevent memory leaks in IE
elem = null;
},
// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {
var j, handleObj, tmp,
origCount, t, events,
special, handlers, type,
namespaces, origType,
elemData = jQuery.hasData( elem ) && jQuery._data( elem );
if ( !elemData || !(events = elemData.events) ) {
return;
}
// Once for each type.namespace in types; type may be omitted
types = ( types || "" ).match( core_rnotwhite ) || [""];
t = types.length;
while ( t-- ) {
tmp = rtypenamespace.exec( types[t] ) || [];
type = origType = tmp[1];
namespaces = ( tmp[2] || "" ).split( "." ).sort();
// Unbind all events (on this namespace, if provided) for the element
if ( !type ) {
for ( type in events ) {
jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
}
continue;
}
special = jQuery.event.special[ type ] || {};
type = ( selector ? special.delegateType : special.bindType ) || type;
handlers = events[ type ] || [];
tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
// Remove matching events
origCount = j = handlers.length;
while ( j-- ) {
handleObj = handlers[ j ];
if ( ( mappedTypes || origType === handleObj.origType ) &&
( !handler || handler.guid === handleObj.guid ) &&
( !tmp || tmp.test( handleObj.namespace ) ) &&
( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
handlers.splice( j, 1 );
if ( handleObj.selector ) {
handlers.delegateCount--;
}
if ( special.remove ) {
special.remove.call( elem, handleObj );
}
}
}
// Remove generic event handler if we removed something and no more handlers exist
// (avoids potential for endless recursion during removal of special event handlers)
if ( origCount && !handlers.length ) {
if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
jQuery.removeEvent( elem, type, elemData.handle );
}
delete events[ type ];
}
}
// Remove the expando if it's no longer used
if ( jQuery.isEmptyObject( events ) ) {
delete elemData.handle;
// removeData also checks for emptiness and clears the expando if empty
// so use it instead of delete
jQuery._removeData( elem, "events" );
}
},
trigger: function( event, data, elem, onlyHandlers ) {
var handle, ontype, cur,
bubbleType, special, tmp, i,
eventPath = [ elem || document ],
type = core_hasOwn.call( event, "type" ) ? event.type : event,
namespaces = core_hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
cur = tmp = elem = elem || document;
// Don't do events on text and comment nodes
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
return;
}
// focus/blur morphs to focusin/out; ensure we're not firing them right now
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
return;
}
if ( type.indexOf(".") >= 0 ) {
// Namespaced trigger; create a regexp to match event type in handle()
namespaces = type.split(".");
type = namespaces.shift();
namespaces.sort();
}
ontype = type.indexOf(":") < 0 && "on" + type;
// Caller can pass in a jQuery.Event object, Object, or just an event type string
event = event[ jQuery.expando ] ?
event :
new jQuery.Event( type, typeof event === "object" && event );
event.isTrigger = true;
event.namespace = namespaces.join(".");
event.namespace_re = event.namespace ?
new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
null;
// Clean up the event in case it is being reused
event.result = undefined;
if ( !event.target ) {
event.target = elem;
}
// Clone any incoming data and prepend the event, creating the handler arg list
data = data == null ?
[ event ] :
jQuery.makeArray( data, [ event ] );
// Allow special events to draw outside the lines
special = jQuery.event.special[ type ] || {};
if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
return;
}
// Determine event propagation path in advance, per W3C events spec (#9951)
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
bubbleType = special.delegateType || type;
if ( !rfocusMorph.test( bubbleType + type ) ) {
cur = cur.parentNode;
}
for ( ; cur; cur = cur.parentNode ) {
eventPath.push( cur );
tmp = cur;
}
// Only add window if we got to document (e.g., not plain obj or detached DOM)
if ( tmp === (elem.ownerDocument || document) ) {
eventPath.push( tmp.defaultView || tmp.parentWindow || window );
}
}
// Fire handlers on the event path
i = 0;
while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
event.type = i > 1 ?
bubbleType :
special.bindType || type;
// jQuery handler
handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
if ( handle ) {
handle.apply( cur, data );
}
// Native handler
handle = ontype && cur[ ontype ];
if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
event.preventDefault();
}
}
event.type = type;
// If nobody prevented the default action, do it now
if ( !onlyHandlers && !event.isDefaultPrevented() ) {
if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
// Call a native DOM method on the target with the same name name as the event.
// Can't use an .isFunction() check here because IE6/7 fails that test.
// Don't do default actions on window, that's where global variables be (#6170)
if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
// Don't re-trigger an onFOO event when we call its FOO() method
tmp = elem[ ontype ];
if ( tmp ) {
elem[ ontype ] = null;
}
// Prevent re-triggering of the same event, since we already bubbled it above
jQuery.event.triggered = type;
try {
elem[ type ]();
} catch ( e ) {
// IE<9 dies on focus/blur to hidden element (#1486,#12518)
// only reproducible on winXP IE8 native, not IE9 in IE8 mode
}
jQuery.event.triggered = undefined;
if ( tmp ) {
elem[ ontype ] = tmp;
}
}
}
}
return event.result;
},
dispatch: function( event ) {
// Make a writable jQuery.Event from the native event object
event = jQuery.event.fix( event );
var i, ret, handleObj, matched, j,
handlerQueue = [],
args = core_slice.call( arguments ),
handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
special = jQuery.event.special[ event.type ] || {};
// Use the fix-ed jQuery.Event rather than the (read-only) native event
args[0] = event;
event.delegateTarget = this;
// Call the preDispatch hook for the mapped type, and let it bail if desired
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
return;
}
// Determine handlers
handlerQueue = jQuery.event.handlers.call( this, event, handlers );
// Run delegates first; they may want to stop propagation beneath us
i = 0;
while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
event.currentTarget = matched.elem;
j = 0;
while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
// Triggered event must either 1) have no namespace, or
// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
event.handleObj = handleObj;
event.data = handleObj.data;
ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
.apply( matched.elem, args );
if ( ret !== undefined ) {
if ( (event.result = ret) === false ) {
event.preventDefault();
event.stopPropagation();
}
}
}
}
}
// Call the postDispatch hook for the mapped type
if ( special.postDispatch ) {
special.postDispatch.call( this, event );
}
return event.result;
},
handlers: function( event, handlers ) {
var sel, handleObj, matches, i,
handlerQueue = [],
delegateCount = handlers.delegateCount,
cur = event.target;
// Find delegate handlers
// Black-hole SVG <use> instance trees (#13180)
// Avoid non-left-click bubbling in Firefox (#3861)
if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
for ( ; cur != this; cur = cur.parentNode || this ) {
// Don't check non-elements (#13208)
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
matches = [];
for ( i = 0; i < delegateCount; i++ ) {
handleObj = handlers[ i ];
// Don't conflict with Object.prototype properties (#13203)
sel = handleObj.selector + " ";
if ( matches[ sel ] === undefined ) {
matches[ sel ] = handleObj.needsContext ?
jQuery( sel, this ).index( cur ) >= 0 :
jQuery.find( sel, this, null, [ cur ] ).length;
}
if ( matches[ sel ] ) {
matches.push( handleObj );
}
}
if ( matches.length ) {
handlerQueue.push({ elem: cur, handlers: matches });
}
}
}
}
// Add the remaining (directly-bound) handlers
if ( delegateCount < handlers.length ) {
handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
}
return handlerQueue;
},
fix: function( event ) {
if ( event[ jQuery.expando ] ) {
return event;
}
// Create a writable copy of the event object and normalize some properties
var i, prop, copy,
type = event.type,
originalEvent = event,
fixHook = this.fixHooks[ type ];
if ( !fixHook ) {
this.fixHooks[ type ] = fixHook =
rmouseEvent.test( type ) ? this.mouseHooks :
rkeyEvent.test( type ) ? this.keyHooks :
{};
}
copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
event = new jQuery.Event( originalEvent );
i = copy.length;
while ( i-- ) {
prop = copy[ i ];
event[ prop ] = originalEvent[ prop ];
}
// Support: IE<9
// Fix target property (#1925)
if ( !event.target ) {
event.target = originalEvent.srcElement || document;
}
// Support: Chrome 23+, Safari?
// Target should not be a text node (#504, #13143)
if ( event.target.nodeType === 3 ) {
event.target = event.target.parentNode;
}
// Support: IE<9
// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
event.metaKey = !!event.metaKey;
return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
},
// Includes some event props shared by KeyEvent and MouseEvent
props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
fixHooks: {},
keyHooks: {
props: "char charCode key keyCode".split(" "),
filter: function( event, original ) {
// Add which for key events
if ( event.which == null ) {
event.which = original.charCode != null ? original.charCode : original.keyCode;
}
return event;
}
},
mouseHooks: {
props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
filter: function( event, original ) {
var body, eventDoc, doc,
button = original.button,
fromElement = original.fromElement;
// Calculate pageX/Y if missing and clientX/Y available
if ( event.pageX == null && original.clientX != null ) {
eventDoc = event.target.ownerDocument || document;
doc = eventDoc.documentElement;
body = eventDoc.body;
event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
}
// Add relatedTarget, if necessary
if ( !event.relatedTarget && fromElement ) {
event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
}
// Add which for click: 1 === left; 2 === middle; 3 === right
// Note: button is not normalized, so don't use it
if ( !event.which && button !== undefined ) {
event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
}
return event;
}
},
special: {
load: {
// Prevent triggered image.load events from bubbling to window.load
noBubble: true
},
click: {
// For checkbox, fire native event so checked state will be right
trigger: function() {
if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
this.click();
return false;
}
}
},
focus: {
// Fire native event if possible so blur/focus sequence is correct
trigger: function() {
if ( this !== document.activeElement && this.focus ) {
try {
this.focus();
return false;
} catch ( e ) {
// Support: IE<9
// If we error on focus to hidden element (#1486, #12518),
// let .trigger() run the handlers
}
}
},
delegateType: "focusin"
},
blur: {
trigger: function() {
if ( this === document.activeElement && this.blur ) {
this.blur();
return false;
}
},
delegateType: "focusout"
},
beforeunload: {
postDispatch: function( event ) {
// Even when returnValue equals to undefined Firefox will still show alert
if ( event.result !== undefined ) {
event.originalEvent.returnValue = event.result;
}
}
}
},
simulate: function( type, elem, event, bubble ) {
// Piggyback on a donor event to simulate a different one.
// Fake originalEvent to avoid donor's stopPropagation, but if the
// simulated event prevents default then we do the same on the donor.
var e = jQuery.extend(
new jQuery.Event(),
event,
{ type: type,
isSimulated: true,
originalEvent: {}
}
);
if ( bubble ) {
jQuery.event.trigger( e, null, elem );
} else {
jQuery.event.dispatch.call( elem, e );
}
if ( e.isDefaultPrevented() ) {
event.preventDefault();
}
}
};
jQuery.removeEvent = document.removeEventListener ?
function( elem, type, handle ) {
if ( elem.removeEventListener ) {
elem.removeEventListener( type, handle, false );
}
} :
function( elem, type, handle ) {
var name = "on" + type;
if ( elem.detachEvent ) {
// #8545, #7054, preventing memory leaks for custom events in IE6-8
// detachEvent needed property on element, by name of that event, to properly expose it to GC
if ( typeof elem[ name ] === core_strundefined ) {
elem[ name ] = null;
}
elem.detachEvent( name, handle );
}
};
jQuery.Event = function( src, props ) {
// Allow instantiation without the 'new' keyword
if ( !(this instanceof jQuery.Event) ) {
return new jQuery.Event( src, props );
}
// Event object
if ( src && src.type ) {
this.originalEvent = src;
this.type = src.type;
// Events bubbling up the document may have been marked as prevented
// by a handler lower down the tree; reflect the correct value.
this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
// Event type
} else {
this.type = src;
}
// Put explicitly provided properties onto the event object
if ( props ) {
jQuery.extend( this, props );
}
// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || jQuery.now();
// Mark it as fixed
this[ jQuery.expando ] = true;
};
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse,
preventDefault: function() {
var e = this.originalEvent;
this.isDefaultPrevented = returnTrue;
if ( !e ) {
return;
}
// If preventDefault exists, run it on the original event
if ( e.preventDefault ) {
e.preventDefault();
// Support: IE
// Otherwise set the returnValue property of the original event to false
} else {
e.returnValue = false;
}
},
stopPropagation: function() {
var e = this.originalEvent;
this.isPropagationStopped = returnTrue;
if ( !e ) {
return;
}
// If stopPropagation exists, run it on the original event
if ( e.stopPropagation ) {
e.stopPropagation();
}
// Support: IE
// Set the cancelBubble property of the original event to true
e.cancelBubble = true;
},
stopImmediatePropagation: function() {
this.isImmediatePropagationStopped = returnTrue;
this.stopPropagation();
}
};
// Create mouseenter/leave events using mouseover/out and event-time checks
jQuery.each({
mouseenter: "mouseover",
mouseleave: "mouseout"
}, function( orig, fix ) {
jQuery.event.special[ orig ] = {
delegateType: fix,
bindType: fix,
handle: function( event ) {
var ret,
target = this,
related = event.relatedTarget,
handleObj = event.handleObj;
// For mousenter/leave call the handler if related is outside the target.
// NB: No relatedTarget if the mouse left/entered the browser window
if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
event.type = handleObj.origType;
ret = handleObj.handler.apply( this, arguments );
event.type = fix;
}
return ret;
}
};
});
// IE submit delegation
if ( !jQuery.support.submitBubbles ) {
jQuery.event.special.submit = {
setup: function() {
// Only need this for delegated form submit events
if ( jQuery.nodeName( this, "form" ) ) {
return false;
}
// Lazy-add a submit handler when a descendant form may potentially be submitted
jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
// Node name check avoids a VML-related crash in IE (#9807)
var elem = e.target,
form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
if ( form && !jQuery._data( form, "submitBubbles" ) ) {
jQuery.event.add( form, "submit._submit", function( event ) {
event._submit_bubble = true;
});
jQuery._data( form, "submitBubbles", true );
}
});
// return undefined since we don't need an event listener
},
postDispatch: function( event ) {
// If form was submitted by the user, bubble the event up the tree
if ( event._submit_bubble ) {
delete event._submit_bubble;
if ( this.parentNode && !event.isTrigger ) {
jQuery.event.simulate( "submit", this.parentNode, event, true );
}
}
},
teardown: function() {
// Only need this for delegated form submit events
if ( jQuery.nodeName( this, "form" ) ) {
return false;
}
// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
jQuery.event.remove( this, "._submit" );
}
};
}
// IE change delegation and checkbox/radio fix
if ( !jQuery.support.changeBubbles ) {
jQuery.event.special.change = {
setup: function() {
if ( rformElems.test( this.nodeName ) ) {
// IE doesn't fire change on a check/radio until blur; trigger it on click
// after a propertychange. Eat the blur-change in special.change.handle.
// This still fires onchange a second time for check/radio after blur.
if ( this.type === "checkbox" || this.type === "radio" ) {
jQuery.event.add( this, "propertychange._change", function( event ) {
if ( event.originalEvent.propertyName === "checked" ) {
this._just_changed = true;
}
});
jQuery.event.add( this, "click._change", function( event ) {
if ( this._just_changed && !event.isTrigger ) {
this._just_changed = false;
}
// Allow triggered, simulated change events (#11500)
jQuery.event.simulate( "change", this, event, true );
});
}
return false;
}
// Delegated event; lazy-add a change handler on descendant inputs
jQuery.event.add( this, "beforeactivate._change", function( e ) {
var elem = e.target;
if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
jQuery.event.add( elem, "change._change", function( event ) {
if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
jQuery.event.simulate( "change", this.parentNode, event, true );
}
});
jQuery._data( elem, "changeBubbles", true );
}
});
},
handle: function( event ) {
var elem = event.target;
// Swallow native change events from checkbox/radio, we already triggered them above
if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
return event.handleObj.handler.apply( this, arguments );
}
},
teardown: function() {
jQuery.event.remove( this, "._change" );
return !rformElems.test( this.nodeName );
}
};
}
// Create "bubbling" focus and blur events
if ( !jQuery.support.focusinBubbles ) {
jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
// Attach a single capturing handler while someone wants focusin/focusout
var attaches = 0,
handler = function( event ) {
jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
};
jQuery.event.special[ fix ] = {
setup: function() {
if ( attaches++ === 0 ) {
document.addEventListener( orig, handler, true );
}
},
teardown: function() {
if ( --attaches === 0 ) {
document.removeEventListener( orig, handler, true );
}
}
};
});
}
jQuery.fn.extend({
on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
var type, origFn;
// Types can be a map of types/handlers
if ( typeof types === "object" ) {
// ( types-Object, selector, data )
if ( typeof selector !== "string" ) {
// ( types-Object, data )
data = data || selector;
selector = undefined;
}
for ( type in types ) {
this.on( type, selector, data, types[ type ], one );
}
return this;
}
if ( data == null && fn == null ) {
// ( types, fn )
fn = selector;
data = selector = undefined;
} else if ( fn == null ) {
if ( typeof selector === "string" ) {
// ( types, selector, fn )
fn = data;
data = undefined;
} else {
// ( types, data, fn )
fn = data;
data = selector;
selector = undefined;
}
}
if ( fn === false ) {
fn = returnFalse;
} else if ( !fn ) {
return this;
}
if ( one === 1 ) {
origFn = fn;
fn = function( event ) {
// Can use an empty set, since event contains the info
jQuery().off( event );
return origFn.apply( this, arguments );
};
// Use same guid so caller can remove using origFn
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
}
return this.each( function() {
jQuery.event.add( this, types, fn, data, selector );
});
},
one: function( types, selector, data, fn ) {
return this.on( types, selector, data, fn, 1 );
},
off: function( types, selector, fn ) {
var handleObj, type;
if ( types && types.preventDefault && types.handleObj ) {
// ( event ) dispatched jQuery.Event
handleObj = types.handleObj;
jQuery( types.delegateTarget ).off(
handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
handleObj.selector,
handleObj.handler
);
return this;
}
if ( typeof types === "object" ) {
// ( types-object [, selector] )
for ( type in types ) {
this.off( type, selector, types[ type ] );
}
return this;
}
if ( selector === false || typeof selector === "function" ) {
// ( types [, fn] )
fn = selector;
selector = undefined;
}
if ( fn === false ) {
fn = returnFalse;
}
return this.each(function() {
jQuery.event.remove( this, types, fn, selector );
});
},
bind: function( types, data, fn ) {
return this.on( types, null, data, fn );
},
unbind: function( types, fn ) {
return this.off( types, null, fn );
},
delegate: function( selector, types, data, fn ) {
return this.on( types, selector, data, fn );
},
undelegate: function( selector, types, fn ) {
// ( namespace ) or ( selector, types [, fn] )
return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
},
trigger: function( type, data ) {
return this.each(function() {
jQuery.event.trigger( type, data, this );
});
},
triggerHandler: function( type, data ) {
var elem = this[0];
if ( elem ) {
return jQuery.event.trigger( type, data, elem, true );
}
}
});
/*!
* Sizzle CSS Selector Engine
* Copyright 2012 jQuery Foundation and other contributors
* Released under the MIT license
* http://sizzlejs.com/
*/
(function( window, undefined ) {
var i,
cachedruns,
Expr,
getText,
isXML,
compile,
hasDuplicate,
outermostContext,
// Local document vars
setDocument,
document,
docElem,
documentIsXML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
sortOrder,
// Instance-specific data
expando = "sizzle" + -(new Date()),
preferredDoc = window.document,
support = {},
dirruns = 0,
done = 0,
classCache = createCache(),
tokenCache = createCache(),
compilerCache = createCache(),
// General-purpose constants
strundefined = typeof undefined,
MAX_NEGATIVE = 1 << 31,
// Array methods
arr = [],
pop = arr.pop,
push = arr.push,
slice = arr.slice,
// Use a stripped-down indexOf if we can't use a native one
indexOf = arr.indexOf || function( elem ) {
var i = 0,
len = this.length;
for ( ; i < len; i++ ) {
if ( this[i] === elem ) {
return i;
}
}
return -1;
},
// Regular expressions
// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]",
// http://www.w3.org/TR/css3-syntax/#characters
characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
// Loosely modeled on CSS identifier characters
// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
identifier = characterEncoding.replace( "w", "w#" ),
// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
operators = "([*^$|!~]?=)",
attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
// Prefer arguments quoted,
// then not containing pseudos/brackets,
// then attribute selectors/non-parenthetical expressions,
// then anything else
// These preferences are here to reduce the number of selectors
// needing tokenize in the PSEUDO preFilter
pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
rpseudo = new RegExp( pseudos ),
ridentifier = new RegExp( "^" + identifier + "$" ),
matchExpr = {
"ID": new RegExp( "^#(" + characterEncoding + ")" ),
"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
"ATTR": new RegExp( "^" + attributes ),
"PSEUDO": new RegExp( "^" + pseudos ),
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
// For use in libraries implementing .is()
// We use this for POS matching in `select`
"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
},
rsibling = /[\x20\t\r\n\f]*[+~]/,
rnative = /^[^{]+\{\s*\[native code/,
// Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
rinputs = /^(?:input|select|textarea|button)$/i,
rheader = /^h\d$/i,
rescape = /'|\\/g,
rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
funescape = function( _, escaped ) {
var high = "0x" + escaped - 0x10000;
// NaN means non-codepoint
return high !== high ?
escaped :
// BMP codepoint
high < 0 ?
String.fromCharCode( high + 0x10000 ) :
// Supplemental Plane codepoint (surrogate pair)
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
};
// Use a stripped-down slice if we can't use a native one
try {
slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType;
} catch ( e ) {
slice = function( i ) {
var elem,
results = [];
while ( (elem = this[i++]) ) {
results.push( elem );
}
return results;
};
}
/**
* For feature detection
* @param {Function} fn The function to test for native support
*/
function isNative( fn ) {
return rnative.test( fn + "" );
}
/**
* Create key-value caches of limited size
* @returns {Function(string, Object)} Returns the Object data after storing it on itself with
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
* deleting the oldest entry
*/
function createCache() {
var cache,
keys = [];
return (cache = function( key, value ) {
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
if ( keys.push( key += " " ) > Expr.cacheLength ) {
// Only keep the most recent entries
delete cache[ keys.shift() ];
}
return (cache[ key ] = value);
});
}
/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
function markFunction( fn ) {
fn[ expando ] = true;
return fn;
}
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/
function assert( fn ) {
var div = document.createElement("div");
try {
return fn( div );
} catch (e) {
return false;
} finally {
// release memory in IE
div = null;
}
}
function Sizzle( selector, context, results, seed ) {
var match, elem, m, nodeType,
// QSA vars
i, groups, old, nid, newContext, newSelector;
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
setDocument( context );
}
context = context || document;
results = results || [];
if ( !selector || typeof selector !== "string" ) {
return results;
}
if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
return [];
}
if ( !documentIsXML && !seed ) {
// Shortcuts
if ( (match = rquickExpr.exec( selector )) ) {
// Speed-up: Sizzle("#ID")
if ( (m = match[1]) ) {
if ( nodeType === 9 ) {
elem = context.getElementById( m );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
if ( elem && elem.parentNode ) {
// Handle the case where IE, Opera, and Webkit return items
// by name instead of ID
if ( elem.id === m ) {
results.push( elem );
return results;
}
} else {
return results;
}
} else {
// Context is not a document
if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
contains( context, elem ) && elem.id === m ) {
results.push( elem );
return results;
}
}
// Speed-up: Sizzle("TAG")
} else if ( match[2] ) {
push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
return results;
// Speed-up: Sizzle(".CLASS")
} else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) {
push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
return results;
}
}
// QSA path
if ( support.qsa && !rbuggyQSA.test(selector) ) {
old = true;
nid = expando;
newContext = context;
newSelector = nodeType === 9 && selector;
// qSA works strangely on Element-rooted queries
// We can work around this by specifying an extra ID on the root
// and working up from there (Thanks to Andrew Dupont for the technique)
// IE 8 doesn't work on object elements
if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
groups = tokenize( selector );
if ( (old = context.getAttribute("id")) ) {
nid = old.replace( rescape, "\\$&" );
} else {
context.setAttribute( "id", nid );
}
nid = "[id='" + nid + "'] ";
i = groups.length;
while ( i-- ) {
groups[i] = nid + toSelector( groups[i] );
}
newContext = rsibling.test( selector ) && context.parentNode || context;
newSelector = groups.join(",");
}
if ( newSelector ) {
try {
push.apply( results, slice.call( newContext.querySelectorAll(
newSelector
), 0 ) );
return results;
} catch(qsaError) {
} finally {
if ( !old ) {
context.removeAttribute("id");
}
}
}
}
}
// All others
return select( selector.replace( rtrim, "$1" ), context, results, seed );
}
/**
* Detect xml
* @param {Element|Object} elem An element or a document
*/
isXML = Sizzle.isXML = function( elem ) {
// documentElement is verified for cases where it doesn't yet exist
// (such as loading iframes in IE - #4833)
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
return documentElement ? documentElement.nodeName !== "HTML" : false;
};
/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
setDocument = Sizzle.setDocument = function( node ) {
var doc = node ? node.ownerDocument || node : preferredDoc;
// If no document and documentElement is available, return
if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
return document;
}
// Set our document
document = doc;
docElem = doc.documentElement;
// Support tests
documentIsXML = isXML( doc );
// Check if getElementsByTagName("*") returns only elements
support.tagNameNoComments = assert(function( div ) {
div.appendChild( doc.createComment("") );
return !div.getElementsByTagName("*").length;
});
// Check if attributes should be retrieved by attribute nodes
support.attributes = assert(function( div ) {
div.innerHTML = "<select></select>";
var type = typeof div.lastChild.getAttribute("multiple");
// IE8 returns a string for some attributes even when not present
return type !== "boolean" && type !== "string";
});
// Check if getElementsByClassName can be trusted
support.getByClassName = assert(function( div ) {
// Opera can't find a second classname (in 9.6)
div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
return false;
}
// Safari 3.2 caches class attributes and doesn't catch changes
div.lastChild.className = "e";
return div.getElementsByClassName("e").length === 2;
});
// Check if getElementById returns elements by name
// Check if getElementsByName privileges form controls or returns elements by ID
support.getByName = assert(function( div ) {
// Inject content
div.id = expando + 0;
div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
docElem.insertBefore( div, docElem.firstChild );
// Test
var pass = doc.getElementsByName &&
// buggy browsers will return fewer than the correct 2
doc.getElementsByName( expando ).length === 2 +
// buggy browsers will return more than the correct 0
doc.getElementsByName( expando + 0 ).length;
support.getIdNotName = !doc.getElementById( expando );
// Cleanup
docElem.removeChild( div );
return pass;
});
// IE6/7 return modified attributes
Expr.attrHandle = assert(function( div ) {
div.innerHTML = "<a href='#'></a>";
return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
div.firstChild.getAttribute("href") === "#";
}) ?
{} :
{
"href": function( elem ) {
return elem.getAttribute( "href", 2 );
},
"type": function( elem ) {
return elem.getAttribute("type");
}
};
// ID find and filter
if ( support.getIdNotName ) {
Expr.find["ID"] = function( id, context ) {
if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
var m = context.getElementById( id );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
return m && m.parentNode ? [m] : [];
}
};
Expr.filter["ID"] = function( id ) {
var attrId = id.replace( runescape, funescape );
return function( elem ) {
return elem.getAttribute("id") === attrId;
};
};
} else {
Expr.find["ID"] = function( id, context ) {
if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
var m = context.getElementById( id );
return m ?
m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
[m] :
undefined :
[];
}
};
Expr.filter["ID"] = function( id ) {
var attrId = id.replace( runescape, funescape );
return function( elem ) {
var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
return node && node.value === attrId;
};
};
}
// Tag
Expr.find["TAG"] = support.tagNameNoComments ?
function( tag, context ) {
if ( typeof context.getElementsByTagName !== strundefined ) {
return context.getElementsByTagName( tag );
}
} :
function( tag, context ) {
var elem,
tmp = [],
i = 0,
results = context.getElementsByTagName( tag );
// Filter out possible comments
if ( tag === "*" ) {
while ( (elem = results[i++]) ) {
if ( elem.nodeType === 1 ) {
tmp.push( elem );
}
}
return tmp;
}
return results;
};
// Name
Expr.find["NAME"] = support.getByName && function( tag, context ) {
if ( typeof context.getElementsByName !== strundefined ) {
return context.getElementsByName( name );
}
};
// Class
Expr.find["CLASS"] = support.getByClassName && function( className, context ) {
if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) {
return context.getElementsByClassName( className );
}
};
// QSA and matchesSelector support
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
// qSa(:focus) reports false when true (Chrome 21),
// no need to also add to buggyMatches since matches checks buggyQSA
// A support test would require too much code (would include document ready)
rbuggyQSA = [ ":focus" ];
if ( (support.qsa = isNative(doc.querySelectorAll)) ) {
// Build QSA regex
// Regex strategy adopted from Diego Perini
assert(function( div ) {
// Select is set to empty string on purpose
// This is to test IE's treatment of not explictly
// setting a boolean content attribute,
// since its presence should be enough
// http://bugs.jquery.com/ticket/12359
div.innerHTML = "<select><option selected=''></option></select>";
// IE8 - Some boolean attributes are not treated correctly
if ( !div.querySelectorAll("[selected]").length ) {
rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
}
// Webkit/Opera - :checked should return selected option elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
// IE8 throws error here and will not see later tests
if ( !div.querySelectorAll(":checked").length ) {
rbuggyQSA.push(":checked");
}
});
assert(function( div ) {
// Opera 10-12/IE8 - ^= $= *= and empty values
// Should not select anything
div.innerHTML = "<input type='hidden' i=''/>";
if ( div.querySelectorAll("[i^='']").length ) {
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
}
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
// IE8 throws error here and will not see later tests
if ( !div.querySelectorAll(":enabled").length ) {
rbuggyQSA.push( ":enabled", ":disabled" );
}
// Opera 10-11 does not throw on post-comma invalid pseudos
div.querySelectorAll("*,:x");
rbuggyQSA.push(",.*:");
});
}
if ( (support.matchesSelector = isNative( (matches = docElem.matchesSelector ||
docElem.mozMatchesSelector ||
docElem.webkitMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector) )) ) {
assert(function( div ) {
// Check to see if it's possible to do matchesSelector
// on a disconnected node (IE 9)
support.disconnectedMatch = matches.call( div, "div" );
// This should fail with an exception
// Gecko does not error, returns false instead
matches.call( div, "[s!='']:x" );
rbuggyMatches.push( "!=", pseudos );
});
}
rbuggyQSA = new RegExp( rbuggyQSA.join("|") );
rbuggyMatches = new RegExp( rbuggyMatches.join("|") );
// Element contains another
// Purposefully does not implement inclusive descendent
// As in, an element does not contain itself
contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
function( a, b ) {
var adown = a.nodeType === 9 ? a.documentElement : a,
bup = b && b.parentNode;
return a === bup || !!( bup && bup.nodeType === 1 && (
adown.contains ?
adown.contains( bup ) :
a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
));
} :
function( a, b ) {
if ( b ) {
while ( (b = b.parentNode) ) {
if ( b === a ) {
return true;
}
}
}
return false;
};
// Document order sorting
sortOrder = docElem.compareDocumentPosition ?
function( a, b ) {
var compare;
if ( a === b ) {
hasDuplicate = true;
return 0;
}
if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) {
if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) {
if ( a === doc || contains( preferredDoc, a ) ) {
return -1;
}
if ( b === doc || contains( preferredDoc, b ) ) {
return 1;
}
return 0;
}
return compare & 4 ? -1 : 1;
}
return a.compareDocumentPosition ? -1 : 1;
} :
function( a, b ) {
var cur,
i = 0,
aup = a.parentNode,
bup = b.parentNode,
ap = [ a ],
bp = [ b ];
// Exit early if the nodes are identical
if ( a === b ) {
hasDuplicate = true;
return 0;
// Parentless nodes are either documents or disconnected
} else if ( !aup || !bup ) {
return a === doc ? -1 :
b === doc ? 1 :
aup ? -1 :
bup ? 1 :
0;
// If the nodes are siblings, we can do a quick check
} else if ( aup === bup ) {
return siblingCheck( a, b );
}
// Otherwise we need full lists of their ancestors for comparison
cur = a;
while ( (cur = cur.parentNode) ) {
ap.unshift( cur );
}
cur = b;
while ( (cur = cur.parentNode) ) {
bp.unshift( cur );
}
// Walk down the tree looking for a discrepancy
while ( ap[i] === bp[i] ) {
i++;
}
return i ?
// Do a sibling check if the nodes have a common ancestor
siblingCheck( ap[i], bp[i] ) :
// Otherwise nodes in our document sort first
ap[i] === preferredDoc ? -1 :
bp[i] === preferredDoc ? 1 :
0;
};
// Always assume the presence of duplicates if sort doesn't
// pass them to our comparison function (as in Google Chrome).
hasDuplicate = false;
[0, 0].sort( sortOrder );
support.detectDuplicates = hasDuplicate;
return document;
};
Sizzle.matches = function( expr, elements ) {
return Sizzle( expr, null, null, elements );
};
Sizzle.matchesSelector = function( elem, expr ) {
// Set document vars if needed
if ( ( elem.ownerDocument || elem ) !== document ) {
setDocument( elem );
}
// Make sure that attribute selectors are quoted
expr = expr.replace( rattributeQuotes, "='$1']" );
// rbuggyQSA always contains :focus, so no need for an existence check
if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr) ) {
try {
var ret = matches.call( elem, expr );
// IE 9's matchesSelector returns false on disconnected nodes
if ( ret || support.disconnectedMatch ||
// As well, disconnected nodes are said to be in a document
// fragment in IE 9
elem.document && elem.document.nodeType !== 11 ) {
return ret;
}
} catch(e) {}
}
return Sizzle( expr, document, null, [elem] ).length > 0;
};
Sizzle.contains = function( context, elem ) {
// Set document vars if needed
if ( ( context.ownerDocument || context ) !== document ) {
setDocument( context );
}
return contains( context, elem );
};
Sizzle.attr = function( elem, name ) {
var val;
// Set document vars if needed
if ( ( elem.ownerDocument || elem ) !== document ) {
setDocument( elem );
}
if ( !documentIsXML ) {
name = name.toLowerCase();
}
if ( (val = Expr.attrHandle[ name ]) ) {
return val( elem );
}
if ( documentIsXML || support.attributes ) {
return elem.getAttribute( name );
}
return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ?
name :
val && val.specified ? val.value : null;
};
Sizzle.error = function( msg ) {
throw new Error( "Syntax error, unrecognized expression: " + msg );
};
// Document sorting and removing duplicates
Sizzle.uniqueSort = function( results ) {
var elem,
duplicates = [],
i = 1,
j = 0;
// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates;
results.sort( sortOrder );
if ( hasDuplicate ) {
for ( ; (elem = results[i]); i++ ) {
if ( elem === results[ i - 1 ] ) {
j = duplicates.push( i );
}
}
while ( j-- ) {
results.splice( duplicates[ j ], 1 );
}
}
return results;
};
function siblingCheck( a, b ) {
var cur = b && a,
diff = cur && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE );
// Use IE sourceIndex if available on both nodes
if ( diff ) {
return diff;
}
// Check if b follows a
if ( cur ) {
while ( (cur = cur.nextSibling) ) {
if ( cur === b ) {
return -1;
}
}
}
return a ? 1 : -1;
}
// Returns a function to use in pseudos for input types
function createInputPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === type;
};
}
// Returns a function to use in pseudos for buttons
function createButtonPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return (name === "input" || name === "button") && elem.type === type;
};
}
// Returns a function to use in pseudos for positionals
function createPositionalPseudo( fn ) {
return markFunction(function( argument ) {
argument = +argument;
return markFunction(function( seed, matches ) {
var j,
matchIndexes = fn( [], seed.length, argument ),
i = matchIndexes.length;
// Match elements found at the specified indexes
while ( i-- ) {
if ( seed[ (j = matchIndexes[i]) ] ) {
seed[j] = !(matches[j] = seed[j]);
}
}
});
});
}
/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
getText = Sizzle.getText = function( elem ) {
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
if ( !nodeType ) {
// If no nodeType, this is expected to be an array
for ( ; (node = elem[i]); i++ ) {
// Do not traverse comment nodes
ret += getText( node );
}
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
// Use textContent for elements
// innerText usage removed for consistency of new lines (see #11153)
if ( typeof elem.textContent === "string" ) {
return elem.textContent;
} else {
// Traverse its children
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
ret += getText( elem );
}
}
} else if ( nodeType === 3 || nodeType === 4 ) {
return elem.nodeValue;
}
// Do not include comment or processing instruction nodes
return ret;
};
Expr = Sizzle.selectors = {
// Can be adjusted by the user
cacheLength: 50,
createPseudo: markFunction,
match: matchExpr,
find: {},
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" }
},
preFilter: {
"ATTR": function( match ) {
match[1] = match[1].replace( runescape, funescape );
// Move the given value to match[3] whether quoted or unquoted
match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
if ( match[2] === "~=" ) {
match[3] = " " + match[3] + " ";
}
return match.slice( 0, 4 );
},
"CHILD": function( match ) {
/* matches from matchExpr["CHILD"]
1 type (only|nth|...)
2 what (child|of-type)
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4 xn-component of xn+y argument ([+-]?\d*n|)
5 sign of xn-component
6 x of xn-component
7 sign of y-component
8 y of y-component
*/
match[1] = match[1].toLowerCase();
if ( match[1].slice( 0, 3 ) === "nth" ) {
// nth-* requires argument
if ( !match[3] ) {
Sizzle.error( match[0] );
}
// numeric x and y parameters for Expr.filter.CHILD
// remember that false/true cast respectively to 0/1
match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
// other types prohibit arguments
} else if ( match[3] ) {
Sizzle.error( match[0] );
}
return match;
},
"PSEUDO": function( match ) {
var excess,
unquoted = !match[5] && match[2];
if ( matchExpr["CHILD"].test( match[0] ) ) {
return null;
}
// Accept quoted arguments as-is
if ( match[4] ) {
match[2] = match[4];
// Strip excess characters from unquoted arguments
} else if ( unquoted && rpseudo.test( unquoted ) &&
// Get excess from tokenize (recursively)
(excess = tokenize( unquoted, true )) &&
// advance to the next closing parenthesis
(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
// excess is a negative index
match[0] = match[0].slice( 0, excess );
match[2] = unquoted.slice( 0, excess );
}
// Return only captures needed by the pseudo filter method (type and argument)
return match.slice( 0, 3 );
}
},
filter: {
"TAG": function( nodeName ) {
if ( nodeName === "*" ) {
return function() { return true; };
}
nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
return function( elem ) {
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
};
},
"CLASS": function( className ) {
var pattern = classCache[ className + " " ];
return pattern ||
(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
classCache( className, function( elem ) {
return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
});
},
"ATTR": function( name, operator, check ) {
return function( elem ) {
var result = Sizzle.attr( elem, name );
if ( result == null ) {
return operator === "!=";
}
if ( !operator ) {
return true;
}
result += "";
return operator === "=" ? result === check :
operator === "!=" ? result !== check :
operator === "^=" ? check && result.indexOf( check ) === 0 :
operator === "*=" ? check && result.indexOf( check ) > -1 :
operator === "$=" ? check && result.slice( -check.length ) === check :
operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
false;
};
},
"CHILD": function( type, what, argument, first, last ) {
var simple = type.slice( 0, 3 ) !== "nth",
forward = type.slice( -4 ) !== "last",
ofType = what === "of-type";
return first === 1 && last === 0 ?
// Shortcut for :nth-*(n)
function( elem ) {
return !!elem.parentNode;
} :
function( elem, context, xml ) {
var cache, outerCache, node, diff, nodeIndex, start,
dir = simple !== forward ? "nextSibling" : "previousSibling",
parent = elem.parentNode,
name = ofType && elem.nodeName.toLowerCase(),
useCache = !xml && !ofType;
if ( parent ) {
// :(first|last|only)-(child|of-type)
if ( simple ) {
while ( dir ) {
node = elem;
while ( (node = node[ dir ]) ) {
if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
return false;
}
}
// Reverse direction for :only-* (if we haven't yet done so)
start = dir = type === "only" && !start && "nextSibling";
}
return true;
}
start = [ forward ? parent.firstChild : parent.lastChild ];
// non-xml :nth-child(...) stores cache data on `parent`
if ( forward && useCache ) {
// Seek `elem` from a previously-cached index
outerCache = parent[ expando ] || (parent[ expando ] = {});
cache = outerCache[ type ] || [];
nodeIndex = cache[0] === dirruns && cache[1];
diff = cache[0] === dirruns && cache[2];
node = nodeIndex && parent.childNodes[ nodeIndex ];
while ( (node = ++nodeIndex && node && node[ dir ] ||
// Fallback to seeking `elem` from the start
(diff = nodeIndex = 0) || start.pop()) ) {
// When found, cache indexes on `parent` and break
if ( node.nodeType === 1 && ++diff && node === elem ) {
outerCache[ type ] = [ dirruns, nodeIndex, diff ];
break;
}
}
// Use previously-cached element index if available
} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
diff = cache[1];
// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
} else {
// Use the same loop as above to seek `elem` from the start
while ( (node = ++nodeIndex && node && node[ dir ] ||
(diff = nodeIndex = 0) || start.pop()) ) {
if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
// Cache the index of each encountered element
if ( useCache ) {
(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
}
if ( node === elem ) {
break;
}
}
}
}
// Incorporate the offset, then check against cycle size
diff -= last;
return diff === first || ( diff % first === 0 && diff / first >= 0 );
}
};
},
"PSEUDO": function( pseudo, argument ) {
// pseudo-class names are case-insensitive
// http://www.w3.org/TR/selectors/#pseudo-classes
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
// Remember that setFilters inherits from pseudos
var args,
fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
Sizzle.error( "unsupported pseudo: " + pseudo );
// The user may use createPseudo to indicate that
// arguments are needed to create the filter function
// just as Sizzle does
if ( fn[ expando ] ) {
return fn( argument );
}
// But maintain support for old signatures
if ( fn.length > 1 ) {
args = [ pseudo, pseudo, "", argument ];
return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
markFunction(function( seed, matches ) {
var idx,
matched = fn( seed, argument ),
i = matched.length;
while ( i-- ) {
idx = indexOf.call( seed, matched[i] );
seed[ idx ] = !( matches[ idx ] = matched[i] );
}
}) :
function( elem ) {
return fn( elem, 0, args );
};
}
return fn;
}
},
pseudos: {
// Potentially complex pseudos
"not": markFunction(function( selector ) {
// Trim the selector passed to compile
// to avoid treating leading and trailing
// spaces as combinators
var input = [],
results = [],
matcher = compile( selector.replace( rtrim, "$1" ) );
return matcher[ expando ] ?
markFunction(function( seed, matches, context, xml ) {
var elem,
unmatched = matcher( seed, null, xml, [] ),
i = seed.length;
// Match elements unmatched by `matcher`
while ( i-- ) {
if ( (elem = unmatched[i]) ) {
seed[i] = !(matches[i] = elem);
}
}
}) :
function( elem, context, xml ) {
input[0] = elem;
matcher( input, null, xml, results );
return !results.pop();
};
}),
"has": markFunction(function( selector ) {
return function( elem ) {
return Sizzle( selector, elem ).length > 0;
};
}),
"contains": markFunction(function( text ) {
return function( elem ) {
return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
};
}),
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
"lang": markFunction( function( lang ) {
// lang value must be a valid identifider
if ( !ridentifier.test(lang || "") ) {
Sizzle.error( "unsupported lang: " + lang );
}
lang = lang.replace( runescape, funescape ).toLowerCase();
return function( elem ) {
var elemLang;
do {
if ( (elemLang = documentIsXML ?
elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
elem.lang) ) {
elemLang = elemLang.toLowerCase();
return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
}
} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
return false;
};
}),
// Miscellaneous
"target": function( elem ) {
var hash = window.location && window.location.hash;
return hash && hash.slice( 1 ) === elem.id;
},
"root": function( elem ) {
return elem === docElem;
},
"focus": function( elem ) {
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
},
// Boolean properties
"enabled": function( elem ) {
return elem.disabled === false;
},
"disabled": function( elem ) {
return elem.disabled === true;
},
"checked": function( elem ) {
// In CSS3, :checked should return both checked and selected elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
var nodeName = elem.nodeName.toLowerCase();
return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
},
"selected": function( elem ) {
// Accessing this property makes selected-by-default
// options in Safari work properly
if ( elem.parentNode ) {
elem.parentNode.selectedIndex;
}
return elem.selected === true;
},
// Contents
"empty": function( elem ) {
// http://www.w3.org/TR/selectors/#empty-pseudo
// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
// not comment, processing instructions, or others
// Thanks to Diego Perini for the nodeName shortcut
// Greater than "@" means alpha characters (specifically not starting with "#" or "?")
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
return false;
}
}
return true;
},
"parent": function( elem ) {
return !Expr.pseudos["empty"]( elem );
},
// Element/input types
"header": function( elem ) {
return rheader.test( elem.nodeName );
},
"input": function( elem ) {
return rinputs.test( elem.nodeName );
},
"button": function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === "button" || name === "button";
},
"text": function( elem ) {
var attr;
// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
// use getAttribute instead to test this case
return elem.nodeName.toLowerCase() === "input" &&
elem.type === "text" &&
( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
},
// Position-in-collection
"first": createPositionalPseudo(function() {
return [ 0 ];
}),
"last": createPositionalPseudo(function( matchIndexes, length ) {
return [ length - 1 ];
}),
"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
return [ argument < 0 ? argument + length : argument ];
}),
"even": createPositionalPseudo(function( matchIndexes, length ) {
var i = 0;
for ( ; i < length; i += 2 ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"odd": createPositionalPseudo(function( matchIndexes, length ) {
var i = 1;
for ( ; i < length; i += 2 ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
var i = argument < 0 ? argument + length : argument;
for ( ; --i >= 0; ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
var i = argument < 0 ? argument + length : argument;
for ( ; ++i < length; ) {
matchIndexes.push( i );
}
return matchIndexes;
})
}
};
// Add button/input type pseudos
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
Expr.pseudos[ i ] = createInputPseudo( i );
}
for ( i in { submit: true, reset: true } ) {
Expr.pseudos[ i ] = createButtonPseudo( i );
}
function tokenize( selector, parseOnly ) {
var matched, match, tokens, type,
soFar, groups, preFilters,
cached = tokenCache[ selector + " " ];
if ( cached ) {
return parseOnly ? 0 : cached.slice( 0 );
}
soFar = selector;
groups = [];
preFilters = Expr.preFilter;
while ( soFar ) {
// Comma and first run
if ( !matched || (match = rcomma.exec( soFar )) ) {
if ( match ) {
// Don't consume trailing commas as valid
soFar = soFar.slice( match[0].length ) || soFar;
}
groups.push( tokens = [] );
}
matched = false;
// Combinators
if ( (match = rcombinators.exec( soFar )) ) {
matched = match.shift();
tokens.push( {
value: matched,
// Cast descendant combinators to space
type: match[0].replace( rtrim, " " )
} );
soFar = soFar.slice( matched.length );
}
// Filters
for ( type in Expr.filter ) {
if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
(match = preFilters[ type ]( match ))) ) {
matched = match.shift();
tokens.push( {
value: matched,
type: type,
matches: match
} );
soFar = soFar.slice( matched.length );
}
}
if ( !matched ) {
break;
}
}
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ?
soFar.length :
soFar ?
Sizzle.error( selector ) :
// Cache the tokens
tokenCache( selector, groups ).slice( 0 );
}
function toSelector( tokens ) {
var i = 0,
len = tokens.length,
selector = "";
for ( ; i < len; i++ ) {
selector += tokens[i].value;
}
return selector;
}
function addCombinator( matcher, combinator, base ) {
var dir = combinator.dir,
checkNonElements = base && dir === "parentNode",
doneName = done++;
return combinator.first ?
// Check against closest ancestor/preceding element
function( elem, context, xml ) {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
return matcher( elem, context, xml );
}
}
} :
// Check against all ancestor/preceding elements
function( elem, context, xml ) {
var data, cache, outerCache,
dirkey = dirruns + " " + doneName;
// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
if ( xml ) {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
if ( matcher( elem, context, xml ) ) {
return true;
}
}
}
} else {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
outerCache = elem[ expando ] || (elem[ expando ] = {});
if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
if ( (data = cache[1]) === true || data === cachedruns ) {
return data === true;
}
} else {
cache = outerCache[ dir ] = [ dirkey ];
cache[1] = matcher( elem, context, xml ) || cachedruns;
if ( cache[1] === true ) {
return true;
}
}
}
}
}
};
}
function elementMatcher( matchers ) {
return matchers.length > 1 ?
function( elem, context, xml ) {
var i = matchers.length;
while ( i-- ) {
if ( !matchers[i]( elem, context, xml ) ) {
return false;
}
}
return true;
} :
matchers[0];
}
function condense( unmatched, map, filter, context, xml ) {
var elem,
newUnmatched = [],
i = 0,
len = unmatched.length,
mapped = map != null;
for ( ; i < len; i++ ) {
if ( (elem = unmatched[i]) ) {
if ( !filter || filter( elem, context, xml ) ) {
newUnmatched.push( elem );
if ( mapped ) {
map.push( i );
}
}
}
}
return newUnmatched;
}
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
if ( postFilter && !postFilter[ expando ] ) {
postFilter = setMatcher( postFilter );
}
if ( postFinder && !postFinder[ expando ] ) {
postFinder = setMatcher( postFinder, postSelector );
}
return markFunction(function( seed, results, context, xml ) {
var temp, i, elem,
preMap = [],
postMap = [],
preexisting = results.length,
// Get initial elements from seed or context
elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
// Prefilter to get matcher input, preserving a map for seed-results synchronization
matcherIn = preFilter && ( seed || !selector ) ?
condense( elems, preMap, preFilter, context, xml ) :
elems,
matcherOut = matcher ?
// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
// ...intermediate processing is necessary
[] :
// ...otherwise use results directly
results :
matcherIn;
// Find primary matches
if ( matcher ) {
matcher( matcherIn, matcherOut, context, xml );
}
// Apply postFilter
if ( postFilter ) {
temp = condense( matcherOut, postMap );
postFilter( temp, [], context, xml );
// Un-match failing elements by moving them back to matcherIn
i = temp.length;
while ( i-- ) {
if ( (elem = temp[i]) ) {
matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
}
}
}
if ( seed ) {
if ( postFinder || preFilter ) {
if ( postFinder ) {
// Get the final matcherOut by condensing this intermediate into postFinder contexts
temp = [];
i = matcherOut.length;
while ( i-- ) {
if ( (elem = matcherOut[i]) ) {
// Restore matcherIn since elem is not yet a final match
temp.push( (matcherIn[i] = elem) );
}
}
postFinder( null, (matcherOut = []), temp, xml );
}
// Move matched elements from seed to results to keep them synchronized
i = matcherOut.length;
while ( i-- ) {
if ( (elem = matcherOut[i]) &&
(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
seed[temp] = !(results[temp] = elem);
}
}
}
// Add elements to results, through postFinder if defined
} else {
matcherOut = condense(
matcherOut === results ?
matcherOut.splice( preexisting, matcherOut.length ) :
matcherOut
);
if ( postFinder ) {
postFinder( null, results, matcherOut, xml );
} else {
push.apply( results, matcherOut );
}
}
});
}
function matcherFromTokens( tokens ) {
var checkContext, matcher, j,
len = tokens.length,
leadingRelative = Expr.relative[ tokens[0].type ],
implicitRelative = leadingRelative || Expr.relative[" "],
i = leadingRelative ? 1 : 0,
// The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator( function( elem ) {
return elem === checkContext;
}, implicitRelative, true ),
matchAnyContext = addCombinator( function( elem ) {
return indexOf.call( checkContext, elem ) > -1;
}, implicitRelative, true ),
matchers = [ function( elem, context, xml ) {
return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
(checkContext = context).nodeType ?
matchContext( elem, context, xml ) :
matchAnyContext( elem, context, xml ) );
} ];
for ( ; i < len; i++ ) {
if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
} else {
matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
// Return special upon seeing a positional matcher
if ( matcher[ expando ] ) {
// Find the next relative operator (if any) for proper handling
j = ++i;
for ( ; j < len; j++ ) {
if ( Expr.relative[ tokens[j].type ] ) {
break;
}
}
return setMatcher(
i > 1 && elementMatcher( matchers ),
i > 1 && toSelector( tokens.slice( 0, i - 1 ) ).replace( rtrim, "$1" ),
matcher,
i < j && matcherFromTokens( tokens.slice( i, j ) ),
j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
j < len && toSelector( tokens )
);
}
matchers.push( matcher );
}
}
return elementMatcher( matchers );
}
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
// A counter to specify which element is currently being matched
var matcherCachedRuns = 0,
bySet = setMatchers.length > 0,
byElement = elementMatchers.length > 0,
superMatcher = function( seed, context, xml, results, expandContext ) {
var elem, j, matcher,
setMatched = [],
matchedCount = 0,
i = "0",
unmatched = seed && [],
outermost = expandContext != null,
contextBackup = outermostContext,
// We must always have either seed elements or context
elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
// Use integer dirruns iff this is the outermost matcher
dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
if ( outermost ) {
outermostContext = context !== document && context;
cachedruns = matcherCachedRuns;
}
// Add elements passing elementMatchers directly to results
// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
for ( ; (elem = elems[i]) != null; i++ ) {
if ( byElement && elem ) {
j = 0;
while ( (matcher = elementMatchers[j++]) ) {
if ( matcher( elem, context, xml ) ) {
results.push( elem );
break;
}
}
if ( outermost ) {
dirruns = dirrunsUnique;
cachedruns = ++matcherCachedRuns;
}
}
// Track unmatched elements for set filters
if ( bySet ) {
// They will have gone through all possible matchers
if ( (elem = !matcher && elem) ) {
matchedCount--;
}
// Lengthen the array for every element, matched or not
if ( seed ) {
unmatched.push( elem );
}
}
}
// Apply set filters to unmatched elements
matchedCount += i;
if ( bySet && i !== matchedCount ) {
j = 0;
while ( (matcher = setMatchers[j++]) ) {
matcher( unmatched, setMatched, context, xml );
}
if ( seed ) {
// Reintegrate element matches to eliminate the need for sorting
if ( matchedCount > 0 ) {
while ( i-- ) {
if ( !(unmatched[i] || setMatched[i]) ) {
setMatched[i] = pop.call( results );
}
}
}
// Discard index placeholder values to get only actual matches
setMatched = condense( setMatched );
}
// Add matches to results
push.apply( results, setMatched );
// Seedless set matches succeeding multiple successful matchers stipulate sorting
if ( outermost && !seed && setMatched.length > 0 &&
( matchedCount + setMatchers.length ) > 1 ) {
Sizzle.uniqueSort( results );
}
}
// Override manipulation of globals by nested matchers
if ( outermost ) {
dirruns = dirrunsUnique;
outermostContext = contextBackup;
}
return unmatched;
};
return bySet ?
markFunction( superMatcher ) :
superMatcher;
}
compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
var i,
setMatchers = [],
elementMatchers = [],
cached = compilerCache[ selector + " " ];
if ( !cached ) {
// Generate a function of recursive functions that can be used to check each element
if ( !group ) {
group = tokenize( selector );
}
i = group.length;
while ( i-- ) {
cached = matcherFromTokens( group[i] );
if ( cached[ expando ] ) {
setMatchers.push( cached );
} else {
elementMatchers.push( cached );
}
}
// Cache the compiled function
cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
}
return cached;
};
function multipleContexts( selector, contexts, results ) {
var i = 0,
len = contexts.length;
for ( ; i < len; i++ ) {
Sizzle( selector, contexts[i], results );
}
return results;
}
function select( selector, context, results, seed ) {
var i, tokens, token, type, find,
match = tokenize( selector );
if ( !seed ) {
// Try to minimize operations if there is only one group
if ( match.length === 1 ) {
// Take a shortcut and set the context if the root selector is an ID
tokens = match[0] = match[0].slice( 0 );
if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
context.nodeType === 9 && !documentIsXML &&
Expr.relative[ tokens[1].type ] ) {
context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
if ( !context ) {
return results;
}
selector = selector.slice( tokens.shift().value.length );
}
// Fetch a seed set for right-to-left matching
i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
while ( i-- ) {
token = tokens[i];
// Abort if we hit a combinator
if ( Expr.relative[ (type = token.type) ] ) {
break;
}
if ( (find = Expr.find[ type ]) ) {
// Search, expanding context for leading sibling combinators
if ( (seed = find(
token.matches[0].replace( runescape, funescape ),
rsibling.test( tokens[0].type ) && context.parentNode || context
)) ) {
// If seed is empty or no tokens remain, we can return early
tokens.splice( i, 1 );
selector = seed.length && toSelector( tokens );
if ( !selector ) {
push.apply( results, slice.call( seed, 0 ) );
return results;
}
break;
}
}
}
}
}
// Compile and execute a filtering function
// Provide `match` to avoid retokenization if we modified the selector above
compile( selector, match )(
seed,
context,
documentIsXML,
results,
rsibling.test( selector )
);
return results;
}
// Deprecated
Expr.pseudos["nth"] = Expr.pseudos["eq"];
// Easy API for creating new setFilters
function setFilters() {}
Expr.filters = setFilters.prototype = Expr.pseudos;
Expr.setFilters = new setFilters();
// Initialize with the default document
setDocument();
// Override sizzle attribute retrieval
Sizzle.attr = jQuery.attr;
jQuery.find = Sizzle;
jQuery.expr = Sizzle.selectors;
jQuery.expr[":"] = jQuery.expr.pseudos;
jQuery.unique = Sizzle.uniqueSort;
jQuery.text = Sizzle.getText;
jQuery.isXMLDoc = Sizzle.isXML;
jQuery.contains = Sizzle.contains;
})( window );
var runtil = /Until$/,
rparentsprev = /^(?:parents|prev(?:Until|All))/,
isSimple = /^.[^:#\[\.,]*$/,
rneedsContext = jQuery.expr.match.needsContext,
// methods guaranteed to produce a unique set when starting from a unique set
guaranteedUnique = {
children: true,
contents: true,
next: true,
prev: true
};
jQuery.fn.extend({
find: function( selector ) {
var i, ret, self,
len = this.length;
if ( typeof selector !== "string" ) {
self = this;
return this.pushStack( jQuery( selector ).filter(function() {
for ( i = 0; i < len; i++ ) {
if ( jQuery.contains( self[ i ], this ) ) {
return true;
}
}
}) );
}
ret = [];
for ( i = 0; i < len; i++ ) {
jQuery.find( selector, this[ i ], ret );
}
// Needed because $( selector, context ) becomes $( context ).find( selector )
ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
ret.selector = ( this.selector ? this.selector + " " : "" ) + selector;
return ret;
},
has: function( target ) {
var i,
targets = jQuery( target, this ),
len = targets.length;
return this.filter(function() {
for ( i = 0; i < len; i++ ) {
if ( jQuery.contains( this, targets[i] ) ) {
return true;
}
}
});
},
not: function( selector ) {
return this.pushStack( winnow(this, selector, false) );
},
filter: function( selector ) {
return this.pushStack( winnow(this, selector, true) );
},
is: function( selector ) {
return !!selector && (
typeof selector === "string" ?
// If this is a positional/relative selector, check membership in the returned set
// so $("p:first").is("p:last") won't return true for a doc with two "p".
rneedsContext.test( selector ) ?
jQuery( selector, this.context ).index( this[0] ) >= 0 :
jQuery.filter( selector, this ).length > 0 :
this.filter( selector ).length > 0 );
},
closest: function( selectors, context ) {
var cur,
i = 0,
l = this.length,
ret = [],
pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
jQuery( selectors, context || this.context ) :
0;
for ( ; i < l; i++ ) {
cur = this[i];
while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
ret.push( cur );
break;
}
cur = cur.parentNode;
}
}
return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret );
},
// Determine the position of an element within
// the matched set of elements
index: function( elem ) {
// No argument, return index in parent
if ( !elem ) {
return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1;
}
// index in selector
if ( typeof elem === "string" ) {
return jQuery.inArray( this[0], jQuery( elem ) );
}
// Locate the position of the desired element
return jQuery.inArray(
// If it receives a jQuery object, the first element is used
elem.jquery ? elem[0] : elem, this );
},
add: function( selector, context ) {
var set = typeof selector === "string" ?
jQuery( selector, context ) :
jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
all = jQuery.merge( this.get(), set );
return this.pushStack( jQuery.unique(all) );
},
addBack: function( selector ) {
return this.add( selector == null ?
this.prevObject : this.prevObject.filter(selector)
);
}
});
jQuery.fn.andSelf = jQuery.fn.addBack;
function sibling( cur, dir ) {
do {
cur = cur[ dir ];
} while ( cur && cur.nodeType !== 1 );
return cur;
}
jQuery.each({
parent: function( elem ) {
var parent = elem.parentNode;
return parent && parent.nodeType !== 11 ? parent : null;
},
parents: function( elem ) {
return jQuery.dir( elem, "parentNode" );
},
parentsUntil: function( elem, i, until ) {
return jQuery.dir( elem, "parentNode", until );
},
next: function( elem ) {
return sibling( elem, "nextSibling" );
},
prev: function( elem ) {
return sibling( elem, "previousSibling" );
},
nextAll: function( elem ) {
return jQuery.dir( elem, "nextSibling" );
},
prevAll: function( elem ) {
return jQuery.dir( elem, "previousSibling" );
},
nextUntil: function( elem, i, until ) {
return jQuery.dir( elem, "nextSibling", until );
},
prevUntil: function( elem, i, until ) {
return jQuery.dir( elem, "previousSibling", until );
},
siblings: function( elem ) {
return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
},
children: function( elem ) {
return jQuery.sibling( elem.firstChild );
},
contents: function( elem ) {
return jQuery.nodeName( elem, "iframe" ) ?
elem.contentDocument || elem.contentWindow.document :
jQuery.merge( [], elem.childNodes );
}
}, function( name, fn ) {
jQuery.fn[ name ] = function( until, selector ) {
var ret = jQuery.map( this, fn, until );
if ( !runtil.test( name ) ) {
selector = until;
}
if ( selector && typeof selector === "string" ) {
ret = jQuery.filter( selector, ret );
}
ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
if ( this.length > 1 && rparentsprev.test( name ) ) {
ret = ret.reverse();
}
return this.pushStack( ret );
};
});
jQuery.extend({
filter: function( expr, elems, not ) {
if ( not ) {
expr = ":not(" + expr + ")";
}
return elems.length === 1 ?
jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
jQuery.find.matches(expr, elems);
},
dir: function( elem, dir, until ) {
var matched = [],
cur = elem[ dir ];
while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
if ( cur.nodeType === 1 ) {
matched.push( cur );
}
cur = cur[dir];
}
return matched;
},
sibling: function( n, elem ) {
var r = [];
for ( ; n; n = n.nextSibling ) {
if ( n.nodeType === 1 && n !== elem ) {
r.push( n );
}
}
return r;
}
});
// Implement the identical functionality for filter and not
function winnow( elements, qualifier, keep ) {
// Can't pass null or undefined to indexOf in Firefox 4
// Set to 0 to skip string check
qualifier = qualifier || 0;
if ( jQuery.isFunction( qualifier ) ) {
return jQuery.grep(elements, function( elem, i ) {
var retVal = !!qualifier.call( elem, i, elem );
return retVal === keep;
});
} else if ( qualifier.nodeType ) {
return jQuery.grep(elements, function( elem ) {
return ( elem === qualifier ) === keep;
});
} else if ( typeof qualifier === "string" ) {
var filtered = jQuery.grep(elements, function( elem ) {
return elem.nodeType === 1;
});
if ( isSimple.test( qualifier ) ) {
return jQuery.filter(qualifier, filtered, !keep);
} else {
qualifier = jQuery.filter( qualifier, filtered );
}
}
return jQuery.grep(elements, function( elem ) {
return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
});
}
function createSafeFragment( document ) {
var list = nodeNames.split( "|" ),
safeFrag = document.createDocumentFragment();
if ( safeFrag.createElement ) {
while ( list.length ) {
safeFrag.createElement(
list.pop()
);
}
}
return safeFrag;
}
var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
rleadingWhitespace = /^\s+/,
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
rtagName = /<([\w:]+)/,
rtbody = /<tbody/i,
rhtml = /<|&#?\w+;/,
rnoInnerhtml = /<(?:script|style|link)/i,
manipulation_rcheckableType = /^(?:checkbox|radio)$/i,
// checked="checked" or checked
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
rscriptType = /^$|\/(?:java|ecma)script/i,
rscriptTypeMasked = /^true\/(.*)/,
rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
// We have to close these tags to support XHTML (#13200)
wrapMap = {
option: [ 1, "<select multiple='multiple'>", "</select>" ],
legend: [ 1, "<fieldset>", "</fieldset>" ],
area: [ 1, "<map>", "</map>" ],
param: [ 1, "<object>", "</object>" ],
thead: [ 1, "<table>", "</table>" ],
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
// unless wrapped in a div with non-breaking characters in front of it.
_default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ]
},
safeFragment = createSafeFragment( document ),
fragmentDiv = safeFragment.appendChild( document.createElement("div") );
wrapMap.optgroup = wrapMap.option;
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
wrapMap.th = wrapMap.td;
jQuery.fn.extend({
text: function( value ) {
return jQuery.access( this, function( value ) {
return value === undefined ?
jQuery.text( this ) :
this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
}, null, value, arguments.length );
},
wrapAll: function( html ) {
if ( jQuery.isFunction( html ) ) {
return this.each(function(i) {
jQuery(this).wrapAll( html.call(this, i) );
});
}
if ( this[0] ) {
// The elements to wrap the target around
var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
if ( this[0].parentNode ) {
wrap.insertBefore( this[0] );
}
wrap.map(function() {
var elem = this;
while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
elem = elem.firstChild;
}
return elem;
}).append( this );
}
return this;
},
wrapInner: function( html ) {
if ( jQuery.isFunction( html ) ) {
return this.each(function(i) {
jQuery(this).wrapInner( html.call(this, i) );
});
}
return this.each(function() {
var self = jQuery( this ),
contents = self.contents();
if ( contents.length ) {
contents.wrapAll( html );
} else {
self.append( html );
}
});
},
wrap: function( html ) {
var isFunction = jQuery.isFunction( html );
return this.each(function(i) {
jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
});
},
unwrap: function() {
return this.parent().each(function() {
if ( !jQuery.nodeName( this, "body" ) ) {
jQuery( this ).replaceWith( this.childNodes );
}
}).end();
},
append: function() {
return this.domManip(arguments, true, function( elem ) {
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
this.appendChild( elem );
}
});
},
prepend: function() {
return this.domManip(arguments, true, function( elem ) {
if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
this.insertBefore( elem, this.firstChild );
}
});
},
before: function() {
return this.domManip( arguments, false, function( elem ) {
if ( this.parentNode ) {
this.parentNode.insertBefore( elem, this );
}
});
},
after: function() {
return this.domManip( arguments, false, function( elem ) {
if ( this.parentNode ) {
this.parentNode.insertBefore( elem, this.nextSibling );
}
});
},
// keepData is for internal use only--do not document
remove: function( selector, keepData ) {
var elem,
i = 0;
for ( ; (elem = this[i]) != null; i++ ) {
if ( !selector || jQuery.filter( selector, [ elem ] ).length > 0 ) {
if ( !keepData && elem.nodeType === 1 ) {
jQuery.cleanData( getAll( elem ) );
}
if ( elem.parentNode ) {
if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
setGlobalEval( getAll( elem, "script" ) );
}
elem.parentNode.removeChild( elem );
}
}
}
return this;
},
empty: function() {
var elem,
i = 0;
for ( ; (elem = this[i]) != null; i++ ) {
// Remove element nodes and prevent memory leaks
if ( elem.nodeType === 1 ) {
jQuery.cleanData( getAll( elem, false ) );
}
// Remove any remaining nodes
while ( elem.firstChild ) {
elem.removeChild( elem.firstChild );
}
// If this is a select, ensure that it displays empty (#12336)
// Support: IE<9
if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
elem.options.length = 0;
}
}
return this;
},
clone: function( dataAndEvents, deepDataAndEvents ) {
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
return this.map( function () {
return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
});
},
html: function( value ) {
return jQuery.access( this, function( value ) {
var elem = this[0] || {},
i = 0,
l = this.length;
if ( value === undefined ) {
return elem.nodeType === 1 ?
elem.innerHTML.replace( rinlinejQuery, "" ) :
undefined;
}
// See if we can take a shortcut and just use innerHTML
if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
( jQuery.support.htmlSerialize || !rnoshimcache.test( value ) ) &&
( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
value = value.replace( rxhtmlTag, "<$1></$2>" );
try {
for (; i < l; i++ ) {
// Remove element nodes and prevent memory leaks
elem = this[i] || {};
if ( elem.nodeType === 1 ) {
jQuery.cleanData( getAll( elem, false ) );
elem.innerHTML = value;
}
}
elem = 0;
// If using innerHTML throws an exception, use the fallback method
} catch(e) {}
}
if ( elem ) {
this.empty().append( value );
}
}, null, value, arguments.length );
},
replaceWith: function( value ) {
var isFunc = jQuery.isFunction( value );
// Make sure that the elements are removed from the DOM before they are inserted
// this can help fix replacing a parent with child elements
if ( !isFunc && typeof value !== "string" ) {
value = jQuery( value ).not( this ).detach();
}
return this.domManip( [ value ], true, function( elem ) {
var next = this.nextSibling,
parent = this.parentNode;
if ( parent ) {
jQuery( this ).remove();
parent.insertBefore( elem, next );
}
});
},
detach: function( selector ) {
return this.remove( selector, true );
},
domManip: function( args, table, callback ) {
// Flatten any nested arrays
args = core_concat.apply( [], args );
var first, node, hasScripts,
scripts, doc, fragment,
i = 0,
l = this.length,
set = this,
iNoClone = l - 1,
value = args[0],
isFunction = jQuery.isFunction( value );
// We can't cloneNode fragments that contain checked, in WebKit
if ( isFunction || !( l <= 1 || typeof value !== "string" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
return this.each(function( index ) {
var self = set.eq( index );
if ( isFunction ) {
args[0] = value.call( this, index, table ? self.html() : undefined );
}
self.domManip( args, table, callback );
});
}
if ( l ) {
fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
first = fragment.firstChild;
if ( fragment.childNodes.length === 1 ) {
fragment = first;
}
if ( first ) {
table = table && jQuery.nodeName( first, "tr" );
scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
hasScripts = scripts.length;
// Use the original fragment for the last item instead of the first because it can end up
// being emptied incorrectly in certain situations (#8070).
for ( ; i < l; i++ ) {
node = fragment;
if ( i !== iNoClone ) {
node = jQuery.clone( node, true, true );
// Keep references to cloned scripts for later restoration
if ( hasScripts ) {
jQuery.merge( scripts, getAll( node, "script" ) );
}
}
callback.call(
table && jQuery.nodeName( this[i], "table" ) ?
findOrAppend( this[i], "tbody" ) :
this[i],
node,
i
);
}
if ( hasScripts ) {
doc = scripts[ scripts.length - 1 ].ownerDocument;
// Reenable scripts
jQuery.map( scripts, restoreScript );
// Evaluate executable scripts on first document insertion
for ( i = 0; i < hasScripts; i++ ) {
node = scripts[ i ];
if ( rscriptType.test( node.type || "" ) &&
!jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
if ( node.src ) {
// Hope ajax is available...
jQuery.ajax({
url: node.src,
type: "GET",
dataType: "script",
async: false,
global: false,
"throws": true
});
} else {
jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
}
}
}
}
// Fix #11809: Avoid leaking memory
fragment = first = null;
}
}
return this;
}
});
function findOrAppend( elem, tag ) {
return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
}
// Replace/restore the type attribute of script elements for safe DOM manipulation
function disableScript( elem ) {
var attr = elem.getAttributeNode("type");
elem.type = ( attr && attr.specified ) + "/" + elem.type;
return elem;
}
function restoreScript( elem ) {
var match = rscriptTypeMasked.exec( elem.type );
if ( match ) {
elem.type = match[1];
} else {
elem.removeAttribute("type");
}
return elem;
}
// Mark scripts as having already been evaluated
function setGlobalEval( elems, refElements ) {
var elem,
i = 0;
for ( ; (elem = elems[i]) != null; i++ ) {
jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
}
}
function cloneCopyEvent( src, dest ) {
if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
return;
}
var type, i, l,
oldData = jQuery._data( src ),
curData = jQuery._data( dest, oldData ),
events = oldData.events;
if ( events ) {
delete curData.handle;
curData.events = {};
for ( type in events ) {
for ( i = 0, l = events[ type ].length; i < l; i++ ) {
jQuery.event.add( dest, type, events[ type ][ i ] );
}
}
}
// make the cloned public data object a copy from the original
if ( curData.data ) {
curData.data = jQuery.extend( {}, curData.data );
}
}
function fixCloneNodeIssues( src, dest ) {
var nodeName, e, data;
// We do not need to do anything for non-Elements
if ( dest.nodeType !== 1 ) {
return;
}
nodeName = dest.nodeName.toLowerCase();
// IE6-8 copies events bound via attachEvent when using cloneNode.
if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) {
data = jQuery._data( dest );
for ( e in data.events ) {
jQuery.removeEvent( dest, e, data.handle );
}
// Event data gets referenced instead of copied if the expando gets copied too
dest.removeAttribute( jQuery.expando );
}
// IE blanks contents when cloning scripts, and tries to evaluate newly-set text
if ( nodeName === "script" && dest.text !== src.text ) {
disableScript( dest ).text = src.text;
restoreScript( dest );
// IE6-10 improperly clones children of object elements using classid.
// IE10 throws NoModificationAllowedError if parent is null, #12132.
} else if ( nodeName === "object" ) {
if ( dest.parentNode ) {
dest.outerHTML = src.outerHTML;
}
// This path appears unavoidable for IE9. When cloning an object
// element in IE9, the outerHTML strategy above is not sufficient.
// If the src has innerHTML and the destination does not,
// copy the src.innerHTML into the dest.innerHTML. #10324
if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
dest.innerHTML = src.innerHTML;
}
} else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) {
// IE6-8 fails to persist the checked state of a cloned checkbox
// or radio button. Worse, IE6-7 fail to give the cloned element
// a checked appearance if the defaultChecked value isn't also set
dest.defaultChecked = dest.checked = src.checked;
// IE6-7 get confused and end up setting the value of a cloned
// checkbox/radio button to an empty string instead of "on"
if ( dest.value !== src.value ) {
dest.value = src.value;
}
// IE6-8 fails to return the selected option to the default selected
// state when cloning options
} else if ( nodeName === "option" ) {
dest.defaultSelected = dest.selected = src.defaultSelected;
// IE6-8 fails to set the defaultValue to the correct value when
// cloning other types of input fields
} else if ( nodeName === "input" || nodeName === "textarea" ) {
dest.defaultValue = src.defaultValue;
}
}
jQuery.each({
appendTo: "append",
prependTo: "prepend",
insertBefore: "before",
insertAfter: "after",
replaceAll: "replaceWith"
}, function( name, original ) {
jQuery.fn[ name ] = function( selector ) {
var elems,
i = 0,
ret = [],
insert = jQuery( selector ),
last = insert.length - 1;
for ( ; i <= last; i++ ) {
elems = i === last ? this : this.clone(true);
jQuery( insert[i] )[ original ]( elems );
// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
core_push.apply( ret, elems.get() );
}
return this.pushStack( ret );
};
});
function getAll( context, tag ) {
var elems, elem,
i = 0,
found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) :
typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) :
undefined;
if ( !found ) {
for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
if ( !tag || jQuery.nodeName( elem, tag ) ) {
found.push( elem );
} else {
jQuery.merge( found, getAll( elem, tag ) );
}
}
}
return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
jQuery.merge( [ context ], found ) :
found;
}
// Used in buildFragment, fixes the defaultChecked property
function fixDefaultChecked( elem ) {
if ( manipulation_rcheckableType.test( elem.type ) ) {
elem.defaultChecked = elem.checked;
}
}
jQuery.extend({
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
var destElements, node, clone, i, srcElements,
inPage = jQuery.contains( elem.ownerDocument, elem );
if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
clone = elem.cloneNode( true );
// IE<=8 does not properly clone detached, unknown element nodes
} else {
fragmentDiv.innerHTML = elem.outerHTML;
fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
}
if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
destElements = getAll( clone );
srcElements = getAll( elem );
// Fix all IE cloning issues
for ( i = 0; (node = srcElements[i]) != null; ++i ) {
// Ensure that the destination node is not null; Fixes #9587
if ( destElements[i] ) {
fixCloneNodeIssues( node, destElements[i] );
}
}
}
// Copy the events from the original to the clone
if ( dataAndEvents ) {
if ( deepDataAndEvents ) {
srcElements = srcElements || getAll( elem );
destElements = destElements || getAll( clone );
for ( i = 0; (node = srcElements[i]) != null; i++ ) {
cloneCopyEvent( node, destElements[i] );
}
} else {
cloneCopyEvent( elem, clone );
}
}
// Preserve script evaluation history
destElements = getAll( clone, "script" );
if ( destElements.length > 0 ) {
setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
}
destElements = srcElements = node = null;
// Return the cloned set
return clone;
},
buildFragment: function( elems, context, scripts, selection ) {
var j, elem, contains,
tmp, tag, tbody, wrap,
l = elems.length,
// Ensure a safe fragment
safe = createSafeFragment( context ),
nodes = [],
i = 0;
for ( ; i < l; i++ ) {
elem = elems[ i ];
if ( elem || elem === 0 ) {
// Add nodes directly
if ( jQuery.type( elem ) === "object" ) {
jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
// Convert non-html into a text node
} else if ( !rhtml.test( elem ) ) {
nodes.push( context.createTextNode( elem ) );
// Convert html into DOM nodes
} else {
tmp = tmp || safe.appendChild( context.createElement("div") );
// Deserialize a standard representation
tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
wrap = wrapMap[ tag ] || wrapMap._default;
tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2];
// Descend through wrappers to the right content
j = wrap[0];
while ( j-- ) {
tmp = tmp.lastChild;
}
// Manually add leading whitespace removed by IE
if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
}
// Remove IE's autoinserted <tbody> from table fragments
if ( !jQuery.support.tbody ) {
// String was a <table>, *may* have spurious <tbody>
elem = tag === "table" && !rtbody.test( elem ) ?
tmp.firstChild :
// String was a bare <thead> or <tfoot>
wrap[1] === "<table>" && !rtbody.test( elem ) ?
tmp :
0;
j = elem && elem.childNodes.length;
while ( j-- ) {
if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
elem.removeChild( tbody );
}
}
}
jQuery.merge( nodes, tmp.childNodes );
// Fix #12392 for WebKit and IE > 9
tmp.textContent = "";
// Fix #12392 for oldIE
while ( tmp.firstChild ) {
tmp.removeChild( tmp.firstChild );
}
// Remember the top-level container for proper cleanup
tmp = safe.lastChild;
}
}
}
// Fix #11356: Clear elements from fragment
if ( tmp ) {
safe.removeChild( tmp );
}
// Reset defaultChecked for any radios and checkboxes
// about to be appended to the DOM in IE 6/7 (#8060)
if ( !jQuery.support.appendChecked ) {
jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
}
i = 0;
while ( (elem = nodes[ i++ ]) ) {
// #4087 - If origin and destination elements are the same, and this is
// that element, do not do anything
if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
continue;
}
contains = jQuery.contains( elem.ownerDocument, elem );
// Append to fragment
tmp = getAll( safe.appendChild( elem ), "script" );
// Preserve script evaluation history
if ( contains ) {
setGlobalEval( tmp );
}
// Capture executables
if ( scripts ) {
j = 0;
while ( (elem = tmp[ j++ ]) ) {
if ( rscriptType.test( elem.type || "" ) ) {
scripts.push( elem );
}
}
}
}
tmp = null;
return safe;
},
cleanData: function( elems, /* internal */ acceptData ) {
var elem, type, id, data,
i = 0,
internalKey = jQuery.expando,
cache = jQuery.cache,
deleteExpando = jQuery.support.deleteExpando,
special = jQuery.event.special;
for ( ; (elem = elems[i]) != null; i++ ) {
if ( acceptData || jQuery.acceptData( elem ) ) {
id = elem[ internalKey ];
data = id && cache[ id ];
if ( data ) {
if ( data.events ) {
for ( type in data.events ) {
if ( special[ type ] ) {
jQuery.event.remove( elem, type );
// This is a shortcut to avoid jQuery.event.remove's overhead
} else {
jQuery.removeEvent( elem, type, data.handle );
}
}
}
// Remove cache only if it was not already removed by jQuery.event.remove
if ( cache[ id ] ) {
delete cache[ id ];
// IE does not allow us to delete expando properties from nodes,
// nor does it have a removeAttribute function on Document nodes;
// we must handle all of these cases
if ( deleteExpando ) {
delete elem[ internalKey ];
} else if ( typeof elem.removeAttribute !== core_strundefined ) {
elem.removeAttribute( internalKey );
} else {
elem[ internalKey ] = null;
}
core_deletedIds.push( id );
}
}
}
}
}
});
var iframe, getStyles, curCSS,
ralpha = /alpha\([^)]*\)/i,
ropacity = /opacity\s*=\s*([^)]*)/,
rposition = /^(top|right|bottom|left)$/,
// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
rdisplayswap = /^(none|table(?!-c[ea]).+)/,
rmargin = /^margin/,
rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
rrelNum = new RegExp( "^([+-])=(" + core_pnum + ")", "i" ),
elemdisplay = { BODY: "block" },
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
cssNormalTransform = {
letterSpacing: 0,
fontWeight: 400
},
cssExpand = [ "Top", "Right", "Bottom", "Left" ],
cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
// return a css property mapped to a potentially vendor prefixed property
function vendorPropName( style, name ) {
// shortcut for names that are not vendor prefixed
if ( name in style ) {
return name;
}
// check for vendor prefixed names
var capName = name.charAt(0).toUpperCase() + name.slice(1),
origName = name,
i = cssPrefixes.length;
while ( i-- ) {
name = cssPrefixes[ i ] + capName;
if ( name in style ) {
return name;
}
}
return origName;
}
function isHidden( elem, el ) {
// isHidden might be called from jQuery#filter function;
// in that case, element will be second argument
elem = el || elem;
return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
}
function showHide( elements, show ) {
var display, elem, hidden,
values = [],
index = 0,
length = elements.length;
for ( ; index < length; index++ ) {
elem = elements[ index ];
if ( !elem.style ) {
continue;
}
values[ index ] = jQuery._data( elem, "olddisplay" );
display = elem.style.display;
if ( show ) {
// Reset the inline display of this element to learn if it is
// being hidden by cascaded rules or not
if ( !values[ index ] && display === "none" ) {
elem.style.display = "";
}
// Set elements which have been overridden with display: none
// in a stylesheet to whatever the default browser style is
// for such an element
if ( elem.style.display === "" && isHidden( elem ) ) {
values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
}
} else {
if ( !values[ index ] ) {
hidden = isHidden( elem );
if ( display && display !== "none" || !hidden ) {
jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
}
}
}
}
// Set the display of most of the elements in a second loop
// to avoid the constant reflow
for ( index = 0; index < length; index++ ) {
elem = elements[ index ];
if ( !elem.style ) {
continue;
}
if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
elem.style.display = show ? values[ index ] || "" : "none";
}
}
return elements;
}
jQuery.fn.extend({
css: function( name, value ) {
return jQuery.access( this, function( elem, name, value ) {
var len, styles,
map = {},
i = 0;
if ( jQuery.isArray( name ) ) {
styles = getStyles( elem );
len = name.length;
for ( ; i < len; i++ ) {
map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
}
return map;
}
return value !== undefined ?
jQuery.style( elem, name, value ) :
jQuery.css( elem, name );
}, name, value, arguments.length > 1 );
},
show: function() {
return showHide( this, true );
},
hide: function() {
return showHide( this );
},
toggle: function( state ) {
var bool = typeof state === "boolean";
return this.each(function() {
if ( bool ? state : isHidden( this ) ) {
jQuery( this ).show();
} else {
jQuery( this ).hide();
}
});
}
});
jQuery.extend({
// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
opacity: {
get: function( elem, computed ) {
if ( computed ) {
// We should always get a number back from opacity
var ret = curCSS( elem, "opacity" );
return ret === "" ? "1" : ret;
}
}
}
},
// Exclude the following css properties to add px
cssNumber: {
"columnCount": true,
"fillOpacity": true,
"fontWeight": true,
"lineHeight": true,
"opacity": true,
"orphans": true,
"widows": true,
"zIndex": true,
"zoom": true
},
// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {
// normalize float css property
"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
},
// Get and set the style property on a DOM Node
style: function( elem, name, value, extra ) {
// Don't set styles on text and comment nodes
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
return;
}
// Make sure that we're working with the right name
var ret, type, hooks,
origName = jQuery.camelCase( name ),
style = elem.style;
name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
// gets hook for the prefixed version
// followed by the unprefixed version
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
// Check if we're setting a value
if ( value !== undefined ) {
type = typeof value;
// convert relative number strings (+= or -=) to relative numbers. #7345
if ( type === "string" && (ret = rrelNum.exec( value )) ) {
value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
// Fixes bug #9237
type = "number";
}
// Make sure that NaN and null values aren't set. See: #7116
if ( value == null || type === "number" && isNaN( value ) ) {
return;
}
// If a number was passed in, add 'px' to the (except for certain CSS properties)
if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
value += "px";
}
// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
// but it would mean to define eight (for every problematic property) identical functions
if ( !jQuery.support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) {
style[ name ] = "inherit";
}
// If a hook was provided, use that value, otherwise just set the specified value
if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
// Fixes bug #5509
try {
style[ name ] = value;
} catch(e) {}
}
} else {
// If a hook was provided get the non-computed value from there
if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
return ret;
}
// Otherwise just get the value from the style object
return style[ name ];
}
},
css: function( elem, name, extra, styles ) {
var num, val, hooks,
origName = jQuery.camelCase( name );
// Make sure that we're working with the right name
name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
// gets hook for the prefixed version
// followed by the unprefixed version
hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
// If a hook was provided get the computed value from there
if ( hooks && "get" in hooks ) {
val = hooks.get( elem, true, extra );
}
// Otherwise, if a way to get the computed value exists, use that
if ( val === undefined ) {
val = curCSS( elem, name, styles );
}
//convert "normal" to computed value
if ( val === "normal" && name in cssNormalTransform ) {
val = cssNormalTransform[ name ];
}
// Return, converting to number if forced or a qualifier was provided and val looks numeric
if ( extra === "" || extra ) {
num = parseFloat( val );
return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
}
return val;
},
// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function( elem, options, callback, args ) {
var ret, name,
old = {};
// Remember the old values, and insert the new ones
for ( name in options ) {
old[ name ] = elem.style[ name ];
elem.style[ name ] = options[ name ];
}
ret = callback.apply( elem, args || [] );
// Revert the old values
for ( name in options ) {
elem.style[ name ] = old[ name ];
}
return ret;
}
});
// NOTE: we've included the "window" in window.getComputedStyle
// because jsdom on node.js will break without it.
if ( window.getComputedStyle ) {
getStyles = function( elem ) {
return window.getComputedStyle( elem, null );
};
curCSS = function( elem, name, _computed ) {
var width, minWidth, maxWidth,
computed = _computed || getStyles( elem ),
// getPropertyValue is only needed for .css('filter') in IE9, see #12537
ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined,
style = elem.style;
if ( computed ) {
if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
ret = jQuery.style( elem, name );
}
// A tribute to the "awesome hack by Dean Edwards"
// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
// Remember the original values
width = style.width;
minWidth = style.minWidth;
maxWidth = style.maxWidth;
// Put in the new values to get a computed value out
style.minWidth = style.maxWidth = style.width = ret;
ret = computed.width;
// Revert the changed values
style.width = width;
style.minWidth = minWidth;
style.maxWidth = maxWidth;
}
}
return ret;
};
} else if ( document.documentElement.currentStyle ) {
getStyles = function( elem ) {
return elem.currentStyle;
};
curCSS = function( elem, name, _computed ) {
var left, rs, rsLeft,
computed = _computed || getStyles( elem ),
ret = computed ? computed[ name ] : undefined,
style = elem.style;
// Avoid setting ret to empty string here
// so we don't default to auto
if ( ret == null && style && style[ name ] ) {
ret = style[ name ];
}
// From the awesome hack by Dean Edwards
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
// If we're not dealing with a regular pixel number
// but a number that has a weird ending, we need to convert it to pixels
// but not position css attributes, as those are proportional to the parent element instead
// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
// Remember the original values
left = style.left;
rs = elem.runtimeStyle;
rsLeft = rs && rs.left;
// Put in the new values to get a computed value out
if ( rsLeft ) {
rs.left = elem.currentStyle.left;
}
style.left = name === "fontSize" ? "1em" : ret;
ret = style.pixelLeft + "px";
// Revert the changed values
style.left = left;
if ( rsLeft ) {
rs.left = rsLeft;
}
}
return ret === "" ? "auto" : ret;
};
}
function setPositiveNumber( elem, value, subtract ) {
var matches = rnumsplit.exec( value );
return matches ?
// Guard against undefined "subtract", e.g., when used as in cssHooks
Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
value;
}
function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
var i = extra === ( isBorderBox ? "border" : "content" ) ?
// If we already have the right measurement, avoid augmentation
4 :
// Otherwise initialize for horizontal or vertical properties
name === "width" ? 1 : 0,
val = 0;
for ( ; i < 4; i += 2 ) {
// both box models exclude margin, so add it if we want it
if ( extra === "margin" ) {
val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
}
if ( isBorderBox ) {
// border-box includes padding, so remove it if we want content
if ( extra === "content" ) {
val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
}
// at this point, extra isn't border nor margin, so remove border
if ( extra !== "margin" ) {
val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
}
} else {
// at this point, extra isn't content, so add padding
val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
// at this point, extra isn't content nor padding, so add border
if ( extra !== "padding" ) {
val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
}
}
}
return val;
}
function getWidthOrHeight( elem, name, extra ) {
// Start with offset property, which is equivalent to the border-box value
var valueIsBorderBox = true,
val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
styles = getStyles( elem ),
isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
// some non-html elements return undefined for offsetWidth, so check for null/undefined
// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
if ( val <= 0 || val == null ) {
// Fall back to computed then uncomputed css if necessary
val = curCSS( elem, name, styles );
if ( val < 0 || val == null ) {
val = elem.style[ name ];
}
// Computed unit is not pixels. Stop here and return.
if ( rnumnonpx.test(val) ) {
return val;
}
// we need the check for style in case a browser which returns unreliable values
// for getComputedStyle silently falls back to the reliable elem.style
valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );
// Normalize "", auto, and prepare for extra
val = parseFloat( val ) || 0;
}
// use the active box-sizing model to add/subtract irrelevant styles
return ( val +
augmentWidthOrHeight(
elem,
name,
extra || ( isBorderBox ? "border" : "content" ),
valueIsBorderBox,
styles
)
) + "px";
}
// Try to determine the default display value of an element
function css_defaultDisplay( nodeName ) {
var doc = document,
display = elemdisplay[ nodeName ];
if ( !display ) {
display = actualDisplay( nodeName, doc );
// If the simple way fails, read from inside an iframe
if ( display === "none" || !display ) {
// Use the already-created iframe if possible
iframe = ( iframe ||
jQuery("<iframe frameborder='0' width='0' height='0'/>")
.css( "cssText", "display:block !important" )
).appendTo( doc.documentElement );
// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
doc = ( iframe[0].contentWindow || iframe[0].contentDocument ).document;
doc.write("<!doctype html><html><body>");
doc.close();
display = actualDisplay( nodeName, doc );
iframe.detach();
}
// Store the correct default display
elemdisplay[ nodeName ] = display;
}
return display;
}
// Called ONLY from within css_defaultDisplay
function actualDisplay( name, doc ) {
var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
display = jQuery.css( elem[0], "display" );
elem.remove();
return display;
}
jQuery.each([ "height", "width" ], function( i, name ) {
jQuery.cssHooks[ name ] = {
get: function( elem, computed, extra ) {
if ( computed ) {
// certain elements can have dimension info if we invisibly show them
// however, it must have a current display style that would benefit from this
return elem.offsetWidth === 0 && rdisplayswap.test( jQuery.css( elem, "display" ) ) ?
jQuery.swap( elem, cssShow, function() {
return getWidthOrHeight( elem, name, extra );
}) :
getWidthOrHeight( elem, name, extra );
}
},
set: function( elem, value, extra ) {
var styles = extra && getStyles( elem );
return setPositiveNumber( elem, value, extra ?
augmentWidthOrHeight(
elem,
name,
extra,
jQuery.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
styles
) : 0
);
}
};
});
if ( !jQuery.support.opacity ) {
jQuery.cssHooks.opacity = {
get: function( elem, computed ) {
// IE uses filters for opacity
return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
computed ? "1" : "";
},
set: function( elem, value ) {
var style = elem.style,
currentStyle = elem.currentStyle,
opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
filter = currentStyle && currentStyle.filter || style.filter || "";
// IE has trouble with opacity if it does not have layout
// Force it by setting the zoom level
style.zoom = 1;
// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
// if value === "", then remove inline opacity #12685
if ( ( value >= 1 || value === "" ) &&
jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
style.removeAttribute ) {
// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
// if "filter:" is present at all, clearType is disabled, we want to avoid this
// style.removeAttribute is IE Only, but so apparently is this code path...
style.removeAttribute( "filter" );
// if there is no filter style applied in a css rule or unset inline opacity, we are done
if ( value === "" || currentStyle && !currentStyle.filter ) {
return;
}
}
// otherwise, set new filter values
style.filter = ralpha.test( filter ) ?
filter.replace( ralpha, opacity ) :
filter + " " + opacity;
}
};
}
// These hooks cannot be added until DOM ready because the support test
// for it is not run until after DOM ready
jQuery(function() {
if ( !jQuery.support.reliableMarginRight ) {
jQuery.cssHooks.marginRight = {
get: function( elem, computed ) {
if ( computed ) {
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
// Work around by temporarily setting element display to inline-block
return jQuery.swap( elem, { "display": "inline-block" },
curCSS, [ elem, "marginRight" ] );
}
}
};
}
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
// getComputedStyle returns percent when specified for top/left/bottom/right
// rather than make the css module depend on the offset module, we just check for it here
if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
jQuery.each( [ "top", "left" ], function( i, prop ) {
jQuery.cssHooks[ prop ] = {
get: function( elem, computed ) {
if ( computed ) {
computed = curCSS( elem, prop );
// if curCSS returns percentage, fallback to offset
return rnumnonpx.test( computed ) ?
jQuery( elem ).position()[ prop ] + "px" :
computed;
}
}
};
});
}
});
if ( jQuery.expr && jQuery.expr.filters ) {
jQuery.expr.filters.hidden = function( elem ) {
// Support: Opera <= 12.12
// Opera reports offsetWidths and offsetHeights less than zero on some elements
return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
(!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
};
jQuery.expr.filters.visible = function( elem ) {
return !jQuery.expr.filters.hidden( elem );
};
}
// These hooks are used by animate to expand properties
jQuery.each({
margin: "",
padding: "",
border: "Width"
}, function( prefix, suffix ) {
jQuery.cssHooks[ prefix + suffix ] = {
expand: function( value ) {
var i = 0,
expanded = {},
// assumes a single number if not a string
parts = typeof value === "string" ? value.split(" ") : [ value ];
for ( ; i < 4; i++ ) {
expanded[ prefix + cssExpand[ i ] + suffix ] =
parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
}
return expanded;
}
};
if ( !rmargin.test( prefix ) ) {
jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
}
});
var r20 = /%20/g,
rbracket = /\[\]$/,
rCRLF = /\r?\n/g,
rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
rsubmittable = /^(?:input|select|textarea|keygen)/i;
jQuery.fn.extend({
serialize: function() {
return jQuery.param( this.serializeArray() );
},
serializeArray: function() {
return this.map(function(){
// Can add propHook for "elements" to filter or add form elements
var elements = jQuery.prop( this, "elements" );
return elements ? jQuery.makeArray( elements ) : this;
})
.filter(function(){
var type = this.type;
// Use .is(":disabled") so that fieldset[disabled] works
return this.name && !jQuery( this ).is( ":disabled" ) &&
rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
( this.checked || !manipulation_rcheckableType.test( type ) );
})
.map(function( i, elem ){
var val = jQuery( this ).val();
return val == null ?
null :
jQuery.isArray( val ) ?
jQuery.map( val, function( val ){
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
}) :
{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
}).get();
}
});
//Serialize an array of form elements or a set of
//key/values into a query string
jQuery.param = function( a, traditional ) {
var prefix,
s = [],
add = function( key, value ) {
// If value is a function, invoke it and return its value
value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
};
// Set traditional to true for jQuery <= 1.3.2 behavior.
if ( traditional === undefined ) {
traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
}
// If an array was passed in, assume that it is an array of form elements.
if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
// Serialize the form elements
jQuery.each( a, function() {
add( this.name, this.value );
});
} else {
// If traditional, encode the "old" way (the way 1.3.2 or older
// did it), otherwise encode params recursively.
for ( prefix in a ) {
buildParams( prefix, a[ prefix ], traditional, add );
}
}
// Return the resulting serialization
return s.join( "&" ).replace( r20, "+" );
};
function buildParams( prefix, obj, traditional, add ) {
var name;
if ( jQuery.isArray( obj ) ) {
// Serialize array item.
jQuery.each( obj, function( i, v ) {
if ( traditional || rbracket.test( prefix ) ) {
// Treat each array item as a scalar.
add( prefix, v );
} else {
// Item is non-scalar (array or object), encode its numeric index.
buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
}
});
} else if ( !traditional && jQuery.type( obj ) === "object" ) {
// Serialize object item.
for ( name in obj ) {
buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
}
} else {
// Serialize scalar item.
add( prefix, obj );
}
}
jQuery.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 contextmenu").split(" "), function( i, name ) {
// Handle event binding
jQuery.fn[ name ] = function( data, fn ) {
return arguments.length > 0 ?
this.on( name, null, data, fn ) :
this.trigger( name );
};
});
jQuery.fn.hover = function( fnOver, fnOut ) {
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
};
var
// Document location
ajaxLocParts,
ajaxLocation,
ajax_nonce = jQuery.now(),
ajax_rquery = /\?/,
rhash = /#.*$/,
rts = /([?&])_=[^&]*/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
// #7653, #8125, #8152: local protocol detection
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
// Keep a copy of the old load method
_load = jQuery.fn.load,
/* Prefilters
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
* 2) These are called:
* - BEFORE asking for a transport
* - AFTER param serialization (s.data is a string if s.processData is true)
* 3) key is the dataType
* 4) the catchall symbol "*" can be used
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
*/
prefilters = {},
/* Transports bindings
* 1) key is the dataType
* 2) the catchall symbol "*" can be used
* 3) selection will start with transport dataType and THEN go to "*" if needed
*/
transports = {},
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = "*/".concat("*");
// #8138, IE may throw an exception when accessing
// a field from window.location if document.domain has been set
try {
ajaxLocation = location.href;
} catch( e ) {
// Use the href attribute of an A element
// since IE will modify it given document.location
ajaxLocation = document.createElement( "a" );
ajaxLocation.href = "";
ajaxLocation = ajaxLocation.href;
}
// Segment location into parts
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
function addToPrefiltersOrTransports( structure ) {
// dataTypeExpression is optional and defaults to "*"
return function( dataTypeExpression, func ) {
if ( typeof dataTypeExpression !== "string" ) {
func = dataTypeExpression;
dataTypeExpression = "*";
}
var dataType,
i = 0,
dataTypes = dataTypeExpression.toLowerCase().match( core_rnotwhite ) || [];
if ( jQuery.isFunction( func ) ) {
// For each dataType in the dataTypeExpression
while ( (dataType = dataTypes[i++]) ) {
// Prepend if requested
if ( dataType[0] === "+" ) {
dataType = dataType.slice( 1 ) || "*";
(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
// Otherwise append
} else {
(structure[ dataType ] = structure[ dataType ] || []).push( func );
}
}
}
};
}
// Base inspection function for prefilters and transports
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
var inspected = {},
seekingTransport = ( structure === transports );
function inspect( dataType ) {
var selected;
inspected[ dataType ] = true;
jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
if( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
options.dataTypes.unshift( dataTypeOrTransport );
inspect( dataTypeOrTransport );
return false;
} else if ( seekingTransport ) {
return !( selected = dataTypeOrTransport );
}
});
return selected;
}
return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
}
// A special extend for ajax options
// that takes "flat" options (not to be deep extended)
// Fixes #9887
function ajaxExtend( target, src ) {
var deep, key,
flatOptions = jQuery.ajaxSettings.flatOptions || {};
for ( key in src ) {
if ( src[ key ] !== undefined ) {
( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
}
}
if ( deep ) {
jQuery.extend( true, target, deep );
}
return target;
}
jQuery.fn.load = function( url, params, callback ) {
if ( typeof url !== "string" && _load ) {
return _load.apply( this, arguments );
}
var selector, response, type,
self = this,
off = url.indexOf(" ");
if ( off >= 0 ) {
selector = url.slice( off, url.length );
url = url.slice( 0, off );
}
// If it's a function
if ( jQuery.isFunction( params ) ) {
// We assume that it's the callback
callback = params;
params = undefined;
// Otherwise, build a param string
} else if ( params && typeof params === "object" ) {
type = "POST";
}
// If we have elements to modify, make the request
if ( self.length > 0 ) {
jQuery.ajax({
url: url,
// if "type" variable is undefined, then "GET" method will be used
type: type,
dataType: "html",
data: params
}).done(function( responseText ) {
// Save response for use in complete callback
response = arguments;
self.html( selector ?
// If a selector was specified, locate the right elements in a dummy div
// Exclude scripts to avoid IE 'Permission Denied' errors
jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
// Otherwise use the full result
responseText );
}).complete( callback && function( jqXHR, status ) {
self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
});
}
return this;
};
// Attach a bunch of functions for handling common AJAX events
jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ){
jQuery.fn[ type ] = function( fn ){
return this.on( type, fn );
};
});
jQuery.each( [ "get", "post" ], function( i, method ) {
jQuery[ method ] = function( url, data, callback, type ) {
// shift arguments if data argument was omitted
if ( jQuery.isFunction( data ) ) {
type = type || callback;
callback = data;
data = undefined;
}
return jQuery.ajax({
url: url,
type: method,
dataType: type,
data: data,
success: callback
});
};
});
jQuery.extend({
// Counter for holding the number of active queries
active: 0,
// Last-Modified header cache for next request
lastModified: {},
etag: {},
ajaxSettings: {
url: ajaxLocation,
type: "GET",
isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
global: true,
processData: true,
async: true,
contentType: "application/x-www-form-urlencoded; charset=UTF-8",
/*
timeout: 0,
data: null,
dataType: null,
username: null,
password: null,
cache: null,
throws: false,
traditional: false,
headers: {},
*/
accepts: {
"*": allTypes,
text: "text/plain",
html: "text/html",
xml: "application/xml, text/xml",
json: "application/json, text/javascript"
},
contents: {
xml: /xml/,
html: /html/,
json: /json/
},
responseFields: {
xml: "responseXML",
text: "responseText"
},
// Data converters
// Keys separate source (or catchall "*") and destination types with a single space
converters: {
// Convert anything to text
"* text": window.String,
// Text to html (true = no transformation)
"text html": true,
// Evaluate text as a json expression
"text json": jQuery.parseJSON,
// Parse text as xml
"text xml": jQuery.parseXML
},
// For options that shouldn't be deep extended:
// you can add your own custom options here if
// and when you create one that shouldn't be
// deep extended (see ajaxExtend)
flatOptions: {
url: true,
context: true
}
},
// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function( target, settings ) {
return settings ?
// Building a settings object
ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
// Extending ajaxSettings
ajaxExtend( jQuery.ajaxSettings, target );
},
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),
// Main method
ajax: function( url, options ) {
// If url is an object, simulate pre-1.5 signature
if ( typeof url === "object" ) {
options = url;
url = undefined;
}
// Force options to be an object
options = options || {};
var // Cross-domain detection vars
parts,
// Loop variable
i,
// URL without anti-cache param
cacheURL,
// Response headers as string
responseHeadersString,
// timeout handle
timeoutTimer,
// To know if global events are to be dispatched
fireGlobals,
transport,
// Response headers
responseHeaders,
// Create the final options object
s = jQuery.ajaxSetup( {}, options ),
// Callbacks context
callbackContext = s.context || s,
// Context for global events is callbackContext if it is a DOM node or jQuery collection
globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
jQuery( callbackContext ) :
jQuery.event,
// Deferreds
deferred = jQuery.Deferred(),
completeDeferred = jQuery.Callbacks("once memory"),
// Status-dependent callbacks
statusCode = s.statusCode || {},
// Headers (they are sent all at once)
requestHeaders = {},
requestHeadersNames = {},
// The jqXHR state
state = 0,
// Default abort message
strAbort = "canceled",
// Fake xhr
jqXHR = {
readyState: 0,
// Builds headers hashtable if needed
getResponseHeader: function( key ) {
var match;
if ( state === 2 ) {
if ( !responseHeaders ) {
responseHeaders = {};
while ( (match = rheaders.exec( responseHeadersString )) ) {
responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
}
}
match = responseHeaders[ key.toLowerCase() ];
}
return match == null ? null : match;
},
// Raw string
getAllResponseHeaders: function() {
return state === 2 ? responseHeadersString : null;
},
// Caches the header
setRequestHeader: function( name, value ) {
var lname = name.toLowerCase();
if ( !state ) {
name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
requestHeaders[ name ] = value;
}
return this;
},
// Overrides response content-type header
overrideMimeType: function( type ) {
if ( !state ) {
s.mimeType = type;
}
return this;
},
// Status-dependent callbacks
statusCode: function( map ) {
var code;
if ( map ) {
if ( state < 2 ) {
for ( code in map ) {
// Lazy-add the new callback in a way that preserves old ones
statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
}
} else {
// Execute the appropriate callbacks
jqXHR.always( map[ jqXHR.status ] );
}
}
return this;
},
// Cancel the request
abort: function( statusText ) {
var finalText = statusText || strAbort;
if ( transport ) {
transport.abort( finalText );
}
done( 0, finalText );
return this;
}
};
// Attach deferreds
deferred.promise( jqXHR ).complete = completeDeferred.add;
jqXHR.success = jqXHR.done;
jqXHR.error = jqXHR.fail;
// Remove hash character (#7531: and string promotion)
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
// Handle falsy url in the settings object (#10093: consistency with old signature)
// We also use the url parameter if available
s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
// Alias method option to type as per ticket #12004
s.type = options.method || options.type || s.method || s.type;
// Extract dataTypes list
s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( core_rnotwhite ) || [""];
// A cross-domain request is in order when we have a protocol:host:port mismatch
if ( s.crossDomain == null ) {
parts = rurl.exec( s.url.toLowerCase() );
s.crossDomain = !!( parts &&
( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
);
}
// Convert data if not already a string
if ( s.data && s.processData && typeof s.data !== "string" ) {
s.data = jQuery.param( s.data, s.traditional );
}
// Apply prefilters
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
// If request was aborted inside a prefilter, stop there
if ( state === 2 ) {
return jqXHR;
}
// We can fire global events as of now if asked to
fireGlobals = s.global;
// Watch for a new set of requests
if ( fireGlobals && jQuery.active++ === 0 ) {
jQuery.event.trigger("ajaxStart");
}
// Uppercase the type
s.type = s.type.toUpperCase();
// Determine if request has content
s.hasContent = !rnoContent.test( s.type );
// Save the URL in case we're toying with the If-Modified-Since
// and/or If-None-Match header later on
cacheURL = s.url;
// More options handling for requests with no content
if ( !s.hasContent ) {
// If data is available, append data to url
if ( s.data ) {
cacheURL = ( s.url += ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
// #9682: remove data so that it's not used in an eventual retry
delete s.data;
}
// Add anti-cache in url if needed
if ( s.cache === false ) {
s.url = rts.test( cacheURL ) ?
// If there is already a '_' parameter, set its value
cacheURL.replace( rts, "$1_=" + ajax_nonce++ ) :
// Otherwise add one to the end
cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_nonce++;
}
}
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if ( s.ifModified ) {
if ( jQuery.lastModified[ cacheURL ] ) {
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
}
if ( jQuery.etag[ cacheURL ] ) {
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
}
}
// Set the correct header, if data is being sent
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
jqXHR.setRequestHeader( "Content-Type", s.contentType );
}
// Set the Accepts header for the server, depending on the dataType
jqXHR.setRequestHeader(
"Accept",
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
s.accepts[ "*" ]
);
// Check for headers option
for ( i in s.headers ) {
jqXHR.setRequestHeader( i, s.headers[ i ] );
}
// Allow custom headers/mimetypes and early abort
if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
// Abort if not done already and return
return jqXHR.abort();
}
// aborting is no longer a cancellation
strAbort = "abort";
// Install callbacks on deferreds
for ( i in { success: 1, error: 1, complete: 1 } ) {
jqXHR[ i ]( s[ i ] );
}
// Get transport
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
// If no transport, we auto-abort
if ( !transport ) {
done( -1, "No Transport" );
} else {
jqXHR.readyState = 1;
// Send global event
if ( fireGlobals ) {
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
}
// Timeout
if ( s.async && s.timeout > 0 ) {
timeoutTimer = setTimeout(function() {
jqXHR.abort("timeout");
}, s.timeout );
}
try {
state = 1;
transport.send( requestHeaders, done );
} catch ( e ) {
// Propagate exception as error if not done
if ( state < 2 ) {
done( -1, e );
// Simply rethrow otherwise
} else {
throw e;
}
}
}
// Callback for when everything is done
function done( status, nativeStatusText, responses, headers ) {
var isSuccess, success, error, response, modified,
statusText = nativeStatusText;
// Called once
if ( state === 2 ) {
return;
}
// State is "done" now
state = 2;
// Clear timeout if it exists
if ( timeoutTimer ) {
clearTimeout( timeoutTimer );
}
// Dereference transport for early garbage collection
// (no matter how long the jqXHR object will be used)
transport = undefined;
// Cache response headers
responseHeadersString = headers || "";
// Set readyState
jqXHR.readyState = status > 0 ? 4 : 0;
// Get response data
if ( responses ) {
response = ajaxHandleResponses( s, jqXHR, responses );
}
// If successful, handle type chaining
if ( status >= 200 && status < 300 || status === 304 ) {
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
if ( s.ifModified ) {
modified = jqXHR.getResponseHeader("Last-Modified");
if ( modified ) {
jQuery.lastModified[ cacheURL ] = modified;
}
modified = jqXHR.getResponseHeader("etag");
if ( modified ) {
jQuery.etag[ cacheURL ] = modified;
}
}
// if no content
if ( status === 204 ) {
isSuccess = true;
statusText = "nocontent";
// if not modified
} else if ( status === 304 ) {
isSuccess = true;
statusText = "notmodified";
// If we have data, let's convert it
} else {
isSuccess = ajaxConvert( s, response );
statusText = isSuccess.state;
success = isSuccess.data;
error = isSuccess.error;
isSuccess = !error;
}
} else {
// We extract error from statusText
// then normalize statusText and status for non-aborts
error = statusText;
if ( status || !statusText ) {
statusText = "error";
if ( status < 0 ) {
status = 0;
}
}
}
// Set data for the fake xhr object
jqXHR.status = status;
jqXHR.statusText = ( nativeStatusText || statusText ) + "";
// Success/Error
if ( isSuccess ) {
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
} else {
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
}
// Status-dependent callbacks
jqXHR.statusCode( statusCode );
statusCode = undefined;
if ( fireGlobals ) {
globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
[ jqXHR, s, isSuccess ? success : error ] );
}
// Complete
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
if ( fireGlobals ) {
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
// Handle the global AJAX counter
if ( !( --jQuery.active ) ) {
jQuery.event.trigger("ajaxStop");
}
}
}
return jqXHR;
},
getScript: function( url, callback ) {
return jQuery.get( url, undefined, callback, "script" );
},
getJSON: function( url, data, callback ) {
return jQuery.get( url, data, callback, "json" );
}
});
/* Handles responses to an ajax request:
* - sets all responseXXX fields accordingly
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/
function ajaxHandleResponses( s, jqXHR, responses ) {
var firstDataType, ct, finalDataType, type,
contents = s.contents,
dataTypes = s.dataTypes,
responseFields = s.responseFields;
// Fill responseXXX fields
for ( type in responseFields ) {
if ( type in responses ) {
jqXHR[ responseFields[type] ] = responses[ type ];
}
}
// Remove auto dataType and get content-type in the process
while( dataTypes[ 0 ] === "*" ) {
dataTypes.shift();
if ( ct === undefined ) {
ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
}
}
// Check if we're dealing with a known content-type
if ( ct ) {
for ( type in contents ) {
if ( contents[ type ] && contents[ type ].test( ct ) ) {
dataTypes.unshift( type );
break;
}
}
}
// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
finalDataType = dataTypes[ 0 ];
} else {
// Try convertible dataTypes
for ( type in responses ) {
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
finalDataType = type;
break;
}
if ( !firstDataType ) {
firstDataType = type;
}
}
// Or just use first one
finalDataType = finalDataType || firstDataType;
}
// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if ( finalDataType ) {
if ( finalDataType !== dataTypes[ 0 ] ) {
dataTypes.unshift( finalDataType );
}
return responses[ finalDataType ];
}
}
// Chain conversions given the request and the original response
function ajaxConvert( s, response ) {
var conv2, current, conv, tmp,
converters = {},
i = 0,
// Work with a copy of dataTypes in case we need to modify it for conversion
dataTypes = s.dataTypes.slice(),
prev = dataTypes[ 0 ];
// Apply the dataFilter if provided
if ( s.dataFilter ) {
response = s.dataFilter( response, s.dataType );
}
// Create converters map with lowercased keys
if ( dataTypes[ 1 ] ) {
for ( conv in s.converters ) {
converters[ conv.toLowerCase() ] = s.converters[ conv ];
}
}
// Convert to each sequential dataType, tolerating list modification
for ( ; (current = dataTypes[++i]); ) {
// There's only work to do if current dataType is non-auto
if ( current !== "*" ) {
// Convert response if prev dataType is non-auto and differs from current
if ( prev !== "*" && prev !== current ) {
// Seek a direct converter
conv = converters[ prev + " " + current ] || converters[ "* " + current ];
// If none found, seek a pair
if ( !conv ) {
for ( conv2 in converters ) {
// If conv2 outputs current
tmp = conv2.split(" ");
if ( tmp[ 1 ] === current ) {
// If prev can be converted to accepted input
conv = converters[ prev + " " + tmp[ 0 ] ] ||
converters[ "* " + tmp[ 0 ] ];
if ( conv ) {
// Condense equivalence converters
if ( conv === true ) {
conv = converters[ conv2 ];
// Otherwise, insert the intermediate dataType
} else if ( converters[ conv2 ] !== true ) {
current = tmp[ 0 ];
dataTypes.splice( i--, 0, current );
}
break;
}
}
}
}
// Apply converter (if not an equivalence)
if ( conv !== true ) {
// Unless errors are allowed to bubble, catch and return them
if ( conv && s["throws"] ) {
response = conv( response );
} else {
try {
response = conv( response );
} catch ( e ) {
return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
}
}
}
}
// Update prev for next iteration
prev = current;
}
}
return { state: "success", data: response };
}
// Install script dataType
jQuery.ajaxSetup({
accepts: {
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
},
contents: {
script: /(?:java|ecma)script/
},
converters: {
"text script": function( text ) {
jQuery.globalEval( text );
return text;
}
}
});
// Handle cache's special case and global
jQuery.ajaxPrefilter( "script", function( s ) {
if ( s.cache === undefined ) {
s.cache = false;
}
if ( s.crossDomain ) {
s.type = "GET";
s.global = false;
}
});
// Bind script tag hack transport
jQuery.ajaxTransport( "script", function(s) {
// This transport only deals with cross domain requests
if ( s.crossDomain ) {
var script,
head = document.head || jQuery("head")[0] || document.documentElement;
return {
send: function( _, callback ) {
script = document.createElement("script");
script.async = true;
if ( s.scriptCharset ) {
script.charset = s.scriptCharset;
}
script.src = s.url;
// Attach handlers for all browsers
script.onload = script.onreadystatechange = function( _, isAbort ) {
if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
// Handle memory leak in IE
script.onload = script.onreadystatechange = null;
// Remove the script
if ( script.parentNode ) {
script.parentNode.removeChild( script );
}
// Dereference the script
script = null;
// Callback if not abort
if ( !isAbort ) {
callback( 200, "success" );
}
}
};
// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
// Use native DOM manipulation to avoid our domManip AJAX trickery
head.insertBefore( script, head.firstChild );
},
abort: function() {
if ( script ) {
script.onload( undefined, true );
}
}
};
}
});
var oldCallbacks = [],
rjsonp = /(=)\?(?=&|$)|\?\?/;
// Default jsonp settings
jQuery.ajaxSetup({
jsonp: "callback",
jsonpCallback: function() {
var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_nonce++ ) );
this[ callback ] = true;
return callback;
}
});
// Detect, normalize options and install callbacks for jsonp requests
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
var callbackName, overwritten, responseContainer,
jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
"url" :
typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
);
// Handle iff the expected data type is "jsonp" or we have a parameter to set
if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
// Get callback name, remembering preexisting value associated with it
callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
s.jsonpCallback() :
s.jsonpCallback;
// Insert callback into url or form data
if ( jsonProp ) {
s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
} else if ( s.jsonp !== false ) {
s.url += ( ajax_rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
}
// Use data converter to retrieve json after script execution
s.converters["script json"] = function() {
if ( !responseContainer ) {
jQuery.error( callbackName + " was not called" );
}
return responseContainer[ 0 ];
};
// force json dataType
s.dataTypes[ 0 ] = "json";
// Install callback
overwritten = window[ callbackName ];
window[ callbackName ] = function() {
responseContainer = arguments;
};
// Clean-up function (fires after converters)
jqXHR.always(function() {
// Restore preexisting value
window[ callbackName ] = overwritten;
// Save back as free
if ( s[ callbackName ] ) {
// make sure that re-using the options doesn't screw things around
s.jsonpCallback = originalSettings.jsonpCallback;
// save the callback name for future use
oldCallbacks.push( callbackName );
}
// Call if it was a function and we have a response
if ( responseContainer && jQuery.isFunction( overwritten ) ) {
overwritten( responseContainer[ 0 ] );
}
responseContainer = overwritten = undefined;
});
// Delegate to script
return "script";
}
});
var xhrCallbacks, xhrSupported,
xhrId = 0,
// #5280: Internet Explorer will keep connections alive if we don't abort on unload
xhrOnUnloadAbort = window.ActiveXObject && function() {
// Abort all pending requests
var key;
for ( key in xhrCallbacks ) {
xhrCallbacks[ key ]( undefined, true );
}
};
// Functions to create xhrs
function createStandardXHR() {
try {
return new window.XMLHttpRequest();
} catch( e ) {}
}
function createActiveXHR() {
try {
return new window.ActiveXObject("Microsoft.XMLHTTP");
} catch( e ) {}
}
// Create the request object
// (This is still attached to ajaxSettings for backward compatibility)
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
/* Microsoft failed to properly
* implement the XMLHttpRequest in IE7 (can't request local files),
* so we use the ActiveXObject when it is available
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
* we need a fallback.
*/
function() {
return !this.isLocal && createStandardXHR() || createActiveXHR();
} :
// For all other browsers, use the standard XMLHttpRequest object
createStandardXHR;
// Determine support properties
xhrSupported = jQuery.ajaxSettings.xhr();
jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
xhrSupported = jQuery.support.ajax = !!xhrSupported;
// Create transport if the browser can provide an xhr
if ( xhrSupported ) {
jQuery.ajaxTransport(function( s ) {
// Cross domain only allowed if supported through XMLHttpRequest
if ( !s.crossDomain || jQuery.support.cors ) {
var callback;
return {
send: function( headers, complete ) {
// Get a new xhr
var handle, i,
xhr = s.xhr();
// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if ( s.username ) {
xhr.open( s.type, s.url, s.async, s.username, s.password );
} else {
xhr.open( s.type, s.url, s.async );
}
// Apply custom fields if provided
if ( s.xhrFields ) {
for ( i in s.xhrFields ) {
xhr[ i ] = s.xhrFields[ i ];
}
}
// Override mime type if needed
if ( s.mimeType && xhr.overrideMimeType ) {
xhr.overrideMimeType( s.mimeType );
}
// X-Requested-With header
// For cross-domain requests, seeing as conditions for a preflight are
// akin to a jigsaw puzzle, we simply never set it to be sure.
// (it can always be set on a per-request basis or even using ajaxSetup)
// For same-domain requests, won't change header if already provided.
if ( !s.crossDomain && !headers["X-Requested-With"] ) {
headers["X-Requested-With"] = "XMLHttpRequest";
}
// Need an extra try/catch for cross domain requests in Firefox 3
try {
for ( i in headers ) {
xhr.setRequestHeader( i, headers[ i ] );
}
} catch( err ) {}
// Do send the request
// This may raise an exception which is actually
// handled in jQuery.ajax (so no try/catch here)
xhr.send( ( s.hasContent && s.data ) || null );
// Listener
callback = function( _, isAbort ) {
var status, responseHeaders, statusText, responses;
// Firefox throws exceptions when accessing properties
// of an xhr when a network error occurred
// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
try {
// Was never called and is aborted or complete
if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
// Only called once
callback = undefined;
// Do not keep as active anymore
if ( handle ) {
xhr.onreadystatechange = jQuery.noop;
if ( xhrOnUnloadAbort ) {
delete xhrCallbacks[ handle ];
}
}
// If it's an abort
if ( isAbort ) {
// Abort it manually if needed
if ( xhr.readyState !== 4 ) {
xhr.abort();
}
} else {
responses = {};
status = xhr.status;
responseHeaders = xhr.getAllResponseHeaders();
// When requesting binary data, IE6-9 will throw an exception
// on any attempt to access responseText (#11426)
if ( typeof xhr.responseText === "string" ) {
responses.text = xhr.responseText;
}
// Firefox throws an exception when accessing
// statusText for faulty cross-domain requests
try {
statusText = xhr.statusText;
} catch( e ) {
// We normalize with Webkit giving an empty statusText
statusText = "";
}
// Filter status for non standard behaviors
// If the request is local and we have data: assume a success
// (success with no data won't get notified, that's the best we
// can do given current implementations)
if ( !status && s.isLocal && !s.crossDomain ) {
status = responses.text ? 200 : 404;
// IE - #1450: sometimes returns 1223 when it should be 204
} else if ( status === 1223 ) {
status = 204;
}
}
}
} catch( firefoxAccessException ) {
if ( !isAbort ) {
complete( -1, firefoxAccessException );
}
}
// Call complete if needed
if ( responses ) {
complete( status, statusText, responses, responseHeaders );
}
};
if ( !s.async ) {
// if we're in sync mode we fire the callback
callback();
} else if ( xhr.readyState === 4 ) {
// (IE6 & IE7) if it's in cache and has been
// retrieved directly we need to fire the callback
setTimeout( callback );
} else {
handle = ++xhrId;
if ( xhrOnUnloadAbort ) {
// Create the active xhrs callbacks list if needed
// and attach the unload handler
if ( !xhrCallbacks ) {
xhrCallbacks = {};
jQuery( window ).unload( xhrOnUnloadAbort );
}
// Add to list of active xhrs callbacks
xhrCallbacks[ handle ] = callback;
}
xhr.onreadystatechange = callback;
}
},
abort: function() {
if ( callback ) {
callback( undefined, true );
}
}
};
}
});
}
var fxNow, timerId,
rfxtypes = /^(?:toggle|show|hide)$/,
rfxnum = new RegExp( "^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
rrun = /queueHooks$/,
animationPrefilters = [ defaultPrefilter ],
tweeners = {
"*": [function( prop, value ) {
var end, unit,
tween = this.createTween( prop, value ),
parts = rfxnum.exec( value ),
target = tween.cur(),
start = +target || 0,
scale = 1,
maxIterations = 20;
if ( parts ) {
end = +parts[2];
unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
// We need to compute starting value
if ( unit !== "px" && start ) {
// Iteratively approximate from a nonzero starting point
// Prefer the current property, because this process will be trivial if it uses the same units
// Fallback to end or a simple constant
start = jQuery.css( tween.elem, prop, true ) || end || 1;
do {
// If previous iteration zeroed out, double until we get *something*
// Use a string for doubling factor so we don't accidentally see scale as unchanged below
scale = scale || ".5";
// Adjust and apply
start = start / scale;
jQuery.style( tween.elem, prop, start + unit );
// Update scale, tolerating zero or NaN from tween.cur()
// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
}
tween.unit = unit;
tween.start = start;
// If a +=/-= token was provided, we're doing a relative animation
tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
}
return tween;
}]
};
// Animations created synchronously will run synchronously
function createFxNow() {
setTimeout(function() {
fxNow = undefined;
});
return ( fxNow = jQuery.now() );
}
function createTweens( animation, props ) {
jQuery.each( props, function( prop, value ) {
var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
index = 0,
length = collection.length;
for ( ; index < length; index++ ) {
if ( collection[ index ].call( animation, prop, value ) ) {
// we're done with this property
return;
}
}
});
}
function Animation( elem, properties, options ) {
var result,
stopped,
index = 0,
length = animationPrefilters.length,
deferred = jQuery.Deferred().always( function() {
// don't match elem in the :animated selector
delete tick.elem;
}),
tick = function() {
if ( stopped ) {
return false;
}
var currentTime = fxNow || createFxNow(),
remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
temp = remaining / animation.duration || 0,
percent = 1 - temp,
index = 0,
length = animation.tweens.length;
for ( ; index < length ; index++ ) {
animation.tweens[ index ].run( percent );
}
deferred.notifyWith( elem, [ animation, percent, remaining ]);
if ( percent < 1 && length ) {
return remaining;
} else {
deferred.resolveWith( elem, [ animation ] );
return false;
}
},
animation = deferred.promise({
elem: elem,
props: jQuery.extend( {}, properties ),
opts: jQuery.extend( true, { specialEasing: {} }, options ),
originalProperties: properties,
originalOptions: options,
startTime: fxNow || createFxNow(),
duration: options.duration,
tweens: [],
createTween: function( prop, end ) {
var tween = jQuery.Tween( elem, animation.opts, prop, end,
animation.opts.specialEasing[ prop ] || animation.opts.easing );
animation.tweens.push( tween );
return tween;
},
stop: function( gotoEnd ) {
var index = 0,
// if we are going to the end, we want to run all the tweens
// otherwise we skip this part
length = gotoEnd ? animation.tweens.length : 0;
if ( stopped ) {
return this;
}
stopped = true;
for ( ; index < length ; index++ ) {
animation.tweens[ index ].run( 1 );
}
// resolve when we played the last frame
// otherwise, reject
if ( gotoEnd ) {
deferred.resolveWith( elem, [ animation, gotoEnd ] );
} else {
deferred.rejectWith( elem, [ animation, gotoEnd ] );
}
return this;
}
}),
props = animation.props;
propFilter( props, animation.opts.specialEasing );
for ( ; index < length ; index++ ) {
result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
if ( result ) {
return result;
}
}
createTweens( animation, props );
if ( jQuery.isFunction( animation.opts.start ) ) {
animation.opts.start.call( elem, animation );
}
jQuery.fx.timer(
jQuery.extend( tick, {
elem: elem,
anim: animation,
queue: animation.opts.queue
})
);
// attach callbacks from options
return animation.progress( animation.opts.progress )
.done( animation.opts.done, animation.opts.complete )
.fail( animation.opts.fail )
.always( animation.opts.always );
}
function propFilter( props, specialEasing ) {
var value, name, index, easing, hooks;
// camelCase, specialEasing and expand cssHook pass
for ( index in props ) {
name = jQuery.camelCase( index );
easing = specialEasing[ name ];
value = props[ index ];
if ( jQuery.isArray( value ) ) {
easing = value[ 1 ];
value = props[ index ] = value[ 0 ];
}
if ( index !== name ) {
props[ name ] = value;
delete props[ index ];
}
hooks = jQuery.cssHooks[ name ];
if ( hooks && "expand" in hooks ) {
value = hooks.expand( value );
delete props[ name ];
// not quite $.extend, this wont overwrite keys already present.
// also - reusing 'index' from above because we have the correct "name"
for ( index in value ) {
if ( !( index in props ) ) {
props[ index ] = value[ index ];
specialEasing[ index ] = easing;
}
}
} else {
specialEasing[ name ] = easing;
}
}
}
jQuery.Animation = jQuery.extend( Animation, {
tweener: function( props, callback ) {
if ( jQuery.isFunction( props ) ) {
callback = props;
props = [ "*" ];
} else {
props = props.split(" ");
}
var prop,
index = 0,
length = props.length;
for ( ; index < length ; index++ ) {
prop = props[ index ];
tweeners[ prop ] = tweeners[ prop ] || [];
tweeners[ prop ].unshift( callback );
}
},
prefilter: function( callback, prepend ) {
if ( prepend ) {
animationPrefilters.unshift( callback );
} else {
animationPrefilters.push( callback );
}
}
});
function defaultPrefilter( elem, props, opts ) {
/*jshint validthis:true */
var prop, index, length,
value, dataShow, toggle,
tween, hooks, oldfire,
anim = this,
style = elem.style,
orig = {},
handled = [],
hidden = elem.nodeType && isHidden( elem );
// handle queue: false promises
if ( !opts.queue ) {
hooks = jQuery._queueHooks( elem, "fx" );
if ( hooks.unqueued == null ) {
hooks.unqueued = 0;
oldfire = hooks.empty.fire;
hooks.empty.fire = function() {
if ( !hooks.unqueued ) {
oldfire();
}
};
}
hooks.unqueued++;
anim.always(function() {
// doing this makes sure that the complete handler will be called
// before this completes
anim.always(function() {
hooks.unqueued--;
if ( !jQuery.queue( elem, "fx" ).length ) {
hooks.empty.fire();
}
});
});
}
// height/width overflow pass
if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
// Make sure that nothing sneaks out
// Record all 3 overflow attributes because IE does not
// change the overflow attribute when overflowX and
// overflowY are set to the same value
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
// Set display property to inline-block for height/width
// animations on inline elements that are having width/height animated
if ( jQuery.css( elem, "display" ) === "inline" &&
jQuery.css( elem, "float" ) === "none" ) {
// inline-level elements accept inline-block;
// block-level elements need to be inline with layout
if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
style.display = "inline-block";
} else {
style.zoom = 1;
}
}
}
if ( opts.overflow ) {
style.overflow = "hidden";
if ( !jQuery.support.shrinkWrapBlocks ) {
anim.always(function() {
style.overflow = opts.overflow[ 0 ];
style.overflowX = opts.overflow[ 1 ];
style.overflowY = opts.overflow[ 2 ];
});
}
}
// show/hide pass
for ( index in props ) {
value = props[ index ];
if ( rfxtypes.exec( value ) ) {
delete props[ index ];
toggle = toggle || value === "toggle";
if ( value === ( hidden ? "hide" : "show" ) ) {
continue;
}
handled.push( index );
}
}
length = handled.length;
if ( length ) {
dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
if ( "hidden" in dataShow ) {
hidden = dataShow.hidden;
}
// store state if its toggle - enables .stop().toggle() to "reverse"
if ( toggle ) {
dataShow.hidden = !hidden;
}
if ( hidden ) {
jQuery( elem ).show();
} else {
anim.done(function() {
jQuery( elem ).hide();
});
}
anim.done(function() {
var prop;
jQuery._removeData( elem, "fxshow" );
for ( prop in orig ) {
jQuery.style( elem, prop, orig[ prop ] );
}
});
for ( index = 0 ; index < length ; index++ ) {
prop = handled[ index ];
tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
if ( !( prop in dataShow ) ) {
dataShow[ prop ] = tween.start;
if ( hidden ) {
tween.end = tween.start;
tween.start = prop === "width" || prop === "height" ? 1 : 0;
}
}
}
}
}
function Tween( elem, options, prop, end, easing ) {
return new Tween.prototype.init( elem, options, prop, end, easing );
}
jQuery.Tween = Tween;
Tween.prototype = {
constructor: Tween,
init: function( elem, options, prop, end, easing, unit ) {
this.elem = elem;
this.prop = prop;
this.easing = easing || "swing";
this.options = options;
this.start = this.now = this.cur();
this.end = end;
this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
},
cur: function() {
var hooks = Tween.propHooks[ this.prop ];
return hooks && hooks.get ?
hooks.get( this ) :
Tween.propHooks._default.get( this );
},
run: function( percent ) {
var eased,
hooks = Tween.propHooks[ this.prop ];
if ( this.options.duration ) {
this.pos = eased = jQuery.easing[ this.easing ](
percent, this.options.duration * percent, 0, 1, this.options.duration
);
} else {
this.pos = eased = percent;
}
this.now = ( this.end - this.start ) * eased + this.start;
if ( this.options.step ) {
this.options.step.call( this.elem, this.now, this );
}
if ( hooks && hooks.set ) {
hooks.set( this );
} else {
Tween.propHooks._default.set( this );
}
return this;
}
};
Tween.prototype.init.prototype = Tween.prototype;
Tween.propHooks = {
_default: {
get: function( tween ) {
var result;
if ( tween.elem[ tween.prop ] != null &&
(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
return tween.elem[ tween.prop ];
}
// passing an empty string as a 3rd parameter to .css will automatically
// attempt a parseFloat and fallback to a string if the parse fails
// so, simple values such as "10px" are parsed to Float.
// complex values such as "rotate(1rad)" are returned as is.
result = jQuery.css( tween.elem, tween.prop, "" );
// Empty strings, null, undefined and "auto" are converted to 0.
return !result || result === "auto" ? 0 : result;
},
set: function( tween ) {
// use step hook for back compat - use cssHook if its there - use .style if its
// available and use plain properties where available
if ( jQuery.fx.step[ tween.prop ] ) {
jQuery.fx.step[ tween.prop ]( tween );
} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
} else {
tween.elem[ tween.prop ] = tween.now;
}
}
}
};
// Remove in 2.0 - this supports IE8's panic based approach
// to setting things on disconnected nodes
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
set: function( tween ) {
if ( tween.elem.nodeType && tween.elem.parentNode ) {
tween.elem[ tween.prop ] = tween.now;
}
}
};
jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
var cssFn = jQuery.fn[ name ];
jQuery.fn[ name ] = function( speed, easing, callback ) {
return speed == null || typeof speed === "boolean" ?
cssFn.apply( this, arguments ) :
this.animate( genFx( name, true ), speed, easing, callback );
};
});
jQuery.fn.extend({
fadeTo: function( speed, to, easing, callback ) {
// show any hidden elements after setting opacity to 0
return this.filter( isHidden ).css( "opacity", 0 ).show()
// animate to the value specified
.end().animate({ opacity: to }, speed, easing, callback );
},
animate: function( prop, speed, easing, callback ) {
var empty = jQuery.isEmptyObject( prop ),
optall = jQuery.speed( speed, easing, callback ),
doAnimation = function() {
// Operate on a copy of prop so per-property easing won't be lost
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
doAnimation.finish = function() {
anim.stop( true );
};
// Empty animations, or finishing resolves immediately
if ( empty || jQuery._data( this, "finish" ) ) {
anim.stop( true );
}
};
doAnimation.finish = doAnimation;
return empty || optall.queue === false ?
this.each( doAnimation ) :
this.queue( optall.queue, doAnimation );
},
stop: function( type, clearQueue, gotoEnd ) {
var stopQueue = function( hooks ) {
var stop = hooks.stop;
delete hooks.stop;
stop( gotoEnd );
};
if ( typeof type !== "string" ) {
gotoEnd = clearQueue;
clearQueue = type;
type = undefined;
}
if ( clearQueue && type !== false ) {
this.queue( type || "fx", [] );
}
return this.each(function() {
var dequeue = true,
index = type != null && type + "queueHooks",
timers = jQuery.timers,
data = jQuery._data( this );
if ( index ) {
if ( data[ index ] && data[ index ].stop ) {
stopQueue( data[ index ] );
}
} else {
for ( index in data ) {
if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
stopQueue( data[ index ] );
}
}
}
for ( index = timers.length; index--; ) {
if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
timers[ index ].anim.stop( gotoEnd );
dequeue = false;
timers.splice( index, 1 );
}
}
// start the next in the queue if the last step wasn't forced
// timers currently will call their complete callbacks, which will dequeue
// but only if they were gotoEnd
if ( dequeue || !gotoEnd ) {
jQuery.dequeue( this, type );
}
});
},
finish: function( type ) {
if ( type !== false ) {
type = type || "fx";
}
return this.each(function() {
var index,
data = jQuery._data( this ),
queue = data[ type + "queue" ],
hooks = data[ type + "queueHooks" ],
timers = jQuery.timers,
length = queue ? queue.length : 0;
// enable finishing flag on private data
data.finish = true;
// empty the queue first
jQuery.queue( this, type, [] );
if ( hooks && hooks.cur && hooks.cur.finish ) {
hooks.cur.finish.call( this );
}
// look for any active animations, and finish them
for ( index = timers.length; index--; ) {
if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
timers[ index ].anim.stop( true );
timers.splice( index, 1 );
}
}
// look for any animations in the old queue and finish them
for ( index = 0; index < length; index++ ) {
if ( queue[ index ] && queue[ index ].finish ) {
queue[ index ].finish.call( this );
}
}
// turn off finishing flag
delete data.finish;
});
}
});
// Generate parameters to create a standard animation
function genFx( type, includeWidth ) {
var which,
attrs = { height: type },
i = 0;
// if we include width, step value is 1 to do all cssExpand values,
// if we don't include width, step value is 2 to skip over Left and Right
includeWidth = includeWidth? 1 : 0;
for( ; i < 4 ; i += 2 - includeWidth ) {
which = cssExpand[ i ];
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
}
if ( includeWidth ) {
attrs.opacity = attrs.width = type;
}
return attrs;
}
// Generate shortcuts for custom animations
jQuery.each({
slideDown: genFx("show"),
slideUp: genFx("hide"),
slideToggle: genFx("toggle"),
fadeIn: { opacity: "show" },
fadeOut: { opacity: "hide" },
fadeToggle: { opacity: "toggle" }
}, function( name, props ) {
jQuery.fn[ name ] = function( speed, easing, callback ) {
return this.animate( props, speed, easing, callback );
};
});
jQuery.speed = function( speed, easing, fn ) {
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
complete: fn || !fn && easing ||
jQuery.isFunction( speed ) && speed,
duration: speed,
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
};
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
// normalize opt.queue - true/undefined/null -> "fx"
if ( opt.queue == null || opt.queue === true ) {
opt.queue = "fx";
}
// Queueing
opt.old = opt.complete;
opt.complete = function() {
if ( jQuery.isFunction( opt.old ) ) {
opt.old.call( this );
}
if ( opt.queue ) {
jQuery.dequeue( this, opt.queue );
}
};
return opt;
};
jQuery.easing = {
linear: function( p ) {
return p;
},
swing: function( p ) {
return 0.5 - Math.cos( p*Math.PI ) / 2;
}
};
jQuery.timers = [];
jQuery.fx = Tween.prototype.init;
jQuery.fx.tick = function() {
var timer,
timers = jQuery.timers,
i = 0;
fxNow = jQuery.now();
for ( ; i < timers.length; i++ ) {
timer = timers[ i ];
// Checks the timer has not already been removed
if ( !timer() && timers[ i ] === timer ) {
timers.splice( i--, 1 );
}
}
if ( !timers.length ) {
jQuery.fx.stop();
}
fxNow = undefined;
};
jQuery.fx.timer = function( timer ) {
if ( timer() && jQuery.timers.push( timer ) ) {
jQuery.fx.start();
}
};
jQuery.fx.interval = 13;
jQuery.fx.start = function() {
if ( !timerId ) {
timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
}
};
jQuery.fx.stop = function() {
clearInterval( timerId );
timerId = null;
};
jQuery.fx.speeds = {
slow: 600,
fast: 200,
// Default speed
_default: 400
};
// Back Compat <1.8 extension point
jQuery.fx.step = {};
if ( jQuery.expr && jQuery.expr.filters ) {
jQuery.expr.filters.animated = function( elem ) {
return jQuery.grep(jQuery.timers, function( fn ) {
return elem === fn.elem;
}).length;
};
}
jQuery.fn.offset = function( options ) {
if ( arguments.length ) {
return options === undefined ?
this :
this.each(function( i ) {
jQuery.offset.setOffset( this, options, i );
});
}
var docElem, win,
box = { top: 0, left: 0 },
elem = this[ 0 ],
doc = elem && elem.ownerDocument;
if ( !doc ) {
return;
}
docElem = doc.documentElement;
// Make sure it's not a disconnected DOM node
if ( !jQuery.contains( docElem, elem ) ) {
return box;
}
// If we don't have gBCR, just use 0,0 rather than error
// BlackBerry 5, iOS 3 (original iPhone)
if ( typeof elem.getBoundingClientRect !== core_strundefined ) {
box = elem.getBoundingClientRect();
}
win = getWindow( doc );
return {
top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ),
left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
};
};
jQuery.offset = {
setOffset: function( elem, options, i ) {
var position = jQuery.css( elem, "position" );
// set position first, in-case top/left are set even on static elem
if ( position === "static" ) {
elem.style.position = "relative";
}
var curElem = jQuery( elem ),
curOffset = curElem.offset(),
curCSSTop = jQuery.css( elem, "top" ),
curCSSLeft = jQuery.css( elem, "left" ),
calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
props = {}, curPosition = {}, curTop, curLeft;
// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
if ( calculatePosition ) {
curPosition = curElem.position();
curTop = curPosition.top;
curLeft = curPosition.left;
} else {
curTop = parseFloat( curCSSTop ) || 0;
curLeft = parseFloat( curCSSLeft ) || 0;
}
if ( jQuery.isFunction( options ) ) {
options = options.call( elem, i, curOffset );
}
if ( options.top != null ) {
props.top = ( options.top - curOffset.top ) + curTop;
}
if ( options.left != null ) {
props.left = ( options.left - curOffset.left ) + curLeft;
}
if ( "using" in options ) {
options.using.call( elem, props );
} else {
curElem.css( props );
}
}
};
jQuery.fn.extend({
position: function() {
if ( !this[ 0 ] ) {
return;
}
var offsetParent, offset,
parentOffset = { top: 0, left: 0 },
elem = this[ 0 ];
// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
if ( jQuery.css( elem, "position" ) === "fixed" ) {
// we assume that getBoundingClientRect is available when computed position is fixed
offset = elem.getBoundingClientRect();
} else {
// Get *real* offsetParent
offsetParent = this.offsetParent();
// Get correct offsets
offset = this.offset();
if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
parentOffset = offsetParent.offset();
}
// Add offsetParent borders
parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
}
// Subtract parent offsets and element margins
// note: when an element has margin: auto the offsetLeft and marginLeft
// are the same in Safari causing offset.left to incorrectly be 0
return {
top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true)
};
},
offsetParent: function() {
return this.map(function() {
var offsetParent = this.offsetParent || document.documentElement;
while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position") === "static" ) ) {
offsetParent = offsetParent.offsetParent;
}
return offsetParent || document.documentElement;
});
}
});
// Create scrollLeft and scrollTop methods
jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
var top = /Y/.test( prop );
jQuery.fn[ method ] = function( val ) {
return jQuery.access( this, function( elem, method, val ) {
var win = getWindow( elem );
if ( val === undefined ) {
return win ? (prop in win) ? win[ prop ] :
win.document.documentElement[ method ] :
elem[ method ];
}
if ( win ) {
win.scrollTo(
!top ? val : jQuery( win ).scrollLeft(),
top ? val : jQuery( win ).scrollTop()
);
} else {
elem[ method ] = val;
}
}, method, val, arguments.length, null );
};
});
function getWindow( elem ) {
return jQuery.isWindow( elem ) ?
elem :
elem.nodeType === 9 ?
elem.defaultView || elem.parentWindow :
false;
}
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
// margin is only for outerHeight, outerWidth
jQuery.fn[ funcName ] = function( margin, value ) {
var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
return jQuery.access( this, function( elem, type, value ) {
var doc;
if ( jQuery.isWindow( elem ) ) {
// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
// isn't a whole lot we can do. See pull request at this URL for discussion:
// https://github.com/jquery/jquery/pull/764
return elem.document.documentElement[ "client" + name ];
}
// Get document width or height
if ( elem.nodeType === 9 ) {
doc = elem.documentElement;
// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
return Math.max(
elem.body[ "scroll" + name ], doc[ "scroll" + name ],
elem.body[ "offset" + name ], doc[ "offset" + name ],
doc[ "client" + name ]
);
}
return value === undefined ?
// Get width or height on the element, requesting but not forcing parseFloat
jQuery.css( elem, type, extra ) :
// Set width or height on the element
jQuery.style( elem, type, value, extra );
}, type, chainable ? margin : undefined, chainable, null );
};
});
});
// Limit scope pollution from any deprecated API
// (function() {
// })();
// Expose jQuery to the global object
window.jQuery = window.$ = jQuery;
// Expose jQuery as an AMD module, but only for AMD loaders that
// understand the issues with loading multiple versions of jQuery
// in a page that all might call define(). The loader will indicate
// they have special allowances for multiple jQuery versions by
// specifying define.amd.jQuery = true. Register as a named module,
// since jQuery can be concatenated with other files that may use define,
// but not use a proper concatenation script that understands anonymous
// AMD modules. A named AMD is safest and most robust way to register.
// Lowercase jquery is used because AMD module names are derived from
// file names, and jQuery is normally delivered in a lowercase file name.
// Do this after creating the global so that if an AMD module wants to call
// noConflict to hide this version of jQuery, it will work.
if ( typeof define === "function" && define.amd ) {
define( function () { return jQuery; } );
}
})( window );
|
const assert = require('assert')
const Automerge = process.env.TEST_DIST === '1' ? require('../dist/automerge') : require('../src/automerge')
const { BloomFilter } = require('../backend/sync')
const { decodeChangeMeta } = require('../backend/columnar')
const { decodeSyncMessage, encodeSyncMessage, decodeSyncState, encodeSyncState, initSyncState } = Automerge.Backend
function getHeads(doc) {
return Automerge.Backend.getHeads(Automerge.Frontend.getBackendState(doc))
}
function getMissingDeps(doc) {
return Automerge.Backend.getMissingDeps(Automerge.Frontend.getBackendState(doc))
}
function sync(a, b, aSyncState = initSyncState(), bSyncState = initSyncState()) {
const MAX_ITER = 10
let aToBmsg = null, bToAmsg = null, i = 0
do {
[aSyncState, aToBmsg] = Automerge.generateSyncMessage(a, aSyncState)
;[bSyncState, bToAmsg] = Automerge.generateSyncMessage(b, bSyncState)
if (aToBmsg) {
[b, bSyncState] = Automerge.receiveSyncMessage(b, bSyncState, aToBmsg)
}
if (bToAmsg) {
[a, aSyncState] = Automerge.receiveSyncMessage(a, aSyncState, bToAmsg)
}
if (i++ > MAX_ITER) {
throw new Error(`Did not synchronize within ${MAX_ITER} iterations. Do you have a bug causing an infinite loop?`)
}
} while (aToBmsg || bToAmsg)
return [a, b, aSyncState, bSyncState]
}
describe('Data sync protocol', () => {
describe('with docs already in sync', () => {
describe('an empty local doc', () => {
it('should send a sync message implying no local data', () => {
let n1 = Automerge.init()
let s1 = initSyncState()
let m1
;[s1, m1] = Automerge.generateSyncMessage(n1, s1)
const message = decodeSyncMessage(m1)
assert.deepStrictEqual(message.heads, [])
assert.deepStrictEqual(message.need, [])
assert.deepStrictEqual(message.have.length, 1)
assert.deepStrictEqual(message.have[0].lastSync, [])
assert.deepStrictEqual(message.have[0].bloom.byteLength, 0)
assert.deepStrictEqual(message.changes, [])
})
it('should not reply if we have no data as well', () => {
let n1 = Automerge.init(), n2 = Automerge.init()
let s1 = initSyncState(), s2 = initSyncState()
let m1 = null, m2 = null
;[s1, m1] = Automerge.generateSyncMessage(n1, s1)
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, m1)
;[s2, m2] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(m2, null)
})
})
describe('documents with data', () => {
it('repos with equal heads do not need a reply message', () => {
let n1 = Automerge.init(), n2 = Automerge.init()
let s1 = initSyncState(), s2 = initSyncState()
let m1 = null, m2 = null
// make two nodes with the same changes
n1 = Automerge.change(n1, {time: 0}, doc => doc.n = [])
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.n.push(i))
;[n2] = Automerge.applyChanges(n2, Automerge.getAllChanges(n1))
assert.deepStrictEqual(n1, n2)
// generate a naive sync message
;[s1, m1] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(s1.lastSentHeads, getHeads(n1))
// heads are equal so this message should be null
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, m1)
;[s2, m2] = Automerge.generateSyncMessage(n2, s2)
assert.strictEqual(m2, null)
})
it('n1 should offer all changes to n2 when starting from nothing', () => {
let n1 = Automerge.init(), n2 = Automerge.init()
// make changes for n1 that n2 should request
n1 = Automerge.change(n1, {time: 0}, doc => doc.n = [])
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.n.push(i))
assert.notDeepStrictEqual(n1, n2)
const [after1, after2] = sync(n1, n2)
assert.deepStrictEqual(after1, after2)
})
it('should sync peers where one has commits the other does not', () => {
let n1 = Automerge.init(), n2 = Automerge.init()
// make changes for n1 that n2 should request
n1 = Automerge.change(n1, {time: 0}, doc => doc.n = [])
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.n.push(i))
assert.notDeepStrictEqual(n1, n2)
;[n1, n2] = sync(n1, n2)
assert.deepStrictEqual(n1, n2)
})
it('should work with prior sync state', () => {
// create & synchronize two nodes
let n1 = Automerge.init(), n2 = Automerge.init()
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
// modify the first node further
for (let i = 5; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
assert.notDeepStrictEqual(n1, n2)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(n1, n2)
})
it('should not generate messages once synced', () => {
// create & synchronize two nodes
let n1 = Automerge.init('abc123'), n2 = Automerge.init('def456')
let s1 = initSyncState(), s2 = initSyncState()
let message, patch
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
for (let i = 0; i < 5; i++) n2 = Automerge.change(n2, {time: 0}, doc => doc.y = i)
// n1 reports what it has
;[s1, message] = Automerge.generateSyncMessage(n1, s1, n1)
// n2 receives that message and sends changes along with what it has
;[n2, s2, patch] = Automerge.receiveSyncMessage(n2, s2, message)
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 5)
assert.deepStrictEqual(patch, null) // no changes arrived
// n1 receives the changes and replies with the changes it now knows n2 needs
;[n1, s1, patch] = Automerge.receiveSyncMessage(n1, s1, message)
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 5)
assert.deepStrictEqual(patch.diffs.props, {y: {'5@def456': {type: 'value', value: 4, datatype: 'int'}}}) // changes arrived
// n2 applies the changes and sends confirmation ending the exchange
;[n2, s2, patch] = Automerge.receiveSyncMessage(n2, s2, message)
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(patch.diffs.props, {x: {'5@abc123': {type: 'value', value: 4, datatype: 'int'}}}) // changes arrived
// n1 receives the message and has nothing more to say
;[n1, s1, patch] = Automerge.receiveSyncMessage(n1, s1, message)
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(message, null)
assert.deepStrictEqual(patch, null) // no changes arrived
// n2 also has nothing left to say
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(message, null)
})
it('should allow simultaneous messages during synchronization', () => {
// create & synchronize two nodes
let n1 = Automerge.init('abc123'), n2 = Automerge.init('def456')
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
for (let i = 0; i < 5; i++) n2 = Automerge.change(n2, {time: 0}, doc => doc.y = i)
const head1 = getHeads(n1)[0], head2 = getHeads(n2)[0]
// both sides report what they have but have no shared peer state
let msg1to2, msg2to1
;[s1, msg1to2] = Automerge.generateSyncMessage(n1, s1)
;[s2, msg2to1] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 0)
assert.deepStrictEqual(decodeSyncMessage(msg1to2).have[0].lastSync.length, 0)
assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 0)
assert.deepStrictEqual(decodeSyncMessage(msg2to1).have[0].lastSync.length, 0)
// n1 and n2 receives that message and update sync state but make no patch
let patch1, patch2
;[n1, s1, patch1] = Automerge.receiveSyncMessage(n1, s1, msg2to1)
assert.deepStrictEqual(patch1, null) // no changes arrived, so no patch
;[n2, s2, patch2] = Automerge.receiveSyncMessage(n2, s2, msg1to2)
assert.deepStrictEqual(patch2, null) // no changes arrived, so no patch
// now both reply with their local changes the other lacks
// (standard warning that 1% of the time this will result in a "need" message)
;[s1, msg1to2] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 5)
;[s2, msg2to1] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 5)
// both should now apply the changes and update the frontend
;[n1, s1, patch1] = Automerge.receiveSyncMessage(n1, s1, msg2to1)
assert.deepStrictEqual(getMissingDeps(n1), [])
assert.notDeepStrictEqual(patch1, null)
assert.deepStrictEqual(n1, {x: 4, y: 4})
;[n2, s2, patch2] = Automerge.receiveSyncMessage(n2, s2, msg1to2)
assert.deepStrictEqual(getMissingDeps(n2), [])
assert.notDeepStrictEqual(patch2, null)
assert.deepStrictEqual(n2, {x: 4, y: 4})
// The response acknowledges the changes received, and sends no further changes
;[s1, msg1to2] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(msg1to2).changes.length, 0)
;[s2, msg2to1] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(decodeSyncMessage(msg2to1).changes.length, 0)
// After receiving acknowledgements, their shared heads should be equal
;[n1, s1, patch1] = Automerge.receiveSyncMessage(n1, s1, msg2to1)
;[n2, s2, patch2] = Automerge.receiveSyncMessage(n2, s2, msg1to2)
assert.deepStrictEqual(s1.sharedHeads, [head1, head2].sort())
assert.deepStrictEqual(s2.sharedHeads, [head1, head2].sort())
assert.deepStrictEqual(patch1, null)
assert.deepStrictEqual(patch2, null)
// We're in sync, no more messages required
;[s1, msg1to2] = Automerge.generateSyncMessage(n1, s1)
;[s2, msg2to1] = Automerge.generateSyncMessage(n2, s2)
assert.deepStrictEqual(msg1to2, null)
assert.deepStrictEqual(msg2to1, null)
// If we make one more change, and start another sync, its lastSync should be updated
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 5)
;[s1, msg1to2] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(msg1to2).have[0].lastSync, [head1, head2].sort())
})
it('should assume sent changes were recieved until we hear otherwise', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), message = null
n1 = Automerge.change(n1, {time: 0}, doc => doc.items = [])
;[n1, n2, s1, /* s2 */] = sync(n1, n2)
n1 = Automerge.change(n1, {time: 0}, doc => doc.items.push('x'))
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
n1 = Automerge.change(n1, {time: 0}, doc => doc.items.push('y'))
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
n1 = Automerge.change(n1, {time: 0}, doc => doc.items.push('z'))
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(message).changes.length, 1)
})
it('should work regardless of who initiates the exchange', () => {
// create & synchronize two nodes
let n1 = Automerge.init(), n2 = Automerge.init()
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
// modify the first node further
for (let i = 5; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
assert.notDeepStrictEqual(n1, n2)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(n1, n2)
})
})
})
describe('with diverged documents', () => {
it('should work without prior sync state', () => {
// Scenario: ,-- c10 <-- c11 <-- c12 <-- c13 <-- c14
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
// `-- c15 <-- c16 <-- c17
// lastSync is undefined.
// create two peers both with divergent commits
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2] = sync(n1, n2)
for (let i = 10; i < 15; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
for (let i = 15; i < 18; i++) n2 = Automerge.change(n2, {time: 0}, doc => doc.x = i)
assert.notDeepStrictEqual(n1, n2)
;[n1, n2] = sync(n1, n2)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
})
it('should work with prior sync state', () => {
// Scenario: ,-- c10 <-- c11 <-- c12 <-- c13 <-- c14
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
// `-- c15 <-- c16 <-- c17
// lastSync is c9.
// create two peers both with divergent commits
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
for (let i = 10; i < 15; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
for (let i = 15; i < 18; i++) n2 = Automerge.change(n2, {time: 0}, doc => doc.x = i)
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
assert.notDeepStrictEqual(n1, n2)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
})
it('should ensure non-empty state after sync', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(s1.sharedHeads, getHeads(n1))
assert.deepStrictEqual(s2.sharedHeads, getHeads(n1))
})
it('should re-sync after one node crashed with data loss', () => {
// Scenario: (r) (n2) (n1)
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8
// n2 has changes {c0, c1, c2}, n1's lastSync is c5, and n2's lastSync is c2.
// we want to successfully sync (n1) with (r), even though (n1) believes it's talking to (n2)
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
// n1 makes three changes, which we sync to n2
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
// save a copy of n2 as "r" to simulate recovering from crash
let r, rSyncState
;[r, rSyncState] = [Automerge.clone(n2), s2]
// sync another few commits
for (let i = 3; i < 6; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
// everyone should be on the same page here
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
// now make a few more changes, then attempt to sync the fully-up-to-date n1 with the confused r
for (let i = 6; i < 9; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
s1 = decodeSyncState(encodeSyncState(s1))
rSyncState = decodeSyncState(encodeSyncState(rSyncState))
assert.notDeepStrictEqual(getHeads(n1), getHeads(r))
assert.notDeepStrictEqual(n1, r)
assert.deepStrictEqual(n1, {x: 8})
assert.deepStrictEqual(r, {x: 2})
;[n1, r, s1, rSyncState] = sync(n1, r, s1, rSyncState)
assert.deepStrictEqual(getHeads(n1), getHeads(r))
assert.deepStrictEqual(n1, r)
})
it('should resync after one node experiences data loss without disconnecting', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
// n1 makes three changes, which we sync to n2
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
let n2AfterDataLoss = Automerge.init('89abcdef')
// "n2" now has no data, but n1 still thinks it does. Note we don't do
// decodeSyncState(encodeSyncState(s1)) in order to simulate data loss without disconnecting
;[n1, n2, s1, s2] = sync(n1, n2AfterDataLoss, s1, initSyncState())
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
})
it('should handle changes concurrent to the last sync heads', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef'), n3 = Automerge.init('fedcba98')
let s12 = initSyncState(), s21 = initSyncState(), s23 = initSyncState(), s32 = initSyncState()
// Change 1 is known to all three nodes
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 1)
;[n1, n2, s12, s21] = sync(n1, n2, s12, s21)
;[n2, n3, s23, s32] = sync(n2, n3, s23, s32)
// Change 2 is known to n1 and n2
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 2)
;[n1, n2, s12, s21] = sync(n1, n2, s12, s21)
// Each of the three nodes makes one change (changes 3, 4, 5)
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 3)
n2 = Automerge.change(n2, {time: 0}, doc => doc.x = 4)
n3 = Automerge.change(n3, {time: 0}, doc => doc.x = 5)
// Apply n3's latest change to n2. If running in Node, turn the Uint8Array into a Buffer, to
// simulate transmission over a network (see https://github.com/automerge/automerge/pull/362)
let change = Automerge.getLastLocalChange(n3)
if (typeof Buffer === 'function') change = Buffer.from(change)
;[n2] = Automerge.applyChanges(n2, [change])
// Now sync n1 and n2. n3's change is concurrent to n1 and n2's last sync heads
;[n1, n2, s12, s21] = sync(n1, n2, s12, s21)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
})
it('should handle histories with lots of branching and merging', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef'), n3 = Automerge.init('fedcba98')
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 0)
;[n2] = Automerge.applyChanges(n2, [Automerge.getLastLocalChange(n1)])
;[n3] = Automerge.applyChanges(n3, [Automerge.getLastLocalChange(n1)])
n3 = Automerge.change(n3, {time: 0}, doc => doc.x = 1)
// - n1c1 <------ n1c2 <------ n1c3 <-- etc. <-- n1c20 <------ n1c21
// / \/ \/ \/
// / /\ /\ /\
// c0 <---- n2c1 <------ n2c2 <------ n2c3 <-- etc. <-- n2c20 <------ n2c21
// \ /
// ---------------------------------------------- n3c1 <-----
for (let i = 1; i < 20; i++) {
n1 = Automerge.change(n1, {time: 0}, doc => doc.n1 = i)
n2 = Automerge.change(n2, {time: 0}, doc => doc.n2 = i)
const change1 = Automerge.getLastLocalChange(n1)
const change2 = Automerge.getLastLocalChange(n2)
;[n1] = Automerge.applyChanges(n1, [change2])
;[n2] = Automerge.applyChanges(n2, [change1])
}
let s1 = initSyncState(), s2 = initSyncState()
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
// Having n3's last change concurrent to the last sync heads forces us into the slower code path
;[n2] = Automerge.applyChanges(n2, [Automerge.getLastLocalChange(n3)])
n1 = Automerge.change(n1, {time: 0}, doc => doc.n1 = 'final')
n2 = Automerge.change(n2, {time: 0}, doc => doc.n2 = 'final')
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
assert.deepStrictEqual(n1, n2)
})
})
describe('with false positives', () => {
// NOTE: the following tests use brute force to search for Bloom filter false positives. The
// tests make change hashes deterministic by fixing the actorId and change timestamp to be
// constants. The loop that searches for false positives is then initialised such that it finds
// a false positive on its first iteration. However, if anything changes about the encoding of
// changes (causing their hashes to change) or if the Bloom filter configuration is changed,
// then the false positive will no longer be the first loop iteration. The tests should still
// pass because the loop will run until a false positive is found, but they will be slower.
it('should handle a false-positive head', () => {
// Scenario: ,-- n1
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
// `-- n2
// where n2 is a false positive in the Bloom filter containing {n1}.
// lastSync is c9.
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
for (let i = 1; ; i++) { // search for false positive; see comment above
const n1up = Automerge.change(Automerge.clone(n1, {actorId: '01234567'}), {time: 0}, doc => doc.x = `${i} @ n1`)
const n2up = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
if (new BloomFilter(getHeads(n1up)).containsHash(getHeads(n2up)[0])) {
n1 = n1up; n2 = n2up; break
}
}
const allHeads = [...getHeads(n1), ...getHeads(n2)].sort()
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), allHeads)
assert.deepStrictEqual(getHeads(n2), allHeads)
})
describe('with a false-positive dependency', () => {
let n1, n2, s1, s2, n1hash2, n2hash2
beforeEach(() => {
// Scenario: ,-- n1c1 <-- n1c2
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
// `-- n2c1 <-- n2c2
// where n2c1 is a false positive in the Bloom filter containing {n1c1, n1c2}.
// lastSync is c9.
n1 = Automerge.init('01234567')
n2 = Automerge.init('89abcdef')
s1 = initSyncState()
s2 = initSyncState()
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
let n1hash1, n2hash1
for (let i = 29; ; i++) { // search for false positive; see comment above
const n1us1 = Automerge.change(Automerge.clone(n1, {actorId: '01234567'}), {time: 0}, doc => doc.x = `${i} @ n1`)
const n2us1 = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
n1hash1 = getHeads(n1us1)[0]; n2hash1 = getHeads(n2us1)[0]
const n1us2 = Automerge.change(n1us1, {time: 0}, doc => doc.x = 'final @ n1')
const n2us2 = Automerge.change(n2us1, {time: 0}, doc => doc.x = 'final @ n2')
n1hash2 = getHeads(n1us2)[0]; n2hash2 = getHeads(n2us2)[0]
if (new BloomFilter([n1hash1, n1hash2]).containsHash(n2hash1)) {
n1 = n1us2; n2 = n2us2; break
}
}
})
it('should sync two nodes without connection reset', () => {
[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), [n1hash2, n2hash2].sort())
assert.deepStrictEqual(getHeads(n2), [n1hash2, n2hash2].sort())
})
it('should sync two nodes with connection reset', () => {
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), [n1hash2, n2hash2].sort())
assert.deepStrictEqual(getHeads(n2), [n1hash2, n2hash2].sort())
})
it('should sync three nodes', () => {
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
// First n1 and n2 exchange Bloom filters
let m1, m2
;[s1, m1] = Automerge.generateSyncMessage(n1, s1)
;[s2, m2] = Automerge.generateSyncMessage(n2, s2)
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, m2)
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, m1)
// Then n1 and n2 send each other their changes, except for the false positive
;[s1, m1] = Automerge.generateSyncMessage(n1, s1)
;[s2, m2] = Automerge.generateSyncMessage(n2, s2)
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, m2)
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, m1)
assert.strictEqual(decodeSyncMessage(m1).changes.length, 2) // n1c1 and n1c2
assert.strictEqual(decodeSyncMessage(m2).changes.length, 1) // only n2c2; change n2c1 is not sent
// n3 is a node that doesn't have the missing change. Nevertheless n1 is going to ask n3 for it
let n3 = Automerge.init('fedcba98'), s13 = initSyncState(), s31 = initSyncState()
;[n1, n3, s13, s31] = sync(n1, n3, s13, s31)
assert.deepStrictEqual(getHeads(n1), [n1hash2])
assert.deepStrictEqual(getHeads(n3), [n1hash2])
})
})
it('should not require an additional request when a false-positive depends on a true-negative', () => {
// Scenario: ,-- n1c1 <-- n1c2 <-- n1c3
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-+
// `-- n2c1 <-- n2c2 <-- n2c3
// where n2c2 is a false positive in the Bloom filter containing {n1c1, n1c2, n1c3}.
// lastSync is c4.
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
let n1hash3, n2hash3
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
for (let i = 86; ; i++) { // search for false positive; see comment above
const n1us1 = Automerge.change(Automerge.clone(n1, {actorId: '01234567'}), {time: 0}, doc => doc.x = `${i} @ n1`)
const n2us1 = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
const n1hash1 = getHeads(n1us1)[0]
const n1us2 = Automerge.change(n1us1, {time: 0}, doc => doc.x = `${i + 1} @ n1`)
const n2us2 = Automerge.change(n2us1, {time: 0}, doc => doc.x = `${i + 1} @ n2`)
const n1hash2 = getHeads(n1us2)[0], n2hash2 = getHeads(n2us2)[0]
const n1up3 = Automerge.change(n1us2, {time: 0}, doc => doc.x = 'final @ n1')
const n2up3 = Automerge.change(n2us2, {time: 0}, doc => doc.x = 'final @ n2')
n1hash3 = getHeads(n1up3)[0]; n2hash3 = getHeads(n2up3)[0]
if (new BloomFilter([n1hash1, n1hash2, n1hash3]).containsHash(n2hash2)) {
n1 = n1up3; n2 = n2up3; break
}
}
const bothHeads = [n1hash3, n2hash3].sort()
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), bothHeads)
assert.deepStrictEqual(getHeads(n2), bothHeads)
})
it('should handle chains of false-positives', () => {
// Scenario: ,-- c5
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-+
// `-- n2c1 <-- n2c2 <-- n2c3
// where n2c1 and n2c2 are both false positives in the Bloom filter containing {c5}.
// lastSync is c4.
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
for (let i = 0; i < 5; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 5)
for (let i = 2; ; i++) { // search for false positive; see comment above
const n2us1 = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
if (new BloomFilter(getHeads(n1)).containsHash(getHeads(n2us1)[0])) {
n2 = n2us1; break
}
}
for (let i = 141; ; i++) { // search for false positive; see comment above
const n2us2 = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} again`)
if (new BloomFilter(getHeads(n1)).containsHash(getHeads(n2us2)[0])) {
n2 = n2us2; break
}
}
n2 = Automerge.change(n2, {time: 0}, doc => doc.x = 'final @ n2')
const allHeads = [...getHeads(n1), ...getHeads(n2)].sort()
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
;[n1, n2, s1, s2] = sync(n1, n2, s1, s2)
assert.deepStrictEqual(getHeads(n1), allHeads)
assert.deepStrictEqual(getHeads(n2), allHeads)
})
it('should allow the false-positive hash to be explicitly requested', () => {
// Scenario: ,-- n1
// c0 <-- c1 <-- c2 <-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8 <-- c9 <-+
// `-- n2
// where n2 causes a false positive in the Bloom filter containing {n1}.
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
let message
for (let i = 0; i < 10; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
for (let i = 1; ; i++) { // brute-force search for false positive; see comment above
const n1up = Automerge.change(Automerge.clone(n1, {actorId: '01234567'}), {time: 0}, doc => doc.x = `${i} @ n1`)
const n2up = Automerge.change(Automerge.clone(n2, {actorId: '89abcdef'}), {time: 0}, doc => doc.x = `${i} @ n2`)
// check if the bloom filter on n2 will believe n1 already has a particular hash
// this will mean n2 won't offer that data to n2 by receiving a sync message from n1
if (new BloomFilter(getHeads(n1up)).containsHash(getHeads(n2up)[0])) {
n1 = n1up; n2 = n2up; break
}
}
// n1 creates a sync message for n2 with an ill-fated bloom
[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.strictEqual(decodeSyncMessage(message).changes.length, 0)
// n2 receives it and DOESN'T send a change back
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, message)
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.strictEqual(decodeSyncMessage(message).changes.length, 0)
// n1 should now realize it's missing that change and request it explicitly
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, message)
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
assert.deepStrictEqual(decodeSyncMessage(message).need, getHeads(n2))
// n2 should fulfill that request
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, message)
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.strictEqual(decodeSyncMessage(message).changes.length, 1)
// n1 should apply the change and the two should now be in sync
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, message)
assert.deepStrictEqual(getHeads(n1), getHeads(n2))
})
})
describe('protocol features', () => {
it('should allow multiple Bloom filters', () => {
// Scenario: ,-- n1c1 <-- n1c2 <-- n1c3
// c0 <-- c1 <-- c2 <-+--- n2c1 <-- n2c2 <-- n2c3
// `-- n3c1 <-- n3c2 <-- n3c3
// n1 has {c0, c1, c2, n1c1, n1c2, n1c3, n2c1, n2c2};
// n2 has {c0, c1, c2, n1c1, n1c2, n2c1, n2c2, n2c3};
// n3 has {c0, c1, c2, n3c1, n3c2, n3c3}.
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef'), n3 = Automerge.init('76543210')
let s13 = initSyncState(), s12 = initSyncState(), s21 = initSyncState()
let s32 = initSyncState(), s31 = initSyncState(), s23 = initSyncState()
let message1, message2, message3
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
// sync all 3 nodes
;[n1, n2, s12, s21] = sync(n1, n2) // eslint-disable-line no-unused-vars -- kept for consistency
;[n1, n3, s13, s31] = sync(n1, n3)
;[n3, n2, s32, s23] = sync(n3, n2)
for (let i = 0; i < 2; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = `${i} @ n1`)
for (let i = 0; i < 2; i++) n2 = Automerge.change(n2, {time: 0}, doc => doc.x = `${i} @ n2`)
;[n1] = Automerge.applyChanges(n1, Automerge.getAllChanges(n2))
;[n2] = Automerge.applyChanges(n2, Automerge.getAllChanges(n1))
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = `3 @ n1`)
n2 = Automerge.change(n2, {time: 0}, doc => doc.x = `3 @ n2`)
for (let i = 0; i < 3; i++) n3 = Automerge.change(n3, {time: 0}, doc => doc.x = `${i} @ n3`)
const n1c3 = getHeads(n1)[0], n2c3 = getHeads(n2)[0], n3c3 = getHeads(n3)[0]
s13 = decodeSyncState(encodeSyncState(s13))
s31 = decodeSyncState(encodeSyncState(s31))
s23 = decodeSyncState(encodeSyncState(s23))
s32 = decodeSyncState(encodeSyncState(s32))
// Now n3 concurrently syncs with n1 and n2. Doing this naively would result in n3 receiving
// changes {n1c1, n1c2, n2c1, n2c2} twice (those are the changes that both n1 and n2 have, but
// that n3 does not have). We want to prevent this duplication.
;[s13, message1] = Automerge.generateSyncMessage(n1, s13) // message from n1 to n3
assert.strictEqual(decodeSyncMessage(message1).changes.length, 0)
;[n3, s31] = Automerge.receiveSyncMessage(n3, s31, message1)
;[s31, message3] = Automerge.generateSyncMessage(n3, s31) // message from n3 to n1
assert.strictEqual(decodeSyncMessage(message3).changes.length, 3) // {n3c1, n3c2, n3c3}
;[n1, s13] = Automerge.receiveSyncMessage(n1, s13, message3)
// Copy the Bloom filter received from n1 into the message sent from n3 to n2. This Bloom
// filter indicates what changes n3 is going to receive from n1.
;[s32, message3] = Automerge.generateSyncMessage(n3, s32) // message from n3 to n2
const modifiedMessage = decodeSyncMessage(message3)
modifiedMessage.have.push(decodeSyncMessage(message1).have[0])
assert.strictEqual(modifiedMessage.changes.length, 0)
;[n2, s23] = Automerge.receiveSyncMessage(n2, s23, encodeSyncMessage(modifiedMessage))
// n2 replies to n3, sending only n2c3 (the one change that n2 has but n1 doesn't)
;[s23, message2] = Automerge.generateSyncMessage(n2, s23)
assert.strictEqual(decodeSyncMessage(message2).changes.length, 1) // {n2c3}
;[n3, s32] = Automerge.receiveSyncMessage(n3, s32, message2)
// n1 replies to n3
;[s13, message1] = Automerge.generateSyncMessage(n1, s13)
assert.strictEqual(decodeSyncMessage(message1).changes.length, 5) // {n1c1, n1c2, n1c3, n2c1, n2c2}
;[n3, s31] = Automerge.receiveSyncMessage(n3, s31, message1)
assert.deepStrictEqual(getHeads(n3), [n1c3, n2c3, n3c3].sort())
})
it('should allow any change to be requested', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
let message = null
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
const lastSync = getHeads(n1)
for (let i = 3; i < 6; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n1, n2, s1, s2] = sync(n1, n2)
s1.lastSentHeads = [] // force generateSyncMessage to return a message even though nothing changed
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
const modMsg = decodeSyncMessage(message)
modMsg.need = lastSync // re-request change 2
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, encodeSyncMessage(modMsg))
;[s1, message] = Automerge.generateSyncMessage(n2, s2)
assert.strictEqual(decodeSyncMessage(message).changes.length, 1)
assert.strictEqual(Automerge.decodeChange(decodeSyncMessage(message).changes[0]).hash, lastSync[0])
})
it('should ignore requests for a nonexistent change', () => {
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef')
let s1 = initSyncState(), s2 = initSyncState()
let message = null
for (let i = 0; i < 3; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i)
;[n2] = Automerge.applyChanges(n2, Automerge.getAllChanges(n1))
;[s1, message] = Automerge.generateSyncMessage(n1, s1)
message.need = ['0000000000000000000000000000000000000000000000000000000000000000']
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, message)
;[s2, message] = Automerge.generateSyncMessage(n2, s2)
assert.strictEqual(message, null)
})
it('should allow a subset of changes to be sent', () => {
// ,-- c1 <-- c2
// c0 <-+
// `-- c3 <-- c4 <-- c5 <-- c6 <-- c7 <-- c8
let n1 = Automerge.init('01234567'), n2 = Automerge.init('89abcdef'), n3 = Automerge.init('76543210')
let s1 = initSyncState(), s2 = initSyncState()
let msg, decodedMsg
n1 = Automerge.change(n1, {time: 0}, doc => doc.x = 0)
n3 = Automerge.merge(n3, n1)
for (let i = 1; i <= 2; i++) n1 = Automerge.change(n1, {time: 0}, doc => doc.x = i) // n1 has {c0, c1, c2}
for (let i = 3; i <= 4; i++) n3 = Automerge.change(n3, {time: 0}, doc => doc.x = i) // n3 has {c0, c3, c4}
const c2 = getHeads(n1)[0], c4 = getHeads(n3)[0]
n2 = Automerge.merge(n2, n3) // n2 has {c0, c3, c4}
// Sync n1 and n2, so their shared heads are {c2, c4}
;[n1, n2, s1, s2] = sync(n1, n2)
s1 = decodeSyncState(encodeSyncState(s1))
s2 = decodeSyncState(encodeSyncState(s2))
assert.deepStrictEqual(s1.sharedHeads, [c2, c4].sort())
assert.deepStrictEqual(s2.sharedHeads, [c2, c4].sort())
// n2 and n3 apply {c5, c6, c7, c8}
n3 = Automerge.change(n3, {time: 0}, doc => doc.x = 5)
const change5 = Automerge.getLastLocalChange(n3)
n3 = Automerge.change(n3, {time: 0}, doc => doc.x = 6)
const change6 = Automerge.getLastLocalChange(n3), c6 = getHeads(n3)[0]
for (let i = 7; i <= 8; i++) n3 = Automerge.change(n3, {time: 0}, doc => doc.x = i)
const c8 = getHeads(n3)[0]
n2 = Automerge.merge(n2, n3)
// Now n1 initiates a sync with n2, and n2 replies with {c5, c6}. n2 does not send {c7, c8}
;[s1, msg] = Automerge.generateSyncMessage(n1, s1)
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, msg)
;[s2, msg] = Automerge.generateSyncMessage(n2, s2)
decodedMsg = decodeSyncMessage(msg)
decodedMsg.changes = [change5, change6]
msg = encodeSyncMessage(decodedMsg)
const sentHashes = {}
sentHashes[decodeChangeMeta(change5, true).hash] = true
sentHashes[decodeChangeMeta(change6, true).hash] = true
s2.sentHashes = sentHashes
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, msg)
assert.deepStrictEqual(s1.sharedHeads, [c2, c6].sort())
// n1 replies, confirming the receipt of {c5, c6} and requesting the remaining changes
;[s1, msg] = Automerge.generateSyncMessage(n1, s1)
;[n2, s2] = Automerge.receiveSyncMessage(n2, s2, msg)
assert.deepStrictEqual(decodeSyncMessage(msg).need, [c8])
assert.deepStrictEqual(decodeSyncMessage(msg).have[0].lastSync, [c2, c6].sort())
assert.deepStrictEqual(s1.sharedHeads, [c2, c6].sort())
assert.deepStrictEqual(s2.sharedHeads, [c2, c6].sort())
// n2 sends the remaining changes {c7, c8}
;[s2, msg] = Automerge.generateSyncMessage(n2, s2)
;[n1, s1] = Automerge.receiveSyncMessage(n1, s1, msg)
assert.strictEqual(decodeSyncMessage(msg).changes.length, 2)
assert.deepStrictEqual(s1.sharedHeads, [c2, c8].sort())
})
})
})
|
/**
* WhRequest.js
*
* @description :: TODO: You might write a short summary of how this model works and what it represents here.
* @docs :: http://sailsjs.org/#!documentation/models
*/
module.exports = {
attributes: {
date: {
type: 'date'
},
offices: {
model: 'Office'
},
whreqs: {
collection: 'WhBook',
via: 'whreq'
},
active: {
type: 'boolean',
defaultsTo: true
}
}
};
|
function solve([arg1]){
let number = Number(arg1)
for(i=number; i>0;i-=1){
console.log(i)
}
}
solve(['10'])
|
module.exports = angular.module('app.login', [])
.controller('LoginController', function($scope, $state, AuthenticationService, localStorageService) {
$scope.username = "";
$scope.password = "";
$scope.login = function() {
console.log($scope.username);
if ($scope.username === 'admin' && $scope.password === 'admin') {
AuthenticationService.isLogged = true;
localStorageService.set('token', 'eyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk');
$state.go('main');
} else {
$scope.username = "";
$scope.password = "";
}
}
});
|
var gulp = require('gulp');
var util = require('gulp-util')
var gulpConnect = require('gulp-connect');
var connect = require('connect');
var cors = require('cors');
var path = require('path');
var exec = require('child_process').exec;
var portfinder = require('portfinder');
var swaggerRepo = require('swagger-repo');
var DIST_DIR = 'web_deploy';
gulp.task('serve', ['build', 'watch', 'edit'], function() {
portfinder.getPort({port: 3030}, function (err, port) {
gulpConnect.server({
root: [DIST_DIR],
livereload: true,
port: port,
middleware: function (gulpConnect, opt) {
return [
cors()
]
}
});
});
});
gulp.task('edit', function() {
portfinder.getPort({port: 4040}, function (err, port) {
var app = connect();
app.use(swaggerRepo.swaggerEditorMiddleware());
app.listen(port);
util.log(util.colors.green('swagger-editor started http://localhost:' + port));
});
});
gulp.task('build', function (cb) {
exec('npm run build', function (err, stdout, stderr) {
console.log(stderr);
cb(err);
});
});
gulp.task('reload', ['build'], function () {
gulp.src(DIST_DIR).pipe(gulpConnect.reload())
});
gulp.task('watch', function () {
gulp.watch(['spec/**/*', 'web/**/*'], ['reload']);
});
|
Module( 'IMC.getIp', function(getIp) {
getIp.create = function() {
this.request();
};
getIp.request = function() {
this._getJSON();
};
getIp._getJSON = function() {
var args = {
url : 'http://ipinfo.io',
data : {},
dataType : 'jsonp',
cache : false
}
, ajax = jQuery.ajax( args )
;
ajax.done( this._done.bind( this ) );
};
getIp._done = function(response, status) {
localStorage.setItem( 'imcUserIp', response.ip );
};
}, {} ); |
// Copyright (c) 2012 Ecma International. All rights reserved.
// Ecma International makes this code available under the terms and conditions set
// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
// "Use Terms"). Any redistribution of this code must retain the above
// copyright and this notice and otherwise comply with the Use Terms.
/*---
es5id: 15.5.4.20-2-40
description: >
String.prototype.trim - 'this' is an object that has an own
toString method that returns an object and valueOf method that
returns a primitive value
includes: [runTestCase.js]
---*/
function testcase() {
var toStringAccessed = false;
var valueOfAccessed = false;
var obj = {
toString: function () {
toStringAccessed = true;
return {};
},
valueOf: function () {
valueOfAccessed = true;
return "abc";
}
};
return (String.prototype.trim.call(obj) === "abc") && valueOfAccessed && toStringAccessed;
}
runTestCase(testcase);
|
/**
*
* AVIONIC
* Propelling World-class Cross-platform Hybrid Applications ✈
*
* Copyright 2015 Reedia Limited. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
(function() {
'use strict';
/**
* @ngdoc function
* @name <%= ngModulName %>.controller:EditProductController
* @description
* # EditProductController
*/
var <%= ngModulName %> = angular.module('<%= ngModulName %>');
<%= ngModulName %>.controller('EditProductController', function($scope, $state, $stateParams, ExampleService) {
console.log($stateParams);
$scope.items={id:$stateParams.id,title:$stateParams.title};
$scope.edit=function(){
ExampleService.edit($scope.items.id,{title:$scope.items.title}).success(function(){
$state.go('app.products');
});
};
});
})();
|
import {describe, it} from 'mocha';
import {expect} from 'chai';
import _ from 'lodash';
import {
GraphQLObjectType,
GraphQLSchema,
GraphQLString,
graphql
} from 'graphql';
import {
getFieldsFromAst,
getFieldsFromInfo
} from '../';
describe('Fields', () => {
describe('getFieldsFromAst', () => {
it('should give root level fields', async () => {
const query = `
{
recentPost {
id,
title
}
}
`;
const info = await getInfo(query);
const fields = getFieldsFromAst(info, info.fieldASTs[0]);
expect(_.keys(fields)).to.be.deep.equal([ 'id', 'title' ]);
});
it('should give fields in fragments', async () => {
const query = `
{
recentPost {
id,
...a
}
}
fragment a on Post {
title
}
`;
const info = await getInfo(query);
const fields = getFieldsFromAst(info, info.fieldASTs[0]);
expect(_.keys(fields)).to.be.deep.equal([ 'id', 'title' ]);
});
it('should give fields in nested fragments', async () => {
const query = `
{
recentPost {
id,
...a
}
}
fragment a on Post {
title,
...b
}
fragment b on Post {
author {
name
}
}
`;
const info = await getInfo(query);
const fields = getFieldsFromAst(info, info.fieldASTs[0]);
expect(_.keys(fields)).to.be.deep.equal([ 'id', 'title', 'author' ]);
});
it('should allow to get fields in nested types', async () => {
const query = `
{
recentPost {
id,
...a
}
}
fragment a on Post {
title,
...b
}
fragment b on Post {
author {
name
}
}
`;
const info = await getInfo(query);
const fieldsOnPost = getFieldsFromAst(info, info.fieldASTs[0]);
const fieldsOnAuthor = getFieldsFromAst(info, fieldsOnPost['author']);
expect(_.keys(fieldsOnAuthor)).to.be.deep.equal([ 'name' ]);
});
});
describe('getFieldsFromInfo', () => {
it('should give filed just passing the info', async () => {
const query = `
{
recentPost {
id,
title
}
}
`;
const info = await getInfo(query);
const fields = getFieldsFromInfo(info);
expect(_.keys(fields)).to.be.deep.equal([ 'id', 'title' ]);
});
});
});
function getInfo(query) {
let resolve = null;
const Post = new GraphQLObjectType({
name: 'Post',
fields: () => ({
id: {type: GraphQLString},
title: {type: GraphQLString},
author: {type: Author},
})
});
const Author = new GraphQLObjectType({
name: 'Author',
fields: () => ({
id: {type: GraphQLString},
name: {type: GraphQLString},
})
});
const schema = new GraphQLSchema({
query: new GraphQLObjectType({
name: 'RootQuery',
fields: () => ({
recentPost: {
type: Post,
resolve(root, args, info) {
resolve(info);
return {};
}
}
})
})
});
setTimeout(() => graphql(schema, query), 0);
return new Promise(r => {resolve = r;});
}
|
import * as fs from 'fs';
import * as Path from 'path';
import * as StreamSplit from 'stream-split';
import {chunk} from 'lodash';
import {fields as gitLogFields} from './git-log-fields';
import {yellow, green, reset} from './colors';
import {console} from './console';
const fields = [
...gitLogFields,
{identifier: 'shortstats'}
];
function changes(data) {
const vs = data.split(',');
return {
changes: p(0),
insertions: p(1),
deletions: p(2)
};
function p(index) {
const v = vs[index] || 0;
let w = 0;
if (v !== 0) {
w = v.split(' ')[1]; // the number of changes is second on the array
}
return parseInt(w);
}
}
/**
* Parse intermediate output from a *single* git repository into JSON
*/
export function parseToJson(inputStream, repoName) {
console.log(`${ yellow }Generating JSON output...${ reset }`);
console.time(`${ green }JSON output for ${ repoName } generated in${ reset }`);
const totalFields = fields.length;
// Split the input on null bytes
const splitter = new StreamSplit(new Buffer([0]), {
// Pass all buffer, even the zero-length ones
readableObjectMode: true
});
inputStream.pipe(splitter);
// Skip leading null byte
splitter.once('data', () => {
splitter.on('data', onData);
});
const commits = [];
let item = [];
let commitIndex = 0;
let fieldIndex = 0;
function onData(field) {
item[fieldIndex++] = field.toString('utf8');
// If we've received a full commit's worth of fields, parse it
if(fieldIndex === totalFields) {
commits.push(parseCommit(item, commitIndex++));
fieldIndex = 0;
}
}
// Parse a commit from an array of fields
function parseCommit(item, index) {
// The last field for each commit includes the trailing newline output by `git log`; remove it
item[totalFields - 1] = item[totalFields - 1].slice(0, -1);
const commit = {
repository: repoName,
commit_nr: index + 1
};
fields.forEach((field, i) => {
commit[field.identifier] = item[i];
});
const stats = commit.shortstats;
const commitChanges = changes(stats);
commit.files_changed = commitChanges.changes;
const insertions = commit.insertions = commitChanges.insertions;
const deletions = commit.deletions = commitChanges.deletions;
commit.impact = insertions - deletions;
// Perform more normalization and cleanup of fields
commit.shortstats = commit.shortstats.trim();
commit.parent_hashes = delimitedArray(commit.parent_hashes, ' ');
commit.parent_hashes_abbreviated = delimitedArray(commit.parent_hashes_abbreviated, ' ');
commit.ref_names = delimitedArray(commit.ref_names, ', ');
if(!commit.encoding.length) commit.encoding = undefined;
if(!commit.commit_notes.length) commit.commit_notes = undefined;
// If commit is not signed
if(commit.signature_validity === 'N') {
commit.raw_GPG_verification_message = undefined;
commit.signer_name = undefined;
commit.key = undefined;
}
return commit;
}
// Wait for the stream to finish
const commitsPromise = new Promise((res, rej) => {
splitter.on('finish', () => {
console.timeEnd(`${ green }JSON output for ${ repoName } generated in${ reset }`);
res(commits);
});
});
return {
commits: commitsPromise
};
}
function delimitedArray(field, delim) {
return field.length ? field.split(delim) : [];
}
|
"use strict";
var util = require('util'),
mpath = require('mpath'),
Promise = require("bluebird"),
_extend = require('node.extend'),
_filter = require('./lib/filter'),
_validator = require('./lib/validator'),
ConformaError = require('./lib/error').ConformaError,
ConformaValidationError = require('./lib/error').ConformaValidationError;
/**
* @typedef {Conforma} Conforma
* @class
* @constructor
*
* @param {Object} [data]
*
* @property {Array} _filter
* @property {Array} _validator
* @property {Object} _data
*
* @returns {Conforma}
*/
var Conforma = function(data) {
if (!(this instanceof Conforma)){
return new Conforma(data);
}
return this.reset().setData(data);
};
/**
* @returns {Conforma}
*/
Conforma.prototype.reset = function() {
/**
* @type {Object}
* @private
*/
this._filter = {};
/**
* @type {Object}
* @private
*/
this._validator = {};
/**
* @type {Object}
* @private
*/
this._msg = {};
/**
* @type {{}}
* @private
*/
this._data = {};
/**
*
* @type {Object|null}
* @private
*/
this._rawData = {};
/**
* @type {Array}
* @private
*/
this._drop = [];
/**
*
* @type {null}
* @private
*/
this._namespace = null;
/**
*
* @type {boolean}
* @private
*/
this._conform = false;
return this;
};
/**
* @param {String} srcPath
* @param {String} [destPath] - if it is empty then move to root node
*
* @returns {Conforma}
*/
Conforma.prototype.move = function(srcPath, destPath) {
var data = mpath.get(srcPath, this._data);
var tmpData = this._data;
if(srcPath && destPath && mpath.get(destPath, this._data)) {
mpath.set(destPath, mpath.get(srcPath, this._data), this._data);
} else if(srcPath && destPath) {
var nodePath = destPath.split('.');
var last = nodePath.pop();
nodePath.forEach(function(path) {
tmpData[path] = tmpData[path] || {};
tmpData = tmpData[path];
});
tmpData[last] = data;
} else if(srcPath && !destPath) {
_extend(this._data, data);
}
return this.remove(srcPath);
};
/**
* @param srcPath
*
* @returns {Conforma}
*/
Conforma.prototype.remove = function(srcPath) {
var path = srcPath.split('.');
var last = path.pop();
var data = this._data;
path.forEach(function(path) {
data = data[path];
});
delete data[last];
return this;
};
/**
* @param {Object} data
*
* @returns {Conforma}
*/
Conforma.prototype.setData = function(data) {
this._rawData = _extend(true, {}, this._rawData, data || {});
this._data = _extend(true, {}, this._data, data || {});
return this;
};
/**
* without start exec you get can get filtered or raw data,
* after exec you get only filtered data
*
* @param {Boolean} [clean] - get clean or raw data
*
* @returns {{}|*}
*/
Conforma.prototype.getData = function(clean) {
if(clean) {
this._runFilter();
}
return _extend(true, {}, this._data);
};
/**
* @param {Boolean} [clean] - get clean or raw data
*
* @returns {{}|*}
*/
Conforma.prototype.getRawData = function(clean) {
return this._rawData;
};
/**
* @param {String} field - get field value
*
* @returns {*|undefined}
*/
Conforma.prototype.getValue = function(field) {
return mpath.get(field, this._data);
};
/**
* @param {*} value
*
* @returns {Conforma}
*/
Conforma.prototype.default = function(value) {
this._data = _extend(true, value, this._data);
return this;
};
/**
* @param {Object|Boolean} [data]
*
* @throws Error
*
* @returns {Conforma}
*/
Conforma.prototype.conform = function(data) {
if(typeof data === 'boolean') {
this._conform = data;
} else if(!data) {
throw new Error('conform empty "data" value');
} else {
this._data = conform(this._rawData, data);
}
return this;
};
/**
*
* @param {String} field
* @param {String|Array|Object} filter
* @param {*} [options]
*
* @returns {Conforma}
*/
Conforma.prototype.filter = function(field, filter, options) {
var _this = this;
if(!field || !filter) {
return this;
}
if(!this._filter.hasOwnProperty(field)) {
this._filter[field] = [];
}
if(typeof filter === 'string' && filter in _filter) {
this._filter[field].push(function(value) {
return _filter[filter].call(_this, value, options);
});
} else if(util.isArray(filter)) {
filter.forEach(function(val) {
_this.filter(field, val);
});
} else if(typeof filter === 'function') {
this._filter[field].push(filter);
} else if(typeof filter === 'object') {
var fName = Object.keys(filter).pop();
this.filter(field, fName, filter[fName]);
} else {
throw new Error('Filter "'+ filter +'" not available');
}
return this;
};
/**
* @param {String} field
* @param {String|Array|Object} validator
* @param {Object} [msg]
*
* @returns {Conforma}
*/
Conforma.prototype.validate = function(field, validator, msg) {
if(!field || !validator) {
return this;
}
var _this = this;
if(!this._validator.hasOwnProperty(field)) {
this._validator[field] = {};
}
if(util.isArray(validator)) {
validator.forEach(function(key) {
_this._applyValidator(field, key, msg);
});
} else {
_this._applyValidator(field, validator, msg);
}
return this;
};
/**
* @param {String} field
* @param {String} key
* @param {Object} [msg]
*
* @private
*/
Conforma.prototype._applyValidator = function (field, key, msg) {
var vName, func;
if(typeof key === 'string' && key in _validator) {
func = _validator[key]();
} else if(typeof key === 'function') {
func = key;
key = '#' + Object.keys(this._validator[field]).length;
} else if(typeof key === 'object') {
vName = Object.keys(key)[0] + '' || null;
if(vName in _validator) {
func = _validator[vName].call(_validator, key[vName]);
msg = key.msg || msg;
key = vName;
}
}
if(func) {
if(!this._validator[field][key]) {
this._validator[field][key] = [];
}
this._msg[field + key] = msg;
this._validator[field][key][this._validator[field][key].length] = func;
} else {
throw Error('Validator "'+ (vName || key) +'" is not available');
}
};
/**
* @returns {Object}
*
* @private
*/
Conforma.prototype._runFilter = function() {
var _this = this;
if(this._conform) {
this._rawData = _extend(true, {}, this._data);
this._data = {};
}
Object.keys(this._filter).forEach(function(field) {
var orgValue = mpath.get(field, _this._rawData);
var newValue = mpath.get(field, _this._data);
if(orgValue === undefined && newValue !== undefined) {
mpath.set(field, newValue, _this._data);
} else {
mpath.set(field, orgValue, _this._data);
}
_this._filter[field].forEach(function(filter) {
mpath.set(
field,
filter.call(_this, mpath.get(field, _this._data)),
_this._data
);
});
});
this._drop
.filter(function(n) {return n && n})
.map(function(n) {return String(n).trim()})
.forEach(this.remove.bind(_this));
};
/**
* Add Drop Data
*
* @public
*
* @returns {Conforma}
*/
Conforma.prototype.drop = function(src) {
this._drop = this._drop.concat((arguments.length === 1 && typeof src === 'string') ? src.split(',')
: Array.isArray(src) ? src
: Array.prototype.slice.call(arguments));
return this;
};
/**
* Filter data and validate
*
* @param {function} [done] - callback or promise
*
* @returns {Promise}
*/
Conforma.prototype.exec = function(done) {
var _this = this, sync = [];
// add first promise with filter
sync[sync.length] = Promise.try(function () {
_this._runFilter();
});
// append all validator promises
Object.keys(this._validator).forEach(function(field) {
var val = _this.getValue(field);
var validators = _this._validator[field];
var extendedField = _this._namespace ? [_this._namespace, field].join('.') : field;
if('required' in validators && val === undefined) {
sync[sync.length] = Promise.try(function () {
return _validator.required()(extendedField, val, _this._msg[field+'required']);
});
} else if('notEmpty' in validators && _validator.isEmpty(val)) {
sync[sync.length] = Promise.try(function () {
return _validator.notEmpty()(extendedField, val, _this._msg[field+'notEmpty']);
});
} else if('empty' in validators && _validator.isEmpty(val)) {
sync[sync.length] = Promise.resolve();
} else {
Object.keys(validators).map(function(validator) {
validators[validator].map(function(v) {
sync[sync.length] = Promise.try(function () {
return v.call(_this, extendedField, val, _this._msg[field + validator]);
});
});
});
}
});
return Promise.all(sync)
.bind(this)
.then(function(err) {
var errors = err || [],
newErrors = [],
newData = [],
normalizedData = [];
errors.forEach(function(err) {
if(err instanceof ConformaError) {
err.errors.forEach(function(data) {
normalizedData.push(data)
});
} else if(err) {
normalizedData.push(err);
}
});
normalizedData.forEach(function(err) {
if(err instanceof ConformaError) {
newErrors = newErrors.concat(err.errors);
} else if(err instanceof ConformaValidationError) {
newErrors = newErrors.concat(err);
} else if(err) {
newData.push(err);
}
});
if(newData.length) {
newData.forEach(function(data) {
_this.setData(data);
});
}
if(newErrors.length) {
throw new ConformaError('You have an error on validate data', newErrors);
}
return _this.getData();
})
.nodeify(done && done.bind(this));
};
/**
* @return {Promise}
*/
Conforma.prototype.mount = function() {
var _this = this;
return this.exec().then(function() {
if(_this._namespace) {
var o = {};
// TODO: complex nesting
o[_this._namespace] = _this.getData();
return o;
} else {
return _this.getData();
}
}).catch(ConformaError, function(err) {
if(_this._namespace) {
var o = {};
o[_this._namespace] = _this.getData();
err.errors.push(o);
} else {
err.errors.push(_this.getData());
}
// prevent throwing error
return err;
});
};
/**
* for mount conformas
*
* @param namespace
* @return {Conforma}
*/
Conforma.prototype.namespace = function(namespace) {
this._namespace = namespace;
return this;
};
/**
* @param {*} src
* @param {*} conf
*
* @returns {*}
*/
function conform(src, conf) {
var dest = {};
var rec = function(dest, src, conf) {
Object.keys(conf).forEach(function(key) {
if((typeof conf[key] === 'object' && !Array.isArray(conf[key]))) {
dest[key] = rec({}, src[key] || {}, conf[key]);
} else if(typeof conf[key] === 'object' && Array.isArray(conf[key])) {
dest[key] = conf[key];
} else {
if(Object.prototype.hasOwnProperty.call(src, key)) {
dest[key] = src[key];
} else {
dest[key] = src[key] || conf[key];
}
}
});
return dest;
};
return rec(dest, src, conf);
}
/** @type {Conforma} */
module.exports.Conforma = Conforma;
/** @type {ConformaFilter} */
module.exports.ConformaFilter = _filter;
/** @type {ConformaValidator} */
module.exports.ConformaValidator = _validator;
/** @type {ConformaError} */
module.exports.ConformaError = ConformaError;
/** @type {ConformaValidationError} */
module.exports.ConformaValidationError = ConformaValidationError;
/** @type {function} */
module.exports.conform = conform; |
/**
* Created by Jackey Li on 2015/12/3.
*/
(function (angular) {
'use strict';
angular.module('desktop').factory('desktopStyleHttpService',
['$http',
function ($http) {
var service = {};
service.getData = function () {
return $http.get('desktop/content/data/style.json');
};
return service;
}]);
})(angular); |
// Download the Node helper library from twilio.com/docs/node/install
// These vars are your accountSid and authToken from twilio.com/user/account
const twilio = require('twilio');
const accountSid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
const authToken = 'your_auth_token';
const workspaceSid = 'WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
const taskQueueSid = 'WQXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
const capability = new twilio.TaskRouterTaskQueueCapability(
accountSid,
authToken,
workspaceSid,
taskQueueSid
);
capability.allowFetchSubresources();
capability.allowUpdates();
let token = capability.generate();
// By default, tokens are good for one hour.
// Override this default timeout by specifiying a new value (in seconds).
// For example, to generate a token good for 8 hours:
token = capability.generate(28800); // 60 * 60 * 8
|
exports.ESLINT_PLUGIN_PREFIX = 'eslint-plugin-';
exports.PLUGIN_NAME_SHORT = 'disable';
exports.PLUGIN_NAME = this.ESLINT_PLUGIN_PREFIX + this.PLUGIN_NAME_SHORT;
exports.PLUGIN_PROCESSOR_NAME = 'disable';
|
'use strict';
(function() {
// Tipos Controller Spec
describe('Tipos Controller Tests', function() {
// Initialize global variables
var TiposController,
scope,
$httpBackend,
$stateParams,
$location;
// The $resource service augments the response object with methods for updating and deleting the resource.
// If we were to use the standard toEqual matcher, our tests would fail because the test values would not match
// the responses exactly. To solve the problem, we define a new toEqualData Jasmine matcher.
// When the toEqualData matcher compares two objects, it takes only object properties into
// account and ignores methods.
beforeEach(function() {
jasmine.addMatchers({
toEqualData: function(util, customEqualityTesters) {
return {
compare: function(actual, expected) {
return {
pass: angular.equals(actual, expected)
};
}
};
}
});
});
// Then we can start by loading the main application module
beforeEach(module(ApplicationConfiguration.applicationModuleName));
// The injector ignores leading and trailing underscores here (i.e. _$httpBackend_).
// This allows us to inject a service but then attach it to a variable
// with the same name as the service.
beforeEach(inject(function($controller, $rootScope, _$location_, _$stateParams_, _$httpBackend_) {
// Set a new global scope
scope = $rootScope.$new();
// Point global variables to injected services
$stateParams = _$stateParams_;
$httpBackend = _$httpBackend_;
$location = _$location_;
// Initialize the Tipos controller.
TiposController = $controller('TiposController', {
$scope: scope
});
}));
it('$scope.find() should create an array with at least one Tipo object fetched from XHR', inject(function(Tipos) {
// Create sample Tipo using the Tipos service
var sampleTipo = new Tipos({
name: 'New Tipo'
});
// Create a sample Tipos array that includes the new Tipo
var sampleTipos = [sampleTipo];
// Set GET response
$httpBackend.expectGET('tipos').respond(sampleTipos);
// Run controller functionality
scope.find();
$httpBackend.flush();
// Test scope value
expect(scope.tipos).toEqualData(sampleTipos);
}));
it('$scope.findOne() should create an array with one Tipo object fetched from XHR using a tipoId URL parameter', inject(function(Tipos) {
// Define a sample Tipo object
var sampleTipo = new Tipos({
name: 'New Tipo'
});
// Set the URL parameter
$stateParams.tipoId = '525a8422f6d0f87f0e407a33';
// Set GET response
$httpBackend.expectGET(/tipos\/([0-9a-fA-F]{24})$/).respond(sampleTipo);
// Run controller functionality
scope.findOne();
$httpBackend.flush();
// Test scope value
expect(scope.tipo).toEqualData(sampleTipo);
}));
it('$scope.create() with valid form data should send a POST request with the form input values and then locate to new object URL', inject(function(Tipos) {
// Create a sample Tipo object
var sampleTipoPostData = new Tipos({
name: 'New Tipo'
});
// Create a sample Tipo response
var sampleTipoResponse = new Tipos({
_id: '525cf20451979dea2c000001',
name: 'New Tipo'
});
// Fixture mock form input values
scope.name = 'New Tipo';
// Set POST response
$httpBackend.expectPOST('tipos', sampleTipoPostData).respond(sampleTipoResponse);
// Run controller functionality
scope.create();
$httpBackend.flush();
// Test form inputs are reset
expect(scope.name).toEqual('');
// Test URL redirection after the Tipo was created
expect($location.path()).toBe('/tipos/' + sampleTipoResponse._id);
}));
it('$scope.update() should update a valid Tipo', inject(function(Tipos) {
// Define a sample Tipo put data
var sampleTipoPutData = new Tipos({
_id: '525cf20451979dea2c000001',
name: 'New Tipo'
});
// Mock Tipo in scope
scope.tipo = sampleTipoPutData;
// Set PUT response
$httpBackend.expectPUT(/tipos\/([0-9a-fA-F]{24})$/).respond();
// Run controller functionality
scope.update();
$httpBackend.flush();
// Test URL location to new object
expect($location.path()).toBe('/tipos/' + sampleTipoPutData._id);
}));
it('$scope.remove() should send a DELETE request with a valid tipoId and remove the Tipo from the scope', inject(function(Tipos) {
// Create new Tipo object
var sampleTipo = new Tipos({
_id: '525a8422f6d0f87f0e407a33'
});
// Create new Tipos array and include the Tipo
scope.tipos = [sampleTipo];
// Set expected DELETE response
$httpBackend.expectDELETE(/tipos\/([0-9a-fA-F]{24})$/).respond(204);
// Run controller functionality
scope.remove(sampleTipo);
$httpBackend.flush();
// Test array after successful delete
expect(scope.tipos.length).toBe(0);
}));
});
}()); |
'use strict'
import {
createAction, handleActions
}
from 'redux-actions'
import { find } from 'lodash'
// ------------------------------------
// Constants
// ------------------------------------
export const MAP_GROUND_SET_MAP_STYLE = 'MAP_GROUND_SET_MAP_STYLE'
const DARK_MAP_NAME = 'mapbox://styles/mapbox/dark-v9'
const DARK_MAP = {
name: 'Dark',
type: 'vector',
url: DARK_MAP_NAME
}
const AVAILABLE_MAPS = [ DARK_MAP ]
// ------------------------------------
// Default State
// ------------------------------------
const DEFAULT_GROUND_STATE = {
mapStyle: DARK_MAP_NAME,
availableMapStyles: AVAILABLE_MAPS
}
// ------------------------------------
// Actions
// ------------------------------------
export const setMapStyle = createAction(MAP_GROUND_SET_MAP_STYLE)
export const mapGroundActions = {
setMapStyle
}
var actionHandlers = {
MAP_GROUND_SET_MAP_STYLE: (state, { payload: { styleName } }) => {
let soughtStyle = find(state.availableMapStyles, 'name', styleName)
if (soughtStyle == null) {
return state
}
return { ...state, mapStyle: soughtStyle }
}
}
export default handleActions(actionHandlers, DEFAULT_GROUND_STATE)
|
import R from 'ramda'
export default {
name: 'book',
schema: {
data: {
type: R.always('book'),
id: R.compose(R.toString, R.path(['data', 'id'])),
untransformId: R.compose(Number, R.path(['id'])),
attributes({ data }) {
const attributes = R.pick(['title', 'copyright'], data)
return R.isEmpty(attributes) ? undefined : attributes
},
untransformAttributes: R.path(['attributes']),
relationships: {
author({ data }) {
const author = R.prop('author', data)
if (!author) {
return undefined
}
return {
data: {
name: 'author',
data: author,
included: true,
},
}
},
reviews({ data }) {
const reviews = R.prop('reviews', data)
if (!reviews) {
return undefined
}
return {
data: reviews.map(review => ({
name: 'review',
data: review,
included: true,
})),
}
},
publisher({ data }) {
const publisher = R.prop('publisher', data)
if (!publisher) {
return undefined
}
return {
data: {
name: 'publisher',
data: publisher,
included: true,
},
}
},
tags({ data }) {
const tags = R.prop('tags', data)
if (!tags) {
return undefined
}
return {
data: tags.map(tag => ({
name: 'tag',
data: tag,
included: true,
})),
}
},
},
links({ options, id }) {
return {
self: `${options.url}/books/${id}`,
}
},
},
},
}
|
import formStyle from '../forms/style';
const initialState = {
isLoading: false,
success: false,
auto: 'none',
fields: {
password: {
placeholder: 'nova senha',
secureTextEntry: true,
maxLength: 72,
error: 'deve ter pelo menos 8 caracteres',
stylesheet: formStyle
},
password_confirmation: {
placeholder: 'confirme a nova senha',
secureTextEntry: true,
maxLength: 72,
error: 'deve ter pelo menos 8 caracteres',
stylesheet: formStyle
}
}
};
function password(state = initialState, action) {
switch (action.type) {
case 'INVALID_PASSWORD_UPDATE':
var {password, password_confirmation} = action.data;
var passwordError = !!password ? password[0] : state.fields.password.error;
var passwordConfirmationError = !!password_confirmation ? password_confirmation[0] : state.fields.password_confirmation.error;
return {
...state,
isLoading: false,
fields: {
password: {
...state.fields.password,
hasError: !!password,
error: passwordError,
editable: true
},
password_confirmation: {
...state.fields.password_confirmation,
hasError: !!password_confirmation,
error: passwordConfirmationError,
editable: true
}
}
};
case 'REQUEST_PASSWORD_UPDATE':
return {
...initialState,
isLoading: true,
fields: {
password: {
...state.fields.password,
editable: false
},
password_confirmation: {
...state.fields.password_confirmation,
editable: false
}
},
password: action.data.password,
password_confirmation: action.data.password_confirmation
};
case 'PASSWORD_UPDATED':
return {
...initialState,
success: true,
fields: {
password: {
...state.fields.password,
editable: true
},
password_confirmation: {
...state.fields.password_confirmation,
editable: true
}
}
};
case 'LOGGED_OUT':
return initialState;
default:
return state;
}
}
module.exports = password;
|
version https://git-lfs.github.com/spec/v1
oid sha256:049d55faf599cf56e0c61557d364f01b10b961b815ed1831d1573796ec45bdff
size 350776
|
'use strict'
const test = require('tap').test
const Rule = require('../../lib/rules/pr-url')
const MISSING_PR_URL = 'Commit must have a PR-URL.'
const INVALID_PR_URL = 'PR-URL must be a GitHub pull request URL.'
const NUMERIC_PR_URL = 'PR-URL must be a URL, not a pull request number.'
const VALID_PR_URL = 'PR-URL is valid.'
test('rule: pr-url', (t) => {
t.test('missing', (tt) => {
tt.plan(7)
const context = {
prUrl: null,
report: (opts) => {
tt.pass('called report')
tt.equal(opts.id, 'pr-url', 'id')
tt.equal(opts.message, MISSING_PR_URL, 'message')
tt.equal(opts.string, null, 'string')
tt.equal(opts.line, 0, 'line')
tt.equal(opts.column, 0, 'column')
tt.equal(opts.level, 'fail', 'level')
}
}
Rule.validate(context)
})
t.test('invalid numeric', (tt) => {
tt.plan(7)
const context = {
prUrl: '#1234',
body: [
'',
'PR-URL: #1234'
],
report: (opts) => {
tt.pass('called report')
tt.equal(opts.id, 'pr-url', 'id')
tt.equal(opts.message, NUMERIC_PR_URL, 'message')
tt.equal(opts.string, '#1234', 'string')
tt.equal(opts.line, 1, 'line')
tt.equal(opts.column, 8, 'column')
tt.equal(opts.level, 'fail', 'level')
}
}
Rule.validate(context)
})
t.test('invalid', (tt) => {
tt.plan(7)
const url = 'https://github.com/nodejs/node/issues/1234'
const context = {
prUrl: url,
body: [
'',
`PR-URL: ${url}`
],
report: (opts) => {
tt.pass('called report')
tt.equal(opts.id, 'pr-url', 'id')
tt.equal(opts.message, INVALID_PR_URL, 'message')
tt.equal(opts.string, url, 'string')
tt.equal(opts.line, 1, 'line')
tt.equal(opts.column, 8, 'column')
tt.equal(opts.level, 'fail', 'level')
}
}
Rule.validate(context)
})
t.test('valid', (tt) => {
tt.plan(7)
const url = 'https://github.com/nodejs/node/pull/1234'
const context = {
prUrl: url,
body: [
'',
`PR-URL: ${url}`
],
report: (opts) => {
tt.pass('called report')
tt.equal(opts.id, 'pr-url', 'id')
tt.equal(opts.message, VALID_PR_URL, 'message')
tt.equal(opts.string, url, 'string')
tt.equal(opts.line, 1, 'line')
tt.equal(opts.column, 8, 'column')
tt.equal(opts.level, 'pass', 'level')
}
}
Rule.validate(context)
})
t.test('valid URL containing hyphen', (tt) => {
tt.plan(7)
const url = 'https://github.com/nodejs/node-report/pull/1234'
const context = {
prUrl: url,
body: [
'',
`PR-URL: ${url}`
],
report: (opts) => {
tt.pass('called report')
tt.equal(opts.id, 'pr-url', 'id')
tt.equal(opts.message, VALID_PR_URL, 'message')
tt.equal(opts.string, url, 'string')
tt.equal(opts.line, 1, 'line')
tt.equal(opts.column, 8, 'column')
tt.equal(opts.level, 'pass', 'level')
}
}
Rule.validate(context)
})
t.end()
})
|
'use strict';
/**
* Module dependencies
*/
var path = require('path'),
config = require(path.resolve('./config/config'));
/**
* Values module init function.
*/
module.exports = function (app, db) {
};
|
describe('tabs', function () {
var tabsComponent = require('../tabs')
it('should have a created hook', function () {
expect(typeof tabsComponent.created).toBe('function')
})
it('should set empty default data', function () {
expect(typeof tabsComponent.data).toBe('function')
var defaultData = tabsComponent.data()
expect(defaultData.jsonData).toBe('')
})
it('should set correct default url', function () {
expect(typeof tabsComponent.data).toBe('function')
var defaultData = tabsComponent.data()
expect(defaultData.apiUrl).toBe('http://api.tabs.dev:8080/sources/search/')
})
it('should have a ready hook', function () {
expect(typeof tabsComponent.ready).toBe('function')
})
}) |
'use strict';
/**
* @ngdoc function
* @name trellocloneApp.controller:MainCtrl
* @description
* # MainCtrl
* Controller of the trellocloneApp
*/
angular.module('trellocloneApp')
.controller('MainCtrl', function ($scope) {
$scope.awesomeThings = [
'HTML5 Boilerplate',
'AngularJS',
'Karma'
];
});
|
/**
* Created by nuintun on 2015/11/20.
*/
'use strict';
var fs = require('fs');
var path = require('path');
var util = require('../../util');
var Vue = require('../../vue/vue');
require('../project-base');
require('../dynamic-item');
module.exports = Vue.component('project-configure', {
template: fs.readFileSync(path.join(__dirname, 'project-configure.html')).toString(),
props: {
show: {
type: Boolean,
twoWay: true,
default: false
},
project: {
type: Object,
required: true
},
unique: {
type: Object,
required: true
}
},
data: function (){
return {
clone: util.clone(this.project)
}
},
watch: {
project: function (project){
this.clone = util.clone(project);
// clean
this.reset();
}
},
methods: {
reset: function (){
// clean item input
var base = this.$refs.base;
var env = this.$refs.env;
var command = this.$refs.command;
base.$emit('reset-error');
env.$emit('reset-error');
command.$emit('reset-error');
env.$emit('reset-input');
command.$emit('reset-input');
},
edit: function (){
if (this.$refs.base.isValid()) {
this.show = false;
// send message
this.$dispatch('edit', util.clone(this.clone));
// clean
this.reset();
}
},
cancel: function (){
this.show = false;
this.clone = util.clone(this.project);
// clean
this.reset();
}
}
});
|
module.exports = {
entry: './src/index.tsx',
output: {
filename: 'bundle.js',
path: __dirname + '/dist'
},
// Enable sourcemaps for debugging webpack's output.
devtool: 'source-map',
resolve: {
// Add '.ts' and '.tsx' as resolvable extensions.
extensions: ['.ts', '.tsx', '.js', '.json']
},
module: {
rules: [
// All files with a '.ts' or '.tsx' extension will be handled by 'awesome-typescript-loader'.
{ test: /\.tsx?$/, loader: 'awesome-typescript-loader' },
// All output '.js' files will have any sourcemaps re-processed by 'source-map-loader'.
{ enforce: 'pre', test: /\.js$/, loader: 'source-map-loader' }
]
},
// When importing a module whose path matches one of the following, just
// assume a corresponding global variable exists and use that instead.
// This is important because it allows us to avoid bundling all of our
// dependencies, which allows browsers to cache those libraries between builds.
externals: {
'react': 'React',
'react-dom': 'ReactDOM'
},
}; |
const CARD_SECTION_TYPE = 10;
const IMAGE_SECTION_TYPE = 2;
/*
* input mobiledoc: [ markers, elements ]
* output: Post
*
*/
export default class MobiledocParser {
constructor(builder) {
this.builder = builder;
}
parse({version, sections: sectionData}) {
const markerTypes = sectionData[0];
const sections = sectionData[1];
const post = this.builder.createPost();
this.markups = [];
this.markerTypes = this.parseMarkerTypes(markerTypes);
this.parseSections(sections, post);
if (post.sections.isEmpty) {
let section = this.builder.createMarkupSection('p');
let marker = this.builder.createBlankMarker();
section.markers.append(marker);
post.sections.append(section);
}
return post;
}
parseMarkerTypes(markerTypes) {
return markerTypes.map((markerType) => this.parseMarkerType(markerType));
}
parseMarkerType([tagName, attributes]) {
return this.builder.createMarkup(tagName, attributes);
}
parseSections(sections, post) {
sections.forEach((section) => this.parseSection(section, post));
}
parseSection(section, post) {
let [type] = section;
switch(type) {
case 1: // markup section
this.parseMarkupSection(section, post);
break;
case IMAGE_SECTION_TYPE:
this.parseImageSection(section, post);
break;
case CARD_SECTION_TYPE:
this.parseCardSection(section, post);
break;
default:
throw new Error(`Unexpected section type ${type}`);
}
}
parseCardSection([type, name, payload], post) {
const section = this.builder.createCardSection(name, payload);
post.sections.append(section);
}
parseImageSection([type, src], post) {
const section = this.builder.createImageSection(src);
post.sections.append(section);
}
parseMarkupSection([type, tagName, markers], post) {
const section = this.builder.createMarkupSection(tagName);
post.sections.append(section);
this.parseMarkers(markers, section);
if (section.markers.isEmpty) {
let marker = this.builder.createBlankMarker();
section.markers.append(marker);
}
}
parseMarkers(markers, section) {
markers.forEach((marker) => this.parseMarker(marker, section));
}
parseMarker([markerTypeIndexes, closeCount, value], section) {
markerTypeIndexes.forEach(index => {
this.markups.push(this.markerTypes[index]);
});
const marker = this.builder.createMarker(value, this.markups.slice());
section.markers.append(marker);
this.markups = this.markups.slice(0, this.markups.length-closeCount);
}
}
|
define([
"../core",
"../var/document",
"../data/var/dataPriv",
"../data/var/acceptData",
"../var/hasOwn",
"../event"
], function (jQuery, document, dataPriv, acceptData, hasOwn) {
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
jQuery.extend(jQuery.event, {
trigger: function (event, data, elem, onlyHandlers) {
var i, cur, tmp, bubbleType, ontype, handle, special,
eventPath = [elem || document],
type = hasOwn.call(event, "type") ? event.type : event,
namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
cur = tmp = elem = elem || document;
// Don't do events on text and comment nodes
if (elem.nodeType === 3 || elem.nodeType === 8) {
return;
}
// focus/blur morphs to focusin/out; ensure we're not firing them right now
if (rfocusMorph.test(type + jQuery.event.triggered)) {
return;
}
if (type.indexOf(".") > -1) {
// Namespaced trigger; create a regexp to match event type in handle()
namespaces = type.split(".");
type = namespaces.shift();
namespaces.sort();
}
ontype = type.indexOf(":") < 0 && "on" + type;
// Caller can pass in a jQuery.Event object, Object, or just an event type string
event = event[jQuery.expando] ?
event :
new jQuery.Event(type, typeof event === "object" && event);
// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
event.isTrigger = onlyHandlers ? 2 : 3;
event.namespace = namespaces.join(".");
event.rnamespace = event.namespace ?
new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") :
null;
// Clean up the event in case it is being reused
event.result = undefined;
if (!event.target) {
event.target = elem;
}
// Clone any incoming data and prepend the event, creating the handler arg list
data = data == null ?
[event] :
jQuery.makeArray(data, [event]);
// Allow special events to draw outside the lines
special = jQuery.event.special[type] || {};
if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
return;
}
// Determine event propagation path in advance, per W3C events spec (#9951)
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
bubbleType = special.delegateType || type;
if (!rfocusMorph.test(bubbleType + type)) {
cur = cur.parentNode;
}
for (; cur; cur = cur.parentNode) {
eventPath.push(cur);
tmp = cur;
}
// Only add window if we got to document (e.g., not plain obj or detached DOM)
if (tmp === ( elem.ownerDocument || document )) {
eventPath.push(tmp.defaultView || tmp.parentWindow || window);
}
}
// Fire handlers on the event path
i = 0;
while (( cur = eventPath[i++] ) && !event.isPropagationStopped()) {
event.type = i > 1 ?
bubbleType :
special.bindType || type;
// jQuery handler
handle = ( dataPriv.get(cur, "events") || {} )[event.type] &&
dataPriv.get(cur, "handle");
if (handle) {
handle.apply(cur, data);
}
// Native handler
handle = ontype && cur[ontype];
if (handle && handle.apply && acceptData(cur)) {
event.result = handle.apply(cur, data);
if (event.result === false) {
event.preventDefault();
}
}
}
event.type = type;
// If nobody prevented the default action, do it now
if (!onlyHandlers && !event.isDefaultPrevented()) {
if (( !special._default ||
special._default.apply(eventPath.pop(), data) === false ) &&
acceptData(elem)) {
// Call a native DOM method on the target with the same name name as the event.
// Don't do default actions on window, that's where global variables be (#6170)
if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {
// Don't re-trigger an onFOO event when we call its FOO() method
tmp = elem[ontype];
if (tmp) {
elem[ontype] = null;
}
// Prevent re-triggering of the same event, since we already bubbled it above
jQuery.event.triggered = type;
elem[type]();
jQuery.event.triggered = undefined;
if (tmp) {
elem[ontype] = tmp;
}
}
}
}
return event.result;
},
// Piggyback on a donor event to simulate a different one
// Used only for `focus(in | out)` events
simulate: function (type, elem, event) {
var e = jQuery.extend(
new jQuery.Event(),
event,
{
type: type,
isSimulated: true
}
);
jQuery.event.trigger(e, null, elem);
}
});
jQuery.fn.extend({
trigger: function (type, data) {
return this.each(function () {
jQuery.event.trigger(type, data, this);
});
},
triggerHandler: function (type, data) {
var elem = this[0];
if (elem) {
return jQuery.event.trigger(type, data, elem, true);
}
}
});
return jQuery;
});
|
/**
* Author: Cameron Green <cam at uq.edu.au>
* Date: 02/12/13
*
* Click directive for buttons
*/
'use strict';
angular.module('uql.orgs')
.directive('uqlOrgsGoClick', ['$location', function ($location) {
return function (scope, element, attrs) {
var path;
attrs.$observe('uqlOrgsGoClick', function (val) {
path = val;
});
element.bind('click', function () {
scope.$apply(function () {
$location.path(path);
});
});
};
}]);
|
import { h, Component } from 'preact';
import { Link } from 'preact-router/match';
import style from './style';
export class Intro extends Component {
render({ offsetX }) {
return <div class={style.intro}>
<div style={this.getStyles(offsetX)}>Scroll or drag to start your advent adventure...</div>
<Link href="/about" class={style.about + ' link-button'}>About</Link>
</div>;
}
getStyles(offsetX) {
if (typeof window === "undefined") {
return {};
}
const ratio = offsetX / window.innerWidth
const percent = 100 * ratio;
return {
transform: `translate3d(${1.5 * offsetX}px, 0, ${-1.5 * percent}px)`,
opacity: 1 - ratio,
}
}
}
|
var readYaml = require('read-yaml');
BlockchainConfig = function() {};
BlockchainConfig.prototype.loadConfigFile = function(filename) {
try {
this.blockchainConfig = readYaml.sync(filename);
} catch (e) {
throw new Error("error reading " + filename);
}
return this;
};
BlockchainConfig.prototype.loadConfig = function(config) {
this.blockchainConfig = config;
return this;
};
BlockchainConfig.prototype.config = function(env) {
if (this.blockchainConfig === null) {
throw new Error("no blockchain config found");
}
var config = this.blockchainConfig[env || "development"];
var networkId;
if (config.network_id === undefined) {
networkId = Math.floor((Math.random() * 100000) + 1000);
}
else {
networkId = config.network_id;
}
config = {
env:env,
rpcHost: config.rpc_host,
rpcPort: config.rpc_port,
gasLimit: config.gas_limit || 500000,
gasPrice: config.gas_price || 10000000000000,
rpcWhitelist: config.rpc_whitelist,
minerthreads: config.minerthreads,
genesisBlock: config.genesis_block,
datadir: config.datadir,
chains: config.chains,
bootNodes: config.bootnodes,
deployTimeout: config.deploy_timeout || 20,
networkId: networkId,
maxPeers: config.max_peers || 4,
port: config.port || "30303",
console_toggle: config.console || false,
mine_when_needed: config.mine_when_needed || false,
whisper: config.whisper || false,
account: config.account,
geth_extra_opts: config.geth_extra_opts,
testnet: config.testnet || false,
deploy_synchronously: config.deploy_synchronously || false
}
return config;
};
module.exports = BlockchainConfig;
|
// homeIntent creates streams from click events on .increment & .decrement
const homeIntent = s => ({
inc$: s.DOM.select('.increment').events('click').map(ev => +1),
dec$: s.DOM.select('.decrement').events('click').map(ev => -1),
});
export default homeIntent
|
// Copyright (c) 2012 Ecma International. All rights reserved.
// Ecma International makes this code available under the terms and conditions set
// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
// "Use Terms"). Any redistribution of this code must retain the above
// copyright and this notice and otherwise comply with the Use Terms.
/*---
es5id: 15.2.3.6-1-4
description: >
Object.defineProperty applied to string primitive throws a
TypeError
includes: [runTestCase.js]
---*/
function testcase() {
try {
Object.defineProperty("hello\nworld\\!", "foo", {});
return false;
} catch (e) {
return e instanceof TypeError;
}
}
runTestCase(testcase);
|
/**
* @ngdoc module
* @name material.components.virtualRepeat
*/
angular.module('material.components.virtualRepeat', [
'material.core'
])
.directive('mdVirtualRepeatContainer', VirtualRepeatContainerDirective)
.directive('mdVirtualRepeat', VirtualRepeatDirective);
/**
* @ngdoc directive
* @name mdVirtualRepeatContainer
* @module material.components.virtualRepeat
* @restrict E
* @description
* `md-virtual-repeat-container` provides the scroll container for md-virtual-repeat.
*
* Virtual repeat is a limited substitute for ng-repeat that renders only
* enough dom nodes to fill the container and recycling them as the user scrolls.
*
* @usage
* <hljs lang="html">
*
* <md-virtual-repeat-container md-top-index="topIndex">
* <div md-virtual-repeat="i in items" md-item-size="20">Hello {{i}}!</div>
* </md-virtual-repeat-container>
* </hljs>
*
* @param {number=} md-top-index Binds the index of the item that is at the top of the scroll
* container to $scope. It can both read and set the scroll position.
* @param {boolean=} md-orient-horizontal Whether the container should scroll horizontally
* (defaults to orientation and scrolling vertically).
* @param {boolean=} md-auto-shrink When present, the container will shrink to fit
* the number of items when that number is less than its original size.
* @param {number=} md-auto-shrink-min Minimum number of items that md-auto-shrink
* will shrink to (default: 0).
*/
function VirtualRepeatContainerDirective() {
return {
controller: VirtualRepeatContainerController,
template: virtualRepeatContainerTemplate,
compile: function virtualRepeatContainerCompile($element, $attrs) {
$element
.addClass('md-virtual-repeat-container')
.addClass($attrs.hasOwnProperty('mdOrientHorizontal')
? 'md-orient-horizontal'
: 'md-orient-vertical');
}
};
}
function virtualRepeatContainerTemplate($element) {
return '<div class="md-virtual-repeat-scroller">' +
'<div class="md-virtual-repeat-sizer"></div>' +
'<div class="md-virtual-repeat-offsetter">' +
$element[0].innerHTML +
'</div></div>';
}
/**
* Maximum size, in pixels, that can be explicitly set to an element. The actual value varies
* between browsers, but IE11 has the very lowest size at a mere 1,533,917px. Ideally we could
* *compute* this value, but Firefox always reports an element to have a size of zero if it
* goes over the max, meaning that we'd have to binary search for the value.
* @const {number}
*/
var MAX_ELEMENT_SIZE = 1533917;
/**
* Number of additional elements to render above and below the visible area inside
* of the virtual repeat container. A higher number results in less flicker when scrolling
* very quickly in Safari, but comes with a higher rendering and dirty-checking cost.
* @const {number}
*/
var NUM_EXTRA = 3;
/** @ngInject */
function VirtualRepeatContainerController($$rAF, $parse, $window, $scope, $element, $attrs) {
this.$scope = $scope;
this.$element = $element;
this.$attrs = $attrs;
/** @type {number} The width or height of the container */
this.size = 0;
/** @type {number} The scroll width or height of the scroller */
this.scrollSize = 0;
/** @type {number} The scrollLeft or scrollTop of the scroller */
this.scrollOffset = 0;
/** @type {boolean} Whether the scroller is oriented horizontally */
this.horizontal = this.$attrs.hasOwnProperty('mdOrientHorizontal');
/** @type {!VirtualRepeatController} The repeater inside of this container */
this.repeater = null;
/** @type {boolean} Whether auto-shrink is enabled */
this.autoShrink = this.$attrs.hasOwnProperty('mdAutoShrink');
/** @type {number} Minimum number of items to auto-shrink to */
this.autoShrinkMin = parseInt(this.$attrs.mdAutoShrinkMin, 10) || 0;
/** @type {?number} Original container size when shrank */
this.originalSize = null;
/** @type {number} Amount to offset the total scroll size by. */
this.offsetSize = parseInt(this.$attrs.mdOffsetSize, 10) || 0;
if (this.$attrs.mdTopIndex) {
/** @type {function(angular.Scope): number} Binds to topIndex on Angular scope */
this.bindTopIndex = $parse(this.$attrs.mdTopIndex);
/** @type {number} The index of the item that is at the top of the scroll container */
this.topIndex = this.bindTopIndex(this.$scope);
if (!angular.isDefined(this.topIndex)) {
this.topIndex = 0;
this.bindTopIndex.assign(this.$scope, 0);
}
this.$scope.$watch(this.bindTopIndex, angular.bind(this, function(newIndex) {
if (newIndex !== this.topIndex) {
this.scrollToIndex(newIndex);
}
}));
} else {
this.topIndex = 0;
}
this.scroller = $element[0].getElementsByClassName('md-virtual-repeat-scroller')[0];
this.sizer = this.scroller.getElementsByClassName('md-virtual-repeat-sizer')[0];
this.offsetter = this.scroller.getElementsByClassName('md-virtual-repeat-offsetter')[0];
// TODO: Come up with a more robust (But hopefully also quick!) way of
var boundUpdateSize = angular.bind(this, this.updateSize);
$$rAF(function() {
boundUpdateSize();
var jWindow = angular.element($window);
jWindow.on('resize', boundUpdateSize);
$scope.$on('$destroy', function() {
jWindow.off('resize', boundUpdateSize);
});
$scope.$on('$md-resize', boundUpdateSize);
});
}
/** Called by the md-virtual-repeat inside of the container at startup. */
VirtualRepeatContainerController.prototype.register = function(repeaterCtrl) {
this.repeater = repeaterCtrl;
angular.element(this.scroller)
.on('scroll wheel touchmove touchend', angular.bind(this, this.handleScroll_));
};
/** @return {boolean} Whether the container is configured for horizontal scrolling. */
VirtualRepeatContainerController.prototype.isHorizontal = function() {
return this.horizontal;
};
/** @return {number} The size (width or height) of the container. */
VirtualRepeatContainerController.prototype.getSize = function() {
return this.size;
};
/**
* Resizes the container.
* @private
* @param {number} The new size to set.
*/
VirtualRepeatContainerController.prototype.setSize_ = function(size) {
this.size = size;
this.$element[0].style[this.isHorizontal() ? 'width' : 'height'] = size + 'px';
};
/** Instructs the container to re-measure its size. */
VirtualRepeatContainerController.prototype.updateSize = function() {
if (this.originalSize) return;
this.size = this.isHorizontal()
? this.$element[0].clientWidth
: this.$element[0].clientHeight;
this.repeater && this.repeater.containerUpdated();
};
/** @return {number} The container's scrollHeight or scrollWidth. */
VirtualRepeatContainerController.prototype.getScrollSize = function() {
return this.scrollSize;
};
/**
* Sets the scroller element to the specified size.
* @private
* @param {number} size The new size.
*/
VirtualRepeatContainerController.prototype.sizeScroller_ = function(size) {
var dimension = this.isHorizontal() ? 'width' : 'height';
var crossDimension = this.isHorizontal() ? 'height' : 'width';
// If the size falls within the browser's maximum explicit size for a single element, we can
// set the size and be done. Otherwise, we have to create children that add up the the desired
// size.
if (size < MAX_ELEMENT_SIZE) {
this.sizer.style[dimension] = size + 'px';
} else {
// Clear any existing dimensions.
this.sizer.innerHTML = '';
this.sizer.style[dimension] = 'auto';
this.sizer.style[crossDimension] = 'auto';
// Divide the total size we have to render into N max-size pieces.
var numChildren = Math.floor(size / MAX_ELEMENT_SIZE);
// Element template to clone for each max-size piece.
var sizerChild = document.createElement('div');
sizerChild.style[dimension] = MAX_ELEMENT_SIZE + 'px';
sizerChild.style[crossDimension] = '1px';
for (var i = 0; i < numChildren; i++) {
this.sizer.appendChild(sizerChild.cloneNode(false));
}
// Re-use the element template for the remainder.
sizerChild.style[dimension] = (size - (numChildren * MAX_ELEMENT_SIZE)) + 'px';
this.sizer.appendChild(sizerChild);
}
};
/**
* If auto-shrinking is enabled, shrinks or unshrinks as appropriate.
* @private
* @param {number} size The new size.
*/
VirtualRepeatContainerController.prototype.autoShrink_ = function(size) {
var shrinkSize = Math.max(size, this.autoShrinkMin * this.repeater.getItemSize());
if (this.autoShrink && shrinkSize !== this.size) {
if (shrinkSize < (this.originalSize || this.size)) {
if (!this.originalSize) {
this.originalSize = this.size;
}
this.setSize_(shrinkSize);
} else if (this.originalSize) {
this.setSize_(this.originalSize);
this.originalSize = null;
}
}
};
/**
* Sets the scrollHeight or scrollWidth. Called by the repeater based on
* its item count and item size.
* @param {number} itemsSize The total size of the items.
*/
VirtualRepeatContainerController.prototype.setScrollSize = function(itemsSize) {
var size = itemsSize + this.offsetSize;
if (this.scrollSize === size) return;
this.sizeScroller_(size);
this.autoShrink_(size);
this.scrollSize = size;
};
/** @return {number} The container's current scroll offset. */
VirtualRepeatContainerController.prototype.getScrollOffset = function() {
return this.scrollOffset;
};
/**
* Scrolls to a given scrollTop position.
* @param {number} position
*/
VirtualRepeatContainerController.prototype.scrollTo = function(position) {
this.scroller[this.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = position;
this.handleScroll_();
};
/**
* Scrolls the item with the given index to the top of the scroll container.
* @param {number} index
*/
VirtualRepeatContainerController.prototype.scrollToIndex = function(index) {
var itemSize = this.repeater.getItemSize();
var itemsLength = this.repeater.itemsLength;
if(index > itemsLength) {
index = itemsLength - 1;
}
this.scrollTo(itemSize * index);
};
VirtualRepeatContainerController.prototype.resetScroll = function() {
this.scrollTo(0);
};
VirtualRepeatContainerController.prototype.handleScroll_ = function() {
var offset = this.isHorizontal() ? this.scroller.scrollLeft : this.scroller.scrollTop;
if (offset === this.scrollOffset) return;
var itemSize = this.repeater.getItemSize();
if (!itemSize) return;
var numItems = Math.max(0, Math.floor(offset / itemSize) - NUM_EXTRA);
var transform = this.isHorizontal() ? 'translateX(' : 'translateY(';
transform += (numItems * itemSize) + 'px)';
this.scrollOffset = offset;
this.offsetter.style.webkitTransform = transform;
this.offsetter.style.transform = transform;
if (this.bindTopIndex) {
var topIndex = Math.floor(offset / itemSize);
if (topIndex !== this.topIndex && topIndex < this.repeater.itemsLength) {
this.topIndex = topIndex;
this.bindTopIndex.assign(this.$scope, topIndex);
if (!this.$scope.$root.$$phase) this.$scope.$digest();
}
}
this.repeater.containerUpdated();
};
/**
* @ngdoc directive
* @name mdVirtualRepeat
* @module material.components.virtualRepeat
* @restrict A
* @priority 1000
* @description
* `md-virtual-repeat` specifies an element to repeat using virtual scrolling.
*
* Virtual repeat is a limited substitute for ng-repeat that renders only
* enough dom nodes to fill the container and recycling them as the user scrolls.
* Arrays, but not objects are supported for iteration.
* Track by, as alias, and (key, value) syntax are not supported.
*
* @usage
* <hljs lang="html">
* <md-virtual-repeat-container>
* <div md-virtual-repeat="i in items">Hello {{i}}!</div>
* </md-virtual-repeat-container>
*
* <md-virtual-repeat-container md-orient-horizontal>
* <div md-virtual-repeat="i in items" md-item-size="20">Hello {{i}}!</div>
* </md-virtual-repeat-container>
* </hljs>
*
* @param {number=} md-item-size The height or width of the repeated elements (which must be
* identical for each element). Optional. Will attempt to read the size from the dom if missing,
* but still assumes that all repeated nodes have same height or width.
* @param {string=} md-extra-name Evaluates to an additional name to which the current iterated item
* can be assigned on the repeated scope (needed for use in `md-autocomplete`).
* @param {boolean=} md-on-demand When present, treats the md-virtual-repeat argument as an object
* that can fetch rows rather than an array.
*
* **NOTE:** This object must implement the following interface with two (2) methods:
*
* - `getItemAtIndex: function(index) [object]` The item at that index or null if it is not yet
* loaded (it should start downloading the item in that case).
* - `getLength: function() [number]` The data length to which the repeater container
* should be sized. Ideally, when the count is known, this method should return it.
* Otherwise, return a higher number than the currently loaded items to produce an
* infinite-scroll behavior.
*/
function VirtualRepeatDirective($parse) {
return {
controller: VirtualRepeatController,
priority: 1000,
require: ['mdVirtualRepeat', '^^mdVirtualRepeatContainer'],
restrict: 'A',
terminal: true,
transclude: 'element',
compile: function VirtualRepeatCompile($element, $attrs) {
var expression = $attrs.mdVirtualRepeat;
var match = expression.match(/^\s*([\s\S]+?)\s+in\s+([\s\S]+?)\s*$/);
var repeatName = match[1];
var repeatListExpression = $parse(match[2]);
var extraName = $attrs.mdExtraName && $parse($attrs.mdExtraName);
return function VirtualRepeatLink($scope, $element, $attrs, ctrl, $transclude) {
ctrl[0].link_(ctrl[1], $transclude, repeatName, repeatListExpression, extraName);
};
}
};
}
/** @ngInject */
function VirtualRepeatController($scope, $element, $attrs, $browser, $document, $$rAF) {
this.$scope = $scope;
this.$element = $element;
this.$attrs = $attrs;
this.$browser = $browser;
this.$document = $document;
this.$$rAF = $$rAF;
/** @type {boolean} Whether we are in on-demand mode. */
this.onDemand = $attrs.hasOwnProperty('mdOnDemand');
/** @type {!Function} Backup reference to $browser.$$checkUrlChange */
this.browserCheckUrlChange = $browser.$$checkUrlChange;
/** @type {number} Most recent starting repeat index (based on scroll offset) */
this.newStartIndex = 0;
/** @type {number} Most recent ending repeat index (based on scroll offset) */
this.newEndIndex = 0;
/** @type {number} Most recent end visible index (based on scroll offset) */
this.newVisibleEnd = 0;
/** @type {number} Previous starting repeat index (based on scroll offset) */
this.startIndex = 0;
/** @type {number} Previous ending repeat index (based on scroll offset) */
this.endIndex = 0;
// TODO: measure width/height of first element from dom if not provided.
// getComputedStyle?
/** @type {?number} Height/width of repeated elements. */
this.itemSize = $scope.$eval($attrs.mdItemSize) || null;
/** @type {boolean} Whether this is the first time that items are rendered. */
this.isFirstRender = true;
/**
* @private {boolean} Whether the items in the list are already being updated. Used to prevent
* nested calls to virtualRepeatUpdate_.
*/
this.isVirtualRepeatUpdating_ = false;
/** @type {number} Most recently seen length of items. */
this.itemsLength = 0;
/**
* @type {!Function} Unwatch callback for item size (when md-items-size is
* not specified), or angular.noop otherwise.
*/
this.unwatchItemSize_ = angular.noop;
/**
* Presently rendered blocks by repeat index.
* @type {Object<number, !VirtualRepeatController.Block}
*/
this.blocks = {};
/** @type {Array<!VirtualRepeatController.Block>} A pool of presently unused blocks. */
this.pooledBlocks = [];
}
/**
* An object representing a repeated item.
* @typedef {{element: !jqLite, new: boolean, scope: !angular.Scope}}
*/
VirtualRepeatController.Block;
/**
* Called at startup by the md-virtual-repeat postLink function.
* @param {!VirtualRepeatContainerController} container The container's controller.
* @param {!Function} transclude The repeated element's bound transclude function.
* @param {string} repeatName The left hand side of the repeat expression, indicating
* the name for each item in the array.
* @param {!Function} repeatListExpression A compiled expression based on the right hand side
* of the repeat expression. Points to the array to repeat over.
* @param {string|undefined} extraName The optional extra repeatName.
*/
VirtualRepeatController.prototype.link_ =
function(container, transclude, repeatName, repeatListExpression, extraName) {
this.container = container;
this.transclude = transclude;
this.repeatName = repeatName;
this.rawRepeatListExpression = repeatListExpression;
this.extraName = extraName;
this.sized = false;
this.repeatListExpression = angular.bind(this, this.repeatListExpression_);
this.container.register(this);
};
/** @private Attempts to set itemSize by measuring a repeated element in the dom */
VirtualRepeatController.prototype.readItemSize_ = function() {
if (this.itemSize) {
// itemSize was successfully read in a different asynchronous call.
return;
}
this.items = this.repeatListExpression(this.$scope);
this.parentNode = this.$element[0].parentNode;
var block = this.getBlock_(0);
if (!block.element[0].parentNode) {
this.parentNode.appendChild(block.element[0]);
}
this.itemSize = block.element[0][
this.container.isHorizontal() ? 'offsetWidth' : 'offsetHeight'] || null;
this.blocks[0] = block;
this.poolBlock_(0);
if (this.itemSize) {
this.containerUpdated();
}
};
/**
* Returns the user-specified repeat list, transforming it into an array-like
* object in the case of infinite scroll/dynamic load mode.
* @param {!angular.Scope} The scope.
* @return {!Array|!Object} An array or array-like object for iteration.
*/
VirtualRepeatController.prototype.repeatListExpression_ = function(scope) {
var repeatList = this.rawRepeatListExpression(scope);
if (this.onDemand && repeatList) {
var virtualList = new VirtualRepeatModelArrayLike(repeatList);
virtualList.$$includeIndexes(this.newStartIndex, this.newVisibleEnd);
return virtualList;
} else {
return repeatList;
}
};
/**
* Called by the container. Informs us that the containers scroll or size has
* changed.
*/
VirtualRepeatController.prototype.containerUpdated = function() {
// If itemSize is unknown, attempt to measure it.
if (!this.itemSize) {
this.unwatchItemSize_ = this.$scope.$watchCollection(
this.repeatListExpression,
angular.bind(this, function(items) {
if (items && items.length) {
this.$$rAF(angular.bind(this, this.readItemSize_));
}
}));
if (!this.$scope.$root.$$phase) this.$scope.$digest();
return;
} else if (!this.sized) {
this.items = this.repeatListExpression(this.$scope);
}
if (!this.sized) {
this.unwatchItemSize_();
this.sized = true;
this.$scope.$watchCollection(this.repeatListExpression,
angular.bind(this, function(items, oldItems) {
if (!this.isVirtualRepeatUpdating_) {
this.virtualRepeatUpdate_(items, oldItems);
}
}));
}
this.updateIndexes_();
if (this.newStartIndex !== this.startIndex ||
this.newEndIndex !== this.endIndex ||
this.container.getScrollOffset() > this.container.getScrollSize()) {
if (this.items instanceof VirtualRepeatModelArrayLike) {
this.items.$$includeIndexes(this.newStartIndex, this.newEndIndex);
}
this.virtualRepeatUpdate_(this.items, this.items);
}
};
/**
* Called by the container. Returns the size of a single repeated item.
* @return {?number} Size of a repeated item.
*/
VirtualRepeatController.prototype.getItemSize = function() {
return this.itemSize;
};
/**
* Updates the order and visible offset of repeated blocks in response to scrolling
* or items updates.
* @private
*/
VirtualRepeatController.prototype.virtualRepeatUpdate_ = function(items, oldItems) {
this.isVirtualRepeatUpdating_ = true;
var itemsLength = items && items.length || 0;
var lengthChanged = false;
// If the number of items shrank, scroll up to the top.
if (this.items && itemsLength < this.items.length && this.container.getScrollOffset() !== 0) {
this.items = items;
this.container.resetScroll();
return;
}
if (itemsLength !== this.itemsLength) {
lengthChanged = true;
this.itemsLength = itemsLength;
}
this.items = items;
if (items !== oldItems || lengthChanged) {
this.updateIndexes_();
}
this.parentNode = this.$element[0].parentNode;
if (lengthChanged) {
this.container.setScrollSize(itemsLength * this.itemSize);
}
if (this.isFirstRender) {
this.isFirstRender = false;
var startIndex = this.$attrs.mdStartIndex ?
this.$scope.$eval(this.$attrs.mdStartIndex) :
this.container.topIndex;
this.container.scrollToIndex(startIndex);
}
// Detach and pool any blocks that are no longer in the viewport.
Object.keys(this.blocks).forEach(function(blockIndex) {
var index = parseInt(blockIndex, 10);
if (index < this.newStartIndex || index >= this.newEndIndex) {
this.poolBlock_(index);
}
}, this);
// Add needed blocks.
// For performance reasons, temporarily block browser url checks as we digest
// the restored block scopes ($$checkUrlChange reads window.location to
// check for changes and trigger route change, etc, which we don't need when
// trying to scroll at 60fps).
this.$browser.$$checkUrlChange = angular.noop;
var i, block,
newStartBlocks = [],
newEndBlocks = [];
// Collect blocks at the top.
for (i = this.newStartIndex; i < this.newEndIndex && this.blocks[i] == null; i++) {
block = this.getBlock_(i);
this.updateBlock_(block, i);
newStartBlocks.push(block);
}
// Update blocks that are already rendered.
for (; this.blocks[i] != null; i++) {
this.updateBlock_(this.blocks[i], i);
}
var maxIndex = i - 1;
// Collect blocks at the end.
for (; i < this.newEndIndex; i++) {
block = this.getBlock_(i);
this.updateBlock_(block, i);
newEndBlocks.push(block);
}
// Attach collected blocks to the document.
if (newStartBlocks.length) {
this.parentNode.insertBefore(
this.domFragmentFromBlocks_(newStartBlocks),
this.$element[0].nextSibling);
}
if (newEndBlocks.length) {
this.parentNode.insertBefore(
this.domFragmentFromBlocks_(newEndBlocks),
this.blocks[maxIndex] && this.blocks[maxIndex].element[0].nextSibling);
}
// Restore $$checkUrlChange.
this.$browser.$$checkUrlChange = this.browserCheckUrlChange;
this.startIndex = this.newStartIndex;
this.endIndex = this.newEndIndex;
this.isVirtualRepeatUpdating_ = false;
};
/**
* @param {number} index Where the block is to be in the repeated list.
* @return {!VirtualRepeatController.Block} A new or pooled block to place at the specified index.
* @private
*/
VirtualRepeatController.prototype.getBlock_ = function(index) {
if (this.pooledBlocks.length) {
return this.pooledBlocks.pop();
}
var block;
this.transclude(angular.bind(this, function(clone, scope) {
block = {
element: clone,
new: true,
scope: scope
};
this.updateScope_(scope, index);
this.parentNode.appendChild(clone[0]);
}));
return block;
};
/**
* Updates and if not in a digest cycle, digests the specified block's scope to the data
* at the specified index.
* @param {!VirtualRepeatController.Block} block The block whose scope should be updated.
* @param {number} index The index to set.
* @private
*/
VirtualRepeatController.prototype.updateBlock_ = function(block, index) {
this.blocks[index] = block;
if (!block.new &&
(block.scope.$index === index && block.scope[this.repeatName] === this.items[index])) {
return;
}
block.new = false;
// Update and digest the block's scope.
this.updateScope_(block.scope, index);
// Perform digest before reattaching the block.
// Any resulting synchronous dom mutations should be much faster as a result.
// This might break some directives, but I'm going to try it for now.
if (!this.$scope.$root.$$phase) {
block.scope.$digest();
}
};
/**
* Updates scope to the data at the specified index.
* @param {!angular.Scope} scope The scope which should be updated.
* @param {number} index The index to set.
* @private
*/
VirtualRepeatController.prototype.updateScope_ = function(scope, index) {
scope.$index = index;
scope[this.repeatName] = this.items && this.items[index];
if (this.extraName) scope[this.extraName(this.$scope)] = this.items[index];
};
/**
* Pools the block at the specified index (Pulls its element out of the dom and stores it).
* @param {number} index The index at which the block to pool is stored.
* @private
*/
VirtualRepeatController.prototype.poolBlock_ = function(index) {
this.pooledBlocks.push(this.blocks[index]);
this.parentNode.removeChild(this.blocks[index].element[0]);
delete this.blocks[index];
};
/**
* Produces a dom fragment containing the elements from the list of blocks.
* @param {!Array<!VirtualRepeatController.Block>} blocks The blocks whose elements
* should be added to the document fragment.
* @return {DocumentFragment}
* @private
*/
VirtualRepeatController.prototype.domFragmentFromBlocks_ = function(blocks) {
var fragment = this.$document[0].createDocumentFragment();
blocks.forEach(function(block) {
fragment.appendChild(block.element[0]);
});
return fragment;
};
/**
* Updates start and end indexes based on length of repeated items and container size.
* @private
*/
VirtualRepeatController.prototype.updateIndexes_ = function() {
var itemsLength = this.items ? this.items.length : 0;
var containerLength = Math.ceil(this.container.getSize() / this.itemSize);
this.newStartIndex = Math.max(0, Math.min(
itemsLength - containerLength,
Math.floor(this.container.getScrollOffset() / this.itemSize)));
this.newVisibleEnd = this.newStartIndex + containerLength + NUM_EXTRA;
this.newEndIndex = Math.min(itemsLength, this.newVisibleEnd);
this.newStartIndex = Math.max(0, this.newStartIndex - NUM_EXTRA);
};
/**
* This VirtualRepeatModelArrayLike class enforces the interface requirements
* for infinite scrolling within a mdVirtualRepeatContainer. An object with this
* interface must implement the following interface with two (2) methods:
*
* getItemAtIndex: function(index) -> item at that index or null if it is not yet
* loaded (It should start downloading the item in that case).
*
* getLength: function() -> number The data legnth to which the repeater container
* should be sized. Ideally, when the count is known, this method should return it.
* Otherwise, return a higher number than the currently loaded items to produce an
* infinite-scroll behavior.
*
* @usage
* <hljs lang="html">
* <md-virtual-repeat-container md-orient-horizontal>
* <div md-virtual-repeat="i in items" md-on-demand>
* Hello {{i}}!
* </div>
* </md-virtual-repeat-container>
* </hljs>
*
*/
function VirtualRepeatModelArrayLike(model) {
if (!angular.isFunction(model.getItemAtIndex) ||
!angular.isFunction(model.getLength)) {
throw Error('When md-on-demand is enabled, the Object passed to md-virtual-repeat must implement ' +
'functions getItemAtIndex() and getLength() ');
}
this.model = model;
}
VirtualRepeatModelArrayLike.prototype.$$includeIndexes = function(start, end) {
for (var i = start; i < end; i++) {
if (!this.hasOwnProperty(i)) {
this[i] = this.model.getItemAtIndex(i);
}
}
this.length = this.model.getLength();
};
function abstractMethod() {
throw Error('Non-overridden abstract method called.');
}
|
/*jslint white: true*/
var tests = [
'text', 'json'
];
for (var file in window.__karma__.files) {
if (window.__karma__.files.hasOwnProperty(file)) {
if (/[sS]pec\.js$/.test(file)) {
tests.push(file);
}
}
}
// hack to make jed (the i18n library that Jupyter uses) happy.
document.nbjs_translations = {
'domain': 'nbjs',
'locale_data':
{
'nbjs': {
'': {
'domain': 'nbjs'
}
}
}
};
// hack to spoof createReactClass, needed by a Jupyter component we aren't testing.
window.createReactClass = () => {};
requirejs.config({
baseUrl: '/narrative/static/',
paths: {
moment: 'components/moment/moment',
codemirror: 'components/codemirror',
bootstraptour: 'components/bootstrap-tour/build/js/bootstrap-tour.min',
bootstrap: 'ext_components/bootstrap/dist/js/bootstrap.min',
testUtil: '../../test/unit/testUtil',
bluebird: 'ext_components/bluebird/js/browser/bluebird.min',
jed: 'components/jed/jed',
custom: 'kbase/custom'
},
map: {
'*': {
'jquery-ui': 'jqueryui',
},
},
deps: tests,
shim: {
jquery: {
deps: [],
exports: 'jquery'
},
bootstraptour: {
deps: ['bootstrap'],
exports: 'Tour'
},
bootstrap: {
deps: ['jquery'],
exports: 'Bootstrap'
},
},
callback: function() {
require(['testUtil'], function(TestUtil) {
TestUtil.make().then(function() {
window.__karma__.start();
});
}, function (error) {
console.error('Failed to open TestUtil file.');
console.error(error);
throw error;
});
}
});
|
'use strict';
/* http://docs.angularjs.org/guide/dev_guide.e2e-testing */
describe('Visit the Home Page', function () {
beforeEach(function () {
browser().navigateTo('../../app/index.html');
});
it('should see the root page', function() {
expect(browser().location().url()).toBe("");
});
}); |
const mongoose = require('mongoose');
let productSchema = mongoose.Schema({
name: {type: 'string', required: 'true'},
priority : {type: 'number', required: 'true'},
quantity : {type: 'number', required: 'true'},
status : {type: 'string', required: 'true'},
});
let Product = mongoose.model('Product', productSchema);
module.exports = Product; |
import hoistStatics from 'hoist-non-react-statics';
import React from 'react';
import { Redirect } from 'react-router-dom';
import AuthService from "./AuthService";
function withAuth(Component) {
const auth = new AuthService();
function C(props) {
if (!auth.loggedIn()) {
return <Redirect to="/login" />
}
return <Component {...props} auth={auth} />
}
C.displayName = `withAuth(${Component.displayName || Component.name})`;
return hoistStatics(C, Component);
}
export default withAuth;
|
var results = angular.module('results', []);
results.controller('resultsController', ['$scope', 'Ballot', 'User', 'socket', function($scope, Ballot, User, socket){
var ctrl = this;
var ballot = Ballot.getBallot();
ctrl.username = User.getUser();
ctrl.topic = ballot.topic;
ctrl.options = ballot.options;
ctrl.tally = ballot.results;
ctrl.voters = ballot.voters;
ctrl.isOwner = User.isOwner;
ctrl.roomcode = ballot.roomcode;
ctrl.done = ballot.done;
ctrl.hasVoted = User.hasVoted();
ctrl.endVote = function(roomcode){
socket.emit('endVote', ballot);
Ballot.endVote(roomcode);
};
socket.emit('newVote', ballot);
socket.on('newVote', function(data){
ctrl.topic = data.topic;
ctrl.options = data.options;
ctrl.tally = data.results;
ctrl.voters = data.voters;
});
socket.on('endVote', function(data){
ctrl.done = true;
});
}]);
|
/*
* This class will get the mint data and return the correct values.
*/
var exec = require('child_process').exec;
var Energy = require('../models/energy');
var Logins = require('../models/logins');
var $ = require('jquery');
var _ = require('underscore');
var ElectricityCommand = function(app) {
this.app = app;
}
ElectricityCommand.prototype.addProgram = function(program) {
var that = this;
program
.command('electricity')
.description('fetches electricity information from texas smart meter')
.option("-n, --numberofdays [number]", "number of days to fetch data for. Default: 30")
.option("-d --lastdate [MM/DD/YYYY]", "date to end with")
.action(function(options) {
that.exec(options);
});
}
ElectricityCommand.prototype.exec = function(options) {
var days = options.numberofdays || 30;
var endDate = new Date();
if(options.lastdate) endDate = new Date(options.lastdate);
this.buildCommand(Number(days), endDate);
}
ElectricityCommand.prototype.buildCommand = function(numberOfDays, endDate) {
var eData = this;
var dir = __dirname.replace(/ /gi,"\\ ");
var startDate = new Date(endDate);
startDate.setDate(startDate.getDate()-numberOfDays);
Logins.getLoginDataForKey("electricity", function(error, loginData) {
if(error || loginData == null) {
eData.errorOut(error || "Could not find any electricity login data");
return;
}
var command = dir + "/mintdataextractor/phantomjs/bin/phantomjs "; //use the mint.com phantomjs, this should be changed to use a centralized phantomjs @todo!
command += dir + "/smartmeterdataextractor/smartmeter.js ";
command += '"monthly" ';
command += '"'+loginData.username+'" ';
command += '"'+loginData.password+'" ';
command += '"'+eData.outputDate(startDate)+'" ';
command += '"'+eData.outputDate(endDate)+'"';
exec(command, _.bind(eData.didExecuteCommand, eData));
});
}
ElectricityCommand.prototype.didExecuteCommand = function(error, stdout, stderr) {
if(error) {
this.errorOut(error);
return;
}
var s = String(stdout).replace(/\n/gi, '').match(/\-\-\-start payload\-\-\-(.*)\-\-\-end payload\-\-\-/);
if(s == null) {
this.errorOut("Could not login: " + stdout);
return;
}
if(s != null && s.length > 1) {
var data = JSON.parse(s[1]);
if(data instanceof Array) {
this.insertIntoDB(data);
}
} else {
this.errorOut("Could not get data");
}
}
ElectricityCommand.prototype.insertIntoDB = function(dbData) {
//put all of these in a array
this.insert(dbData, 0, this.insert);
}
ElectricityCommand.prototype.insert = function(insertData, index, next) {
if(index >= insertData.length) {
console.log("Finished");
process.exit(code=0);
return;
}
var data = insertData[index];
var date = new Date(data.date);
Energy.update({date:date}, {
date:date,
endreading:data.endreading,
startreading:data.startreading,
wattage:data.wattage
}, {upsert:true}, function(error) {
if(error) {
console.log(error);
}
next(insertData, index+1, next);
});
}
ElectricityCommand.prototype.errorOut = function(error) {
console.log(error);
process.exit(code=0);
}
ElectricityCommand.prototype.outputDate = function(date)
{
var m = date.getMonth()+1;
if(String(m).length < 2) m = "0" + m;
var d = date.getDate();
if(String(d).length < 2) d = "0" + d;
return m + "/" + d + "/" + date.getFullYear();
}
module.exports = ElectricityCommand;
|
import _ from 'lodash';
import ExtractTextPlugin from 'extract-text-webpack-plugin';
export default (config, options) => {
if (options.docs) {
let jsLoader = '';
let cssSourceMap = options.development ? '?sourceMap' : '';
config = _.extend({}, config, {
entry: {
bundle: './client.js'
},
output: {
filename: '[name].js',
path: './built/assets',
publicPath: '/assets/'
},
externals: undefined,
resolve: {
extensions: ['', '.js', '.json']
},
module: {
noParse: /babel-core\/browser/,
loaders: config.module.loaders
.map(value => {
if (/\.js\/$/.test(value.test.toString())) {
jsLoader = value.loader;
return _.extend({}, value, {
loader: jsLoader + '!client'
});
}
return value;
})
.concat([
{ test: /\.css/, loader: ExtractTextPlugin.extract('style', `css${cssSourceMap}`) },
{ test: /\.less$/, loader: ExtractTextPlugin.extract('style', `css${cssSourceMap}!less${cssSourceMap}`) },
{ test: /\.json$/, loader: 'json' },
{ test: /\.jpe?g$|\.gif$|\.png|\.ico$/, loader: 'file?name=[name].[ext]' },
{ test: /\.eot$|\.ttf$|\.svg$|\.woff2?$/, loader: 'file?name=[name].[ext]' }
])
},
plugins: config.plugins.concat([
new ExtractTextPlugin('[name].css')
])
});
return config;
}
return config;
};
|
/**
* Created by Sweets823 on 2016/6/23.
*/
(function () {
'use strict';
angular
.module('sysApp.demo')
.controller("demoController", demoController)
demoController.$inject = ['$scope','$timeout','$log','$q'];
function demoController($scope,$timeout,$log,$q){
var vm = $scope.vm = {};
$log.info("----------demoController,生成成功-----")
vm.title = "这是Demo页面"
}
})(); |
import React, { Component, PropTypes } from 'react';
export default class Checkbox extends Component {
handleChange(e) {
const { onChange, checked } = this.props;
onChange(e.target.checked);
}
render() {
const { text, checked } = this.props;
return (
<div className="checkbox-container">
{text}
<label className="switch">
<input onChange={(e) => this.handleChange(e)}
type="checkbox"
defaultChecked={checked}
ref="checkbox" />
<div className="slider round" />
</label>
</div>
);
}
}
Checkbox.propTypes = {
text: PropTypes.string.isRequired,
checked: PropTypes.bool.isRequired,
onChange: PropTypes.func.isRequired
};
|
import * as mutations from "src/store/mutations";
describe('mutations.js', () => {
it('should set products', () => {
checkSet('products', mutations.setProducts);
});
it('should set categories', () => {
checkSet('categories', mutations.setCategories);
});
it('should set packs', () => {
checkSet('packs', mutations.setPacks);
});
it('should set product types', () => {
checkSet('productTypes', mutations.setProductTypes);
});
it('should set product logs', () => {
checkSet('productLogs', mutations.setProductLogs);
});
it('should set menu items', () => {
checkSet('menuItems', mutations.setMenuItems);
});
function checkSet(property, method) {
const state = {};
const items = [
{item: 'item 1'},
{item: 'item 2'},
{item: 'item 3'}
];
method(state, items);
expect(state).to.eql({
[property]: items
});
}
});
|
describe("JsonBloomfilter.BitArray", function() {
describe("#initialize", function() {
it("should require a size", function() {
expect(function(){new JsonBloomfilter.BitArray()}).toThrow("Missing argument: size")
});
it("should take an optional bit field", function() {
field = [0,0,0,2];
ba = new JsonBloomfilter.BitArray(100, field);
expect(ba.field).toBe(field);
});
it("should create the right size field", function() {
ba = new JsonBloomfilter.BitArray(100);
expect(ba.field.length).toBe(4);
});
});
describe("#add", function() {
it("should set the bit to 1", function() {
ba = new JsonBloomfilter.BitArray(10);
ba.add(9);
expect(ba.toString()).toBe("0000000001");
});
it("should throw an error on out of bound", function() {
ba = new JsonBloomfilter.BitArray(10);
ba.add(9);
expect(function(){ba.add(10);}).toThrow("BitArray index out of bounds");
});
});
describe("#remove", function() {
it("should set the bit to 0", function() {
ba = new JsonBloomfilter.BitArray(10);
ba.add(9);
ba.remove(9);
expect(ba.toString()).toBe("0000000000");
});
it("should throw an error on out of bound", function() {
ba = new JsonBloomfilter.BitArray(10);
expect(function(){ba.remove(10);}).toThrow("BitArray index out of bounds");
});
});
describe("#get", function() {
it("should return the bit set", function() {
ba = new JsonBloomfilter.BitArray(10);
ba.add(9);
expect(ba.get(9)).toBe(1);
expect(ba.get(8)).toBe(0);
});
it("should throw an error on out of bound", function() {
ba = new JsonBloomfilter.BitArray(10);
expect(function(){ba.get(10);}).toThrow("BitArray index out of bounds");
});
});
describe("#toString", function() {
it("should output the bit string", function() {
ba = new JsonBloomfilter.BitArray(10);
ba.add(3);
ba.add(9);
expect(ba.toString()).toBe("0001000001");
});
});
}); |
'use strict';
module.exports = app => {
const { STRING, DATE } = app.Sequelize;
const SITE_NAME = {
WEAPP: 'WEAPP',
WECHAT: 'WECHAT',
WEIBO: 'WEIBO',
};
const SocialOauth = app.model.define('social_oauth', {
site: {
type: STRING(32),
defaultValue: SITE_NAME.WEAPP,
},
site_uid: STRING(255),
unionid: STRING(255),
site_uname: STRING(255),
access_token: STRING(255),
refresh_token: STRING(255),
expire_date: DATE,
}, {
indexes: [
{
fields: ['site_uid'],
},
{
fields: ['unionid'],
},
],
classMethods: {
associate() {
SocialOauth.belongsTo(app.model.User);
},
},
});
return SocialOauth;
};
|
import crypto from 'crypto';
/**
* Transform a string in camelCase style
*
* @param {String} string string to transform
* @return {String} transformed string
*/
export const camelCase = function(string) {
return string
.split('_')
.map((word, i) => {
if (i === 0) {
return word.toLowerCase();
}
return word.charAt(0) + word.slice(1).toLowerCase();
})
.join('');
};
export const avatar = function (email) {
if (!email) {
return '';
}
email = crypto.createHash('md5').update(email).digest('hex');
return `http://www.gravatar.com/avatar/${email}?s=92`;
};
|
// Your card and deque factory code should be loaded into the browser before this file
// by the main.html container file.
// At this point, both makeCard and makeDeque should be defined.
// 2b:
// make a deque instance to store a full deck of cards:
var deckOfCards = makeDeque(makeCard.fullSet);
function compareByAscendingCardSuit(a,b) {
if (a.suit() > b.suit()) return 1;
if (a.suit() < b.suit()) return -1;
//suits are equal; compare by rank
if (a.rank() > b.rank()) return 1;
if (a.rank() < b.rank()) return -1;
return 0;
}
deckOfCards.sort(compareByAscendingCardSuit);
deckOfCards.cut();
assert(deckOfCards.top().name() === 'King of Diamonds', 'Failed King of Diamonds test');
function compareByCardName(a,b) {
if (a.name() > b.name()) return 1;
if (a.name() < b.name()) return -1;
return 0;
}
deckOfCards.sort(compareByCardName);
assert(deckOfCards.bottom().name() === 'Ace of Clubs', 'Failed Ace of Clubs test');
assert(deckOfCards.top().name() === 'Two of Spades', 'Failed Two of Spades test');
// 2c:
// make a deque instance to store student names:
var people = [
'Anastasia','Chad','David','Elijah','Elizabeth','Emi',
'Greg','Harrison','Louise','Matt','Molly','Natalie',
'Sarah','Stephen','Tim','Wendy'];
var deckOfNames= makeDeque(people);
function compareBySecondLetter(strA,strB) {
return (strA[1]>strB[1]) ? 1 : -1;
}
deckOfNames.sort(compareBySecondLetter);
var theFinalName = 'Stephen'; //whoever is last via that sort
assert(deckOfNames.top() === theFinalName, 'Failed name test');
// 2d:
/*
// Example of bad way:
function compareByRandom(a,b) {
return (Math.random()-.5);
}
makeDeque.shuffle = function () {
this.array.sort(compareByRandom);
}
*/
// Good way: first add a deque.shuffle() method in your factory, then...
var shuffledDeck = makeDeque(makeCard.fullSet);
shuffledDeck.shuffle();
var ids = shuffledDeck.map(function(card){
return card.id;
});
console.log(ids);
var names = shuffledDeck.map(function(card) {
return card.name();
});
console.log(names);
// 2f: see full makeDeque version in deque-solution.js
|
define(function(require, exports, module){
/*
* webui popover plugin - v1.1.3
* A lightWeight popover plugin with jquery ,enchance the popover plugin of bootstrap with some awesome new features. It works well with bootstrap ,but bootstrap is not necessary!
* https://github.com/sandywalker/webui-popover
*
* Made by Sandy Duan
* Under MIT License
*/
;
(function($, window, document, undefined) {
'use strict';
// Create the defaults once
var pluginName = 'webuiPopover';
var pluginClass = 'webui-popover';
var pluginType = 'webui.popover';
var defaults = {
placement: 'auto',
width: 'auto',
height: 'auto',
trigger: 'click',
style: '',
delay: {
show: null,
hide: null
},
async: {
before: null, //function(that, xhr){}
success: null //function(that, xhr){}
},
cache: true,
multi: false,
arrow: true,
title: '',
content: '',
closeable: false,
padding: true,
url: '',
type: 'html',
constrains: null,
animation: null,
template: '<div class="webui-popover">' +
'<div class="arrow"></div>' +
'<div class="webui-popover-inner">' +
'<a href="#" class="close">x</a>' +
'<h3 class="webui-popover-title"></h3>' +
'<div class="webui-popover-content"><i class="icon-refresh"></i> <p> </p></div>' +
'</div>' +
'</div>',
backdrop: false,
dismissible: true,
onShow: null,
onHide: null
};
var popovers = [];
var backdrop = $('<div class="webui-popover-backdrop"></div>');
var _globalIdSeed = 0;
var $document = $(document);
// The actual plugin constructor
function WebuiPopover(element, options) {
this.$element = $(element);
if (options) {
if ($.type(options.delay) === 'string' || $.type(options.delay) === 'number') {
options.delay = {
show: options.delay,
hide: options.delay
}; // bc break fix
}
}
this.options = $.extend({}, defaults, options);
this._defaults = defaults;
this._name = pluginName;
this._targetclick = false;
this.init();
popovers.push(this.$element);
}
WebuiPopover.prototype = {
//init webui popover
init: function() {
//init the event handlers
if (this.getTrigger() === 'click') {
this.$element.off('click').on('click', $.proxy(this.toggle, this));
} else if (this.getTrigger() === 'hover') {
this.$element
.off('mouseenter mouseleave click')
.on('mouseenter', $.proxy(this.mouseenterHandler, this))
.on('mouseleave', $.proxy(this.mouseleaveHandler, this));
// .on('click', function(e) {
// e.stopPropagation();
// });
}
this._poped = false;
this._inited = true;
this._opened = false;
this._idSeed = _globalIdSeed;
if (this.options.backdrop) {
backdrop.appendTo(document.body).hide();
}
_globalIdSeed++;
},
/* api methods and actions */
destroy: function() {
var index = -1;
for (var i = 0; i < popovers.length; i++) {
if (popovers[i] === this.$element) {
index = i;
break;
}
}
popovers.splice(index, 1);
this.hide();
this.$element.data('plugin_' + pluginName, null);
if (this.getTrigger() === 'click') {
this.$element.off('click');
} else if (this.getTrigger() === 'hover') {
this.$element.off('mouseenter mouseleave');
}
if (this.$target) {
this.$target.remove();
}
},
hide: function(event) {
if (!this._opened) {
return;
}
if (event) {
event.preventDefault();
event.stopPropagation();
}
if (this.xhr) {
this.xhr.abort();
this.xhr = null;
}
var e = $.Event('hide.' + pluginType);
this.$element.trigger(e);
if (this.$target) {
this.$target.removeClass('in').hide();
}
if (this.options.backdrop) {
backdrop.hide();
}
this._opened = false;
this.$element.trigger('hidden.' + pluginType);
if (this.options.onShow) {
this.options.onShow(this.$target);
}
},
toggle: function(e) {
if (e) {
e.preventDefault();
e.stopPropagation();
}
this[this.getTarget().hasClass('in') ? 'hide' : 'show']();
},
hideAll: function() {
for (var i = 0; i < popovers.length; i++) {
popovers[i].webuiPopover('hide');
}
$document.trigger('hiddenAll.' + pluginType);
},
/*core method ,show popover */
show: function() {
var
$target = this.getTarget().removeClass().addClass(pluginClass).addClass(this._customTargetClass);
if (!this.options.multi) {
this.hideAll();
}
if (this._opened) {
return;
}
// use cache by default, if not cache setted , reInit the contents
if (!this.getCache() || !this._poped || this.content === '') {
this.content = '';
this.setTitle(this.getTitle());
if (!this.options.closeable) {
$target.find('.close').off('click').remove();
}
if (!this.isAsync()) {
this.setContent(this.getContent());
} else {
this.setContentASync(this.options.content);
this.displayContent();
return;
}
$target.show();
}
this.displayContent();
if (this.options.onShow) {
this.options.onShow($target);
}
this.bindBodyEvents();
if (this.options.backdrop) {
backdrop.show();
}
this._opened = true;
},
displayContent: function() {
var
//element postion
elementPos = this.getElementPosition(),
//target postion
$target = this.getTarget().removeClass().addClass(pluginClass).addClass(this._customTargetClass),
//target content
$targetContent = this.getContentElement(),
//target Width
targetWidth = $target[0].offsetWidth,
//target Height
targetHeight = $target[0].offsetHeight,
//placement
placement = 'bottom',
e = $.Event('show.' + pluginType);
//if (this.hasContent()){
this.$element.trigger(e);
//}
if (this.options.width !== 'auto') {
$target.width(this.options.width);
}
if (this.options.height !== 'auto') {
$targetContent.height(this.options.height);
}
//init the popover and insert into the document body
if (!this.options.arrow) {
$target.find('.arrow').remove();
}
$target.detach().css({
top: -2000,
left: -2000,
display: 'block'
});
if (this.getAnimation()) {
$target.addClass(this.getAnimation());
}
$target.appendTo(document.body);
targetWidth = $target[0].offsetWidth;
targetHeight = $target[0].offsetHeight;
placement = this.getPlacement(elementPos);
this.initTargetEvents();
var postionInfo = this.getTargetPositin(elementPos, placement, targetWidth, targetHeight);
this.$target.css(postionInfo.position).addClass(placement).addClass('in');
if (this.options.type === 'iframe') {
var $iframe = $target.find('iframe');
$iframe.width($target.width()).height($iframe.parent().height());
}
if (this.options.style) {
this.$target.addClass(pluginClass + '-' + this.options.style);
}
if (!this.options.padding) {
$targetContent.css('height', $targetContent.outerHeight());
this.$target.addClass('webui-no-padding');
}
if (!this.options.arrow) {
this.$target.css({
'margin': 0
});
}
if (this.options.arrow) {
var $arrow = this.$target.find('.arrow');
$arrow.removeAttr('style');
if (postionInfo.arrowOffset) {
$arrow.css(postionInfo.arrowOffset);
}
}
this._poped = true;
this.$element.trigger('shown.' + pluginType);
},
isTargetLoaded: function() {
return this.getTarget().find('i.glyphicon-refresh').length === 0;
},
/*getter setters */
getTriggerElement: function() {
return this.$element;
},
getTarget: function() {
if (!this.$target) {
var id = pluginName + this._idSeed;
this.$target = $(this.options.template)
.attr('id', id)
.data('trigger-element', this.getTriggerElement());
this._customTargetClass = this.$target.attr('class') !== pluginClass ? this.$target.attr('class') : null;
this.getTriggerElement().attr('data-target', id);
}
return this.$target;
},
getTitleElement: function() {
return this.getTarget().find('.' + pluginClass + '-title');
},
getContentElement: function() {
return this.getTarget().find('.' + pluginClass + '-content');
},
getTitle: function() {
return this.$element.attr('data-title') || this.options.title || this.$element.attr('title');
},
getUrl: function() {
return this.$element.attr('data-url') || this.options.url;
},
getCache: function() {
var dataAttr = this.$element.attr('data-cache');
if (typeof(dataAttr) !== 'undefined') {
switch (dataAttr.toLowerCase()) {
case 'true':
case 'yes':
case '1':
return true;
case 'false':
case 'no':
case '0':
return false;
}
}
return this.options.cache;
},
getTrigger: function() {
return this.$element.attr('data-trigger') || this.options.trigger;
},
getDelayShow: function() {
var dataAttr = this.$element.attr('data-delay-show');
if (typeof(dataAttr) !== 'undefined') {
return dataAttr;
}
return this.options.delay.show === 0 ? 0 : this.options.delay.show || 100;
},
getHideDelay: function() {
var dataAttr = this.$element.attr('data-delay-hide');
if (typeof(dataAttr) !== 'undefined') {
return dataAttr;
}
return this.options.delay.hide === 0 ? 0 : this.options.delay.hide || 100;
},
getConstrains: function() {
var dataAttr = this.$element.attr('data-contrains');
if (typeof(dataAttr) !== 'undefined') {
return dataAttr;
}
return this.options.constrains;
},
getAnimation: function() {
var dataAttr = this.$element.attr('data-animation');
return dataAttr || this.options.animation;
},
setTitle: function(title) {
var $titleEl = this.getTitleElement();
if (title) {
$titleEl.html(title);
} else {
$titleEl.remove();
}
},
hasContent: function() {
return this.getContent();
},
getContent: function() {
if (this.getUrl()) {
if (this.options.type === 'iframe') {
this.content = $('<iframe frameborder="0"></iframe>').attr('src', this.getUrl());
}
} else if (!this.content) {
var content = '';
if ($.isFunction(this.options.content)) {
content = this.options.content.apply(this.$element[0], arguments);
} else {
content = this.options.content;
}
this.content = this.$element.attr('data-content') || content;
}
return this.content;
},
setContent: function(content) {
var $target = this.getTarget();
this.getContentElement().html(content);
this.$target = $target;
},
isAsync: function() {
return this.options.type === 'async';
},
setContentASync: function(content) {
var that = this;
this.xhr = $.ajax({
url: this.getUrl(),
type: 'GET',
cache: this.getCache(),
beforeSend: function(xhr) {
if (that.options.async.before) {
that.options.async.before(that, xhr);
}
},
success: function(data) {
that.bindBodyEvents();
if (content && $.isFunction(content)) {
that.content = content.apply(that.$element[0], [data]);
} else {
that.content = data;
}
that.setContent(that.content);
var $targetContent = that.getContentElement();
$targetContent.removeAttr('style');
that.displayContent();
if (that.options.async.success) {
that.options.async.success(that, data);
}
this.xhr = null;
}
});
},
bindBodyEvents: function() {
if (this.options.dismissible) {
$('body').off('keyup.webui-popover').on('keyup.webui-popover', $.proxy(this.escapeHandler, this));
$('body').off('click.webui-popover').on('click.webui-popover', $.proxy(this.bodyClickHandler, this));
}
},
/* event handlers */
mouseenterHandler: function() {
var self = this;
if (self._timeout) {
clearTimeout(self._timeout);
}
self._enterTimeout = setTimeout(function() {
if (!self.getTarget().is(':visible')) {
self.show();
}
}, this.getDelayShow());
},
mouseleaveHandler: function() {
var self = this;
clearTimeout(self._enterTimeout);
//key point, set the _timeout then use clearTimeout when mouse leave
self._timeout = setTimeout(function() {
self.hide();
}, this.getHideDelay());
},
escapeHandler: function(e) {
if (e.keyCode === 27) {
this.hideAll();
}
},
bodyClickHandler: function() {
if (this.getTrigger() === 'click') {
if (this._targetclick) {
this._targetclick = false;
} else {
this.hideAll();
}
}
},
targetClickHandler: function() {
this._targetclick = true;
},
//reset and init the target events;
initTargetEvents: function() {
if (this.getTrigger() === 'hover') {
this.$target
.off('mouseenter mouseleave')
.on('mouseenter', $.proxy(this.mouseenterHandler, this))
.on('mouseleave', $.proxy(this.mouseleaveHandler, this));
}
this.$target.find('.close').off('click').on('click', $.proxy(this.hide, this));
this.$target.off('click.webui-popover').on('click.webui-popover', $.proxy(this.targetClickHandler, this));
},
/* utils methods */
//caculate placement of the popover
getPlacement: function(pos) {
var
placement,
de = document.documentElement,
db = document.body,
clientWidth = de.clientWidth,
clientHeight = de.clientHeight,
scrollTop = Math.max(db.scrollTop, de.scrollTop),
scrollLeft = Math.max(db.scrollLeft, de.scrollLeft),
pageX = Math.max(0, pos.left - scrollLeft),
pageY = Math.max(0, pos.top - scrollTop);
//arrowSize = 20;
console.log(scrollTop);
//if placement equals auto，caculate the placement by element information;
if (typeof(this.options.placement) === 'function') {
placement = this.options.placement.call(this, this.getTarget()[0], this.$element[0]);
} else {
placement = this.$element.data('placement') || this.options.placement;
}
if (placement === 'auto') {
var constrainsH = this.getConstrains() === 'horizontal',
constrainsV = this.getConstrains() === 'vertical';
if (pageX < clientWidth / 3) {
if (pageY < clientHeight / 3) {
placement = constrainsH ? 'right-bottom' : 'bottom-right';
} else if (pageY < clientHeight * 2 / 3) {
if (constrainsV) {
placement = pageY <= clientHeight / 2 ? 'bottom-right' : 'top-right';
} else {
placement = 'right';
}
} else {
placement = constrainsH ? 'right-top' : 'top-right';
}
//placement= pageY>targetHeight+arrowSize?'top-right':'bottom-right';
} else if (pageX < clientWidth * 2 / 3) {
if (pageY < clientHeight / 3) {
if (constrainsH) {
placement = pageX <= clientWidth / 2 ? 'right-bottom' : 'left-bottom';
} else {
placement = 'bottom';
}
} else if (pageY < clientHeight * 2 / 3) {
if (constrainsH) {
placement = pageX <= clientWidth / 2 ? 'right' : 'left';
} else {
placement = pageY <= clientHeight / 2 ? 'bottom' : 'top';
}
} else {
if (constrainsH) {
placement = pageX <= clientWidth / 2 ? 'right-top' : 'left-top';
} else {
placement = 'top';
}
}
} else {
//placement = pageY>targetHeight+arrowSize?'top-left':'bottom-left';
if (pageY < clientHeight / 3) {
placement = constrainsH ? 'left-bottom' : 'bottom-left';
} else if (pageY < clientHeight * 2 / 3) {
if (constrainsV) {
placement = pageY <= clientHeight / 2 ? 'bottom-left' : 'top-left';
} else {
placement = 'left';
}
} else {
placement = constrainsH ? 'left-top' : 'top-left';
}
}
} else if (placement === 'auto-top') {
if (pageX < clientWidth / 3) {
placement = 'top-right';
} else if (pageX < clientHeight * 2 / 3) {
placement = 'top';
} else {
placement = 'top-left';
}
} else if (placement === 'auto-bottom') {
if (pageX < clientWidth / 3) {
placement = 'bottom-right';
} else if (pageX < clientHeight * 2 / 3) {
placement = 'bottom';
} else {
placement = 'bottom-left';
}
} else if (placement === 'auto-left') {
if (pageY < clientHeight / 3) {
placement = 'left-top';
} else if (pageY < clientHeight * 2 / 3) {
placement = 'left';
} else {
placement = 'left-bottom';
}
} else if (placement === 'auto-right') {
if (pageY < clientHeight / 3) {
placement = 'right-top';
} else if (pageY < clientHeight * 2 / 3) {
placement = 'right';
} else {
placement = 'right-bottom';
}
}
return placement;
},
getElementPosition: function() {
return $.extend({}, this.$element.offset(), {
width: this.$element[0].offsetWidth,
height: this.$element[0].offsetHeight
});
},
getTargetPositin: function(elementPos, placement, targetWidth, targetHeight) {
var pos = elementPos,
elementW = this.$element.outerWidth(),
elementH = this.$element.outerHeight(),
position = {},
arrowOffset = null,
arrowSize = this.options.arrow ? 20 : 0,
fixedW = elementW < arrowSize + 10 ? arrowSize : 0,
fixedH = elementH < arrowSize + 10 ? arrowSize : 0;
switch (placement) {
case 'bottom':
position = {
top: pos.top + pos.height,
left: pos.left + pos.width / 2 - targetWidth / 2
};
break;
case 'top':
position = {
top: pos.top - targetHeight - 15,
left: pos.left + pos.width / 2 - targetWidth / 2
};
break;
case 'left':
position = {
top: pos.top + pos.height / 2 - targetHeight / 2,
left: pos.left - targetWidth
};
break;
case 'right':
position = {
top: pos.top + pos.height / 2 - targetHeight / 2,
left: pos.left + pos.width
};
break;
case 'top-right':
position = {
top: pos.top - targetHeight - 15,
left: pos.left - fixedW
};
arrowOffset = {
left: Math.min(elementW, targetWidth) / 2 + fixedW
};
break;
case 'top-left':
position = {
top: pos.top - targetHeight,
left: pos.left - targetWidth + pos.width + fixedW
};
arrowOffset = {
left: targetWidth - Math.min(elementW, targetWidth) / 2 - fixedW
};
break;
case 'bottom-right':
position = {
top: pos.top + pos.height,
left: pos.left - fixedW
};
arrowOffset = {
left: Math.min(elementW, targetWidth) / 2 + fixedW
};
break;
case 'bottom-left':
position = {
top: pos.top + pos.height,
left: pos.left - targetWidth + pos.width + fixedW
};
arrowOffset = {
left: targetWidth - Math.min(elementW, targetWidth) / 2 - fixedW
};
break;
case 'right-top':
position = {
top: pos.top - targetHeight + pos.height + fixedH,
left: pos.left + pos.width
};
arrowOffset = {
top: targetHeight - Math.min(elementH, targetHeight) / 2 - fixedH
};
break;
case 'right-bottom':
position = {
top: pos.top - fixedH,
left: pos.left + pos.width
};
arrowOffset = {
top: Math.min(elementH, targetHeight) / 2 + fixedH
};
break;
case 'left-top':
position = {
top: pos.top - targetHeight + pos.height + fixedH,
left: pos.left - targetWidth
};
arrowOffset = {
top: targetHeight - Math.min(elementH, targetHeight) / 2 - fixedH
};
break;
case 'left-bottom':
position = {
top: pos.top - fixedH,
left: pos.left - targetWidth
};
arrowOffset = {
top: Math.min(elementH, targetHeight) / 2 + fixedH
};
break;
}
return {
position: position,
arrowOffset: arrowOffset
};
}
};
$.fn[pluginName] = function(options, noInit) {
var results = [];
var $result = this.each(function() {
var webuiPopover = $.data(this, 'plugin_' + pluginName);
if (!webuiPopover) {
if (!options) {
webuiPopover = new WebuiPopover(this, null);
} else if (typeof options === 'string') {
if (options !== 'destroy') {
if (!noInit) {
webuiPopover = new WebuiPopover(this, null);
results.push(webuiPopover[options]());
}
}
} else if (typeof options === 'object') {
webuiPopover = new WebuiPopover(this, options);
}
$.data(this, 'plugin_' + pluginName, webuiPopover);
} else {
if (options === 'destroy') {
webuiPopover.destroy();
} else if (typeof options === 'string') {
results.push(webuiPopover[options]());
}
}
});
return (results.length) ? results : $result;
};
})(jQuery, window, document);
});
|
exports.buildBreadcrumb = (nodes, selector, onClick) => {
window.requestAnimationFrame(() => {
const breadcrumb = document.createDocumentFragment();
nodes.forEach((node, idx) => {
const domNode = document.createElement("a");
domNode.className = "breadcrumb-item";
domNode.addEventListener("click", ev => {
ev.preventDefault();
onClick(node);
});
domNode.innerHTML = node.data.name;
breadcrumb.appendChild(domNode);
// Don't add a separator for the last breadcrumb item.
if (idx !== nodes.length - 1) {
const separator = document.createElement("i");
separator.className = "breadcrumb-separator ion-android-arrow-dropright";
breadcrumb.appendChild(separator);
}
});
const parent = document.querySelector(selector);
parent.innerHTML = "";
parent.appendChild(breadcrumb);
});
};
|
describe('User Stories', function() {
var plane;
var airport;
var weather;
describe('under normal conditions', function() {
beforeEach(function() {
weather = new Weather();
airport = new Airport(weather);
plane = new Plane();
spyOn(Math, 'random').and.returnValue(0);
});
// As an air traffic controller
// So I can get passengers to a destination
// I want to instruct a plane to land at an airport and confirm that it has landed
it('plane is instructed to land', function() {
airport.landPlane(plane);
expect(airport.landedPlanes).toContain(plane);
});
it('plane is in the airport after being instructed to land', function() {
airport.landPlane(plane);
expect(plane.isInAirport).toBe(true);
});
// As an air traffic controller
// So I can get passengers on the way to their destination
// I want to instruct a plane to take off from an airport and confirm that it is no longer in the airport
it('plane is instructed to take off', function() {
airport.landPlane(plane);
airport.instructTakeOff(plane);
expect(airport.landedPlane).not.toContain(plane);
});
it('plane is no longer in the airport after being instructed to take off', function() {
airport.instructTakeOff(plane);
expect(plane.isInAirport).toBe(false);
});
// As an air traffic controller
// To ensure safety
// I want to prevent landing when the airport is full
it('airport prevents landing when the airport is full', function() {
airport.landPlane(plane);
expect(function(){airport.landPlane(plane);}).toThrow(new Error("No planes can land as airport is full"));
});
});
describe('under stormy conditions', function() {
beforeEach(function() {
weather = new Weather();
airport = new Airport(weather);
plane = new Plane();
spyOn(Math, 'random').and.returnValue(1);
});
// As an air traffic controller
// To ensure safety
// I want to prevent takeoff when weather is stormy
it('airport prevents takeoff', function() {
expect(function(){airport.instructTakeOff(plane);}).toThrow(new Error("No planes can take off as it is stormy"));
});
// As an air traffic controller
// To ensure safety
// I want to prevent landing when weather is stormy
it('airport prevents the plane from landing', function() {
for(i=0; i<5; i++) {
airport.landPlane(plane);
}
expect(function(){airport.landPlane(plane);}).toThrow(new Error("No planes can land as it is stormy"));
});
});
});
|
/**
* created by Tomas Kulhanek on 4/11/17.
*/
//import {HttpClient} from 'aurelia-http-client';
import {ProjectApi} from "../components/projectapi";
import {EventAggregator} from 'aurelia-event-aggregator';
import {SelectedFile} from '../filepicker/messages';
import {bindable} from 'aurelia-framework';
import {Filepanel} from '../filepicker/filepanel';
export class Uploaddirpanel extends Filepanel {
static inject = [EventAggregator, ProjectApi];
@bindable panelid;
constructor(ea, pa) {
super(ea,pa)
}
selectFile(file){
//console.log("filepanel tableid:"+this.panelid);
if (!file.size || (file.size.endsWith && file.size.endsWith('DIR'))) this.changefolder(file.name);
}
selectThisDir() {
//console.log("selected:"+this.currentdir);
//publish only if the currentdir is set (metadata exists)
if (this.currentdir)
this.ea.publish(new SelectedFile(this.currentdir, this.panelid));
/*let myfile= {};
myfile.name = this.path;
this.pa.getPublicWebDav()
.then(data => {
let mypath = data.signed_url;
mypath+= this.path.startsWith('/')?this.path.slice(1):this.path;
let mydir = {};
mydir.webdavuri = mypath;
this.ea.publish(new SelectedFile(mydir, this.panelid));
});*/
}
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import a11y from 'react-a11y';
import App from './App';
import './index.css';
a11y(React);
ReactDOM.render(<App />, document.getElementById('root'));
|
import test from 'ava';
import nightmare from 'nightmare';
import cleanstyle from '../../helpers/cleanstyle';
import common from '../../helpers/common';
const runner = nightmare({
show : false
});
let tagName = 'quote';
let docUrl = common.getE2eDocUrl(tagName);
let basicDemo = `[name="开始"] mor-${tagName}`;
let context = {
tagName,
basicDemo,
common
};
test.serial('basic style', async t => {
const result = await runner
.goto(docUrl)
.wait(basicDemo)
.evaluate(
eval(`(${common.e2eBasicFnString})`),
context
);
t.plan(1);
cleanstyle(result.style);
t.snapshot(result);
});
test.serial('color', async t => {
const result = await runner
.goto(docUrl)
.wait(basicDemo)
.evaluate(
eval(`(${common.e2eStatementFnString})`),
context,
'color',
[
'color',
'border-left-color'
]
);
t.plan(2);
t.snapshot(result);
t.is(JSON.stringify(result.color['light-blue']), JSON.stringify(result.default));
});
|
'use strict';
/**
* @ngdoc overview
* @name memoappUiApp
* @description
* # memoappUiApp
*
* Main module of the application.
*/
angular
.module('memoappUiApp', [
'ngAnimate',
'ngCookies',
'ngResource',
'ngRoute',
'ngSanitize',
'ngTouch',
'ui.bootstrap'
])
.config(['$routeProvider', function ($routeProvider) {
$routeProvider
.when('/', {
templateUrl: 'views/main.html',
controller: 'MainCtrl'
})
.when('/about', {
templateUrl: 'views/about.html',
controller: 'AboutCtrl'
})
.otherwise({
redirectTo: '/'
});
}]);
|
/*
* grunt-ssh
* https://github.com/andrewrjones/grunt-ssh
*
* Copyright (c) 2013 Andrew Jones
* Licensed under the MIT license.
*/
// TODO: use passphrase
// TODO: unit tests
module.exports = function (grunt) {
'use strict';
grunt.util = grunt.util || grunt.utils;
grunt.registerMultiTask('sshexec', 'Executes a shell command on a remote machine', function () {
var utillib = require('./lib/util').init(grunt);
var Connection = require('ssh2');
var c = new Connection();
var done = this.async();
var commands = this.data.command;
if( typeof commands === "function" ){
commands = [commands()];
}else if( typeof commands === "string"){
commands = [commands];
}
var options = this.options({
config: false,
host: false,
username: false,
password: false,
agent: "",
agentForward: false,
port: utillib.port,
proxy: {
port: utillib.port
},
ignoreErrors: false,
minimatch: {},
pty: {},
suppressRemoteErrors: false,
callback: function() {}
});
grunt.verbose.writeflags(options, 'Raw Options');
function setOption(optionName) {
var option;
if ((!options[optionName]) && (option = grunt.option(optionName))) {
options[optionName] = option;
}
}
setOption('config');
if (options.config && grunt.util._(options.config).isString()) {
this.requiresConfig(['sshconfig', options.config]);
var configOptions = grunt.config.get(['sshconfig', options.config]);
options = grunt.util._.extend(options, configOptions);
}
setOption('username');
setOption('password');
setOption('passphrase');
grunt.verbose.writeflags(options, 'Options');
c.on('connect', function () {
grunt.verbose.writeln('Connection :: connect');
});
c.on('ready', function () {
grunt.verbose.writeln('Connection :: ready');
execCommand();
});
c.on('error', function (err) {
grunt.fail.warn('Connection :: error :: ' + err);
});
c.on('debug', function (message) {
grunt.log.debug('Connection :: debug :: ' + message);
});
c.on('end', function () {
grunt.verbose.writeln('Connection :: end');
});
c.on('close', function (had_error) {
grunt.verbose.writeln('Connection :: close');
grunt.verbose.writeln('finishing task');
done();
});
function execCommand() {
if (commands.length === 0) {
c.end();
} else {
var command = commands.shift();
grunt.verbose.writeln('Executing :: ' + command);
c.exec(command, options, function (err, stream) {
if (err) {
throw err;
}
var out;
stream.on('data', function (data, extended) {
out = String(data);
if (extended === 'stderr') {
if (!options.suppressRemoteErrors) {
grunt.log.warn(out);
}
else {
grunt.verbose.warn(out);
}
} else {
grunt.log.write(out);
}
});
stream.on('end', function () {
grunt.verbose.writeln('Stream :: EOF');
if (out && typeof options.callback === "function") {
options.callback(out.trim());
}
});
stream.on('exit', function () {
grunt.verbose.writeln('Stream :: exit');
});
stream.on('close', function (code, signal) {
grunt.verbose.writeln('Stream :: close :: code: ' + code + ', signal: ' + signal);
if (!options.ignoreErrors && code !== 0) {
grunt.fail.warn('Error executing task ' + command);
c.end();
} else {
execCommand();
}
});
});
}
}
var connectionOptions = utillib.parseConnectionOptions(options);
if (options.proxy.host) {
var proxyConnectionOptions = utillib.parseConnectionOptions(options.proxy);
var proxyConnection = new Connection();
proxyConnection.on('connect', function () {
grunt.verbose.writeln('Proxy connection :: connect');
});
proxyConnection.on('error', function (err) {
grunt.fail.warn('Proxy connection :: error :: ' + err);
});
proxyConnection.on('ready', function() {
grunt.verbose.writeln('Proxy connection :: ready');
proxyConnection.exec('nc ' + connectionOptions.host + ' ' + connectionOptions.port, function(err, stream) {
if (err) {
proxyConnection.end();
throw err;
}
connectionOptions.sock = stream;
c.connect(connectionOptions);
});
});
proxyConnection.connect(proxyConnectionOptions);
}
else {
c.connect(connectionOptions);
}
});
};
|
$(function() {
document.onkeydown = function(e) {
var ev = document.all ? window.event : e;
if (ev.keyCode == 13) {
$('#search').click()
}
}
$('#search').click(function() {
if ($('#key').val() == '') {
$('.input-group').addClass('has-error');
} else {
window.location = '/search/' + encodeURIComponent($('#key').val())
}
});
$('#gotop').hide();
$('#gotop').click(function() {
$('html,body').animate({
scrollTop: '0px'
}, 800)
});
$(window).bind('scroll', function() {
var scrollTop = $(window).scrollTop();
if (scrollTop > 100) $('#gotop').show();
else $('#gotop').hide()
})
});
function changeLanguage(lang) {
var date = new Date();
var expireDays = 9999999;
date.setTime(date.getTime()+expireDays*24*3600*1000);
document.cookie = "lang="+lang+";path=/; expires="+date.toGMTString();
window.location.reload();
}
|
"use strict"
var xdTesting = require('./index')
var AddressOptions = require('./addressOptions')
var CommandAnalyzer = require('./commandAnalyzer')
var WebdriverIOMultiBrowser = require('webdriverio/lib/multibrowser')
var q = require('q')
var Flow = require('./flow/flow')
var Checkpoint = require('./flow/checkpoint')
var AbortedWaitError = require('./abortedWaitError')
var abortWait = false
/**
* @constructor
* @extends {Multibrowser}
*/
function MultiDevice(options) {
// Call parent class constructor
WebdriverIOMultiBrowser.call(this)
/**
* @type {Object.<string, Device>}
*/
this.options = options
}
// Inherit from WebdriverIOMultiBrowser
MultiDevice.prototype = Object.create(WebdriverIOMultiBrowser.prototype)
/**
* Modifier for multi instance.
* @param {AddressOptions} [addressOptions]
* @param {Flow} [flow]
* @returns {Function} - Modify or add functionality for the given client
* @override
*/
MultiDevice.prototype.getModifier = function (addressOptions, flow) {
var multiDevice = this
var deviceIds = Object.keys(this.instances)
addressOptions = addressOptions || new AddressOptions()
return function (client) {
// Call parent method.
let parentModifier = WebdriverIOMultiBrowser.prototype.getModifier.call(multiDevice)
client = parentModifier.call(multiDevice, client)
// Add additional functionality
// TODO add custom `select` return xdTesting.remote()
var _next = client.next
/**
* Distribute commands to multiple device instances.
* Used to select matching devices in implicit context.
* Based on webdriverio/lib/multibrowser.js, getModifier(), client.next
* @returns {Q.Promise}
*/
client.next = function () {
let self = this
let args = Array.prototype.slice.apply(arguments)
let stack = args.pop()
let fnName = args.pop()
/**
* no need for actual function here
*/
args.shift()
/**
* flush promise bucket
*/
multiDevice.promiseBucket = []
return this.lastPromise.done(function () {
let usedDeviceIds = []
let intermediatePromise = null
let fnArgs = args[0]
// Intercept the command and execute it only on matching devices if:
// - Command uses implicit/any device selection context
// - Command uses element selector
let command = new CommandAnalyzer(fnName, fnArgs)
if (addressOptions.implicit || addressOptions.any) {
let selector = command.selector
if (command.requiresTwoElementSelectors()) {
throw new Error('The command "' + fnName + '" with more than one element selectors is not ' +
'supported in implicit device selection context yet', 'ImplicitDeviceSelectionError')
}
if (command.acceptsElementSelector() && command.hasSelectorArgument()) {
// Determine matching devices, use promise for async call
intermediatePromise = q
.all(deviceIds
.map(id => multiDevice.instances[id])
.map(device => device.isVisible(selector).then(visible => {
if (visible && !(addressOptions.any && usedDeviceIds.length)) {
usedDeviceIds.push(device.options.id)
}
}))
.map(device => device.promise)
)
.then(() => {
if (usedDeviceIds.length === 0) {
self.defer.reject(new Error('Failed to select a device with visible element "' + selector + '". No such device found.'))
}
})
}
}
// Setup default values
if (intermediatePromise === null) {
// Execute command on all devices per default
usedDeviceIds = deviceIds
// Create a promise and resolve it immediately
let intermediateDeferred = q.defer()
intermediatePromise = intermediateDeferred.promise
intermediateDeferred.resolve()
}
// After async device selection
return intermediatePromise.then(() => {
let promises = []
// Apply command function and collect promises
usedDeviceIds.forEach(id => {
let device = multiDevice.instances[id]
device = device[fnName].apply(device, fnArgs)
promises.push(device.promise)
})
let unifiedPromise = null;
if (fnName.startsWith('wait')) {
if (addressOptions.implicit || addressOptions.any) {
// In implicit or any mode, only wait for the first device to resolve
let successCount = 0
let errors = []
let success = function() {
successCount++
}
let fail = err => {
if (err instanceof AbortedWaitError) {
// Catch our own exception and log them
errors.push(err)
} else {
// Rethrow foreign error
return q.reject(err)
}
}
// Catch all rejected promises
promises = promises.map(promise => promise.then(success).catch(fail))
// When the first command returns, signal to abort the wait command
unifiedPromise = q.any(promises)
.catch(err => {
if (err instanceof Error && err.message === "Can't get fulfillment value from any promise, all promises were rejected.") {
// Mask the q.any error and return the original promise for better error messages
return promises
} else {
return q.reject(err)
}
})
.then(() => {
abortWait = true
})
// Wait for all promises
.then(() => q.all(promises))
// Reset the wait abort
.finally(() => {
abortWait = false
})
}
}
if (unifiedPromise === null) {
unifiedPromise = q.all(promises)
}
return unifiedPromise.then(function (result) {
/**
* custom event handling since multibrowser instance
* actually never executes any command
*/
var payload = {
fnName: fnName
}
for (var i = 0; i < deviceIds.length; ++i) {
payload[deviceIds[i]] = result[i]
}
if (fnName.match(/(init|end)/)) {
self.emit(fnName, payload)
}
self.emit('result', payload)
self.defer.resolve(result)
}, function (err) {
self.emit('error', err)
self.defer.reject(err)
})
})
})
}
let _url = client.url
client.url = function(url) {
return _url.call(client, url)
.then(() => {
if (xdTesting.appFramework) {
let app = client.app()
let urlHooks = app && app.getCommandHooks instanceof Function && app.getCommandHooks().url
if (urlHooks && urlHooks.after) {
return urlHooks.after()
}
}
})
}
let _init = client.init
/**
* Custom initialization. Simulate devices by resizing browser windows.
* @return {WebdriverIO.Client}
*/
client.init = function init() {
let result = _init.call(client)
.forEach(device => {
let width = device.options.width
let height = device.options.height
if (width && height) {
return device.windowHandleSize({width: width, height: height})
}
})
if (xdTesting.baseUrl) {
result = result.url(xdTesting.baseUrl)
}
return result
}
/**
* Enable app specific support
* @return {xdmvc}
*/
client.app = function() {
if (!(xdTesting.appFramework instanceof Function)) {
let dump = JSON.stringify(xdTesting.appFramework)
if (dump === undefined) {
dump = xdTesting.appFramework
}
throw new Error('xdTesting.appFramework is not set or not valid: ' + dump)
}
return new xdTesting.appFramework(this)
}
/**
* @callback DeviceCallback
* @param {WebdriverIO.Client} device
*/
/**
* @callback DeviceIdsCallback
* @return {number|number[]}
*/
/**
* @param {string[]|string|DeviceIdsCallback} ids - A single id or an array of ids; can also be a promise
* @param {DeviceCallback} [callback] - receives the selected DeviceCollection as parameter
* @param {DeviceCallback} [complementCallback] - receives the complementary selection as parameter
* @param {AddressOptions} [newAddressOptions]
*/
client.selectById = function selectById(ids, callback, complementCallback, newAddressOptions) {
let returnSelection = typeof callback === 'undefined'
// Throw TypeError on invalid parameter types
if (!returnSelection && !(callback instanceof Function)) {
throw new TypeError("Invalid callback")
}
if (!(typeof callback === 'undefined' || callback instanceof Function || callback === null)) {
// Defined but not a function
throw new TypeError("Invalid complementCallback")
}
newAddressOptions = newAddressOptions || new AddressOptions()
let newMultiDevice = null
let newSelection = function () {
// Resolve ids callback
if (ids instanceof Function) {
ids = ids()
}
// Normalize ids to array
if (!Array.isArray(ids)) {
ids = [ids]
}
let newOptions = {}
newMultiDevice = new MultiDevice(newOptions)
ids.forEach(id => {
let instance = multiDevice.instances[id]
if (!instance) {
throw new Error('browser "' + id + '" is not defined')
}
newMultiDevice.addInstance(id, instance)
newOptions[id] = multiDevice.options[id]
})
return xdTesting.remote(newOptions, newMultiDevice.getModifier(newAddressOptions, flow), null)
}
if (returnSelection) {
// Return selection instead of using the callback
return newSelection()
// Wait for the currently issued commands before proceeding
.then(() => client.sync())
} else {
// Use the new selection as the callback parameter
let result = client.call(() => callback(newSelection()))
// Append the complement selection callback
if (complementCallback) {
let complementIds = () => deviceIds.filter(id => ids.indexOf(id) === -1)
result = result.selectById(complementIds, complementCallback)
}
return result
}
}
/**
* Wrap callback in implicit context and execute commands with element selectors only on matching devices.
* @param {DeviceCallback} callback - receives the DeviceCollection as parameter
*/
client.implicit = function implicit(callback) {
let ids = Object.keys(multiDevice.options)
return client.selectById(ids, callback, null, new AddressOptions(true))
}
/**
* Wrap callback in implicit context and execute commands with element selectors only on a single matching device.
* @param {DeviceCallback} callback - receives the DeviceCollection as parameter
*/
client.any = function any(callback) {
let ids = Object.keys(multiDevice.options)
return client.selectById(ids, callback, null, new AddressOptions(true, true))
}
/**
* @return {AddressOptions}
*/
client.getAddressingOptions = function () {
return this.then(() => addressOptions)
}
/**
* @param {string[]|string} sizes - A single size or an array of sizes
* @param {DeviceCallback} callback - receives the selected DeviceCollection as parameter
* @param {DeviceCallback} [complementCallback] - receives the complementary selection as parameter
*/
client.selectBySize = function selectBySize(sizes, callback, complementCallback) {
sizes = Array.isArray(sizes) ? sizes : [sizes]
var matchingInstanceIds = Object.keys(multiDevice.instances).filter(id => sizes.indexOf(multiDevice.options[id].size) >= 0)
return client.selectById(matchingInstanceIds, callback, complementCallback)
}
/**
* @param {string[]|string} types - A single type or an array of types
* @param {DeviceCallback} callback - receives the selected DeviceCollection as parameter
* @param {DeviceCallback} [complementCallback] - receives the complementary selection as parameter
*/
client.selectByType = function selectByType(types, callback, complementCallback) {
types = Array.isArray(types) ? types : [types]
var matchingInstanceIds = Object.keys(multiDevice.instances).filter(id => types.indexOf(multiDevice.options[id].type) >= 0)
return client.selectById(matchingInstanceIds, callback, complementCallback)
}
/**
* Select all devices matching the selector parameter and execute the callback on them.
* @param {string} selector - A css selector as used in WebdriverIO
* @param {DeviceCallback} callback - receives the selected DeviceCollection as parameter
* @param {DeviceCallback} [complementCallback] - receives the complementary selection as parameter
*/
client.selectByElement = function selectByElement(selector, callback, complementCallback) {
selector = selector || null
let matchingInstanceIds = []
return client
.forEach(device => device
.elements(selector)
.then(response => {
if (response.value.length) {
matchingInstanceIds.push(device.options.id)
}
})
)
// Provide ids per callback, otherwise the array is read before it is filled
.selectById(() => matchingInstanceIds, callback, complementCallback)
}
/**
* Select any single device and execute the callback on it.
* @param {DeviceCallback} callback - receives a single device as parameter
* @param {DeviceCallback} [complementCallback] - receives the complementary selection as parameter
*/
client.selectAny = function selectAny(callback, complementCallback) {
let ids = []
return client
.forEach(device => ids.push(device.options.id))
// Execute callback on the first device
.selectById(() => ids[0], callback, complementCallback)
}
/**
* @callback DeviceCallbackWithIndex
* @param {WebdriverIO.Client} device
* @param {number} index
*/
/**
* Execute the callback on each device.
* @param {DeviceCallbackWithIndex} callback
*/
client.forEach = (callback) => {
return client.call(function () {
let usedInstanceKeys = Object.keys(multiDevice.instances)
if (addressOptions.any) {
// Use any single device to execute the command
usedInstanceKeys = [usedInstanceKeys[0]]
}
return q.all(usedInstanceKeys.map(
(key, index) => callback(multiDevice.instances[key], index)
))
})
}
/**
* Get the number of devices.
* @returns {number}
*/
client.getCount = () => {
if (addressOptions.implicit && !addressOptions.any) {
return client.call(function() {
// Number of selected devices is determined at each command execution.
// In general the number is undefined.
return undefined;
})
} else {
let count = 0
return client.forEach(device => {
count++
}).then(() => {
return count
})
}
}
/**
* Get the used device ids.
*/
client.getDeviceIds = () => {
return client.then(() => {
return {
value: deviceIds
}
})
}
/**
* Add an error checkpoint and store the flow.
* Note: Independent of the promise chain! Wrap in .then to execute in order.
*/
client.addErrorCheckpoint = () => {
if (!(flow instanceof Flow)) {
throw new TypeError('flow is not set or of invalid type: ' + flow)
}
let store = () => {
// Store remaining captured steps in a last checkpoint
flow.deviceArray().forEach(flowDevice => {
// Create new checkpoint
flowDevice.addCheckpoint(new Checkpoint(flow.generateCheckpointId(), 'ERROR'))
})
flow.store()
}
store()
}
return client
}
}
/**
* modifier for single webdriverio instances
*/
MultiDevice.prototype.getInstanceModifier = function() {
var multiDevice = this
return function(client) {
// Call parent method.
let parentModifier = WebdriverIOMultiBrowser.prototype.getInstanceModifier.call(multiDevice)
client = parentModifier.call(multiDevice, client)
client.getAbortWait = function() {
return abortWait
}
return client;
};
};
module.exports = MultiDevice
|
// @flow
import type { Layer } from 'types/layers.types';
import i18n from 'i18next';
/**
* Sorts an array of GFW contextual layers (from either API)
*
* The sort order is slightly complex and is as follows:
* 1. Protected Areas
* 2. TCL in descending date order
* 3. All other GFW areas in alphabetical order
*
* @param {Array} layers The array of layers to sort
*/
export function sortGFWContextualLayers(layers: Array<Layer>): Array<Layer> {
// Copy layers array, we will remove from here as we sort...
const allLayers = [...layers];
let sortedLayers = [];
// Move protected area layer to the top
const protectedAreasIndex = allLayers.findIndex((layer: Layer) => {
return layer.name === 'layers.protectedAreas' || layer.id === '597b6b899c157500128c912b';
});
if (protectedAreasIndex !== -1) {
sortedLayers.push(allLayers[protectedAreasIndex]);
allLayers.splice(protectedAreasIndex, 1);
}
// Find all tree cover loss layers
const nonTreeCoverLossLayers = [];
const treeCoverLossLayers = allLayers.filter((layer: Layer) => {
const isTreeCoverLossLayer =
layer.name
?.toLowerCase?.()
.replace?.(/\s/g, '')
.includes?.('treecoverloss') === true;
// If it's a tree cover loss layer, remove it from `allLayers`
if (!isTreeCoverLossLayer) {
nonTreeCoverLossLayers.push(layer);
}
return isTreeCoverLossLayer;
});
// Can't just sort alphabetically directly because one layer
// does not have an i18n key, rather a readable name. So we will
// regex the date out of the names...
treeCoverLossLayers.sort((layerA, layerB) => {
const yearMatchesA = layerA.name?.match?.(/\d{4}/g);
const yearMatchesB = layerB.name?.match?.(/\d{4}/g);
if (yearMatchesA.length > 0 && yearMatchesB.length > 0) {
const yearA = yearMatchesA[0];
const yearB = yearMatchesB[0];
return yearA < yearB ? 1 : yearA > yearB ? -1 : 0;
} else {
// Do nothing!
return 0;
}
});
sortedLayers = sortedLayers.concat(treeCoverLossLayers);
// Sort remaining layers alphabetically by their human-readable
// name (in case we have any left over which need localising)
nonTreeCoverLossLayers.sort((layerA, layerB) => {
const nameA = i18n.t(layerA.name);
const nameB = i18n.t(layerB.name);
return nameA < nameB ? -1 : nameA > nameB ? 1 : 0;
});
sortedLayers = sortedLayers.concat(nonTreeCoverLossLayers);
return sortedLayers;
}
|
"use strict";
module.exports = function(context){
return context.be.tableDefAdapt({
name:'element_images',
title:'images for elements and isotopes',
editable:context.user.rol==='boss',
fields:[
{name:'atomic_number', title:'A#',typeName:'integer', nullable:false, },
{name:'kind' , typeName:'text' },
{name:'mass_number' , typeName:'integer', nullable:false, default:0 },
{name:'url' , typeName:'text' },
],
primaryKey:['atomic_number','mass_number','kind'],
actionNamesList:['showImg'],
allow:{showImg:true},
layout:{vertical:true}
});
}
|
import React from 'react';
import {Link} from 'react-router';
import ResumeStore from '../stores/ResumeStore'
import ResumeActions from '../actions/ResumeActions';
class Resume extends React.Component {
constructor(props) {
super(props);
this.state = ResumeStore.getState();
this.onChange = this.onChange.bind(this);
}
componentDidMount() {
ResumeStore.listen(this.onChange);
document.getElementById('name-brand').style.opacity = '';
document.getElementById('resume').className = 'current-state';
document.getElementById('technologies').className = 'nav-links';
document.getElementById('projects').className = 'nav-links';
}
componentWillUnmount() {
ResumeStore.unlisten(this.onChange);
}
onChange(state) {
document.getElementByClassName('container').classList.remove('fadeIn animated');
document.getElementByClassName('container').classList.add('fadeOut animated');
this.setState(state);
}
render() {
return (
<div className='container fadeIn animated'>
<div className='col-xs-10 col-sm-10 col-md-8 col-md-offset-2' style={{paddingBottom: '200px;'}}>
<div className="panel panel-default text-center">
<br></br>
<text className='project-title'>Under Construction, Please Check out my <a href="https://www.linkedin.com/in/jayteesanchez">Linked-In!</a></text>
<br></br>
<br></br>
</div>
</div>
</div>
)
}
}
export default Resume;
|
angular.module('DashboardModule', ['ui.router', 'toastr', 'ngResource', 'ngAnimate'])
.run(['$templateCache', function ($templateCache) {
$templateCache.put('assets/templates/toast.html',
"<div>Your template here</div>"
);
$templateCache.put('assets/templates/progressbar.html',
"<div>Your progressbar here</div>"
);
}])
//.config(function ($routeProvider, $locationProvider) {
// $routeProvider
//
// .when('/', {
// templateUrl: '/js/private/dashboard/tpl/dashboard.tpl.html',
// controller: 'DashboardController'
// })
//
// .when('/account', {
// templateUrl: '/js/private/dashboard/account/tpl/account.tpl.html',
// controller: 'AccountController'
// })
// ;
// $locationProvider.html5Mode({enabled: true, requireBase: false});
//})
.config(function ($stateProvider, $urlRouterProvider, $locationProvider) {
$stateProvider
.state('home', {
url: '/',
views: {
//'sidebar@': {templateUrl: '/js/private/tpl/sidebar.tpl.html'},
// Абсолютное позиционирование вида 'footerTwo' в корневом безымянном состоянии.
// <div ui-view='footerTwo'/> внутри index.html
// "footerTwo@" : { }
'footerTwo@': {templateUrl: '/js/private/dashboard/tpl/footerTwo.html'},
'@': {templateUrl: '/js/private/dashboard/tpl/dashboard.html'}
}
})
.state('home.dogs', {
abstract: true, // запрет на вход в этот URL, о при этом dogs отображается в цепочки урла
url: 'dogs',
template: '<ui-view/>'
})
.state('home.dogs.catalogs', {
url: '/catalogs',
views: {
'@': {
templateUrl: '/js/private/admin/catalogs/tpl/list.tpl.html',
controller: 'ListCatalogController'
},
"actionView@home.dogs.catalogs": {templateUrl: '/js/private/admin/catalogs/views/home.admin.catalogs.action.html'},
}
})
.state('home.dogs.catalog', {
url: '/catalog/:catalogId',
views: {
'@': {
templateUrl: '/js/private/admin/catalogs/tpl/show.tpl.html',
controller: 'CatalogController'
},
// Абсолютное позиционирование вида 'formView' в состоянии home.admin.catalogs.
// <div ui-view='formView'/> внутри /js/private/admin/catalog/tpl/show.tpl.html
// "formView@home.admin.catalog" : { }
"formView@home.dogs.catalog": {
templateUrl: '/js/private/admin/messages/views/min.messages.form.html',
// controller: 'EditMessageController'
},
}
})
.state('home.profile', {
url: 'profile',
views: {
'@': {
templateUrl: '/js/private/dashboard/tpl/profile.html',
controller: 'ProfileController'
}
}
})
.state('home.profile.edit', {
url: '/edit',
views: {
'@': {
templateUrl: '/js/private/dashboard/tpl/edit-profile.html',
controller: 'EditProfileController'
}
}
})
.state('home.about', {
url: 'about',
views: {
'@': {
templateUrl: '/js/private/dashboard/tpl/about.html',
controller: 'AboutController'
}
}
})
// .state('home.profile.restore', {
// url: 'restore',
// views: {
// '@': {
// templateUrl: '/js/private/dashboard/tpl/restore-profile.html',
// controller: 'RestoreProfileController'
// }
// }
// })
// .state('account', {
// url: '/account',
// templateUrl: '/js/private/dashboard/account/tpl/account.tpl.html'
// })
// .state('contact', {
// url: '/contact',
// // Будет автоматически вложен в безымянный ui-view
// // родительского шаблона. Начиная с состояния верхнего уровня,
// // шаблоном этого родительского состояния является index.html.
// templateUrl: '/js/private/contacts.html'
// })
//
// .state('contact.detail', {
// views: {
// /////////////////////////////////////////////////////
// // Относительное позиционирование //
// // позиционируется родительское состояние в ui-view//
// /////////////////////////////////////////////////////
//
// // Относительное позиционирование вида 'detail' в родительском
// // состоянии 'contacts'.
// // <div ui-view='detail'/> внутри contacts.html
// // "detail": {},
//
// // Относительное поциционирование безымянного вида в родительском
// // состояния 'contacts'.
// // <div ui-view/> внутри contacts.html
// // "": {}
//
// ////////////////////////////////////////////////////////////////////////////
// // Абсолютное позиционирование '@' //
// // Позиционирование любых видов внутри этого состояния или предшествующего //
// ////////////////////////////////////////////////////////////////////////////
//
// // Абсолютное позиционирование вида 'info' в состоянии 'contacts.detail'.
// // <div ui-view='info'/> внутри contacts.detail.html
// //"info@contacts.detail" : { }
//
// // Абсолютное позиционирование вида 'detail' в состоянии 'contacts'.
// // <div ui-view='detail'/> внутри contacts.html
// "detail@contact": {templateUrl: '/js/private/contact.detail.tpl.html'}
//
// // Абсолютное позиционирование безымянного вида в родительском
// // состоянии 'contacts'.
// // <div ui-view/> внутри contacts.html
// // "@contacts" : { }
//
// // Абсолютное позиционирование вида 'status' в корневом безымянном состоянии.
// // <div ui-view='status'/> внутри index.html
// // "status@" : { }
//
// // Абсолютное позиционирование безымянного вида в корневом безымянном состоянии.
// // <div ui-view/> внутри index.html
// // "@" : { }
// }
// // .state('route1.viewC', {
// // url: "/route1",
// // views: {
// // "viewC": { template: "route1.viewA" }
// // }
// // })
// // .state('route2', {
// // url: "/route2",
// // views: {
// // "viewA": { template: "route2.viewA" },
// // "viewB": { template: "route2.viewB" }
// // }
// // })
// })
;
})
.config(function (toastrConfig) {
angular.extend(toastrConfig, {
autoDismiss: false,
containerId: 'toast-container',
maxOpened: 0,
newestOnTop: true,
// templates: {
// toast: 'directives/toast/toast.html',
// progressbar: 'directives/progressbar/progressbar.html'
// },
positionClass: 'toast-top-right',
// positionClass: 'toast-top-left',
// positionClass: 'toast-top-full-width',
preventDuplicates: false,
preventOpenDuplicates: true,
target: 'body',
// iconClasses: {
// error: 'toast-error',
// info: 'toast-info',
// success: 'toast-success',
// warning: 'toast-warning'
// },
messageClass: 'toast-message',
titleClass: 'toast-title',
toastClass: 'toast',
// closeButton:true,
extendedTimeOut: 1000,
"showDuration": "100",
"hideDuration": "300",
"timeOut": "5000",
"progressBar": false,
});
})
; |
// Copyright (C) 2011 - Texas Instruments, Jason Kridner
//
//
var fs = require('fs');
var http = require('http');
var winston = require('winston');
var express = require('express');
var events = require('events');
var socketHandlers = require('./socket_handlers');
var serverEmitter = new events.EventEmitter();
var debug = process.env.DEBUG ? true : false;
myrequire('systemd', function() {
if(debug) winston.debug("Startup as socket-activated service under systemd not enabled");
});
exports.serverStart = function(port, directory, callback) {
if(port === undefined) {
port = (process.env.LISTEN_PID > 0) ? 'systemd' : ((process.env.PORT) ? process.env.PORT : 80);
}
if(directory === undefined) {
directory = (process.env.SERVER_DIR) ? process.env.SERVER_DIR : '/usr/share/bone101';
}
var server = mylisten(port, directory);
serverEmitter.on('newListner', addServerListener);
function addServerListener(event, listener) {
console.log('got here'); //TODO: not getting here
if(debug) winston.debug('Got request to add listener to ' + event);
var serverEvent = event.replace(/^server\$/, '');
if(serverEvent) {
if(debug) winston.debug('Adding listener to server$' + serverEvent);
server.on(serverEvent, listener);
}
}
return(serverEmitter);
};
function mylisten(port, directory) {
winston.info("Opening port " + port + " to serve up " + directory);
var app = express();
app.get('/bonescript.js', socketHandlers.socketJSReqHandler);
app.use('/bone101', express.static(directory));
app.use('/bone101/static', express.static(directory+"/static"));
app.use(express.static(directory));
var server = http.createServer(app);
socketHandlers.addSocketListeners(server, serverEmitter);
server.listen(port);
return(server);
}
function myrequire(packageName, onfail) {
var y = {};
try {
y = require(packageName);
y.exists = true;
} catch(ex) {
y.exists = false;
if(debug) winston.debug("Optional package '" + packageName + "' not loaded");
if(onfail) onfail();
}
return(y);
}
|
/**
Template Controllers
@module Routes
*/
/**
The app routes
@class App routes
@constructor
*/
// Change the URLS to use #! instead of real paths
// Iron.Location.configure({useHashPaths: true});
// Router defaults
Router.configure({
layoutTemplate: 'layout_main',
notFoundTemplate: 'layout_notFound',
yieldRegions: {
'layout_header': {to: 'header'}
, 'layout_footer': {to: 'footer'}
}
});
// ROUTES
/**
The receive route, showing the wallet overview
@method dashboard
*/
Router.route('/', {
template: 'views_borrowerQueue',
name: 'home'
});
Router.route('/borrowerQueue', {
template: 'views_borrowerQueue',
name: 'borrowerQueue'
});
Router.route('/blacklist', {
template: 'views_blacklist',
name: 'blacklist'
});
Router.route('/borrow', {
template: 'views_borrow',
name: 'borrow'
});
Router.route('/save', {
template: 'views_save',
name: 'save'
});
Router.route('/stats', {
template: 'views_stats',
name: 'stats'
});
Router.route('/networkHealth', {
template: 'views_networkHealth',
name: 'networkHealth'
});
Router.route('/myaccount', {
template: 'views_myaccount',
name: 'myaccount'
});
|
function htmlbodyHeightUpdate(){
var height3 = $(window).height();
var height1 = $('.nav').height() + 50;
var height2 = $('.main').height();
if(height2 > height3) {
$('html').height(Math.max(height1,height3,height2)+10);
$('body').height(Math.max(height1,height3,height2)+10);
} else {
$('html').height(Math.max(height1,height3,height2));
$('body').height(Math.max(height1,height3,height2));
}
}
$(document).ready(function () {
htmlbodyHeightUpdate();
$( window ).resize(function() {
htmlbodyHeightUpdate();
});
$( window ).scroll(function() {
height2 = $('.main').height();
htmlbodyHeightUpdate();
});
});
|
var fs = require('fs');
fs.readFile('./helloworld.js', encoding='utf-8', function(err, data){
if(err){
throw err;
}
console.log(data);
});
console.log('파일의 내용 : ');
|
import React from 'react';
class ToolbarGroup extends React.Component {
shouldComponentUpdate(nextProps) {
return (nextProps.children !== this.props.children);
}
render() {
return (
<section className="toolbar-group">
<h2 className="toolbar-group-title">
{this.props.label}
</h2>
{this.props.children}
</section>
);
}
}
export default ToolbarGroup;
|
import { Platform } from 'react-native';
export const HOT_COLOR = '#EE2A7B';
export const NAV_BAR_HEIGHT = 44;
export const STATUS_BAR_HEIGHT = Platform.select({ ios: 20, android: 10 });
export const INPUT_HEIGHT = 50;
export const INPUT_FONT_SIZE = 14;
export default {
mainContainer: {
flex: 1,
paddingTop: NAV_BAR_HEIGHT + STATUS_BAR_HEIGHT,
},
mainContainer__noNav: {
paddingTop: STATUS_BAR_HEIGHT,
},
mainContainer__full: {
paddingTop: 0,
},
navBarIcon: {
tintColor: HOT_COLOR,
},
navBarText: {
color: HOT_COLOR,
},
};
|
'use strict';
const calculateCacheKeyForTree = require('./calculate-cache-key-for-tree');
/*
An implementation of Addon#cacheKeyForTree that assumes the return values of
all trees is stable. This makes it easy to opt-back-in to tree caching for
addons that implement stable overrides of treeFor hooks.
@public
@method cacheKeyForStableTree
@param {String} treeType
@return {String} cacheKey
*/
module.exports = function cacheKeyForStableTree(treeType) {
let addon = this;
return calculateCacheKeyForTree(treeType, addon);
};
|
module.exports = {
dynamic: undefined,
bool: 'bool',
number: 'number',
string: 'string',
object: 'object',
list: 'list'
}; |
search_result['4422']=["topic_0000000000000A84_events--.html","CompanyService Events",""]; |
/**
* Handlebars Mech Helpers
* Copyright (c) 2015 Alexander Brandt
* Based on Assemble Handlebars Helpers Copyright (c) 2013 Jon Schlinkert, Brian Woodward, contributors
* Licensed under the MIT License (MIT).
*/
'use strict';
// Node.js
var path = require('path');
// node_modules
//var Handlebars = require('../helpers/helpers').Handlebars;
// The module to be exported
var helpers = {
/**
* {{embed}}
*
* Embeds code from an external file as preformatted
* text. The first parameter requires a path to the file
* you want to embed. There second second optional parameter
* is for specifying (forcing) syntax highlighting for
* language of choice.
*
* @syntax:
* {{ embed [file] [lang] }}
* @usage:
* {{embed 'path/to/file.js'}} or
* {{embed 'path/to/file.hbs' 'html'}}
*/
ecm: function (hardpoints_ecm) {
if (hardpoints_ecm === 0) {
return '<i class="fa fa-remove"></i>';
} else {
return '<i class="fa fa-check"></i>';
}
},
jj: function(jump_jets) {
if (jump_jets === 0) {
return '<i class="fa fa-remove"></i>';
} else {
return jump_jets;
}
},
ams: function(ams) {
if (ams === 0) {
return '<i class="fa fa-remove"></i>';
} else {
return ams;
}
}
};
// Export helpers
module.exports.register = function (Handlebars, options) {
options = options || {};
for (var helper in helpers) {
if (helpers.hasOwnProperty(helper)) {
Handlebars.registerHelper(helper, helpers[helper]);
}
}
};
|
function productOfNumbers(nums) {
let x = Number(nums[0]);
let y = Number(nums[1]);
let z = Number(nums[2]);
let sum = x * y * z ;
if (sum >= 0){
return "Positive";
}
else
{
return "Negative";
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.