text
stringlengths 2
6.14k
|
|---|
/**
* Copyright 2017 The AMP HTML Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS-IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import * as lolex from 'lolex';
import {createElementWithAttributes} from '../../../../src/dom';
import {
getAmpAdRenderOutsideViewport,
incrementLoadingAds,
is3pThrottled,
waitFor3pThrottle,
} from '../concurrent-load';
import {installTimerService} from '../../../../src/service/timer-impl';
import {macroTask} from '../../../../testing/yield';
describes.realWin('concurrent-load', {}, env => {
describe('getAmpAdRenderOutsideViewport', () => {
it('should return null if ' +
'data-loading-strategy attribute does not exist', () => {
const element = env.win.document.createElement('amp-ad');
expect(getAmpAdRenderOutsideViewport(element)).to.be.null;
});
it('should respect data-loading-strategy attribute', () => {
// data-loading-strategy=prefer-viewability-over-views is 1.25
verifyGetAmpAdRenderOutsideViewport(
'prefer-viewability-over-views', 1.25);
// data-loading-strategy attribute with no value is 1.25
verifyGetAmpAdRenderOutsideViewport('', 1.25);
verifyGetAmpAdRenderOutsideViewport('0', 0);
verifyGetAmpAdRenderOutsideViewport('0.256', 0.256);
verifyGetAmpAdRenderOutsideViewport('1.25', 1.25);
verifyGetAmpAdRenderOutsideViewport('3.0', 3);
expectGetAmpAdRenderOutsideViewportThrow('3.1');
expectGetAmpAdRenderOutsideViewportThrow('-0.1');
expectGetAmpAdRenderOutsideViewportThrow('invalid-value');
});
function verifyGetAmpAdRenderOutsideViewport(loadingStrategy, viewportNum) {
const element = createElementWithAttributes(env.win.document, 'amp-ad', {
'data-loading-strategy': loadingStrategy,
});
expect(getAmpAdRenderOutsideViewport(element)).to.equal(viewportNum);
}
function expectGetAmpAdRenderOutsideViewportThrow(loadingStrategy) {
const element = createElementWithAttributes(env.win.document, 'amp-ad', {
'data-loading-strategy': loadingStrategy,
});
allowConsoleError(() => {
expect(() => getAmpAdRenderOutsideViewport(element)).to.throw();
});
}
});
describe('incrementLoadingAds', () => {
let win;
let clock;
beforeEach(() => {
win = env.win;
clock = lolex.install({
target: win, toFake: ['Date', 'setTimeout', 'clearTimeout']});
installTimerService(win);
});
afterEach(() => {
clock.uninstall();
});
it('should throttle ad loading one per second', function* () {
expect(is3pThrottled(win)).to.be.false;
incrementLoadingAds(win);
expect(is3pThrottled(win)).to.be.true;
clock.tick(999);
yield macroTask();
expect(is3pThrottled(win)).to.be.true;
clock.tick(1);
yield macroTask();
expect(is3pThrottled(win)).to.be.false;
});
it('should throttle ad one a time', function* () {
expect(is3pThrottled(win)).to.be.false;
let resolver;
incrementLoadingAds(win, new Promise(res => {
resolver = res;
}));
expect(is3pThrottled(win)).to.be.true;
resolver();
yield macroTask();
expect(is3pThrottled(win)).to.be.false;
});
});
describe('waitFor3pThrottle', () => {
beforeEach(() => {
installTimerService(env.win);
});
// TODO(jeffkaufman, #13422): this test was silently failing
it.skip('should block if incremented', () => {
incrementLoadingAds(env.win);
const start = Date.now();
return waitFor3pThrottle(env.win).then(
() => expect(Date.now() - start).to.be.at.least(1000));
});
it('should not block if never incremented', () => {
const start = Date.now();
return waitFor3pThrottle(env.win).then(
() => expect(Date.now() - start).to.be.at.most(50));
});
});
});
|
/*
Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
Available via Academic Free License >= 2.1 OR the modified BSD license.
see: http://dojotoolkit.org/license for details
*/
if(!dojo._hasResource["dojox.lang.aspect.memoizer"]){
dojo._hasResource["dojox.lang.aspect.memoizer"]=true;
dojo.provide("dojox.lang.aspect.memoizer");
(function(){
var _1=dojox.lang.aspect;
var _2={around:function(_3){
var _4=_1.getContext(),_5=_4.joinPoint,_6=_4.instance,t,u,_7;
if((t=_6.__memoizerCache)&&(t=t[_5.targetName])&&(_3 in t)){
return t[_3];
}
var _7=_1.proceed.apply(null,arguments);
if(!(t=_6.__memoizerCache)){
t=_6.__memoizerCache={};
}
if(!(u=t[_5.targetName])){
u=t[_5.targetName]={};
}
return u[_3]=_7;
}};
var _8=function(_9){
return {around:function(){
var _a=_1.getContext(),_b=_a.joinPoint,_c=_a.instance,t,u,_d,_e=_9.apply(_c,arguments);
if((t=_c.__memoizerCache)&&(t=t[_b.targetName])&&(_e in t)){
return t[_e];
}
var _d=_1.proceed.apply(null,arguments);
if(!(t=_c.__memoizerCache)){
t=_c.__memoizerCache={};
}
if(!(u=t[_b.targetName])){
u=t[_b.targetName]={};
}
return u[_e]=_d;
}};
};
_1.memoizer=function(_f){
return arguments.length==0?_2:_8(_f);
};
})();
}
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/**
* @fileoverview Types for CrSettingsPrefsElement.
*/
if (CrSettingsPrefs === undefined) {
var CrSettingsPrefs = {};
/**
* The type of the event fired when prefs have been fetched and initialized.
* @const {string}
*/
CrSettingsPrefs.INITIALIZED = 'cr-settings-prefs-initialized';
/**
* Global boolean set to true when all settings have been initialized.
* @type {boolean}
*/
CrSettingsPrefs.isInitialized = false;
}
|
var searchData=
[
['blackbonedef_2eh',['BlackBoneDef.h',['../_black_bone_def_8h.html',1,'']]],
['blackbonedrv_2ec',['BlackBoneDrv.c',['../_black_bone_drv_8c.html',1,'']]],
['blackbonedrv_2eh',['BlackBoneDrv.h',['../_black_bone_drv_8h.html',1,'']]]
];
|
/**
* @file
* Modify jcarousel behaviour to set number of items on window resize.
*/
(function($) {
Drupal.debutMedia = {};
Drupal.debutMedia.setupCallback = function(carousel) {
Drupal.jcarousel.setupCarousel(carousel);
if (carousel.options.navigation) {
Drupal.jcarousel.addNavigation(carousel, carousel.options.navigation);
}
carousel.reload();
};
Drupal.debutMedia.reloadCallback = function(carousel) {
// Set the clip and container to auto width so that they will fill
// the available space.
carousel.container.css('width', 'auto');
carousel.clip.css('width', 'auto');
var clipWidth = carousel.clip.width();
var containerExtra = carousel.container.width() - carousel.clip.outerWidth(true);
// Determine the width of an item.
var itemWidth = carousel.list.find('li').first().outerWidth(true);
var numItems = Math.floor(carousel.clip.width() / itemWidth) || 1;
// Set the new scroll number.
carousel.options.scroll = numItems;
var newClipWidth = numItems * itemWidth;
var newContainerWidth = newClipWidth + containerExtra;
// Resize the clip and container.
carousel.clip.width(newClipWidth);
carousel.container.width(newContainerWidth);
};
})(jQuery);
|
/* eslint-disable */
// rename this file from _test_[name] to test_[name] to activate
// and remove above this line
QUnit.test("test: Staffing Plan", function (assert) {
let done = assert.async();
// number of asserts
assert.expect(1);
frappe.run_serially([
// insert a new Staffing Plan
() => frappe.tests.make('Staffing Plan', [
// values to be set
{key: 'value'}
]),
() => {
assert.equal(cur_frm.doc.key, 'value');
},
() => done()
]);
});
|
require('css/iconmap.css');
module.exports = {
componentIcons: {
hypothesis: 'fa fa-lightbulb-o',
'methods and measures': 'fa fa-pencil',
procedure: 'fa fa-cogs',
instrumentation: 'fa fa-flask',
data: 'fa fa-database',
analysis: 'fa fa-bar-chart',
communication: 'fa fa-comment',
other: 'fa fa-th-large',
'': 'fa fa-circle-o-notch'
},
projectIcons: {
collection: 'fa fa-cubes',
smartCollection: 'fa fa-certificate',
project: 'fa fa-cube',
registration: 'fa fa-th-list text-muted',
component: 'fa fa-th-large',
registeredComponent: 'fa fa-th-large text-muted',
link: 'fa fa-link'
},
info: 'fa fa-info-circle',
smaller: 'iconmap-smaller',
clickable: 'iconmap-clickable',
private : 'fa fa-lock'
};
|
({"preview":"แสดงตัวอย่าง"})
|
/*
YUI 3.15.0 (build 834026e)
Copyright 2014 Yahoo! Inc. All rights reserved.
Licensed under the BSD License.
http://yuilibrary.com/license/
*/
YUI.add('autocomplete-filters-accentfold', function (Y, NAME) {
/**
Provides pre-built accent-folding result matching filters for AutoComplete.
These filters are similar to the ones provided by the `autocomplete-filters`
module, but use accent-aware comparisons. For example, "resume" and "résumé"
will be considered equal when using the accent-folding filters.
@module autocomplete
@submodule autocomplete-filters-accentfold
**/
/**
@class AutoCompleteFilters
@static
**/
var AccentFold = Y.Text.AccentFold,
WordBreak = Y.Text.WordBreak,
YArray = Y.Array,
YObject = Y.Object;
Y.mix(Y.namespace('AutoCompleteFilters'), {
/**
Accent folding version of `charMatch()`.
@method charMatchFold
@param {String} query Query to match
@param {Array} results Results to filter
@return {Array} Filtered results
@static
**/
charMatchFold: function (query, results) {
if (!query) { return results; }
var queryChars = YArray.unique(AccentFold.fold(query).split(''));
return YArray.filter(results, function (result) {
var text = AccentFold.fold(result.text);
return YArray.every(queryChars, function (chr) {
return text.indexOf(chr) !== -1;
});
});
},
/**
Accent folding version of `phraseMatch()`.
@method phraseMatchFold
@param {String} query Query to match
@param {Array} results Results to filter
@return {Array} Filtered results
@static
**/
phraseMatchFold: function (query, results) {
if (!query) { return results; }
query = AccentFold.fold(query);
return YArray.filter(results, function (result) {
return AccentFold.fold(result.text).indexOf(query) !== -1;
});
},
/**
Accent folding version of `startsWith()`.
@method startsWithFold
@param {String} query Query to match
@param {Array} results Results to filter
@return {Array} Filtered results
@static
**/
startsWithFold: function (query, results) {
if (!query) { return results; }
query = AccentFold.fold(query);
return YArray.filter(results, function (result) {
return AccentFold.fold(result.text).indexOf(query) === 0;
});
},
/**
Accent folding version of `subWordMatch()`.
@method subWordMatchFold
@param {String} query Query to match
@param {Array} results Results to filter
@return {Array} Filtered results
@static
**/
subWordMatchFold: function (query, results) {
if (!query) { return results; }
var queryWords = WordBreak.getUniqueWords(AccentFold.fold(query));
return YArray.filter(results, function (result) {
var resultText = AccentFold.fold(result.text);
return YArray.every(queryWords, function (queryWord) {
return resultText.indexOf(queryWord) !== -1;
});
});
},
/**
Accent folding version of `wordMatch()`.
@method wordMatchFold
@param {String} query Query to match
@param {Array} results Results to filter
@return {Array} Filtered results
@static
**/
wordMatchFold: function (query, results) {
if (!query) { return results; }
var queryWords = WordBreak.getUniqueWords(AccentFold.fold(query));
return YArray.filter(results, function (result) {
// Convert resultWords array to a hash for fast lookup.
var resultWords = YArray.hash(WordBreak.getUniqueWords(
AccentFold.fold(result.text)));
return YArray.every(queryWords, function (word) {
return YObject.owns(resultWords, word);
});
});
}
});
}, '3.15.0', {"requires": ["array-extras", "text-accentfold", "text-wordbreak"]});
|
var Noble = require('./lib/noble');
var bindings = require('./lib/resolve-bindings')();
module.exports = new Noble(bindings);
|
// Copyright 2011 Joyent, Inc. All rights reserved.
var crypto = require('crypto');
var fs = require('fs');
var http = require('http');
var httpu = require('httpu');
var test = require('tap').test;
var uuid = require('node-uuid');
var httpSignature = require('../lib/index');
///--- Globals
var hmacKey = null;
var httpOptions = null;
var rsaPrivate = null;
var signOptions = null;
var server = null;
var socket = null;
///--- Tests
test('setup', function(t) {
rsaPrivate = fs.readFileSync(__dirname + '/rsa_private.pem', 'ascii');
t.ok(rsaPrivate);
socket = '/tmp/.' + uuid();
server = http.createServer(function(req, res) {
res.writeHead(200);
res.end();
});
server.listen(socket, function() {
hmacKey = uuid();
httpOptions = {
socketPath: socket,
path: '/',
method: 'GET',
headers: {}
};
signOptions = {
key: rsaPrivate,
keyId: 'unitTest'
};
t.end();
});
});
test('defaults', function(t) {
var req = httpu.request(httpOptions, function(res) {
t.end();
});
t.ok(httpSignature.sign(req, signOptions));
t.ok(req.getHeader('Authorization'));
console.log('> ' + req.getHeader('Authorization'));
req.end();
});
test('request line', function(t) {
var req = httpu.request(httpOptions, function(res) {
t.end();
});
var opts = {
keyId: 'unit',
key: rsaPrivate,
headers: ['date', 'request-line']
};
t.ok(httpSignature.sign(req, opts));
t.ok(req.getHeader('Authorization'));
console.log('> ' + req.getHeader('Authorization'));
req.end();
});
test('hmac', function(t) {
var req = httpu.request(httpOptions, function(res) {
t.end();
});
var opts = {
keyId: 'unit',
key: uuid(),
algorithm: 'hmac-sha1'
};
t.ok(httpSignature.sign(req, opts));
t.ok(req.getHeader('Authorization'));
console.log('> ' + req.getHeader('Authorization'));
req.end();
});
test('tear down', function(t) {
server.on('close', function() {
t.end();
});
server.close();
});
|
/* jshint -W084 */
'use strict';
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; }; })();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
var PathUtils = require('./PathUtils');
function deepSearch(route, pathname, query) {
// Check the subtree first to find the most deeply-nested match.
var childRoutes = route.childRoutes;
if (childRoutes) {
var match, childRoute;
for (var i = 0, len = childRoutes.length; i < len; ++i) {
childRoute = childRoutes[i];
if (childRoute.isDefault || childRoute.isNotFound) continue; // Check these in order later.
if (match = deepSearch(childRoute, pathname, query)) {
// A route in the subtree matched! Add this route and we're done.
match.routes.unshift(route);
return match;
}
}
}
// No child routes matched; try the default route.
var defaultRoute = route.defaultRoute;
if (defaultRoute && (params = PathUtils.extractParams(defaultRoute.path, pathname))) return new Match(pathname, params, query, [route, defaultRoute]);
// Does the "not found" route match?
var notFoundRoute = route.notFoundRoute;
if (notFoundRoute && (params = PathUtils.extractParams(notFoundRoute.path, pathname))) return new Match(pathname, params, query, [route, notFoundRoute]);
// Last attempt: check this route.
var params = PathUtils.extractParams(route.path, pathname);
if (params) return new Match(pathname, params, query, [route]);
return null;
}
var Match = (function () {
_createClass(Match, null, [{
key: 'findMatch',
/**
* Attempts to match depth-first a route in the given route's
* subtree against the given path and returns the match if it
* succeeds, null if no match can be made.
*/
value: function findMatch(routes, path) {
var pathname = PathUtils.withoutQuery(path);
var query = PathUtils.extractQuery(path);
var match = null;
for (var i = 0, len = routes.length; match == null && i < len; ++i) match = deepSearch(routes[i], pathname, query);
return match;
}
}]);
function Match(pathname, params, query, routes) {
_classCallCheck(this, Match);
this.pathname = pathname;
this.params = params;
this.query = query;
this.routes = routes;
}
return Match;
})();
module.exports = Match;
|
version https://git-lfs.github.com/spec/v1
oid sha256:b23029b4165a58f710a281bca67aae572e36f1f9a789d5a144ad574f0f77e280
size 2325
|
//! moment.js locale configuration
//! locale : Montenegrin (me)
//! author : Miodrag Nikač <miodrag@restartit.me> : https://github.com/miodragnikac
import moment from '../moment';
var translator = {
words: { //Different grammatical cases
m: ['jedan minut', 'jednog minuta'],
mm: ['minut', 'minuta', 'minuta'],
h: ['jedan sat', 'jednog sata'],
hh: ['sat', 'sata', 'sati'],
dd: ['dan', 'dana', 'dana'],
MM: ['mjesec', 'mjeseca', 'mjeseci'],
yy: ['godina', 'godine', 'godina']
},
correctGrammaticalCase: function (number, wordKey) {
return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
},
translate: function (number, withoutSuffix, key) {
var wordKey = translator.words[key];
if (key.length === 1) {
return withoutSuffix ? wordKey[0] : wordKey[1];
} else {
return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
}
}
};
export default moment.defineLocale('me', {
months: ['januar', 'februar', 'mart', 'april', 'maj', 'jun', 'jul', 'avgust', 'septembar', 'oktobar', 'novembar', 'decembar'],
monthsShort: ['jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun', 'jul', 'avg.', 'sep.', 'okt.', 'nov.', 'dec.'],
weekdays: ['nedjelja', 'ponedjeljak', 'utorak', 'srijeda', 'četvrtak', 'petak', 'subota'],
weekdaysShort: ['ned.', 'pon.', 'uto.', 'sri.', 'čet.', 'pet.', 'sub.'],
weekdaysMin: ['ne', 'po', 'ut', 'sr', 'če', 'pe', 'su'],
longDateFormat: {
LT: 'H:mm',
LTS : 'H:mm:ss',
L: 'DD. MM. YYYY',
LL: 'D. MMMM YYYY',
LLL: 'D. MMMM YYYY H:mm',
LLLL: 'dddd, D. MMMM YYYY H:mm'
},
calendar: {
sameDay: '[danas u] LT',
nextDay: '[sjutra u] LT',
nextWeek: function () {
switch (this.day()) {
case 0:
return '[u] [nedjelju] [u] LT';
case 3:
return '[u] [srijedu] [u] LT';
case 6:
return '[u] [subotu] [u] LT';
case 1:
case 2:
case 4:
case 5:
return '[u] dddd [u] LT';
}
},
lastDay : '[juče u] LT',
lastWeek : function () {
var lastWeekDays = [
'[prošle] [nedjelje] [u] LT',
'[prošlog] [ponedjeljka] [u] LT',
'[prošlog] [utorka] [u] LT',
'[prošle] [srijede] [u] LT',
'[prošlog] [četvrtka] [u] LT',
'[prošlog] [petka] [u] LT',
'[prošle] [subote] [u] LT'
];
return lastWeekDays[this.day()];
},
sameElse : 'L'
},
relativeTime : {
future : 'za %s',
past : 'prije %s',
s : 'nekoliko sekundi',
m : translator.translate,
mm : translator.translate,
h : translator.translate,
hh : translator.translate,
d : 'dan',
dd : translator.translate,
M : 'mjesec',
MM : translator.translate,
y : 'godinu',
yy : translator.translate
},
ordinalParse: /\d{1,2}\./,
ordinal : '%d.',
week : {
dow : 1, // Monday is the first day of the week.
doy : 7 // The week that contains Jan 1st is the first week of the year.
}
});
|
var keystone = require('keystone');
exports = module.exports = function(done) {
keystone.list('User').updateAll(done);
};
exports.__defer__ = true;
|
/*! React Starter Kit | MIT License | http://www.reactstarterkit.com/ */
import React, { PropTypes } from 'react';
import classNames from 'classnames';
import styles from './Navigation.less';
import withStyles from '../../decorators/withStyles';
import Link from '../../utils/Link';
@withStyles(styles)
class Navigation {
static propTypes = {
className: PropTypes.string
};
render() {
return (
<div className={classNames(this.props.className, 'Navigation')} role="navigation">
<a className="Navigation-link" href="/about" onClick={Link.handleClick}>About</a>
<a className="Navigation-link" href="/contact" onClick={Link.handleClick}>Contact</a>
<span className="Navigation-spacer"> | </span>
<a className="Navigation-link" href="/login" onClick={Link.handleClick}>Log in</a>
<span className="Navigation-spacer">or</span>
<a className="Navigation-link Navigation-link--highlight" href="/register" onClick={Link.handleClick}>Sign up</a>
</div>
);
}
}
export default Navigation;
|
function su_reset_textbox(id, d, m, e) {
if (confirm(m+"\n\n"+d)) {
document.getElementById(id).value=d;
e.className='hidden';
su_enable_unload_confirm();
}
}
function su_textbox_value_changed(e, d, l) {
if (e.value==d)
document.getElementById(l).className='hidden';
else
document.getElementById(l).className='';
}
function su_toggle_blind(id) {
if (document.getElementById(id)) {
if (document.getElementById(id).style.display=='none')
Effect.BlindDown(id);
else
Effect.BlindUp(id);
}
return false;
}
function su_enable_unload_confirm() {
window.onbeforeunload = su_confirm_unload_message;
}
function su_disable_unload_confirm() {
window.onbeforeunload = null;
}
function su_confirm_unload_message() {
return suModulesModulesL10n.unloadConfirmMessage;
}
jQuery(document).ready(function() {
jQuery('input, textarea, select', 'div.su-module').change(su_enable_unload_confirm);
jQuery('form', 'div.su-module').submit(su_disable_unload_confirm);
});
|
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
/**
* Competency rule points module.
*
* @package core
* @copyright 2017 Damyon Wiese
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
define(['core/icon_system', 'jquery', 'core/ajax', 'core/mustache', 'core/localstorage', 'core/url'],
function(IconSystem, $, Ajax, Mustache, LocalStorage, Url) {
var staticMap = null;
var fetchMap = null;
/**
* IconSystemFontawesome
*/
var IconSystemFontawesome = function() {
IconSystem.apply(this, arguments);
};
IconSystemFontawesome.prototype = Object.create(IconSystem.prototype);
/**
* Prefetch resources so later calls to renderIcon can be resolved synchronously.
*
* @method init
* @return {Promise}
*/
IconSystemFontawesome.prototype.init = function() {
var currTheme = M.cfg.theme;
if (staticMap) {
return $.when(this);
}
var map = LocalStorage.get('core_iconsystem/theme/' + currTheme + '/core/iconmap-fontawesome');
if (map) {
map = JSON.parse(map);
}
if (map) {
staticMap = map;
return $.when(this);
}
if (fetchMap === null) {
fetchMap = Ajax.call([{
methodname: 'core_output_load_fontawesome_icon_system_map',
args: {
themename: M.cfg.theme,
},
}], true, false, false, 0, M.cfg.themerev)[0];
}
return fetchMap.then(function(map) {
staticMap = {};
$.each(map, function(index, value) {
staticMap[value.component + '/' + value.pix] = value.to;
});
LocalStorage.set('core_iconsystem/theme/' + currTheme + '/core/iconmap-fontawesome', JSON.stringify(staticMap));
return this;
}.bind(this));
};
/**
* Render an icon.
*
* @param {String} key
* @param {String} component
* @param {String} title
* @param {String} template
* @return {String}
* @method renderIcon
*/
IconSystemFontawesome.prototype.renderIcon = function(key, component, title, template) {
var mappedIcon = staticMap[component + '/' + key];
var unmappedIcon = false;
if (typeof mappedIcon === "undefined") {
var url = Url.imageUrl(key, component);
unmappedIcon = {
attributes: [
{name: 'src', value: url},
{name: 'alt', value: title},
{name: 'title', value: title}
]
};
}
var context = {
key: mappedIcon,
title: title,
alt: title,
unmappedIcon: unmappedIcon
};
if (typeof title === "undefined" || title === '') {
context['aria-hidden'] = true;
}
var result = Mustache.render(template, context);
return result.trim();
};
/**
* Get the name of the template to pre-cache for this icon system.
*
* @return {String}
* @method getTemplateName
*/
IconSystemFontawesome.prototype.getTemplateName = function() {
return 'core/pix_icon_fontawesome';
};
return /** @alias module:core/icon_system_fontawesome */ IconSystemFontawesome;
});
|
// Copyright 2009 the Sputnik authors. All rights reserved.
/**
* Only Function objects implement [[HasInstance]] and can be proper ShiftExpression for the "instanceof" operator consequently
*
* @path ch11/11.8/11.8.6/S11.8.6_A6_T1.js
* @description Checking "this" case
*/
//CHECK#1
try{
({}) instanceof this;
$ERROR('#1: Only Function objects implement [[HasInstance]] and consequently can be proper ShiftExpression for The instanceof operator');
}
catch(e){
if (e instanceof TypeError !== true) {
$ERROR('#1: Only Function objects implement [[HasInstance]] and consequently can be proper ShiftExpression for The instanceof operator');
}
}
|
/// Copyright (c) 2012 Ecma International. All rights reserved.
/**
* @path ch15/15.4/15.4.4/15.4.4.16/15.4.4.16-7-c-i-14.js
* @description Array.prototype.every - element to be retrieved is own accessor property that overrides an inherited accessor property on an Array
*/
function testcase() {
function callbackfn(val, idx, obj) {
if (idx === 0) {
return val === 5;
} else {
return true;
}
}
var arr = [];
try {
Object.defineProperty(Array.prototype, "0", {
get: function () {
return 5;
},
configurable: true
});
Object.defineProperty(arr, "0", {
get: function () {
return 11;
},
configurable: true
});
return !arr.every(callbackfn);
} finally {
delete Array.prototype[0];
}
}
runTestCase(testcase);
|
/// Copyright (c) 2012 Ecma International. All rights reserved.
/**
* @path ch15/15.2/15.2.3/15.2.3.10/15.2.3.10-3-22.js
* @description Object.preventExtensions - properties can still be deleted after extensions have been prevented
*/
function testcase() {
var obj = { prop: 12 };
var preCheck = Object.isExtensible(obj);
Object.preventExtensions(obj);
delete obj.prop;
return preCheck && !obj.hasOwnProperty("prop");
}
runTestCase(testcase);
|
var Checker = require('../../../lib/checker');
var assert = require('assert');
describe('rules/require-parentheses-around-arrow-param', function() {
var checker;
beforeEach(function() {
checker = new Checker();
checker.registerDefaultRules();
checker.configure({ esnext: true, requireParenthesesAroundArrowParam: true });
});
it('should report an arrow function expression without parens', function() {
assert(checker.checkString('[1, 2].map(x => x * x);').getErrorCount() === 1);
});
it('should not report an arrow function expression with parens around a single parameter', function() {
assert(checker.checkString('[1, 2].map((x) => x * x);').isEmpty());
});
it('should not report an arrow function expression with parens around multiple parameters', function() {
assert(checker.checkString('[1, 2].map((x, y) => x * x);').isEmpty());
});
it('should not report an arrow function expression with a single rest param #1616', function() {
assert(checker.checkString('[1, 2].map((...x) => x);').isEmpty());
});
});
|
/**
* ag-grid - Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components
* @version v10.1.0
* @link http://www.ag-grid.com/
* @license MIT
*/
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var columnGroup_1 = require("./columnGroup");
var column_1 = require("./column");
var eventService_1 = require("../eventService");
var OriginalColumnGroup = (function () {
function OriginalColumnGroup(colGroupDef, groupId, padding) {
this.localEventService = new eventService_1.EventService();
this.expandable = false;
this.colGroupDef = colGroupDef;
this.groupId = groupId;
this.expanded = colGroupDef && !!colGroupDef.openByDefault;
this.padding = padding;
}
OriginalColumnGroup.prototype.isPadding = function () {
return this.padding;
};
OriginalColumnGroup.prototype.setExpanded = function (expanded) {
this.expanded = expanded;
this.localEventService.dispatchEvent(OriginalColumnGroup.EVENT_EXPANDED_CHANGED);
};
OriginalColumnGroup.prototype.isExpandable = function () {
return this.expandable;
};
OriginalColumnGroup.prototype.isExpanded = function () {
return this.expanded;
};
OriginalColumnGroup.prototype.getGroupId = function () {
return this.groupId;
};
OriginalColumnGroup.prototype.getId = function () {
return this.getGroupId();
};
OriginalColumnGroup.prototype.setChildren = function (children) {
this.children = children;
};
OriginalColumnGroup.prototype.getChildren = function () {
return this.children;
};
OriginalColumnGroup.prototype.getColGroupDef = function () {
return this.colGroupDef;
};
OriginalColumnGroup.prototype.getLeafColumns = function () {
var result = [];
this.addLeafColumns(result);
return result;
};
OriginalColumnGroup.prototype.addLeafColumns = function (leafColumns) {
this.children.forEach(function (child) {
if (child instanceof column_1.Column) {
leafColumns.push(child);
}
else if (child instanceof OriginalColumnGroup) {
child.addLeafColumns(leafColumns);
}
});
};
OriginalColumnGroup.prototype.getColumnGroupShow = function () {
if (!this.padding) {
return this.colGroupDef.columnGroupShow;
}
else {
// if this is padding we have exactly only child. we then
// take the value from the child and push it up, making
// this group 'invisible'.
return this.children[0].getColumnGroupShow();
}
};
// need to check that this group has at least one col showing when both expanded and contracted.
// if not, then we don't allow expanding and contracting on this group
OriginalColumnGroup.prototype.calculateExpandable = function () {
// want to make sure the group doesn't disappear when it's open
var atLeastOneShowingWhenOpen = false;
// want to make sure the group doesn't disappear when it's closed
var atLeastOneShowingWhenClosed = false;
// want to make sure the group has something to show / hide
var atLeastOneChangeable = false;
for (var i = 0, j = this.children.length; i < j; i++) {
var abstractColumn = this.children[i];
// if the abstractColumn is a grid generated group, there will be no colDef
var headerGroupShow = abstractColumn.getColumnGroupShow();
if (headerGroupShow === columnGroup_1.ColumnGroup.HEADER_GROUP_SHOW_OPEN) {
atLeastOneShowingWhenOpen = true;
atLeastOneChangeable = true;
}
else if (headerGroupShow === columnGroup_1.ColumnGroup.HEADER_GROUP_SHOW_CLOSED) {
atLeastOneShowingWhenClosed = true;
atLeastOneChangeable = true;
}
else {
atLeastOneShowingWhenOpen = true;
atLeastOneShowingWhenClosed = true;
}
}
this.expandable = atLeastOneShowingWhenOpen && atLeastOneShowingWhenClosed && atLeastOneChangeable;
};
OriginalColumnGroup.prototype.addEventListener = function (eventType, listener) {
this.localEventService.addEventListener(eventType, listener);
};
OriginalColumnGroup.prototype.removeEventListener = function (eventType, listener) {
this.localEventService.removeEventListener(eventType, listener);
};
return OriginalColumnGroup;
}());
OriginalColumnGroup.EVENT_EXPANDED_CHANGED = 'expandedChanged';
exports.OriginalColumnGroup = OriginalColumnGroup;
|
/**
* @license Highcharts JS v6.0.6 (2018-02-05)
* Streamgraph module
*
* (c) 2010-2017 Torstein Honsi
*
* License: www.highcharts.com/license
*/
'use strict';
(function(factory) {
if (typeof module === 'object' && module.exports) {
module.exports = factory;
} else {
factory(Highcharts);
}
}(function(Highcharts) {
(function(H) {
/**
* Streamgraph module
*
* (c) 2010-2017 Torstein Honsi
*
* License: www.highcharts.com/license
*/
var seriesType = H.seriesType;
/**
* A streamgraph is a type of stacked area graph which is displaced around a
* central axis, resulting in a flowing, organic shape.
*
* @extends {plotOptions.areaspline}
* @product highcharts highstock
* @sample {highcharts|highstock} highcharts/demo/streamgraph/
* Streamgraph
* @since 6.0.0
* @optionparent plotOptions.streamgraph
*/
seriesType('streamgraph', 'areaspline', {
fillOpacity: 1,
lineWidth: 0,
marker: {
enabled: false
},
stacking: 'stream'
// Prototype functions
}, {
negStacks: false,
/**
* Modifier function for stream stacks. It simply moves the point up or down
* in order to center the full stack vertically.
*/
streamStacker: function(pointExtremes, stack, i) {
var reversedStacks = H.pick(this.yAxis.options.reversedStacks, true);
// Y bottom value
pointExtremes[0] -= stack.total / 2;
// Y value
pointExtremes[1] -= stack.total / 2;
this.stackedYData[i] = this.index === 0 ?
pointExtremes[+reversedStacks] :
pointExtremes[+!reversedStacks];
}
});
/**
* A `streamgraph` series. If the [type](#series.streamgraph.type) option is not
* specified, it is inherited from [chart.type](#chart.type).
*
* For options that apply to multiple series, it is recommended to add
* them to the [plotOptions.series](#plotOptions.series) options structure.
* To apply to all series of this specific type, apply it to [plotOptions.
* streamgraph](#plotOptions.streamgraph).
*
* @type {Object}
* @extends series,plotOptions.streamgraph
* @excluding dataParser,dataURL
* @product highcharts highstock
* @apioption series.streamgraph
*/
/**
* An array of data points for the series. For the `streamgraph` series type,
* points can be given in the following ways:
*
* 1. An array of numerical values. In this case, the numerical values
* will be interpreted as `y` options. The `x` values will be automatically
* calculated, either starting at 0 and incremented by 1, or from `pointStart`
* and `pointInterval` given in the series options. If the axis has
* categories, these will be used. Example:
*
* ```js
* data: [0, 5, 3, 5]
* ```
*
* 2. An array of arrays with 2 values. In this case, the values correspond
* to `x,y`. If the first value is a string, it is applied as the name
* of the point, and the `x` value is inferred.
*
* ```js
* data: [
* [0, 9],
* [1, 7],
* [2, 6]
* ]
* ```
*
* 3. An array of objects with named values. The objects are point
* configuration objects as seen below. If the total number of data
* points exceeds the series' [turboThreshold](#series.area.turboThreshold),
* this option is not available.
*
* ```js
* data: [{
* x: 1,
* y: 9,
* name: "Point2",
* color: "#00FF00"
* }, {
* x: 1,
* y: 6,
* name: "Point1",
* color: "#FF00FF"
* }]
* ```
*
* @type {Array<Object|Array|Number>}
* @extends series.line.data
* @sample {highcharts} highcharts/chart/reflow-true/
* Numerical values
* @sample {highcharts} highcharts/series/data-array-of-arrays/
* Arrays of numeric x and y
* @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
* Arrays of datetime x and y
* @sample {highcharts} highcharts/series/data-array-of-name-value/
* Arrays of point.name and y
* @sample {highcharts} highcharts/series/data-array-of-objects/
* Config objects
* @product highcharts highstock
* @apioption series.streamgraph.data
*/
}(Highcharts));
}));
|
tinyMCE.addI18n('fi.fullpage_dlg',{
title:"Tiedoston asetukset",
meta_tab:"Yleinen",
appearance_tab:"Ulkoasu",
advanced_tab:"Edistynyt",
meta_props:"Meta tiedot",
langprops:"Kieli ja koodaus",
meta_title:"Otsikko",
meta_keywords:"Avainsanat",
meta_description:"Kuvaus",
meta_robots:"Robotit",
doctypes:"Dokumenttityypit",
langcode:"Kielen koodi",
langdir:"Kielen suunta",
ltr:"Vasemmalta oikealle",
rtl:"Oikealta vasemmalle",
xml_pi:"XML Ilmoitus",
encoding:"Tekstin koodaus",
appearance_bgprops:"Taustan asetukset",
appearance_marginprops:"Body marginaalit",
appearance_linkprops:"Linkkien v\u00E4rit",
appearance_textprops:"Tekstin asetukset",
bgcolor:"Taustan v\u00E4ri",
bgimage:"Taustakuva",
left_margin:"Vasen marginaali",
right_margin:"Oikea marginaali",
top_margin:"Yl\u00E4marginaali",
bottom_margin:"Alamarginaali",
text_color:"Tekstin v\u00E4ri",
font_size:"Fonttikoko",
font_face:"Fontti",
link_color:"Linkin v\u00E4ri",
hover_color:"Hover v\u00E4ri",
visited_color:"Vierailtu v\u00E4ri",
active_color:"Aktiivinen v\u00E4ri",
textcolor:"V\u00E4ri",
fontsize:"Fonttikoko",
fontface:"Fontti",
meta_index_follow:"Indeksoi ja seuraa linkkej\u00E4",
meta_index_nofollow:"Indeksoi, mutta \u00E4l\u00E4 seuraa linkkej\u00E4",
meta_noindex_follow:"\u00C4l\u00E4 indeksoi, mutta seuraa linkkej\u00E4.",
meta_noindex_nofollow:"\u00C4l\u00E4 indeksoi, \u00E4l\u00E4k\u00E4 seuraa linkkej\u00E4",
appearance_style:"Tyylitiedosto ja tyylin asetukset",
stylesheet:"Tyylitiedosto",
style:"Tyyli",
author:"Kirjoittaja",
copyright:"Copyright",
add:"Lis\u00E4\u00E4 uusi elementti",
remove:"Poista valittu elementti",
moveup:"Siirr\u00E4 valittua elementti\u00E4 yl\u00F6s",
movedown:"Siirr\u00E4 valittua elementti\u00E4 alas",
head_elements:"P\u00E4\u00E4elementti",
info:"Informaatio",
add_title:"Otsikkoelementti",
add_meta:"Meta-elementti",
add_script:"Script-elementti",
add_style:"Tyylielementti",
add_link:"Linkkielementti",
add_base:"Base-elementti",
add_comment:"Yleinen elementti",
title_element:"Otsikkoelementti",
script_element:"Script-elementti",
style_element:"Tyylielementti",
base_element:"Base-elementti",
link_element:"Linkkielementti",
meta_element:"Meta-elementti",
comment_element:"Kommentti",
src:"L\u00E4hde",
language:"Kieli",
href:"Href",
target:"Kohde",
type:"Tyyppi",
charset:"Kirjasintyyppi",
defer:"Mukautuminen",
media:"Media",
properties:"Asetukset",
name:"Nimi",
value:"Arvo",
content:"Sis\u00E4lt\u00F6",
rel:"Rel",
rev:"Rev",
hreflang:"Href kieli",
general_props:"Yleinen",
advanced_props:"Edistynyt"
});
|
/*
*
* Copyright 2013 Jesse MacFadyen
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
/* jshint laxcomma:true, sub:true */
var common = require('./common'),
path = require('path'),
glob = require('glob'),
csproj = require('../../util/windows/csproj'),
events = require('../../events'),
xml_helpers = require('../../util/xml-helpers');
module.exports = {
www_dir:function(project_dir) {
return path.join(project_dir, 'www');
},
package_name:function(project_dir) {
return xml_helpers.parseElementtreeSync(path.join(project_dir, 'Properties', 'WMAppManifest.xml')).find('App').attrib.ProductID;
},
parseProjectFile:function(project_dir) {
var project_files = glob.sync('*.csproj', {
cwd:project_dir
});
if (project_files.length === 0) {
throw new Error('does not appear to be a Windows Phone project (no .csproj file)');
}
return new csproj(path.join(project_dir, project_files[0]));
},
'source-file':{
install:function(obj, plugin_dir, project_dir, plugin_id, options, project_file) {
var dest = path.join('Plugins', plugin_id, obj.targetDir ? obj.targetDir : '', path.basename(obj.src));
common.copyNewFile(plugin_dir, obj.src, project_dir, dest);
// add reference to this file to csproj.
project_file.addSourceFile(dest);
},
uninstall:function(obj, project_dir, plugin_id, options, project_file) {
var dest = path.join('Plugins', plugin_id, obj.targetDir ? obj.targetDir : '', path.basename(obj.src));
common.removeFile(project_dir, dest);
// remove reference to this file from csproj.
project_file.removeSourceFile(dest);
}
},
'header-file': {
install:function(obj, plugin_dir, project_dir, plugin_id, options) {
events.emit('verbose', 'header-file.install is not supported for wp8');
},
uninstall:function(obj, project_dir, plugin_id, options) {
events.emit('verbose', 'header-file.uninstall is not supported for wp8');
}
},
'resource-file':{
install:function(obj, plugin_dir, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'resource-file.install is not supported for wp8');
},
uninstall:function(obj, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'resource-file.uninstall is not supported for wp8');
}
},
'framework':{
install:function(obj, plugin_dir, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'wp8 framework install :: ' + plugin_id );
var src = obj.src;
var dest = src; // if !isCustom, we will just add a reference to the file in place
var isCustom = obj.custom;
if(isCustom) {
dest = path.join('plugins', plugin_id, path.basename(src));
common.copyFile(plugin_dir, src, project_dir, dest);
}
project_file.addReference(dest);
},
uninstall:function(obj, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'wp8 framework uninstall :: ' + plugin_id );
var src = obj.src;
var isCustom = obj.custom;
if(isCustom) {
var dest = path.join('plugins', plugin_id);
common.removeFile(project_dir, dest);
}
project_file.removeReference(src);
}
},
'lib-file': {
install:function(obj, plugin_dir, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'wp8 lib-file install :: ' + plugin_id);
var inc = obj.Include;
project_file.addSDKRef(inc);
},
uninstall:function(obj, project_dir, plugin_id, options, project_file) {
events.emit('verbose', 'wp8 lib-file uninstall :: ' + plugin_id);
var inc = obj.Include;
project_file.removeSDKRef(inc);
}
}
};
|
var mongoose = require('mongoose')
, Schema = mongoose.Schema
var InviteCodeSchema = new Schema({
code: { type: String, unique: true }
, created_timestamp: Date
, consumed_timestamp: Date
, emailed_to: { type: String, index: true }
, consumed_by_user: { type: Schema.ObjectId, ref: 'user' }
, collaborations: [
{
project: String
, access_level: Number
, invited_by: { type: Schema.ObjectId, ref: 'user' }
}
]
});
module.exports = mongoose.model('InviteCode', InviteCodeSchema);
|
/* */
var ecstatic = require("ecstatic")(__dirname);
var http = require("http");
http.createServer(ecstatic).listen(8000);
console.log('listening on :8000');
console.log('# remember to run browserify entry.js -o bundle.js');
|
(function() {
var def = {
"!name": "mongo-map",
"!define": {
},
"emit": {
"!type": "fn(key: ?, value: ?)",
"!url": "http://docs.mongodb.org/manual/reference/command/mapReduce/#requirements-for-the-map-function",
"!doc": "the emit(key,value) function associates the key with a value."
}
}
CodeMirror.tern.addDef(def);
})();
|
angular.module('ui.bootstrap.accordion', ['ui.bootstrap.collapse'])
.constant('accordionConfig', {
closeOthers: true
})
.controller('AccordionController', ['$scope', '$attrs', 'accordionConfig', function($scope, $attrs, accordionConfig) {
// This array keeps track of the accordion groups
this.groups = [];
// Ensure that all the groups in this accordion are closed, unless close-others explicitly says not to
this.closeOthers = function(openGroup) {
var closeOthers = angular.isDefined($attrs.closeOthers) ?
$scope.$eval($attrs.closeOthers) : accordionConfig.closeOthers;
if (closeOthers) {
angular.forEach(this.groups, function(group) {
if (group !== openGroup) {
group.isOpen = false;
}
});
}
};
// This is called from the accordion-group directive to add itself to the accordion
this.addGroup = function(groupScope) {
var that = this;
this.groups.push(groupScope);
groupScope.$on('$destroy', function(event) {
that.removeGroup(groupScope);
});
};
// This is called from the accordion-group directive when to remove itself
this.removeGroup = function(group) {
var index = this.groups.indexOf(group);
if (index !== -1) {
this.groups.splice(index, 1);
}
};
}])
// The accordion directive simply sets up the directive controller
// and adds an accordion CSS class to itself element.
.directive('accordion', function() {
return {
restrict: 'EA',
controller: 'AccordionController',
controllerAs: 'accordion',
transclude: true,
replace: false,
templateUrl: function(element, attrs) {
return attrs.templateUrl || 'template/accordion/accordion.html';
}
};
})
// The accordion-group directive indicates a block of html that will expand and collapse in an accordion
.directive('accordionGroup', function() {
return {
require: '^accordion', // We need this directive to be inside an accordion
restrict: 'EA',
transclude: true, // It transcludes the contents of the directive into the template
replace: true, // The element containing the directive will be replaced with the template
templateUrl: function(element, attrs) {
return attrs.templateUrl || 'template/accordion/accordion-group.html';
},
scope: {
heading: '@', // Interpolate the heading attribute onto this scope
isOpen: '=?',
isDisabled: '=?'
},
controller: function() {
this.setHeading = function(element) {
this.heading = element;
};
},
link: function(scope, element, attrs, accordionCtrl) {
accordionCtrl.addGroup(scope);
scope.openClass = attrs.openClass || 'panel-open';
scope.panelClass = attrs.panelClass;
scope.$watch('isOpen', function(value) {
element.toggleClass(scope.openClass, value);
if (value) {
accordionCtrl.closeOthers(scope);
}
});
scope.toggleOpen = function($event) {
if (!scope.isDisabled) {
if (!$event || $event.which === 32) {
scope.isOpen = !scope.isOpen;
}
}
};
}
};
})
// Use accordion-heading below an accordion-group to provide a heading containing HTML
// <accordion-group>
// <accordion-heading>Heading containing HTML - <img src="..."></accordion-heading>
// </accordion-group>
.directive('accordionHeading', function() {
return {
restrict: 'EA',
transclude: true, // Grab the contents to be used as the heading
template: '', // In effect remove this element!
replace: true,
require: '^accordionGroup',
link: function(scope, element, attr, accordionGroupCtrl, transclude) {
// Pass the heading to the accordion-group controller
// so that it can be transcluded into the right place in the template
// [The second parameter to transclude causes the elements to be cloned so that they work in ng-repeat]
accordionGroupCtrl.setHeading(transclude(scope, angular.noop));
}
};
})
// Use in the accordion-group template to indicate where you want the heading to be transcluded
// You must provide the property on the accordion-group controller that will hold the transcluded element
// <div class="accordion-group">
// <div class="accordion-heading" ><a ... accordion-transclude="heading">...</a></div>
// ...
// </div>
.directive('accordionTransclude', function() {
return {
require: '^accordionGroup',
link: function(scope, element, attr, controller) {
scope.$watch(function() { return controller[attr.accordionTransclude]; }, function(heading) {
if (heading) {
element.find('span').html('');
element.find('span').append(heading);
}
});
}
};
})
;
|
Package.describe({
summary: "Telescope library package",
version: '0.2.9',
name: "telescope-lib"
});
Package.onUse(function (api) {
api.use([
'underscore'
], ['client', 'server']);
api.use([
'jquery'
], 'client');
api.add_files([
'lib/lib.js',
'lib/deep.js',
'lib/deep_extend.js',
'lib/autolink.js',
'lib/permissions.js'
], ['client', 'server']);
api.add_files(['lib/client/jquery.exists.js'], ['client']);
api.export([
'deepExtend',
'camelToDash',
'dashToCamel',
'camelCaseify',
'removeSetting',
'getThemeSetting',
'getSiteUrl',
'trimWords',
'can',
'_',
'capitalise'
]);
});
|
/*
Copyright (c) 2003-2015, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'save', 'en-ca', {
toolbar: 'Save'
} );
|
/**
* math.js
* https://github.com/josdejong/mathjs
*
* Math.js is an extensive math library for JavaScript and Node.js,
* It features real and complex numbers, units, matrices, a large set of
* mathematical functions, and a flexible expression parser.
*
* @version @@version
* @date @@date
*
* @license
* Copyright (C) 2013-2015 Jos de Jong <wjosdejong@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
|
/*
This file is part of Ext JS 4
Copyright (c) 2011 Sencha Inc
Contact: http://www.sencha.com/contact
GNU General Public License Usage
This file may be used under the terms of the GNU General Public License version 3.0 as published by the Free Software Foundation and appearing in the file LICENSE included in the packaging of this file. Please review the following information to ensure the GNU General Public License version 3.0 requirements will be met: http://www.gnu.org/copyleft/gpl.html.
If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact.
*/
/**
* @class Ext.button.Split
* @extends Ext.button.Button
* A split button that provides a built-in dropdown arrow that can fire an event separately from the default
* click event of the button. Typically this would be used to display a dropdown menu that provides additional
* options to the primary button action, but any custom handler can provide the arrowclick implementation.
* {@img Ext.button.Split/Ext.button.Split.png Ext.button.Split component}
* Example usage:
* <pre><code>
// display a dropdown menu:
Ext.create('Ext.button.Split', {
renderTo: 'button-ct', // the container id
text: 'Options',
handler: optionsHandler, // handle a click on the button itself
menu: new Ext.menu.Menu({
items: [
// these items will render as dropdown menu items when the arrow is clicked:
{text: 'Item 1', handler: item1Handler},
{text: 'Item 2', handler: item2Handler}
]
})
});
// Instead of showing a menu, you provide any type of custom
// functionality you want when the dropdown arrow is clicked:
Ext.create('Ext.button.Split', {
renderTo: 'button-ct',
text: 'Options',
handler: optionsHandler,
arrowHandler: myCustomHandler
});
</code></pre>
* @cfg {Function} arrowHandler A function called when the arrow button is clicked (can be used instead of click event)
* @cfg {String} arrowTooltip The title attribute of the arrow
*/
Ext.define('Ext.button.Split', {
/* Begin Definitions */
alias: 'widget.splitbutton',
extend: 'Ext.button.Button',
alternateClassName: 'Ext.SplitButton',
// private
arrowCls : 'split',
split : true,
// private
initComponent : function(){
this.callParent();
/**
* @event arrowclick
* Fires when this button's arrow is clicked
* @param {MenuButton} this
* @param {EventObject} e The click event
*/
this.addEvents("arrowclick");
},
/**
* Sets this button's arrow click handler.
* @param {Function} handler The function to call when the arrow is clicked
* @param {Object} scope (optional) Scope for the function passed above
*/
setArrowHandler : function(handler, scope){
this.arrowHandler = handler;
this.scope = scope;
},
// private
onClick : function(e, t) {
var me = this;
e.preventDefault();
if (!me.disabled) {
if (me.overMenuTrigger) {
if (me.menu && !me.menu.isVisible() && !me.ignoreNextClick) {
me.showMenu();
}
me.fireEvent("arrowclick", me, e);
if (me.arrowHandler) {
me.arrowHandler.call(me.scope || me, me, e);
}
} else {
if (me.enableToggle) {
me.toggle();
}
me.fireEvent("click", me, e);
if (me.handler) {
me.handler.call(me.scope || me, me, e);
}
me.onBlur();
}
}
}
});
|
__ace_shadowed__.define('ace/snippets/mel', ['require', 'exports', 'module' ], function(require, exports, module) {
exports.snippetText = "";
exports.scope = "mel";
});
|
// @flow
function fun(x: 'hi', y: 123) {}
fun(...['hi', 123]); // No error
fun(...['hi'], ...[123]); // No error
fun(...['hi'], ...[], ...[123]); // No error
fun(...['hi'], ...[], ...[123], ...[true]); // Error - true is unused
fun(...['hi'], ...[true], ...[123]); // Error: true ~> 123 and 123 is unused
declare var arrOf123: Array<123>;
fun('hi', ...arrOf123); // No error - ignore the fact arrOf123 could be empty
function funWithRestArray(x: 'hi', y: 123, ...rest: Array<number>) {}
funWithRestArray(...['hi', 123]); // No error
funWithRestArray(...['hi'], ...[123]); // No error
funWithRestArray(...['hi'], ...[], ...[123]); // No error
funWithRestArray(...['hi'], ...[], ...[123], ...[456, 789]); // No error
funWithRestArray(...['hi'], ...[true], ...[123]); // Error: true ~> 123
funWithRestArray('hi', 123, ...arrOf123); // Ok
funWithRestArray('hi', ...arrOf123); // No error - ignore the fact arrOf123 could be empty
funWithRestArray('hi', ...arrOf123, ...arrOf123); // No error - ignore the fact arrOf123 could be empty
// 2 errors
// 1. 'bye' ~> 123 in case the first spread is empty
// 2. 'bye' ~> number in case the first spread is not empty
funWithRestArray('hi', ...arrOf123, 'bye', ...arrOf123);
|
exports.default = {
servers: {
socket: function(api){
return {
enabled: false,
// TCP or TLS?
secure: false,
// passed to tls.createServer if secure=true. Should contain SSL certificates
serverOptions: {},
// Port or Socket
port: 5000,
// which IP to listen on (use 0.0.0.0 for all)
bindIP: '0.0.0.0',
// Enabple TCP KeepAlive pings on each connection?
setKeepAlive: false
}
}
}
}
exports.test = {
servers: {
socket: function(api){
return {
enabled: true,
port: 5001,
secure: false
}
}
}
}
|
ej.addCulture( "es-BO", {
name: "es-BO",
englishName: "Spanish (Bolivia)",
nativeName: "Español (Bolivia)",
language: "es",
numberFormat: {
",": ".",
".": ",",
"NaN": "NeuN",
negativeInfinity: "-Infinito",
positiveInfinity: "Infinito",
percent: {
",": ".",
".": ","
},
currency: {
pattern: ["($ n)","$ n"],
",": ".",
".": ",",
symbol: "$b"
}
},
calendars: {
standard: {
days: {
names: ["domingo","lunes","martes","miércoles","jueves","viernes","sábado"],
namesAbbr: ["dom","lun","mar","mié","jue","vie","sáb"],
namesShort: ["do","lu","ma","mi","ju","vi","sá"]
},
months: {
names: ["enero","febrero","marzo","abril","mayo","junio","julio","agosto","septiembre","octubre","noviembre","diciembre",""],
namesAbbr: ["ene","feb","mar","abr","may","jun","jul","ago","sep","oct","nov","dic",""]
},
AM: ["a.m.","a.m.","A.M."],
PM: ["p.m.","p.m.","P.M."],
patterns: {
d: "dd/MM/yyyy",
D: "dddd, dd' de 'MMMM' de 'yyyy",
t: "hh:mm tt",
T: "hh:mm:ss tt",
f: "dddd, dd' de 'MMMM' de 'yyyy hh:mm tt",
F: "dddd, dd' de 'MMMM' de 'yyyy hh:mm:ss tt",
M: "d' de 'MMM",
Y: "MMMM' de 'yyyy"
}
}
}
});
|
"use strict";
var WebpackMd5Hash = require('./plugin/webpack_md5_hash');
module.exports = WebpackMd5Hash;
|
import Vue from './instance/index'
import { initGlobalAPI } from './global-api/index'
import { isServerRendering } from 'core/util/env'
initGlobalAPI(Vue)
Object.defineProperty(Vue.prototype, '$isServer', {
get: isServerRendering
})
Object.defineProperty(Vue.prototype, '$ssrContext', {
get () {
/* istanbul ignore next */
return this.$vnode.ssrContext
}
})
Vue.version = '__VERSION__'
export default Vue
|
"use strict";
/**
* @license
* Copyright 2013 Palantir Technologies, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var abstractFormatter_1 = require("../language/formatter/abstractFormatter");
var colors = require("colors");
var Utils = require("../utils");
var Formatter = (function (_super) {
tslib_1.__extends(Formatter, _super);
function Formatter() {
return _super !== null && _super.apply(this, arguments) || this;
}
/* tslint:enable:object-literal-sort-keys */
Formatter.prototype.format = function (failures) {
var outputLines = this.mapToMessages(failures);
// Removes initial blank line
if (outputLines[0] === "") {
outputLines.shift();
}
return outputLines.join("\n") + "\n";
};
Formatter.prototype.mapToMessages = function (failures) {
if (failures.length === 0) {
return [];
}
var outputLines = [];
var positionMaxSize = this.getPositionMaxSize(failures);
var ruleMaxSize = this.getRuleMaxSize(failures);
var currentFile;
for (var _i = 0, failures_1 = failures; _i < failures_1.length; _i++) {
var failure = failures_1[_i];
var fileName = failure.getFileName();
// Output the name of each file once
if (currentFile !== fileName) {
outputLines.push("");
outputLines.push(fileName);
currentFile = fileName;
}
var failureString = failure.getFailure();
failureString = colors.yellow(failureString);
// Rule
var ruleName = failure.getRuleName();
ruleName = this.pad(ruleName, ruleMaxSize);
ruleName = colors.grey(ruleName);
// Lines
var lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
var positionTuple = lineAndCharacter.line + 1 + ":" + (lineAndCharacter.character + 1);
positionTuple = this.pad(positionTuple, positionMaxSize);
positionTuple = failure.getRuleSeverity() === "warning"
? colors.blue(failure.getRuleSeverity().toUpperCase() + ": " + positionTuple)
: colors.red(failure.getRuleSeverity().toUpperCase() + ": " + positionTuple);
// Output
var output = positionTuple + " " + ruleName + " " + failureString;
outputLines.push(output);
}
return outputLines;
};
Formatter.prototype.pad = function (str, len) {
var padder = Array(len + 1).join(" ");
return (str + padder).substring(0, padder.length);
};
Formatter.prototype.getPositionMaxSize = function (failures) {
var positionMaxSize = 0;
for (var _i = 0, failures_2 = failures; _i < failures_2.length; _i++) {
var failure = failures_2[_i];
var lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
var positionSize = (lineAndCharacter.line + 1 + ":" + (lineAndCharacter.character + 1)).length;
if (positionSize > positionMaxSize) {
positionMaxSize = positionSize;
}
}
return positionMaxSize;
};
Formatter.prototype.getRuleMaxSize = function (failures) {
var ruleMaxSize = 0;
for (var _i = 0, failures_3 = failures; _i < failures_3.length; _i++) {
var failure = failures_3[_i];
var ruleSize = failure.getRuleName().length;
if (ruleSize > ruleMaxSize) {
ruleMaxSize = ruleSize;
}
}
return ruleMaxSize;
};
return Formatter;
}(abstractFormatter_1.AbstractFormatter));
/* tslint:disable:object-literal-sort-keys */
Formatter.metadata = {
formatterName: "stylish",
description: "Human-readable formatter which creates stylish messages.",
descriptionDetails: (_a = ["\n The output matches that produced by eslint's stylish formatter. Its readability\n enhanced through spacing and colouring"], _a.raw = ["\n The output matches that produced by eslint's stylish formatter. Its readability\n enhanced through spacing and colouring"], Utils.dedent(_a)),
sample: (_b = ["\n myFile.ts\n 1:14 semicolon Missing semicolon"], _b.raw = ["\n myFile.ts\n 1:14 semicolon Missing semicolon"], Utils.dedent(_b)),
consumer: "human",
};
exports.Formatter = Formatter;
var _a, _b;
|
/*
Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
*/
CKEDITOR.plugins.setLang("placeholder","uk",{title:"Налаштування Заповнювача",toolbar:"Створити Заповнювач",name:"Назва заповнювача",invalidName:"Заповнювач не може бути порожнім і не може містити наступні символи: [, ], \x3c, \x3e",pathName:"заповнювач"});
|
/**
* @license
* Copyright 2013 Google Inc. All rights reserved.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Requires all blocks to load them into the factory.
*/
/** @suppress {extraProvide} this aggregation needs a namespace */
goog.provide('e2e.hash.all');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Md5');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Sha1');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Sha224');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Sha256');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Sha384');
/** @suppress {extraRequire} intentional import */
goog.require('e2e.hash.Sha512');
|
ace.define("ace/theme/dreamweaver",["require","exports","module","ace/lib/dom"], function(acequire, exports, module) {
exports.isDark = false;
exports.cssClass = "ace-dreamweaver";
exports.cssText = ".ace-dreamweaver .ace_gutter {\
background: #e8e8e8;\
color: #333;\
}\
.ace-dreamweaver .ace_print-margin {\
width: 1px;\
background: #e8e8e8;\
}\
.ace-dreamweaver {\
background-color: #FFFFFF;\
color: black;\
}\
.ace-dreamweaver .ace_fold {\
background-color: #757AD8;\
}\
.ace-dreamweaver .ace_cursor {\
color: black;\
}\
.ace-dreamweaver .ace_invisible {\
color: rgb(191, 191, 191);\
}\
.ace-dreamweaver .ace_storage,\
.ace-dreamweaver .ace_keyword {\
color: blue;\
}\
.ace-dreamweaver .ace_constant.ace_buildin {\
color: rgb(88, 72, 246);\
}\
.ace-dreamweaver .ace_constant.ace_language {\
color: rgb(88, 92, 246);\
}\
.ace-dreamweaver .ace_constant.ace_library {\
color: rgb(6, 150, 14);\
}\
.ace-dreamweaver .ace_invalid {\
background-color: rgb(153, 0, 0);\
color: white;\
}\
.ace-dreamweaver .ace_support.ace_function {\
color: rgb(60, 76, 114);\
}\
.ace-dreamweaver .ace_support.ace_constant {\
color: rgb(6, 150, 14);\
}\
.ace-dreamweaver .ace_support.ace_type,\
.ace-dreamweaver .ace_support.ace_class {\
color: #009;\
}\
.ace-dreamweaver .ace_support.ace_php_tag {\
color: #f00;\
}\
.ace-dreamweaver .ace_keyword.ace_operator {\
color: rgb(104, 118, 135);\
}\
.ace-dreamweaver .ace_string {\
color: #00F;\
}\
.ace-dreamweaver .ace_comment {\
color: rgb(76, 136, 107);\
}\
.ace-dreamweaver .ace_comment.ace_doc {\
color: rgb(0, 102, 255);\
}\
.ace-dreamweaver .ace_comment.ace_doc.ace_tag {\
color: rgb(128, 159, 191);\
}\
.ace-dreamweaver .ace_constant.ace_numeric {\
color: rgb(0, 0, 205);\
}\
.ace-dreamweaver .ace_variable {\
color: #06F\
}\
.ace-dreamweaver .ace_xml-pe {\
color: rgb(104, 104, 91);\
}\
.ace-dreamweaver .ace_entity.ace_name.ace_function {\
color: #00F;\
}\
.ace-dreamweaver .ace_heading {\
color: rgb(12, 7, 255);\
}\
.ace-dreamweaver .ace_list {\
color:rgb(185, 6, 144);\
}\
.ace-dreamweaver .ace_marker-layer .ace_selection {\
background: rgb(181, 213, 255);\
}\
.ace-dreamweaver .ace_marker-layer .ace_step {\
background: rgb(252, 255, 0);\
}\
.ace-dreamweaver .ace_marker-layer .ace_stack {\
background: rgb(164, 229, 101);\
}\
.ace-dreamweaver .ace_marker-layer .ace_bracket {\
margin: -1px 0 0 -1px;\
border: 1px solid rgb(192, 192, 192);\
}\
.ace-dreamweaver .ace_marker-layer .ace_active-line {\
background: rgba(0, 0, 0, 0.07);\
}\
.ace-dreamweaver .ace_gutter-active-line {\
background-color : #DCDCDC;\
}\
.ace-dreamweaver .ace_marker-layer .ace_selected-word {\
background: rgb(250, 250, 255);\
border: 1px solid rgb(200, 200, 250);\
}\
.ace-dreamweaver .ace_meta.ace_tag {\
color:#009;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_anchor {\
color:#060;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_form {\
color:#F90;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_image {\
color:#909;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_script {\
color:#900;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_style {\
color:#909;\
}\
.ace-dreamweaver .ace_meta.ace_tag.ace_table {\
color:#099;\
}\
.ace-dreamweaver .ace_string.ace_regex {\
color: rgb(255, 0, 0)\
}\
.ace-dreamweaver .ace_indent-guide {\
background: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==\") right repeat-y;\
}";
var dom = acequire("../lib/dom");
dom.importCssString(exports.cssText, exports.cssClass);
});
|
var PJD_3PARAM = 1;
var PJD_7PARAM = 2;
var PJD_GRIDSHIFT = 3;
var PJD_NODATUM = 5; // WGS84 or equivalent
var SRS_WGS84_SEMIMAJOR = 6378137; // only used in grid shift transforms
var SRS_WGS84_ESQUARED = 0.006694379990141316; //DGR: 2012-07-29
module.exports = function(source, dest, point) {
var wp, i, l;
function checkParams(fallback) {
return (fallback === PJD_3PARAM || fallback === PJD_7PARAM);
}
// Short cut if the datums are identical.
if (source.compare_datums(dest)) {
return point; // in this case, zero is sucess,
// whereas cs_compare_datums returns 1 to indicate TRUE
// confusing, should fix this
}
// Explicitly skip datum transform by setting 'datum=none' as parameter for either source or dest
if (source.datum_type === PJD_NODATUM || dest.datum_type === PJD_NODATUM) {
return point;
}
//DGR: 2012-07-29 : add nadgrids support (begin)
var src_a = source.a;
var src_es = source.es;
var dst_a = dest.a;
var dst_es = dest.es;
var fallback = source.datum_type;
// If this datum requires grid shifts, then apply it to geodetic coordinates.
if (fallback === PJD_GRIDSHIFT) {
if (this.apply_gridshift(source, 0, point) === 0) {
source.a = SRS_WGS84_SEMIMAJOR;
source.es = SRS_WGS84_ESQUARED;
}
else {
// try 3 or 7 params transformation or nothing ?
if (!source.datum_params) {
source.a = src_a;
source.es = source.es;
return point;
}
wp = 1;
for (i = 0, l = source.datum_params.length; i < l; i++) {
wp *= source.datum_params[i];
}
if (wp === 0) {
source.a = src_a;
source.es = source.es;
return point;
}
if (source.datum_params.length > 3) {
fallback = PJD_7PARAM;
}
else {
fallback = PJD_3PARAM;
}
}
}
if (dest.datum_type === PJD_GRIDSHIFT) {
dest.a = SRS_WGS84_SEMIMAJOR;
dest.es = SRS_WGS84_ESQUARED;
}
// Do we need to go through geocentric coordinates?
if (source.es !== dest.es || source.a !== dest.a || checkParams(fallback) || checkParams(dest.datum_type)) {
//DGR: 2012-07-29 : add nadgrids support (end)
// Convert to geocentric coordinates.
source.geodetic_to_geocentric(point);
// CHECK_RETURN;
// Convert between datums
if (checkParams(source.datum_type)) {
source.geocentric_to_wgs84(point);
// CHECK_RETURN;
}
if (checkParams(dest.datum_type)) {
dest.geocentric_from_wgs84(point);
// CHECK_RETURN;
}
// Convert back to geodetic coordinates
dest.geocentric_to_geodetic(point);
// CHECK_RETURN;
}
// Apply grid shift to destination if required
if (dest.datum_type === PJD_GRIDSHIFT) {
this.apply_gridshift(dest, 1, point);
// CHECK_RETURN;
}
source.a = src_a;
source.es = src_es;
dest.a = dst_a;
dest.es = dst_es;
return point;
};
|
/*
* L.Transformation is an utility class to perform simple point transformations through a 2d-matrix.
*/
L.Transformation = function (a, b, c, d) {
this._a = a;
this._b = b;
this._c = c;
this._d = d;
};
L.Transformation.prototype = {
transform: function (point, scale) { // (Point, Number) -> Point
return this._transform(point.clone(), scale);
},
// destructive transform (faster)
_transform: function (point, scale) {
scale = scale || 1;
point.x = scale * (this._a * point.x + this._b);
point.y = scale * (this._c * point.y + this._d);
return point;
},
untransform: function (point, scale) {
scale = scale || 1;
return new L.Point(
(point.x / scale - this._b) / this._a,
(point.y / scale - this._d) / this._c);
}
};
|
/**
* Module Dependencies
*/
var hasOwnProperty = require('../helpers').object.hasOwnProperty;
/**
* Traverse an object representing values and map out any associations.
*
* @param {String} model
* @param {Object} schema
* @param {Object} values
* @return {Object}
* @api private
*/
module.exports = function(model, schema, values) {
var self = this;
// Pick out the top level associations
var associations = {
collections: [],
models: []
};
Object.keys(values).forEach(function(key) {
// Ignore values equal to null
if(values[key] === null) return;
// Ignore joinTables
if(hasOwnProperty(schema[model], 'junctionTable')) return;
if(!hasOwnProperty(schema[model].attributes, key)) return;
var attribute = schema[model].attributes[key];
if(!hasOwnProperty(attribute, 'collection') && !hasOwnProperty(attribute, 'foreignKey')) return;
if(hasOwnProperty(attribute, 'collection')) associations.collections.push(key);
if(hasOwnProperty(attribute, 'foreignKey')) associations.models.push(key);
});
return associations;
};
|
version https://git-lfs.github.com/spec/v1
oid sha256:909f2a7fc44411e110b2a8e09f1a01f34d765f30bcfe20a8ea29612b0d1b09ff
size 3612
|
//// [typeAssertionsWithUnionTypes01.ts]
interface I1 {
p1: number
}
interface I2 extends I1 {
p2: number;
}
var x = { p1: 10, p2: 20 };
var y: number | I2 = x;
var z: I1 = x;
var a = <number | I2>z;
var b = <number>z;
var c = <I2>z;
var d = <I1>y;
//// [typeAssertionsWithUnionTypes01.js]
var x = { p1: 10, p2: 20 };
var y = x;
var z = x;
var a = z;
var b = z;
var c = z;
var d = y;
|
(function() {
'use strict';
var boilerplatePlugin = (function BoilerplatePluginClosure() {
function BoilerplateStore(config) {
this._coordinator = {};
this._data = [];
this._max = 1;
this._min = 0;
};
BoilerplateStore.prototype = {
setCoordinator: function(coordinator) {
},
setData: function(data) {
},
addData: function(data) {
},
removeData: function(data) {
},
getData: function() {
}
};
function BoilerplateRenderer(config) {
};
return {
store: BoilerplateStore,
renderer: BoilerplateRenderer
}
}());
h337.register('boilerplate', boilerplatePlugin);
}());
|
/**
* The Alert Component
*
* @module aui-alert
*/
var getClassName = A.getClassName,
CSS_CLOSE = getClassName('close'),
CSS_INFO = getClassName('alert', 'info'),
CSS_DISMISSABLE = getClassName('alert', 'dismissable');
/**
* A base class for Alert.
*
* Check the [live demo](http://alloyui.com/examples/alert/).
*
* @class A.Alert
* @extends Widget
* @uses A.WidgetCssClass, A.WidgetTransition
* @param {Object} config Object literal specifying widget configuration
* properties.
* @constructor
* @include http://alloyui.com/examples/alert/basic-markup.html
* @include http://alloyui.com/examples/alert/basic.js
*/
A.Alert = A.Base.create('alert', A.Widget, [
A.WidgetCssClass,
A.WidgetStdMod,
A.WidgetTransition
], {
CONTENT_TEMPLATE: null,
_eventHandle: null,
/**
* Renders the Alert component instance. Lifecycle.
*
* @method renderUI
* @protected
*/
renderUI: function() {
this._uiSetCloseable(this.get('closeable'));
},
/**
* Binds the events on the Alert UI. Lifecycle.
*
* @method bindUI
* @protected
*/
bindUI: function() {
this.on('closeableChange', this._onCloseableChange);
this.after('visibleChange', this._afterVisibleChange);
},
/**
* Fires after visibility changes.
*
* @method _afterVisibleChange
* @param {EventFacade} event
* @protected
*/
_afterVisibleChange: function(event) {
if (!event.newVal && this.get('destroyOnHide')) {
A.soon(A.bind('destroy', this));
}
},
/**
* Handles close icon click event.
*
* @method _onClickBoundingBox
* @param {EventFacade} event
* @protected
*/
_onClickBoundingBox: function(event) {
if (event.target.test('.' + CSS_CLOSE)) {
this.hide();
}
},
/**
* Handles `closeable` events.
*
* @method _onCloseableChange
* @param {EventFacade} event
* @protected
*/
_onCloseableChange: function(event) {
this._uiSetCloseable(event.newVal);
},
/**
* Sets `closeable` UI.
*
* @method _uiSetCloseable
* @protected
*/
_uiSetCloseable: function(val) {
var boundingBox = this.get('boundingBox'),
closeableNode = this.get('closeableNode');
boundingBox.toggleClass(CSS_DISMISSABLE, val);
closeableNode.remove();
if (this._eventHandle) {
this._eventHandle.detach();
}
if (val) {
boundingBox.insert(closeableNode, 0);
this._eventHandle = boundingBox.on('click', this._onClickBoundingBox, this);
}
}
}, {
/**
* Static property used to define the default attribute
* configuration for the Alert.
*
* @property ATTRS
* @type Object
* @static
*/
ATTRS: {
/**
* Whether the alert can be closed.
*
* @attribute closeable
* @default true
* @type {Boolean}
*/
closeable: {
validator: A.Lang.isBoolean,
value: true
},
/**
* Node used to generate a close button.
*
* @attribute closeableNode
* @default `<button type="button" class="close">×</button>`
* @type {Node}
*/
closeableNode: {
valueFn: function() {
return A.Node.create('<button type="button" class="close">×</button>');
}
},
/**
* CSS class for alert.
*
* @attribute popoverCssClass
* @default A.getClassName('alert-info')
* @type {String}
*/
cssClass: {
value: CSS_INFO
},
/**
* Determine if Alert should be destroyed when hidden.
*
* @attribute destroyOnHide
* @default false
* @type Boolean
*/
destroyOnHide: {
validator: A.Lang.isBoolean,
value: false
}
},
/**
* Static property provides a string to identify the CSS prefix.
*
* @property CSS_PREFIX
* @type {String}
* @static
*/
CSS_PREFIX: 'alert',
/**
* Object hash, defining how closeableNode value have to be parsed from markup.
*
* @property HTML_PARSER
* @type Object
* @static
*/
HTML_PARSER: {
closeableNode: '.' + CSS_CLOSE
}
});
|
import { Vector2 } from './Vector2';
/**
* @author bhouston / http://clara.io
*/
function Box2( min, max ) {
this.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity );
this.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity );
}
Box2.prototype = {
constructor: Box2,
set: function ( min, max ) {
this.min.copy( min );
this.max.copy( max );
return this;
},
setFromPoints: function ( points ) {
this.makeEmpty();
for ( var i = 0, il = points.length; i < il; i ++ ) {
this.expandByPoint( points[ i ] );
}
return this;
},
setFromCenterAndSize: function () {
var v1 = new Vector2();
return function setFromCenterAndSize( center, size ) {
var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
this.min.copy( center ).sub( halfSize );
this.max.copy( center ).add( halfSize );
return this;
};
}(),
clone: function () {
return new this.constructor().copy( this );
},
copy: function ( box ) {
this.min.copy( box.min );
this.max.copy( box.max );
return this;
},
makeEmpty: function () {
this.min.x = this.min.y = + Infinity;
this.max.x = this.max.y = - Infinity;
return this;
},
isEmpty: function () {
// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );
},
getCenter: function ( optionalTarget ) {
var result = optionalTarget || new Vector2();
return this.isEmpty() ? result.set( 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
},
getSize: function ( optionalTarget ) {
var result = optionalTarget || new Vector2();
return this.isEmpty() ? result.set( 0, 0 ) : result.subVectors( this.max, this.min );
},
expandByPoint: function ( point ) {
this.min.min( point );
this.max.max( point );
return this;
},
expandByVector: function ( vector ) {
this.min.sub( vector );
this.max.add( vector );
return this;
},
expandByScalar: function ( scalar ) {
this.min.addScalar( - scalar );
this.max.addScalar( scalar );
return this;
},
containsPoint: function ( point ) {
return point.x < this.min.x || point.x > this.max.x ||
point.y < this.min.y || point.y > this.max.y ? false : true;
},
containsBox: function ( box ) {
return this.min.x <= box.min.x && box.max.x <= this.max.x &&
this.min.y <= box.min.y && box.max.y <= this.max.y;
},
getParameter: function ( point, optionalTarget ) {
// This can potentially have a divide by zero if the box
// has a size dimension of 0.
var result = optionalTarget || new Vector2();
return result.set(
( point.x - this.min.x ) / ( this.max.x - this.min.x ),
( point.y - this.min.y ) / ( this.max.y - this.min.y )
);
},
intersectsBox: function ( box ) {
// using 6 splitting planes to rule out intersections.
return box.max.x < this.min.x || box.min.x > this.max.x ||
box.max.y < this.min.y || box.min.y > this.max.y ? false : true;
},
clampPoint: function ( point, optionalTarget ) {
var result = optionalTarget || new Vector2();
return result.copy( point ).clamp( this.min, this.max );
},
distanceToPoint: function () {
var v1 = new Vector2();
return function distanceToPoint( point ) {
var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
return clampedPoint.sub( point ).length();
};
}(),
intersect: function ( box ) {
this.min.max( box.min );
this.max.min( box.max );
return this;
},
union: function ( box ) {
this.min.min( box.min );
this.max.max( box.max );
return this;
},
translate: function ( offset ) {
this.min.add( offset );
this.max.add( offset );
return this;
},
equals: function ( box ) {
return box.min.equals( this.min ) && box.max.equals( this.max );
}
};
export { Box2 };
|
declare module "m" {
global {
var x: number;
}
}
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _Expression2 = require('../Expression');
var _Expression3 = _interopRequireDefault(_Expression2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var logicalOperators = {
'||': true,
'&&': true
};
var LogicalExpression = function (_Expression) {
(0, _inherits3.default)(LogicalExpression, _Expression);
// TODO: Should respect operator precedence: putting "a + b" before " * b" without parens should raise an error.
function LogicalExpression(childNodes) {
(0, _classCallCheck3.default)(this, LogicalExpression);
return (0, _possibleConstructorReturn3.default)(this, (LogicalExpression.__proto__ || (0, _getPrototypeOf2.default)(LogicalExpression)).call(this, 'LogicalExpression', childNodes));
}
(0, _createClass3.default)(LogicalExpression, [{
key: '_acceptChildren',
value: function _acceptChildren(children) {
var left = children.passExpression();
children.skipNonCode();
var operator = children.passToken('Punctuator', logicalOperators).value;
children.skipNonCode();
var right = children.passExpression();
children.assertEnd();
this.left = left;
this.operator = operator;
this.right = right;
}
}]);
return LogicalExpression;
}(_Expression3.default);
exports.default = LogicalExpression;
//# sourceMappingURL=LogicalExpression.js.map
|
var common = require("../common-tap.js")
var test = require("tap").test
var npm = require("../../")
var mkdirp = require("mkdirp")
var rimraf = require("rimraf")
var mr = require("npm-registry-mock")
var path = require("path")
// config
var pkg = path.resolve(__dirname, "outdated-include-devdependencies")
var cache = path.resolve(pkg, "cache")
mkdirp.sync(cache)
test("includes devDependencies in outdated", function (t) {
process.chdir(pkg)
mr({port : common.port}, function (er, s) {
npm.load({cache: cache, registry: common.registry}, function () {
npm.outdated(function (er, d) {
t.equal("1.5.1", d[0][3])
s.close()
t.end()
})
})
})
})
test("cleanup", function (t) {
rimraf.sync(cache)
t.end()
})
|
/**
* Copyright 2013-present NightWorld.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var dal = require('./dal.js');
model = module.exports;
var OAuthAccessTokenTable = "oauth2accesstoken";
var OAuthAuthCodeTable = "oauth2authcode";
var OAuthRefreshTokenTable = "oauth2refreshtoken";
var OAuthClientTable = "oauth2client";
var OAuthUserTable = "userid_map";
//
// oauth2-server callbacks
//
model.getAccessToken = function (bearerToken, callback) {
console.log('in getAccessToken (bearerToken: ' + bearerToken + ')');
dal.doGet(OAuthAccessTokenTable,
{"accessToken": {"S": bearerToken}}, true, function(err, data) {
if (data && data.expires) {
data.expires = new Date(data.expires * 1000);
}
callback(err, data);
});
};
model.getClient = function (clientId, clientSecret, callback) {
console.log('in getClient (clientId: ' + clientId + ', clientSecret: ' + clientSecret + ')');
dal.doGet(OAuthClientTable, { clientId: { S: clientId }}, true,
function(err, data) {
if (err || !data) return callback(err, data);
if (clientSecret !== null && data.clientSecret !== clientSecret) {
return callback();
}
callback(null, data);
});
};
// This will very much depend on your setup, I wouldn't advise doing anything exactly like this but
// it gives an example of how to use the method to restrict certain grant types
var authorizedClientIds = ['abc1', 'def2'];
model.grantTypeAllowed = function (clientId, grantType, callback) {
console.log('in grantTypeAllowed (clientId: ' + clientId + ', grantType: ' + grantType + ')');
if (grantType === 'password') {
return callback(false, authorizedClientIds.indexOf(clientId) >= 0);
}
callback(false, true);
};
model.saveAccessToken = function (accessToken, clientId, expires, user, callback) {
console.log('in saveAccessToken (accessToken: ' + accessToken + ', clientId: ' + clientId + ', userId: ' + user.id + ', expires: ' + expires + ')');
var token = {
accessToken: accessToken,
clientId: clientId,
userId: user.id
};
if (expires) token.expires = parseInt(expires / 1000, 10);
console.log('saving', token);
dal.doSet(token, OAuthAccessTokenTable, { accessToken: { S: accessToken }}, callback);
};
model.saveRefreshToken = function (refreshToken, clientId, expires, user, callback) {
console.log('in saveRefreshToken (refreshToken: ' + refreshToken + ', clientId: ' + clientId + ', userId: ' + user.id + ', expires: ' + expires + ')');
var token = {
refreshToken: refreshToken,
clientId: clientId,
userId: user.id
};
if (expires) token.expires = parseInt(expires / 1000, 10);
console.log('saving', token);
dal.doSet(token, OAuthRefreshTokenTable, { refreshToken: { S: refreshToken }}, callback);
};
model.getRefreshToken = function (bearerToken, callback) {
console.log("in getRefreshToken (bearerToken: " + bearerToken + ")");
dal.doGet(OAuthRefreshTokenTable, { refreshToken: { S: bearerToken }}, true, function(err, data) {
if (data && data.expires) {
data.expires = new Date(data.expires * 1000);
}
callback(err, data);
});
};
model.revokeRefreshToken = function(bearerToken, callback) {
console.log("in revokeRefreshToken (bearerToken: " + bearerToken + ")");
dal.doDelete(OAuthRefreshTokenTable, { refreshToken: { S: bearerToken }}, callback);
};
model.getAuthCode = function (bearerCode, callback) {
console.log("in getAuthCode (bearerCode: " + bearerCode + ")");
dal.doGet(OAuthAuthCodeTable, { authCode: { S: bearerCode }}, true, function(err, data) {
if (data && data.expires) {
data.expires = new Date(data.expires * 1000);
}
callback(err, data);
});
};
model.saveAuthCode = function (authCode, clientId, expires, user, callback) {
console.log('in saveAuthCode (authCode: ' + authCode + ', clientId: ' + clientId + ', userId: ' + user.id + ', expires: ' + expires + ')');
var code = {
authCode: authCode,
clientId: clientId,
userId: user.id
};
if (expires) code.expires = parseInt(expires / 1000, 10);
console.log("saving", code);
dal.doSet(code, OAuthAuthCodeTable, { authCode: { S: authCode }}, callback);
};
/*
* Required to support password grant type
*/
model.getUser = function (username, password, callback) {
console.log('in getUser (username: ' + username + ', password: ' + password + ')');
dal.doGet(OAuthUserTable, { id: { S: "email:" + username}}, true, function(err, data) {
if (err) return callback(err);
callback(null, { id: data.userId });
});
};
|
tinyMCE.addI18n('en.w3cvalidate',{
desc : 'W3C Markup Validation'
});
|
//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the MIT License (MIT).
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
(function () {
"use strict";
var app = WinJS.Application;
var nav = WinJS.Navigation;
var activationKinds = Windows.ApplicationModel.Activation.ActivationKind;
var splitView;
WinJS.Namespace.define("SdkSample", {
paneHiddenInitially: false
});
function activated(eventObject) {
var activationKind = eventObject.detail.kind;
var activatedEventArgs = eventObject.detail.detail;
SdkSample.paneHiddenInitially = window.innerWidth <= 768;
var p = WinJS.UI.processAll().
then(function () {
splitView = document.querySelector("#root").winControl;
splitView.onbeforeclose = function () { WinJS.Utilities.addClass(splitView.element, "hiding"); };
splitView.onafterclose = function () { WinJS.Utilities.removeClass(splitView.element, "hiding"); };
window.addEventListener("resize", handleResize);
handleResize();
var buttons = document.querySelectorAll(".splitViewButton");
for (var i = 0, len = buttons.length; i < len; i++) {
buttons[i].addEventListener("click", handleSplitViewButton);
}
// Navigate to either the first scenario or to the last running scenario
// before suspension or termination.
var url = SdkSample.scenarios.getAt(0).url;
var initialState = {};
var navHistory = app.sessionState.navigationHistory;
if (navHistory) {
nav.history = navHistory;
url = navHistory.current.location;
initialState = navHistory.current.state || initialState;
}
initialState.activationKind = activationKind;
initialState.activatedEventArgs = activatedEventArgs;
nav.history.current.initialPlaceholder = true;
return nav.navigate(url, initialState);
});
// Calling done on a promise chain allows unhandled exceptions to propagate.
p.done();
// Use setPromise to indicate to the system that the splash screen must not be torn down
// until after processAll and navigate complete asynchronously.
eventObject.setPromise(p);
}
function navigating(eventObject) {
var url = eventObject.detail.location;
var host = document.getElementById("contentHost");
// Call unload and dispose methods on current scenario, if any exist
if (host.winControl) {
host.winControl.unload && host.winControl.unload();
host.winControl.dispose && host.winControl.dispose();
}
WinJS.Utilities.disposeSubTree(host);
WinJS.Utilities.empty(host);
WinJS.log && WinJS.log("", "", "status");
var p = WinJS.UI.Pages.render(url, host, eventObject.detail.state).
then(function () {
var navHistory = nav.history;
app.sessionState.navigationHistory = {
backStack: navHistory.backStack.slice(0),
forwardStack: navHistory.forwardStack.slice(0),
current: navHistory.current
};
app.sessionState.lastUrl = url;
});
p.done();
eventObject.detail.setPromise(p);
}
function handleSplitViewButton() {
splitView.paneOpened = !splitView.paneOpened;
}
function handleResize() {
if (window.innerWidth > 768) {
splitView.closedDisplayMode = WinJS.UI.SplitView.ClosedDisplayMode.none;
splitView.openedDisplayMode = WinJS.UI.SplitView.OpenedDisplayMode.inline;
} else {
splitView.closedDisplayMode = WinJS.UI.SplitView.ClosedDisplayMode.none;
splitView.openedDisplayMode = WinJS.UI.SplitView.OpenedDisplayMode.overlay;
splitView.closePane();
}
}
nav.addEventListener("navigating", navigating);
app.addEventListener("activated", activated, false);
app.start();
})();
window.onerror = function (E) {
debugger;
}
|
'use strict';
var DefaultNode = require('./default');
var Node = require('./');
var ParameterNode = require('./parameter');
var Insert = Node.define({
type: 'INSERT',
constructor: function () {
Node.call(this);
this.names = [];
this.columns = [];
this.valueSets = [];
}
});
module.exports = Insert;
Insert.prototype.add = function (nodes) {
var hasColumns = false;
var hasValues = false;
var self = this;
var values = {};
nodes.forEach(function (node) {
var column = node.toNode();
var name = column.name;
var idx = self.names.indexOf(name);
if (idx < 0) {
self.names.push(name);
self.columns.push(column);
}
hasColumns = true;
hasValues = hasValues || column.value !== undefined;
values[name] = column;
});
// When none of the columns have a value, it's ambiguous whether the user
// intends to insert a row of default values or append a SELECT statement
// later. Resolve the ambiguity by assuming that if no columns are specified
// it is a row of default values, otherwise a SELECT will be added.
if (hasValues || !hasColumns) {
this.valueSets.push(values);
}
return self;
};
/*
* Get parameters for all values to be inserted. This function
* handles handles bulk inserts, where keys may be present
* in some objects and not others. When keys are not present,
* the insert should refer to the column value as DEFAULT.
*/
Insert.prototype.getParameters = function () {
var self = this;
return this.valueSets
.map(function (nodeDict) {
var set = [];
self.names.forEach(function (name) {
var node = nodeDict[name];
if (node) {
set.push(ParameterNode.getNodeOrParameterNode(node.value));
}
else {
set.push(new DefaultNode());
}
});
return set;
});
};
|
/**
* @author mrdoob / http://mrdoob.com/
*/
THREE.CSS2DObject = function ( element ) {
THREE.Object3D.call( this );
this.element = element;
this.element.style.position = 'absolute';
this.addEventListener( 'removed', function ( event ) {
if ( this.element.parentNode !== null ) {
this.element.parentNode.removeChild( this.element );
}
} );
};
THREE.CSS2DObject.prototype = Object.create( THREE.Object3D.prototype );
THREE.CSS2DObject.prototype.constructor = THREE.CSS2DObject;
//
THREE.CSS2DRenderer = function () {
console.log( 'THREE.CSS2DRenderer', THREE.REVISION );
var _width, _height;
var _widthHalf, _heightHalf;
var vector = new THREE.Vector3();
var viewMatrix = new THREE.Matrix4();
var viewProjectionMatrix = new THREE.Matrix4();
var domElement = document.createElement( 'div' );
domElement.style.overflow = 'hidden';
this.domElement = domElement;
this.setSize = function ( width, height ) {
_width = width;
_height = height;
_widthHalf = _width / 2;
_heightHalf = _height / 2;
domElement.style.width = width + 'px';
domElement.style.height = height + 'px';
};
var renderObject = function ( object, camera ) {
if ( object instanceof THREE.CSS2DObject ) {
vector.setFromMatrixPosition( object.matrixWorld );
vector.applyProjection( viewProjectionMatrix );
var element = object.element;
var style = 'translate(-50%,-50%) translate(' + ( vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - vector.y * _heightHalf + _heightHalf ) + 'px)';
element.style.WebkitTransform = style;
element.style.MozTransform = style;
element.style.oTransform = style;
element.style.transform = style;
if ( element.parentNode !== domElement ) {
domElement.appendChild( element );
}
}
for ( var i = 0, l = object.children.length; i < l; i ++ ) {
renderObject( object.children[ i ], camera );
}
};
this.render = function ( scene, camera ) {
scene.updateMatrixWorld();
if ( camera.parent === null ) camera.updateMatrixWorld();
camera.matrixWorldInverse.getInverse( camera.matrixWorld );
viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, viewMatrix );
renderObject( scene, camera );
};
};
|
// Ratio of Obese (BMI >= 30) in U.S. Adults, CDC 2008
var data = [
, .187, .198, , .133, .175, .151, , .1, .125, .171, , .172, .133, , .108,
.142, .167, .201, .175, .159, .169, .177, .141, .163, .117, .182, .153, .195,
.189, .134, .163, .133, .151, .145, .13, .139, .169, .164, .175, .135, .152,
.169, , .132, .167, .139, .184, .159, .14, .146, .157, , .139, .183, .16, .143
];
var svg = d3.select("#chart").append("svg")
.attr("width", 960)
.attr("height", 500);
d3.json("../data/us-states.json", function(json) {
var path = d3.geo.path();
// A thick black stroke for the exterior.
svg.append("g")
.attr("class", "black")
.selectAll("path")
.data(json.features)
.enter().append("path")
.attr("d", path);
// A white overlay to hide interior black strokes.
svg.append("g")
.attr("class", "white")
.selectAll("path")
.data(json.features)
.enter().append("path")
.attr("d", path);
// The polygons, scaled!
svg.append("g")
.attr("class", "grey")
.selectAll("path")
.data(json.features)
.enter().append("path")
.attr("d", path)
.attr("transform", function(d) {
var centroid = path.centroid(d),
x = centroid[0],
y = centroid[1];
return "translate(" + x + "," + y + ")"
+ "scale(" + Math.sqrt(data[+d.id] * 5 || 0) + ")"
+ "translate(" + -x + "," + -y + ")";
})
.style("stroke-width", function(d) {
return 1 / Math.sqrt(data[+d.id] * 5 || 1);
});
});
|
define(
//begin v1.x content
{
"field-second-relative+0": "现在",
"field-weekday": "星期",
"field-wed-relative+0": "本周三",
"field-wed-relative+1": "下周三",
"dateFormatItem-GyMMMEd": "Gy年M月d日E",
"dateFormatItem-MMMEd": "M月d日E",
"field-tue-relative+-1": "上周二",
"dateFormat-long": "Gy年M月d日",
"field-fri-relative+-1": "上周五",
"field-wed-relative+-1": "上周三",
"dateFormatItem-yyyyQQQ": "Gy年第Q季度",
"dateTimeFormat-medium": "{1} {0}",
"dateFormat-full": "Gy年M月d日EEEE",
"dateFormatItem-yyyyMEd": "Gy/M/dE",
"field-thu-relative+-1": "上周四",
"dateFormatItem-Md": "M/d",
"field-era": "纪元",
"field-year": "年",
"dateFormatItem-yyyyMMMM": "Gy年M月",
"field-hour": "小时",
"field-sat-relative+0": "本周六",
"field-sat-relative+1": "下周六",
"field-day-relative+0": "今天",
"field-day-relative+1": "明天",
"field-thu-relative+0": "本周四",
"dateFormatItem-GyMMMd": "Gy年M月d日",
"field-day-relative+2": "后天",
"field-thu-relative+1": "下周四",
"dateFormatItem-H": "H时",
"dateFormatItem-Gy": "Gy年",
"dateFormatItem-yyyyMMMEd": "Gy年M月d日E",
"dateFormatItem-M": "M月",
"dateFormatItem-yyyyMMM": "Gy年M月",
"dateFormatItem-yyyyMMMd": "Gy年M月d日",
"field-sun-relative+0": "本周日",
"dateFormatItem-Hm": "HH:mm",
"field-sun-relative+1": "下周日",
"field-minute": "分钟",
"field-dayperiod": "上午/下午",
"dateFormatItem-d": "d日",
"dateFormatItem-ms": "mm:ss",
"field-day-relative+-1": "昨天",
"dateFormatItem-h": "ah时",
"dateTimeFormat-long": "{1} {0}",
"field-day-relative+-2": "前天",
"dateFormatItem-MMMd": "M月d日",
"dateFormatItem-MEd": "M/dE",
"dateTimeFormat-full": "{1} {0}",
"field-fri-relative+0": "本周五",
"field-fri-relative+1": "下周五",
"field-day": "日",
"field-zone": "时区",
"dateFormatItem-y": "Gy年",
"field-year-relative+-1": "去年",
"field-month-relative+-1": "上个月",
"dateFormatItem-hm": "ah:mm",
"dateFormatItem-yyyyMd": "Gy/M/d",
"field-month": "月",
"dateFormatItem-MMM": "LLL",
"field-tue-relative+0": "本周二",
"field-tue-relative+1": "下周二",
"field-mon-relative+0": "本周一",
"field-mon-relative+1": "下周一",
"dateFormat-short": "Gy/M/d",
"field-second": "秒钟",
"field-sat-relative+-1": "上周六",
"field-sun-relative+-1": "上周日",
"field-month-relative+0": "本月",
"field-month-relative+1": "下个月",
"dateFormatItem-Ed": "d日E",
"field-week": "周",
"dateFormat-medium": "Gy年M月d日",
"field-year-relative+0": "今年",
"field-week-relative+-1": "上周",
"dateFormatItem-yyyyM": "Gy年M月",
"field-year-relative+1": "明年",
"dateFormatItem-yyyyQQQQ": "Gy年第Q季度",
"dateTimeFormat-short": "{1} {0}",
"dateFormatItem-Hms": "HH:mm:ss",
"dateFormatItem-hms": "ah:mm:ss",
"dateFormatItem-GyMMM": "Gy年M月",
"field-mon-relative+-1": "上周一",
"dateFormatItem-yyyy": "Gy年",
"field-week-relative+0": "本周",
"field-week-relative+1": "下周"
}
//end v1.x content
);
|
// Copyright 2013 Traceur Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
const $ceil = Math.ceil;
const $floor = Math.floor;
const $isFinite = isFinite;
const $isNaN = isNaN;
const $pow = Math.pow;
const $min = Math.min;
const $TypeError = TypeError;
const $Object = Object;
export function toObject(x) {
if (x == null) { // Needs to be ==
throw $TypeError();
}
return $Object(x);
}
export function toUint32(x) {
return x >>> 0;
}
export function isObject(x) {
return x && (typeof x === 'object' || typeof x === 'function');
}
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-iscallable
export function isCallable(x) {
return typeof x === 'function';
}
export function isNumber(x) {
return typeof x === 'number';
}
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tointeger
export function toInteger(x) {
x = +x;
if ($isNaN(x)) return 0;
if (x === 0 || !$isFinite(x)) return x;
return x > 0 ? $floor(x) : $ceil(x);
}
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
var MAX_SAFE_LENGTH = $pow(2, 53) - 1;
export function toLength(x) {
var len = toInteger(x);
return len < 0 ? 0 : $min(len, MAX_SAFE_LENGTH);
}
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-checkiterable
export function checkIterable(x) {
return !isObject(x) ? undefined : x[Symbol.iterator];
}
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor
export function isConstructor(x) {
return isCallable(x);
}
// 15.19.4.3.4 CreateIterResultObject
export function createIteratorResultObject(value, done) {
return {value: value, done: done};
}
export function maybeDefine(object, name, descr) {
if (!(name in object)) {
Object.defineProperty(object, name, descr);
}
}
export function maybeDefineMethod(object, name, value) {
maybeDefine(object, name, {
value: value,
configurable: true,
enumerable: false,
writable: true
});
}
export function maybeDefineConst(object, name, value) {
maybeDefine(object, name, {
value: value,
configurable: false,
enumerable: false,
writable: false
});
}
export function maybeAddFunctions(object, functions) {
for (var i = 0; i < functions.length; i += 2) {
var name = functions[i];
var value = functions[i + 1];
maybeDefineMethod(object, name, value);
}
}
export function maybeAddConsts(object, consts) {
for (var i = 0; i < consts.length; i += 2) {
var name = consts[i];
var value = consts[i + 1];
maybeDefineConst(object, name, value);
}
}
export function maybeAddIterator(object, func, Symbol) {
if (!Symbol || !Symbol.iterator || object[Symbol.iterator])
return;
// Firefox does not have symbols so they use a hack.
if (object['@@iterator'])
func = object['@@iterator'];
Object.defineProperty(object, Symbol.iterator, {
value: func,
configurable: true,
enumerable: false,
writable: true
});
}
var polyfills = [];
export function registerPolyfill(func) {
polyfills.push(func);
}
export function polyfillAll(global) {
polyfills.forEach((f) => f(global));
}
|
/*
* FeedEk jQuery RSS/ATOM Feed Plugin v3.0 with YQL API
* http://jquery-plugins.net/FeedEk/FeedEk.html https://github.com/enginkizil/FeedEk
* Author : Engin KIZIL http://www.enginkizil.com
*/
(function ($) {
$.fn.FeedEk = function (opt) {
var def = $.extend({
FeedUrl: "http://jquery-plugins.net/rss",
MaxCount: 5,
ShowDesc: true,
ShowPubDate: true,
DescCharacterLimit: 0,
TitleLinkTarget: "_blank",
DateFormat: "",
DateFormatLang:"en"
}, opt);
var id = $(this).attr("id"), i, s = "",dt;
$("#" + id).empty().append('<img src="loader.gif" />');
var YQLstr = 'SELECT channel.item FROM feednormalizer WHERE output="rss_2.0" AND url ="' + def.FeedUrl + '" LIMIT ' + def.MaxCount;
$.ajax({
url: "https://query.yahooapis.com/v1/public/yql?q=" + encodeURIComponent(YQLstr) + "&format=json&diagnostics=true&callback=?",
dataType: "json",
success: function (data) {
$("#" + id).empty();
$.each(data.query.results.rss, function (e, itm) {
s += '<li><div class="itemTitle"><a href="' + itm.channel.item.link + '" target="' + def.TitleLinkTarget + '" >' + itm.channel.item.title + '</a></div>';
if (def.ShowPubDate){
dt = new Date(itm.channel.item.pubDate);
s += '<div class="itemDate">';
if ($.trim(def.DateFormat).length > 0) {
try {
moment.lang(def.DateFormatLang);
s += moment(dt).format(def.DateFormat);
}
catch (e){s += dt.toLocaleDateString();}
}
else {
s += dt.toLocaleDateString();
}
s += '</div>';
}
if (def.ShowDesc) {
s += '<div class="itemContent">';
if (def.DescCharacterLimit > 0 && itm.channel.item.description.length > def.DescCharacterLimit) {
s += itm.channel.item.description.substring(0, def.DescCharacterLimit) + '...';
}
else {
s += itm.channel.item.description;
}
s += '</div>';
}
});
$("#" + id).append('<ul class="feedEkList">' + s + '</ul>');
}
});
};
})(jQuery);
|
/* $Id: align.js,v 1.3 2009/02/11 20:08:33 bdragon Exp $ */
/**
* @file
* Alignment widget.
* Applies CSS classes to a macro.
*/
/*global $, Drupal */
Drupal.gmap.addHandler('align', function (elem) {
var obj = this;
// Respond to incoming alignment changes.
var binding = obj.bind("alignchange", function () {
elem.value = obj.vars.align;
});
// Send out outgoing alignment changes.
$(elem).change(function () {
obj.vars.align = elem.value;
obj.change("alignchange", binding);
});
});
Drupal.gmap.addHandler('gmap', function (elem) {
var obj = this;
// Respond to incoming alignment changes.
obj.bind("alignchange", function () {
var cont = obj.map.getContainer();
$(cont)
.removeClass('gmap-left')
.removeClass('gmap-center')
.removeClass('gmap-right');
if (obj.vars.align === 'Left') {
$(cont).addClass('gmap-left');
}
if (obj.vars.align === 'Center') {
$(cont).addClass('gmap-center');
}
if (obj.vars.align === 'Right') {
$(cont).addClass('gmap-right');
}
});
// Send out outgoing alignment changes.
// N/A
obj.bind('buildmacro', function (add) {
if (obj.vars.align && obj.vars.align !== 'None') {
add.push('align=' + obj.vars.align);
}
});
});
|
'use strict';
module.exports = {
set: function (v) {
this.setProperty('max-width', v);
},
get: function () {
return this.getPropertyValue('max-width');
},
enumerable: true
};
|
/*
* L.FeatureGroup extends L.LayerGroup by introducing mouse events and additional methods
* shared between a group of interactive layers (like vectors or markers).
*/
L.FeatureGroup = L.LayerGroup.extend({
includes: L.Mixin.Events,
statics: {
EVENTS: 'click dblclick mouseover mouseout mousemove contextmenu popupopen popupclose'
},
addLayer: function (layer) {
if (this.hasLayer(layer)) {
return this;
}
if ('on' in layer) {
layer.on(L.FeatureGroup.EVENTS, this._propagateEvent, this);
}
L.LayerGroup.prototype.addLayer.call(this, layer);
if (this._popupContent && layer.bindPopup) {
layer.bindPopup(this._popupContent, this._popupOptions);
}
return this.fire('layeradd', {layer: layer});
},
removeLayer: function (layer) {
if (!this.hasLayer(layer)) {
return this;
}
if (layer in this._layers) {
layer = this._layers[layer];
}
layer.off(L.FeatureGroup.EVENTS, this._propagateEvent, this);
L.LayerGroup.prototype.removeLayer.call(this, layer);
if (this._popupContent) {
this.invoke('unbindPopup');
}
return this.fire('layerremove', {layer: layer});
},
bindPopup: function (content, options) {
this._popupContent = content;
this._popupOptions = options;
return this.invoke('bindPopup', content, options);
},
openPopup: function (latlng) {
// open popup on the first layer
for (var id in this._layers) {
this._layers[id].openPopup(latlng);
break;
}
return this;
},
setStyle: function (style) {
return this.invoke('setStyle', style);
},
bringToFront: function () {
return this.invoke('bringToFront');
},
bringToBack: function () {
return this.invoke('bringToBack');
},
getBounds: function () {
var bounds = new L.LatLngBounds();
this.eachLayer(function (layer) {
bounds.extend(layer instanceof L.Marker ? layer.getLatLng() : layer.getBounds());
});
return bounds;
},
_propagateEvent: function (e) {
e = L.extend({
layer: e.target,
target: this
}, e);
this.fire(e.type, e);
}
});
L.featureGroup = function (layers) {
return new L.FeatureGroup(layers);
};
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var LOG = function(msg) {
window.console.log(msg);
};
var failTest = function() {
chrome.test.sendMessage('WebViewTest.FAILURE');
};
var startTest = function() {
document.querySelector('#webview-tag-container').innerHTML =
'<webview style="width: 10px; height: 10px; margin: 0; padding: 0;"' +
'></webview>';
var webview = document.querySelector('webview');
var onLoadStop = function(e) {
chrome.test.sendMessage('LAUNCHED');
};
webview.addEventListener('loadstop', onLoadStop);
webview.src = 'data:text/html,<body>Guest</body>';
};
window.onAppCommand = function(command) {
LOG('onAppCommand: ' + command);
switch (command) {
case 'hide-guest':
document.querySelector('webview').style.display = 'none';
break;
case 'hide-embedder':
document.body.style.display = 'none';
break;
default:
failTest();
break;
}
};
window.onload = startTest;
|
export default function _initializerWarningHelper(descriptor, context) {
throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.');
}
|
/**
* Redux Checkbox
* Dependencies : jquery
* Feature added by : Dovy Paukstys
* Date : 17 June 2014
*/
/*global redux_change, wp, redux*/
(function( $ ) {
"use strict";
redux.field_objects = redux.field_objects || {};
redux.field_objects.checkbox = redux.field_objects.checkbox || {};
$( document ).ready(
function() {
//redux.field_objects.checkbox.init();
}
);
redux.field_objects.checkbox.init = function( selector ) {
if ( !selector ) {
selector = $( document ).find( '.redux-container-checkbox' );
}
$( selector ).each(
function() {
var el = $( this );
var parent = el;
if ( !el.hasClass( 'redux-field-container' ) ) {
parent = el.parents( '.redux-field-container:first' );
}
if ( parent.hasClass( 'redux-field-init' ) ) {
parent.removeClass( 'redux-field-init' );
} else {
return;
}
el.find( '.checkbox' ).on(
'click', function( e ) {
var val = 0;
if ($(this).is(':checked')) {
val = $(this).parent().find('.checkbox-check' ).attr('data-val');
}
$(this).parent().find('.checkbox-check').val(val);
redux_change( $( this ) );
}
);
}
);
};
})( jQuery );
|
if ( 'undefined' !== typeof(jQuery.fn.bxSlider) ) {
jQuery( '.bxslider' ).each( function () {
var $slider = jQuery( this );
$slider.bxSlider( $slider.data( 'settings' ) );
} );
}
if ( 'undefined' !== typeof(window.Swiper) ) {
jQuery( '.swiper-container' ).each( function () {
var $this = jQuery( this ),
my_swiper,
max_slide_size = 0,
options = jQuery( this ).data( 'settings' );
if ( 'vertical' === options.mode ) {
$this.find( '.swiper-slide' ).each( function () {
var height = jQuery( this ).outerHeight( true );
if ( height > max_slide_size ) {
max_slide_size = height;
}
} );
$this.height( max_slide_size );
$this.css( 'overflow', 'hidden' );
}
jQuery( window ).resize( function () {
$this.find( '.swiper-slide' ).each( function () {
var height = jQuery( this ).outerHeight( true );
if ( height > max_slide_size ) {
max_slide_size = height;
}
} );
$this.height( max_slide_size );
} );
my_swiper = jQuery( this ).swiper( jQuery.extend( options, {
onFirstInit: function ( swiper ) {
if ( 2 > swiper.slides.length ) {
$this.find( '.vc_arrow-left,.vc_arrow-right' ).hide();
} else if ( 0 === swiper.activeIndex && true !== swiper.params.loop ) {
$this.find( '.vc_arrow-left' ).hide();
} else {
$this.find( '.vc_arrow-left' ).show();
}
},
onSlideChangeStart: function ( swiper ) {
if ( 1 < swiper.slides.length && true !== swiper.params.loop ) {
if ( 0 === swiper.activeIndex ) {
$this.find( '.vc_arrow-left' ).hide();
} else {
$this.find( '.vc_arrow-left' ).show();
}
if ( swiper.slides.length - 1 === swiper.activeIndex ) {
$this.find( '.vc_arrow-right' ).hide();
} else {
$this.find( '.vc_arrow-right' ).show();
}
}
}
} ) );
$this.find( '.vc_arrow-left' ).click( function ( e ) {
e.preventDefault();
my_swiper.swipePrev();
} );
$this.find( '.vc_arrow-right' ).click( function ( e ) {
e.preventDefault();
my_swiper.swipeNext();
} );
my_swiper.reInit();
} );
}
|
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var Observable_1 = require('../Observable');
var tryCatch_1 = require('../util/tryCatch');
var errorObject_1 = require('../util/errorObject');
var Subscription_1 = require('../Subscription');
function isNodeStyleEventEmmitter(sourceObj) {
return !!sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';
}
function isJQueryStyleEventEmitter(sourceObj) {
return !!sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';
}
function isNodeList(sourceObj) {
return !!sourceObj && sourceObj.toString() === '[object NodeList]';
}
function isHTMLCollection(sourceObj) {
return !!sourceObj && sourceObj.toString() === '[object HTMLCollection]';
}
function isEventTarget(sourceObj) {
return !!sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';
}
/**
* We need this JSDoc comment for affecting ESDoc.
* @extends {Ignored}
* @hide true
*/
var FromEventObservable = (function (_super) {
__extends(FromEventObservable, _super);
function FromEventObservable(sourceObj, eventName, selector) {
_super.call(this);
this.sourceObj = sourceObj;
this.eventName = eventName;
this.selector = selector;
}
/**
* @param sourceObj
* @param eventName
* @param selector
* @return {FromEventObservable}
* @static true
* @name fromEvent
* @owner Observable
*/
FromEventObservable.create = function (sourceObj, eventName, selector) {
return new FromEventObservable(sourceObj, eventName, selector);
};
FromEventObservable.setupSubscription = function (sourceObj, eventName, handler, subscriber) {
var unsubscribe;
if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
for (var i = 0, len = sourceObj.length; i < len; i++) {
FromEventObservable.setupSubscription(sourceObj[i], eventName, handler, subscriber);
}
}
else if (isEventTarget(sourceObj)) {
sourceObj.addEventListener(eventName, handler);
unsubscribe = function () { return sourceObj.removeEventListener(eventName, handler); };
}
else if (isJQueryStyleEventEmitter(sourceObj)) {
sourceObj.on(eventName, handler);
unsubscribe = function () { return sourceObj.off(eventName, handler); };
}
else if (isNodeStyleEventEmmitter(sourceObj)) {
sourceObj.addListener(eventName, handler);
unsubscribe = function () { return sourceObj.removeListener(eventName, handler); };
}
subscriber.add(new Subscription_1.Subscription(unsubscribe));
};
FromEventObservable.prototype._subscribe = function (subscriber) {
var sourceObj = this.sourceObj;
var eventName = this.eventName;
var selector = this.selector;
var handler = selector ? function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i - 0] = arguments[_i];
}
var result = tryCatch_1.tryCatch(selector).apply(void 0, args);
if (result === errorObject_1.errorObject) {
subscriber.error(errorObject_1.errorObject.e);
}
else {
subscriber.next(result);
}
} : function (e) { return subscriber.next(e); };
FromEventObservable.setupSubscription(sourceObj, eventName, handler, subscriber);
};
return FromEventObservable;
}(Observable_1.Observable));
exports.FromEventObservable = FromEventObservable;
//# sourceMappingURL=FromEventObservable.js.map
|
/**
* LegacyInput.js
*
* Copyright 2009, Moxiecode Systems AB
* Released under LGPL License.
*
* License: http://tinymce.moxiecode.com/license
* Contributing: http://tinymce.moxiecode.com/contributing
*/
tinymce.onAddEditor.add(function(tinymce, ed) {
var filters, fontSizes, dom, settings = ed.settings;
if (settings.inline_styles) {
fontSizes = tinymce.explode(settings.font_size_style_values);
function replaceWithSpan(node, styles) {
tinymce.each(styles, function(value, name) {
if (value)
dom.setStyle(node, name, value);
});
dom.rename(node, 'span');
};
filters = {
font : function(dom, node) {
replaceWithSpan(node, {
backgroundColor : node.style.backgroundColor,
color : node.color,
fontFamily : node.face,
fontSize : fontSizes[parseInt(node.size) - 1]
});
},
u : function(dom, node) {
replaceWithSpan(node, {
textDecoration : 'underline'
});
},
strike : function(dom, node) {
replaceWithSpan(node, {
textDecoration : 'line-through'
});
}
};
function convert(editor, params) {
dom = editor.dom;
if (settings.convert_fonts_to_spans) {
tinymce.each(dom.select('font,u,strike', params.node), function(node) {
filters[node.nodeName.toLowerCase()](ed.dom, node);
});
}
};
ed.onPreProcess.add(convert);
ed.onSetContent.add(convert);
ed.onInit.add(function() {
ed.selection.onSetContent.add(convert);
});
}
});
|
'use strict';
var ensureString = require('../../object/validate-stringifiable-value');
module.exports = function (search) {
var string = ensureString(this), count = 0, index = 0;
search = ensureString(search);
if (!search) throw new TypeError("Search string cannot be empty");
while (true) {
index = string.indexOf(search, index);
if (index === -1) break;
++count;
index += search.length;
}
return count;
};
|
/*!
* Bootstrap-select v1.12.4 (http://silviomoreto.github.io/bootstrap-select)
*
* Copyright 2013-2017 bootstrap-select
* Licensed under MIT (https://github.com/silviomoreto/bootstrap-select/blob/master/LICENSE)
*/
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module unless amdModuleId is set
define(["jquery"], function (a0) {
return (factory(a0));
});
} else if (typeof module === 'object' && module.exports) {
// Node. Does not work with strict CommonJS, but
// only CommonJS-like environments that support module.exports,
// like Node.
module.exports = factory(require("jquery"));
} else {
factory(root["jQuery"]);
}
}(this, function (jQuery) {
(function ($) {
$.fn.selectpicker.defaults = {
noneSelectedText: '何もが選択した',
noneResultsText: '\'{0}\'が結果を返さない',
countSelectedText: '{0}/{1}が選択した',
maxOptionsText: ['限界は達した({n}{var}最大)', '限界をグループは達した({n}{var}最大)', ['アイテム', 'アイテム']],
selectAllText: '全部を選択する',
deselectAllText: '何も選択しない',
multipleSeparator: ', '
};
})(jQuery);
}));
|
/*
Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'table', 'vi', {
border: 'Kích thước đường viền',
caption: 'Đầu đề',
cell: {
menu: 'Ô',
insertBefore: 'Chèn ô Phía trước',
insertAfter: 'Chèn ô Phía sau',
deleteCell: 'Xoá ô',
merge: 'Kết hợp ô',
mergeRight: 'Kết hợp sang phải',
mergeDown: 'Kết hợp xuống dưới',
splitHorizontal: 'Phân tách ô theo chiều ngang',
splitVertical: 'Phân tách ô theo chiều dọc',
title: 'Thuộc tính của ô',
cellType: 'Kiểu của ô',
rowSpan: 'Kết hợp hàng',
colSpan: 'Kết hợp cột',
wordWrap: 'Chữ liền hàng',
hAlign: 'Canh lề ngang',
vAlign: 'Canh lề dọc',
alignBaseline: 'Đường cơ sở',
bgColor: 'Màu nền',
borderColor: 'Màu viền',
data: 'Dữ liệu',
header: 'Đầu đề',
yes: 'Có',
no: 'Không',
invalidWidth: 'Chiều rộng của ô phải là một số nguyên.',
invalidHeight: 'Chiều cao của ô phải là một số nguyên.',
invalidRowSpan: 'Số hàng kết hợp phải là một số nguyên.',
invalidColSpan: 'Số cột kết hợp phải là một số nguyên.',
chooseColor: 'Chọn màu'
},
cellPad: 'Khoảng đệm giữ ô và nội dung',
cellSpace: 'Khoảng cách giữa các ô',
column: {
menu: 'Cột',
insertBefore: 'Chèn cột phía trước',
insertAfter: 'Chèn cột phía sau',
deleteColumn: 'Xoá cột'
},
columns: 'Số cột',
deleteTable: 'Xóa bảng',
headers: 'Đầu đề',
headersBoth: 'Cả hai',
headersColumn: 'Cột đầu tiên',
headersNone: 'Không có',
headersRow: 'Hàng đầu tiên',
invalidBorder: 'Kích cỡ của đường biên phải là một số nguyên.',
invalidCellPadding: 'Khoảng đệm giữa ô và nội dung phải là một số nguyên.',
invalidCellSpacing: 'Khoảng cách giữa các ô phải là một số nguyên.',
invalidCols: 'Số lượng cột phải là một số lớn hơn 0.',
invalidHeight: 'Chiều cao của bảng phải là một số nguyên.',
invalidRows: 'Số lượng hàng phải là một số lớn hơn 0.',
invalidWidth: 'Chiều rộng của bảng phải là một số nguyên.',
menu: 'Thuộc tính bảng',
row: {
menu: 'Hàng',
insertBefore: 'Chèn hàng phía trước',
insertAfter: 'Chèn hàng phía sau',
deleteRow: 'Xoá hàng'
},
rows: 'Số hàng',
summary: 'Tóm lược',
title: 'Thuộc tính bảng',
toolbar: 'Bảng',
widthPc: 'Phần trăm (%)',
widthPx: 'Điểm ảnh (px)',
widthUnit: 'Đơn vị'
});
|
/*
Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'table', 'ug', {
border: 'گىرۋەك',
caption: 'ماۋزۇ',
cell: {
menu: 'كاتەكچە',
insertBefore: 'سولغا كاتەكچە قىستۇر',
insertAfter: 'ئوڭغا كاتەكچە قىستۇر',
deleteCell: 'كەتەكچە ئۆچۈر',
merge: 'كاتەكچە بىرلەشتۈر',
mergeRight: 'كاتەكچىنى ئوڭغا بىرلەشتۈر',
mergeDown: 'كاتەكچىنى ئاستىغا بىرلەشتۈر',
splitHorizontal: 'كاتەكچىنى توغرىسىغا بىرلەشتۈر',
splitVertical: 'كاتەكچىنى بويىغا بىرلەشتۈر',
title: 'كاتەكچە خاسلىقى',
cellType: 'كاتەكچە تىپى',
rowSpan: 'بويىغا چات ئارىسى قۇر سانى',
colSpan: 'توغرىسىغا چات ئارىسى ئىستون سانى',
wordWrap: 'ئۆزلۈكىدىن قۇر قاتلا',
hAlign: 'توغرىسىغا توغرىلا',
vAlign: 'بويىغا توغرىلا',
alignBaseline: 'ئاساسىي سىزىق',
bgColor: 'تەگلىك رەڭگى',
borderColor: 'گىرۋەك رەڭگى',
data: 'سانلىق مەلۇمات',
header: 'جەدۋەل باشى',
yes: 'ھەئە',
no: 'ياق',
invalidWidth: 'كاتەكچە كەڭلىكى چوقۇم سان بولىدۇ',
invalidHeight: 'كاتەكچە ئېگىزلىكى چوقۇم سان بولىدۇ',
invalidRowSpan: 'قۇر چات ئارىسى چوقۇم پۈتۈن سان بولىدۇ ',
invalidColSpan: 'ئىستون چات ئارىسى چوقۇم پۈتۈن سان بولىدۇ',
chooseColor: 'تاللاڭ'
},
cellPad: 'يان ئارىلىق',
cellSpace: 'ئارىلىق',
column: {
menu: 'ئىستون',
insertBefore: 'سولغا ئىستون قىستۇر',
insertAfter: 'ئوڭغا ئىستون قىستۇر',
deleteColumn: 'ئىستون ئۆچۈر'
},
columns: 'ئىستون سانى',
deleteTable: 'جەدۋەل ئۆچۈر',
headers: 'ماۋزۇ كاتەكچە',
headersBoth: 'بىرىنچى ئىستون ۋە بىرىنچى قۇر',
headersColumn: 'بىرىنچى ئىستون',
headersNone: 'يوق',
headersRow: 'بىرىنچى قۇر',
invalidBorder: 'گىرۋەك توملۇقى چوقۇم سان بولىدۇ',
invalidCellPadding: 'كاتەكچىگە چوقۇم سان تولدۇرۇلىدۇ',
invalidCellSpacing: 'كاتەكچە ئارىلىقى چوقۇم سان بولىدۇ',
invalidCols: 'بەلگىلەنگەن قۇر سانى چوقۇم نۆلدىن چوڭ بولىدۇ',
invalidHeight: 'جەدۋەل ئېگىزلىكى چوقۇم سان بولىدۇ',
invalidRows: 'بەلگىلەنگەن ئىستون سانى چوقۇم نۆلدىن چوڭ بولىدۇ',
invalidWidth: 'جەدۋەل كەڭلىكى چوقۇم سان بولىدۇ',
menu: 'جەدۋەل خاسلىقى',
row: {
menu: 'قۇر',
insertBefore: 'ئۈستىگە قۇر قىستۇر',
insertAfter: 'ئاستىغا قۇر قىستۇر',
deleteRow: 'قۇر ئۆچۈر'
},
rows: 'قۇر سانى',
summary: 'ئۈزۈندە',
title: 'جەدۋەل خاسلىقى',
toolbar: 'جەدۋەل',
widthPc: 'پىرسەنت',
widthPx: 'پىكسېل',
widthUnit: 'كەڭلىك بىرلىكى'
});
|
'use strict';
angular.module("ngLocale", [], ["$provide", function($provide) {
var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
function getDecimals(n) {
n = n + '';
var i = n.indexOf('.');
return (i == -1) ? 0 : n.length - i - 1;
}
function getVF(n, opt_precision) {
var v = opt_precision;
if (undefined === v) {
v = Math.min(getDecimals(n), 3);
}
var base = Math.pow(10, v);
var f = ((n * base) | 0) % base;
return {v: v, f: f};
}
$provide.value("$locale", {
"DATETIME_FORMATS": {
"AMPMS": [
"kang\u2019ama",
"kingoto"
],
"DAY": [
"Ijumapili",
"Ijumatatu",
"Ijumanne",
"Ijumatano",
"Alhamisi",
"Ijumaa",
"Ijumamosi"
],
"ERANAMES": [
"Kabla ya Mayesu",
"Baada ya Mayesu"
],
"ERAS": [
"KM",
"BM"
],
"FIRSTDAYOFWEEK": 0,
"MONTH": [
"Mweri wa kwanza",
"Mweri wa kaili",
"Mweri wa katatu",
"Mweri wa kaana",
"Mweri wa tanu",
"Mweri wa sita",
"Mweri wa saba",
"Mweri wa nane",
"Mweri wa tisa",
"Mweri wa ikumi",
"Mweri wa ikumi na moja",
"Mweri wa ikumi na mbili"
],
"SHORTDAY": [
"Ijp",
"Ijt",
"Ijn",
"Ijtn",
"Alh",
"Iju",
"Ijm"
],
"SHORTMONTH": [
"M1",
"M2",
"M3",
"M4",
"M5",
"M6",
"M7",
"M8",
"M9",
"M10",
"M11",
"M12"
],
"STANDALONEMONTH": [
"Mweri wa kwanza",
"Mweri wa kaili",
"Mweri wa katatu",
"Mweri wa kaana",
"Mweri wa tanu",
"Mweri wa sita",
"Mweri wa saba",
"Mweri wa nane",
"Mweri wa tisa",
"Mweri wa ikumi",
"Mweri wa ikumi na moja",
"Mweri wa ikumi na mbili"
],
"WEEKENDRANGE": [
5,
6
],
"fullDate": "EEEE, d MMMM y",
"longDate": "d MMMM y",
"medium": "d MMM y HH:mm:ss",
"mediumDate": "d MMM y",
"mediumTime": "HH:mm:ss",
"short": "dd/MM/y HH:mm",
"shortDate": "dd/MM/y",
"shortTime": "HH:mm"
},
"NUMBER_FORMATS": {
"CURRENCY_SYM": "TSh",
"DECIMAL_SEP": ".",
"GROUP_SEP": ",",
"PATTERNS": [
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 3,
"minFrac": 0,
"minInt": 1,
"negPre": "-",
"negSuf": "",
"posPre": "",
"posSuf": ""
},
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 0,
"minFrac": 0,
"minInt": 1,
"negPre": "-\u00a4",
"negSuf": "",
"posPre": "\u00a4",
"posSuf": ""
}
]
},
"id": "rof-tz",
"localeID": "rof_TZ",
"pluralCat": function(n, opt_precision) { var i = n | 0; var vf = getVF(n, opt_precision); if (i == 1 && vf.v == 0) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;}
});
}]);
|
'use strict';
angular.module("ngLocale", [], ["$provide", function($provide) {
var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
$provide.value("$locale", {
"DATETIME_FORMATS": {
"AMPMS": [
"AM",
"PM"
],
"DAY": [
"domingo",
"segunda-feira",
"ter\u00e7a-feira",
"quarta-feira",
"quinta-feira",
"sexta-feira",
"s\u00e1bado"
],
"MONTH": [
"janeiro",
"fevereiro",
"mar\u00e7o",
"abril",
"maio",
"junho",
"julho",
"agosto",
"setembro",
"outubro",
"novembro",
"dezembro"
],
"SHORTDAY": [
"dom",
"seg",
"ter",
"qua",
"qui",
"sex",
"s\u00e1b"
],
"SHORTMONTH": [
"jan",
"fev",
"mar",
"abr",
"mai",
"jun",
"jul",
"ago",
"set",
"out",
"nov",
"dez"
],
"fullDate": "EEEE, d 'de' MMMM 'de' y",
"longDate": "d 'de' MMMM 'de' y",
"medium": "dd/MM/yyyy HH:mm:ss",
"mediumDate": "dd/MM/yyyy",
"mediumTime": "HH:mm:ss",
"short": "dd/MM/yy HH:mm",
"shortDate": "dd/MM/yy",
"shortTime": "HH:mm"
},
"NUMBER_FORMATS": {
"CURRENCY_SYM": "R$",
"DECIMAL_SEP": ",",
"GROUP_SEP": ".",
"PATTERNS": [
{
"gSize": 3,
"lgSize": 3,
"macFrac": 0,
"maxFrac": 3,
"minFrac": 0,
"minInt": 1,
"negPre": "-",
"negSuf": "",
"posPre": "",
"posSuf": ""
},
{
"gSize": 3,
"lgSize": 3,
"macFrac": 0,
"maxFrac": 2,
"minFrac": 2,
"minInt": 1,
"negPre": "(\u00a4",
"negSuf": ")",
"posPre": "\u00a4",
"posSuf": ""
}
]
},
"id": "pt-mz",
"pluralCat": function (n) { if (n == 1) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;}
});
}]);
|
var m1 = require("ref/m1");
var m2 = require("../outputdir_module_multifolder_ref/m2");
exports.a1 = 10;
var c1 = (function () {
function c1() {
}
return c1;
})();
exports.c1 = c1;
exports.instance1 = new c1();
function f1() {
return exports.instance1;
}
exports.f1 = f1;
exports.a2 = m1.m1_c1;
exports.a3 = m2.m2_c1;
//# sourceMappingURL=http://www.typescriptlang.org/outputdir_module_multifolder/test.js.map
|
export { default } from './DialogTitle';
|
/**
* Copyright 2013-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*
*/
'use strict';
var nextDebugID = 1;
function getNextDebugID() {
return nextDebugID++;
}
module.exports = getNextDebugID;
|
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2015 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
/**
* Connects two bodies at given offset points, letting them rotate relative to each other around this point.
* The pivot points are given in world (pixel) coordinates.
*
* @class Phaser.Physics.P2.RevoluteConstraint
* @constructor
* @param {Phaser.Physics.P2} world - A reference to the P2 World.
* @param {p2.Body} bodyA - First connected body.
* @param {Float32Array} pivotA - The point relative to the center of mass of bodyA which bodyA is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
* @param {p2.Body} bodyB - Second connected body.
* @param {Float32Array} pivotB - The point relative to the center of mass of bodyB which bodyB is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
* @param {number} [maxForce=0] - The maximum force that should be applied to constrain the bodies.
* @param {Float32Array} [worldPivot=null] - A pivot point given in world coordinates. If specified, localPivotA and localPivotB are automatically computed from this value.
*/
Phaser.Physics.P2.RevoluteConstraint = function (world, bodyA, pivotA, bodyB, pivotB, maxForce, worldPivot) {
if (maxForce === undefined) { maxForce = Number.MAX_VALUE; }
if (worldPivot === undefined) { worldPivot = null; }
/**
* @property {Phaser.Game} game - Local reference to game.
*/
this.game = world.game;
/**
* @property {Phaser.Physics.P2} world - Local reference to P2 World.
*/
this.world = world;
pivotA = [ world.pxmi(pivotA[0]), world.pxmi(pivotA[1]) ];
pivotB = [ world.pxmi(pivotB[0]), world.pxmi(pivotB[1]) ];
if (worldPivot)
{
worldPivot = [ world.pxmi(worldPivot[0]), world.pxmi(worldPivot[1]) ];
}
var options = { worldPivot: worldPivot, localPivotA: pivotA, localPivotB: pivotB, maxForce: maxForce };
p2.RevoluteConstraint.call(this, bodyA, bodyB, options);
};
Phaser.Physics.P2.RevoluteConstraint.prototype = Object.create(p2.RevoluteConstraint.prototype);
Phaser.Physics.P2.RevoluteConstraint.prototype.constructor = Phaser.Physics.P2.RevoluteConstraint;
|
/*
* Copyright (c) 2013 The Chromium Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
NaClTerm.prefix = 'lua'
NaClTerm.nmf = '//storage.googleapis.com/gonacl/demos/publish/234230_dev/lua/lua.nmf'
window.onload = function() {
lib.init(function() {
document.getElementById('shell').addEventListener('click', runLua, false);
document.getElementById('scimark').addEventListener('click', runSciMark, false);
document.getElementById('unittests').addEventListener('click', runUnitTests, false);
document.getElementById('binarytrees').addEventListener('click', runBinaryTrees, false);
document.getElementById('mandlebrot').addEventListener('click', runMandlebrot, false);
document.getElementById('donut').addEventListener('click', runDonut, false);
document.getElementById('fibonacci').addEventListener('click', runFibonacci, false);
document.getElementById('banner').addEventListener('click', runBanner, false);
NaClTerm.init();
});
};
function runLua() {
NaClTerm.argv = [];
term_.command.restartNaCl();
}
function runUnitTests() {
NaClTerm.argv = ['-e_U=true', 'all.lua']
term_.command.restartNaCl();
return false;
}
function runSciMark(e) {
NaClTerm.argv = ['/mnt/http/scimark.lua']
term_.command.restartNaCl();
return false;
}
function runBinaryTrees(e) {
NaClTerm.argv = ['/mnt/http/binarytrees.lua']
term_.command.restartNaCl();
return false;
}
function runMandlebrot(e) {
if (!term_.command.loaded)
runLua();
term_.command.sendMessage('for i=-1,1,.08 do for r=-2,1,.04 do I=i R=r n=0 b=I*I while n<26 and R*R+b<4 do I=2*R*I+i R=R*R-b+r b=I*I n=n+1 end io.write(string.char(n+32)) end print() end')
document.getElementById('terminal').focus();
}
function runFibonacci(e) {
if (!term_.command.loaded)
runLua();
term_.command.sendMessage('function fib(n) return n<2 and n or fib(n-1)+fib(n-2) end\nprint(fib(10))\nprint(fib(30))\n')
document.getElementById('terminal').focus();
}
function runBanner(e) {
if (!term_.command.loaded)
runLua();
term_.command.sendMessage(
't=0 A={64,36,35,42,33,61,59,58,126,45,44,46,32}L={0,254,195,3,224,135,231,127, \
124,60,128,255,120,158,207,199,241,252,192,121,30,31,61,227,1,223,243,188,63,251 \
,190,193,28,156,62,248,143,7,126}D={2,3,3,4,1,5,6,7,8,9,10,1,11,12,13,14,15,16,4 \
,1,10,14,7,17,18,10,1,19,3,20,21,15,15,3,22,21,11,7,17,18,23,2,24,25,13,14,15,26 \
,27,13,21,11,7,8,28,29,19,7,25,13,2,3,30,3,8,21,11,7,25,10,29,31,7,32,13,21,19, \
27,27,13,33,34,7,25,10,35,15,16,24,20,21,19,24,27,8,36,37,7,25,10,10,31,38,39,13 \
}B=bit32 M=math I=io.write T=string.char P=print S=M.sin C=M.cos F=M.floor b={} \
for i=1,1200 do b[i]=0 end for i,v in ipairs(D)do w=L[v]for j=1,8 do if B.band(w \
,1)==1 then b[160-48+i*8+j]=1 end w=B.rshift(w,1)end end P("\\x1b[2J") for w=1, \
4720 do P("\\x1b[H")s=1.06*S(t*.07)^2 for i=1,1200 do x=s*((i%60)-34)+34 y=s*(F(i \
/60)-15)+15 n=32 if y>=0 and y<20 and x>=0 and x<60 and b[F(y)*60+F(x)]==1 then \
n=A[M.min(F(((x-30+C(t)*20)^2+(y-S(t)^2*10)^2)/(195*S(t*.2)^32+5)),12)+1]end if \
i%60==0 then n=10 end I(T(n))end t=t+.005 end');
document.getElementById('terminal').focus();
}
function runDonut(e) {
if (!term_.command.loaded)
runLua();
term_.command.sendMessage(
' A=0 B=0 z={}b=\n\
{}E={32,46,44,45,126,\n\
58,59,61,33,42,35,36,64}S\n\
=math.sin C=math.cos F=math.\n\
floor I=io.write T=string.char W=60\n\
P=print H=25 P("\\x1b[2J")for w=1,240\n\
do for o=0,W*H do b[o]=1 z[o]=0 end e=\n\
S(A)g=C(A)m=C(B)n=S(B)for j=0,6.28,.09\n\
do d=C(j)f=S(j) for i=0,6.28,.04\n\
do c=S(i)h=d+2 D =1/(c*h*e+f*g+5)\n\
l=C(i)t=c*h*g- f*e x=F(W/2+W*\n\
.3*D*(l*h*m-t*n ))y=F(H/2+H*.6*\n\
D*(l*h*n+t*m))o =x+W*y N=math.\n\
max(0,F(8*((f*e-c*d*g)*m-c*d*e-f*g -l*\n\
d *n)))+2 if H> y and y>0 and x>0 and\n\
W>x and D> z[o] then z[o]=D b[o]=N\n\
end end end P( "\\x1b[H")for k=0\n\
,W* H do if k%W~=0 then I(T(\n\
E[b[k]]))else I( T( 10))\n\
end end A = A + .04\n\
B=B+.02 end')
document.getElementById('terminal').focus();
}
|
(function($) {
/**
* Attach this editor to a target element.
*/
Drupal.wysiwyg.editor.attach.markitup = function(context, params, settings) {
$('#' + params.field, context).markItUp(settings);
// Adjust CSS for editor buttons.
$.each(settings.markupSet, function (button) {
$('.' + settings.nameSpace + ' .' + this.className + ' a')
.css({ backgroundImage: 'url(' + settings.root + 'sets/default/images/' + button + '.png' + ')' })
.parents('li').css({ backgroundImage: 'none' });
});
};
/**
* Detach a single or all editors.
*/
Drupal.wysiwyg.editor.detach.markitup = function (context, params, trigger) {
if (trigger == 'serialize') {
return;
}
$('#' + params.field, context).markItUpRemove();
};
Drupal.wysiwyg.editor.instance.markitup = {
insert: function (content) {
$.markItUp({ replaceWith: content });
},
setContent: function (content) {
$('#' + this.field).val(content);
},
getContent: function () {
return $('#' + this.field).val();
}
};
})(jQuery);
|
define([
"../core",
"../var/support"
], function( jQuery, support ) {
(function() {
// Minified: var b,c,d,e,f,g, h,i
var div, style, a, pixelPositionVal, boxSizingReliableVal,
reliableHiddenOffsetsVal, reliableMarginRightVal;
// Setup
div = document.createElement( "div" );
div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
a = div.getElementsByTagName( "a" )[ 0 ];
style = a && a.style;
// Finish early in limited (non-browser) environments
if ( !style ) {
return;
}
style.cssText = "float:left;opacity:.5";
// Support: IE<9
// Make sure that element opacity exists (as opposed to filter)
support.opacity = style.opacity === "0.5";
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
support.cssFloat = !!style.cssFloat;
div.style.backgroundClip = "content-box";
div.cloneNode( true ).style.backgroundClip = "";
support.clearCloneStyle = div.style.backgroundClip === "content-box";
// Support: Firefox<29, Android 2.3
// Vendor-prefix box-sizing
support.boxSizing = style.boxSizing === "" || style.MozBoxSizing === "" ||
style.WebkitBoxSizing === "";
jQuery.extend(support, {
reliableHiddenOffsets: function() {
if ( reliableHiddenOffsetsVal == null ) {
computeStyleTests();
}
return reliableHiddenOffsetsVal;
},
boxSizingReliable: function() {
if ( boxSizingReliableVal == null ) {
computeStyleTests();
}
return boxSizingReliableVal;
},
pixelPosition: function() {
if ( pixelPositionVal == null ) {
computeStyleTests();
}
return pixelPositionVal;
},
// Support: Android 2.3
reliableMarginRight: function() {
if ( reliableMarginRightVal == null ) {
computeStyleTests();
}
return reliableMarginRightVal;
}
});
function computeStyleTests() {
// Minified: var b,c,d,j
var div, body, container, contents;
body = document.getElementsByTagName( "body" )[ 0 ];
if ( !body || !body.style ) {
// Test fired too early or in an unsupported environment, exit.
return;
}
// Setup
div = document.createElement( "div" );
container = document.createElement( "div" );
container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px";
body.appendChild( container ).appendChild( div );
div.style.cssText =
// Support: Firefox<29, Android 2.3
// Vendor-prefix box-sizing
"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" +
"box-sizing:border-box;display:block;margin-top:1%;top:1%;" +
"border:1px;padding:1px;width:4px;position:absolute";
// Support: IE<9
// Assume reasonable values in the absence of getComputedStyle
pixelPositionVal = boxSizingReliableVal = false;
reliableMarginRightVal = true;
// Check for getComputedStyle so that this code is not run in IE<9.
if ( window.getComputedStyle ) {
pixelPositionVal = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
boxSizingReliableVal =
( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
// Support: Android 2.3
// Div with explicit width and no margin-right incorrectly
// gets computed margin-right based on width of container (#3333)
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
contents = div.appendChild( document.createElement( "div" ) );
// Reset CSS: box-sizing; display; margin; border; padding
contents.style.cssText = div.style.cssText =
// Support: Firefox<29, Android 2.3
// Vendor-prefix box-sizing
"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
contents.style.marginRight = contents.style.width = "0";
div.style.width = "1px";
reliableMarginRightVal =
!parseFloat( ( window.getComputedStyle( contents, null ) || {} ).marginRight );
div.removeChild( contents );
}
// 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>";
contents = div.getElementsByTagName( "td" );
contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";
reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
if ( reliableHiddenOffsetsVal ) {
contents[ 0 ].style.display = "";
contents[ 1 ].style.display = "none";
reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;
}
body.removeChild( container );
}
})();
return support;
});
|
require('./angular-locale_uz-arab-af');
module.exports = 'ngLocale';
|
module.exports = require('../conforms');
|
define("ace/theme/idle_fingers",["require","exports","module","ace/lib/dom"], function(require, exports, module) {
exports.isDark = true;
exports.cssClass = "ace-idle-fingers";
exports.cssText = ".ace-idle-fingers .ace_gutter {\
background: #3b3b3b;\
color: rgb(153,153,153)\
}\
.ace-idle-fingers .ace_print-margin {\
width: 1px;\
background: #3b3b3b\
}\
.ace-idle-fingers {\
background-color: #323232;\
color: #FFFFFF\
}\
.ace-idle-fingers .ace_cursor {\
color: #91FF00\
}\
.ace-idle-fingers .ace_marker-layer .ace_selection {\
background: rgba(90, 100, 126, 0.88)\
}\
.ace-idle-fingers.ace_multiselect .ace_selection.ace_start {\
box-shadow: 0 0 3px 0px #323232;\
border-radius: 2px\
}\
.ace-idle-fingers .ace_marker-layer .ace_step {\
background: rgb(102, 82, 0)\
}\
.ace-idle-fingers .ace_marker-layer .ace_bracket {\
margin: -1px 0 0 -1px;\
border: 1px solid #404040\
}\
.ace-idle-fingers .ace_marker-layer .ace_active-line {\
background: #353637\
}\
.ace-idle-fingers .ace_gutter-active-line {\
background-color: #353637\
}\
.ace-idle-fingers .ace_marker-layer .ace_selected-word {\
border: 1px solid rgba(90, 100, 126, 0.88)\
}\
.ace-idle-fingers .ace_invisible {\
color: #404040\
}\
.ace-idle-fingers .ace_keyword,\
.ace-idle-fingers .ace_meta {\
color: #CC7833\
}\
.ace-idle-fingers .ace_constant,\
.ace-idle-fingers .ace_constant.ace_character,\
.ace-idle-fingers .ace_constant.ace_character.ace_escape,\
.ace-idle-fingers .ace_constant.ace_other,\
.ace-idle-fingers .ace_support.ace_constant {\
color: #6C99BB\
}\
.ace-idle-fingers .ace_invalid {\
color: #FFFFFF;\
background-color: #FF0000\
}\
.ace-idle-fingers .ace_fold {\
background-color: #CC7833;\
border-color: #FFFFFF\
}\
.ace-idle-fingers .ace_support.ace_function {\
color: #B83426\
}\
.ace-idle-fingers .ace_variable.ace_parameter {\
font-style: italic\
}\
.ace-idle-fingers .ace_string {\
color: #A5C261\
}\
.ace-idle-fingers .ace_string.ace_regexp {\
color: #CCCC33\
}\
.ace-idle-fingers .ace_comment {\
font-style: italic;\
color: #BC9458\
}\
.ace-idle-fingers .ace_meta.ace_tag {\
color: #FFE5BB\
}\
.ace-idle-fingers .ace_entity.ace_name {\
color: #FFC66D\
}\
.ace-idle-fingers .ace_collab.ace_user1 {\
color: #323232;\
background-color: #FFF980\
}\
.ace-idle-fingers .ace_indent-guide {\
background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWMwMjLyZYiPj/8PAAreAwAI1+g0AAAAAElFTkSuQmCC) right repeat-y\
}";
var dom = require("../lib/dom");
dom.importCssString(exports.cssText, exports.cssClass);
});
|
'use strict';
angular.module("ngLocale", [], ["$provide", function($provide) {
var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
$provide.value("$locale", {
"DATETIME_FORMATS": {
"AMPMS": [
"AM",
"PM"
],
"DAY": [
"dimanche",
"lundi",
"mardi",
"mercredi",
"jeudi",
"vendredi",
"samedi"
],
"ERANAMES": [
"avant J\u00e9sus-Christ",
"apr\u00e8s J\u00e9sus-Christ"
],
"ERAS": [
"av. J.-C.",
"ap. J.-C."
],
"FIRSTDAYOFWEEK": 0,
"MONTH": [
"janvier",
"f\u00e9vrier",
"mars",
"avril",
"mai",
"juin",
"juillet",
"ao\u00fbt",
"septembre",
"octobre",
"novembre",
"d\u00e9cembre"
],
"SHORTDAY": [
"dim.",
"lun.",
"mar.",
"mer.",
"jeu.",
"ven.",
"sam."
],
"SHORTMONTH": [
"janv.",
"f\u00e9vr.",
"mars",
"avr.",
"mai",
"juin",
"juil.",
"ao\u00fbt",
"sept.",
"oct.",
"nov.",
"d\u00e9c."
],
"WEEKENDRANGE": [
5,
6
],
"fullDate": "EEEE d MMMM y",
"longDate": "d MMMM y",
"medium": "d MMM y HH:mm:ss",
"mediumDate": "d MMM y",
"mediumTime": "HH:mm:ss",
"short": "dd/MM/y HH:mm",
"shortDate": "dd/MM/y",
"shortTime": "HH:mm"
},
"NUMBER_FORMATS": {
"CURRENCY_SYM": "\u20ac",
"DECIMAL_SEP": ",",
"GROUP_SEP": "\u00a0",
"PATTERNS": [
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 3,
"minFrac": 0,
"minInt": 1,
"negPre": "-",
"negSuf": "",
"posPre": "",
"posSuf": ""
},
{
"gSize": 3,
"lgSize": 3,
"maxFrac": 2,
"minFrac": 2,
"minInt": 1,
"negPre": "-",
"negSuf": "\u00a0\u00a4",
"posPre": "",
"posSuf": "\u00a0\u00a4"
}
]
},
"id": "fr-gp",
"pluralCat": function(n, opt_precision) { var i = n | 0; if (i == 0 || i == 1) { return PLURAL_CATEGORY.ONE; } return PLURAL_CATEGORY.OTHER;}
});
}]);
|
(function () {
// notequalto extra validators
window.ParsleyConfig = window.ParsleyConfig || {};
window.ParsleyConfig.validators = window.ParsleyConfig.validators || {};
// Greater than validator
window.ParsleyConfig.validators.notequalto = {
fn: function (value, requirement) {
return value !== ($(requirement).length ? $(requirement).val() : requirement);
},
priority: 256
};
})();
|
/**
* Copyright 2013-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*
*/
'use strict';
var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
module.exports = ReactPropTypesSecret;
|
"use strict";
exports.__esModule = true;
exports.getBindingIdentifiers = getBindingIdentifiers;
// istanbul ignore next
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj["default"] = obj; return newObj; } }
var _index = require("./index");
var t = _interopRequireWildcard(_index);
/**
* Return a list of binding identifiers associated with the input `node`.
*/
function getBindingIdentifiers(node, duplicates) {
var search = [].concat(node);
var ids = Object.create(null);
while (search.length) {
var id = search.shift();
if (!id) continue;
var keys = t.getBindingIdentifiers.keys[id.type];
if (t.isIdentifier(id)) {
if (duplicates) {
var _ids = ids[id.name] = ids[id.name] || [];
_ids.push(id);
} else {
ids[id.name] = id;
}
} else if (t.isExportDeclaration(id)) {
if (t.isDeclaration(node.declaration)) {
search.push(node.declaration);
}
} else if (keys) {
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (id[key]) {
search = search.concat(id[key]);
}
}
}
}
return ids;
}
/**
* Mapping of types to their identifier keys.
*/
getBindingIdentifiers.keys = {
DeclareClass: ["id"],
DeclareFunction: ["id"],
DeclareModule: ["id"],
DeclareVariable: ["id"],
InterfaceDeclaration: ["id"],
TypeAlias: ["id"],
ComprehensionExpression: ["blocks"],
ComprehensionBlock: ["left"],
CatchClause: ["param"],
LabeledStatement: ["label"],
UnaryExpression: ["argument"],
AssignmentExpression: ["left"],
ImportSpecifier: ["local"],
ImportNamespaceSpecifier: ["local"],
ImportDefaultSpecifier: ["local"],
ImportDeclaration: ["specifiers"],
FunctionDeclaration: ["id", "params"],
FunctionExpression: ["id", "params"],
ClassDeclaration: ["id"],
ClassExpression: ["id"],
RestElement: ["argument"],
UpdateExpression: ["argument"],
SpreadProperty: ["argument"],
Property: ["value"],
AssignmentPattern: ["left"],
ArrayPattern: ["elements"],
ObjectPattern: ["properties"],
VariableDeclaration: ["declarations"],
VariableDeclarator: ["id"]
};
|
/*
* /MathJax/jax/output/SVG/fonts/TeX/AMS/Regular/GeneralPunctuation.js
*
* Copyright (c) 2009-2013 The MathJax Consortium
*
* Part of the MathJax library.
* See http://www.mathjax.org for details.
*
* Licensed under the Apache License, Version 2.0;
* you may not use this file except in compliance with the License.
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
MathJax.Hub.Insert(MathJax.OutputJax.SVG.FONTDATA.FONTS.MathJax_AMS,{8245:[560,-43,275,12,244,"12 501Q12 527 31 542T63 558Q73 560 77 560Q114 560 128 528Q133 518 188 293T244 61Q244 56 223 50T195 43Q192 43 190 45T102 263T14 486Q12 496 12 501"]});MathJax.Ajax.loadComplete(MathJax.OutputJax.SVG.fontDir+"/AMS/Regular/GeneralPunctuation.js");
|
/**
* Module dependencies.
*/
var _ = require('lodash');
var dotenv = require('dotenv');
var path = require('path');
var fs = require('fs');
var DEFAULT_ENV_FILE = 'default.env';
var USER_ENV_FILE = '.env';
module.exports = function(oars) {
function Env() {
this.load = function(cb) {
// default env file
var defaultEnvPath = path.join(__dirname, DEFAULT_ENV_FILE);
var defaultEnv = dotenv.parse(fs.readFileSync(defaultEnvPath));
// user's env file
var userEnvPath = path.join(oars.info.appPath, USER_ENV_FILE);
var userEnv = dotenv.parse(fs.readFileSync(userEnvPath));
var mergedEnv = _.merge(defaultEnv, userEnv);
oars.log.verbose('load merged env:')
oars.log.verbose(mergedEnv);
// IMPORTANT: write into process without override
_.defaults(process.env, mergedEnv);
if(cb) cb();
};
_.bindAll(this);
}
return new Env();
};
|
// load the configuration settings
var config = require('./config');
var self = {};
// the log singleton
var logObject = function() {
if ( logObject.prototype._singletonInstance ) {
return logObject.prototype._singletonInstance;
}
logObject.prototype._singletonInstance = this;
self = this;
};
// define each action as a function available within the configuration
logObject.prototype = {
msg : function(msg) {
if (config.get('config:verbose:console'))
console.log(msg);
},
err : function(msg) {
if (config.get('config:verbose:errors'))
console.error(msg);
}
};
module.exports = new logObject();
|
import * as Constants from '../constants';
export default function(parent, startVertex, endVertex) {
const startCoord = startVertex.geometry.coordinates;
const endCoord = endVertex.geometry.coordinates;
// If a coordinate exceeds the projection, we can't calculate a midpoint,
// so run away
if (startCoord[1] > Constants.LAT_RENDERED_MAX ||
startCoord[1] < Constants.LAT_RENDERED_MIN ||
endCoord[1] > Constants.LAT_RENDERED_MAX ||
endCoord[1] < Constants.LAT_RENDERED_MIN) {
return null;
}
const mid = {
lng: (startCoord[0] + endCoord[0]) / 2,
lat: (startCoord[1] + endCoord[1]) / 2
};
return {
type: Constants.geojsonTypes.FEATURE,
properties: {
meta: Constants.meta.MIDPOINT,
parent,
lng: mid.lng,
lat: mid.lat,
coord_path: endVertex.properties.coord_path
},
geometry: {
type: Constants.geojsonTypes.POINT,
coordinates: [mid.lng, mid.lat]
}
};
}
|
// not actually mocking wotblitz; providing a single instance, mimicking the bot code
const wotblitz = require('wotblitz')();
exports.commands = {
client: {
user: {
id: '0101',
username: 'testbot'
}
},
wotblitz: wotblitz
};
exports.createMessage = function(content, author, mentions) {
if (mentions && !('size' in mentions)) mentions.size = mentions.length || Object.keys(mentions).length;
return {
'author': {
send: text => Promise.resolve(text),
username: author
},
channel: {
send: text => Promise.resolve(text)
},
'content': content,
'mentions': {
users: mentions
},
reply: text => Promise.resolve(`@${author}, ${text}`)
};
};
|
'use strict';
var Trunc = require('lodash.trunc');
function capture(fn) {
var oldLog = console.log;
var oldWarn = console.warn;
var oldError = console.error;
console.log = function() {
fn('log', arguments);
oldLog.apply(console, arguments);
};
console.warn = function() {
fn('warn', arguments);
oldWarn.apply(console, arguments);
};
console.error = function() {
fn('error', arguments);
oldError.apply(console, arguments);
};
}
function printDebug(inst, thing) {
printMessage('DEBUG', inst, thing);
}
function printWarning(inst, thing) {
printMessage('WARN', inst, thing);
}
function printError(inst, thing, state) {
printMessage('ERROR', inst, thing);
printMessage('ERROR', inst, 'Error occurred while processing list ' + inst.counter + '');
if (state) printMessage('ERROR', inst, state);
}
function printMessage(type, inst, thing) {
var meth = 'info';
if (type === 'ERROR') meth = 'error';
if (type === 'WARN') meth = 'warn';
var info =
'Runiq [' + type + ']: ' +
'(' + inst.counter + ') ' +
Trunc(JSON.stringify(thing), 60)
console[meth](info);
}
module.exports = {
capture: capture,
printDebug: printDebug,
printWarning: printWarning,
printError: printError,
printMessage: printMessage
};
|
function sanitize(string) {
return string.replace(/[^\x00-\xFFF]|[\r\n]/g, '');
}
module.exports = sanitize;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.