Upload folder using huggingface_hub (part 64)

pool/shard005/JavaScript/0032510_demo-wizard.js

@@ -0,0 +1,98 @@
+// FORM DEMO - Account Form
+// ------------------------------------------------------------------------------------------------ * -->
+$(document).ready(function ($) {
+
+    $(function (wizardForm) {
+        // navbar, numbering, progressbar, submit button well-nice
+        wizardForm('#demoWizard').bootstrapWizard({
+            nextSelector: '.wizard-action .next',
+            previousSelector: '.wizard-action .previous',
+            firstSelector: '.wizard-action .first',
+            lastSelector: '.wizard-action .last',
+            onTabShow: function (tab, navigation, index) {
+
+                var $total = navigation.find('li').length;
+                var $current = index + 1;
+                var $percent = ($current / $total) * 100;
+                var $wizard = $('#demoWizard');
+
+                $wizard.find('.bar').css({
+                    width: $percent + '%'
+                });
+
+                $wizard.find('.number-page').text($current + ' of ' + $total);
+
+                // If it's the last tab then hide the last button and show the finish instead
+                if ($current >= $total) {
+                    $wizard.find('.wizard-action .next').hide();
+                    $wizard.find('.wizard-action .finish').show();
+                    $wizard.find('.wizard-action .finish').removeClass('disabled');
+                    $wizard.find('.wizard-action .print').show();
+                    $wizard.find('.wizard-action .print').removeClass('disabled');
+                    $wizard.find('.wizard-action .cancel').show();
+                    $wizard.find('.wizard-action .cancel').removeClass('disabled');
+                } else {
+                    $wizard.find('.wizard-action .next').show();
+                    $wizard.find('.wizard-action .finish').hide();
+                    $wizard.find('.wizard-action .print').hide();
+                    $wizard.find('.wizard-action .cancel').hide();
+                }
+
+            }
+
+        });
+        wizardForm('#demoWizard .finish').click(function () {
+            alert('Finished!, Starting over!');
+            $('#demoWizard').find("a[href*='tab1e']").trigger('click');
+        });
+
+        wizardForm('#wzNewAddressState').select2();
+    });
+
+    $(function (wizardForm) {
+        // navbar, numbering, progressbar, submit button well-nice
+        wizardForm('#demoWizard2').bootstrapWizard({
+            nextSelector: '.wizard-action .next',
+            previousSelector: '.wizard-action .previous',
+            firstSelector: '.wizard-action .first',
+            lastSelector: '.wizard-action .last',
+            onTabShow: function (tab, navigation, index) {
+
+                var $total = navigation.find('li').length;
+                var $current = index + 1;
+                var $percent = ($current / $total) * 100;
+                var $wizard = $('#demoWizard2');
+
+                $wizard.find('.bar').css({
+                    width: $percent + '%'
+                });
+
+                $wizard.find('.number-page').text($current + ' of ' + $total);
+
+                // If it's the last tab then hide the last button and show the finish instead
+                if ($current >= $total) {
+                    $wizard.find('.wizard-action .next').hide();
+                    $wizard.find('.wizard-action .finish').show();
+                    $wizard.find('.wizard-action .finish').removeClass('disabled');
+                    $wizard.find('.wizard-action .print').show();
+                    $wizard.find('.wizard-action .print').removeClass('disabled');
+                    $wizard.find('.wizard-action .cancel').show();
+                    $wizard.find('.wizard-action .cancel').removeClass('disabled');
+                } else {
+                    $wizard.find('.wizard-action .next').show();
+                    $wizard.find('.wizard-action .finish').hide();
+                    $wizard.find('.wizard-action .print').hide();
+                    $wizard.find('.wizard-action .cancel').hide();
+                }
+
+            }
+
+        });
+        wizardForm('#demoWizard2 .finish').click(function () {
+            alert('Finished!, Starting over!');
+            $('#demoWizard2').find("a[href*='tab1e']").trigger('click');
+        });
+
+        wizardForm('#wzNewAddressState2').select2();
+    });
+});

pool/shard005/JavaScript/0032515_gulpfile.js

@@ -0,0 +1,119 @@
+/*
+	gulpfile.js
+	===========
+	Rather than manage one giant configuration file responsible
+	for creating multiple tasks, each task has been broken out into
+	its own file in gulp/tasks. Any file in that folder gets automatically
+	required by the loop in ./gulp/index.js (required below).
+
+	To add a new task, simply add a new task file to gulp/tasks.
+*/
+// require('./gulp');
+
+
+var path = require('path');
+var gulp = require('gulp');
+var gutil = require('gulp-util');
+var express = require('express');
+var clean = require('gulp-clean');
+var tiny_lr = require('tiny-lr');
+var webpack = require("webpack");
+var webpackConfig = require("./webpack.config.js");
+var WebpackDevServer = require("webpack-dev-server");
+
+// == COMPASS TASK =============
+require('./gulp/tasks/compass');
+
+// == COPY TASK =============
+require('./gulp/tasks/copy');
+
+// == IMAGES TASK =============
+require('./gulp/tasks/images');
+
+// == BUILD TASK =============
+require('./gulp/tasks/build');
+
+// == DEFAULT TASK =============
+require('./gulp/tasks/default');
+
+gulp.task('clean', function() {
+  return gulp.src('build', {
+    read: false
+  }).pipe(clean());
+});
+
+gulp.task('webpack', function(callback) {
+  execWebpack(webpackConfig);
+  return callback();
+});
+
+gulp.task("dev", ['build'], function(callback) {
+  gulp.watch(['./src/**/*'], function(evt) {
+    gutil.log("Files changed, re-building..");
+    return gulp.run('build');
+  });
+
+	// modify some webpack config options
+	var myConfig = Object.create(webpackConfig);
+	myConfig.devtool = "sourcemap";
+	myConfig.debug = true;
+
+  myConfig = webpackConfig;
+
+	// Start a webpack-dev-server
+	new WebpackDevServer(webpack(myConfig), {
+      publicPath: "/" + myConfig.output.publicPath,
+      stats: {
+        colors: true
+      }
+    })
+    .listen(4000, "localhost", function(err) {
+      if(err) throw new gutil.PluginError("webpack-dev-server", err);
+      gutil.log("[webpack-dev-server]", "http://localhost:4000/webpack-dev-server/index.html");
+    });
+});
+
+// gulp.task('dev', ['build'], function() {
+//   var servers;
+//   servers = createServers(4000, 35729);
+//   gulp.watch(['./src/**/*'], function(evt) {
+//     return gulp.run('build');
+//   });
+//   return gulp.watch(['./build/**/*'], function(evt) {
+//     gutil.log(gutil.colors.cyan(evt.path), 'changed');
+//     return servers.lr.changed({
+//       body: {
+//         files: [evt.path]
+//       }
+//     });
+//   });
+// });
+
+// var createServers = function(port, lrport) {
+//   var app, lr;
+//   lr = tiny_lr();
+//   lr.listen(lrport, function() {
+//     return gutil.log("LiveReload listening on", lrport);
+//   });
+//   app = express();
+//   app.use(express["static"](path.resolve("./build")));
+//   app.listen(port, function() {
+//     return gutil.log("HTTP server listening on", port);
+//   });
+//   return {
+//     lr: lr,
+//     app: app
+//   };
+// };
+
+var execWebpack = function(config) {
+  return webpack(config, function(err, stats) {
+    if (err) {
+      throw new gutil.PluginError("execWebpack", err);
+    }
+    return gutil.log("[execWebpack]", stats.toString({
+      colors: true
+    }));
+  });
+};
+

pool/shard005/JavaScript/0032517_catalogActions.js

@@ -0,0 +1,28 @@
+
+import {collection, element} from './actions';
+import {createAction} from 'redux-actions';
+import {request} from '../services';
+
+export const getCategories = createAction(
+	'GET_CATEGORIES',
+	(...args) => request('GET', 'categories', null, collection(...args)));
+
+export const getCategory = createAction(
+	'GET_CATEGORY',
+	(id, ...args) => request('GET', 'categories', id, element(...args)));
+
+export const getProducts = createAction(
+	'GET_PRODUCTS',
+	(...args) => request('GET', 'products', null, collection(...args)));
+
+export const getProduct = createAction(
+	'GET_PRODUCT',
+	(id, ...args) => request('GET', 'products', id, element(...args)));
+
+export const getOrders = createAction(
+	'GET_ORDERS',
+	(...args) => request('GET', 'orders', null, collection(...args)));
+
+export const getOrder = createAction(
+	'GET_ORDER',
+  (id, ...args) => request('GET', 'orders', id, element(...args)));

pool/shard005/JavaScript/0032519_index.js

@@ -0,0 +1,39 @@
+$.index.open();
+
+$.index.addEventListener('focus', function(e){
+  library.fetch();
+});
+
+$.add.addEventListener('click', function(e){
+  var newUser = Alloy.createModel('user', {
+    name:  $.userName.value,
+    age:   $.userAge.value,
+    email: $.userEmail.value,
+  });
+
+  /* validate */
+  if(newUser.isValid()){
+    newUser.save();
+    alert('success');
+    $.userName.setValue('');
+    $.userAge.setValue('');
+    $.userEmail.setValue('');
+  } else{
+    alert(newUser.errorMsg.join("\n"));
+  }
+});
+
+/* これ重要 */
+function transFormFunction(model){
+  var transform = model.toJSON();
+  return transform;
+}
+
+function doClick(e){
+  Ti.API.debug(e);
+  alert('name: ' + e.row.title);
+}
+
+/* これ重要 */
+var library = Alloy.Collections.user;
+library.fetch();

pool/shard005/JavaScript/0032528_rq-angular-napp-menu.js

@@ -0,0 +1,83 @@
+/**
+ *  Module
+ *
+ * Description
+ */
+define(["angular"], function(angular) {
+	'use strict';
+
+	return angular.module('napp.menu', [])
+		.directive('menu', ["$location",
+			function(location) {
+				return {
+					restrict: "AE",
+					transclude: true,
+					replace: true,
+					scope: {
+						title: "@"
+					},
+					controller: function($scope) {
+						$scope.items = [];
+
+						this.addItem = function(match, element) {
+							$scope.items.push({"element": element, "match": match});
+
+							var reg = new RegExp(match);
+
+							if (reg.test(location.path())) {
+								angular.element(element).addClass("active");
+							}
+						};
+
+						$scope.$on("$routeChangeStart", function() {
+							var route = location.path();
+
+							for (var item in $scope.items) {
+								item = $scope.items[item];
+								var reg = new RegExp(item.match);
+								if (reg.test(route)) {
+									angular.element(item.element).addClass("active");
+								} else {
+									angular.element(item.element).removeClass("active");
+								}
+							}
+						});
+					},
+					templateUrl: "/app/lib/napp-menu/partials/menu.html",
+				};
+			}
+		])
+		.directive("menuItemParent", function() {
+			return {
+				require: "^menu",
+				restrict: "AE",
+				replace: true,
+				transclude: true,
+				scope: {
+					match: "@",
+					title: "@"
+				},
+				link: function(scope, element, attrs, menuCtrl) {
+					menuCtrl.addItem(scope.match, element);
+				},
+				templateUrl: "/app/lib/napp-menu/partials/menu-item-parent.html"
+			};
+		})
+		.directive('menuItem', function() {
+			return {
+				require: "^menu",
+				restrict: 'AE',
+				replace: true,
+				transclude: true,
+				scope: {
+					match: "@",
+					route: "@",
+					title: "@"
+				},
+				link: function(scope, element, attrs, menuCtrl) {
+					menuCtrl.addItem(scope.match, element);
+				},
+				templateUrl: "/app/lib/napp-menu/partials/menu-item.html",
+			}
+		});
+});

pool/shard005/JavaScript/0032529_poseestimation_normal.js

@@ -0,0 +1,79 @@
+QUnit.module("PoseEstimation Profile Normal Test", {
+    before: function () {
+        init();
+    }
+});
+
+
+/**
+ * PoseEstimationプロファイルの正常系テストを行うクラス。
+ * @class
+ */
+let PoseEstimationProfileNormalTest = {};
+
+/**
+ * 姿勢推定を取得するテストを行う。
+ * <h3>【HTTP通信】</h3>
+ * <p id="test">
+ * Method: GET<br/>
+ * Path: /poseEstimation/onPoseEstimation?serviceId=xxxx&accessToken=xxx<br/>
+ * </p>
+ * <h3>【期待する動作】</h3>
+ * <p id="expected">
+ * ・resultに0が返ってくること。<br/>
+ * ・poseの値が返ってくること。<br/>
+ * </p>
+ */
+PoseEstimationProfileNormalTest.poseNormalTest = function (assert) {
+  let done = assert.async();
+  sdk.get({
+    profile: 'poseEstimation',
+    attribute: 'onPoseEstimation',
+    params: {
+      serviceId: getCurrentServiceId()
+    }
+  }).then(json => {
+    assert.ok(true, "result=" + json.result);
+    assert.ok(json.pose != undefined, "pose=" + json.pose);
+    done();
+  }).catch(e => {
+    assert.ok(checkErrorCode(e.errorCode),
+        'errorCode=' + e.errorCode + ' errorMessage=' + e.errorMessage);
+    done();
+  });
+}
+QUnit.test("pose", PoseEstimationProfileNormalTest.poseNormalTest);
+
+/**
+ * PoseEstimationプロファイルのheartrateの登録と解除を行うテストを行う。
+ * <h3>【HTTP通信】</h3>
+ * <p id="test">
+ * Method: PUT<br/>
+ * Path: /poseEstimation/onPoseEstimation?serviceId=xxxx&accessToken=xxx<br/>
+ * </p>
+ * <h3>【期待する動作】</h3>
+ * <p id="expected">
+ * ・resultに0が返ってくること。<br/>
+ * ・イベント通知が送られてくること。<br/>
+ * </p>
+ */
+PoseEstimationProfileNormalTest.poseEventNormalTest001 = function (assert) {
+  let params = {
+    profile: 'poseEstimation',
+    attribute: 'onPoseEstimation',
+    params: {
+      serviceId: getCurrentServiceId()
+    }
+  };
+  openWebsocket(params, assert, 10000, message => {
+        let json = JSON.parse(message);
+        if (json.profile === "poseEstimation"
+            && json.attribute === "onPoseEstimation") {
+            assert.ok(true, message);
+            assert.ok(json.pose != undefined, "pose=" + json.pose);
+            return true;
+        }
+        return false;
+    });
+}
+QUnit.test("poseEventNormalTest001", PoseEstimationProfileNormalTest.poseEventNormalTest001);

pool/shard005/JavaScript/0032530_ruleFileList.js

@@ -0,0 +1,289 @@
+/**
+ * HABmin - the openHAB admin interface
+ *
+ * openHAB, the open Home Automation Bus.
+ * Copyright (C) 2010-2013, openHAB.org <admin@openhab.org>
+ *
+ * See the contributors.txt file in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This program 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.
+ *
+ * This program 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 this program; if not, see <http://www.gnu.org/licenses>.
+ *
+ * Additional permission under GNU GPL version 3 section 7
+ *
+ * If you modify this Program, or any covered work, by linking or
+ * combining it with Eclipse (or a modified version of that library),
+ * containing parts covered by the terms of the Eclipse Public License
+ * (EPL), the licensors of this Program grant you additional permission
+ * to convey the resulting work.
+ */
+
+/**
+ * OpenHAB Admin Console HABmin
+ *
+ * @author Chris Jackson
+ */
+
+
+Ext.define('openHAB.automation.ruleFileList', {
+    extend: 'Ext.panel.Panel',
+    layout: 'fit',
+    icon: 'images/document-copy.png',
+
+    initComponent: function () {
+        this.title = language.rule_FileListTitle;
+
+        // Define the Rule Template Store
+        Ext.define('RuleModelModel', {
+            extend: 'Ext.data.Model',
+            fields: [
+                {name: 'model'},
+                {name: 'rule'}
+            ]
+        });
+
+        var ruleModelStore = Ext.create('Ext.data.ArrayStore', {
+            model: 'RuleModelModel'
+        });
+
+        var toolbar = Ext.create('Ext.toolbar.Toolbar', {
+            items: [
+                {
+                    icon: 'images/plus-button.png',
+                    itemId: 'add',
+                    text: language.add,
+                    cls: 'x-btn-icon',
+                    disabled: false,
+                    tooltip: language.rule_FileListAddTip,
+                    handler: function () {
+                        Ext.define('RuleModelsModel', {
+                            extend: 'Ext.data.Model',
+                            fields: [
+                                {name: 'name'},
+                                {name: 'icon'},
+                                {name: 'iconCls'}
+                            ]
+                        });
+
+                        // Generate a list of all existing models
+                        // User can type their own, but this gives them options.
+                        var models = [];
+                        var ocnt = 0;
+                        for (var cnt = 0; cnt < ruleModelStore.getCount(); cnt++) {
+                            var found = false;
+                            var name = ruleModelStore.getAt(cnt).get("model");
+                            for (var mcnt = 0; mcnt < models.length; mcnt++) {
+                                if (models[mcnt].name == name) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                            if (found === false) {
+                                models[ocnt] = {};
+                                models[ocnt].name = name;
+                                ocnt++;
+                            }
+                        }
+
+                        var form = Ext.widget('form', {
+                            layout: {
+                                type: 'vbox',
+                                align: 'stretch'
+                            },
+                            border: false,
+                            bodyPadding: 10,
+                            fieldDefaults: {
+                                labelAlign: 'top',
+                                labelWidth: 100,
+                                labelStyle: 'font-weight:bold'
+                            },
+                            defaults: {
+                                margins: '0 0 10 0'
+                            },
+                            items: [
+                                {
+                                    margin: '0 0 0 0',
+                                    xtype: 'combobox',
+                                    fieldLabel: 'Model name:',
+                                    itemId: 'model',
+                                    name: 'model',
+                                    store: {model: 'RuleModelsModel', data: models},
+                                    allowBlank: false,
+                                    valueField: 'name',
+                                    displayField: 'name',
+                                    queryMode: 'local',
+                                    forceSelection: false,
+                                    editable: true,
+                                    typeAhead: true
+                                }
+                            ],
+                            buttons: [
+                                {
+                                    text: language.cancel,
+                                    handler: function () {
+                                        this.up('window').destroy();
+                                    }
+                                },
+                                {
+                                    text: language.rule_FileListCreateButton,
+                                    handler: function () {
+                                        if (this.up('form').getForm().isValid()) {
+                                            // Read the model name
+                                            var model = form.getForm().findField('model').getSubmitValue();
+
+                                            var newProperties = null;
+
+                                            // Create a new ruleEditor
+                                            var newProperties = Ext.create('openHAB.automation.ruleEditor', {
+                                                modelName: model
+                                            });
+
+                                            if (newProperties != null)
+                                                Ext.getCmp('automationPropertyContainer').setNewProperty(newProperties);
+
+                                            this.up('window').destroy();
+                                        }
+                                    }
+                                }
+                            ]
+                        });
+
+                        var createWin = Ext.widget('window', {
+                            title: language.rule_FileListCreateButton,
+                            closeAction: 'destroy',
+                            width: 225,
+                            resizable: false,
+                            draggable: false,
+                            modal: true,
+                            layout: {
+                                type: 'vbox',
+                                align: 'stretch'
+                            },
+                            items: [form]
+                        });
+
+                        createWin.show();
+                    }
+                },
+                {
+                    xtype: 'tbfill'
+                },
+                {
+                    icon: 'images/arrow-circle-315.png',
+                    itemId: 'refresh',
+                    cls: 'x-btn-icon',
+                    disabled: false,
+                    tooltip: language.refresh,
+                    handler: function () {
+                        loadModelList();
+                    }
+                }
+            ]
+        });
+
+        var ruleList = Ext.create('Ext.grid.Panel', {
+            store: ruleModelStore,
+            header: false,
+            split: true,
+            tbar: toolbar,
+            collapsible: false,
+            multiSelect: false,
+            columns: [
+                {
+                    text: language.rule_FileListModel,
+                    flex: 1,
+                    dataIndex: 'model'
+                    /*,
+                     renderer:function (value, metadata, record) {
+                     var icon = "";
+                     var ref = itemConfigStore.findExact("name", value);
+                     if (ref != -1) {
+                     if (itemConfigStore.getAt(ref).get('icon') != "")
+                     icon = '<img src="../images/' + itemConfigStore.getAt(ref).get('icon') + '.png" align="left" height="16">';
+                     }
+
+                     return '<div>' + icon + '</div><div style="margin-left:20px">' + value + '</div>';
+                     }*/
+                },
+                {
+                    text: language.rule_FileListRule,
+                    flex: 3,
+                    dataIndex: 'rule'
+                }
+            ],
+            listeners: {
+                itemclick: function (grid, record) {
+                    if (record == null)
+                        return;
+
+                    // Create a new ruleEditor
+                    var newProperties = Ext.create('openHAB.automation.ruleEditor', {
+                        modelName: record.get('model'),
+                        ruleName: record.get('rule')
+                    });
+
+                    if (newProperties != null)
+                        Ext.getCmp('automationPropertyContainer').setNewProperty(newProperties);
+
+                    // Update the toolbar
+//                    toolbar.getComponent('delete').enable();
+                }
+            }
+        });
+
+        this.items = ruleList;
+
+        this.callParent();
+
+        loadModelList();
+
+        function loadModelList() {
+            // Clear the existing data
+            ruleModelStore.loadData([], false);
+
+            // Load the rule list from openHAB
+            Ext.Ajax.request({
+                url: HABminBaseURL + "/config/rules/model/list",
+                headers: {'Accept': 'application/json'},
+                method: 'GET',
+                success: function (response, opts) {
+                    var json = Ext.decode(response.responseText);
+                    // If there's no config for this sitemap, records will be null
+                    if (json == null)
+                        return;
+
+                    var models = [].concat(json.rule);
+                    for (var cnt = 0; cnt < models.length; cnt++) {
+                        if (models[cnt].rules == null) {
+                            var element = {};
+                            element.model = models[cnt].model;
+
+                            ruleModelStore.add(element);
+                            continue;
+                        }
+                        var rules = [].concat(models[cnt].rules);
+                        for (var elcnt = 0; elcnt < rules.length; elcnt++) {
+                            var element = {};
+                            element.model = models[cnt].model;
+                            element.rule = rules[elcnt].name;
+
+                            ruleModelStore.add(element);
+                        }
+                    }
+                }
+            });
+        }
+    }
+})
+;

pool/shard005/JavaScript/0032531_index.ui.js

@@ -0,0 +1,36 @@
+//related to pullAnimation.ui
+var image=ui("do_ImageView_3");
+var scroll=ui("do_ScrollView_1");
+var nf=sm("do_Notification");
+var list=ui("do_ListView_1");
+var page=sm("do_Page");
+var app=sm("do_App");
+var close = ui("close1");
+var do_Label_3=ui("do_Label_3");
+
+close.on("touch", function() {
+	app.closePage();
+})
+page.on("back", function() {
+	app.closePage();
+});
+
+do_Label_3.show("slide_l2r", 3000);
+
+var animator = mm("do_Animator");
+var animatorB = mm("do_Animator");
+
+		//顶部背景显示动画
+		animator.append(5000, props, "EaseOut");
+		var props = {bgColor:"0080FFFF"}
+		animatorB.append(5000, propsB, "EaseOut");
+		var propsB = {bgColor:"#ffFFFF00"}
+		scroll.on("scroll", function(datas) {
+			//根据返回的值，改变图片的高
+			deviceone.print(JSON.stringify(datas));
+			image.height = 500 -+ datas;
+			image.redraw();
+			
+		});
+
+

pool/shard005/JavaScript/0032532_main.js

@@ -0,0 +1,114 @@
+var obj_geditor=document.getElementById("geditor");
+var obj_tools=document.getElementById("tools");
+var obj_geditor_co=document.getElementById("geditor").contentWindow;
+//³õʼ»¯£¬±à¼­Æ÷
+//¼ì²âÓû§°´¼ü£¬´Ó¶øÌí¼Ó±êÇ©
+  var p_ok=0;
+  window.onkeyup=function(event){
+  var e = event || window.event || arguments.callee.caller.arguments[0];
+   if(obj_geditor.textContent!=""){
+   if(p_ok==0){
+   for(var i=0;i<=100;i++){
+	     if(e && e.keyCode==i){
+			 //alert(s.textContent);
+				  obj_geditor.innerHTML="<p>"+obj_geditor.textContent+"</p>";
+				  p_ok=1;
+			 }
+   
+	   }
+   }
+ }else{
+	 p_ok=0;
+	 }
+}; 
+
+
+/**¹«¹²µ÷Ó÷½·¨**/
+//½«Îı¾ÄÚÈÝÑ¡ÖУ¬²¢½øÐÐÏàÓ¦²Ù×÷
+var s;
+function funcSelectText(mode,attr,value){     //modeÖ¸ÔªËرêÇ©;attrÖ¸Ëù´´½¨ÔªËصÄÊôÐÔ;valueÖ¸ÊôÐÔÖµ
+	var txt="";
+	if(document.selection){
+		sel=document.selection.createRange().text;
+		}else{
+	    sel=document.getSelection();
+			}
+		txt=sel.getRangeAt(0).extractContents().textContent;
+			range=sel.getRangeAt(0);
+			if(txt.length>0){
+			 s=range;
+			 range.deleteContents();
+			var obj_txt=document.createElement(mode);
+			if(attr==""||value==""){
+			obj_txt.innerHTML=txt;
+			range.insertNode(obj_txt);
+			}else{
+			obj_txt.setAttribute(attr,value);
+			obj_txt.innerHTML=txt;
+			range.insertNode(obj_txt);
+			}
+			}
+			  // alert(range);
+	/*if(txt!=null || txt!=""){	
+        obj_geditor.innerHTML=obj_geditor.textContent.replace(txt,"121312");
+	}      Ìæ»»Îı¾*/
+	
+	}
+/**var container = container || document;
+		container.onmouseup = function(){
+		 funcSelectText();
+		}     °´ÏÂÊó±êµ÷ÓÃÑ¡ÖÐÎı¾,²âÊÔʱºòÓõÄ**/
+		
+//option±êÇ©µÄÑ¡Ôñº¯Êý·½·¨£¨¹«¹²·½·¨,¿Éµ÷Óã©
+/**function opsel(id,mode,attr,val){
+		   var oindex;
+		   var id=id;
+		   var mode=mode;
+		   var attr=attr;
+	       var obj=document.getElementById(id);
+ 	      value=obj.options[obj_font_size.options.selectedIndex].text;
+          obj_geditor.onfocus=funcSelectText(mode,attr,val+value);
+	}
+**/
+//(×¢ÒâÕâ¸ö·½·¨Ö»ÄÜÔÚselectÏÂʹÓã¡)µ÷ÓÃÑ¡È¡optionµÄ·½·¨º¯Êý£¬¿ÉÖ±½Óµ÷ÓÃʹÓã¡idÖ¸£ºÒªµ÷Ó÷½·¨µÄÔªËØidÖµ£»modeÖ¸±êÇ©,±ÈÈç:span£»attrÖ¸ÊôÐÔÃû³Æ,È磺style£»valÖ¸ÊôÐÔÖµµÄÒ»²¿·Ö,È磺font-size:,×¢ÒâðºÅ±ØÐë¼ÓÉÏvalue¾ÍÊÇÑ¡ÖеÄÖµÁË
+function fs(id,mode,attr,val,ty){
+           var val=val;
+		   var id=id;
+           var obj=document.getElementById(id);
+           value=obj.options[obj.options.selectedIndex].text;
+		   if(ty=="" || ty==null){                        //tyÖ¸µÄÊÇÇл»valueºÍmode,ÒÔÊÊÓ¦¿ª·¢½×¶Î
+              funcSelectText(mode,attr,val+value);}else{
+			  funcSelectText(value,attr,mode);              //´ËʱvalueºÍmode½øÐÐÁËÇл»
+				  }
+       }
+	   		
+//ÏÔʾԪËØ
+   function	show(){
+alert(obj_geditor.innerHTML);
+}
+
+
+/**µ÷Óòå¼þ¹Ø¼ü¹¦ÄÜ**/
+
+var js_src=new Array("tools/font/font_size.js","tools/font/font_type.js");   //×¢²á²å¼þµØÖ·
+
+  function diaoyong(src1){                //µ÷Óòå¼þ          
+     var src=src1;
+   new_js=document.createElement("script");
+   new_js.setAttribute("type","text/javascript");
+   new_js.setAttribute("src",src);
+   document.body.appendChild(new_js);
+}
+
+
+  function js_ok(){
+     for(var i=0;i<=js_src.length;i++){
+          //alert(js_src[i]);
+          diaoyong(js_src[i]);
+          }
+  }
+
+js_ok();
+//alert("ssssss");
+
+

pool/shard005/JavaScript/0032534_index.js

@@ -0,0 +1,84 @@
+/*jslint node: true, forin: true, jslint white: true, newcap: true*/
+/*
+ * wrappify
+ * author : Takeshi Iwana
+ * https://github.com/iwatakeshi
+ * license : MIT
+ * Code heavily borrowed from Adam Draper
+ * https://github.com/adamwdraper
+ */
+
+(function() {
+  'use strict';
+
+  var wrappify,
+    hasModule = (typeof module !== 'undefined' && module.exports);
+
+  function Wrappify(core) {
+    'use strict';
+    this.core = core;
+  }
+
+  Wrappify.prototype.express = function() {
+    return this.core.ship.bind(this.core);
+  };
+
+  Wrappify.prototype.hapi = function() {
+    var core = this.core;
+    var plugin = {
+      register: function hapi(plugin, options, next) {
+        plugin.ext('onPreHandler', function(request, reply) {
+          core.ship.bind(core)(request);
+          reply.continue();
+        });
+        plugin.ext('onPreResponse', function(request, reply) {
+          core.ship.bind(core)(request);
+          reply.continue();
+        });
+        return next();
+      }
+    }
+    plugin.register.attributes = {
+      name: 'Wrappify',
+      version: '0.0.1'
+    }
+    return plugin;
+  };
+
+  Wrappify.prototype.koa = function() {
+    var core = this.core;
+    return function (self, next) {
+      core.ship.bind(core)(self);
+      return next();
+    }
+  };
+
+
+  wrappify = function(core) {
+    return new Wrappify(core);
+  };
+
+  /************************************
+      Exposing wrappify
+  ************************************/
+
+  // CommonJS module is defined
+  if (hasModule) {
+    module.exports = wrappify;
+  }
+
+  /*global ender:false */
+  if (typeof ender === 'undefined') {
+    // here, `this` means `window` in the browser, or `global` on the server
+    // add `wrappify` as a global object via a string identifier,
+    // for Closure Compiler 'advanced' mode
+    this.wrappify = wrappify;
+  }
+
+  /*global define:false */
+  if (typeof define === 'function' && define.amd) {
+    define([], function() {
+      return wrappify;
+    });
+  }
+}).call(this);

pool/shard005/JavaScript/0032535_index.js

@@ -0,0 +1,28 @@
+const lastSaid = {};
+const replaceRegex = /^s\/(.*?)\/(.*?)(?:(?:\/g)|(?:\/))?$/;
+
+function replaceAll(find, replace, str) {
+  return str.replace(new RegExp(find, 'g'), replace);
+}
+
+module.exports.msg = function (text, from, reply, raw) {
+  match = replaceRegex.exec(text);
+  if (match) {
+    // Replace the last thing the person said, if anything
+    if (lastSaid[from] != undefined) {
+      let personLastSaid = lastSaid[from],
+        find = match[1],
+        replace = match[2];
+      const fixed = replaceAll(find, replace, personLastSaid);
+
+      if (fixed != personLastSaid) {
+        const response = `<${from}> ${fixed}`;
+
+        reply(response);
+      }
+    }
+  } else {
+    // The proper way to do this would be with scrollback module but w/e
+    lastSaid[from] = text;
+  }
+};

pool/shard005/JavaScript/0032537_child-router.test.js

@@ -0,0 +1,37 @@
+import { ChildRouter } from '../../src/child-router';
+var RouterStub = (function () {
+    function RouterStub() {
+    }
+    RouterStub.prototype.configure = function (handler) {
+        handler(this);
+    };
+    RouterStub.prototype.map = function (routes) {
+        this.routes = routes;
+    };
+    return RouterStub;
+}());
+describe('the Child Router module', function () {
+    var sut;
+    var mockedRouter;
+    beforeEach(function () {
+        mockedRouter = new RouterStub();
+        sut = new ChildRouter();
+        sut.configureRouter(mockedRouter, mockedRouter);
+    });
+    it('contains a router property', function () {
+        expect(sut.router).toBeDefined();
+    });
+    it('configures the heading', function () {
+        expect(sut.heading).toEqual('Child Router');
+    });
+    it('should have a welcome route', function () {
+        expect(sut.router.routes).toContainEqual({ route: ['', 'welcome'], name: 'welcome', moduleId: './welcome', nav: true, title: 'Welcome' });
+    });
+    it('should have a users route', function () {
+        expect(sut.router.routes).toContainEqual({ route: 'users', name: 'users', moduleId: './users', nav: true, title: 'Github Users' });
+    });
+    it('should have a child router route', function () {
+        expect(sut.router.routes).toContainEqual({ route: 'child-router', name: 'child-router', moduleId: './child-router', nav: true, title: 'Child Router' });
+    });
+});
+//# sourceMappingURL=child-router.test.js.map

pool/shard005/JavaScript/0032538_collapser.user.js

@@ -0,0 +1,97 @@
+import UI from './ui';
+import Settings from './settings';
+
+const idPrefix = 'collapser';
+const userSettings = new Settings('collapser.');
+const dataToggle = 'data-toggle';
+
+var buffers; // All networks
+var colEnabled, colTogActive, colTogInactive, colTogConvo, colTogArchive;
+var toggleApply = false;
+
+function hide () {
+  var header =  $(this);
+  var restore = header.data('restore');
+
+  if (restore == null || toggleApply == true) {
+    toggleApply = false;
+    restore = header.nextAll();
+
+    var classes = [colTogActive, colTogInactive, colTogConvo, colTogArchive]
+      .filter(i => i.prop('checked'))
+      .map(i => i.attr(dataToggle))
+      .join(', ');
+
+    restore = restore.filter(classes);
+    header.data('restore', restore);
+  }
+
+  restore.filter('.archiveToggle').toggleClass('show');
+  restore.not('.archiveToggle').toggleClass('hide');
+}
+
+function toggleActivation (toggle) {
+  buffers[toggle == true ? 'on' : 'off']('dblclick', hide);
+}
+
+UI.pageReady(function () {
+
+  var style = '$includeStyle$';
+  style = UI.embedStyle(style);
+
+  const hashName = 'collapser';
+  var menu = UI.buildMenuTemplate('collapser-menu', hashName, 'Collapser');
+  menu = $(menu);
+  menu = UI.addMenu(menu);
+
+  var container = '$includeContainer$';
+  container = $(container);
+  container = UI.addContainer(container);
+
+  window.location.hash === '#?/settings=' + hashName && SESSIONVIEW.showSettings(hashName);
+  buffers = $('h2.buffer');
+
+  // Init container props
+  const snEnabled = 'enabled';
+  colEnabled = container.find(`#${idPrefix}-enabled-check`);
+  colEnabled
+    .change(() => { userSettings.set(snEnabled, colEnabled[0].checked); toggleActivation(colEnabled[0].checked); })
+    .prop('checked', JSON.parse(userSettings.get(snEnabled, true)));
+
+
+  function blink1 (next) { buffers.css({ outline: '4px solid blue' }); next(); }
+  function blink2 (next) { buffers.css({ outline: '' }); next(); }
+  var colShowNetworks = container.find(`#${idPrefix}-show-networks`)
+    .click(() => { buffers.clearQueue(); for (var i = 0; i < 2; i++) buffers.queue(blink1).delay(600).queue(blink2).delay(600); });
+
+  const snActive = 'toggle.active';
+  colTogActive = container.find(`#${idPrefix}-collapse-active`);
+  colTogActive
+    .attr(dataToggle, '.channels')
+    .change(() => { userSettings.set(snActive, colTogActive[0].checked); toggleApply = true; })
+    .prop('checked', JSON.parse(userSettings.get(snActive, true)));
+
+  const snInactive = 'toggle.inactive';
+  colTogInactive = container.find(`#${idPrefix}-collapse-inactive`);
+  colTogInactive
+    .attr(dataToggle, '.inactiveChannels')
+    .change(() => { userSettings.set(snInactive, colTogInactive[0].checked); toggleApply = true; })
+    .prop('checked', JSON.parse(userSettings.get(snInactive, true)));
+
+  const snConvo = 'toggle.convo';
+  colTogConvo = container.find(`#${idPrefix}-collapse-convo`);
+  colTogConvo
+    .attr(dataToggle, '.conversations')
+    .change(() => { userSettings.set(snConvo, colTogConvo[0].checked); toggleApply = true; })
+    .prop('checked', JSON.parse(userSettings.get(snConvo, true)));
+
+  const snArchive = 'toggle.archive';
+  colTogArchive = container.find(`#${idPrefix}-collapse-archive`);
+  colTogArchive
+    .attr(dataToggle, '.archiveToggle')
+    .change(() => { userSettings.set(snArchive, colTogArchive[0].checked); toggleApply = true; })
+    .prop('checked', JSON.parse(userSettings.get(snArchive, true)));
+
+  // Start
+  JSON.parse(userSettings.get('enabled', true)) && toggleActivation(true);
+});

pool/shard005/JavaScript/0032543_map_flatten_and_wrap_filters.js

@@ -0,0 +1,14 @@
+import _ from 'lodash';
+import FilterBarLibMapAndFlattenFiltersProvider from 'ui/filter_bar/lib/map_and_flatten_filters';
+export default function mapFlattenAndWrapFilters(Private) {
+  const mapAndFlattenFilters = Private(FilterBarLibMapAndFlattenFiltersProvider);
+  return function (filters) {
+    return mapAndFlattenFilters(filters).then(function (filters) {
+      return _.map(filters, function (filter) {
+        filter.meta = filter.meta || {};
+        filter.meta.apply = true;
+        return filter;
+      });
+    });
+  };
+}

pool/shard005/JavaScript/0032547_train-tracking-service.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/**
+ * @ngdoc service
+ * @name traffic.trainTrackingService
+ * @description
+ * # trainTrackingService
+ * Service in the traffic.
+ */
+angular.module('traffic')
+  .service('trainTrackingService', function() {
+    var stompClient = null;
+    var subscription;
+    
+/*    function getHistory(trainNumber) {
+      var url = 'http://rata.digitraffic.fi/api/v1/train-tracking/' + trainNumber + '?departure_date=2016-01-26';
+      return $http.get(url);
+    }
+*/
+    //TODO: refactor as generic pub/sub stomp service & extend
+    var trainTrackingService = {
+      track: function(trainNumber, callback) {
+        var socket = new SockJS('http://rata.digitraffic.fi/api/v1/websockets/train-tracking');
+        stompClient = Stomp.over(socket);
+        stompClient.connect({}, function(frame) {
+          console.log('frame', frame);
+          subscription = stompClient.subscribe('/' + trainNumber, function(message) {
+            callback(angular.fromJson(message.body)[0]);
+          });
+        });
+      },
+      stop: function() {
+        if (subscription) {
+          subscription.unsubscribe();  
+        }
+        if (stompClient) {
+          stompClient.disconnect();
+        }
+      }
+    };
+
+    return trainTrackingService;
+  });

pool/shard005/JavaScript/0032548_work.js

@@ -0,0 +1,16 @@
+//alert(localStorage["user"]);
+var storage = {};
+
+function loginform(){
+    if(storage.user && storage.pass){
+        if($("#loginForm").length>0&&$("p.error").length==0){
+            $("#loginForm #nme").val(storage.user);
+            $("#loginForm #pwd").val(storage.pass);
+            $("#loginForm [type=submit]").click();
+        }
+    }
+}
+chrome.runtime.sendMessage({greeting: "hello"}, function(response) {
+  storage = response.storage;
+  loginform();
+});

pool/shard005/JavaScript/0032551_ui_tab_panel_library.js

@@ -0,0 +1,255 @@
+/*
+ * @Author: Vaninadh
+ * @Date:   2016-03-30 19:51:31
+ * @Last Modified by:   Vaninadh
+ * @Last Modified time: 2016-04-27 11:31:12
+ */
+
+define(function(require) {
+    var defineComponent = require("flight/lib/component");
+    var uiCellMixinDraggable = require("KCEPROD/ui/sider_panel/cell/ui_cell_mixin_draggable");
+    var util = require("KCEPROD/util/util");
+
+    var Mustache = require("mustache");
+    var ns = window.kc.ns;
+
+    return defineComponent(uiCellMixinDraggable, uiTabPanelLibrary);
+
+    function uiTabPanelLibrary() {
+        this.attributes({
+            loadonce: false,
+            picAddBtnSelector: "#library-add-pic",
+            picUploadFileSelector: ".pic-upload-file",
+            picBtnDivSelector: ".pic-btn-div",
+            libraryTabSelector: "#tab-library",
+            libraryPicBoxSelector: "#library-pic-box",
+            pageid: 0,
+            cellLibrarySelector: ".library-cell",
+            cellImageSelector: ".cell-image",
+            itemOpDeleteSelector: ".icon-shanchu",
+            itemDraggable: ".item-draggable",
+            picDialog: "",
+            pic_dialog_url: "#pic_dialog_url",
+            picPreview: "#picPreview",
+            picAddClose: "#picAddClose",
+            picSaveBtn: "#picSaveBtn"
+
+        });
+
+        this.renderTab = function(e, data) {
+            if (!this.attr.loadonce) {
+                console.log("render uiTabPanelLibrary is ok!");
+
+                var that = this;
+                $('body').append(this.getDialog());
+
+                this.attr.picDialog = $("#uiPicAdd").dialog({
+                    closeOnEscape:false,
+                    create: function(event) {
+                        $(event.target).dialog("widget").css({ "position": "fixed" });
+                    },
+                    resizable: false,
+                    height: 400,
+                    width: 680,
+                    modal: true,
+                    title: 'i am dialog',
+                    position: { my: "top", at: "bottom", of: $('#artOpPanel') },
+                    dialogClass: '',
+                    autoOpen: false,
+                    buttons: {
+
+                    }
+                });
+
+                this.renderPicListScroll();
+                this.addBoxListener();
+            }
+            this.attr.loadonce = true;
+        }
+
+        this.addBoxListener = function() {
+            var that = this;
+
+            $(this.attr.loveBoxSelector).scroll(function() {
+                var $this = $(this);
+                var height = this.scrollHeight - $this.height() - 50; // Get the height of the div
+                var scroll = $this.scrollTop(); // Get the vertical scroll position
+
+                var isScrolledToEnd = (scroll >= height);
+
+                if (isScrolledToEnd) {
+                    that.renderPicListScroll();
+                }
+            });
+
+            this.on(this.attr.libraryTabSelector, 'click', {
+                itemOpDeleteSelector: this.itemOpDelete,
+                picAddBtnSelector: this.picAddDialog
+            });
+
+            this.on(this.attr.picBtnDivSelector, 'change', {
+                picUploadFileSelector: this.picUpload
+            });
+
+            this.on(this.attr.picAddClose, 'click', this.closePicAddDialog);
+
+            this.on(this.attr.pic_dialog_url, 'change', this.onImgUrlChange);
+            this.on(this.attr.picSaveBtn, 'click', this.picSave);
+        }
+
+        this.renderPicListScroll = function() {
+            this.trigger(ns.e.data.dataPicList, {
+                pageid: this.attr.pageid,
+                triggerEvent:ns.e.tab.uiPicList
+            });
+            this.attr.pageid++;
+        }
+        this.clearPicListInBox = function() {
+            this.attr.pageid = 0;
+            $(this.attr.libraryPicBoxSelector).html('');
+        }
+
+        this.itemOpDelete = function(e, data) {
+            var lid = $(data.el).parent().data('id');
+            this.trigger(ns.e.data.dataPicDelete, {
+                lid: lid,
+                el: data.el,
+                triggerEvent:ns.e.tab.uiPicDelete
+            });
+        };
+        this.picSave = function (){
+            var url = $("#pic_dialog_url").val();
+            this.picAdd(null, {
+                url: url
+            });
+
+            this.closePicAddDialog();
+        }
+
+        this.picAdd = function(e, data) {
+            this.trigger(ns.e.data.dataPicAdd, {
+                url: data.url,
+                triggerEvent:ns.e.tab.uiPicRefresh
+            });
+        }
+
+        this.picUpload = function(e, data) {
+            var file = $(data.el)[0].files[0];
+            var that = this;
+            var ic = ns.c.img;
+            util.uploadfile(file, {
+                success: function(blkRet) {
+                    that.picAdd(null, {
+                        url: ic.url + blkRet.key + "?" + ic.api_type + ic.suf + ic.mode + ic.suf + "w" + ic.suf + ic.pic_list_img.w
+                    });
+                },
+                error: function() {
+
+                }
+            });
+        }
+
+        this.onImgUrlChange = function () {
+            var url = $("#pic_dialog_url").val();
+            $(this.attr.picPreview).attr("src",url);
+        }
+
+        this.picAddDialog = function() {
+            util.displayGrayBg();
+            this.attr.picDialog.dialog("open");
+        }
+
+        this.closePicAddDialog  = function() {
+            this.attr.picDialog.dialog("close");
+            util.hideGrayBg();
+        }
+
+        //callback when server send json data to client
+        this.renderPicList = function(e, data) {
+            $(this.attr.libraryPicBoxSelector).append(Mustache.render(this.getTmpl(), data.json));
+            this.activeDraggable($(this.attr.itemDraggable));
+        }
+
+        this.renderPicDelete = function(e, data) {
+            $(data.el).parent().parent().remove();
+        }
+
+        this.renderPicRefresh = function(e, data) {
+            if (this.attr.loadonce) {
+                /*var json = {
+                    objs: {
+                        id: data.json.lid,
+                        url: data.url
+                    }
+                };
+                $(this.attr.libraryPicBoxSelector).append(Mustache.render(this.getTmpl(), json));*/
+                this.clearPicListInBox();
+                this.renderPicListScroll();
+            }
+        }
+
+        this.getDialog = function() {
+            return [
+                // '<div id="uiPicAdd">',
+                // '<div>',
+                // '<label style="display:inline-block;">图片链接地址:</label>',
+                // '<input type="text" id="pic_dialog_url" style="display:inline-block;width:300px;"/>',
+                // '</div>',
+                // '</div>',
+                '<div id="uiPicAdd" class="popContent9 displayT">\
+                    <img id="picAddClose" src="images/p3_7.png" class="popClose" />\
+                    <div class="pd20 displayTC">\
+                        <div class="font16 colorBlack">图片</div>\
+                        <div class="bgWhite1 pt20 pb20">\
+                            <input id="pic_dialog_url" class="input1 width6 bgGray1 pd10 borderR5" type="text" placeholder="输入链接">\
+                        </div>\
+                        <div class="textC pt10">\
+                            <a id="picSaveBtn" class="displayI bgYellow font16 colorWhite pt5 pb5 pl30 pr30">保存</a>\
+                        </div>\
+                    </div>\
+                    <div class="bgGray3 pd20 displayTC borderTR5 borderBR5">\
+                        <div class="displayI font14 colorGray border1 pt5 pb5 pl10 pr10">预览</div>\
+                        <img id="picPreview" src="" class="displayB width6 mt20" />\
+                    </div>\
+                </div>'
+            ].join('\n');
+        }
+
+        this.getTmpl = function() {
+            return [
+                '{{#objs}}',
+                '<div class="cell-image item-draggable" style="position:relative" targettype="image" src="{{url}}">',
+                '<div class="item-op-center" data-id="{{id}}">',
+                '<i class="iconfont icon-shanchu"/>',
+                '</div>',
+                '<div class="library-cell">',
+                '<img src="{{url}}"/>',
+                '</div>',
+                '</div>',
+                '{{/objs}}',
+            ].join('\n');
+        }
+
+        this.doDirectInsert = function (e, data){
+            var lastIdx = util.getLastCanvasItemIndex();
+
+            var styleObj = {};
+            styleObj['src']= e.currentTarget.attributes['src'].value;
+            this.trigger(ns.e.createNode, {
+                itemtype: 'image',
+                para :  styleObj,
+                el:$(".canvas > [kctype='container']")[0],
+                preel: lastIdx,
+            });
+        }
+
+        this.after("initialize", function() {
+            console.log("uiTabPanelLibrary is ok!");
+            this.on(document, ns.e.tab.uiTabLibrary, this.renderTab);
+            this.on(document, ns.e.tab.uiPicList, this.renderPicList);
+            this.on(document, ns.e.tab.uiPicDelete, this.renderPicDelete);
+            this.on(document, ns.e.tab.uiPicRefresh, this.renderPicRefresh);
+            this.on('click', {cellImageSelector: this.doDirectInsert});
+        });
+    }
+});

pool/shard005/JavaScript/0032554_Data.js

@@ -0,0 +1,110 @@
+function Data(){
+
+		//this.config = JSON.parse(Titanium.App.Properties.getString("config"));
+}
+
+Data.prototype.getGasolineras = function(coordenadas) {
+	var config = JSON.parse(Titanium.App.Properties.getString("config"));
+	var xhr = Titanium.Network.createHTTPClient({
+		enableKeepAlive:false
+		});
+	if(Ti.Network.online){
+		xhr.timeout = 15000;
+		xhr.onload = function()
+		{
+			Ti.API.info('XHR "onload" ['+this.status+']: '+this.responseText+'');
+			Titanium.API.info('loaded');
+			//Si nos responde correctamente con el JSON
+			if (this.status == 200)
+			{
+				var gasolineras = JSON.parse(this.responseText);
+				if (gasolineras.error == "Ninguna gasolinera cercana")
+				{
+					//hideIndicator();
+					Titanium.API.info('Ninguna gasolinera cercana');
+					var alertDialog = Titanium.UI.createAlertDialog({
+					    title: 'Aviso',
+					    message: 'Ninguna gasolinera cercana a tu posición',
+					    buttonNames: ['Reintentar','Ajustes']
+					});
+					//Mostramos alerta del error y volvemos a pedir las gasolineras si clicka el boton
+					alertDialog.show();
+					alertDialog.addEventListener('click', function(e){
+						//Si ha pulsado reintentar
+						if (e.index==0)
+						{
+						//showIndicator();
+			            Ti.App.fireEvent('location.refresh');
+			           	}
+			            else{
+			           	Ti.App.fireEvent('gas.notfound');
+			           }
+			        }); 
+				}
+				else
+				{
+					var gasolinerasArray = new Array();
+					
+						for (var c=0;c<gasolineras.length;c++)
+						{
+							gasolinerasArray[c] = {
+													'id': gasolineras[c].id_gasolinera,
+													'lat':gasolineras[c].lat,
+													'lng':gasolineras[c].lng,
+													'provincia': gasolineras[c].provincia, 
+													'localidad': gasolineras[c].localidad,
+													'distancia': gasolineras[c].distance,
+													'precio': gasolineras[c]['p'+JSON.parse(Titanium.App.Properties.getString("config")).tipoName],
+													'fecha':gasolineras[c]['f'+JSON.parse(Titanium.App.Properties.getString("config")).tipoName],
+													'direccion':gasolineras[c].direccion,
+													'rotulo': gasolineras[c].rotulo,
+													'horario': gasolineras[c].horario
+											};
+							try{
+							gasolinerasArray[c].precio = gasolinerasArray[c].precio.replace('.',',');
+							}
+							catch (e){
+							gasolinerasArray[c].precio = "-,--";
+							}
+						}
+					Titanium.App.Properties.setString("gasolinerasList",  JSON.stringify(gasolinerasArray) );
+					Ti.App.fireEvent('gasolineras.updated');		
+				}
+			}
+			 
+		}
+		xhr.onerror = function()
+		{
+			Titanium.API.info('error');
+			Ti.API.info('XHR "onload" ['+this.status+']: '+this.responseText+'');
+			var alertDialog = Titanium.UI.createAlertDialog({
+			    title: 'Error',
+			    message: 'No se ha podido establecer la conexion, comprueba tu conexión',
+			    buttonNames: ['Reintentar']
+			});
+			//Mostramos alerta del error y volvemos a pedir las gasolineras si clicka el boton
+			alertDialog.show();
+			alertDialog.addEventListener('click', function(e){
+	              	Ti.App.fireEvent('location.refresh');
+	        }); 
+		}
+		
+		Ti.API.info("http://localhost:10088/Repostaje/api/gasolineras/lat/"+coordenadas.lat+"/lng/"+coordenadas.lng+"/radio/"+config.radio+"/limit/"+config.limit+"/carburante/"+config.tipoName);
+		//xhr.open("GET","http://localhost:10088/Repostaje/api/gasolineras/lat/"+42.538059+"/lng/"+-2.556020+"/radio/"+radio+"/limit/"+limit);
+		xhr.open("GET","http://repostaje.gesdinet.org/api/gasolineras/lat/"+coordenadas.lat+"/lng/"+coordenadas.lng+"/radio/"+config.radio+"/limit/"+config.limit+"/carburante/"+config.tipoName);
+		xhr.send();
+	}
+	else {
+			//hideIndicator();
+            var alertDialog = Titanium.UI.createAlertDialog({
+              title: 'Problemas',
+              message: 'No tienes conexión a Internet.',
+              buttonNames: ['Ok']
+            });
+            alertDialog.show();
+            Ti.App.fireEvent('change.settings');
+        }
+	
+};
+
+module.exports = Data;

pool/shard005/JavaScript/0032557_withdrawaltransfer.js

@@ -0,0 +1,134 @@
+var constants = require("../helpers/constants.js");
+
+var private = {}, self = null,
+	library = null, modules = null;
+
+function WithdrawalTransfer(cb, _library) {
+	self = this;
+	library = _library;
+	cb(null, self);
+}
+
+WithdrawalTransfer.prototype.create = function (data, trs) {
+	trs.recipientId = null;
+	trs.amount = data.amount;
+	return trs;
+}
+
+WithdrawalTransfer.prototype.calculateFee = function (trs) {
+	return 0.1 * constants.fixedPoint;
+}
+
+WithdrawalTransfer.prototype.verify = function (trs, sender, cb, scope) {
+	if (trs.recipientId) {
+		return cb("Invalid recipient");
+	}
+
+	if (trs.amount <= 0) {
+		return cb("Invalid transaction amount");
+	}
+
+	cb(null, trs);
+}
+
+WithdrawalTransfer.prototype.getBytes = function (trs) {
+	return null;
+}
+
+WithdrawalTransfer.prototype.apply = function (trs, sender, cb, scope) {
+	modules.blockchain.accounts.mergeAccountAndGet({
+		address: sender.address,
+		balance: {"LISK": -(trs.amount + trs.fee)}
+	}, cb, scope);
+}
+
+WithdrawalTransfer.prototype.undo = function (trs, sender, cb, scope) {
+	modules.blockchain.accounts.undoMerging({
+		address: sender.address,
+		balance: {"LISK": -(trs.amount + trs.fee)}
+	}, cb, scope);
+}
+
+WithdrawalTransfer.prototype.applyUnconfirmed = function (trs, sender, cb, scope) {
+	var sum = trs.amount + trs.fee;
+
+	if (sender.u_balance["LISK"] < sum) {
+		return cb("Account does not have enough LISK");
+	}
+
+	modules.blockchain.accounts.mergeAccountAndGet({
+		address: sender.address,
+		u_balance: {"LISK": -(trs.amount + trs.fee)}
+	}, cb, scope);
+}
+
+WithdrawalTransfer.prototype.undoUnconfirmed = function (trs, sender, cb, scope) {
+	modules.blockchain.accounts.undoMerging({
+		address: sender.address,
+		u_balance: {"LISK": -(trs.amount + trs.fee)}
+	}, cb, scope);
+}
+
+WithdrawalTransfer.prototype.ready = function (trs, sender, cb, scope) {
+	setImmediate(cb);
+}
+
+WithdrawalTransfer.prototype.normalize = function (asset, cb) {
+	setImmediate(cb);
+}
+
+WithdrawalTransfer.prototype.save = function (trs, cb) {
+	setImmediate(cb);
+}
+
+WithdrawalTransfer.prototype.dbRead = function (row) {
+	return null;
+}
+
+WithdrawalTransfer.prototype.onBind = function (_modules) {
+	modules = _modules;
+
+	modules.logic.transaction.attachAssetType(2, self);
+}
+
+WithdrawalTransfer.prototype.withdrawal = function (cb, query) {
+	library.validator.validate(query, {
+		type: "object",
+		properties: {
+			secret: {
+				type: "string",
+				minLength: 1,
+				maxLength: 100
+			},
+			amount: {
+				type: "integer",
+				minimum: 1
+			}
+		},
+	}, function (err) {
+		if (err) {
+			return cb(err[0].message);
+		}
+
+		var keypair = modules.api.crypto.keypair(query.secret);
+
+		var account = modules.blockchain.accounts.getAccount({
+			publicKey: keypair.publicKey.toString("hex")
+		}, function (err, account) {
+			try {
+				var transaction = library.modules.logic.transaction.create({
+					type: 2,
+					amount: query.amount,
+					sender: account,
+					keypair: keypair
+				});
+			} catch (e) {
+				return setImmediate(cb, e.toString(0));
+			}
+
+			modules.blockchain.transactions.processUnconfirmedTransaction(transaction, cb);
+		});
+	})
+}
+
+module.exports = WithdrawalTransfer;

pool/shard005/JavaScript/0032563_test-browser-creation.js

@@ -0,0 +1,72 @@
+/*global describe, beforeEach, it*/
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var yeoman = require('yeoman-generator');
+var helpers = yeoman.test;
+var assert = yeoman.assert;
+
+var expectedFiles = ['.bowerrc', 'bower.json', 'index.html'];
+var unexpectedFiles = ['package.json'];
+
+
+describe('test browser generator', function () {
+
+  // -----------------------------------------------------------------------------
+  // Test behavior when there are not pre-existing js files.
+  // -----------------------------------------------------------------------------
+  it('creates expected files when no .js files exist', function (done) {
+    helpers.run(path.join(__dirname, '../app'))
+      .inDir(path.join(__dirname, './temp'))
+      .withOptions({
+        'skip-install': true
+      })
+      .withPrompt({
+        'environment': 'browser',
+        'algorithm': 'algorithm'
+      })
+      .on('end', function () {
+        var expected = expectedFiles.concat([
+          'spec/algorithm.js',
+          'algorithm.js'
+        ]);
+        assert.file(expected);
+        assert.fileContent('algorithm.js', /var algorithm = function ()/);
+        assert.fileContent('bower.json', /chai/);
+        assert.noFileContent('./spec/algorithm.js', /require/);
+        done();
+      });
+  });
+
+  it('leaves existing files intact when they exist', function (done) {
+    helpers.run(path.join(__dirname, '../app'))
+      .inDir(path.join(__dirname, './temp'))
+      .withOptions({
+        'skip-install': true
+      })
+      .withPrompt({
+        'environment': 'browser',
+        'file': 'myAlgo.js'
+      })
+      .on('ready', function (generator) {
+        var js = "var myAlgo = function () { return { method: function () {} }; };";
+        fs.writeFileSync(path.join(__dirname, './temp/myAlgo.js'), js);
+      })
+      .on('end', function () {
+        var expected = expectedFiles.concat([
+          'spec/myAlgo.js',
+          'myAlgo.js'
+        ]);
+        assert.file(expected);
+        assert.fileContent('myAlgo.js', /myAlgo/);
+        assert.noFileContent('./spec/myAlgo.js', /require/);
+        assert.fileContent('bower.json', /chai/);
+        // doesn't work as expected; figure out a better way to do this.
+        // eval(fs.readFileSync(path.join(__dirname, './temp/myAlgo.js'), 'utf8'));
+        // assert.implement(myAlgo(), ['method']);
+        done();
+      });
+  });
+
+});

pool/shard005/JavaScript/0032567_ajaxLog.js

@@ -0,0 +1,39 @@
+/**
+ *
+ * @authors Leonard LEPADATU (lepadatu.leonard-ext@groupehn.com)
+ * @date    2015-05-08 14:24:24
+ * @version $Id$
+ */
+
+ function ajaxLog(data) {
+
+	if (window.XMLHttpRequest) { // Mozilla, Safari, ...
+
+		httpRequest = new XMLHttpRequest();
+
+	} else if (window.ActiveXObject) { // IE
+
+		try {
+			httpRequest = new ActiveXObject("Msxml2.XMLHTTP");
+		}
+		catch (e) {
+
+			try {
+				httpRequest = new ActiveXObject("Microsoft.XMLHTTP");
+			}
+			catch (e) {}
+
+		}
+
+	}
+
+	if (!httpRequest) {
+		console.log('Cannot create an XMLHTTP instance');
+		return false;
+	}
+
+	httpRequest.onreadystatechange = console.log("ready for log...");
+	httpRequest.open('POST', "../log/log.php");
+	httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+	httpRequest.send('adblock=' + encodeURIComponent(data));
+}

pool/shard005/JavaScript/0032569_Entry.js

@@ -0,0 +1,262 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 argscheck = require('cordova/argscheck'),
+    exec = require('cordova/exec'),
+    FileError = require('./FileError'),
+    Metadata = require('./Metadata');
+
+/**
+ * Represents a file or directory on the local file system.
+ *
+ * @param isFile
+ *            {boolean} true if Entry is a file (readonly)
+ * @param isDirectory
+ *            {boolean} true if Entry is a directory (readonly)
+ * @param name
+ *            {DOMString} name of the file or directory, excluding the path
+ *            leading to it (readonly)
+ * @param fullPath
+ *            {DOMString} the absolute full path to the file or directory
+ *            (readonly)
+ * @param fileSystem
+ *            {FileSystem} the filesystem on which this entry resides
+ *            (readonly)
+ * @param nativeURL
+ *            {DOMString} an alternate URL which can be used by native
+ *            webview controls, for example media players.
+ *            (optional, readonly)
+ */
+function Entry(isFile, isDirectory, name, fullPath, fileSystem, nativeURL) {
+    this.isFile = !!isFile;
+    this.isDirectory = !!isDirectory;
+    this.name = name || '';
+    this.fullPath = fullPath || '';
+    this.filesystem = fileSystem || null;
+    this.nativeURL = nativeURL || null;
+}
+
+/**
+ * Look up the metadata of the entry.
+ *
+ * @param successCallback
+ *            {Function} is called with a Metadata object
+ * @param errorCallback
+ *            {Function} is called with a FileError
+ */
+Entry.prototype.getMetadata = function(successCallback, errorCallback) {
+    argscheck.checkArgs('FF', 'Entry.getMetadata', arguments);
+    var success = successCallback && function(entryMetadata) {
+        var metadata = new Metadata({
+            size: entryMetadata.size,
+            modificationTime: entryMetadata.lastModifiedDate
+        });
+        successCallback(metadata);
+    };
+    var fail = errorCallback && function(code) {
+        errorCallback(new FileError(code));
+    };
+    exec(success, fail, "File", "getFileMetadata", [this.toInternalURL()]);
+};
+
+/**
+ * Set the metadata of the entry.
+ *
+ * @param successCallback
+ *            {Function} is called with a Metadata object
+ * @param errorCallback
+ *            {Function} is called with a FileError
+ * @param metadataObject
+ *            {Object} keys and values to set
+ */
+Entry.prototype.setMetadata = function(successCallback, errorCallback, metadataObject) {
+    argscheck.checkArgs('FFO', 'Entry.setMetadata', arguments);
+    exec(successCallback, errorCallback, "File", "setMetadata", [this.toInternalURL(), metadataObject]);
+};
+
+/**
+ * Move a file or directory to a new location.
+ *
+ * @param parent
+ *            {DirectoryEntry} the directory to which to move this entry
+ * @param newName
+ *            {DOMString} new name of the entry, defaults to the current name
+ * @param successCallback
+ *            {Function} called with the new DirectoryEntry object
+ * @param errorCallback
+ *            {Function} called with a FileError
+ */
+Entry.prototype.moveTo = function(parent, newName, successCallback, errorCallback) {
+    argscheck.checkArgs('oSFF', 'Entry.moveTo', arguments);
+    var fail = errorCallback && function(code) {
+        errorCallback(new FileError(code));
+    };
+    var srcURL = this.toInternalURL(),
+        // entry name
+        name = newName || this.name,
+        success = function(entry) {
+            if (entry) {
+                if (successCallback) {
+                    // create appropriate Entry object
+                    var newFSName = entry.filesystemName || (entry.filesystem && entry.filesystem.name);
+                    var fs = newFSName ? new FileSystem(newFSName, { name: "", fullPath: "/" }) : new FileSystem(parent.filesystem.name, { name: "", fullPath: "/" });
+                    var result = (entry.isDirectory) ? new (require('./DirectoryEntry'))(entry.name, entry.fullPath, fs, entry.nativeURL) : new (require('cordova-plugin-file.FileEntry'))(entry.name, entry.fullPath, fs, entry.nativeURL);
+                    successCallback(result);
+                }
+            }
+            else {
+                // no Entry object returned
+                if (fail) {
+                    fail(FileError.NOT_FOUND_ERR);
+                }
+            }
+        };
+
+    // copy
+    exec(success, fail, "File", "moveTo", [srcURL, parent.toInternalURL(), name]);
+};
+
+/**
+ * Copy a directory to a different location.
+ *
+ * @param parent
+ *            {DirectoryEntry} the directory to which to copy the entry
+ * @param newName
+ *            {DOMString} new name of the entry, defaults to the current name
+ * @param successCallback
+ *            {Function} called with the new Entry object
+ * @param errorCallback
+ *            {Function} called with a FileError
+ */
+Entry.prototype.copyTo = function(parent, newName, successCallback, errorCallback) {
+    argscheck.checkArgs('oSFF', 'Entry.copyTo', arguments);
+    var fail = errorCallback && function(code) {
+        errorCallback(new FileError(code));
+    };
+    var srcURL = this.toInternalURL(),
+        // entry name
+        name = newName || this.name,
+        // success callback
+        success = function(entry) {
+            if (entry) {
+                if (successCallback) {
+                    // create appropriate Entry object
+                    var newFSName = entry.filesystemName || (entry.filesystem && entry.filesystem.name);
+                    var fs = newFSName ? new FileSystem(newFSName, { name: "", fullPath: "/" }) : new FileSystem(parent.filesystem.name, { name: "", fullPath: "/" });
+                    var result = (entry.isDirectory) ? new (require('./DirectoryEntry'))(entry.name, entry.fullPath, fs, entry.nativeURL) : new (require('cordova-plugin-file.FileEntry'))(entry.name, entry.fullPath, fs, entry.nativeURL);
+                    successCallback(result);
+                }
+            }
+            else {
+                // no Entry object returned
+                if (fail) {
+                    fail(FileError.NOT_FOUND_ERR);
+                }
+            }
+        };
+
+    // copy
+    exec(success, fail, "File", "copyTo", [srcURL, parent.toInternalURL(), name]);
+};
+
+/**
+ * Return a URL that can be passed across the bridge to identify this entry.
+ */
+Entry.prototype.toInternalURL = function() {
+    if (this.filesystem && this.filesystem.__format__) {
+      return this.filesystem.__format__(this.fullPath, this.nativeURL);
+    }
+};
+
+/**
+ * Return a URL that can be used to identify this entry.
+ * Use a URL that can be used to as the src attribute of a <video> or
+ * <audio> tag. If that is not possible, construct a cdvfile:// URL.
+ */
+Entry.prototype.toURL = function() {
+    if (this.nativeURL) {
+      return this.nativeURL;
+    }
+    // fullPath attribute may contain the full URL in the case that
+    // toInternalURL fails.
+    return this.toInternalURL() || "file://localhost" + this.fullPath;
+};
+
+/**
+ * Backwards-compatibility: In v1.0.0 - 1.0.2, .toURL would only return a
+ * cdvfile:// URL, and this method was necessary to obtain URLs usable by the
+ * webview.
+ * See CB-6051, CB-6106, CB-6117, CB-6152, CB-6199, CB-6201, CB-6243, CB-6249,
+ * and CB-6300.
+ */
+Entry.prototype.toNativeURL = function() {
+    console.log("DEPRECATED: Update your code to use 'toURL'");
+    return this.toURL();
+};
+
+/**
+ * Returns a URI that can be used to identify this entry.
+ *
+ * @param {DOMString} mimeType for a FileEntry, the mime type to be used to interpret the file, when loaded through this URI.
+ * @return uri
+ */
+Entry.prototype.toURI = function(mimeType) {
+    console.log("DEPRECATED: Update your code to use 'toURL'");
+    return this.toURL();
+};
+
+/**
+ * Remove a file or directory. It is an error to attempt to delete a
+ * directory that is not empty. It is an error to attempt to delete a
+ * root directory of a file system.
+ *
+ * @param successCallback {Function} called with no parameters
+ * @param errorCallback {Function} called with a FileError
+ */
+Entry.prototype.remove = function(successCallback, errorCallback) {
+    argscheck.checkArgs('FF', 'Entry.remove', arguments);
+    var fail = errorCallback && function(code) {
+        errorCallback(new FileError(code));
+    };
+    exec(successCallback, fail, "File", "remove", [this.toInternalURL()]);
+};
+
+/**
+ * Look up the parent DirectoryEntry of this entry.
+ *
+ * @param successCallback {Function} called with the parent DirectoryEntry object
+ * @param errorCallback {Function} called with a FileError
+ */
+Entry.prototype.getParent = function(successCallback, errorCallback) {
+    argscheck.checkArgs('FF', 'Entry.getParent', arguments);
+    var fs = this.filesystem;
+    var win = successCallback && function(result) {
+        var DirectoryEntry = require('./DirectoryEntry');
+        var entry = new DirectoryEntry(result.name, result.fullPath, fs, result.nativeURL);
+        successCallback(entry);
+    };
+    var fail = errorCallback && function(code) {
+        errorCallback(new FileError(code));
+    };
+    exec(win, fail, "File", "getParent", [this.toInternalURL()]);
+};
+
+module.exports = Entry;

pool/shard005/JavaScript/0032570_IceFailedHandling.js

@@ -0,0 +1,124 @@
+import { getLogger } from '@jitsi/logger';
+
+import * as JitsiConferenceErrors from '../../JitsiConferenceErrors';
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+
+const logger = getLogger(__filename);
+
+/**
+ * This class deals with shenanigans around JVB media session's ICE failed status handling.
+ *
+ * If ICE restarts are NOT explicitly enabled by the {@code enableIceRestart} config option, then the conference will
+ * delay emitting the {@JitsiConferenceErrors.ICE_FAILED} event by 15 seconds. If the network info module reports
+ * the internet offline status then the time will start counting after the internet comes back online.
+ *
+ * If ICE restart are enabled, then a delayed ICE failed notification to Jicofo will be sent, only if the ICE connection
+ * does not recover soon after or before the XMPP connection is restored (if it was ever broken). If ICE fails while
+ * the XMPP connection is not broken then the notifications will be sent after 2 seconds delay.
+ */
+export default class IceFailedHandling {
+    /**
+     * Creates new {@code DelayedIceFailed} task.
+     * @param {JitsiConference} conference
+     */
+    constructor(conference) {
+        this._conference = conference;
+    }
+
+    /**
+     * After making sure there's no way for the ICE connection to recover this method either sends ICE failed
+     * notification to Jicofo or emits the ice failed conference event.
+     * @private
+     * @returns {void}
+     */
+    _actOnIceFailed() {
+        if (!this._conference.room) {
+            return;
+        }
+
+        const { enableForcedReload, enableIceRestart } = this._conference.options.config;
+        const explicitlyDisabled = typeof enableIceRestart !== 'undefined' && !enableIceRestart;
+        const supportsRestartByTerminate = this._conference.room.supportsRestartByTerminate();
+        const useTerminateForRestart = supportsRestartByTerminate && !enableIceRestart;
+
+        logger.info('ICE failed,'
+            + ` enableForcedReload: ${enableForcedReload},`
+            + ` enableIceRestart: ${enableIceRestart},`
+            + ` supports restart by terminate: ${supportsRestartByTerminate}`);
+
+        if (explicitlyDisabled || (!enableIceRestart && !supportsRestartByTerminate) || enableForcedReload) {
+            logger.info('ICE failed, but ICE restarts are disabled');
+            const reason = enableForcedReload
+                ? JitsiConferenceErrors.CONFERENCE_RESTARTED
+                : JitsiConferenceErrors.ICE_FAILED;
+
+            this._conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, reason);
+
+            return;
+        }
+
+        const jvbConnection = this._conference.jvbJingleSession;
+        const jvbConnIceState = jvbConnection && jvbConnection.getIceConnectionState();
+
+        if (!jvbConnection) {
+            logger.warn('Not sending ICE failed - no JVB connection');
+        } else if (jvbConnIceState === 'connected') {
+            logger.info('ICE connection restored - not sending ICE failed');
+        } else {
+            logger.info('Sending ICE failed - the connection did not recover, '
+                + `ICE state: ${jvbConnIceState}, `
+                + `use 'session-terminate': ${useTerminateForRestart}`);
+            if (useTerminateForRestart) {
+                this._conference.jvbJingleSession.terminate(
+                    () => {
+                        logger.info('session-terminate for ice restart - done');
+                    },
+                    error => {
+                        logger.error(`session-terminate for ice restart - error: ${error.message}`);
+                    }, {
+                        reason: 'connectivity-error',
+                        reasonDescription: 'ICE FAILED',
+                        requestRestart: true,
+                        sendSessionTerminate: true
+                    });
+            } else {
+                this._conference.jvbJingleSession.sendIceFailedNotification();
+            }
+        }
+    }
+
+    /**
+     * Starts the task.
+     */
+    start() {
+        //  Using xmpp.ping allows to handle both XMPP being disconnected and internet offline cases. The ping function
+        // uses sendIQ2 method which is resilient to XMPP connection disconnected state and will patiently wait until it
+        // gets reconnected.
+        //  This also handles the case about waiting for the internet to come back online, because ping
+        // will only succeed when the internet is online and then there's a chance for the ICE to recover from FAILED to
+        // CONNECTED which is the extra 2 second timeout after ping.
+        //  The 65 second timeout is given on purpose as there's no chance for XMPP to recover after 65 seconds of no
+        // communication with the server. Such resume attempt will result in unrecoverable conference failed event due
+        // to 'item-not-found' error returned by the server.
+        this._conference.xmpp.ping(65000).then(
+            () => {
+                if (!this._canceled) {
+                    this._iceFailedTimeout = window.setTimeout(() => {
+                        this._iceFailedTimeout = undefined;
+                        this._actOnIceFailed();
+                    }, 2000);
+                }
+            },
+            error => {
+                logger.error('PING error/timeout - not sending ICE failed', error);
+            });
+    }
+
+    /**
+     * Cancels the task.
+     */
+    cancel() {
+        this._canceled = true;
+        window.clearTimeout(this._iceFailedTimeout);
+    }
+}

pool/shard005/JavaScript/0032576_printer.js

@@ -0,0 +1,26 @@
+var BrotherPrinter = function () {}
+BrotherPrinter.prototype = {
+    findNetworkPrinters: function (callback, scope) {
+        var callbackFn = function () {
+            var args = typeof arguments[0] == 'boolean' ? arguments : arguments[0]
+            callback.apply(scope || window, args)
+        }
+        cordova.exec(callbackFn, null, 'BrotherPrinter', 'findNetworkPrinters', [])
+    },
+    printViaSDK: function (data, callback) {
+        if (!data || !data.length) {
+            console.log('No data passed in. Expects a bitmap.')
+            return
+        }
+        cordova.exec(callback, function(err){console.log('error: '+err)}, 'BrotherPrinter', 'printViaSDK', [data])
+    },
+    sendUSBConfig: function (data, callback) {
+        if (!data || !data.length) {
+            console.log('No data passed in. Expects print payload string.')
+            return
+        }
+        cordova.exec(callback, function(err){console.log('error: '+err)}, 'BrotherPrinter', 'sendUSBConfig', [data])
+    }
+}
+var plugin = new BrotherPrinter()
+module.exports = plugin

pool/shard005/JavaScript/0032577_logger.js

@@ -0,0 +1,42 @@
+import config from './config';
+import Utils from './utils';
+
+export default class Logger {
+
+  /**
+   * Logs the current instruction and state of registers
+   * @param cpu
+   * @param fn
+   * @param paramLength
+   * @param param
+   */
+  static state(cpu, fn, paramLength, param){
+    if (config.DEBUG) {
+      console.info(`[${Utils.hex4(cpu.pc() - paramLength - 1)}] ${Utils.str20(fn.name + ' ' + Utils.hexStr(param))} 0b${cpu.Z()}${cpu.N()}${cpu.H()}${cpu.C()}  a:${Utils.hex2(cpu.a())} bc:${Utils.hex4(cpu.bc())} de:${Utils.hex4(cpu.de())} hl:${Utils.hex4(cpu.hl())} sp:${Utils.hex4(cpu.sp())} pc:${Utils.hex4(cpu.pc())} if:${Utils.hex2(cpu.If())} ie:${Utils.hex2(cpu.ie())} ly:${Utils.hex2(cpu.mmu.ly())} lcdc:${Utils.hex2(cpu.lcdc())} stat:${Utils.hex2(cpu.stat())}`);
+    }
+  }
+
+  static beforeCrash(cpu, instructionFn, paramLength, param){
+    config.DEBUG = true;
+    Logger.state(cpu, instructionFn, paramLength, param);
+    config.DEBUG = false;
+  }
+
+  static warn(msg){
+    if (!config.TEST) {
+      console.warn(`${msg}`);
+    }
+  }
+
+  static info(msg){
+    if (config.DEBUG && !config.TEST) {
+      console.info(`${msg}`);
+    }
+  }
+
+  static error(msg){
+    if (!config.TEST) {
+      console.error(`${msg}`);
+    }
+  }
+}

pool/shard005/JavaScript/0032580_Screen4.js

@@ -0,0 +1,100 @@
+import React, { Component, PropTypes } from 'react';
+import {
+  View,
+  StyleSheet,
+  TouchableOpacity,
+  Text,
+  Dimensions,
+ } from 'react-native';
+import { NavigationActions } from 'react-navigation';
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    flexDirection: 'column',
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: 'lightgreen',
+  },
+  text: {
+    fontWeight: '100',
+    fontSize: 40,
+    textAlign: 'center',
+    paddingVertical: 100,
+  },
+  button: {
+    justifyContent: 'center',
+    alignItems: 'center',
+    width: Dimensions.get('window').width,
+    height: 50,
+    marginVertical: 5,
+    backgroundColor: 'grey',
+  },
+  buttonText: {
+    fontWeight: '100',
+    fontSize: 20,
+    textAlign: 'center',
+    color: 'white',
+  },
+});
+
+
+class Screen4 extends Component {
+
+  back() {
+ // this.props.dispatch in the main function that literally activates/runs the action you give it
+ // In this case we are going back one page
+    this.props.navigation.dispatch(NavigationActions.back());
+  }
+
+// This navigates back to the initial page
+  top() {
+  // Same dispatch function from before
+    this.props.navigation.dispatch(
+      // in this case were running the action "reset"
+      NavigationActions.reset({
+        // this is the index of the page we want to go to
+        // it can be anything but in this case we want to go to the start
+        index: 0,
+        // this is what action we want to do
+        // we are navigating to the first page but we have to do this
+        // inside the reset function or else it would add the page to the
+        // navigator stack instead of going back to the first one
+        // idk what else you can do in here but ik this works
+        actions: [
+            // routeName has to be the ReferenceName of the page you are going to
+          NavigationActions.navigate({ routeName: 'Home' }),
+        ],
+      }),
+      );
+  }
+
+  render() {
+    const { params } = this.props.navigation.state;
+    return (
+      <View style={styles.container}>
+        <Text>{params.teamName}</Text>
+        <Text style={styles.text}>This is Screen 4</Text>
+        <TouchableOpacity style={styles.button} onPress={() => this.back()}>
+          <Text style={styles.buttonText}>Go Back</Text>
+        </TouchableOpacity>
+        <TouchableOpacity style={styles.button} onPress={() => this.top()}>
+          <Text style={styles.buttonText}>Go Home</Text>
+        </TouchableOpacity>
+      </View>
+    );
+  }
+ }
+
+// This is the title that appears on the top
+// it has to be the same name as your class
+// {CLASSNAME}.navigationOptions = {}
+Screen4.navigationOptions = {
+  title: 'Screen 4',
+};
+
+Screen4.propTypes = {
+  navigation: PropTypes.object.isRequired,
+};
+
+export default Screen4;

pool/shard005/JavaScript/0032584_test.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var argv = require('yargs').argv;
+var gulp = require('gulp');
+var karma = require('karma').server;
+var mkdirp = require('mkdirp');
+var path = require('path');
+var runSequence = require('run-sequence');
+
+var rootDir = path.join(__dirname, '..');
+
+var distFolder = path.join(rootDir, 'dist');
+var editorDistFolder = path.join(distFolder, 'alloy-editor');
+
+var coreSrcFiles = require('../test/core/_src.js');
+var pluginsSrcFiles = require('../test/plugins/_src.js');
+
+gulp.task('copy-files', function() {
+    var files = coreSrcFiles.concat(pluginsSrcFiles);
+
+    return gulp.src(files, {cwd: 'src', base: 'src'})
+        .pipe(gulp.dest(path.join(editorDistFolder, 'test')));
+});
+
+gulp.task('create-output-dir', function(callback) {
+    mkdirp(editorDistFolder, callback);
+});
+
+gulp.task('prepare-files', function(done) {
+    runSequence(
+        'clean-dist', 'create-output-dir', [
+            'copy-ckeditor', 'copy-files'
+        ], done);
+});
+
+gulp.task('test:core', ['prepare-files'], function (done) {
+    karma.start({
+        configFile: path.join(__dirname, '../test/core/karma.js'),
+        singleRun: (argv.debug || argv.d) ? false : true
+    }, done);
+});
+
+gulp.task('test:plugins', ['prepare-files'], function (done) {
+    karma.start({
+        configFile: path.join(__dirname, '../test/plugins/karma.js'),
+        singleRun: (argv.debug || argv.d) ? false : true
+    }, done);
+});

pool/shard005/JavaScript/0032585_test.js

@@ -0,0 +1,210 @@
+var test = require('tape'),
+  point = require('turf-helpers').point,
+  multipoint = require('turf-helpers').multiPoint,
+  linestring = require('turf-helpers').lineString,
+  multilinestring = require('turf-helpers').multiLineString,
+  polygon = require('turf-helpers').polygon,
+  multipolygon = require('turf-helpers').multiPolygon,
+  featurecollection = require('turf-helpers').featureCollection;
+
+var combine = require('./')
+
+test('combine -- points', function(t) {
+  // MultiPoint
+  var pt1 = point([50, 51])
+  var pt2 = point([100, 101])
+
+  var multiPt = combine(featurecollection([pt1, pt2]))
+
+  t.ok(multiPt, 'should combine two Points into a MultiPoint')
+  t.deepEqual(multiPt.features[0].geometry.coordinates, [[50, 51], [100, 101]])
+  t.end();
+});
+
+test('combine -- mixed multipoint & point', function(t) {
+  // MultiPoint
+  var pt1 = point([50, 51])
+  var pt2 = multipoint([[100, 101], [101, 102]])
+
+  var multiPt = combine(featurecollection([pt1, pt2]))
+
+  t.ok(multiPt, 'should combine Points + MultiPoint into a MultiPoint')
+  t.deepEqual(multiPt.features[0].geometry.coordinates, [[50, 51], [100, 101], [101, 102]])
+  t.end();
+});
+
+test('combine -- linestrings', function(t) {
+  // MultiLineString
+  var l1 = linestring([
+    [102.0,
+    -10.0],
+    [130.0,
+    4.0]])
+  var l2 = linestring([
+    [40.0,
+    -20.0],
+    [150.0,
+    18.0]])
+
+  var multiLine = combine(featurecollection([l1, l2]))
+
+  t.ok(multiLine, 'should combine two LineStrings into a MultiLineString')
+  t.equal(multiLine.features[0].geometry.type, 'MultiLineString')
+  t.deepEqual(multiLine.features[0].geometry.coordinates, [[[102, -10], [130, 4]], [[40, -20], [150, 18]]])
+  t.end();
+});
+
+test('combine -- mixed multilinestring & linestring', function(t) {
+  // MultiLineString
+  var l1 = linestring([
+    [102.0, -10.0],
+    [130.0, 4.0]
+  ]);
+  var l2 = multilinestring([
+    [
+      [40.0, -20.0],
+      [150.0, 18.0]
+    ],
+    [
+      [50, -10],
+      [160, 28]
+    ]
+  ]);
+
+  var multiLine = combine(featurecollection([l1, l2]))
+
+  t.ok(multiLine, 'should combine LineString + MultiLineString into a MultiLineString')
+  t.equal(multiLine.features[0].geometry.type, 'MultiLineString')
+  t.deepEqual(multiLine.features[0].geometry.coordinates, [[[102, -10], [130, 4]], [[40, -20], [150, 18]], [[50, -10], [160, 28]]])
+  t.end();
+});
+
+test('combine -- polygons', function(t) {
+  // MultiPolygon
+  var p1 = polygon( [
+      [
+        [20.0,0.0],
+        [101.0,0.0],
+        [101.0,1.0],
+        [100.0,1.0],
+        [100.0,0.0],
+        [20.0,0.0]
+      ]
+    ])
+  var p2 = polygon([
+      [
+        [30.0,0.0],
+        [102.0,0.0],
+        [103.0,1.0],
+        [30.0,0.0]
+      ]
+    ])
+    var multiPoly = combine(featurecollection([p1, p2]))
+
+    t.ok(multiPoly, 'should combine two Polygons into a MultiPolygon')
+    t.equal(multiPoly.features[0].geometry.type, 'MultiPolygon')
+    t.deepEqual(multiPoly.features[0].geometry.coordinates,
+        [[[[20,0],[101.0,0.0],[101.0,1.0],[100.0,1.0],[100.0,0.0],[20,0]]],
+        [[[30.0,0.0],[102.0,0.0],[103.0,1.0],[30.0,0.0]]]])
+
+  t.end()
+});
+
+test('combine -- polygons', function(t) {
+  // MultiPolygon
+  var p1 = polygon( [
+    [
+      [20.0,0.0],
+      [101.0,0.0],
+      [101.0,1.0],
+      [100.0,1.0],
+      [100.0,0.0],
+      [20.0,0.0]
+    ]
+  ]);
+  var p2 = multipolygon([
+    [[
+      [30.0,0.0],
+      [102.0,0.0],
+      [103.0,1.0],
+      [30.0,0.0]
+    ]],
+    [
+      [
+        [20.0,5.0],
+        [92.0,5.0],
+        [93.0,6.0],
+        [20.0,5.0]
+      ],
+      [
+        [25, 5],
+        [30, 5],
+        [30, 5.5],
+        [25, 5]
+      ]
+    ]
+  ]);
+  var multiPoly = combine(featurecollection([p1, p2]))
+
+  t.ok(multiPoly, 'should combine two Polygon + MultiPolygon into a MultiPolygon')
+  t.equal(multiPoly.features[0].geometry.type, 'MultiPolygon')
+  t.deepEqual(multiPoly.features[0].geometry.coordinates,
+      [[[[20,0],[101.0,0.0],[101.0,1.0],[100.0,1.0],[100.0,0.0],[20,0]]],
+      [[[30.0,0.0],[102.0,0.0],[103.0,1.0],[30.0,0.0]]],
+      [[[20.0,5.0],[92.0,5.0],[93.0,6.0],[20.0,5.0]],
+       [[25, 5],[30, 5],[30, 5.5],[25, 5]]]
+  ])
+
+  t.end()
+});
+
+test('combine -- heterogenous', function(t) {
+  // MultiPolygon
+  var p1 = polygon( [
+    [
+      [20.0,0.0],
+      [101.0,0.0],
+      [101.0,1.0],
+      [100.0,1.0],
+      [100.0,0.0],
+      [20.0,0.0]
+    ]
+  ]);
+  var p2 = multipolygon([
+    [[
+      [30.0,0.0],
+      [102.0,0.0],
+      [103.0,1.0],
+      [30.0,0.0]
+    ]],
+    [
+      [
+        [20.0,5.0],
+        [92.0,5.0],
+        [93.0,6.0],
+        [20.0,5.0]
+      ],
+      [
+        [25, 5],
+        [30, 5],
+        [30, 5.5],
+        [25, 5]
+      ]
+    ]
+  ]);
+  var pt1 = point([50, 51])
+  var multiPoly = combine(featurecollection([p1, p2, pt1]))
+
+  t.ok(multiPoly, 'should combine two Polygon + MultiPolygon into a MultiPolygon')
+  t.equal(multiPoly.features[0].geometry.type, 'MultiPoint')
+
+  t.equal(multiPoly.features[1].geometry.type, 'MultiPolygon')
+  t.deepEqual(multiPoly.features[1].geometry.coordinates,
+      [[[[20,0],[101.0,0.0],[101.0,1.0],[100.0,1.0],[100.0,0.0],[20,0]]],
+      [[[30.0,0.0],[102.0,0.0],[103.0,1.0],[30.0,0.0]]],
+      [[[20.0,5.0],[92.0,5.0],[93.0,6.0],[20.0,5.0]],
+       [[25, 5],[30, 5],[30, 5.5],[25, 5]]]
+  ])
+
+  t.end()
+});

pool/shard005/JavaScript/0032587_main.js

@@ -0,0 +1,36 @@
+function fib() {
+	var now = 0;
+	var one = 0;
+	var two = 0;
+	var count = 0;
+	function nacci() {
+		if (count == 0){
+			now = one + two;
+		} else if (count == 1) {
+			one++;
+			now = one + two;
+		} else if (count == 2) {
+			now = one + two;
+			two = now;
+		} else {
+			one = two;
+			two = now;
+			now = one + two;
+		}
+		console.log(now);
+		count++;
+	}
+	return nacci
+}
+var fibCounter = fib();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();
+fibCounter();

pool/shard005/JavaScript/0032589_auth-form-header.js

@@ -0,0 +1,63 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { shallow } from 'enzyme';
+import FormattedHeader from 'calypso/components/formatted-header';
+import { AuthFormHeader } from '../auth-form-header';
+import wooDnaConfig from '../woo-dna-config';
+
+const CLIENT_ID = 98765;
+const SITE_SLUG = 'an.example.site';
+const DEFAULT_PROPS = {
+	authQuery: {
+		authApproved: false,
+		blogname: 'Example Blog',
+		clientId: CLIENT_ID,
+		from: 'banner-44-slide-1-dashboard',
+		homeUrl: `http://${ SITE_SLUG }`,
+		jpVersion: '5.4',
+		nonce: 'fooBarNonce',
+		redirectAfterAuth: `http://${ SITE_SLUG }/wp-admin/admin.php?page=jetpack`,
+		redirectUri: `http://${ SITE_SLUG }/wp-admin/admin.php?page=jetpack&action=authorize&_wpnonce=fooBarNonce&redirect=http%3A%2F%2F${ SITE_SLUG }%2Fwp-admin%2Fadmin.php%3Fpage%3Djetpack`,
+		scope: 'administrator:fooBarBaz',
+		secret: 'fooBarSecret',
+		site: `http://${ SITE_SLUG }`,
+		siteIcon: '',
+		siteUrl: `http://${ SITE_SLUG }`,
+		state: '1',
+		userEmail: `email@${ SITE_SLUG }`,
+	},
+	translate: ( string ) => string,
+};
+
+describe( 'AuthFormHeader', () => {
+	test( 'renders as expected', () => {
+		const wrapper = shallow( <AuthFormHeader { ...DEFAULT_PROPS } /> );
+
+		expect( wrapper ).toMatchSnapshot();
+	} );
+
+	test( 'should render WC Payments specific sub header copy', () => {
+		const authQuery = {
+			...DEFAULT_PROPS.authQuery,
+			from: 'woocommerce-payments',
+			woodna_service_name: 'WooCommerce Payments',
+		};
+		const props = {
+			...DEFAULT_PROPS,
+			authQuery,
+			wooDnaConfig: wooDnaConfig( authQuery ),
+		};
+
+		// Notice we have \xa0. This is needed when we compare translated text.
+		// Please refer to https://stackoverflow.com/questions/54242039/intl-numberformat-space-character-does-not-match
+		const expectedText =
+			'Approve your connection. Your account will enable you to start using the features and benefits offered by WooCommerce\xa0Payments';
+		const wrapper = shallow( <AuthFormHeader { ...props } /> )
+			.find( FormattedHeader )
+			.render();
+
+		expect( wrapper.find( '.formatted-header__subtitle' ).text() ).toEqual( expectedText );
+	} );
+} );

pool/shard005/JavaScript/0032590_notecard.controller.js

@@ -0,0 +1,321 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _btMongodb = require('bt-mongodb');
+
+var _btMongodb2 = _interopRequireDefault(_btMongodb);
+
+var _activity = require('./activity.controller');
+
+var _activity2 = _interopRequireDefault(_activity);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var CONTACT_ADMIN = 'there was an error, please contact an admin';
+var BODY_EMPTY = 'The body was empty';
+var NO_OBJECT_ID = 'There was no id in the request';
+var NOT_EXISTED_BEFORE = 'Couldn\'t match id to an actual object';
+var NOT_OWNER = 'you are not the owner of that object';
+
+/**
+ * @api             {get} notecard GET owned Notecards
+ * @apiName         GetAllNotecards
+ * @apiGroup        notecard
+ * @apiDescription  Collects all the notecards of which the authorizated profile
+ * has access to and returns them in a json response.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Response 200
+ * Content-Type: application/json
+ * [
+ *   {
+ *     "_id": "593eaebcf8ac692c4c13b2c1",
+ *     "title": "Lorem Ipsum",
+ *     "task": "Dolor Sit",
+ *     "answer": "Ahmet",
+ *     "owner": "593eaa0bcf7f5000011c24c4",
+ *     "lastchange": "2017-06-12T15:58:37.406Z",
+ *     "__v": 0
+ *   },...
+ * ]
+ */
+function getAllAction(req, res) {
+  _btMongodb2.default.notecard.findByOwner(req.auth0.id, function (err, map) {
+    if (err) {
+      res.send(CONTACT_ADMIN);
+    } else {
+      res.send(map);
+    }
+  });
+}
+
+/**
+ * @api             {get} notecard/:id GET specific Notecard
+ * @apiName         GetSpecificNotecards
+ * @apiGroup        notecard
+ * @apiDescription  Returns the Notecard with the given id.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiParam        {Number} id id of the notecard
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Response 200
+ * Content-Type: application/json
+ * {
+ *   "_id": "593eaebcf8ac692c4c13b2c1",
+ *   "title": "Lorem Ipsum",
+ *   "task": "Dolor Sit",
+ *   "answer": "Ahmet",
+ *   "owner": "593eaa0bcf7f5000011c24c4",
+ *   "__v": 0
+ * }
+ */
+function getByIdAction(req, res) {
+  if (req.params === null || req.params.id === null) {
+    res.send(NO_OBJECT_ID);
+  } else {
+    _btMongodb2.default.notecard.findById(req.params.id, function (err, card) {
+      if (err) {
+        res.send(CONTACT_ADMIN);
+      } else {
+        res.send(card);
+      }
+    });
+  }
+}
+
+/**
+ * @api             {post} notecard POST Notecard
+ * @apiName         PostNotecard
+ * @apiGroup        notecard
+ * @apiDescription  Creates a Notecard of the given json body.
+ * Owner and the date of creation will be set automatically.
+ * Emits the notecard_new event on the websocket for follower.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiHeader       {String} Content-Type application/json
+ * @apiHeader       {String} Content-Type application/json
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Request
+ * Content-Type: application/json
+ * {
+ *   "title": "Lorem Ipsum",
+ *   "task": "Dolor Sit",
+ *   "answer": "Ahmet"
+ * }
+ *
+ * @apiSuccessExample {json} Response 200
+ * Content-Type: application/json
+ * {
+ *   "__v": 0,
+ *   "title": "Lorem Ipsum",
+ *   "task": "Dolor Sit",
+ *   "answer": "Ahmet",
+ *   "owner": "593eaa0bcf7f5000011c24c4",
+ *   "lastchange": "2017-06-13T17:08:53.703Z",
+ *   "_id": "59401c25b5746212889f54f9"
+ * }
+ */
+function createAction(req, res) {
+  if (req.body === null) {
+    res.send(BODY_EMPTY);
+  } else {
+    req.body.owner = req.auth0.id;
+    req.body.lastchange = new Date();
+    _btMongodb2.default.notecard.createNotecard(req.body, function (err, newCard) {
+      if (err) {
+        res.send(CONTACT_ADMIN);
+      } else {
+        res.send(newCard);
+        _activity2.default.createActivityForFollower(req.auth0, 'notecard_new');
+      }
+    });
+  }
+}
+
+/**
+ * @api             {post} notecard/set/:id POST Notecard and Append to Set
+ * @apiName         PostNotecardAppend
+ * @apiGroup        notecard
+ * @apiDescription  Creates a Notecard of the given json body.
+ * Owner and the date of creation will be set automatically. It will be appended
+ * to the Set of the given id.
+ * Emits the notecard_new event on the websocket for follower.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiHeader       {String} Content-Type application/json
+ * @apiParam        {Number} id id of the Set on which the newly created
+ * Notecard will be appended to.
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Request
+ * Content-Type: application/json
+ * {
+ *   "title": "Lorem Ipsum",
+ *   "task": "Dolor Sit",
+ *   "answer": "Ahmet"
+ * }
+ *
+ * @apiSuccessExample {json} Response 200
+ * Content-Type: application/json
+ * {
+ *   "__v": 0,
+ *   "title": "Lorem Ipsum",
+ *   "task": "Dolor Sit",
+ *   "answer": "Ahmet",
+ *   "owner": "593eaa0bcf7f5000011c24c4",
+ *   "lastchange": "2017-06-13T17:08:53.703Z",
+ *   "_id": "59401c25b5746212889f54f9"
+ * }
+ */
+function createAndAppendAction(req, res) {
+  if (req.params === null || req.params.id === null) {
+    res.send(NO_OBJECT_ID);
+  } else if (req.body === null) {
+    res.send(BODY_EMPTY);
+  } else {
+    _btMongodb2.default.set.findById(req.params.id, function (err, set) {
+      if (err) {
+        res.send(NOT_EXISTED_BEFORE);
+      } else if (set) {
+        req.body.owner = req.auth0.id;
+        req.body.lastchange = new Date();
+        _btMongodb2.default.notecard.createNotecard(req.body, function (err1, newCard) {
+          if (err1) {
+            res.send(CONTACT_ADMIN);
+          } else if (newCard) {
+            _btMongodb2.default.set.addNotecards(req.params.id, [newCard.id], function (err2) {
+              if (err2) {
+                res.send(CONTACT_ADMIN);
+              } else {
+                res.send(newCard);
+                _activity2.default.createActivityForFollower(req.auth0, 'notecard_new');
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+}
+
+/**
+ * @api             {put} notecard/:id PUT Notecard
+ * @apiName         PutNotecard
+ * @apiGroup        notecard
+ * @apiDescription  Updates a Notecard with the given json body.
+ * Owner and the date of lastchange will be set automatically.
+ * Emits the notecard_update event on the websocket for follower.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiHeader       {String} Content-Type application/json
+ * @apiParam        {Number} id id of the Notecard which will be updated
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Request
+ * Content-Type: application/json
+ * {
+ *   "title": "Lorem Ipsum1",
+ *   "task": "Dolor Sit2",
+ *   "answer": "Ahmet3",
+ *   "owner": "593eaa0bcf7f5000011c24c4"
+ * }
+ *
+ * @apiSuccessExample {json} Response 200
+ * Content-Type: application/json
+ * {
+ *   "_id": "59401de1b5746212889f54fa",
+ *   "title": "Lorem Ipsum1",
+ *   "task": "Dolor Sit2",
+ *   "answer": "Ahmet3",
+ *   "owner": "593eaa0bcf7f5000011c24c4",
+ *   "lastchange": "2017-06-13T17:47:22.826Z",
+ *   __v": 0
+ * }
+ */
+function updateAction(req, res) {
+  if (req.body === null) {
+    res.send(BODY_EMPTY);
+  } else if (req.params === null || req.params.id === null) {
+    res.send(NO_OBJECT_ID);
+  } else {
+    _btMongodb2.default.notecard.findById(req.params.id, function (err, card) {
+      if (err) {
+        res.send(NOT_EXISTED_BEFORE);
+      } else if (card.owner.toString() === req.auth0.id) {
+        req.body.lastchange = new Date();
+        _btMongodb2.default.notecard.updateNotecard(req.params.id, req.body, function (err1, changedCard) {
+          if (err1) {
+            res.send(CONTACT_ADMIN);
+          } else {
+            res.send(changedCard);
+            _activity2.default.createActivityForFollower(req.auth0, 'notecard_update');
+          }
+        });
+      } else {
+        res.send(NOT_OWNER);
+      }
+    });
+  }
+}
+
+/**
+ * @api             {delete} notecard/:id DELETE Notecard
+ * @apiName         DeleteNotecard
+ * @apiGroup        notecard
+ * @apiDescription  Deletes a Notecard.
+ * Emits the notecard_delete event on the websocket for follower.
+ *
+ * @apiHeader       {String} Authorization Bearer JWT Token
+ * @apiParam        {Number} id id of the Notecard which will be deleted
+ * @apiPermission   AuthToken
+ *
+ * @apiSuccessExample {json} Response 200
+ * {
+ *   "_id": "59401de1b5746212889f54fa",
+ *   "title": "Lorem Ipsum1",
+ *   "task": "Dolor Sit2",
+ *   "answer": "Ahmet3",
+ *   "owner": "593eaa0bcf7f5000011c24c4",
+ *   "lastchange": "2017-06-13T17:47:22.826Z",
+ *   "__v": 0
+ * }
+ */
+function deleteAction(req, res) {
+  // TODO alle Referenzen entfernen
+  if (req.params === null || req.params.id === null) {
+    res.send(NO_OBJECT_ID);
+  } else {
+    _btMongodb2.default.notecard.findById(req.params.id, function (err, card) {
+      if (err) {
+        res.send(CONTACT_ADMIN);
+      } else if (card && card.owner.toString() === req.auth0.id) {
+        _btMongodb2.default.notecard.deleteNotecard(req.params.id, function (err1, result) {
+          if (err1) {
+            res.send(CONTACT_ADMIN);
+          } else {
+            res.send(result);
+            _activity2.default.createActivityForFollower(req.auth0, 'notecard_delete');
+          }
+        });
+      } else {
+        res.send(NOT_OWNER);
+      }
+    });
+  }
+}
+
+exports.default = {
+  getAllAction: getAllAction,
+  getByIdAction: getByIdAction,
+  createAction: createAction,
+  updateAction: updateAction,
+  deleteAction: deleteAction,
+  createAndAppendAction: createAndAppendAction
+};

pool/shard005/JavaScript/0032596_counter.js

@@ -0,0 +1,36 @@
+var express = require('express');
+var router = express.Router();
+
+var Counter = require('../services/counter.service.js');
+var CounterService = new Counter();
+
+/* Post Counter Add Hit. */
+router.get('/add/:content_id/:channel_id', function(request, response, next) {
+    var content_id =  request.params.content_id;
+    var channel_id =  request.params.channel_id;
+
+    CounterService.addHit(content_id, channel_id, function(result){
+        response.status(result.statusCode);
+        response.setHeader("Content-Type", "application/json");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("X-Powered-By", "Okezone.com v1.0" );
+        response.write(JSON.stringify(result), null);
+        response.end();
+    });
+});
+
+router.get('/get/:content_id', function(request, response, next) {
+    var content_id =  request.params.content_id;
+
+    CounterService.getHit(content_id, function(result){
+        response.status(result.statusCode);
+        response.setHeader("Content-Type", "application/json");
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("X-Powered-By", "Okezone.com v1.0" );
+        response.write(JSON.stringify(result), null);
+        response.end();
+    });
+});
+
+
+module.exports = router;

pool/shard005/JavaScript/0032600_usuarios.js

@@ -0,0 +1,83 @@
+var app = angular.module('app');
+
+app.controller('UsuariosController',function($scope,$location,$rootScope,$timeout,userFactory){
+
+  $scope.usuarios = [];
+  $scope.newUsuario = {};
+  $scope.search_field_txt = 'Nombre:';
+  $scope.search_field = 'nombre';
+  $scope.search_data = '';
+  $scope.es_admin = false;
+  $scope.editMode = false;
+
+
+
+  if ($location.path()=='/usuarios/editar'){
+    $scope.editMode = true;
+    if ($rootScope.editUsuario!==undefined){
+      $scope.newUsuario=$rootScope.editUsuario;
+      $scope.blank_password=$scope.newUsuario.password;
+      $scope.check_password=$scope.newUsuario.password;
+    } else {
+      $location.path('/');
+    }
+  }
+
+  $scope.getAllUsuarios = function(){
+    userFactory.getAllUsuarios(function(data){
+      $scope.usuarios=data;
+    });
+  };
+
+
+  $scope.addUsuario = function(){
+    if ($scope.es_admin){
+      $scope.newUsuario.rol=0;
+    } else {
+      $scope.newUsuario.rol=1;
+    }
+    $scope.newUsuario.password = $scope.blank_password;
+    userFactory.addUsuario($scope.newUsuario,function(data){
+      $scope.newUsuario = {};
+      $location.path('/usuarios/listar');
+      $rootScope.addNotification($rootScope.notifications.SUCCESS,"Usuario agregado con exito.",5000);
+    },function(data){
+      $rootScope.addNotification($rootScope.notifications.ERROR,data.error.message,5000);
+    });
+  };
+
+  $scope.saveUsuario = function(){
+    if ($scope.es_admin){
+      $scope.newUsuario.rol=0;
+    } else {
+      $scope.newUsuario.rol=1;
+    }
+    if ($scope.blank_password!=$scope.newUsuario.password){
+      $scope.newUsuario.password = $scope.blank_password;
+    } else {
+      $scope.newUsuario.password = null;
+    }
+    userFactory.saveUsuario($scope.newUsuario,function(data){
+      $rootScope.addNotification($rootScope.notifications.SUCCESS,"Usuario guardado con exito.",5000);
+      $scope.newUsuario = {};
+    },function(data){
+      $rootScope.addNotification($rootScope.notifications.ERROR,data.error.message,5000);
+    });
+  };
+
+  $scope.deleteUsuario = function(indice){
+    userFactory.deleteUsuario($scope.usuarios[indice],function(data){
+      $scope.usuarios.splice(indice,1);
+      $rootScope.addNotification($rootScope.notifications.SUCCESS,"Usuario eliminado con exito.",5000);
+      $scope.newUsuario = {};
+    },function(data){
+      $rootScope.addNotification($rootScope.notifications.ERROR,data.error.message,5000);
+    });
+  };
+
+  $scope.editarUsuario = function(user){
+    $rootScope.editUsuario = user;
+    $location.path('/usuarios/editar');
+  };
+
+});

pool/shard005/JavaScript/0032601_prototype.js

@@ -0,0 +1,78 @@
+(function( $ ) {
+	"use strict";
+
+	$(function() {
+
+		var months = new Array('jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec');
+
+		$('#clockface div').click(function (e) {
+
+			//console.log( e.target );
+
+			var $slot = $(e.target);
+			var classes = $slot.attr('class').split(' ');
+
+			var $slot1_top = $('.' + classes[2] + '.top-slot');
+			var $slot1_bottom = $('.' + classes[2] + '.bottom-slot');
+
+			var $new_top = $('<div />');
+			for (var i = 0; i < classes.length; i++) {
+				$new_top.addClass(classes[i]);
+			}
+			$new_top.removeClass('bottom-slot');
+			$new_top.addClass('top-slot');
+
+			var $new_bottom = $('<div />');
+			for (var i = 0; i < classes.length; i++) {
+				$new_bottom.addClass(classes[i]);
+			}
+			$new_bottom.removeClass('top-slot');
+			$new_bottom.addClass('bottom-slot');
+
+			//console.log( $new_top );
+			//console.log( $new_bottom );
+
+			var $current_number = $slot.css('background-image');
+			$current_number = $current_number.split('/');
+			$current_number = $current_number[$current_number.length - 1];
+			$current_number = $current_number.replace(/\..*/, '');
+			$current_number = $current_number.split('_');
+			//console.log( $current_number );
+
+			if ( $current_number[0] === 'num' ) {
+				$current_number[1]++;
+			}
+			else if ( $current_number[0] === 'month' ) {
+				$current_number[1] = months[months.indexOf($current_number[1]) + 1];
+			}
+
+			//console.log( $current_number );
+
+			var new_image_url = '../resources/src/images/' + $current_number.join('_') + '.png';
+			//console.log( new_image_url );
+			$new_top.css('background-image', 'url('+new_image_url+')');
+			$new_bottom.css('background-image', 'url('+new_image_url+')');
+
+			$new_top.css('z-index', 0);
+			$new_bottom.css('z-index', 999);
+			$new_bottom.css('backgroundPositionY', "-84px");
+
+			$('#clockface').append( $new_top );
+			$('#clockface').append( $new_bottom );
+
+			$slot1_top.animate({
+				backgroundPositionY: "42px"
+			}, 75, 'linear', function() {
+				$new_bottom.animate({
+					backgroundPositionY: "-42px"
+				}, 75, 'linear', function() {
+					$slot1_top.remove();
+					$slot1_bottom.remove();
+				});
+			});
+
+		});
+
+	});
+
+}(jQuery));

pool/shard005/JavaScript/0032602_utils.js

@@ -0,0 +1,156 @@
+
+module.exports = {
+  getDelimiter: getDelimiter, // Handle auto delimiter: return explicitely specified delimiter or try auto detect
+  rowSplit: rowSplit, //Split a csv row to an array based on delimiter and quote
+  isToogleQuote: isToogleQuote //returns if a segmenthas even number of quotes
+}
+
+var defaulDelimiters=[",","|","\t",";",":"];
+function getDelimiter(rowStr,param) {
+  var checker;
+  if (param.delimiter==="auto"){
+    checker=defaulDelimiters;
+  }else if (param.delimiter instanceof Array){
+    checker=param.delimiter;
+  }else{
+    return param.delimiter;
+  }
+  var count=0;
+  var rtn=",";
+  checker.forEach(function(delim){
+    var delimCount=rowStr.split(delim).length;
+    if (delimCount>count){
+      rtn=delim;
+      count=delimCount;
+    }
+  });
+  return rtn;
+}
+function isQuoteOpen(str,param){
+  var quote=param.quote;
+  var escape=param.escape;
+  return str[0] === quote && (
+    str[1]!==quote || 
+    str[1]===escape && (str[2] === quote || str.length ===2));
+}
+function isQuoteClose(str,param){
+  var quote=param.quote;
+  var count=0;
+  var idx=str.length-1;
+  var escape=param.escape;
+  while (str[idx] === quote || str[idx]===escape){
+    idx--;
+    count++;
+  }
+  return count%2!==0;
+}
+function rowSplit(rowStr, param) {
+  if (rowStr ===""){
+    return [];
+  }
+  var quote=param.quote;
+  var trim=param.trim;
+  var escape=param.escape;
+  if (param.needCheckDelimiter===true){
+      param.delimiter=getDelimiter(rowStr,param);
+      param.needCheckDelimiter=false;
+  }
+  var delimiter=param.delimiter;
+  var rowArr = rowStr.split(delimiter);
+  if (quote ==="off"){
+    return rowArr;
+  }
+  var row = [];
+  var inquote = false;
+  var quoteBuff = '';
+  for (var i=0;i<rowArr.length;i++){
+    var e=rowArr[i];
+    if (!inquote && trim){
+      e=e.trim();
+    }
+    var len=e.length;
+    if (!inquote){
+      if (isQuoteOpen(e,param)){ //quote open
+          e=e.substr(1);
+          if (isQuoteClose(e,param)){ //quote close
+              e=e.substring(0,e.length-1);
+              e=_escapeQuote(e,quote,escape);
+              row.push(e);
+              continue;
+          }else{
+            inquote=true;
+            quoteBuff+=e;
+            continue;
+          }
+      }else{
+        row.push(e);
+        continue;
+      }
+    }else{ //previous quote not closed
+      if (isQuoteClose(e,param)){ //close double quote
+        inquote=false;
+        e=e.substr(0,len-1);
+        quoteBuff+=delimiter+e;
+        quoteBuff=_escapeQuote(quoteBuff,quote,escape);
+        if (trim){
+          quoteBuff=quoteBuff.trimRight();
+        }
+        row.push(quoteBuff);
+        quoteBuff="";
+      }else{
+        quoteBuff+=delimiter+e;
+      }
+    }
+
+
+    // if (isToogleQuote(e, quote)) { //if current col has odd quotes, switch quote status
+    //   if (inquote) { //if currently in open quote status, close it and output data
+    //     quoteBuff += delimiter;
+    //     quoteBuff += twoDoubleQuote(e.substr(0, e.length - 1), quote);
+    //     row.push(trim ? quoteBuff.trim() : quoteBuff);
+    //     quoteBuff = '';
+    //   } else { // currently not in open quote status, open it
+    //     quoteBuff += twoDoubleQuote(e.substring(1), quote);
+    //   }
+    //   inquote = !inquote;
+    // } else if (inquote) { // if current col has even quotes, do not switch quote status
+    //   //if current status is in quote, add to buffer wait to close
+    //   quoteBuff += delimiter + twoDoubleQuote(e, quote);
+    // } else { // if current status is not in quote, out put data
+    //   if (trim) {
+    //     e = e.trim();
+    //   }
+    //   if (e.indexOf(quote) === 0 && e[e.length - 1] === quote) { //if current col contain full quote segment,remove quote first
+    //     e = e.substring(1, e.length - 1);
+    //   }
+    //   row.push(twoDoubleQuote(e, quote));
+    // }
+  }
+  return row;
+}
+
+
+var cachedRegExp = {};
+
+function isToogleQuote(segment, quote) {
+  var key="s|"+quote;
+  if ( cachedRegExp[key]=== undefined){
+    cachedRegExp[key]=new RegExp(quote, 'g');
+  }
+  var reg =  cachedRegExp[key];
+  var match = segment.match(reg);
+  return match && match.length % 2 !== 0;
+}
+
+function _escapeQuote(segment, quote,escape) {
+  
+  var key="es|"+quote+"|"+escape;
+  if (cachedRegExp[key] === undefined){
+    if (escape ==="\\"){
+      escape="\\\\";
+    }
+    cachedRegExp[key]=new RegExp(escape+quote,'g');
+  }
+  var regExp = cachedRegExp[key];
+  return segment.replace(regExp, quote);
+}

pool/shard005/JavaScript/0032603_ipvFuture.js

@@ -0,0 +1,25 @@
+var Benchmark = require('benchmark'),
+    benchmarks = require('beautify-benchmark'),
+    isIP = require('..'),
+    suite = new Benchmark.Suite,
+    testIp = 'v1.09azAZ-._~!$&\'()*+,;=:';
+
+suite.add({
+    name: 'isIP#test(ipvFuture)',
+    minSamples: 100,
+    fn: function () {
+        isIP.test(testIp);
+    }
+}).add({
+    name: 'isIP#future(ipvFuture)',
+    minSamples: 100,
+    fn: function () {
+        isIP.future(testIp);
+    }
+}).on('start', function onCycle() {
+    process.stdout.write('  Testing IP "' + testIp + '"\n\n')
+}).on('cycle', function onCycle(event) {
+    benchmarks.add(event.target);
+}).on('complete', function onComplete() {
+    benchmarks.log();
+}).run();

pool/shard005/JavaScript/0032604_assignments.controller.js

@@ -0,0 +1,25 @@
+'use strict';
+
+angular.module('proj2App')
+    .controller('AssignmentsController', function ($scope, $state, Assignments) {
+        $scope.assignmentss = [];
+        $scope.loadAll = function() {
+            Assignments.query(function(result) {
+               $scope.assignmentss = result;
+            });
+        };
+        $scope.loadAll();
+        $scope.refresh = function () {
+            $scope.loadAll();
+            $scope.clear();
+        };
+
+        $scope.clear = function () {
+            $scope.assignments = {
+                cost: null,
+                startDate: null,
+                endDate: null,
+                id: null
+            };
+        };
+    });

pool/shard005/JavaScript/0032606_RendererOptions.js

@@ -0,0 +1,16 @@
+define(["require", "exports"], function (require, exports) {
+    var RendererOptions = (function () {
+        function RendererOptions(options) {
+            this.view = options.view || document.createElement('canvas');
+            this.transparent = options.transparent || false;
+            this.autoResize = options.autoResize || false;
+            this.antialias = options.antialias || false;
+            this.resolution = options.resolution || 1;
+            this.clearBeforeRender = options.clearBeforeRender || true;
+            this.roundPixels = options.roundPixels || false;
+        }
+        return RendererOptions;
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default = RendererOptions;
+});

pool/shard005/JavaScript/0032609_sidenav.js

@@ -0,0 +1,424 @@
+/*!
+ * Angular Material Design
+ * https://github.com/angular/material
+ * @license MIT
+ * v0.10.0-rc1-master-8285e2d
+ */
+(function( window, angular, undefined ){
+"use strict";
+
+/**
+ * @ngdoc module
+ * @name material.components.sidenav
+ *
+ * @description
+ * A Sidenav QP component.
+ */
+angular.module('material.components.sidenav', [
+    'material.core',
+    'material.components.backdrop'
+  ])
+  .factory('$mdSidenav', SidenavService )
+  .directive('mdSidenav', SidenavDirective)
+  .directive('mdSidenavFocus', SidenavFocusDirective)
+  .controller('$mdSidenavController', SidenavController);
+
+
+/**
+ * @private
+ * @ngdoc service
+ * @name $mdSidenav
+ * @module material.components.sidenav
+ *
+ * @description
+ * `$mdSidenav` makes it easy to interact with multiple sidenavs
+ * in an app.
+ *
+ * @usage
+ * <hljs lang="js">
+ * // Async lookup for sidenav instance; will resolve when the instance is available
+ * $mdSidenav(componentId).then(function(instance) {
+ *   $log.debug( componentId + "is now ready" );
+ * });
+ * // Async toggle the given sidenav;
+ * // when instance is known ready and lazy lookup is not needed.
+ * $mdSidenav(componentId)
+ *    .toggle()
+ *    .then(function(){
+ *      $log.debug('toggled');
+ *    });
+ * // Async open the given sidenav
+ * $mdSidenav(componentId)
+ *    .open()
+ *    .then(function(){
+ *      $log.debug('opened');
+ *    });
+ * // Async close the given sidenav
+ * $mdSidenav(componentId)
+ *    .close()
+ *    .then(function(){
+ *      $log.debug('closed');
+ *    });
+ * // Sync check to see if the specified sidenav is set to be open
+ * $mdSidenav(componentId).isOpen();
+ * // Sync check to whether given sidenav is locked open
+ * // If this is true, the sidenav will be open regardless of close()
+ * $mdSidenav(componentId).isLockedOpen();
+ * </hljs>
+ */
+function SidenavService($mdComponentRegistry, $q) {
+  return function(handle) {
+
+    // Lookup the controller instance for the specified sidNav instance
+    var self;
+    var errorMsg = "SideNav '" + handle + "' is not available!";
+    var instance = $mdComponentRegistry.get(handle);
+
+    if(!instance) {
+      $mdComponentRegistry.notFoundError(handle);
+    }
+
+    return self = {
+      // -----------------
+      // Sync methods
+      // -----------------
+      isOpen: function() {
+        return instance && instance.isOpen();
+      },
+      isLockedOpen: function() {
+        return instance && instance.isLockedOpen();
+      },
+      // -----------------
+      // Async methods
+      // -----------------
+      toggle: function() {
+        return instance ? instance.toggle() : $q.reject(errorMsg);
+      },
+      open: function() {
+        return instance ? instance.open() : $q.reject(errorMsg);
+      },
+      close: function() {
+        return instance ? instance.close() : $q.reject(errorMsg);
+      },
+      then : function( callbackFn ) {
+        var promise = instance ? $q.when(instance) : waitForInstance();
+        return promise.then( callbackFn || angular.noop );
+      }
+    };
+
+    /**
+     * Deferred lookup of component instance using $component registry
+     */
+    function waitForInstance() {
+      return $mdComponentRegistry
+                .when(handle)
+                .then(function( it ){
+                  instance = it;
+                  return it;
+                });
+    }
+  };
+}
+SidenavService.$inject = ["$mdComponentRegistry", "$q"];
+/**
+ * @ngdoc directive
+ * @name mdSidenavFocus
+ * @module material.components.sidenav
+ *
+ * @restrict A
+ *
+ * @description
+ * `$mdSidenavFocus` provides a way to specify the focused element when a sidenav opens.
+ * This is completely optional, as the sidenav itself is focused by default.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <md-sidenav>
+ *   <form>
+ *     <md-input-container>
+ *       <label for="testInput">Label</label>
+ *       <input id="testInput" type="text" md-sidenav-focus>
+ *     </md-input-container>
+ *   </form>
+ * </md-sidenav>
+ * </hljs>
+ **/
+function SidenavFocusDirective() {
+  return {
+    restrict: 'A',
+    require: '^mdSidenav',
+    link: function(scope, element, attr, sidenavCtrl) {
+      sidenavCtrl.focusElement(element);
+    }
+  };
+}
+/**
+ * @ngdoc directive
+ * @name mdSidenav
+ * @module material.components.sidenav
+ * @restrict E
+ *
+ * @description
+ *
+ * A Sidenav component that can be opened and closed programatically.
+ *
+ * By default, upon opening it will slide out on top of the main content area.
+ *
+ * For keyboard and screen reader accessibility, focus is sent to the sidenav wrapper by default.
+ * It can be overridden with the `md-sidenav-focus` directive on the child element you want focused.
+ *
+ * @usage
+ * <hljs lang="html">
+ * <div layout="row" ng-controller="MyController">
+ *   <md-sidenav md-component-id="left" class="md-sidenav-left">
+ *     Left Nav!
+ *   </md-sidenav>
+ *
+ *   <md-content>
+ *     Center Content
+ *     <md-button ng-click="openLeftMenu()">
+ *       Open Left Menu
+ *     </md-button>
+ *   </md-content>
+ *
+ *   <md-sidenav md-component-id="right"
+ *     md-is-locked-open="$mdMedia('min-width: 333px')"
+ *     class="md-sidenav-right">
+ *     <form>
+ *       <md-input-container>
+ *         <label for="testInput">Test input</label>
+ *         <input id="testInput" type="text"
+ *                ng-model="data" md-sidenav-focus>
+ *       </md-input-container>
+ *     </form>
+ *   </md-sidenav>
+ * </div>
+ * </hljs>
+ *
+ * <hljs lang="js">
+ * var app = angular.module('myApp', ['ngMaterial']);
+ * app.controller('MyController', function($scope, $mdSidenav) {
+ *   $scope.openLeftMenu = function() {
+ *     $mdSidenav('left').toggle();
+ *   };
+ * });
+ * </hljs>
+ *
+ * @param {expression=} md-is-open A model bound to whether the sidenav is opened.
+ * @param {string=} md-component-id componentId to use with $mdSidenav service.
+ * @param {expression=} md-is-locked-open When this expression evalutes to true,
+ * the sidenav 'locks open': it falls into the content's flow instead
+ * of appearing over it. This overrides the `is-open` attribute.
+ *
+ * The $mdMedia() service is exposed to the is-locked-open attribute, which
+ * can be given a media query or one of the `sm`, `gt-sm`, `md`, `gt-md`, `lg` or `gt-lg` presets.
+ * Examples:
+ *
+ *   - `<md-sidenav md-is-locked-open="shouldLockOpen"></md-sidenav>`
+ *   - `<md-sidenav md-is-locked-open="$mdMedia('min-width: 1000px')"></md-sidenav>`
+ *   - `<md-sidenav md-is-locked-open="$mdMedia('sm')"></md-sidenav>` (locks open on small screens)
+ */
+function SidenavDirective($timeout, $animate, $parse, $log, $mdMedia, $mdConstant, $compile, $mdTheming, $q, $document) {
+  return {
+    restrict: 'E',
+    scope: {
+      isOpen: '=?mdIsOpen'
+    },
+    controller: '$mdSidenavController',
+    compile: function(element) {
+      element.addClass('md-closed');
+      element.attr('tabIndex', '-1');
+      return postLink;
+    }
+  };
+
+  /**
+   * Directive Post Link function...
+   */
+  function postLink(scope, element, attr, sidenavCtrl) {
+    var lastParentOverFlow;
+    var triggeringElement = null;
+    var promise = $q.when(true);
+
+    var isLockedOpenParsed = $parse(attr.mdIsLockedOpen);
+    var isLocked = function() {
+      return isLockedOpenParsed(scope.$parent, {
+        $media: function(arg) {
+          $log.warn("$media is deprecated for is-locked-open. Use $mdMedia instead.");
+          return $mdMedia(arg);
+        },
+        $mdMedia: $mdMedia
+      });
+    };
+    var backdrop = $compile(
+      '<md-backdrop class="md-sidenav-backdrop md-opaque ng-enter">'
+    )(scope);
+
+    element.on('$destroy', sidenavCtrl.destroy);
+    $mdTheming.inherit(backdrop, element);
+
+    scope.$watch(isLocked, updateIsLocked);
+    scope.$watch('isOpen', updateIsOpen);
+
+
+    // Publish special accessor for the Controller instance
+    sidenavCtrl.$toggleOpen = toggleOpen;
+    sidenavCtrl.focusElement( sidenavCtrl.focusElement() || element );
+
+    /**
+     * Toggle the DOM classes to indicate `locked`
+     * @param isLocked
+     */
+    function updateIsLocked(isLocked, oldValue) {
+      scope.isLockedOpen = isLocked;
+      if (isLocked === oldValue) {
+        element.toggleClass('md-locked-open', !!isLocked);
+      } else {
+        $animate[isLocked ? 'addClass' : 'removeClass'](element, 'md-locked-open');
+      }
+      backdrop.toggleClass('md-locked-open', !!isLocked);
+    }
+
+    /**
+     * Toggle the SideNav view and attach/detach listeners
+     * @param isOpen
+     */
+    function updateIsOpen(isOpen) {
+      var parent = element.parent();
+
+      parent[isOpen ? 'on' : 'off']('keydown', onKeyDown);
+      backdrop[isOpen ? 'on' : 'off']('click', close);
+
+      if ( isOpen ) {
+        // Capture upon opening..
+        triggeringElement = $document[0].activeElement;
+      }
+      var focusEl = sidenavCtrl.focusElement();
+
+      disableParentScroll(isOpen);
+
+      return promise = $q.all([
+                isOpen ? $animate.enter(backdrop, parent) : $animate.leave(backdrop),
+                $animate[isOpen ? 'removeClass' : 'addClass'](element, 'md-closed')
+              ])
+              .then(function() {
+                // Perform focus when animations are ALL done...
+                if (scope.isOpen) {
+                  focusEl && focusEl.focus();
+                }
+              });
+    }
+
+    /**
+     * Prevent parent scrolling (when the SideNav is open)
+     */
+    function disableParentScroll(disabled) {
+      var parent = element.parent();
+      if ( disabled ) {
+        lastParentOverFlow = parent.css('overflow');
+        parent.css('overflow', 'hidden');
+      } else if (angular.isDefined(lastParentOverFlow)) {
+        parent.css('overflow', lastParentOverFlow);
+        lastParentOverFlow = undefined;
+      }
+    }
+
+    /**
+     * Toggle the sideNav view and publish a promise to be resolved when
+     * the view animation finishes.
+     *
+     * @param isOpen
+     * @returns {*}
+     */
+    function toggleOpen( isOpen ) {
+      if (scope.isOpen == isOpen ) {
+
+        return $q.when(true);
+
+      } else {
+        var deferred = $q.defer();
+
+        // Toggle value to force an async `updateIsOpen()` to run
+        scope.isOpen = isOpen;
+
+        $timeout(function() {
+
+          // When the current `updateIsOpen()` animation finishes
+          promise.then(function(result) {
+
+            if ( !scope.isOpen ) {
+              // reset focus to originating element (if available) upon close
+              triggeringElement && triggeringElement.focus();
+              triggeringElement = null;
+            }
+
+            deferred.resolve(result);
+          });
+
+        },0,false);
+
+        return deferred.promise;
+      }
+    }
+
+    /**
+     * Auto-close sideNav when the `escape` key is pressed.
+     * @param evt
+     */
+    function onKeyDown(ev) {
+      var isEscape = (ev.keyCode === $mdConstant.KEY_CODE.ESCAPE);
+      return isEscape ? close(ev) : $q.when(true);
+    }
+
+    /**
+     * With backdrop `clicks` or `escape` key-press, immediately
+     * apply the CSS close transition... Then notify the controller
+     * to close() and perform its own actions.
+     */
+    function close(ev) {
+      ev.preventDefault();
+      ev.stopPropagation();
+
+      return sidenavCtrl.close();
+    }
+
+  }
+}
+SidenavDirective.$inject = ["$timeout", "$animate", "$parse", "$log", "$mdMedia", "$mdConstant", "$compile", "$mdTheming", "$q", "$document"];
+
+/*
+ * @private
+ * @ngdoc controller
+ * @name SidenavController
+ * @module material.components.sidenav
+ *
+ */
+function SidenavController($scope, $element, $attrs, $mdComponentRegistry, $q) {
+
+  var self = this,
+      focusElement;
+
+  // Use Default internal method until overridden by directive postLink
+
+  // Synchronous getters
+  self.isOpen = function() { return !!$scope.isOpen; };
+  self.isLockedOpen = function() { return !!$scope.isLockedOpen; };
+
+  // Async actions
+  self.open   = function() { return self.$toggleOpen( true );  };
+  self.close  = function() { return self.$toggleOpen( false ); };
+  self.toggle = function() { return self.$toggleOpen( !$scope.isOpen );  };
+  self.focusElement = function(el) {
+    if ( angular.isDefined(el) ) {
+      focusElement = el;
+    }
+    return focusElement;
+  };
+
+  self.$toggleOpen = function() { return $q.when($scope.isOpen); };
+
+  self.destroy = $mdComponentRegistry.register(self, $attrs.mdComponentId);
+}
+SidenavController.$inject = ["$scope", "$element", "$attrs", "$mdComponentRegistry", "$q"];
+
+})(window, window.angular);

pool/shard005/JavaScript/0032610_plotter.js

@@ -0,0 +1,74 @@
+
+jQuery(document).ready(function($) {
+	var metrics = $.parseJSON($('.storage.storage-profile').html());
+	var ticks = [];
+	var series = [];
+	var values = [];
+	var legendItemHeight = 18;
+	for (var filename in metrics) {
+		series.push({
+			label: filename,
+			neighborThreshold: 0
+		});
+		var dataset = [];
+		for (var metricName in metrics[filename]) {
+			var value = metrics[filename][metricName];
+			if (-1 == ticks.indexOf(metricName)) {
+				ticks.push(metricName);
+			};
+			maxHeight = Math.max(maxHeight, value);
+			dataset.push([metricName, value]);
+		};
+		values.push(dataset);
+	};
+	var barMargin = 0;
+	var barWidth = Math.round((800 / ticks.length) / series.length);
+	var maxHeight =+ (300 + (series.length * legendItemHeight));
+	var scale = ticks.length * values.length;
+	var plotter = $('.graph').jqplot('graph', values, {
+		width: ((barWidth + (barMargin * 2)) * scale) + 35,
+		height: maxHeight,
+		seriesColors: ['#002b36', '#586e75', '#839496', '#b58900', '#cb4b16', '#dc322f', '#d33682', '#6c71c4', '#268bd2', '#2aa198', '#859900', '#073642', '#657b83', '#93a1a1'],
+		seriesDefaults:{
+			renderer: $.jqplot.BarRenderer,
+			rendererOptions: {
+				//barDirection: 'horizontal',
+				shadow: false,
+				barWidth: barWidth,
+				barMargin: barMargin,
+				barPadding: 0
+			},
+			trendline: {
+				show: true
+			}
+		},
+		legend: {
+			show: true,
+			placement: 'insideGrid',
+			location: 'ne'
+		},
+		series: series,
+		grid: {
+			background: '#FAFAFA'
+		},
+		cursor:{
+			show: true,
+			zoom: true,
+			showTooltip: false,
+			followMouse: true
+		},
+		axes: {
+			yaxis: {
+				padMin: 0
+			},
+			xaxis: {
+				renderer: $.jqplot.CategoryAxisRenderer,
+				tickRenderer: $.jqplot.CanvasAxisTickRenderer ,
+				tickOptions: {
+					angle: -90,
+					fontSize: '12pt'
+				}
+			}
+		}
+	});
+});

pool/shard005/JavaScript/0032611_slushfile.js

@@ -0,0 +1,115 @@
+var gulp = require('gulp'),
+    conflict = require('gulp-conflict'),
+    install = require('gulp-install'),
+    rename = require('gulp-rename'),
+    template = require('gulp-template'),
+    spawn = require('child_process').spawn,
+    inquirer = require('inquirer'),
+    path = require('path'),
+    _ = require('underscore.string'),
+    sfSetup = require('sf-placeholder'),
+    data = require('gulp-data'),
+    files = [],
+    mPageName = '';
+
+    var jsForceConfig;
+    try{ jsForceConfig = require( path.resolve(process.cwd(), 'jsforce.config.js'))}catch(e){}
+
+    console.log(path.resolve(process.cwd(), 'jsforce.config.js'));
+    console.log(typeof jsForceConfig);
+
+gulp.task('default', function (done) {
+    inquirer.prompt([
+        {type: 'input', name: 'name', message: 'What would you like to name your project or VisualForce page?', default: 'base'},
+        {type: 'confirm', name: 'salesforce', message: 'Is this a Salesforce project?'},
+        /*{ when: function (response) {
+             return response.salesforce;
+            },
+            type: 'input',
+            name: 'pageName',
+            message: 'Enter your VF page and resource name:(Must match project name for auto-upload)?',
+            default: 'mainPage'
+        },*/
+        { when: function (response) {
+             return response.salesforce && typeof jsForceConfig === 'undefined';
+            },
+            type: 'input',
+            name: 'username',
+            message: 'Enter your Salesforce username.'
+        },
+        { when: function (response) {
+             return response.salesforce && typeof jsForceConfig === 'undefined';
+            },
+            type: 'input',
+            name: 'password',
+            message: 'Enter your Salesforce password.'
+        },
+        { when: function (response) {
+             return response.salesforce && typeof jsForceConfig === 'undefined';
+            },
+            type: 'input',
+            name: 'token',
+            message: 'Enter your Salesforce token.'
+        }
+    ],
+    function (answers) {
+
+        
+
+        /*// set the page name to none if it is a non salesforce project
+        if(typeof answers.pageName === 'undefined' && mPageName === '' ){
+
+            answers.pageName = 'none';
+        }
+
+        mPageName = answers.pageName;*/
+
+        // build project directory
+        answers.slug = _.slugify(answers.name);
+        answers.camel = _.camelize(answers.slug);
+        path.resolve(process.cwd(), answers.slug);
+        files.push(__dirname + '/templates/');
+        files.push(__dirname + '/templates/webpack.config.js');
+        files.push(__dirname + '/templates/webpack.salesforce.js');
+        files.push(__dirname + '/templates/webpack.salesforce.deploy.js');
+        files.push(__dirname + '/templates/package.json');
+        files.push(__dirname + '/templates/karma.conf.js');
+        files.push(__dirname + '/templates/app/index.html');
+        files.push(__dirname + '/templates/app/index.js');
+        files.push(__dirname + '/templates/app/states/main/*');
+        files.push(__dirname + '/templates/app/components/form/*');
+        files.push(__dirname + '/templates/app/components/navBar/*');
+        files.push(__dirname + '/templates/app/components/simpleTest/*');
+
+        answers.pageName = answers.name;
+
+        // create visualforce page and placeholder
+        if(answers.salesforce !== false){
+            console.log(answers.username);
+            console.log(answers.password);
+            console.log(answers.token);
+            console.log(answers.pageName);
+        }
+
+        sfSetup.defineUserName((typeof jsForceConfig === 'undefined') ? '' + answers.username + '' : '' + jsForceConfig.username + '' );
+        sfSetup.definePassword((typeof jsForceConfig === 'undefined') ? '' + answers.password + '' : '' + jsForceConfig.password + '');
+        sfSetup.defineToken((typeof jsForceConfig === 'undefined') ? '' + answers.token + '' : '' + jsForceConfig.token + '');
+        if(answers.salesforce !== false){
+            sfSetup.setupPageAndResource('' + answers.pageName + '');
+        }
+
+
+        return gulp.src(files,{base:__dirname + '/templates' })
+        .pipe(data(function (answers) {
+            return { pageName: answers.pageName };
+        }))
+        .pipe(template(answers))
+        .pipe(rename(function (file) { if (file.basename[0] === '_') { file.basename = '.' + file.basename.slice(1); }}))
+        .pipe(conflict(path.join(process.cwd(), answers.name)))
+        .pipe(gulp.dest(path.join(process.cwd(), answers.name)))
+        .pipe(install())
+        .on('finish', function () {
+            done();
+        });
+    });
+});

pool/shard005/JavaScript/0032612_lazyLoader.js

@@ -0,0 +1,29 @@
+// getComponent is a function that returns a promise for a component
+// It will not be called until the first mount
+import React from 'react'
+
+function asyncComponent(getComponent) {
+  return class AsyncComponent extends React.Component {
+    static Component = null;
+    state = { Component: AsyncComponent.Component };
+
+    componentWillMount() {
+      if (!this.state.Component) {
+        getComponent().then(Component => {
+          AsyncComponent.Component = Component
+          this.setState({ Component })
+        })
+      }
+    }
+    render() {
+      const { Component } = this.state
+      if (Component) {
+        return <Component {...this.props} />
+      }
+      return null
+    }
+  }
+}
+
+
+export default asyncComponent

pool/shard005/JavaScript/0032613_ddxapi.js

@@ -0,0 +1,65 @@
+DDXApi = {
+    _timerId: null,
+    _notify: false,
+    startPoll: function() {
+
+        if (DDXApi._timerId === null) {
+
+            DDXApi._timerId = Meteor.setInterval(DDXApi.runPoll, 300000);
+        }
+    },
+    stopPoll : function() {
+        Meteor.clearInterval(DDXApi._timerId);
+        DDXApi._timerId = null;
+    },
+    runPoll : function() {
+        DDXApi._notify = true;
+        DDXApi.refreshActivityLog();
+    },
+    refreshActivityLog: function () {
+        Meteor.call('refreshActivityLog', function (error, logData) {
+            if (logData && logData.items) {
+
+                for (var i = logData.items.length, c = 0; c < i; ++c) {
+
+                    var count = Log.find({
+                        id: logData.items[c].id
+                    }).count();
+
+                    if (count === 0) {
+
+                        Log.insert(
+                            {
+                                id: logData.items[c].id,
+                                created: logData.items[c].created,
+                                type: logData.items[c].type,
+                                data: logData.items[c].data,
+                                target_type: logData.items[c].target_type,
+                                target_id: logData.items[c].target_id,
+                                target_parent: logData.items[c].target_parent,
+                                target_parent_role: logData.items[c].target_role,
+                                originator_id: logData.items[c].originator_id,
+                                originator_role: logData.items[c].originator_role
+                            }
+                        );
+                    }
+                }
+            }
+        });
+
+    },
+    spawnNotification: function(title, body) {
+
+        var notification = window.Notification || window.mozNotification || window.webkitNotification;
+
+        if (DDXApi._notify && 'undefined' !== typeof notification && notification.permission === 'granted') {
+            new Notification(
+                title,
+                {
+                    body: body,
+                    icon: Meteor.absoluteUrl('icon.png')
+                }
+            );
+        }
+    }
+};

pool/shard005/JavaScript/0032615_gulpfile.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var chalk = require('chalk');
+
+console.log(chalk.green('\n---Gulp In Action---\n'));
+
+var gulp = require('gulp');
+var jshint = require('gulp-jshint');
+var concat = require('gulp-concat');
+var rename = require('gulp-rename');
+var uglify = require('gulp-uglify');
+var minify = require('gulp-minify');
+var less = require('gulp-less');
+
+gulp.task('less', function () {
+	gulp.src('../webapp*//**//*.less')
+		.pipe(less())
+		.pipe(gulp.dest('webapp'));
+});
+
+// TODO Order of scripts needs to be maintained
+
+gulp.task('minify_common', function(){
+	return gulp.src('../webapp/scripts/common/**/*.js')
+		.pipe(concat('common.js'))
+		.pipe(gulp.dest('../webapp/scripts/common'))
+		.pipe(rename('common.min.js'))
+		.pipe(uglify())
+		.pipe(gulp.dest('../webapp/scripts/common/'));
+});
+
+gulp.task('minify_lib', function(){
+	return gulp.src('../webapp/scripts/lib/**/*.js')
+		.pipe(concat('lib.js'))
+		.pipe(gulp.dest('../webapp/scripts/lib'))
+		.pipe(rename('lib.min.js'))
+		.pipe(uglify())
+		.pipe(gulp.dest('../webapp/scripts/lib/'));
+});
+
+gulp.task('lint', function() {
+	return gulp.src('webapp*//**//*.js')
+		.pipe(jshint())
+		.pipe(jshint.reporter('default'));
+});
+
+gulp.task('default', ['minify_common', 'minify_lib'], function() {
+	console.log(chalk.green('\n---The Gulp Task has run.---\n'));
+});

pool/shard005/JavaScript/0032618_StickyOnScrollUpHeader.js

@@ -0,0 +1,64 @@
+import React from 'react';
+import Header from './Header.js';
+import {throttle} from '../utils/Throttle.js';
+
+const SCROLL_HEADER_THROTTLE_TIME = 20;
+
+/**
+ * Header which is not sticky while scroll down but sticks
+ *  to the top when you are scrolling up
+ *
+ *  It's meant to wrap the header element.
+ *
+ * Note: It introduces a extra div but planning to remove that
+ */
+export default class StickyOnScrollUpHeader extends React.Component {
+
+  constructor(props) {
+    super(props);
+    this.state = {};
+    this.handleScroll = throttle(this.handleScroll.bind(this), SCROLL_HEADER_THROTTLE_TIME);
+    this.setHeader = this.setHeader.bind(this);
+  }
+
+  setHeader(header) {
+    this.header = header;
+  }
+
+  handleScroll() {
+    const headerHeight = this.header.clientHeight;
+    const currentScrollTop = window.pageYOffset || 0;
+    const direction = (currentScrollTop - this.state.scrollTop) > 0 ? 'DOWN': 'UP';
+    const isHeaderVisible = headerHeight > currentScrollTop;
+    this.setState({
+      direction: direction,
+      scrollTop: currentScrollTop,
+      isHeaderVisible: isHeaderVisible,
+      headerHeight: headerHeight
+    })
+  }
+
+  componentDidMount() {
+    window.addEventListener('scroll', this.handleScroll);
+    // Fire it once for initial setup
+    this.handleScroll();
+  }
+
+  componentWillUnmount() {
+    window.removeEventListener('scroll', this.handleScroll);
+  }
+
+  render() {
+    const {direction, isHeaderVisible, headerHeight} = this.state;
+    const isStickyClass = direction === 'UP' ? 'sticky-header' : '';
+    // Header should be moved up when it's not visible, so that it can be animated
+    const style = {
+      transform: `translateY(-${isHeaderVisible || direction === 'UP' ? '0': headerHeight}px)`
+    };
+    return (
+      <div ref={this.setHeader} style={style} className={`sticky-scrollup-header ${isStickyClass}`}>
+        <Header {...this.props}/>
+      </div>
+    );
+  }
+}

pool/shard005/JavaScript/0032619_custom_radio.js

@@ -0,0 +1,21 @@
+$vic(document).on('click', '#vic-mode-toggler .vic-mode', function(event) {
+
+    var mode = $vic(this).data('mode');
+    $vic('body').attr('role', mode);
+    var route = Routing.generate('victoire_core_switchMode', {'mode': mode, '_locale': locale});
+    $vic('#vic-mode-toggler .vic-mode').removeClass('vic-active');
+    $vic(this).addClass('vic-active');
+
+    loading(true);
+    $vic.ajax(
+        {
+            url: route,
+            context: document.body,
+            type: "GET",
+            error: function(jsonResponse) {
+                error('Woups. La panne !');
+            }
+        }
+    );
+    loading(false);
+});

pool/shard005/JavaScript/0032620_widget-htmlparser.js

@@ -0,0 +1,222 @@
+/*
+YUI 3.17.1 (build 0eb5a52)
+Copyright 2014 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+YUI.add('widget-htmlparser', function (Y, NAME) {
+
+/**
+ * Adds HTML Parser support to the base Widget class
+ *
+ * @module widget
+ * @submodule widget-htmlparser
+ * @for Widget
+ */
+
+var Widget = Y.Widget,
+    Node = Y.Node,
+    Lang = Y.Lang,
+
+    SRC_NODE = "srcNode",
+    CONTENT_BOX = "contentBox";
+
+/**
+ * Object hash, defining how attribute values are to be parsed from
+ * markup contained in the widget's content box. e.g.:
+ * <pre>
+ *   {
+ *       // Set single Node references using selector syntax
+ *       // (selector is run through node.one)
+ *       titleNode: "span.yui-title",
+ *       // Set NodeList references using selector syntax
+ *       // (array indicates selector is to be run through node.all)
+ *       listNodes: ["li.yui-item"],
+ *       // Set other attribute types, using a parse function.
+ *       // Context is set to the widget instance.
+ *       label: function(contentBox) {
+ *           return contentBox.one("span.title").get("innerHTML");
+ *       }
+ *   }
+ * </pre>
+ *
+ * @property HTML_PARSER
+ * @type Object
+ * @static
+ */
+Widget.HTML_PARSER = {};
+
+/**
+ * The build configuration for the Widget class.
+ * <p>
+ * Defines the static fields which need to be aggregated,
+ * when this class is used as the main class passed to
+ * the <a href="Base.html#method_build">Base.build</a> method.
+ * </p>
+ * @property _buildCfg
+ * @type Object
+ * @static
+ * @final
+ * @private
+ */
+Widget._buildCfg = {
+    aggregates : ["HTML_PARSER"]
+};
+
+/**
+ * The DOM node to parse for configuration values, passed to the Widget's HTML_PARSER definition
+ *
+ * @attribute srcNode
+ * @type String | Node
+ * @writeOnce
+ */
+Widget.ATTRS[SRC_NODE] = {
+    value: null,
+    setter: Node.one,
+    getter: "_getSrcNode",
+    writeOnce: true
+};
+
+Y.mix(Widget.prototype, {
+
+    /**
+     * @method _getSrcNode
+     * @protected
+     * @return {Node} The Node to apply HTML_PARSER to
+     */
+    _getSrcNode : function(val) {
+        return val || this.get(CONTENT_BOX);
+    },
+
+    /**
+     * Implement the BaseCore _preAddAttrs method hook, to add
+     * the srcNode and related attributes, so that HTML_PARSER
+     * (which relies on `this.get("srcNode")`) can merge in it's
+     * results before the rest of the attributes are added.
+     *
+     * @method _preAddAttrs
+     * @protected
+     *
+     * @param attrs {Object} The full hash of statically defined ATTRS
+     * attributes being added for this instance
+     *
+     * @param userVals {Object} The hash of user values passed to
+     * the constructor
+     *
+     * @param lazy {boolean} Whether or not to add the attributes lazily
+     */
+    _preAddAttrs : function(attrs, userVals, lazy) {
+
+        var preAttrs = {
+            id : attrs.id,
+            boundingBox : attrs.boundingBox,
+            contentBox : attrs.contentBox,
+            srcNode : attrs.srcNode
+        };
+
+        this.addAttrs(preAttrs, userVals, lazy);
+
+        delete attrs.boundingBox;
+        delete attrs.contentBox;
+        delete attrs.srcNode;
+        delete attrs.id;
+
+        if (this._applyParser) {
+            this._applyParser(userVals);
+        }
+    },
+
+    /**
+     * @method _applyParsedConfig
+     * @protected
+     * @return {Object} The merged configuration literal
+     */
+    _applyParsedConfig : function(node, cfg, parsedCfg) {
+        return (parsedCfg) ? Y.mix(cfg, parsedCfg, false) : cfg;
+    },
+
+    /**
+     * Utility method used to apply the <code>HTML_PARSER</code> configuration for the
+     * instance, to retrieve config data values.
+     *
+     * @method _applyParser
+     * @protected
+     * @param config {Object} User configuration object (will be populated with values from Node)
+     */
+    _applyParser : function(config) {
+
+        var widget = this,
+            srcNode = this._getNodeToParse(),
+            schema = widget._getHtmlParser(),
+            parsedConfig,
+            val;
+
+        if (schema && srcNode) {
+            Y.Object.each(schema, function(v, k, o) {
+                val = null;
+
+                if (Lang.isFunction(v)) {
+                    val = v.call(widget, srcNode);
+                } else {
+                    if (Lang.isArray(v)) {
+                        val = srcNode.all(v[0]);
+                        if (val.isEmpty()) {
+                            val = null;
+                        }
+                    } else {
+                        val = srcNode.one(v);
+                    }
+                }
+
+                if (val !== null && val !== undefined) {
+                    parsedConfig = parsedConfig || {};
+                    parsedConfig[k] = val;
+                }
+            });
+        }
+        config = widget._applyParsedConfig(srcNode, config, parsedConfig);
+    },
+
+    /**
+     * Determines whether we have a node reference which we should try and parse.
+     *
+     * The current implementation does not parse nodes generated from CONTENT_TEMPLATE,
+     * only explicitly set srcNode, or contentBox attributes.
+     *
+     * @method _getNodeToParse
+     * @return {Node} The node reference to apply HTML_PARSER to.
+     * @private
+     */
+    _getNodeToParse : function() {
+        var srcNode = this.get("srcNode");
+        return (!this._cbFromTemplate) ? srcNode : null;
+    },
+
+    /**
+     * Gets the HTML_PARSER definition for this instance, by merging HTML_PARSER
+     * definitions across the class hierarchy.
+     *
+     * @private
+     * @method _getHtmlParser
+     * @return {Object} HTML_PARSER definition for this instance
+     */
+    _getHtmlParser : function() {
+        // Removed caching for kweight. This is a private method
+        // and only called once so don't need to cache HTML_PARSER
+        var classes = this._getClasses(),
+            parser = {},
+            i, p;
+
+        for (i = classes.length - 1; i >= 0; i--) {
+            p = classes[i].HTML_PARSER;
+            if (p) {
+                Y.mix(parser, p, true);
+            }
+        }
+        return parser;
+    }
+});
+
+
+}, '3.17.1', {"requires": ["widget-base"]});

pool/shard005/JavaScript/0032623_test.js

@@ -0,0 +1,66 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2012, Red Hat, Inc., and individual contributors
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * 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.
+ */
+/*
+Unit tests that cover basic functionality of app.js.
+ */
+
+module('Member Row Construction');
+
+test('Build 2 Member Rows', function() {
+    expect(1);
+
+    var members = [{"email": "jane.doe@company.com", "id": 1, "name": "Jane Doe", "phoneNumber": "12312312311"},{"email": "john.doe@company.com", "id": 0, "name": "John Doe", "phoneNumber": "2125551212"}];
+
+    var html = buildMemberRows(members);
+
+    ok($(html).length == 2, 'Number of rows built: ' + length);
+});
+
+test('Build 0 member Rows', function() {
+    expect(1);
+
+    var members = [];
+
+    var html = buildMemberRows(members);
+
+    ok($(html).length == 0, 'Created no rows for empty members');
+});
+
+module('Member Restful Calls');
+
+asyncTest('Request current member list', function() {
+    expect(1);
+
+    $.ajax({
+        // replace this with externally available IP - should be propagated by Arquillian
+        url: "http://" + window.location.host + "/arquillian-browsers-scenario/rest/members",
+        dataType: "jsonp",
+        jsonp: "jsonpcallback",
+        success: function(data) {
+            ok($(data).length, "Initial member returned");
+            start();
+        }
+    });
+});
+
+test('Register a new member', function() {
+    ok(1==1,"TODO");
+});
+
+test('Register a member with a duplicate email', function() {
+    ok(1==1,"TODO");
+});

pool/shard005/JavaScript/0032624_DistanceOpacityMaterial.js

@@ -0,0 +1,158 @@
+/**
+ * A Material which sets opacity according to the distance to the camera. 
+ * Close parts will be transparent, so you could watch inside a building, while the walls in the back are still opaque.
+ * 
+ * @namespace GIScene
+ * @class DistanceOpacityMaterial
+ * @constructor
+ * @param {Number} near distance from where opacity begins
+ * @param {Number} far  distance from where opacity will be 1.0
+ *  
+ */
+
+GIScene.DistanceOpacityMaterial = function(near,far) {
+	var near = near || 15.0;
+	var far  = far  || 30.0;
+	
+	var parameters = {
+				transparent:true,
+				lights: true,
+				side:2,
+				uniforms: THREE.UniformsUtils.merge( [
+		
+					THREE.UniformsLib[ "common" ],
+					THREE.UniformsLib[ "fog" ],
+					THREE.UniformsLib[ "lights" ],
+					THREE.UniformsLib[ "shadowmap" ],
+		
+					{
+						"ambient"  : { type: "c", value: new THREE.Color( 0xaaaaaa ) },
+						"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
+						"wrapRGB"  : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) },
+					
+						"mNear": { type: "f", value: near },
+						"mFar" : { type: "f", value: far }
+					}
+		
+				] ),
+		
+				vertexShader: [
+		
+					"#define LAMBERT",
+		
+					"varying vec3 vLightFront;",
+		
+					"#ifdef DOUBLE_SIDED",
+		
+						"varying vec3 vLightBack;",
+		
+					"#endif",
+		
+					THREE.ShaderChunk[ "map_pars_vertex" ],
+					THREE.ShaderChunk[ "lightmap_pars_vertex" ],
+					THREE.ShaderChunk[ "envmap_pars_vertex" ],
+					THREE.ShaderChunk[ "lights_lambert_pars_vertex" ],
+					THREE.ShaderChunk[ "color_pars_vertex" ],
+					THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
+					THREE.ShaderChunk[ "skinning_pars_vertex" ],
+					THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
+		
+					"void main() {",
+		
+						THREE.ShaderChunk[ "map_vertex" ],
+						THREE.ShaderChunk[ "lightmap_vertex" ],
+						THREE.ShaderChunk[ "color_vertex" ],
+		
+						THREE.ShaderChunk[ "morphnormal_vertex" ],
+						THREE.ShaderChunk[ "skinbase_vertex" ],
+						THREE.ShaderChunk[ "skinnormal_vertex" ],
+						THREE.ShaderChunk[ "defaultnormal_vertex" ],
+		
+						THREE.ShaderChunk[ "morphtarget_vertex" ],
+						THREE.ShaderChunk[ "skinning_vertex" ],
+						THREE.ShaderChunk[ "default_vertex" ],
+		
+						THREE.ShaderChunk[ "worldpos_vertex" ],
+						THREE.ShaderChunk[ "envmap_vertex" ],
+						THREE.ShaderChunk[ "lights_lambert_vertex" ],
+						THREE.ShaderChunk[ "shadowmap_vertex" ],
+		
+					"}"
+		
+				].join("\n"),
+		
+				fragmentShader: [
+					//mca
+					"uniform float mNear;",
+					"uniform float mFar;",
+					
+					
+					"uniform float opacity;",
+		
+					"varying vec3 vLightFront;",
+		
+					"#ifdef DOUBLE_SIDED",
+		
+						"varying vec3 vLightBack;",
+		
+					"#endif",
+		
+					THREE.ShaderChunk[ "color_pars_fragment" ],
+					THREE.ShaderChunk[ "map_pars_fragment" ],
+					THREE.ShaderChunk[ "lightmap_pars_fragment" ],
+					THREE.ShaderChunk[ "envmap_pars_fragment" ],
+					THREE.ShaderChunk[ "fog_pars_fragment" ],
+					THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
+					THREE.ShaderChunk[ "specularmap_pars_fragment" ],
+		
+					"void main() {",
+					
+						
+						
+						
+						"gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
+		
+						THREE.ShaderChunk[ "map_fragment" ],
+						THREE.ShaderChunk[ "alphatest_fragment" ],
+						THREE.ShaderChunk[ "specularmap_fragment" ],
+		
+						"#ifdef DOUBLE_SIDED",
+		
+							//"float isFront = float( gl_FrontFacing );",
+							//"gl_FragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;",
+		
+							"if ( gl_FrontFacing )",
+								"gl_FragColor.xyz *= vLightFront;",
+							"else",
+								"gl_FragColor.xyz *= vLightBack;",
+		
+						"#else",
+		
+							"gl_FragColor.xyz *= vLightFront;",
+		
+						"#endif",
+		
+						THREE.ShaderChunk[ "lightmap_fragment" ],
+						THREE.ShaderChunk[ "color_fragment" ],
+						THREE.ShaderChunk[ "envmap_fragment" ],
+						THREE.ShaderChunk[ "shadowmap_fragment" ],
+		
+						THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
+		
+						THREE.ShaderChunk[ "fog_fragment" ],
+						
+						//mca
+						"float depth_ = gl_FragCoord.z / gl_FragCoord.w;",
+						"float distOpacity = smoothstep( mNear, mFar, depth_ );",
+						"gl_FragColor = vec4( gl_FragColor.rgb, distOpacity );",
+						"if (distOpacity < 0.01) discard;", //depthBuffer will not be written
+					"}"
+		
+				].join("\n")
+		
+			};
+	
+	THREE.ShaderMaterial.call(this, parameters);
+};
+
+GIScene.DistanceOpacityMaterial.prototype = Object.create( THREE.ShaderMaterial.prototype );

pool/shard005/JavaScript/0032626_normalize-pk-value.js

@@ -0,0 +1,163 @@
+/**
+ * Module dependencies
+ */
+
+var util = require('util');
+var _ = require('@sailshq/lodash');
+var flaverr = require('flaverr');
+var isSafeNaturalNumber = require('./is-safe-natural-number');
+
+
+/**
+ * normalizePkValue()
+ *
+ * Validate and normalize the provided pk value.
+ *
+ * > This ensures the provided pk value is a string or a number.
+ * > • If a string, it also validates that it is not the empty string ("").
+ * > • If a number, it also validates that it is a base-10, non-zero, positive integer
+ * >   that is not larger than the maximum safe integer representable by JavaScript.
+ * >   Also, if we are expecting numbers, numeric strings are tolerated, so long as they
+ * >   can be parsed as valid numeric pk values.
+ *
+ * ------------------------------------------------------------------------------------------
+ * @param  {String|Number} pkValue
+ * @param  {String} expectedPkType   [either "number" or "string"]
+ * ------------------------------------------------------------------------------------------
+ * @returns {String|Number}
+ *          A valid primary key value, guaranteed to match the specified `expectedPkType`.
+ * ------------------------------------------------------------------------------------------
+ * @throws {Error} if invalid
+ *         @property {String} code (=== "E_INVALID_PK_VALUE")
+ * ------------------------------------------------------------------------------------------
+ * @throws {Error} If anything unexpected happens, e.g. bad usage, or a failed assertion.
+ * ------------------------------------------------------------------------------------------
+ */
+
+module.exports = function normalizePkValue (pkValue, expectedPkType){
+
+  // Check usage
+  if (expectedPkType !== 'string' && expectedPkType !== 'number') {
+    throw new Error('Consistency violation: The internal normalizePkValue() utility must always be called with a valid second argument ("string" or "number").  But instead, got: '+util.inspect(expectedPkType, {depth:5})+'');
+  }
+
+
+  // If explicitly expecting strings...
+  if (expectedPkType === 'string') {
+    if (!_.isString(pkValue)) {
+      // > Note that we DO NOT tolerate non-strings being passed in, even though it
+      // > would be possible to cast them into strings automatically.  While this would
+      // > be useful for key/value adapters like Redis, or in SQL databases when using
+      // > a string primary key, it can lead to bugs when querying against a database
+      // > like MongoDB that uses special hex or uuid strings.
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Instead of a string (the expected pk type), the provided value is: '+util.inspect(pkValue,{depth:5})+''));
+    }//-•
+
+    // Empty string ("") is never a valid primary key value.
+    if (pkValue === '') {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use empty string ('+util.inspect(pkValue,{depth:5})+') as a primary key value.'));
+    }//-•
+
+  }//‡
+  // Else if explicitly expecting numbers...
+  else if (expectedPkType === 'number') {
+    if (!_.isNumber(pkValue)) {
+
+      // If this is not even a _string_ either, then reject it.
+      // (Note that we handle this case separately in order to support a more helpful error message.)
+      if (!_.isString(pkValue)) {
+        throw flaverr('E_INVALID_PK_VALUE', new Error(
+          'Instead of a number (the expected pk type), got: '+util.inspect(pkValue,{depth:5})+''
+        ));
+      }//-•
+
+
+
+      // Tolerate strings that _look_ like base-10, non-zero, positive integers;
+      // and that wouldn't be too big to be a safe JavaScript number.
+      // (Cast them into numbers automatically.)
+
+      var GOT_STRING_FOR_NUMERIC_PK_SUFFIX =
+      'To resolve this error, pass in a valid base-10, non-zero, positive integer instead.  '+
+      '(Or if you must use strings, then change the relevant model\'s pk attribute from '+
+      '`type: \'number\'` to `type: \'string\'`.)';
+
+      var canPrblyCoerceIntoValidNumber = _.isString(pkValue) && pkValue.match(/^[0-9]+$/);
+      if (!canPrblyCoerceIntoValidNumber) {
+        throw flaverr('E_INVALID_PK_VALUE', new Error(
+          'Instead of a number, the provided value (`'+util.inspect(pkValue,{depth:5})+'`) is a string, '+
+          'and it cannot be coerced into a valid primary key value automatically (contains characters other '+
+          'than numerals 0-9).  '+
+          GOT_STRING_FOR_NUMERIC_PK_SUFFIX
+        ));
+      }//-•
+
+      var coercedNumber = +pkValue;
+      if (coercedNumber > (Number.MAX_SAFE_INTEGER||9007199254740991)) {
+        throw flaverr('E_INVALID_PK_VALUE', new Error(
+          'Instead of a valid number, the provided value (`'+util.inspect(pkValue,{depth:5})+'`) is '+
+          'a string that looks like a number.  But it cannot be coerced automatically because, despite '+
+          'its "numbery" appearance, it\'s just too big!  '+
+          GOT_STRING_FOR_NUMERIC_PK_SUFFIX
+        ));
+      }//-•
+
+      pkValue = coercedNumber;
+
+    }//>-•  </ if !_.isNumber(pkValue) >
+
+
+    //-•
+    // IWMIH, then we know that `pkValue` is now a number.
+    // (But it might be something like `NaN` or `Infinity`!)
+    //
+    // `pkValue` should be provided as a safe, positive, non-zero, finite integer.
+    //
+    // > We do a few explicit checks below for better error messages, and then finally
+    // > do one last check as a catchall, at the very end.
+
+    // NaN is never valid as a primary key value.
+    if (_.isNaN(pkValue)) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use `NaN` as a primary key value.'));
+    }//-•
+
+    // Zero is never a valid primary key value.
+    if (pkValue === 0) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use zero ('+util.inspect(pkValue,{depth:5})+') as a primary key value.'));
+    }//-•
+
+    // A negative number is never a valid primary key value.
+    if (pkValue < 0) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use a negative number ('+util.inspect(pkValue,{depth:5})+') as a primary key value.'));
+    }//-•
+
+    // A floating point number is never a valid primary key value.
+    if (Math.floor(pkValue) !== pkValue) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use a floating point number ('+util.inspect(pkValue,{depth:5})+') as a primary key value.'));
+    }//-•
+
+    // Neither Infinity nor -Infinity are ever valid as primary key values.
+    if (Infinity === pkValue || -Infinity === pkValue) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use `Infinity` or `-Infinity` (`'+util.inspect(pkValue,{depth:5})+'`) as a primary key value.'));
+    }//-•
+
+    // Numbers greater than the maximum safe JavaScript integer are never valid as a primary key value.
+    // > Note that we check for `Infinity` above FIRST, before we do this comparison.  That's just so that
+    // > we can display a tastier error message.
+    if (pkValue > (Number.MAX_SAFE_INTEGER||9007199254740991)) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use the provided value (`'+util.inspect(pkValue,{depth:5})+'`), because it is too large to safely fit into a JavaScript integer (i.e. `> Number.MAX_SAFE_INTEGER`)'));
+    }//-•
+
+    // Now do one last check as a catch-all, w/ a generic error msg.
+    if (!isSafeNaturalNumber(pkValue)) {
+      throw flaverr('E_INVALID_PK_VALUE', new Error('Cannot use the provided value (`'+util.inspect(pkValue,{depth:5})+'`) as a primary key value -- it is not a "safe", natural number (see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).'));
+    }
+
+  } else { throw new Error('Consistency violation: Should not be possible to make it here in the code!  If you are seeing this error, there\'s a bug in Waterline!'); }
+  //>-•
+
+  // Return the normalized pk value.
+  return pkValue;
+
+};
+